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


21

इस कोड गोल्फ का लक्ष्य पूर्णांकों को अंग्रेजी शब्दों में बदलना है।

कार्यक्रम इनपुट के लिए संकेत देता है। यदि यह इनपुट पूर्णांक नहीं है, तो प्रिंट करें NaN। यदि यह पूर्णांक है, तो इसे अंग्रेजी शब्दों में रूपांतरित करें और इन शब्दों को प्रिंट करें। न्यूनतम इनपुट: 0 (शून्य)। अधिकतम इनपुट: 9000 (नौ हजार)।
तो, 5रिटर्न five(मामला कोई फर्क नहीं पड़ता), और 500रिटर्न five hundredया five-hundred(डैश कोई फर्क नहीं पड़ता)।

कुछ अन्य नियम:

एक oneसे पहले hundredया thousandवैकल्पिक है: one hundredसही है, लेकिन है hundredबहुत (यदि इनपुट है 100निश्चित रूप से)।

andउदाहरण के लिए शब्द one hundred and forty fiveवैकल्पिक भी है।

व्हाट्सएप मायने रखता है। तो, के लिए 500, five-hundredया five hundredसही है, लेकिन fivehundredनहीं है।

सौभाग्य!


यहाँ एक अनियंत्रित उत्तर दिया गया है rgagnon.com/javadetails/java-0426.html

एसओ में यह जवाब समान सामान है, लेकिन कोड-गोल्फ नहीं है।
ST3

जवाबों:


7

पर्ल 281 बाइट्स

print+0eq($_=<>)?Zero:"@{[((@0=($z,One,Two,Three,Four,Five,@2=(Six,Seven),
Eight,Nine,Ten,Eleven,Twelve,map$_.teen,Thir,Four,@1=(Fif,@2,Eigh,Nine)))
[$_/1e3],Thousand)x($_>999),($0[($_%=1e3)/100],Hundred)x($_>99),
($_%=100)>19?((Twen,Thir,For,@1)[$_/10-2].ty,$0[$_%10]):$0[$_]]}"||NaN

क्षैतिज पवित्रता के लिए नई कड़ियाँ जोड़ी गईं। उपरोक्त का उपयोग अंतःक्रियात्मक रूप से किया जा सकता है, या स्टिंग के माध्यम से इसका मूल्य पाइप करके।

श्रेणी [0, 19999] पर सभी पूर्णांक मानों के लिए सही ढंग से काम करता है , इस सीमा के बाहर के मान अपरिभाषित व्यवहार प्रदर्शित करते हैं। गैर-पूर्णांक मान शून्य की ओर छोटा हो जाएगा, और इस तरह, केवल वे मान जो गैर-संख्यात्मक हैं, रिपोर्ट करेंगे NaN

नमूना उपयोग:

for $n (14, 42, 762, 2000, 6012, 19791, 1e9, foobar, 17.2, -3) {
  print "$n: ", `echo $n | perl spoken-numbers.pl`, $/;
}

नमूना उत्पादन:

14: Fourteen
42: Forty Two
762: Seven Hundred Sixty Two
2000: Two Thousand 
6012: Six Thousand Twelve
19791: Nineteen Thousand Seven Hundred Ninety One
1000000000: Thousand 
foobar: NaN
17.2: Seventeen
-3: Nine Hundred Ninety Seven

"1000000000: हजार"? और 17.2 प्रिंट "NaN" नहीं होना चाहिए?
डेविड

5
@DavidCarraher "... इस श्रेणी के बाहर के मान अपरिभाषित व्यवहार प्रदर्शित करते हैं । गैर-पूर्णांक मान शून्य की ओर छोटा हो जाएगा, और इस तरह, केवल वे मान जो वास्तव में गैर-संख्यात्मक रिपोर्ट करेंगे NaN।"
प्रिमो

