ינטעגער צו ענגליש ווערטער


שוועריקייט לעוועל שווער
אָפט געבעטן אין אַמאַזאָן facebook מייקראָסאָפֿט אָראַקל
שטריקל

אין פּראָבלעם "ינטעגער צו ענגליש ווערטער" מיר האָבן געגעבן אַ ניט-נעגאַטיוו ינטאַדזשער און די טאַסקס צו קאָנווערט די ינטאַדזשער אין זיין נומעריקאַל ווערטער אָדער מיר באַקומען אַ אַרייַנשרייַב פון אַ נומער, קיין נומער, און אונדזער אַרבעט איז צו פאָרשטעלן דעם נומער אין אַ שטריקל פאָרעם. זאל ס זען איין בייַשפּיל, די נומער "765" זאָל זיין רעפּריזענטיד ווי "זיבן הונדערט פינף און זעכציק". אַזוי מיר האַנדלען מיט יעדער ספּעציפיש נומער אין אַ נומער.

בייַשפּיל

ינפּוט:

123

אָוטפּוט:

הונדערט דריי און צוואנציג

ינפּוט:

4517

אָוטפּוט:

פֿיר ט thousandזנט און פֿינף הונדערט זיבעצן

איר מוזן שרייַבן אַ פּראָגראַם צו קאָנווערט קיין ינטאַדזשער אין זיין נומעריקאַל וואָרט פאָרעם

אַלגאָריטהם

  1. דערקלערן אַ לאנג ינטעגער בייַטעוודיק און באַקומען די ינפּוט.
  2. דערקלערן אַן מענגע פֿאַר איין אָרט און יניטיאַליזירן אַלע יענע וואָס שטעלן ווערטער אין עס, און אן אנדער מענגע פֿאַר טענס שטעלן און ינישאַלייז מיט טענס פון ערטער ווערטער ווי געשריבן אין קאָד.
  3. פאָרן די דיווידענד פון די נומער מיט אַ פּאַסיק שטריקל צו די פונקציע וואָס קענען באַקומען די איין און טענס ווערטער און לייגן עס צו אַ צייַטווייַליק שטריקל.
  4. ווייַזן דעם צייַטווייַליק שטריקל.
  5. די פֿונקציע קענען אַרבעטן אויף אָנעס און טענס ערטער קענען באַקומען פּאַסיק ווערטער פֿאַר עס פֿון אַ מענגע און סטאָרד עס אין שטריקל רעזולטאַט.
  6. און עס וועט האַלטן אַפּפּענדינג די שטריקל ביז עס קומט צו זיין אָרט פֿאַר נומער.
  7. און מיר באַקומען די רעזולטאַט פון אַ נומער וואָס איז רעפּריזענטינג ווי אַ שטריקל.

דערקלערונג

אונדזער הויפּט געדאַנק איז צו אָנהייבן פֿון אַ מאַקסימום ווערט. אַזוי דערקלערט צוויי ערייז אין וואָס איינער סטאָרד אַלע די ווערטער וואָס זענען ווייניקער ווי 20. און איינער וואָס סטאָרז אַלע די וואַלועס אין וואָס אַלע די מאַלטאַפּאַלז פון צען זענען סטאָרד וואָס זענען ווייניקער ווי 100, ווי געשריבן אין קאָד.

אַזוי מיר וועלן גיין דורך דעם מיט אַ ביישפּיל.

ינפּוט איז געגעבן ווי 56543

מיר נעמען אַרייַנשרייַב און פאָרן עס צו אונדזער פונקציע געטוואָרדס, וווּ מיר דערקלערן די שטריקל רעזולטאַט און מיר וועלן פאָרן דיווידענד. אַזוי ערשטער עס וועט פאָרן וואָס דיוויידז די נומער דורך 10000000 און מיר באַקומען דיווידענד ווי 0. 0 פּאַסיז מיט שטריקל קראָרע. עס וועט זיין געפֿונען אין דער וואָרדס פונקציאָנירן ווו עס טשעקס די 0th אָרט פון טענס און אָנעס ווו עס געפינט גאָרנישט און איצט קערט מיט אַ ליידיק טעמפּ שטריקל.

