我想生成（作为函数的返回结果，或仅作为程序的输出）与数字连接的正整数的序数后缀。

样品：

1st  
2nd  
3rd  
4th  
...  
11th  
12th  
13th  
...  
20th  
21st
22nd
23rd
24th

依此类推，后缀每10个重复最初的1-10个子模式，直到100个，该模式最终重新开始。

输入将是数字，输出将是如上所示的序数字符串。

最小的算法是什么？

Perl，37个1个字符

s/1?\d\b/$&.((0,st,nd,rd)[$&]||th)/eg

这是一个正则表达式替换，它将适当的序数后缀附加到$_尚未跟有字母的任何数字之后。要将其应用于文件输入，请使用p命令行开关，如下所示：

perl -pe 's/1?\d\b/$&.((0,st,nd,rd)[$&]||th)/eg'

这是一个完整的Perl程序，可从stdin读取输入并将处理后的输出写入stdout。实际的代码长37个字符，但该p开关算作一个额外的字符。

输入样例：

This is the 1 line of the sample input...
...and this is the 2.
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
101 102 103 104 105 106 107 108 109 110

输出：

This is the 1st line of the sample input...
...and this is the 2nd.
1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th
11th 12th 13th 14th 15th 16th 17th 18th 19th 20th
21st 22nd 23rd 24th 25th 26th 27th 28th 29th 30th
101st 102nd 103rd 104th 105th 106th 107th 108th 109th 110th

已经跟随字母的数字将被忽略，因此通过过滤器再次提供输出不会改变它。数字之间的空格，逗号和句点没有特别处理，因此假定它们像其他标点符号一样分隔数字。因此，例如3.14159变为3rd.14159th。

它是如何工作的？

• 首先，这是全局regexp替换（s///g）。匹配的正则表达式为1?\d\b，其中\d匹配任何数字，并且\b是零宽度的断言，与字母数字字符和非字母数字字符之间的边界匹配。因此，1?\d\b匹配任何数字的最后一位，如果恰好是，则匹配前一位1。

• 在替换中，由于/e切换，该替换被评估为Perl代码，我们将匹配的字符串segment（$&）.加上后缀（）附加到后缀，该后缀通过将$&自身用作列表的整数索引而获得(0,st,nd,rd)；如果此后缀为零或未定义（即，当$&为零或大于三时），则||运算符用替换th。

编辑：如果输入限制为单个整数，则此35个字符的解决方案就足够了：

s/1?\d$/$&.((0,st,nd,rd)[$&]||th)/e

Python 2，49字节

lambda n:`n`+'tsnrhtdd'[n%5*(n%100^15>4>n%10)::4]

匿名函数。一个完整的程序将在55个字节计数。

'tsnrhtdd'[i::4]编码th st nd rd值i从0到3 的后缀。鉴于此，我们需要的是一种将的值映射n到相应后缀的索引的方法i。一个简单有效的表达式是(n%10)*(n%10<4 and 10<n%100<14)。我们可以通过删除第一组括号并观察n%5得出与特殊后缀n%10的值相同的结果来轻松缩短此时间n。反复尝试，一个也可能会缩短10<n%100<14为n%100^15>4，可以与另一个条件链接起来以节省更多字节。

Python，68个字符

i=input()
k=i%10
print"%d%s"%(i,"tsnrhtdd"[(i/10%10!=1)*(k<4)*k::4])

Mathematica 39 45字节

注意：在最新版本的Mathematica中，询问的nth部分p，其中pundefined不确定，会生成一条错误消息，但无论如何都会返回正确的答案。我已添加Quiet以防止打印错误消息。

