सवाल संख्या शब्दों को इंटीग्रर्स में बदलने का कोई तरीका है?


मुझे कन्वर्ट करने की ज़रूरत है one में 1, two में 2 और इसी तरह।

क्या पुस्तकालय या कक्षा या कुछ भी ऐसा करने का कोई तरीका है?


44
2018-01-29 20:07


मूल


यह भी देखें: stackoverflow.com/questions/70161/... - tzot
शायद यह सहायक होगा: pastebin.com/WwFCjYtt - alvas


जवाब:


इस कोड का अधिकांश हिस्सा numwords dict सेट अप करना है, जो केवल पहले कॉल पर किया जाता है।

def text2int(textnum, numwords={}):
    if not numwords:
      units = [
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
      ]

      tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

      scales = ["hundred", "thousand", "million", "billion", "trillion"]

      numwords["and"] = (1, 0)
      for idx, word in enumerate(units):    numwords[word] = (1, idx)
      for idx, word in enumerate(tens):     numwords[word] = (1, idx * 10)
      for idx, word in enumerate(scales):   numwords[word] = (10 ** (idx * 3 or 2), 0)

    current = result = 0
    for word in textnum.split():
        if word not in numwords:
          raise Exception("Illegal word: " + word)

        scale, increment = numwords[word]
        current = current * scale + increment
        if scale > 100:
            result += current
            current = 0

    return result + current

print text2int("seven billion one hundred million thirty one thousand three hundred thirty seven")
#7100031337

85
2018-01-29 22:32



किसी भी उपयोगकर्ता को फिर से क्लिक करने के लिए पुनर्जन्म के लिए टिकटिक? ;) - Bleeding Fingers
एफवाईआई, यह तिथियों के साथ काम नहीं करेगा। प्रयत्न: print text2int("nineteen ninety six") # 115 - Nick Ruiz
शब्दों में एक संख्या के रूप में 1 99 6 लिखने का सही तरीका "एक हजार नौ सौ नब्बे छः" है। यदि आप वर्षों का समर्थन करना चाहते हैं, तो आपको अलग-अलग कोड की आवश्यकता होगी। - recursive
वहां एक रूबी मणि मार्क बर्न्स द्वारा यह करता है। मैंने हाल ही में वर्षों से समर्थन जोड़ने के लिए इसे फोर्क किया है। आप कॅाल कर सकते हैं अजगर से रूबी कोड। - dimid
यह 'सौ और छः' प्रयास के लिए टूट जाता है। प्रिंट (text2int ("सौ और छः")) .. प्रिंट भी करें (text2int ("हजार")) - Harish Kayarohanam


कोड स्निपेट के लिए धन्यवाद ... मुझे बहुत समय बचाया!

मुझे कुछ अतिरिक्त पार्सिंग मामलों को संभालने की ज़रूरत थी, जैसे कि सामान्य शब्द ("पहला", "दूसरा"), हाइफेनेटेड शब्द ("एक सौ"), और हाइफेनेटेड सामान्य शब्द ("पचास-सातवां"), इसलिए मैंने जोड़ा कुछ पंक्तियां:

