Défi CodeGolf

PWSSHHHH! Vous vous réveillez dans un laboratoire de cryogénie en l'an 3000. Après avoir été escorté au bureau des affectations pour recevoir votre puce de carrière, vraisemblablement celle d'un livreur, une sonde détecte que vous êtes à partir de l'an 2000. Pour cette raison, quelques les stéréotypes, vous supposiez stupide par rapport à aujourd'hui humain moderne et sont obligés de répéter les gradeschool.

Vous entrez dans votre classe de première année et l'enseignant donne un devoir. Elle dira ou écrira un nombre allant jusqu'à 50. Si elle écrit le nombre sur le tableau (par exemple: 25), vous devrez alors indiquer les nombres jusqu'à ce nombre "un, deux, trois, ..., vingt-cinq ". Si elle dit le numéro à haute voix (par exemple: "six"), vous devez écrire sur votre tablette les nombres jusqu'à ce que "1, 2, 3, 4, 5, 6"

Cela devient très fastidieux et vous décidez d’automatiser le processus avec vos connaissances en matière de programmation du 21ème siècle, qui fonctionnent encore mais restent archaïques.

Objectif:

Votre programme devrait prendre une entrée. Cette entrée sera soit un nombre décimal ( 1 thru 50), soit un nombre écrit ( one thru fifty).

• Si l'entrée est un nombre décimal, votre sortie doit compter de un à ce nombre, en utilisant le style écrit. (par exemple trente-deux )

• Si l'entrée est un nombre écrit, votre sortie doit compter de 1 à ce nombre, en utilisant un style décimal. (par exemple 32 )

Règles:

