Wyzwanie CodeGolf

PWSSHHHH! Budzisz się w laboratorium kriogenicznym w 3000 roku. Po eskortowaniu do biura zadań, aby otrzymać chip kariery, prawdopodobnie od chłopca z dostawy, sonda wykrywa, że ​​jesteś od 2000 roku. Z tego powodu i kilku stereotypy, jesteś głupi w porównaniu z dzisiejszym współczesnym człowiekiem i zmuszony jesteś powtarzać klasę.

Wchodzisz do swojej pierwszej klasy, a nauczyciel daje zadanie. Ona powie lub napisze liczbę do 50. Jeśli zapisze numer na tablicy (na przykład: 25), musisz podać liczby do tej liczby „jeden, dwa, trzy, ..., dwadzieścia pięć „. Jeśli powie głośno liczbę (na przykład „sześć”), wówczas na tablecie musisz wpisać liczby do tej liczby „1, 2, 3, 4, 5, 6”

To staje się bardzo żmudne i decydujesz, że zautomatyzujesz ten proces za pomocą wciąż działającej, ale archaicznej wiedzy programistycznej XXI wieku.

Cel:

Twój program powinien wziąć udział. Będzie to albo liczba dziesiętna ( 1 thru 50), albo liczba zapisana ( one thru fifty).

• Jeśli wprowadzana liczba jest liczbą dziesiętną, wynik powinien liczyć się od jednej do tej liczby, używając stylu zapisanego. (np. trzydzieści dwa )

• Jeśli wejście jest liczbą zapisaną, wynik powinien liczyć się od 1 do tej liczby, używając stylu dziesiętnego. (np. 32 )

Zasady:

Dane wejściowe i wyjściowe mogą być w każdym wybranym przez Ciebie przypadku (możesz więc stworzyć program, który akceptuje wielkie litery tylko w razie potrzeby).

Wprowadzane liczby dziesiętne nie muszą być typu liczbowego (np. Int), mogą być łańcuchem wejściowym zawierającym liczby (25 vs „25”). Oba są w porządku i możesz wybrać, który program ma zaakceptować. (Twój program nie musi akceptować obu)

Zapisany styl NIE wymaga łącznika między słowami złożonymi, ale możesz w razie potrzeby.

Wartości wyjściowe muszą być oddzielone w jakiejś formie, każdy separator jest w porządku 1,2,3 1 2 3 etc

Nie można dodawać dodatkowych bibliotek, takich jak num2words (python) itp. (Jednak biblioteki systemowe są w porządku)

Mimo że historia mówi, że pochodzisz z 2000 roku, możesz używać języków utworzonych po tej dacie (LOL)

To jest golf golfowy , więc wygrywa program z najkrótszą liczbą bajtów!

Perl 6 , 119 113 bajtów

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

Baza danych Unicode FTW!

Wykorzystuje wypisane wielkie litery bez myślnika, np TWENTYTWO.
Zwraca listę ciągów znaków lub zakres liczb. (Oba używają spacji jako separatora po wydrukowaniu za pomocą put.)

Python3, 276 271 269 243 237 235 232 217 bajtów

Biorąc pod uwagę przesłanie perla @smls ...

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

Podejrzewam, że może być nieco bardziej golfa.

Wykorzystuje bibliotekę systemową unicodedatado wyszukiwania nazw numerów. Wymaga to wprowadzania nazw wielkich liter (oddzielonych spacją FORTY TWO:) lub liczb całkowitych dziesiętnych jako danych wejściowych.

(To jest mój pierwszy kod golfowy.)

(Właśnie zauważyłem, że źle przeliczyłem długość (kodowanie), więc jest to kilka bajtów mniej niż wcześniej sądziłem. Jednak zaktualizowałem tylko najnowszą liczbę bajtów. Ups.)

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

Detale

