ഇംഗ്ലീഷ് പദങ്ങളുമായി സംയോജിപ്പിക്കുക


വൈഷമ്യ നില ഹാർഡ്
പതിവായി ചോദിക്കുന്നു ആമസോൺ ഫേസ്ബുക്ക് മൈക്രോസോഫ്റ്റ് ഒറാക്കിൾ
സ്ട്രിംഗ്

“ഇംഗ്ലീഷ് പദങ്ങളിലേക്ക് സംയോജിപ്പിക്കൽ” എന്ന പ്രശ്‌നത്തിൽ, ഞങ്ങൾ ഒരു നെഗറ്റീവ് അല്ലാത്ത സംഖ്യയും ആ സംഖ്യയെ അതിന്റെ സംഖ്യാ പദങ്ങളാക്കി മാറ്റുന്നതിനുള്ള ചുമതലകളും നൽകിയിട്ടുണ്ട് അല്ലെങ്കിൽ ഒരു സംഖ്യ, ഏത് സംഖ്യയുടെ ഇൻപുട്ട് ലഭിക്കുന്നു, ഒപ്പം ആ സംഖ്യയെ ഒരു നമ്പറിൽ പ്രതിനിധീകരിക്കുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല. സ്ട്രിംഗ് ഫോം. ഒരു ഉദാഹരണം നോക്കാം, “765” എന്ന സംഖ്യയെ “എഴുനൂറ്റി അറുപത്തഞ്ചു” എന്ന് പ്രതിനിധീകരിക്കണം. അതിനാൽ ഒരു സംഖ്യയിലെ ഓരോ നിർദ്ദിഷ്ട സംഖ്യയും കൈകാര്യം ചെയ്യാൻ ഞങ്ങൾക്ക് കഴിയും.

ഉദാഹരണം

ഇൻപുട്ട്:

123

ഔട്ട്പുട്ട്:

നൂറ്റി ഇരുപത്തിമൂന്ന്

ഇൻപുട്ട്:

4517

ഔട്ട്പുട്ട്:

നാലായിരത്തി അഞ്ഞൂറ് പതിനേഴ്

ഏതെങ്കിലും സംഖ്യയെ അതിന്റെ സംഖ്യാ പദ രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ നിങ്ങൾ ഒരു പ്രോഗ്രാം എഴുതണം

അൽഗോരിതം

  1. ഒരു ലോംഗ് ഇന്റീജർ വേരിയബിൾ പ്രഖ്യാപിച്ച് ഇൻപുട്ട് നേടുക.
  2. ഒരു പ്രഖ്യാപിക്കുക ശ്രേണി ഒരിടത്ത്, എല്ലാം സമാരംഭിച്ച് അതിൽ വാക്കുകൾ സ്ഥാപിക്കുക, മറ്റൊരു നിര പതിനായിരങ്ങൾ സ്ഥാപിക്കുകയും കോഡിൽ എഴുതിയതുപോലെ പതിനായിരക്കണക്കിന് സ്ഥലങ്ങൾ ഉപയോഗിച്ച് ആരംഭിക്കുകയും ചെയ്യുക.
  3. ഫംഗ്ഷനിലേക്ക് അനുയോജ്യമായ സ്ട്രിംഗ് ഉപയോഗിച്ച് ആ സംഖ്യയുടെ ഡിവിഡന്റ് കൈമാറുക, അത് പദങ്ങളും പതിനായിരം വാക്കുകളും നേടുകയും ഒരു താൽക്കാലിക സ്ട്രിംഗിലേക്ക് ചേർക്കുകയും ചെയ്യും.
  4. ആ താൽക്കാലിക സ്‌ട്രിംഗ് നൽകുക.
  5. ഫംഗ്ഷന് ഒരെണ്ണത്തിൽ പ്രവർത്തിക്കാനും പത്ത് സ്ഥലങ്ങൾക്ക് ഒരു അറേയിൽ നിന്ന് അനുയോജ്യമായ വാക്കുകൾ നേടാനും സ്ട്രിംഗ് ഫലത്തിൽ സംഭരിക്കാനും കഴിയും.
  6. നമ്പറിനായി ഒരാളുടെ സ്ഥലത്ത് എത്തുന്നതുവരെ ഇത് സ്‌ട്രിംഗ് കൂട്ടിച്ചേർക്കും.
  7. ഒരു സ്‌ട്രിംഗായി പ്രതിനിധീകരിക്കുന്ന ഒരു സംഖ്യയുടെ output ട്ട്‌പുട്ട് നമുക്ക് ലഭിക്കും.