איצט, עס וועט פאָרן די נומער וואָס דיוויידז די נומער דורך 100000 און מאַדזשאַלער מיט 100 און מיר באַקומען דיווידענד ווי 0. 0 פּאַסיז מיט שטריקל לאַך איצט. עס וועט זיין געפֿונען אין דער וואָרדס פונקציאָנירן ווו עס טשעקס די 0th אָרט פון טענס און אָנעס עס די געפֿינען גאָרנישט און איצט צוריקקומען מיט אַ ליידיק טעמפּ שטריקל.

איצט, עס וועט פאָרן די נומער וואָס דיוויד די נומער דורך 1000 און מאַדזשאַלער מיט 100 און מיר באַקומען דיווידענד ווי 0, 56 פּאַסיז איצט מיט שטריקל טויזנט. עס וועט קומען אין די וואָרדס פונקציע, ווו עס נעמט די דיווידענד ווי 5 און די רעשט ווי 6 מיט שטריקל פּאַסיז ווי טויזנט, די אַלע זענען סטאָרד אין אַ צייַטווייַליק שטריקל וואָס איז "XNUMX" און עס קערט אין די רעזולטאַט.

איצט עס וועט פאָרן די נומער וואָס דיוויידז די נומער דורך 100 און מאַדזשאַלער מיט 10 און מיר באַקומען דיווידענד ווי 5. 5 גייט איצט דורך די שטריקל הונדערט. עס וועט קומען אין דער וואָרדס פונקציע ווו עס נעמט די דיווידענד ווי 5. און די רוען ווי 0 מיט די שטריקל דורכגעגאנגען ווי אַ הונדערט, אַזוי נאָך זוכן אין די מענגע און לייגן עס אין די צייַטווייַליק שטריקל וועט ווערן "XNUMX און פינף הונדערט".

איצט נאָך קאָנטראָלירונג אויב בלאָק, עס וועט דרוקן "און" און איצט ווידער. עס וועט פאָרן די נומער וואָס איז מאַדזשאַלער מיט 100 און פּאַסיז 43. און מיר באַקומען דיווידענד ווי 4 און די רעשט ווי 3 וואָס איז סטאָרד אין די צייַטווייַליק שטריקל. נאָך דערוויסן די ווערטער פֿאַר אַ געגעבן נומער און טעמפּעראַטור צוריק צו אַ רעזולטאַט.

און איצט דער רעזולטאַט וועט ווערן "XNUMX און דריי און פערציק".

ימפּלעמענטאַטיאָן

C ++ פּראָגראַם פֿאַר ינטעגער צו ענגליש ווערטער

#include <iostream>
using namespace std;

string ones_place[] = { "", "one ", "two ", "three ", "four ",
                        "five ", "six ", "seven ", "eight ",
                        "nine ", "ten ", "eleven ", "twelve ",
                        "thirteen ", "fourteen ", "fifteen ",
                        "sixteen ", "seventeen ", "eighteen ",
                        "nineteen "
                      };

string tens_place[] = { "", "", "twenty ", "thirty ", "forty ",
                        "fifty ", "sixty ", "seventy ", "eighty ",
                        "ninety "
                      };

string Words(int num, string s)
{
    string temp = "";
    if (num > 19)
    {
        temp += tens_place[num / 10] + ones_place[num % 10];
    }
    else
    {
        temp += ones_place[num];
    }
    if (num)
    {
        temp += s;
    }
    return temp;
}

