ಇಂಗ್ಲಿಷ್ ಪದಗಳಿಗೆ ಪೂರ್ಣಾಂಕ


ತೊಂದರೆ ಮಟ್ಟ ಹಾರ್ಡ್
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ ಫೇಸ್ಬುಕ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಒರಾಕಲ್
ಸ್ಟ್ರಿಂಗ್

“ಇಂಗ್ಲಿಷ್ ಪದಗಳಿಗೆ ಪೂರ್ಣಾಂಕ” ಸಮಸ್ಯೆಯಲ್ಲಿ ನಾವು negative ಣಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕವನ್ನು ಮತ್ತು ಆ ಪೂರ್ಣಾಂಕವನ್ನು ಅದರ ಸಂಖ್ಯಾತ್ಮಕ ಪದಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ಕಾರ್ಯಗಳನ್ನು ನೀಡಿದ್ದೇವೆ ಅಥವಾ ನಾವು ಒಂದು ಸಂಖ್ಯೆ, ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಇನ್ಪುಟ್ ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ನಮ್ಮ ಕಾರ್ಯವನ್ನು ಆ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವುದು ಸ್ಟ್ರಿಂಗ್ ರೂಪ. ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ, “765” ಸಂಖ್ಯೆಯನ್ನು “ಏಳುನೂರ ಅರವತ್ತೈದು” ಎಂದು ಪ್ರತಿನಿಧಿಸಬೇಕು. ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಸಂಖ್ಯೆಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತೇವೆ.

ಉದಾಹರಣೆ

ಇನ್ಪುಟ್:

123

ಔಟ್ಪುಟ್:

ನೂರ ಇಪ್ಪತ್ಮೂರು

ಇನ್ಪುಟ್:

4517

ಔಟ್ಪುಟ್:

ನಾಲ್ಕು ಸಾವಿರದ ಐನೂರು ಹದಿನೇಳು

ಯಾವುದೇ ಪೂರ್ಣಾಂಕವನ್ನು ಅದರ ಸಂಖ್ಯಾತ್ಮಕ ಪದ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ನೀವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯಬೇಕಾಗಿದೆ

ಕ್ರಮಾವಳಿ

  1. ಲಾಂಗ್ ಇಂಟಿಜರ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಘೋಷಿಸಿ ಮತ್ತು ಇನ್ಪುಟ್ ಪಡೆಯಿರಿ.
  2. ಒಂದು ಘೋಷಿಸಿ ಸರಣಿ ಒಂದು ಸ್ಥಳಕ್ಕಾಗಿ ಮತ್ತು ಎಲ್ಲವನ್ನು ಪ್ರಾರಂಭಿಸಿ ಅದರಲ್ಲಿ ಪದಗಳನ್ನು ಇರಿಸಿ, ಮತ್ತು ಹತ್ತಾರು ಸ್ಥಳಗಳಿಗೆ ಮತ್ತೊಂದು ರಚನೆ ಮತ್ತು ಕೋಡ್‌ನಲ್ಲಿ ಬರೆದಂತೆ ಹತ್ತಾರು ಸ್ಥಳಗಳ ಪದಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ.
  3. ಆ ಸಂಖ್ಯೆಯ ಲಾಭಾಂಶವನ್ನು ಸೂಕ್ತವಾದ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಹಾದುಹೋಗಿರಿ ಮತ್ತು ಅದು ಪದಗಳನ್ನು ಮತ್ತು ಹತ್ತಾರು ಪದಗಳನ್ನು ಪಡೆಯಬಹುದು ಮತ್ತು ಅದನ್ನು ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಸೇರಿಸಬಹುದು.
  4. ಆ ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿ.
  5. ಕಾರ್ಯವು ಒಂದರ ಮೇಲೆ ಕೆಲಸ ಮಾಡಬಹುದು ಮತ್ತು ಹತ್ತಾರು ಸ್ಥಳಗಳು ಅದಕ್ಕೆ ಸೂಕ್ತವಾದ ಪದಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯಿಂದ ಪಡೆಯಬಹುದು ಮತ್ತು ಅದನ್ನು ಸ್ಟ್ರಿಂಗ್ ಫಲಿತಾಂಶದಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು.
  6. ಮತ್ತು ಅದು ಸಂಖ್ಯೆಗೆ ಒಬ್ಬರ ಸ್ಥಳಕ್ಕೆ ಬರುವವರೆಗೆ ಅದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸೇರಿಸುತ್ತಲೇ ಇರುತ್ತದೆ.
  7. ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ನಂತೆ ಪ್ರತಿನಿಧಿಸುವ ಸಂಖ್ಯೆಯ output ಟ್‌ಪುಟ್ ಅನ್ನು ನಾವು ಪಡೆಯುತ್ತೇವೆ.