मैं पर्ल विशेषज्ञ नहीं हूं, इसलिए मैं यह सवाल पूछता हूं: क्या यह कार्यक्रम इनपुट के लिए संकेत देता है?
प्रोग्रामफॉक्स

@ProgramFOX मैंने स्टड से एक मान पढ़ने के लिए इसे अपडेट किया है (यदि अंतःक्रियात्मक रूप से चलाया जाए, तो यह उपयोगकर्ता को एक फ़ंक्शन के बजाय, मान के लिए संकेत देगा)।
प्रिमो

13

जावास्क्रिप्ट (375)

शायद एक भयानक प्रयास, लेकिन वैसे भी, यहाँ जाता है ...

alert(function N(s,z){return O="zero,one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,,fif,,,eigh,,,,twen,,for".split(","),(z?O[s]||O[s-10]||O[s-20]:s<13?N(s,1):s<20?N(s,1)+"teen":s<100?N(a=20+(s/10|0),1)+"ty"+(s%10?" "+N(s%10):""):s<1e3?N(s/100|0)+" hundred"+(s%100?" "+N(s%100):""):s<1e5?N(s/1e3|0)+" thousand"+(s%1e3?" "+N(s%1e3):""):0)||NaN}(prompt()))

सुंदर-मुद्रित (एक समारोह के रूप में):

function N(s,z) {
  return O = "zero,one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,,fif,,,eigh,,,,twen,,for".split(","),
      (z? O[s] || O[s-10] || O[s-20]
       : s < 13?  N(s,1)
       : s < 20?  N(s,1) + "teen"
       : s < 100? N(a=20+(s/10|0),1) + "ty" + (s%10?" "+N(s%10):"")
       : s < 1e3?  N(s/100|0) +  " hundred" + (s%100?" "+N(s%100):"")
       : s < 1e5?  N(s/1e3|0) + " thousand" + (s%1e3?" "+N(s%1e3):"") : 0) || NaN
}

नमूना रूपांतरण (ध्यान दें कि यह NaNसीमा से बाहर होने पर भी आउटपुट होता है, अर्थात अमान्य इनपुट):

540: five hundred forty
4711: four thousand seven hundred eleven
7382: seven thousand three hundred eighty two
1992: one thousand nine hundred ninety two
hutenosa: NaN
1000000000: NaN
-3: NaN

+1जावास्क्रिप्ट जैसी भाषा में इसका प्रदर्शन करना काफी कठिन है। (आप N(s,z) {return1 चार को बचाने के लिए अंतरिक्ष को हटा सकते हैं )
गणित चिलर

ओह, हाहा, उस एक को याद किया होगा। मुझे यह भी लगता है कि Oस्ट्रिंग में चेरों का एक समूह छूट गया है। मैं ठीक करूँगा कि ..
FireFly

11

गणितज्ञ ६० ५hem

f = ToString@#~WolframAlpha~{{"NumberName", 1}, "Plaintext"} &

उपयोग:

f[500]

पांच सौ

संपादित करें:

InputString[]~WolframAlpha~{{"NumberName", 1}, "Plaintext"}

3
यह वास्तव में इस सवाल का जवाब नहीं देता है। मैंने कहा कि उपयोगकर्ता को एक नंबर इनपुट करना है (कमांड लाइन, या उदाहरण के लिए एक प्रांप्ट बॉक्स का उपयोग करके), और फिर आपके प्रोग्राम को शब्दों (कमांड लाइन पर, या उदाहरण के लिए एक संदेश बॉक्स में) को आउटपुट करना चाहिए। आपका कोड इसे परिवर्तित करने के लिए केवल एक फ़ंक्शन है, और आपका प्रोग्राम इनपुट के लिए नहीं पूछता है।
प्रोग्रामऑफ

@ProgramFOX का कहना है कि 'उपयोगकर्ता कुछ इनपुट'। इसका मतलब यह नहीं है कि 'कार्यक्रम इनपुट के लिए संकेत देता है'।
श्रीजैंडर

@ मेज़रैंडर: ठीक है, 'इनपुट के लिए कार्यक्रम का संकेत' वास्तव में मेरा मतलब था। मैं अपने प्रश्न को अपडेट करता हूं, लेकिन निश्चित रूप से, यह अनुचित होगा यदि मैं एलेफाल्फा के उत्तर को आगे नहीं बढ़ाऊंगा, इसलिए उसे मेरे +1
प्रोग्रामफॉक्स

8

लिस्प, 72 56 वर्ण

मुझे 1) एहसास हुआ कि यह पुराना है, और 2) यह पूरी तरह से कार्य करने के लिए मानक पुस्तकालय पर निर्भर करता है, लेकिन तथ्य यह है कि आप इस तरह की चीज करने के लिए सी-लिस्प प्रिंटिंग सिस्टम प्राप्त कर सकते हैं, जिसने मुझे हमेशा प्रभावित किया है। इसके अलावा, यह वास्तव में एक उपयोगकर्ता से इनपुट लेता है, इसे रूपांतरित करता है, और इसे प्रिंट करता है।

