CodeGolf挑战

PWSSHHHH！您在3000年的一个低温实验室中醒来。在押送至任务分配办公室以接收您的职业筹码（大概是送货员的职业筹码）后，探针会检测到您来自2000年。刻板印象，与当今的现代人相比，你被认为是愚蠢的，被迫重读小学。

您进入一年级教室，老师正在做作业。她会说或写一个不超过50的数字。如果她在黑板上写下该数字（例如：25），那么您必须说不超过该数字的数字“ 1、2、3，...，25 ”。如果她大声说出数字（例如：“六个”），则必须在平板电脑上将数字写成最大为“ 1、2、3、4、5、6”

这变得非常乏味，您决定使用仍在运行的21世纪原始编程知识来自动化该过程。

目的：

您的程序应该接受输入。该输入将是十进制数字（1 thru 50）或写出数字（one thru fifty）。

•如果输入为十进制数字，则您的输出应使用写出样式从一到该数字进行计数。（例如32个）

•如果输入是写出的数字，则您的输出应使用小数形式从1计数到该数字。（例如32）

规则：

输入和输出可以在您选择的任何情况下使用（因此，如果需要，您可以制作一个仅接受大写字母的程序）。

输入的十进制数字不必是数字类型（例如int），它们可以是包含数字的输入字符串（25对“ 25”）。两种都很好，您可以选择要让程序接受的一种。（您的程序无需同时接受两者）

书面样式不需要复合词之间的连字符，但是如果需要，可以。

输出值必须以某种形式分隔，任何分隔符都可以 1,2,3 1 2 3 etc

您不能添加额外的库，例如num2words（python）等（但是系统库也可以）

即使背景故事说您来自2000年，您也可以使用在该日期之后创建的语言（lol）

这是代码高尔夫球，因此字节数最短的程序将获胜！

Perl 6的，119个 113字节

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

Unicode数据库FTW！

使用不带连字符的大写字母数字，例如TWENTYTWO。
返回字符串列表或数字范围。（当使用时，都使用空格作为分隔符put。）

Python3 276 271 269 243 237 235 232 217字节

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

我怀疑它可能会打得更远一些。

它利用系统库unicodedata来查找数字的名称。它要求使用大写数字名称（以空格分隔FORTY TWO）或十进制整数作为输入。

（这是我第一次提交高尔夫球代码。）

（我还注意到我在错误地计算了长度（编码），所以它比以前认为的少了几个字节。不过，我只更新了最新的字节数。糟糕。）

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

细节

(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 ~]是一个开关，基于下一个可用参数的值，它会跳到适当的子控件格式。在这里，我只有一个大小写为“ 0”，并且为“ else”。由于U从零开始，因此用于在除第一个数字之外的每个数字之前插入分隔符。

• ~:[ FALSE ~; TRUE ~]是条件格式；在这里，无论输入s是否为字符串，我们输出的内容都不同。

• ~R写一个数字作为基数英文数字，​​而~D只打印数字。

例子

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字节

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

感谢Kritixi Lithos提出了拆分数组的想法，并感谢Arnauld提出了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字节

-5感谢@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)

在线尝试！

输入数字或数字的空格分隔拼写。

略少打高尔夫球，更易读的版本：

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)

计划，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)))))))

未压缩：