L'entrée et la sortie peuvent être dans n'importe quel cas de votre choix (vous pouvez donc créer un programme qui n'accepte que les majuscules si vous le souhaitez).

Les nombres décimaux en entrée ne doivent pas nécessairement être de type numérique (par exemple, int), ils peuvent être une chaîne en entrée contenant des nombres (25 vs "25"). Soit ça va et vous pouvez choisir lequel vous voulez que votre programme accepte. (Votre programme n'a pas besoin d'accepter les deux)

Le style écrit n'exige PAS un trait d'union entre les mots composés, mais vous pouvez le faire si vous le souhaitez.

Les valeurs de sortie doivent être séparées sous une forme quelconque, tout séparateur convient 1,2,3 1 2 3 etc

Vous ne pouvez pas ajouter de bibliothèques supplémentaires telles que num2words (python), etc. (les bibliothèques système conviennent toutefois)

Même si l'histoire raconte que vous êtes de l'an 2000, vous pouvez utiliser des langues créées après cette date (lol).

C'est du code-golf , alors le programme avec le plus petit décompte gagne!

Perl 6 , 119 113 octets

{my \n=<① ⑳ ㉑ ㉟ ㊱ ㊿>.map:{|map *.uniname.words[2..*].join,$^a..$^b}
/\d/??n[^$_]!!1..1+first $_,n,:k}

Base de données Unicode FTW!

Utilise les chiffres en majuscules sans chiffres, par exemple TWENTYTWO.
Renvoie une liste de chaînes ou une plage de nombres. (Les deux utilisent l’espace comme séparateur lorsqu’ils sont imprimés avec put.)

Python3, 276 271 269 243 237 235 232 217 octets

Prendre exemple sur la soumission de @smls perl ...

from unicodedata import*
o=[name(chr(k)).split(' ',2)[-1]for j in['①⑴','㉑㉠','㊱㋀']for k in range(ord(j[0]),ord(j[1]))]
i=input()
w=i in o
for i in range(w and o.index(i)+1or int(i)):print(w and i+1or o[i])

Je pense que cela pourrait être joué un peu plus loin.

Il utilise la bibliothèque système unicodedatapour rechercher des noms de nombres. Il nécessite des noms de nombres en majuscules (séparés par un espace FORTY TWO:) ou des nombres entiers décimaux en entrée.

(Ceci est ma première soumission de code de golf.)

(Je viens aussi de remarquer que je calculais mal la longueur (encodage), donc c'est quelques octets de moins que prévu. J'ai cependant mis à jour le nombre d'octets le plus récent. Oups.)

Common Lisp, 297 253 243 242 144 128

(lambda(s)(#1=dotimes(u(or(#1#(i 51)(if(equal(#2=format()"~R"i)s)(return i)))s))(#2#t"~[~:;, ~]~:[~R~;~D~]"u(stringp s)(1+ u))))

Détails

(lambda (s) 
  (dotimes                         ; iterate...                                                                          
      (u                           ; for u from zero below ...                
       (or                         ; if s is a string, then                   
        (dotimes (i 51)            ;   parse s by iterating from 0 to 50      
          (if (equal               ;   until we find a match between          
               (format nil "~R" i) ;   the English word(s) for i              
               s)                  ;   and the given s                        
              (return i)))         ;   (exit loop)                            
        s))                        ; otherwise, use s, which is a number      
    (format t                      ; for each U, print to standard output     
            "~[~:;, ~]~:[~R~;~D~]" ; (see below for details)                  
            u                      ; ...                                      
            (stringp s)            ; ... arguments to format                  
            (1+ u))))              ; ...                                      

• ~[ 0 ~; 1 ~; ... ~:; else ~]est un commutateur, basé sur la valeur du prochain argument disponible, qui passe au format de sous-contrôle approprié. Ici, je n'ai qu'un cas de "0" et pour "sinon". Ceci est utilisé pour insérer un séparateur avant chaque numéro sauf le premier, grâce à U à partir de zéro.

• ~:[ FALSE ~; TRUE ~]est un format conditionnel; Ici, nous produisons les choses différemment, que l’entrée s soit une chaîne ou non.

• ~Récrivez un nombre en tant que nombre anglais cardinal, alors ~Dque le chiffre est simplement imprimé.

Exemples

CL-USER> (test "five")
1, 2, 3, 4, 5

CL-USER> (test 32)
one, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen, twenty, twenty-one, twenty-two, twenty-three, twenty-four, twenty-five, twenty-six, twenty-seven, twenty-eight, twenty-nine, thirty, thirty-one, thirty-two

JavaScript ES6, 559 526 381 368 364 358 332 327 315 octets

a="one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir10four10fif10six10seven10eigh10nine1".replace(/1/g,'teen').split(0),b="twenty0thirty0forty0fifty".split(0),c=(n,d=Array,e=b.forEach(i=>a=a.concat(i,a.slice(0,9).map(x=>i+x))))=>1/n?a.slice(0,n).join():d.from(d(a.indexOf(n)+1),(x,i)=>i+1).join();

Merci à Kritixi Lithos pour l’idée de scinder le tableau et à Arnauld pour le tour 1 / n.

a="one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir10four10fif10six10seven10eigh10nine1".replace(/1/g,'teen').split(0),b="twenty0thirty0forty0fifty".split(0),c=(n,d=Array,e=b.forEach(i=>a=a.concat(i,a.slice(0,9).map(x=>i+x))))=>1/n?a.slice(0,n).join():d.from(d(a.indexOf(n)+1),(x,i)=>i+1).join();

console.log(c("twentyfive"));
console.log(c("fifty"));
console.log(c(50));

Python 2 , 503 499 494 490 479 octets

-5 grâce à @JonathanAllan

l='one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#'.replace('#','teen ').split()
m='twenty','thirty','forty','fifty'
i,z,R=raw_input(),' ',range
try:n=int(i);p=(n/10)-2;o=(l+sum([[m[x]]+[m[x]+z+l[y]for y in R(9)]for x in R(p)],[])+[m[p]]+[m[p]+z+l[y]for y in R(n%10)],l[:n])[n<20]
except:j=i.split();o=map(str,R(1,(m.index(j[0])+2)*10+l.index(j[1])+2if z in i else l.index(i)+2if i in l else(m.index(i)+2)*10+1))
print','.join(o)

Essayez-le en ligne!

Entrez un nombre ou une espace séparée par l’orthographe d’un nombre.

Version légèrement moins jouée et plus lisible:

l='one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen'.split()
m='twenty','thirty','forty','fifty'
i=raw_input()
try:
 n=int(i)
 if n<20:
  o=l[0:n]
 else:
  o=l
  for x in range((n/10)-2):
   o+=[m[x]]+[m[x]+' '+l[y]for y in' '*9]
  p=m[(n/10)-2]
  o+=[p]+[p+' '+l[y]for y in' '*n%10]
except:
 if' 'in i:
  t=i.split()
  s=((m.index(t[0])+2)*10)+l.index(t[1])+2
 else:
  s=l.index(i)+2 if i in l else((m.index(i)+2)*10)+1
 r=range(1,s)
 o=map(str,r)
print','.join(o)

Schéma, 161 , 152 , 149

(define (c x)(let((r(string->number x)))(let l((i 1))(let((n (format #f "~r" i)))(display(if r n i))(newline)(or(eq? r i)(equal? x n)(l (+ i 1)))))))

Non compressé:

(define (count limit)
  (let ((numerical-limit (string->number limit)))
    (let l ((i 1))
      (let ((current-number (format #f "~r" i)))
        (display (if numerical-limit current-number i))
        (newline)
        (or (eq? numerical-limit i)
            (equal? limit current-number)
            (l (+ i 1)))))))

PHP - 397 372 349 344 329 octets

Inspiré par la solution JS de TomDevs

Sauvegardé 25 octets en remplaçant $a=[...]par$a=explode(...)

Vous avez sauvegardé 23 autres octets en revenant dans un tableau sans séparateurs de chaînes et en les stockant teendans une variable, grâce à @ user59178.

Enregistré 5 autres octets en supprimant la (int)conversion de typage

Sauvegardé 15 octets supplémentaires en supprimant $b, $idans les fordéclarations et les accolades, grâce à @ user59178 à nouveau

$a=[one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir.$t=teen,four.$t,fif.$t,six.$t,seven.$t,eigh.$t,nine.$t];foreach([twenty,thirty,forty,fifty] as$c){$a[]=$c;for($i=0;$i<9;)$a[]=$c.'-'.$a[$i++];}if($argv[1]!=0)for($i=0;$i<$argv[1];)echo$a[$i++].' ';else for($i=1;$i<=array_search($argv[1],$a)+1;)echo$i++.' ';

Ungolfed:

$a =[one,two,three,four,five,six,seven,eight,nine,ten,eleven,‌​twelve,thir.$t=teen,‌​four.$t,fif.$t,six.$‌​t,seven.$t,eigh.$t,n‌​ine.$t];
foreach ([twenty,thirty,forty,fifty] as $c){
    $a[] = $c;
    for ($i=0;$i<9;)
        $a[] = $c . '-' . $a[$i++];
}
if( $argv[1] !=0 )
    for ($i=0;$i<$argv[1];)
        echo $a[$i++] . ' ';
else
    for ($i=1;$i<=array_search($argv[1], $a)+1;)
        echo $i++ . ' ';

Essayez-le pour une chaîne d'entrée ou pour un numéro d'entrée

Python 2, 262 octets

x="one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#".replace("#","teen ").split()
x+=[a+"ty"+b for a in"twen","thir","for","fif"for b in['']+x[:9]]
v=input()
for s in range(1,x.index(v)+2)if v>50else x[:v]:print s

repl.it

Les chaînes d'entrée et de sortie sont en minuscules et concaténées *, aussi, pour tester une chaîne, saisissez, par exemple, "thirtyfive"à l'invite.

Construit la liste de tous les mots (plus "fiftyone"à "fiftynine"), xpuis teste si inputest un mot avec le proxy v>50(les chaînes sont plus grandes que les nombres dans Python 2, et tous les nombres de la plage d’entrée valide de la spécification sont <=50) et prints les valeurs en découpant soit la liste, x[:v]ou la construction d' une série de nombres entiers, range(1,x.index(v)+2).

* Ajouter une césure sur les deux coûts coûte 11 octets, en le remplaçant a+"ty"bpar a+"ty"+'-'*(b>'')+b.

Wolfram Language, 92 octets

If[NumberQ@#, Do[Print@IntegerName@i, {i, #}], 
  Do[Print@i, {i, Interpreter["SemanticNumber"]@#}]] &

(Je suis nouveau à cela, laissez-moi savoir si j'ai fait quelque chose de mal)

JavaScript (ES6), 261 octets

Remarque: la chaîne affectée à z est codée avec atob. Dans la chaîne codée, il y a 11 octets que je ne peux pas publier sur ce site, même s'il s'agit de caractères valides dans une chaîne javascript. J'ai donc utilisé un hex d'échappement sous la forme \ xHH. Chacune de ces échappées compte pour 1 octet.
La chaîne originale non compressée est la version moins golfée .

x=>(z=btoa('ö\x89ÞöÜ(öØkyï_¢êý~+Þöȱöǯz\x7f^\x8a\x08möx§{Û^\x9f×¥z÷§öÜ\x1e\x96÷½¶\x18«÷×â\x7fß}z(!÷Ûpz\x7f}~\x8aý').split(9),o=(0+z.map((v,i)=>i<20?i<13?v:(v||z[i-10])+'teen':z.slice(0,10).map(d=>(z[i]||z[i-8]||z[i-18])+'ty'+d))).split`,`,p=o.indexOf(x),o.slice(1,-~x+p+!~p).map((x,i)=>~p?i+1:x))

Moins joué au golf

x => (
  z = '9one9two9three9four9five9six9seven9eight9nine9ten9eleven9twelve9thir99fif999eigh99twen99for9'
      .split(9),
  o = (0 + // 0 + array to build a comma separated string
       z.map( (v, i) => 
         i < 20 
         ? i < 13 
           ? v // 1 to 13 are 'as is'
           : (v||z[i-10])+'teen' // compose for 14 to 19
         : z.slice(0,10).map(d=>(v||z[i-8]||z[i-18])+'ty'+d)) // 20s, 30s, 40s, 50s
      ).split`,`, // from comma separated to array again
  // o contains strings from one to fiftynine
  p = o.indexOf(x), // look for input
  o.slice(1, -~x+p+!~p).map((x,i) => ~p?i+1:x)
)

Tester

F=
x=>(z=btoa('ö\x89ÞöÜ(öØkyï_¢êý~+Þöȱöǯz\x7f^\x8a\x08möx§{Û^\x9f×¥z÷§öÜ\x1e\x96÷½¶\x18«÷×â\x7fß}z(!÷Ûpz\x7f}~\x8aý').split(9),o=(0+z.map((v,i)=>i<20?i<13?v:(v||z[i-10])+'teen':z.slice(0,10).map(d=>(v||z[i-8]||z[i-18])+'ty'+d))).split`,`,p=o.indexOf(x),o.slice(1,-~x+p+!~p).map((x,i)=>~p?i+1:x))

function update() {
  var i=I.value
  O.textContent = F(i)
}  

update()

<input id=I value=25 oninput='update()'><pre id=O></pre>

Python 3 , 305 303 octets

Converti en Python 3 après avis de @ nedla2004. Maintenant, n’a plus d’espace entre les nombres écrits en entrée ou en sortie, par exemple, entrez vingt

l='one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#'.replace('#','teen ').split()
m='twenty','thirty','forty','fifty'
i,R=input(),range
l+=sum([[m[x]]+[m[x]+l[y]for y in R(9)]for x in R(3)],[])
for x in R(1,l.index(i)+2)if i in l else l[:int(i)]:print(x)

Essayez-le en ligne 3!

Python 2 , 327 320 313 308 octets

l='one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#'.replace('#','teen ').split()
m='twenty','thirty','forty'
i,R=raw_input(),range
l+=sum([[m[x]]+[m[x]+l[y]for y in R(9)]for x in R(3)],[])+['fifty']
for x in R(1,l.index(i)+2)if i in l else l[:int(i)]:print x

Essayez-le en ligne 2!

163 170 177 octets plus court que ma réponse originale, je l’affiche donc comme alternative. Ceci utilise forsur les deux listes pour construire une liste complète de toutes les représentations sous forme de chaîne des nombres, puis identifie celle de droite dans la liste et affiche tout ce qui s’y passe, par valeur ou par index. Affiche une nouvelle ligne pour chaque valeur.

Python 2, 432 422 416 403 octets

Je suis sûr que cela peut être amélioré. À tout le moins, si je peux me permettre de coder en dur la valeur sur laquelle travailler et de ne pas avoir besoin d'une fonction, je peux économiser 20. Il faut un espace pour séparer les mots dans la saisie de texte. Sauvegardé de 6 octets grâce au commentaire de JonathanAllan sur la réponse d'ElPedro, 4 pour avoir réarrangé les maths.

def z(f):
 a,b,i,d="one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#".replace("#","teen ").split()+[""],"twenty thirty forty fifty".split(),1,f>50
 if d:f=f.split();f=a.index(f[-1])+21+b.index(f[-2])*10 if len(f)>1 else b.index(f[-1])*10+20 if f[-1]in b else a.index(f[-1])+1
 while i<=f:s=i if d else a[i-1]if i<20 else b[i//10-2]+a[i%10-1];print s;i+=1

(NB: la version actuelle de this utilise des tabulations pour mettre en retrait au lieu d'espaces. QPaysTaxes a ajouté un seul espace, car le rendu n'était pas correct, pour assurer la compilation du code donné. Cela ne devrait pas changer le nombre d'octets.)

C ++ 11, 484 480 477 octets

#import<iostream>
#import<cstdlib>
#import<vector>
using namespace std;f(){int j,i=2;string s="teen";vector<string>v={"","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve"};for(;i++<9;)v.push_back(v[i]+s);v[13]="thir"+s;v[15]="fif"+s;v[18]="eigh"+s;for(i=19;i++<50;){string n[4]={"twenty","thirty","forty","fifty"};v.push_back(n[i/10-2]+v[i%10]);}cin>>s;if(i=atoi(s.c_str()))for(j=0;j++<i;)cout<<v[j]<<" ";else while(v[i++]!=s)cout<<i<<" ";}

Saisie de texte en minuscule sans trait d'union.

PowerShell , 362 octets

$z=0..50|%{("0twenty0thirty0forty0fifty"-split0)[+(($b="$_"[0])-gt49)*($_-gt19)*(+"$b"-1)]+($x=(("0one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve"-split0)+(-split'thir four fif six seven eigh nine'|%{$_+'teen'})))[($_%10)*($_-gt19)]+$x[$_*($_-le19)]}
if(($n=-split$args)[0][0]-in48..57){$z[$n[0]..$n[2]]}else{$z.IndexOf($n[0])..$z.IndexOf($n[2])}

Essayez-le en ligne! mots saisis ou chiffres saisis

C'est un vrai gâchis et je n'en suis pas très content, mais le voici. Les suggestions de golf sont les bienvenues.

La première ligne $zest un tableau des mots anglais complets. Vous pouvez voir les -split0nombres 1pour 12, et la boucle pour construire tous les teens, puis il y a beaucoup de logique pour tout assembler correctement. Essayez-le en ligne!

La deuxième ligne commence par une certaine logique. Nous prenons l'entrée $args(sous forme de chaîne), -splitcelle - ci sur des espaces, nous l'enregistrons $npour une utilisation ultérieure, prenons le premier [0]mot et le premier [0]caractère de celui-ci et vérifions s'il s'agit d' -inune plage 48..57(c'est-à-dire, de l'ASCII 0à 9). Donc, nous vérifions si nous avons une entrée décimale ou une entrée en anglais. Essayez-le en ligne!

Dans le premier cas, nous construisons une plage basée sur les entrées décimales $n[0]..$n[2]et l'utilisons pour l'indexation $z[...]. Dans l'autre cas, nous trouvons le .indexOf()premier mot et le dernier mot et construisons une plage numérique à partir de cela. Dans les deux cas, nous avons maintenant un tableau d'objets sur le pipeline (soit des chaînes, soit des entiers), et un implicite Write-Outputà l'achèvement du programme nous donne un nouveau trait entre les éléments.

Swift3, 402 octets

let f=["one","two","three","four","five","six","seven","eight","nine"]
let g=["twenty","thirty","forty","fifty"]
let v=[f,["ten","eleven","twelve"],["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"},[g[0]],f.map{g[0]+$0},[g[1]],f.map{g[1]+$0},[g[2]],f.map{g[2]+$0},[g[3]]].flatMap{$0}
func c(s:String){if let i=Int(s){print(v.prefix(upTo:i))}else{for j in 1...v.index(of:s)!+1{print(j)}}}

Ungolfed:

let f = ["one","two","three","four","five","six","seven","eight","nine"]
let g = ["twenty","thirty","forty","fifty"]

let values = [f,["ten","eleven","twelve"],["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"},
              [g[0]], f.map{g[0]+$0},
              [g[1]], f.map{g[1]+$0},
              [g[2]], f.map{g[2]+$0},
              [g[3]]].flatMap{$0}

func count(s:String){
    if let i = Int(s) {
        print(values.prefix(upTo: i))
    } else {
        for j in 1...values.index(of: s)!+1{
            print(j)
        }
    }
}

count(s:"29")
count(s:"twentyeight")

Rien de spécial ici, juste en utilisant un tableau pour sauvegarder les nombres écrits.

J'ai initialement pensé à cette solution en utilisant cette autre façon de calculer le valuestableau:

let values = f + ["eleven","twelve"]
    + ["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"}
    + [g[0]] + f.map{g[0]+$0}
    + [g[1]] + f.map{g[1]+$0}
    + [g[2]] + f.map{g[2]+$0}
    + [g[3]]

Ce qui pourrait être joué au golf pour:

let v=f+["eleven","twelve"]+["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"}+[g[0]]+f.map{g[0]+$0}+[g[1]]+f.map{g[1]+$0}+[g[2]]+.map{g[2]+$0}+[g[3]]

remplacement de la 3ème ligne du code golfé

J'aurais pu marquer 381 octets, mais il y a une erreur de compilation qui dit: "l'expression était trop complexe pour être résolue dans un délai raisonnable", plus d'informations sur l'erreur peuvent être trouvées ici

R, 452 430 424 octets

o=c("","one","two","three","four","five","six","seven","eight","nine") 
t=gsub(0,"teen",c("ten","eleven","twelve","thir0","four0","fif0","six0","seven0","eigh0","nine0"))
s=c("twenty","thirty","forty") 
p=""
for(i in s){for(j in o){p=paste0(p,i,j," ")}}
as.data.frame(t(d<-1:50))
names(d)=c(o[-1],t,as.vector(strsplit(p," ")[[1]]),"fifty")
f=function(x){if(is.numeric(x)){names(d)[1:x]}else{matrix(d[1:d[x]],dimnames=NULL)}}

#> f(5)
#[1] "one"   "two"   "three" "four"  "five" 

#> f('five')
#     [,1]
#[1,]    1
#[2,]    2
#[3,]    3
#[4,]    4
#[5,]    5

Place les numéros dans un data.frame avec des numéros écrits en tant que noms de colonnes, ce qui facilite la conversion entre les deux (et l'impression ultérieure).

La principale tentative de golf consistait à créer les numéros écrits pour les 20-49 ans, probablement beaucoup plus que pour jouer au golf ici.

J'ai essayé as.matrixd'imprimer le data.frame avec seulement les nombres, mais il me reste un en-tête de matrice. J'espère que ça va.

Ungolfed:

ones <- c("","one","two","three","four","five","six","seven","eight","nine") 
teens <- c("ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen")
tens <- c("twenty","thirty","forty") 

p=""
for(i in tens){
  for(j in ones){
    p=paste0(p, i, j," ")
  }
}

nums <- 1:50
as.data.frame(t(nums))
names(nums) <- c(ones[-1], teens, as.vector(strsplit(p, " ")[[1]]), "fifty")
f <- function(x){
  if(is.numeric(x)){
    names(nums)[1:x]
  } else {
    matrix(nums[1:nums[x]], dimnames = NULL)
  }
}

C, 342 331 octets

char*x[]={"teen","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thir","four","fif","twenty","thirty","fourty","fifty"};void main(int z,char**i){for(z=1;z<=atoi(i[3]);z++)printf("%s%s%s\n",z<16?x[z]:z<20?z^18?x[z-10]:"eigh":x[z/10+14],z>20&&z%10?"-":z>12&&z<20?*x:"",z>20&&z%10?x[z%10]:"");}

Essayez-le en ligne!

SAS, 179

%macro c(n);%let f=words.;%if%length(&n)>2%then%do;%do c=1%to 50;%if%qsysfunc(putn(&c,&f))=&n%then%let n=&c;%end;%let f=2.;%end;%do i=1%to &n;%put%sysfunc(putn(&i,&f));%end;%mend;

La sortie est écrite dans le journal, séparée par des nouvelles lignes. SAS a un format intégré pour convertir les chiffres en mots, ce qui est un avantage majeur pour ce défi, mais il est ennuyeux de ne pas disposer d’informations permettant de faire l’inverse.