Quiet@StringSplit[SpokenString[p[[#]]]][[2]]&

用法

Quiet@StringSplit[SpokenString[p[[#]]]][[2]] &[31]

31日

Quiet@StringSplit[SpokenString[p[[#]]]][[2]] &/@Range[21]

{“第1个”，“第2个”，“第3个”，“第4个”，“第5个”，“第6个”，“第7个”，“第8个”，“第9个”，“第10个”，“第11个”，“第12个”，“ 13“，” 14th“，” 15th“，” 16th“，” 17th“，” 18th“，” 19th“，” 20th“，” 21st“}

这个怎么运作

SpokenString写出任何可能有效的Mathematica表达式。以下是SpokenString文档中的两个示例，

SpokenString[Sqrt[x/(y + z)]]

“数量x超过数量y加z的平方根” *）

SpokenString[Graphics3D[Sphere[{{0, 0, 0}, {1, 1, 1}}]], "DetailedGraphics" -> True]

“由以0、0、0和1、1、1为中心的单位球面组成的三维图形”

现在，举个例子

Quiet@SpokenString[p[[#]]] &[31]

“ p的第31个元素”

让我们将上述字符串表示为单词列表：

StringSplit[%]

{“ the”，“ 31st”，“ element”，“ of”，“ p”}

并考虑第二个要素...

%[[2]]

31日

Ruby，60岁

它不如Perl入门，但我认为我会研究Ruby技能。

def o(n)n.to_s+%w{th st nd rd}[n/10%10==1||n%10>3?0:n%10]end

函数采用一个整数参数，n并以字符串形式返回字符串。

根据以下逻辑工作：
如果十位数为1或一个位数大于3，则使用后缀'th'；否则，使用最后一位作为索引，从数组['th'，'st'，'nd'，'rd']中找到后缀。

Javascript（ES6）50 44字节（非竞争）

a=>a+=[,"st","nd","rd"][a.match`1?.$`]||"th"

笔记

• 以imput作为字符串
• 删除了6个字节，谢谢@ user81655

Javascript 68 71

function o(n){return n+([,'st','nd','rd'][~~(n/10%10)-1?n%10:0]||'th')}

与itsCosmo共同努力。

编辑：无法正常使用数字> 100

Golfscript，34个字符

~.10/10%1=!1$10%*.4<*'thstndrd'2/=

Haskell，95个字符

h=foldr g"th".show
g '1'"th"="1st"
g '2'"th"="2nd"
g '3'"th"="3rd"
g '1'[x,_,_]='1':x:"th"
g a s=a:s

测试：

*Main> map h [1..40]
["1st","2nd","3rd","4th","5th","6th","7th","8th","9th","10th","11th","12th","13t
h","14th","15th","16th","17th","18th","19th","20th","21st","22nd","23rd","24th",
"25th","26th","27th","28th","29th","30th","31st","32nd","33rd","34th","35th","36
th","37th","38th","39th","40th"]

必须加载-XNoMonomorphismRestriction。

JavaScript，64个字符（ES3）或47个字符（ES6）

ES3（64个字符）：

function(n){return n+=[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'}

ES6（47个字符）：

n=>n+=[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'

说明

n % 100 >> 3 ^ 1对于n以数字08– 表示的任何正数结尾，该表达式的计算结果为0 15。因此，对于任何n mod 100结束在11，12或13，阵列查找返回undefined，导致的后缀th。

对于任何正n在其他数字比结局08- 15，表达式n % 100 >> 3 ^ 1计算结果为正整数，调用表达式n % 10为阵列查找，返回st，nd或rd用于n其端用1，2或3。否则，th。

APL（Dyalog Unicode）， 38 36字节

感谢ngn在维护字节数的同时修复了错误。

匿名默认前缀功能。需要将⎕IO（I ndex O rigin）设置为0，这在许多系统上都是默认设置。甚至适用于0！

⍕,{2↑'thstndrd'↓⍨2×⊃⍵⌽∊1 0 8\⊂10↑⍳4}

在线尝试！

{… } 匿名lambda；⍵是参数：

 ⍳4 前四个ɩ ndices;[0,1,2,3]

 10↑ 从中取前十个元素，并用零填充： [0,1,2,3,0,0,0,0,0,0]

 ⊂ 封闭视为单一要素； [[0,1,2,3,0,0,0,0,0,0]]

 1 0 8\ 扩展到一个副本，一个原型副本（全零），八个副本；
  [[0,1,2,3,0,0,0,0,0,0],
   [0,0,0,0,0,0,0,0,0,0],
   [0,1,2,3,0,0,0,0,0,0],
   [0,1,2,3,0,0,0,0,0,0],
   ⋮（另外5个）
   [0,1,2,3,0,0,0,0,0,0]]

 ∊ ε NLIST（扁平化）;
  [0,1,2,3,0,0,0,0,0,0,
   0,0,0,0,0,0,0,0,0,0,
   0,1,2,3,0,0,0,0,0,0,
   0,1,2,3,0,0,0,0,0,0,
   ⋮（另外50个）
   0,1,2,3,0,0,0,0,0,0]

 ⍵⌽ 循环向左旋转参数指定的步数

 ⊃ 选择第一个数字（即第100个mod-mod参数）

 2× 乘两个由（给出0，2，4，或6）

 'thstndrd'↓⍨从该字符串中删除那么多字符

 2↑ 取剩下的两个字符

⍕, 将字符串化参数连接到该字符串

PowerShell，92岁

process{"$_$(switch -r($_){"(?<!1)1$"{'st'}"(?<!1)2$"{'nd'}"(?<!1)3$"{'rd'}default{'th'}})"}

每行输入只能使用一个数字。输入是通过管道给出的。使它仅适用于单个数字并不会减小大小。

J-44个字符

J什么都没有？这真是令人发指！

(":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:])

解释（请注意，1在J中布尔值为true，0为false）：

• 10 10(...)/@#:]-首先，我们接受参数（]）并找到十位数和个位数（10 10 #:）。然后，我们将在(...)两者之间插入。
• (]*[(~:*])4>])-在此子表达式中（而不是最里面的子表达式）]将指向一位数字和[十位数。
• [(~:*])4>]- ~:是“不等于”的J，因此将结果4>]（即一位数字是否小于4）乘以结果tens ~: (4>])。为什么有人会这样做？考虑以下：
  • 如果我们正在检查10、11、12、13，tens则为1（我们处于十几岁）且ones小于4，因此tens ~: (4>])为false，结果为0*1= 0。
  • 如果我们是{X0，X1，X2，X3}中的任何其他人，那么显然tens ~: (4>])是正确的，我们得出1*1=1。
  • 如果ones大于4，然后4>]是0它不事会发生什么情况测试了，我们会得到0了不管。
  • 总结一下，[(~:*])4>]就是1我们是否在{X0，X1，X2，X3}中，但不在青少年中，0否则。
• ]*-最后，我们将结果乘以一个数字。因此，0如果该数字应加一个'th'后缀，则该产品将为它的值。
• th`st`nd`rd{::~-我们使用上方的修改后的一位索引后缀列表。0gets 'th'，1gets 'st'等。
• ":,-最后，获取原始数字，将其转换为字符串（":），然后将其添加到后缀之前。

用法很明显，尽管动词按原样只能接受一个序数，而不能接受一个列表。

   (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:]) 112         NB. single use
112th
   (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:]) 1 2 3 4 5   NB. doing it wrong
|length error
|       (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:])1 2 3 4 5
   NB. i.5 10   makes a 5x10 grid of increasing integers
   NB. &.>      to operate on each integer separately, and box the result after
   (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:])&.> i.5 10   NB. all better
+----+----+----+----+----+----+----+----+----+----+
|0th |1st |2nd |3rd |4th |5th |6th |7th |8th |9th |
+----+----+----+----+----+----+----+----+----+----+
|10th|11th|12th|13th|14th|15th|16th|17th|18th|19th|
+----+----+----+----+----+----+----+----+----+----+
|20th|21st|22nd|23rd|24th|25th|26th|27th|28th|29th|
+----+----+----+----+----+----+----+----+----+----+
|30th|31st|32nd|33rd|34th|35th|36th|37th|38th|39th|
+----+----+----+----+----+----+----+----+----+----+
|40th|41st|42nd|43rd|44th|45th|46th|47th|48th|49th|
+----+----+----+----+----+----+----+----+----+----+

C＃，62个字节

n=>n+(n/10%10==1||(n%=10)<1||n>3?"th":n<2?"st":n<3?"nd":"rd");

完整的程序和验证：

using System;

namespace OutputOrdinalNumbers
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,string>f= n=>n+(n/10%10==1||(n%=10)<1||n>3?"th":n<2?"st":n<3?"nd":"rd");

            for (int i=1; i<=124; i++)
                Console.WriteLine(f(i));
        }
    }
}

Mathematica 29 + 5 = 34字节

SpokenStringDump`SpeakOrdinal

+5个字节，因为Speak必须在使用此内置函数之前调用函数。

用法

SpokenStringDump`SpeakOrdinal[1]

"1st "

SpokenStringDump`SpeakOrdinal[4707]

"4,707th "

PHP 151

我知道该程序无法与其他程序相提并论。只是觉得自己想办法。

<?$s=explode(' ',trim(fgets(STDIN)));foreach($s as$n){echo$n;echo(int)(($n%100)/10)==1?'th':($n%10==1?'st':($n%10==2?'nd':($n%10==3?'rd':'th')))."\n";}

斯卡拉86

def x(n:Int)=n+{if(n%100/10==1)"th"else(("thstndrd"+"th"*6).sliding(2,2).toSeq(n%10))}

Scala 102：

def x(n:Int)=if((n%100)/10==1)n+"th"else if(n%10<4)n+("thstndrd".take(n+1)%5*2.drop(n%5*2))else n+"th"

102：

def x(n:Int)=if((n%100)/10==1)n+"th"else if(n%10<4)n+("thstndrd".sliding(2,2).toSeq(n%10))else n+"th"

松散：

def x (n: Int) =
  n + { if (((n % 100) / 10) == 1) "th" 
        else (("thstndrd"  + ("th"  * 6)).sliding (2, 2).toSeq (n % 10))
      }

OCaml

我对OCaml很陌生，但这是我能得到的最短的时间。

let n x =
   let v = x mod 100 and string_v = string_of_int x in
   let z = v mod 10 in
   if v=11 || v=12 || v=13 then string_v^"th" 
   else if v = 1 || z = 1 then string_v^"st" else if v = 2 || z = 2 then string_v^"nd" else if v = 3 || z = 3 then string_v^"rd" else string_v^"th";;

我创建了一个以数字为参数的函数n并完成了工作。它虽然很长，但是认为拥有一个实用的示例会很棒。

K-44个字符

碰巧这恰好与J一样长，并且工作方式几乎相同。

{x,$`th`st`nd`rd@{y*(y<4)*~1=x}.-2#0,.:'x$:}

解释：

• x$:-首先，我们将操作数x转换为字符串，然后将其分配回x。稍后我们将再次需要其字符串rep，因此现在可以保存字符。
• .:'-将.:每个（'）数字（）转换回一个数字。
• -2#0, -在数字列表的前面加上一个0（如果是一位数字），然后取最后两位。
• {y*(y<4)*~1=x}.-使用两位数作为该内部函数的参数x，如果小于4 且不等于1，则返回0，否则返回0。yyyx
• `th`st`nd`rd@ -通过该结果索引后缀列表。
• x,$ -将后缀从符号转换为字符串，并将其附加到原始数字之后。

用法：

  {x,$`th`st`nd`rd@{y*(y<4)*~1=x}.-2#0,.:'x$:} 3021
"3021st"
  {x,$`th`st`nd`rd@{y*(y<4)*~1=x}.-2#0,.:'x$:}' 1 2 3 4 11 12 13 14  /for each in list
("1st"
 "2nd"
 "3rd"
 "4th"
 "11th"
 "12th"
 "13th"
 "14th")

C- 95 83个字符

main(n,k){scanf("%d",&n);k=(n+9)%10;printf("%d%s\n",n,k<3?"st\0nd\0rd"+3*k:"th");}

已脱胶：

main(n,k)
{
    scanf("%d",&n);
    k=(n+9)%10; // xx1->0, xx2->1, xx3->2
    printf("%d%s\n",n,k<3?"st\0nd\0rd"+3*k:"th");
}

我们可以做k=(n-1)%10而不是加9，但是对于n = 0，我们将得到不正确的行为，因为在C中的(-1)%10计算结果为-1，而不是9。

Javascript，75

function s(i){return i+'thstndrd'.substr(~~(i/10%10)-1&&i%10<4?i%10*2:0,2)}

PHP，98字节

function c($n){$c=$n%100;$s=['','st','nd','rd'];echo$c>9&&$c<14||!$s[$c%10]?$n.'th':$n.$s[$c%10];}

11-13位在这里杀了我。适用于任何整数$n >= 0。

对于任何整数$n：

PHP，103字节

function c($n){$c=abs($n%100);$s=['','st','nd','rd'];echo$c>9&&$c<14||!$s[$c%10]?$n.'th':$n.$s[$c%10];}

Python，88 84字节

lambda x:x+((('th','st','nd','rd')+('th',)*6)[int(x[-1])]if('0'+x)[-2]!='1'else'th')

取消高尔夫：

def y(x):
    return x + (('th', 'st', 'nd', 'rd') + ('th', ) * 6)[int(x[-1])] if ('0' + x)[-2] != '1' else 'th')

lambda x用参数定义一个匿名函数x。((('th','st','nd','rd')+('th',)*6)[int(x[-1])]为小于10的数字定义结尾的元组，为的0-th元素0，依此类推。在if ('0'+x)[-2] != '1'检查是否存在11，12或13以修复，并将然后else 'th'添加th代替st，rd或nd。

JavaScript（Node.js），51字节

感谢@KevinCruijssen改善了答案

n=>n+=[,'st','nd','rd'][~~(n/10%10)-1?n%10:0]||'th'

在线尝试！

说明：

n =>                      // input
    n+=[,'st','nd','rd']     // the array of suffices add everything to n
        [~~(n/10%10)-1?n%10:0] // the full magic 
    || 'th'               // works for everything except 1 , 2 , 3 just like what you want

R，79 76字节

由于还没有R解决方案...这里没有技巧，基本的矢量索引在Giuseppe的帮助下减少了3个字符。先前尝试过的索引：[1+(x%%10)-(x%%100==11)]和[1+(x%%10)*(x%%100!=11)]。

function(x)paste0(x,c("th","st","nd","rd",rep("th",6))[1+x%%10*!x%%100==11])

在线尝试！

含substr，79个字节：

function(x,y=1+2*min(x%%10-(x%%100==11),4))paste0(x,substr("thstndrdth",y,y+1))

在线尝试！

Python 2.7，137个字符

def b(n):
 for e,o in[[i,'th']for i in['11','12','13']+list('4567890')]+[['2','nd'],['1','st'],['3','rd']]:
  if n.endswith(e):return n+o

n 应该是一个字符串

我知道我已经在这里赢得比赛了，但是我想我还是会提出我的想法

这基本上只是生成一个键列表，键值对以数字（作为字符串）结尾e和序号o。它尝试首先匹配“ th”（因此为什么我不使用字典），以便它不会偶然返回“ st”，例如，当它应为“ th”时。这将适用于任何正整数

C：95个字符

一个荒唐的解决方案：

n;main(){scanf("%d",&n);printf("%d%s",n,n/10%10-1&&(n=n%10)<4&&n?n>2?"rd":n<2?"st":"nd":"th");}

它需要更多地修改。

Javascript，75

function o(s){return s+((0|s/10%10)==1?"th":[,"st","nd","rd"][s%10]||"th")}

Oracle SQL 11.2，101字节

SELECT:1||DECODE(ROUND(MOD(:1,100),-1),10,'th',DECODE(MOD(:1,10),1,'st',2,'nd',3,'rd','th'))FROM DUAL

Javascript ES6，52个字符

n=>n+(!/1.$/.test(--n)&&'snr'[n%=10]+'tdd'[n]||'th')