(format t "~:[NaN~;~:*~r~]" (parse-integer (read-line) :junk-allowed t))

यह 72 अक्षरों का योग है।

  • :junk-allowed पार्स-पूर्णांक एक त्रुटि को बढ़ाने के बजाय विफलता पर शून्य लौटाता है।
  • ~:[if-nil~;if-non-nill] एनआईएल पर आवश्यक सशर्त, NaN को संभालता है जहां आवश्यक हो
  • ~:* इनपुट को फिर से उपभोग करने के लिए तर्क व्याख्या का समर्थन करता है
  • ~r पूर्ण सुधारित विराम चिह्न को छोड़कर, संख्या को अंग्रेजी शब्द स्ट्रिंग के रूप में अनुरोध करता है

नमूना:

17823658
seventeen million, eight hundred and twenty-three thousand, six hundred and fifty-eight

192hqfwoelkqhwef9812ho1289hg18hoif3h1o98g3hgq
NaN

मुख्य रूप से व्यावहारिक आम लिस्प से लिस्प जानकारी ।

संपादित करें, 56 वर्णों तक सही ढंग से गढ़ा

(format t "~:[NaN~;~:*~r~]"(ignore-errors(floor(read))))

यह संस्करण अलग तरह से काम करता है। एक पंक्ति को पढ़ने और इसे परिवर्तित करने के बजाय, यह लिस्प रीडर को इनपुट को एक लिस्प एस-एक्सप्रेशन के रूप में व्याख्या करने के लिए आमंत्रित करता है, इसे एक संख्या के रूप में उपयोग करने का प्रयास करता है, और यदि कोई त्रुटि उत्पन्न होती है तो उन्हें प्रारूप स्ट्रिंग सशर्त खिलाने के लिए शून्य का उत्पादन करने वाले उपेक्षा करते हैं। यह पहला उदाहरण हो सकता है, जिसे मैंने लिस्प को सही मायने में ट्रिक प्रोग्राम बनाते हुए देखा है ... फन!

  • (read) लिस्प रीडर / पार्सर को मानक इनपुट से एक अभिव्यक्ति को पढ़ने और इसे एक उपयुक्त वस्तु में बदलने के लिए आमंत्रित करता है
  • (floor) किसी भी संख्यात्मक प्रकार को निकटतम निचले पूर्णांक में बदलने का प्रयास, गैर-संख्यात्मक प्रकार के कारण त्रुटि उत्पन्न करता है
  • (ignore-errors ...) टिन पर यह क्या कहता है, यह संलग्न अभिव्यक्ति में किसी भी त्रुटि को पकड़ता है और अनदेखा करता है, प्रारूप स्ट्रिंग की NaN शाखा को खिलाने के लिए शून्य लौटाता है

