Bu golf kodunun amacı, tamsayıları İngilizce kelimelere çevirmektir.

Program giriş ister. Bu giriş bir tam sayı değilse, yazdırın NaN. Bir tamsayıysa, İngilizce sözcüklere dönüştürün ve bu sözcükleri yazdırın. Minimum giriş: 0 (sıfır). Maksimum giriş: 9000 (dokuz bin).
Yani, 5geri dönüşler five(durum önemli değil) ve 500geri döner five hundredveya five-hundred(tire önemli değil).

Diğer bazı kurallar:

A oneönce hundredveya thousandisteğe bağlı: one hundreddoğru, ancak hundredçok (giriş 100elbette ise).

andÖrneğin kelime one hundred and forty fivede isteğe bağlıdır.

Boşluk önemlidir. Yani, çünkü 500, five-hundredya five hundredda doğru, ama fivehundreddeğil.

İyi şanslar!

Perl 281 bayt

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

Yatay akıl sağlığına yeni satırlar eklendi. Yukarıdakiler etkileşimli olarak veya bir değerin stdin üzerinden pipoyla kullanılmasıyla kullanılabilir.

[0, 19999] aralığındaki tüm tamsayı değerleri için doğru çalışıyor , bu aralığın dışındaki değerler tanımsız davranış gösteriyor. Tamsayı olmayan değerler sıfıra kesilecek ve bu nedenle, yalnızca gerçekten sayısal olmayan değerler raporlanacaktır NaN.

Örnek kullanım:

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

Örnek çıktı:

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

JavaScript (375)

Muhtemelen korkunç bir girişim, ama yine de, işte ...

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()))

Oldukça basılmış (işlev olarak):

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
}

Örnek dönüştürme ( NaNsınırların dışında, yani geçersiz girdi olduğunda bile çıktı alındığını unutmayın ):

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

Mathematica 60 57

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

Kullanımı:

f[500]

beş yüz

Düzenle:

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

Lisp, 72 56 karakter

1) bunun eski olduğunu ve 2) işlevsellik için tamamen standart kütüphaneye dayandığını fark ettim, ancak c-lisp baskı sisteminin bu tür bir işlemi yapmasını sağlayabilmeniz beni her zaman etkiledi. Ayrıca, bu aslında bir kullanıcıdan girişi alır, dönüştürür ve yazdırır.

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

Toplamda 72 karakter.

• :junk-allowed ayrıştırma tamsayısının, hata oluşturmak yerine başarısızlıkta sıfır döndürmesine neden olur.
• ~:[if-nil~;if-non-nill] sıfırda şartlı koşullu, gerektiğinde NaN'yi kullanır
• ~:* girdiyi tekrar tüketmek için argüman yorumlamasını yedekler
• ~r , tam düzeltilmiş noktalama işaretleri dışında, istendiği gibi sayıyı ingilizce kelime dizgisi olarak yazdırır.

Numune:

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

192hqfwoelkqhwef9812ho1289hg18hoif3h1o98g3hgq
NaN

Lisp bilgileri esas olarak Pratik Ortak Lisp'ten alınmıştır .

Düzenleme, 56 karaktere kadar uygun şekilde golf oynama

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

Bu sürüm oldukça farklı çalışıyor. Bir satırı okumak ve dönüştürmek yerine, lisp okuyucuyu girişi bir lisp s ifadesi olarak yorumlamaya, sayı olarak kullanmaya çalışır ve herhangi bir hata üretilirse koşullu biçim dizesini beslemek için nil üretmediğini yok sayar. Bu, lisp'i gerçekten özlü bir program yaparken gördüğüm ilk örnek olabilir ... Eğlenceli!

• (read) Lisp okuyucu / ayrıştırıcısını standart girdiden bir ifade okumaya ve uygun bir nesneye dönüştürmeye çağırır.
• (floor) Herhangi bir sayısal türü en yakın en küçük tam sayıya dönüştürmeye çalışır, sayısal olmayan türlerde hata oluşmasına neden olur
• (ignore-errors ...) kalay üzerinde söylediklerini yapar, ekteki ifadedeki hataları yakalar ve yok sayar, biçim dizesinin NaN dalını beslemek için sıfır döndürür

PHP, 327 310 308 bayt

<?$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;

sayıyı parametre olarak alır, 0 için çalışır <= n <= 12999

Yıkmak

// 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
;

SAS, 70 karakter

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

windowVe displaytablolar SAS komut istemi açın. İçin giriş nBu SAS biçimin avantajlarından yararlanan hat 1. gider words."ve", "bir kelime veya kelime serisi olarak sayısını yazdırır" ve "-" uygun olarak.

PHP

777 karakter

Bu kesinlikle korkunç bir girişim, ancak beni herhangi bir boşluktan yararlanmakla suçlayamazsınız, artı çok şanslı bir rakam. Bahşiş için ProgramFOX'a teşekkürler.

<?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]];}}

Uzun el

<?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]];}
}

Python 2.x - 378

Fireflys türevi cevap değiştirerek rağmen P milyon veya trilyon vb olarak herhangi bir pozitif sayı aralığında kullanılabilir. Bu aynı zamanda 999.999'a kadar olan değerleri de destekler

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())

Örnek test (giriş <<<, çıkış >>>):

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

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

Her ne kadar, birileri bu garip "arabellek akışı" sorununu açıklayabilirse, bu harika olurdu ...

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

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

SmileBASIC, 365 Üç Yüz Kırk Yedi bayt

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

Son bir veya iki hane 0 ise sondaki bir boşluk var.

MOO - 55 karakter

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

Veya, "stdout" e yazdırmam gerekmiyorsa - 42 karakter: $string_utils:english_number(read(player))

Not: Bu kod standart çıktı ve baskılar için herhangi bir istemi yazdırmıyor zeroyerine NaNgirdi bir sayı olmadığında.

Bir bonus olarak, bu kod moo dilinin sınırlarını aşarak herhangi bir numarayı kullanabilir ( 2147483647--2147483648 ) içeren .

Wolfram Dili 27 40 bayt

Yerel fonksiyondan faydalanmak IntegerName,

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

Yukarıdaki kullanıcı girişi ister. Kullanıcı bir tam sayıdan başka bir şeye girerse, mevcut uygulama "NaN" döndürür.

Bazı örnekler (önceden ayarlanmış girişlerle) :

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

iki yüz kırk üç

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

bir milyar, iki yüz otuz dört milyon, beş yüz altmış yedi bin, sekiz yüz doksan

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

NaN

Python 2,333 bayt

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)))

Çevrimiçi deneyin!

Bu, 1 - 999.999, dahil olmak üzere iyidir.

Pyth, 239 242 bayt

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

Giriş, [0-999,999] aralığında bir tam sayıdır. Çevrimiçi deneyinBurada . Açıklama beklemede.

Önceki sürüm, çok benzer bir işlem, ancak 0 desteklemiyor:

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

Önceki versiyonun açıklaması:

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