(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 ~]to przełącznik oparty na wartości następnego dostępnego argumentu, który przeskakuje do odpowiedniego formatu kontrolki podrzędnej. Tutaj mam tylko przypadek „0” i „else”. Służy do wstawiania separatora przed każdą liczbą oprócz pierwszej, dzięki U zaczynając od zera.

• ~:[ FALSE ~; TRUE ~]jest formatem warunkowym; tutaj wypisujemy różne rzeczy, niezależnie od tego, czy dane wejściowe s są ciągiem znaków, czy nie.

• ~Rnapisz liczbę jako główny numer angielski, a ~Dpo prostu wydrukuj liczbę.

Przykłady

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 bajtów

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

Podziękowania dla Kritixi Lithos za pomysł podzielenia tablicy i Arnaulda za sztuczkę 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 bajtów

-5 dzięki dzięki @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)

Wypróbuj online!

Wprowadź liczbę lub pisownię liczby oddzieloną spacją.

Nieco mniej golfowa i bardziej czytelna wersja:

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)

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

Nieskompresowane:

(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 bajtów

Zainspirowany rozwiązaniem JS TomDevs

Zaoszczędzono 25 bajtów, zastępując $a=[...]przez$a=explode(...)

Zaoszczędzono kolejne 23 bajty, przełączając się z powrotem do tablicy bez ograniczników ciągów i przechowując teenw zmiennej dzięki @ user59178

Zaoszczędzono kolejne 5 bajtów, usuwając (int)rzutowanie czcionek

Zapisano kolejne 15 bajtów, upuszczając $b , $iw fordeklaracjach i nawiasach klamrowych, dzięki @ user59178 ponownie

$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++.' ';

Nie golfowany:

$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++ . ' ';

Wypróbuj dla ciągu wejściowego lub dla numeru wejściowego

Python 2, 262 bajty

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

Ciągi wejściowe i wyjściowe są pisane małymi literami i łączone *, więc aby przetestować ciąg wejściowy, wpisz na przykład: "thirtyfive" monit.

Tworzy listę wszystkich słów (od plus "fiftyone"do "fiftynine"), xa następnie sprawdza, czy inputjest to słowo z proxy v>50(łańcuchy są większe niż liczby w Pythonie 2, a wszystkie liczby w prawidłowym zakresie wejściowym ze specyfikacji są <=50) i prints odpowiednie wartości przez wycięcie listy,x[:v] lub budując zakres liczb całkowitych,range(1,x.index(v)+2) .

* Dodanie dzielenia wyrazów dla obu kosztuje 11 bajtów, zastępując a+"ty"bje a+"ty"+'-'*(b>'')+b.

Wolfram Language, 92 bajty

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

(Jestem nowy, daj mi znać, jeśli zrobiłem coś złego)

JavaScript (ES6), 261 bajtów

Uwaga: ciąg przypisany do z jest kodowany za pomocą atob. W zakodowanym ciągu znajduje się 11 bajtów, których nie mogę opublikować na tej stronie, nawet jeśli są one poprawnymi znakami w ciągu javascript. Użyłem więc ucieczki heksadecymalnej w postaci \ xHH. Każda z tych ucieczek jest liczona jako 1 bajt.
Oryginalny nieskompresowany ciąg jest wersją mniej golfową .

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

Mniej golfa

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

Test

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 bajtów

Konwersja do Python 3 po porady od @ nedla2004. Teraz nie ma również spacji między wpisanymi liczbami na wejściu lub wyjściu, np. Wpisz twentytwo

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)

Wypróbuj online 3!

Python 2 , 327 320 313 308 bajtów

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

Wypróbuj online 2!

163 170 177 bajtów krótszych niż moja pierwotna odpowiedź, więc zamieszczam ją jako alternatywę. Wykorzystuje to forna dwóch listach, aby zbudować pełną listę wszystkich reprezentacji ciągów liczb, a następnie identyfikuje właściwą na liście i drukuje wszystko do niej według wartości lub według indeksu. Wysyła nowy wiersz dla każdej wartości.

Python 2, 432 422 416 403 bajtów