यह निश्चित रूप से कोई समस्या नहीं है कि प्रश्न पुराना :) मैंने भाषा का नाम और वर्ण गणना को हेडर में शामिल करने के लिए आपके उत्तर को संपादित किया।
प्रोग्रामफॉक्स

संपादन के लिए धन्यवाद, मैंने अभी तक इन चीजों के लिए स्टैक * सिंटैक्स नहीं प्राप्त किया है। में वापस चला गया और एक गलती मैंने प्रारूप स्ट्रिंग में सशर्त के वर्णन में भी तय की।
टॉम स्कोगलैंड

3

PHP, 327 310 308 बाइट्स

<?$a=['',one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,0,fif,0,0,eigh];echo($n=$argv[1])>999?$a[$n/1000].' thousand ':'',$n%1000>99?$a[$n/100%10].' hundred ':'',$n?($k=$n%100)<20?($a[$k]?:$a[$k%10]).[teen][$k<13]:[2=>twen,thir,'for',fif,six,seven,eigh,nine][$k/10].'ty '.$a[$k%10]:zero;

संख्या को पैरामीटर के रूप में लेता है, 0 <= n <= 12999 के लिए काम करता है

टूट - फूट

// define names
$a=['',one,two,three,four,five,six,seven,eight,nine,
    ten,eleven,twelve,thir,0,fif,0,0,eigh];
// print ...
echo
    ($n=$argv[1])>999?$a[$n/1000].' thousand ':'',                  // thousands
    $n%1000>99?$a[$n/100%10].' hundred ':'',                        // hundreds
    $n?
        // if remains <20:
        ($k=$n%100)<20?
            ($a[$k]?:$a[$k%10]) // no value at index (0,14,16,17,19)? value from index%10
            .[teen][$k<13]      // append "teen" for $k>12
        // else:
        :[2=>twen,thir,'for',fif,six,seven,eigh,nine][$k/10].'ty '  // tens
        .$a[$k%10]                                                  // ones
    // "zero" for $n==0
    :zero
;

2

एसएएस, 70 अक्षर

data;window w n;display w;if n=. then put 'NaN';else put n words.;run;

windowऔर displayबयानों को खोलने एसएएस शीघ्र आदेश। इनपुट के लिए nलाइन 1 पर जाता है। यह एसएएस प्रारूप का लाभ लेता है words.जो संख्या को "या", "", और "-" के रूप में शब्दों की श्रृंखला या शब्दों के रूप में प्रिंट करेगा।


2

पीएचपी

777 वर्ण

यह निश्चित रूप से एक भयानक प्रयास है, लेकिन आप किसी भी खामियों का फायदा उठाने का मुझ पर आरोप नहीं लगा सकते हैं, साथ ही यह बहुत भाग्यशाली संख्या है। टिप के लिए ProgramFOX को धन्यवाद।

<?php $i=9212;$b = array('zero','one','two','three','four','five','six','seven','eight','nine');$t='teen';$c = array('ten','eleven','tweleve','thir'.$t,$b[4].$t,'fif'.$t,$b[6].$t,$b[7].$t,$b[8].$t,$b[9].$t);$d = array('','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninety');$e='hundred';$f='thousand';$j=str_split($i);if (strlen($i)===1){$a=$b[$i];}elseif (strlen($i)===3){$k=1;$a=$b[$j[0]].' '.$e.' '.x($j,$k);}elseif (strlen($i)===4){$k=2;$a=$b[$j[0]].' '.$f.' '.$b[$j[1]].' '.$e.' '.x($j,$k);}elseif (substr($i, -2, 1)==='1'){$a=$c[$j[1]];}else{$a=$d[$j[0]].' '.$b[$j[1]];}$a = str_replace('zero hundred','',$a);echo $a;function x($j,$k){global $i, $b, $c, $d;if (substr($i, -2, 1)==='1'){return $c[$j[$k+1]];}else{return $d[$j[$k]].' '.$b[$j[$k+1]];}}