string getWords(long number)
{
    string result;
    result += Words((number / 10000000), "crore ");

    result += Words(((number / 100000) % 100), "lakh ");

    result += Words(((number / 1000) % 100), "thousand ");

    result += Words(((number / 100) % 10), "hundred ");

    if (number> 100 && number % 100)
    {
        result += "and ";
    }
    result += Words((number % 100), "");

    return result;
}
int main()
{
    cout << getWords(4517) << endl;
    return 0;
}
four thousand five hundred and seventeen

Java פּראָגראַם פֿאַר ינטעגער צו ענגליש ווערטער

import java.text.DecimalFormat;

public class Integer_to_words {

  private static final String[] tens_names = {
    "", " ten", " twenty",
    " thirty", " forty", " fifty", " sixty", " seventy", " eighty",
    " ninety"
  };

  private static final String[] num_Names = {
    "", " one", " two", " three",
    " four", " five", " six", " seven", " eight", " nine", " ten",
    " eleven", " twelve", " thirteen", " fourteen", " fifteen",
    " sixteen", " seventeen", " eighteen", " nineteen"
  };

  private static String Upto_one_thousand(int number) {
    String soFar;

    if (number % 100<20) {
      soFar = num_Names[number % 100];
      number /= 100;
    } else {
      soFar = num_Names[number % 10];
      number /= 10;

      soFar = tens_names[number % 10] + soFar;
      number /= 10;
    }
    if (number == 0)
      return soFar;
    return num_Names[number] + " hundred" + soFar;
  }

  public static String convert(long number) {
    // 0 to 999 999 999 999
    if (number == 0) {
      return "zero";
    }

    String snumber = Long.toString(number);

    // pad with "0"
    String mask = "000000000000";
    DecimalFormat df = new DecimalFormat(mask);
    snumber = df.format(number);

    // XXXnnnnnnnnn
    int billions = Integer.parseInt(snumber.substring(0, 3));
    // nnnXXXnnnnnn
    int millions = Integer.parseInt(snumber.substring(3, 6));
    // nnnnnnXXXnnn
    int hundredThousands = Integer.parseInt(snumber.substring(6, 9));
    // nnnnnnnnnXXX
    int thousands = Integer.parseInt(snumber.substring(9, 12));

    String tradBillions;
    switch (billions) {
      case 0:
        tradBillions = "";
        break;
      case 1:
        tradBillions = Upto_one_thousand(billions) + " billion ";
        break;
      default:
        tradBillions = Upto_one_thousand(billions) + " billion ";
    }
    String result = tradBillions;

    String tradMillions;
    switch (millions) {
      case 0:
        tradMillions = "";
        break;
      case 1:
        tradMillions = Upto_one_thousand(millions) + " million ";
        break;
      default:
        tradMillions = Upto_one_thousand(millions) + " million ";
    }
    result = result + tradMillions;

    String tradHundredThousands;
    switch (hundredThousands) {
      case 0:
        tradHundredThousands = "";
        break;
      case 1:
        tradHundredThousands = "one thousand ";
        break;
      default:
        tradHundredThousands = Upto_one_thousand(hundredThousands) +
          " thousand ";
    }
    result = result + tradHundredThousands;

    String tradThousand;
    tradThousand = Upto_one_thousand(thousands);
    result = result + tradThousand;

    // remove extra spaces!
    return result.replaceAll("^\\s+", "").replaceAll("\\b\\s{2,}\\b", " ");
  }

  public static void main(String[] args) {
    System.out.println(convert(4517));
  }
}
four thousand five hundred seventeen

קאַמפּלעקסיטי אַנאַליסיס פֿאַר ינטעגער צו ענגליש ווערטער

צייט קאַמפּלעקסיטי

די שלייף ראַנז פֿאַר אַ קעסיידערדיק סומע פון ​​צייט אַזוי די קאַמפּלעקסיטי וועט זיין אָ (1).

אַגזיליערי ספעיס

די אַגזיליערי פּלאַץ איז אָ (1) ווי קיין עקסטרע פּלאַץ איז פארלאנגט.