अंग्रेजी शब्दों का पूर्णांक


कठिनाई स्तर कठिन
में अक्सर पूछा वीरांगना Facebook माइक्रोसॉफ्ट ओरेकल
तार

समस्या में "अंग्रेजी शब्दों का पूर्णांक" हमने एक गैर-नकारात्मक पूर्णांक और कार्यों को उस पूर्णांक को उसके संख्यात्मक शब्दों में बदलने के लिए दिया है या हमें एक संख्या, किसी भी संख्या का इनपुट मिलता है, और हमारा कार्य उस संख्या का प्रतिनिधित्व करना है स्ट्रिंग प्रपत्र। आइए एक उदाहरण देखें, संख्या "765" को "सात सौ पैंसठ" के रूप में दर्शाया जाना चाहिए। तो हम हर विशिष्ट संख्या के साथ एक नंबर में सौदा करते हैं।

उदाहरण

इनपुट:

123

आउटपुट:

एक सौ तेईस

इनपुट:

4517

आउटपुट:

चार हजार पांच सौ सत्रह

आपको किसी भी पूर्णांक को उसके संख्यात्मक शब्द रूप में बदलने के लिए एक कार्यक्रम लिखना होगा

कलन विधि

  1. एक लंबे इंटेगर चर की घोषणा करें और इनपुट प्राप्त करें।
  2. डिक्लेयर ए सरणी एक जगह के लिए और सभी लोगों को शुरू में यह शब्द जगह है, और दसियों जगह के लिए एक और सरणी और स्थानों के दसियों शब्दों के साथ initialize के रूप में कोड में लिखा है।
  3. फ़ंक्शन के लिए एक उपयुक्त स्ट्रिंग के साथ उस संख्या के लाभांश को पास करें जो लोगों और दसियों शब्दों को प्राप्त कर सकता है और इसे एक अस्थायी स्ट्रिंग में जोड़ सकता है।
  4. उस अस्थायी स्ट्रिंग को वापस करें।
  5. फ़ंक्शन लोगों पर काम कर सकता है और दसियों स्थान इसके लिए एक सरणी से उपयुक्त शब्द प्राप्त कर सकता है और इसे स्ट्रिंग परिणाम में संग्रहीत कर सकता है।
  6. और यह स्ट्रिंग को तब तक जोड़कर रखेगा जब तक कि वह नंबर के लिए किसी के स्थान पर न आ जाए।
  7. और हमें एक संख्या का आउटपुट मिलता है जो एक स्ट्रिंग के रूप में प्रतिनिधित्व करता है।

व्याख्या

हमारा मुख्य विचार अधिकतम मूल्य से शुरू करना है। इसलिए दो सरणियों की घोषणा की जिसमें एक सभी शब्दों को संग्रहीत करता है जो 20 से कम हो।

तो हम एक उदाहरण के साथ इस पर से गुजरेंगे।

इनपुट ५६०४३ के रूप में दिया गया है

हम इनपुट लेते हैं और इसे अपने फंक्शन गेटवर्क में पास करते हैं जहां हम स्ट्रिंग रिजल्ट घोषित करते हैं और हम डिविडेंड पास करने वाले हैं। इसलिए सबसे पहले यह पास होने वाला है जो संख्या को 10000000 से विभाजित करता है और हम स्ट्रिंग 0 के साथ 0. 0 पास के रूप में लाभांश प्राप्त करते हैं। यह वर्ड्स फंक्शन में आएगा जहां यह XNUMX को चेक करता हैth दसियों की जगह और जहाँ यह कुछ भी नहीं पाता है और अब एक खाली अस्थायी तार के साथ लौटता है।

तो अब, यह संख्या को पारित करने जा रहा है जो संख्या को १००००० से विभाजित करता है और १०० के साथ मॉड्यूलर होता है और हम ०.० के साथ लाभांश प्राप्त करते हैं। यह वर्ड्स फंक्शन में आएगा जहां यह 100000 को चेक करता हैth दसियों की जगह और यह कुछ भी नहीं पाते हैं और अब एक खाली अस्थायी तार के साथ लौटते हैं।

तो अब, यह संख्या पास करने जा रहा है, जो संख्या को 1000 से विभाजित करता है और 100 के साथ मॉड्यूलर होता है और हम 0, 56 के साथ स्ट्रिंग हजार के रूप में लाभांश प्राप्त करते हैं। यह वर्ड्स फंक्शन में आएगा, जहां यह 5 के रूप में डिविडेंड लेता है और 6 के रूप में शेष है, जबकि स्ट्रिंग पास हजार के रूप में है, इन सभी को अस्थायी स्ट्रिंग में संग्रहीत किया जाता है, जो कि "छप्पन हजार" है और यह परिणाम में वापस आता है।

अब, यह संख्या को पास करने जा रहा है जो संख्या को 100 से विभाजित करता है और 10 के साथ मॉड्यूलर होता है और हम 5 के रूप में लाभांश प्राप्त करते हैं। यह वर्ड्स फंक्शन में आएगा जहां यह 5 के रूप में लाभांश लेता है। और स्ट्रिंग के साथ 5 के रूप में रहता है, इसलिए एक सौ के रूप में पारित कर दिया जाता है ताकि सरणी में खोज करने और इसे अस्थायी स्ट्रिंग में जोड़ने के बाद "पचास छह हजार पांच सौ" बन जाएंगे।

अब अगर ब्लॉक की जाँच के बाद, यह “और” और अब फिर से प्रिंट करेगा। यह नंबर पास करने वाला है जो 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) के रूप में कोई अतिरिक्त स्थान की आवश्यकता है।