लंबा हाथ

<?php
// Input
$i=9212;
// 0-9
$b = array('zero','one','two','three','four','five','six','seven','eight','nine');
// 10-19 (Very tricky)
$t='teen';
$c = array('ten','eleven','tweleve','thir'.$t,$b[4].$t,'fif'.$t,$b[6].$t,$b[7].$t,$b[8].$t,$b[9].$t); 
// Left digit of 20-99
$d = array('','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninety');
// Hundreds
$e='hundred';
// Thousands
$f='thousand';
// Split input
$j=str_split($i);
// 1 digit inputs
if (strlen($i)===1){$a=$b[$i];}
// 3 digit input
elseif (strlen($i)===3){$k=1;$a=$b[$j[0]].' '.$e.' '.x($j,$k);}
// 4 digit input
elseif (strlen($i)===4){$k=2;$a=$b[$j[0]].' '.$f.' '.$b[$j[1]].' '.$e.' '.x($j,$k);}
// 10-19
elseif (substr($i, -2, 1)==='1'){$a=$c[$j[1]];}
// 20-99
else{$a=$d[$j[0]].' '.$b[$j[1]];}
// Fix for thousand numbers
$a = str_replace('zero hundred','',$a);
// Result
echo $a;
// Abstracted function last 2 digits for 3 and 4 digit numbers
function x($j,$k){
    global $i, $b, $c, $d;
    // 10-19
    if (substr($i, -2, 1)==='1'){return $c[$j[$k+1]];}
    // 20-99
    else{return $d[$j[$k]].' '.$b[$j[$k+1]];}
}

1
मुझे लगता है कि आप इस तरह से सरणियाँ बनाकर अपने कोड को छोटा कर सकते हैं array('zero','one','two'):।
प्रोग्रामफॉक्स

@ProgramFOX या यहां तक ​​कि ['zero','one','two'](php 5.4+)। और अगर आप बुरा न मानें E_NOTICE, [zero,one,two]तो भी काम करेंगे।
प्रिमो

मुझे इसे अपडेट करना चाहिए, लेकिन 777 इतनी भाग्यशाली संख्या है।
हंस

आपके प्रयासों के लिए +1। कोड गोल्फ में PHP को त्रिकोणीय रूप से रेखांकित किया गया है।
प्रिमो

1

पायथन 2.x - 378

जुगनू के व्युत्पन्न उत्तर, हालांकि Pलाख या खरबों को शामिल करने के लिए बदलकर , आदि .. इसका पुन: उपयोग किसी भी सकारात्मक संख्या की सीमा के लिए किया जा सकता है। यह 999,999 तक के मूल्यों का भी समर्थन करता है

O=",one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,,fif,,,eigh,,,,twen,thir,for,fif,,,eigh,".split(",")
P=",thousand".split(',')
def N(s,p=0):
 h,s=divmod(s,1000);x=N(h,p+1)if h>0 else" "
 if s<20:x+=O[s]or O[s-10]+["","teen"][s>12]
 elif s<100:x+=(O[s/10+20]or O[s/10])+"ty"+N(s%10)
 else:x+=N(s/100)+"hundred"+N(s%100)
 return x+" "+P[p]
print N(input())

नमूना परीक्षण (इनपुट है <<<, आउटपुट है >>>):

<<< 1234
>>> one thousand two hundred thirty four

<<< 999999
>>>  nine hundred ninety nine   thousand nine hundred ninety nine

हालांकि, अगर कोई मुझे इस अजीब "बफर अंडरफ़्लो" मुद्दे की व्याख्या कर सकता है, तो वह प्रफुल्लित होगा ...

<<< -1
>>>  nine hundred ninety nine

<<< -2
>>>  nine hundred ninety eight

print divmod(-2,1000) #-> (-1, 998)
प्रिमो