def text2int(textnum, numwords={}):
    if not numwords:
        units = [
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
        ]

        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

        scales = ["hundred", "thousand", "million", "billion", "trillion"]

        numwords["and"] = (1, 0)
        for idx, word in enumerate(units):  numwords[word] = (1, idx)
        for idx, word in enumerate(tens):       numwords[word] = (1, idx * 10)
        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)

    ordinal_words = {'first':1, 'second':2, 'third':3, 'fifth':5, 'eighth':8, 'ninth':9, 'twelfth':12}
    ordinal_endings = [('ieth', 'y'), ('th', '')]

    textnum = textnum.replace('-', ' ')

    current = result = 0
    for word in textnum.split():
        if word in ordinal_words:
            scale, increment = (1, ordinal_words[word])
        else:
            for ending, replacement in ordinal_endings:
                if word.endswith(ending):
                    word = "%s%s" % (word[:-len(ending)], replacement)

            if word not in numwords:
                raise Exception("Illegal word: " + word)

            scale, increment = numwords[word]

         current = current * scale + increment
         if scale > 100:
            result += current
            current = 0

    return result + current`

7
2018-02-28 17:10



नोट: यह शून्य के लिए शून्य देता है hundredth, thousandth आदि का प्रयोग करें one hundredth लेना 100! - rohithpr


यदि कोई दिलचस्पी लेता है, तो मैंने एक ऐसे संस्करण को हैक किया जो बाकी स्ट्रिंग को बनाए रखता है (हालांकि इसमें बग हो सकती है, इसका परीक्षण नहीं किया गया है)।

def text2int (textnum, numwords={}):
    if not numwords:
        units = [
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
        ]

        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

        scales = ["hundred", "thousand", "million", "billion", "trillion"]

        numwords["and"] = (1, 0)
        for idx, word in enumerate(units):  numwords[word] = (1, idx)
        for idx, word in enumerate(tens):       numwords[word] = (1, idx * 10)
        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)

    ordinal_words = {'first':1, 'second':2, 'third':3, 'fifth':5, 'eighth':8, 'ninth':9, 'twelfth':12}
    ordinal_endings = [('ieth', 'y'), ('th', '')]

    textnum = textnum.replace('-', ' ')

    current = result = 0
    curstring = ""
    onnumber = False
    for word in textnum.split():
        if word in ordinal_words:
            scale, increment = (1, ordinal_words[word])
            current = current * scale + increment
            if scale > 100:
                result += current
                current = 0
            onnumber = True
        else:
            for ending, replacement in ordinal_endings:
                if word.endswith(ending):
                    word = "%s%s" % (word[:-len(ending)], replacement)

            if word not in numwords:
                if onnumber:
                    curstring += repr(result + current) + " "
                curstring += word + " "
                result = current = 0
                onnumber = False
            else:
                scale, increment = numwords[word]

                current = current * scale + increment
                if scale > 100:
                    result += current
                    current = 0
                onnumber = True

    if onnumber:
        curstring += repr(result + current)

    return curstring

उदाहरण:

 >>> text2int("I want fifty five hot dogs for two hundred dollars.")
 I want 55 hot dogs for 200 dollars.

यदि आपके पास "$ 200" है, तो समस्याएं हो सकती हैं। लेकिन, यह वास्तव में मोटा था।


7
2017-08-04 07:04





यहां मामूली मामला दृष्टिकोण है:

>>> number = {'one':1,
...           'two':2,
...           'three':3,}
>>> 
>>> number['two']
2

या आप कुछ ऐसा ढूंढ रहे हैं जो संभाल सकता है "बारह हजार, एक सौ सत्तर-दो"?


4
2018-01-29 20:25





यदि आपके पास पार्स करना सीमित संख्या है तो इसे आसानी से एक शब्दकोश में हार्डकोड किया जा सकता है।

थोड़ा अधिक जटिल मामलों के लिए, आप शायद अपेक्षाकृत सरल संख्या व्याकरण के आधार पर, स्वचालित रूप से इस शब्दकोश को उत्पन्न करना चाहते हैं। इस के साथ कुछ (निश्चित रूप से, सामान्यीकृत ...)

for i in range(10):
   myDict[30 + i] = "thirty-" + singleDigitsDict[i]

यदि आपको कुछ और व्यापक की आवश्यकता है, तो ऐसा लगता है कि आपको प्राकृतिक भाषा संसाधन उपकरण की आवश्यकता होगी। यह लेख एक अच्छा प्रारंभिक बिंदु हो सकता है।


3
2018-01-29 20:28





यह 1 उत्तर में कोड का सी # कार्यान्वयन है:

public static double ConvertTextToNumber(string text)
{
    string[] units = new string[] {
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
    };

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

    string[] scales = new string[] { "hundred", "thousand", "million", "billion", "trillion" };

    Dictionary<string, ScaleIncrementPair> numWord = new Dictionary<string, ScaleIncrementPair>();
    numWord.Add("and", new ScaleIncrementPair(1, 0));
    for (int i = 0; i < units.Length; i++)
    {
        numWord.Add(units[i], new ScaleIncrementPair(1, i));
    }

    for (int i = 1; i < tens.Length; i++)
    {
        numWord.Add(tens[i], new ScaleIncrementPair(1, i * 10));                
    }

    for (int i = 0; i < scales.Length; i++)
    {
        if(i == 0)
            numWord.Add(scales[i], new ScaleIncrementPair(100, 0));
        else
            numWord.Add(scales[i], new ScaleIncrementPair(Math.Pow(10, (i*3)), 0));
    }

    double current = 0;
    double result = 0;

    foreach (var word in text.Split(new char[] { ' ', '-', '—'}))
    {
        ScaleIncrementPair scaleIncrement = numWord[word];
        current = current * scaleIncrement.scale + scaleIncrement.increment;
        if (scaleIncrement.scale > 100)
        {
            result += current;
            current = 0;
        }
    }
    return result + current;
}


public struct ScaleIncrementPair
{
    public double scale;
    public int increment;
    public ScaleIncrementPair(double s, int i)
    {
        scale = s;
        increment = i;
    }
}

3
2018-04-23 14:21



यह वही है जो मुझे पसंद है - एक ही उत्तर को लागू करने के विभिन्न तरीकों पर विस्तार करने वाले उत्तरों को एक्सटेंशन देखना। चूंकि सवाल का पहले से ही उत्तर दिया गया था, इसलिए यह उस भाषा में लागू करने में कोई दिक्कत नहीं होगी जिसे पूछताछकर्ता ने निर्दिष्ट नहीं किया था। पर यह कर देता है कोड की कोशिश करने और लागू करने के लिए आने वाले लोगों की सहायता करें। इस समस्या के भविष्य के पाठकों की मदद के लिए, +1


मैंने अभी पीईपीआई को एक पायथन मॉड्यूल जारी किया है word2number सटीक उद्देश्य के लिए। https://github.com/akshaynagpal/w2n

इसका उपयोग करके स्थापित करें:

pip install word2number

सुनिश्चित करें कि आपका पीपी नवीनतम संस्करण में अपडेट किया गया है।

उपयोग:

from word2number import w2n

print w2n.word_to_num("two million three thousand nine hundred and eighty four")
2003984

3
2018-01-02 18:48



अपने पैकेज का प्रयास किया। तारों को संभालने का सुझाव देंगे: "1 million" या "1M"। w2n.word_to_num ("1 मिलियन") एक त्रुटि फेंकता है। - Ray
@ रे इसे आजमाने के लिए धन्यवाद। क्या आप कृपया एक मुद्दा उठा सकते हैं github.com/akshaynagpal/w2n/issues । यदि आप चाहें तो आप भी योगदान दे सकते हैं। अन्यथा, मैं निश्चित रूप से अगली रिलीज में इस मुद्दे को देखूंगा। एक बार फिर धन्यवाद! - akshaynagpal
इस पैकेज का उपयोग करने के खिलाफ सलाह: github.com/akshaynagpal/w2n/issues/7 - Robert Elwell
रॉबर्ट, ओपन सोर्स सॉफ्टवेयर सभी लोगों को सहयोगी रूप से सुधारने के बारे में है। मैं एक पुस्तकालय चाहता था, और देखा कि लोग भी एक चाहते थे। तो इसे बनाया। यह उत्पादन स्तर प्रणाली के लिए तैयार नहीं हो सकता है या पाठ्यपुस्तक buzzwords के अनुरूप हो सकता है। लेकिन, यह उद्देश्य के लिए काम करता है। साथ ही, यह बहुत अच्छा होगा अगर आप पीआर जमा कर सकें ताकि सभी उपयोगकर्ताओं के लिए इसे और बेहतर किया जा सके। - akshaynagpal


परिवर्तन किया गया ताकि टेक्स्ट 2int (स्केल) सही रूपांतरण वापस कर सके। उदाहरण के लिए, text2int ("सौ") => 100।

import re

numwords = {}


def text2int(textnum):

    if not numwords:

        units = [ "zero", "one", "two", "three", "four", "five", "six",
                "seven", "eight", "nine", "ten", "eleven", "twelve",
                "thirteen", "fourteen", "fifteen", "sixteen", "seventeen",
                "eighteen", "nineteen"]

        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", 
                "seventy", "eighty", "ninety"]

        scales = ["hundred", "thousand", "million", "billion", "trillion", 
                'quadrillion', 'quintillion', 'sexillion', 'septillion', 
                'octillion', 'nonillion', 'decillion' ]

        numwords["and"] = (1, 0)
        for idx, word in enumerate(units): numwords[word] = (1, idx)
        for idx, word in enumerate(tens): numwords[word] = (1, idx * 10)
        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)

    ordinal_words = {'first':1, 'second':2, 'third':3, 'fifth':5, 
            'eighth':8, 'ninth':9, 'twelfth':12}
    ordinal_endings = [('ieth', 'y'), ('th', '')]
    current = result = 0
    tokens = re.split(r"[\s-]+", textnum)
    for word in tokens:
        if word in ordinal_words:
            scale, increment = (1, ordinal_words[word])
        else:
            for ending, replacement in ordinal_endings:
                if word.endswith(ending):
                    word = "%s%s" % (word[:-len(ending)], replacement)

            if word not in numwords:
                raise Exception("Illegal word: " + word)

            scale, increment = numwords[word]

        if scale > 1:
            current = max(1, current)

        current = current * scale + increment
        if scale > 100:
            result += current
            current = 0

    return result + current

1
2018-04-21 18:37



मुझे लगता है कि 100 की सही अंग्रेजी वर्तनी "सौ सौ" है। - recursive
@recursive आप बिल्कुल सही हैं, लेकिन इस कोड का लाभ यह है कि यह "सौवां" (संभवतः यही है कि दावा हाइलाइट करने की कोशिश कर रहा था)। विवरण की ध्वनि से, अन्य समान कोड को "एक सौवां" की आवश्यकता होती है और यह हमेशा सामान्य रूप से उपयोग नहीं किया जाता है (उदाहरण के लिए "उसने सौदा करने के लिए सौवां आइटम चुना") - Neil


E_h के सी # कार्यान्वयन (ऊपर) के त्वरित और गंदे जावा पोर्ट। ध्यान दें कि दोनों डबल वापस आते हैं, int नहीं।

public class Text2Double {

    public double Text2Double(String text) {

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

        String[] tens = new String[]{"", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};

        String[] scales = new String[]{"hundred", "thousand", "million", "billion", "trillion"};

        Map<String, ScaleIncrementPair> numWord = new LinkedHashMap<>();
        numWord.put("and", new ScaleIncrementPair(1, 0));


        for (int i = 0; i < units.length; i++) {
            numWord.put(units[i], new ScaleIncrementPair(1, i));
        }

        for (int i = 1; i < tens.length; i++) {
            numWord.put(tens[i], new ScaleIncrementPair(1, i * 10));
        }

        for (int i = 0; i < scales.length; i++) {
            if (i == 0)
                numWord.put(scales[i], new ScaleIncrementPair(100, 0));
            else
                numWord.put(scales[i], new ScaleIncrementPair(Math.pow(10, (i * 3)), 0));
        }

        double current = 0;
        double result = 0;

        for(String word : text.split("[ -]"))
        {
            ScaleIncrementPair scaleIncrement = numWord.get(word);
            current = current * scaleIncrement.scale + scaleIncrement.increment;
            if (scaleIncrement.scale > 100) {
                result += current;
                current = 0;
            }
        }
        return result + current;
    }
}

public class ScaleIncrementPair
{
    public double scale;
    public int increment;

    public ScaleIncrementPair(double s, int i)
    {
        scale = s;
        increment = i;
    }
}

1
2018-01-30 14:06





एक त्वरित समाधान का उपयोग करना है inflect.py अनुवाद के लिए एक शब्दकोश उत्पन्न करने के लिए।

inflect.py में एक है number_to_words() फ़ंक्शन, जो एक नंबर चालू करेगा (उदा। 2) इसके शब्द प्रपत्र (उदा। 'two')। दुर्भाग्य से, इसके विपरीत (जो आपको अनुवाद शब्दकोश मार्ग से बचने की अनुमति देगा) की पेशकश नहीं की जाती है। वही, आप अनुवाद फ़ंक्शन बनाने के लिए उस फ़ंक्शन का उपयोग कर सकते हैं:

>>> import inflect
>>> p = inflect.engine()
>>> word_to_number_mapping = {}
>>>
>>> for i in range(1, 100):
...     word_form = p.number_to_words(i)  # 1 -> 'one'
...     word_to_number_mapping[word_form] = i
...
>>> print word_to_number_mapping['one']
1
>>> print word_to_number_mapping['eleven']
11
>>> print word_to_number_mapping['forty-three']
43

यदि आप कुछ समय देने के इच्छुक हैं, तो inflect.py की आंतरिक-कार्यप्रणाली की जांच करना संभव हो सकता है number_to_words() कार्य करने और गतिशील रूप से ऐसा करने के लिए अपना स्वयं का कोड बनाएं (मैंने ऐसा करने की कोशिश नहीं की है)।


0
2018-02-10 04:27





वहां एक रूबी मणि मार्क बर्न्स द्वारा यह करता है। मैंने हाल ही में वर्षों से समर्थन जोड़ने के लिए इसे फोर्क किया है। आप कॅाल कर सकते हैं अजगर से रूबी कोड

  require 'numbers_in_words'
  require 'numbers_in_words/duck_punch'

  nums = ["fifteen sixteen", "eighty five sixteen",  "nineteen ninety six",
          "one hundred and seventy nine", "thirteen hundred", "nine thousand two hundred and ninety seven"]
  nums.each {|n| p n; p n.in_numbers}

परिणाम:
"fifteen sixteen" 1516 "eighty five sixteen" 8516 "nineteen ninety six" 1996 "one hundred and seventy nine" 179 "thirteen hundred" 1300 "nine thousand two hundred and ninety seven" 9297


0
2018-03-05 20:27



रूबी से पाइथन या पायथन कोड से रूबी कोड को कॉल न करें। वे इतने करीब हैं कि इस तरह कुछ ऐसा बंद हो जाना चाहिए। - yekta
सहमत हैं, लेकिन जब तक यह पोर्ट नहीं किया जाता है, तब तक रूबी कोड को कॉल करना कुछ भी नहीं है। - dimid
यह बहुत जटिल नहीं है, @recursive के नीचे तर्क प्रदान किया गया है (कोड की कुछ पंक्तियों के साथ) जिसका उपयोग किया जा सकता है। - yekta
यह वास्तव में मुझे लगता है कि "पंद्रह सोलह" गलत है? - PascalVKooten
@yekta ठीक है, मुझे लगता है कि रिकर्सिव का जवाब SO SO के दायरे में अच्छा है। हालांकि, मणि परीक्षण और अन्य सुविधाओं के साथ एक पूरा पैकेज प्रदान करता है। किसी भी तरह, मुझे लगता है कि दोनों की जगह है। - dimid