(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字节

受TomDevs的JS解决方案启发

替换$a=[...]为节省了25个字节$a=explode(...)

teen@ user59178，通过切换回没有字符串定界符的数组并存储在变量中，又节省了23个字节

删除(int)类型转换，另外节省了5个字节

通过删除保存的另外15个字节$b，则$i在for为@ user59178再次声明，并花括号，谢谢

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

松散

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

尝试输入字符串或输入数字

Python 2，262字节

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

代表

输入和输出字符串为小写字母并已连接*，因此要测试字符串输入，请"thirtyfive"在提示时输入。

构建所有单词的列表（"fiftyone"加到"fiftynine"），x然后测试是否input是带有代理的单词v>50（字符串大于Python 2中的数字，并且在规范中有效输入范围内的所有数字均为<=50），并且prints通过切片列表x[:v]或构建整数范围来获取值range(1,x.index(v)+2)。

*用替换a+"ty"b为两者都加上连字号需要11个字节a+"ty"+'-'*(b>'')+b。

Wolfram语言，92个字节

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

（我是新来的，如果做错了事，请告诉我）

JavaScript（ES6），261个字节

注意：分配给z的字符串使用编码atob。编码的字符串中有11个字节，即使它们是JavaScript字符串中的有效字符，也无法发布到此站点。因此，我使用了\ xHH格式的十六进制转义符。这些转义中的每一个都计为1个字节。
原始的未压缩弦是打高尔夫球较少的版本。

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

少打高尔夫球

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

测试

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字节

在@ nedla2004的建议下转换为Python 3。现在在输入或输出的书面数字之间也没有空格，例如输入22

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)

在线尝试3！

Python 2中，327个 320 313 308字节

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

在线尝试2！

163 170 177个字节比我的原始答案短，因此我将其发布为替代方法。这将for在两个列表上使用以构建所有数字字符串表示形式的完整列表，然后在列表中标识正确的列表，并按值或按索引显示所有内容。为每个值输出一个新行。

Python 2中，432个422 416 403字节

我相信这可以改善。至少如果我可以对要处理的值进行硬编码而不需要使用函数，那么我可以节省20。它需要一个空格来分隔文本输入中的单词。感谢JonathanAllan对ElPedro的回答的评论，节省了6个字节，其中4个用于重新排列数学。

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

（注意：此版本的实际版本使用制表符而不是空格来缩进。QPaysTaxes添加了一个空格，因为该空格不能正确呈现，以确保给定的代码可以编译。它不应更改字节数。）

C ++ 11，484个 480 477字节

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

小写字母输入，不带连字符。

PowerShell，362字节

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

在线尝试！单词输入或数字输入

这是一个正确的烂摊子，我对此并不十分满意，但事实确实如此。欢迎打高尔夫球。

第一行设置$z为完整英语单词的数组。你可以看到-split0的数字1来12，循环，构建所有的teens，然后有把一切一堆逻辑的共同权利。在线尝试！

第二行以某种逻辑开始。我们将输入$args（作为字符串）输入-split到空格，将其存储$n以供以后使用，获取第一个[0]单词和第一个[0]字符，并检查它是否-in是范围48..57（即ASCII 0到9）。因此，我们正在检查是否有十进制输入或英文输入。在线尝试！

在第一种情况下，我们基于小数输入构建​​一个范围，$n[0]..$n[2]并使用该范围索引到$z[...]。在另一种情况下，我们找到第.indexOf()一个单词和最后一个单词，并以此建立一个数字范围。无论哪种情况，我们现在在管道上都有一个对象数组（字符串或整数），并且Write-Output在程序完成时隐式提供了元素之间的换行符。

Swift3，402个字节

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

取消高尔夫：

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

这里没什么特别的，只是使用数组来备份已写出的数字。

我最初以为这种解决方案使用其他方式来计算values数组：

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

可以打到：

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

替换高尔夫球代码中的第三行

我本可以得分381个字节，但是有一个编译器错误，上面写着：“表达式太复杂，无法在合理的时间内解决”，有关错误的更多信息，请参见此处。

R，452 430 424个字节

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

将这些数字放置在data.frame中，并用写出的数字作为列名，这使两者之间的转换（以及随后的打印）非常容易。

打高尔夫球的主要尝试是为20-49创建写出的数字，这可能对这里的高尔夫而言要大得多。

我尝试as.matrix仅用数字打印data.frame，但仍然留下矩阵标题。希望没关系。

取消高尔夫：

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，342331字节

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

在线尝试！

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;

输出被写入换行符分隔的日志中。SAS具有用于将数字转换为单词的内置格式，这是此挑战的主要优势，但令人讨厌的是，它缺少进行反向操作的信息。