ओह बेशक। मैं सोच रहा था कि यह एक पूर्ण मूल्य या कुछ ले सकता है। लेकिन वहाँ है -1*1000और एक "शेष" है 998

1

स्माइलबेसिक, 365 थ्री हंड्रेड फोर्टी सेवन बाइट्स

DIM N$[22]D$="OneTwoThreeFourFiveSixSevenEightNineTenElevenTwelveThirFourFifSixSevenEighNineTwenFor
WHILE LEN(D$)INC I,D$[0]<"_
INC N$[I],SHIFT(D$)WEND
INPUT N
W=N MOD 100C%=N/100MOD 10M%=N/1E3T=W<20X=W/10>>0?(N$[M%]+" Thousand ")*!!M%+(N$[C%]+" Hundred ")*!!C%+(N$[X+10+(X==2)*8+(X==4)*7]+"ty "+N$[N MOD 10])*!T+N$[W*T]+"teen"*(T&&W>12)+"Zero"*!N

यदि पिछले एक या दो अंक 0 हैं, तो एक अनुगामी स्थान है।


0

एमओओ - 55 चार्ट

player:tell($string_utils:english_number(read(player)))

या, अगर मुझे "स्टडआउट" के लिए प्रिंट करने की आवश्यकता नहीं है - 42 वर्ण: $string_utils:english_number(read(player))

नोट: यह कोड मानक आउटपुट के लिए कोई संकेत नहीं छापता है और इनपुट के नंबर के zeroबजाय प्रिंट NaNकरता है।

एक बोनस के रूप में, यह कोड किसी भी संख्या को मू भाषा ( 2147483647- -2147483648) की सीमा के साथ संभाल सकता है ।


0

वोल्फ्राम भाषा 27 40 बाइट्स

देशी फ़ंक्शन का उपयोग करना IntegerName,

 Check[Input[]~IntegerName~"Words","NaN"]

उपयोगकर्ता इनपुट के लिए उपरोक्त संकेत देता है। यदि उपयोगकर्ता किसी पूर्णांक के अलावा कुछ भी दर्ज करता है, तो वर्तमान कार्यान्वयन "NaN" देता है।


कुछ उदाहरण (प्री-सेट इनपुट के साथ) :

 Check[243~IntegerName~"Words","NaN"]

दो सौ तेईस


 Check[1234567890~IntegerName~"Words","NaN"]   

एक अरब, दो सौ चौंतीस करोड़, पांच सौ साठ, हज़ार, आठ सौ नब्बे


 Check["abc"~IntegerName~"Words","NaN"]  

NaN


0

पायथन 2 , 333 बाइट्स

def f(n):S=str.split;D=S('z one two three four five six seven eight nine');K=' fif six seven eigh nine';k=n/1000;n,m=n/100%10,n%100;e,d=m/10,m%10;return' '.join([k and f(k),'thousand']*(k>0)+[D[n],'hundred']*(n>0)+([S('ten eleven twelve thir four'+K)[d]+'teen'*(d>2)]if 9<m<20else[S('twen thir for'+K)[e-2]+'ty']*(e>0)+[D[d]]*(d>0)))

इसे ऑनलाइन आज़माएं!

यह 1 से 999,999 के लिए अच्छा है, समावेशी।


0

पायथ, 239 242 बाइट्स

L:rjdb6"  +"dAm+cd;"nine"," one two three four five six seven eight""  twen thir for fif six seven eigh"|y_.ey+Wk.e?Y?thZjd,?hZ+@HhZ"ty"""@GeZ@+c"ten eleven twelve"d+R"teen"+c"thir four"d>H5eZ?hZ+@GhZ" hundred"""c.[03_b]1"thousand"c_jQT3"zero

इनपुट रेंज में एक पूर्णांक है [0-999,999]। इसे यहाँ ऑनलाइन आज़माएँ । स्पष्टीकरण लंबित है।