ವಿವರಣೆ

ನಮ್ಮ ಮುಖ್ಯ ಆಲೋಚನೆ ಗರಿಷ್ಠ ಮೌಲ್ಯದಿಂದ ಪ್ರಾರಂಭಿಸುವುದು. ಆದ್ದರಿಂದ ಎರಡು ಸರಣಿಗಳನ್ನು ಘೋಷಿಸಲಾಗಿದೆ, ಇದರಲ್ಲಿ ಒಬ್ಬರು 20 ಕ್ಕಿಂತ ಕಡಿಮೆ ಇರುವ ಎಲ್ಲಾ ಪದಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತಾರೆ. ಮತ್ತು ಹತ್ತು ಮೌಲ್ಯಗಳ ಎಲ್ಲಾ ಗುಣಾಕಾರಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದ ಎಲ್ಲ ಮೌಲ್ಯಗಳನ್ನು 100 ಕ್ಕಿಂತ ಕಡಿಮೆ ಇರುವ ಕೋಡ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ.

ಆದ್ದರಿಂದ ನಾವು ಇದನ್ನು ಉದಾಹರಣೆಯೊಂದಿಗೆ ನೋಡುತ್ತೇವೆ.

ಇನ್ಪುಟ್ ಅನ್ನು 56543 ಎಂದು ನೀಡಲಾಗಿದೆ

ನಾವು ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ನಮ್ಮ ಕಾರ್ಯ ಗೆಟ್ ವರ್ಡ್ಸ್ ಗೆ ರವಾನಿಸುತ್ತೇವೆ, ಅಲ್ಲಿ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಫಲಿತಾಂಶವನ್ನು ಘೋಷಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಲಾಭಾಂಶವನ್ನು ರವಾನಿಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ ಮೊದಲು ಅದು 10000000 ರಿಂದ ಸಂಖ್ಯೆಯನ್ನು ಭಾಗಿಸುವ ಪಾಸ್ ಆಗಲಿದೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಕೋಟಿಯೊಂದಿಗೆ 0. 0 ರಂತೆ ಲಾಭಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಇದು 0 ಅನ್ನು ಪರಿಶೀಲಿಸುವ ವರ್ಡ್ಸ್ ಕಾರ್ಯದಲ್ಲಿ ಬರುತ್ತದೆth ಅದು ಏನನ್ನೂ ಕಂಡುಕೊಳ್ಳದ ಮತ್ತು ಈಗ ಖಾಲಿ ಟೆಂಪ್ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಹಿಂದಿರುಗುವ ಹತ್ತಾರು ಮತ್ತು ಸ್ಥಳಗಳ ಸ್ಥಳ.

ಈಗ, ಅದು ಸಂಖ್ಯೆಯನ್ನು 100000 ರಿಂದ ಭಾಗಿಸುವ ಸಂಖ್ಯೆಯನ್ನು ಮತ್ತು 100 ರೊಂದಿಗೆ ಮಾಡ್ಯುಲರ್ ಅನ್ನು ರವಾನಿಸಲಿದೆ ಮತ್ತು ನಾವು ಲಾಭಾಂಶವನ್ನು 0 ಎಂದು ಪಡೆಯುತ್ತೇವೆ. 0 ಈಗ ಸ್ಟ್ರಿಂಗ್ ಲಕ್ಷದೊಂದಿಗೆ ಹಾದುಹೋಗುತ್ತದೆ. ಇದು 0 ಅನ್ನು ಪರಿಶೀಲಿಸುವ ವರ್ಡ್ಸ್ ಕಾರ್ಯದಲ್ಲಿ ಬರುತ್ತದೆth ಹತ್ತಾರು ಮತ್ತು ಇತರರ ಸ್ಥಳವು ಏನನ್ನೂ ಕಂಡುಹಿಡಿಯುವುದಿಲ್ಲ ಮತ್ತು ಈಗ ಖಾಲಿ ಟೆಂಪ್ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಹಿಂತಿರುಗಿ.

ಈಗ, ಅದು ಸಂಖ್ಯೆಯನ್ನು 1000 ಮತ್ತು ಮಾಡ್ಯುಲರ್ ಅನ್ನು 100 ರಿಂದ ಭಾಗಿಸುವ ಸಂಖ್ಯೆಯನ್ನು ರವಾನಿಸಲಿದೆ ಮತ್ತು ನಾವು 0, 56 ರಂತೆ ಲಾಭಾಂಶವನ್ನು ಸ್ಟ್ರಿಂಗ್ ಸಾವಿರದೊಂದಿಗೆ ಪಡೆಯುತ್ತೇವೆ. ಇದು ವರ್ಡ್ಸ್ ಕಾರ್ಯದಲ್ಲಿ ಬರುತ್ತದೆ, ಅಲ್ಲಿ ಅದು ಲಾಭಾಂಶವನ್ನು 5 ಮತ್ತು ಉಳಿದ 6 ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಪಾಸ್ನೊಂದಿಗೆ ಸಾವಿರ ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಇವೆಲ್ಲವನ್ನೂ ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಅದು “ಐವತ್ತಾರು ಸಾವಿರ” ಮತ್ತು ಅದು ಫಲಿತಾಂಶದಲ್ಲಿ ಮರಳುತ್ತದೆ.

ಈಗ, ಅದು ಸಂಖ್ಯೆಯನ್ನು 100 ರಿಂದ ಭಾಗಿಸುವ ಸಂಖ್ಯೆಯನ್ನು ಮತ್ತು 10 ರೊಂದಿಗೆ ಮಾಡ್ಯುಲರ್ ಅನ್ನು ಹಾದುಹೋಗಲಿದೆ ಮತ್ತು ನಾವು 5 ರಂತೆ ಲಾಭಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ. 5 ಈಗ ಸ್ಟ್ರಿಂಗ್ ನೂರಿನೊಂದಿಗೆ ಹಾದುಹೋಗುತ್ತದೆ. ಇದು ವರ್ಡ್ಸ್ ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಬರುತ್ತದೆ, ಅಲ್ಲಿ ಅದು ಲಾಭಾಂಶವನ್ನು 5 ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ 0 ರಂತೆ ಉಳಿದಿರುವಂತೆ ನೂರು ರವಾನಿಸಲಾಗಿದೆ ಆದ್ದರಿಂದ ಶ್ರೇಣಿಯಲ್ಲಿ ಹುಡುಕಿದ ನಂತರ ಮತ್ತು ಅದನ್ನು ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಸೇರಿಸಿದ ನಂತರ “ಐವತ್ತಾರು ಸಾವಿರದ ಐನೂರು” ಆಗುತ್ತದೆ.

ಈಗ ಬ್ಲಾಕ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿದ ನಂತರ, ಅದು “ಮತ್ತು” ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಈಗ ಮತ್ತೆ. ಇದು 100 ರೊಂದಿಗೆ ಮಾಡ್ಯುಲರ್ ಮತ್ತು 43 ಅನ್ನು ಹಾದುಹೋಗುವ ಸಂಖ್ಯೆಯನ್ನು ರವಾನಿಸುತ್ತದೆ. ಮತ್ತು ನಾವು ಲಾಭಾಂಶವನ್ನು 4 ಮತ್ತು ಉಳಿದ 3 ಅನ್ನು ತಾತ್ಕಾಲಿಕ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ. ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಪದಗಳನ್ನು ಕಂಡುಕೊಂಡ ನಂತರ ಮತ್ತು ಫಲಿತಾಂಶಕ್ಕೆ ತಾತ್ಕಾಲಿಕವಾಗಿ ಹಿಂತಿರುಗಿ.

ಮತ್ತು ಈಗ ಫಲಿತಾಂಶವು “ಐವತ್ತಾರು ಸಾವಿರದ ಐನೂರ ನಲವತ್ತಮೂರು” ಆಗುತ್ತದೆ.

ಅನುಷ್ಠಾನ

ಇಂಗ್ಲಿಷ್ ಪದಗಳಿಗೆ ಇಂಟಿಜರ್ಗಾಗಿ ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#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

ಇಂಗ್ಲಿಷ್ ಪದಗಳಿಗೆ ಇಂಟಿಜರ್ಗಾಗಿ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

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) ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಸ್ಥಳದ ಅಗತ್ಯವಿಲ್ಲ.