വിശദീകരണം

ഞങ്ങളുടെ പ്രധാന ആശയം പരമാവധി മൂല്യത്തിൽ നിന്ന് ആരംഭിക്കുക എന്നതാണ്. അതിനാൽ രണ്ട് അറേകൾ പ്രഖ്യാപിച്ചു, അതിൽ 20 ൽ താഴെയുള്ള എല്ലാ പദങ്ങളും സംഭരിക്കുന്നു. കൂടാതെ പത്തിൽ ഗുണിതങ്ങൾ സൂക്ഷിച്ചിരിക്കുന്ന എല്ലാ മൂല്യങ്ങളും 100 ൽ താഴെയുള്ള കോഡിൽ എഴുതിയിരിക്കുന്നതുപോലെ സംഭരിക്കുന്നു.

അതിനാൽ ഞങ്ങൾ ഒരു ഉദാഹരണത്തിലൂടെ ഇതിലൂടെ പോകും.

ഇൻപുട്ട് 56543 ആയി നൽകിയിരിക്കുന്നു

ഞങ്ങൾ ഇൻപുട്ട് എടുത്ത് അത് ഞങ്ങളുടെ ഫംഗ്ഷൻ getWords ലേക്ക് കൈമാറുന്നു, അവിടെ ഞങ്ങൾ സ്ട്രിംഗ് ഫലം പ്രഖ്യാപിക്കുകയും ലാഭവിഹിതം കൈമാറുകയും ചെയ്യും. അതിനാൽ ആദ്യം അത് 10000000 കൊണ്ട് ഹരിച്ചാൽ കടന്നുപോകാൻ പോകുന്നു, കൂടാതെ നമുക്ക് 0 ലാഭവിഹിതം സ്ട്രിംഗ് കോടിയുമായി 0 0 പാസായി ലഭിക്കും. ഇത് XNUMX പരിശോധിക്കുന്ന വേഡ്സ് ഫംഗ്ഷനിൽ വരുംth ഒന്നും കണ്ടെത്താത്തതും ഇപ്പോൾ ശൂന്യമായ ഒരു താൽക്കാലിക സ്‌ട്രിംഗ് ഉപയോഗിച്ച് മടങ്ങുന്നതുമായ പതിനായിരത്തിന്റെയും സ്ഥലത്തിന്റെയും സ്ഥലം.

ഇപ്പോൾ, അത് 100000 കൊണ്ട് മൊഡ്യൂളറും 100 ഉപയോഗിച്ച് മൊഡ്യൂളറും വിഭജിക്കുന്ന സംഖ്യ കടന്നുപോകാൻ പോകുന്നു, കൂടാതെ നമുക്ക് 0 ലാഭവിഹിതം 0. 0 സ്ട്രിംഗ് ലക്ഷത്തോടെ കടന്നുപോകുന്നു. ഇത് XNUMX പരിശോധിക്കുന്ന വേഡ്സ് ഫംഗ്ഷനിൽ വരും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

ഇംഗ്ലീഷ് പദങ്ങളിലേക്ക് സംയോജിപ്പിക്കുന്നതിനുള്ള സങ്കീർണ്ണ വിശകലനം

സമയ സങ്കീർണ്ണത

ലൂപ്പ് സ്ഥിരമായ സമയത്തേക്ക് പ്രവർത്തിക്കുന്നു അതിനാൽ സങ്കീർണ്ണത ഉണ്ടാകും O (1).

സഹായ സ്ഥലം

സഹായ ഇടം O (1) അധിക ഇടം ആവശ്യമില്ലാത്തതിനാൽ.