पिछला संस्करण, बहुत समान संचालन, लेकिन 0 का समर्थन नहीं करता है:

L:rjdb6"  +"dJc" one two three four five six seven eight nine"dKc"  twen thir for fif six seven eigh nine"dy_.ey+Wk.e?Y?thZjd,?hZ+@KhZ"ty"""@JeZ@+c"ten eleven twelve"d+R"teen"+c"thir four"d>K5eZ?hZ+@JhZ" hundred"""c.[03_b]1"thousand"c_jQT3

पिछले संस्करण की व्याख्या:

Implicit: Q=eval(input()), d=" "

Step 1: output formatting helper function
L:rjdb6"  +"d   
L               Define a function, y(b):
   jdb          Join b on spaces
  r   6         Strip whitespace from beginning and end
 :              In the above, replace...
       "  +"    ... strings of more than one space...
            d   ... with a single space

Step 2: Define number lookup lists
Jc"..."dKc"..."d   
  "..."            Lookup string
 c     d           Split the above on spaces
J                  Store in J - this is list of unit names
        Kc"..."d   As above, but storing in K - this is list of tens names, without "ty"

Step 3: Bringing it all together
y_.ey+Wk.e?Y?thZjd,?hZ+@KhZ"ty"""@JeZ@+c"ten eleven twelve"d+R"teen"+c"thir four"d>K5eZ?hZ+@JhZ" hundred"""c.[03_b]1"thousand"c_jQT3   
                                                                                                                                jQT    Get digits of Q
                                                                                                                               _       Reverse
                                                                                                                              c    3   Split into groups of 3
  .e                                                                                                                                   Map the above, element as b, index as k, using:
                                                                                                                _b                       Reverse the digits in the group
                                                                                                            .[03                         Pad the above on the left with 0 to length 3
                                                                                                           c      ]1                     Chop at index 1 - [1,2,3] => [[1],[2,3]]
        .e                                                                                                                               Map the above, element as Z, index as Y, using:
          ?Y                                                                                                                               If second element in the group (i.e. tens and units):
            ?thZ                                                                                                                             If (tens - 1) is non-zero (i.e. 0 or >=2):
                   ?hZ                                                                                                                         If tens is non-zero:
                       @KhZ                                                                                                                      Lookup in tens names
                      +    "ty"                                                                                                                  Append "ty"
                                                                                                                                               Else:
                               ""                                                                                                                Empty string
                  ,                                                                                                                            Create two-element list of the above with...
                                 @JeZ                                                                                                          ... lookup units name
                jd                                                                                                                             Join the above on a space - this covers [0-9] and [20-99]
                                                                                                                                             Else:
                                                                     c"thir four"d                                                             ["thir", "four"]
                                                                    +             >K5                                                          Append last 5 element of tens names ("fif" onwards)
                                                            +R"teen"                                                                           Append "teen" to each string in the above
                                      +c"ten eleven twelve"d                                                                                   Prepend ["ten", "eleven", "twelve"]
                                     @                                               eZ                                                        Take string at index of units column - this covers [10-19]
                                                                                                                                           Else: (i.e. hundreds column)
                                                                                       ?hZ                                                   If hundreds column is non-zero:
                                                                                           @JhZ                                                Lookup units name
                                                                                          +    " hundred"                                      Append " hundred"
                                                                                                         ""                                  Else: empty string
                                                                                                                                         Result of map is two element list of [hundreds name, tens and units name]
      Wk                                                                                                                                 If k is nonzero (i.e. dealing with thousands group)...
     +                                                                                                              "thousand"           ... Append "thousand"
    y                                                                                                                                    Apply output formatting (join on spaces, strip, deduplicate spaces)
                                                                                                                                       Result of map is [units group string, thousands group string]
 _                                                                                                                                     Reverse group ordering to put thousands back in front
y                                                                                                                                      Apply output formatting again, implicit print
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.