Jestem pewien, że można to poprawić. Przynajmniej jeśli uda mi się na stałe zakodować wartość, nad którą pracuję, i nie potrzebuję żadnej funkcji, mogę zapisać 20. Potrzebuje miejsca do oddzielenia słów podczas wprowadzania tekstu. Zaoszczędzono 6 bajtów dzięki komentarzowi JonathanAllan do odpowiedzi ElPedro, 4 za przestawienie matematyki.

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

(Uwaga: rzeczywista wersja tego używa tabulacji do wcięcia zamiast spacji. QPaysTaxes dodała jedną spację, ponieważ nie wyświetlała się poprawnie, aby zapewnić, że dany kod się skompiluje. Nie powinna zmieniać liczby bajtów.)

C ++ 11, 484 480 477 bajtów

#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<<" ";}

Wprowadzanie tekstu małymi literami bez myślników.

PowerShell , 362 bajty

$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])}

Wypróbuj online! wprowadzanie słów lub wprowadzanie liczb

To dobry bałagan i nie jestem z tego powodu bardzo zadowolony, ale oto jest. Sugestie dotyczące gry w golfa mile widziane.

Pierwszy wiersz $zjest tablicą pełnych angielskich słów. Możesz zobaczyć -split0numery for1 do 12i pętla do skonstruowania wszystkie teens, a następnie istnieje grono logiki umieścić wszystko razem dobrze. Wypróbuj online!

Druga linia zaczyna się od logiki. Bierzemy dane wejściowe $args(jako ciąg znaków), umieszczamy -splitje na białej spacji, przechowujemy w $ncelu późniejszego użycia, bierzemy pierwsze [0]słowo i pierwszy [0]znak tego i sprawdzamy, czy jest -into zakres 48..57(tj. ASCII 0do 9). Sprawdzamy więc, czy mamy dane dziesiętne, czy angielskie. Wypróbuj online!

W pierwszym przypadku budujemy zakres na podstawie danych dziesiętnych $n[0]..$n[2]i używamy go do indeksowania $z[...]. W drugim przypadku znajdujemy .indexOf()pierwsze słowo i ostatnie słowo i na tej podstawie budujemy tylko zakres liczbowy. W obu przypadkach mamy teraz szereg obiektów w potoku (ciągi lub liczby całkowite), a domniemane Write-Outputzakończenie programu daje nam nową linię między elementami.

Swift3, 402 bajtów

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

Nie golfowany:

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

Nie ma tu nic specjalnego, wystarczy użyć tablicy do utworzenia zapisanych liczb.

Początkowo myślałem, że to rozwiązanie przy użyciu innego sposobu obliczania valuestablicy:

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

Które można golfować do:

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

zastępując trzecią linię w kodzie golfowym

Mogłem zdobyć 381 bajtów, ale istnieje błąd kompilatora, który mówi: „wyrażenie było zbyt złożone, aby można je było rozwiązać w rozsądnym czasie”, więcej informacji na temat błędu można znaleźć tutaj

R, 452 430 424 bajtów

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

Umieszcza liczby w ramce danych z wypisanymi liczbami jako nazwami kolumn, dzięki czemu tłumaczenie między nimi (i późniejszym drukowaniem) jest bardzo łatwe.

Główną próbą gry w golfa było stworzenie spisanych liczb dla 20-49, prawdopodobnie o wiele więcej tutaj.

as.matrixPodjąłem próbę wydrukowania data.frame z samych liczb, ale nadal mam nagłówek matrycy. Mam nadzieję, że to w porządku.

Nie golfowany:

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

DO, 342 331 bajtów

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]:"");}

Wypróbuj online!

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;

Dane wyjściowe są zapisywane w dzienniku oddzielone znakami nowej linii. SAS ma wbudowany format do konwersji cyfr na słowa, co jest główną zaletą tego wyzwania, ale irytująco brakuje mu informacji, aby zrobić odwrotnie.