Ich möchte (als Ergebnis einer Funktion oder einfach als Ausgabe eines Programms) das Ordnungssuffix einer positiven Ganzzahl erzeugen, die mit der Zahl verkettet ist.

Proben:

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

Und so weiter, mit dem Suffix, das alle 10 bis 100 das erste Untermuster von 1 bis 10 wiederholt, wo das Muster schließlich von vorne beginnt.

Die Eingabe wäre die Zahl und die Ausgabe die Ordnungszahl wie oben gezeigt.

Was ist der kleinste Algorithmus dafür?

Perl, 37 + 1 Zeichen

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

Hierbei handelt es sich um eine reguläre Ausdrücke-Ersetzung, bei der den Zahlen, auf $_die noch kein Buchstabe folgt, das entsprechende Ordnungssuffix angehängt wird . Verwenden Sie die pBefehlszeilenoption wie folgt, um sie auf die Dateieingabe anzuwenden :

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

Dies ist ein vollständiges Perl-Programm, das Eingaben aus stdin liest und die verarbeitete Ausgabe in stdout schreibt. Der tatsächliche Code ist 37 Zeichen lang, aber der pSchalter zählt als ein zusätzliches Zeichen .

Beispieleingabe:

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

Ausgabe:

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

Zahlen, auf die bereits Buchstaben folgen, werden ignoriert. Wenn Sie also die Ausgabe erneut durch den Filter führen, wird dies nicht geändert. Leerzeichen, Kommas und Punkte zwischen Zahlen werden nicht speziell behandelt, daher wird davon ausgegangen, dass sie Zahlen wie jede andere Interpunktion trennen. So zB 3.14159wird 3rd.14159th.

Wie funktioniert es?

• Erstens ist dies ein globaler regulärer Ausdruck ( s///g). Die regexp wird abgestimmt ist 1?\d\b, in dem \dübereinstimmt jede Ziffer und \beine Null-Breite Assertion die Grenze zwischen einem alphanumerischen passenden und einem nicht-alphanumerischen Zeichen. Somit 1?\d\bentspricht die letzte Ziffer einer beliebigen Zahl, plus die vorherige Stelle , wenn es passiert zu sein 1.

• In der Ersetzung, die aufgrund des /eSwitches als Perl-Code ausgewertet wird , nehmen wir das übereinstimmende Zeichenfolgensegment ( $&) und hängen ( .) das Suffix an, das sich $&selbst als ganzzahliger Index für die Liste ergibt (0,st,nd,rd). Wenn dieses Suffix Null oder undefiniert ist (dh wenn $&Null oder größer als Drei ist), ersetzt der ||Operator es durch th.

Bearbeiten: Wenn die Eingabe auf eine einzelne Ganzzahl beschränkt ist, reicht diese 35-stellige Lösung aus:

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

Python 2, 49 Bytes

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

Eine anonyme Funktion. Ein volles Programm würde mit 55 Bytes gezählt.

'tsnrhtdd'[i::4]codiert die Suffixe th st nd rdfür Werte ivon 0 bis 3. Vor diesem Hintergrund ist es nur erforderlich, die Werte von nauf den Index des entsprechenden Suffixes abzubilden i. Ein klarer Ausdruck, der funktioniert, ist (n%10)*(n%10<4 and 10<n%100<14). Wir können dies leicht verkürzen, indem wir den ersten Satz von Klammern fallen lassen und beobachten, dass sich n%5dieselben Ergebnisse ergeben wie n%10für die Werte nmit den speziellen Suffixen. Mit einem bisschen von Versuch und Irrtum kann man verkürzen auch 10<n%100<14zu n%100^15>4, die mit den anderen bedingten verkettet werden können , um noch mehr zu sparen Bytes.

Python, 68 Zeichen

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

Mathematica 39 45 Bytes

Hinweis: In neueren Versionen von Mathematica wird bei der Abfrage des nthTeils von p, wo nicht pdefiniert, eine Fehlermeldung generiert, die richtige Antwort wird jedoch trotzdem zurückgegeben. Ich habe hinzugefügt Quiet, um zu verhindern, dass die Fehlermeldung gedruckt wird.

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

Verwendungszweck

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

31st

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

{"1.", "2.", "3.", "4.", "5.", "6.", "7.", "8.", "9.", "10.", "11.", "12." 13., 14., 15., 16., 17., 18., 19., 20., 21.}

Wie es funktioniert

SpokenStringSchreibt einen gültigen Mathematica-Ausdruck aus, wie er gesprochen werden könnte. Nachfolgend finden Sie zwei Beispiele aus der Dokumentation für SpokenString :

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

"Quadratwurzel der Menge x über der Menge y plus z" *)

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

eine dreidimensionale Grafik, die aus Einheitskugeln besteht, die bei 0, 0, 0 und 1, 1, 1 zentriert sind

Nun zum vorliegenden Beispiel:

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

"das 31. Element von p"

Lassen Sie uns die obige Zeichenfolge als eine Liste von Wörtern darstellen:

StringSplit[%]

{"das", "31.", "Element", "von", "p"}

und nimm das zweite Element ...

%[[2]]

31st

Rubin, 60

Es ist nicht so gut wie der Perl-Eintrag, aber ich dachte, ich würde an meinen Ruby-Fähigkeiten arbeiten.

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

Function akzeptiert ein ganzzahliges Argument nund gibt eine Zeichenfolge als Ordnungszahl zurück.

Funktioniert nach der folgenden Logik:
Wenn die Zehnerstelle eine 1 ist oder die Einerstelle größer als 3 ist, verwenden Sie das Suffix 'th'; Andernfalls suchen Sie das Suffix aus dem Array ['th', 'st', 'nd', 'rd'] mit der letzten Ziffer als Index.

Javascript (ES6) 50 44 Bytes (nicht konkurrierend)

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

Anmerkungen

• Nimmt den Input als String
• 6 Bytes entfernt, danke @ user81655

Javascript, 68 71

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

Gemeinsame Anstrengung mit ItsCosmo.

BEARBEITEN: Funktionierte nicht richtig mit Zahlen> 100

Golfscript, 34 Zeichen

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

Haskell, 95 Zeichen

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

Testen:

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

Muss mit -XNoMonomorphismRestriction geladen werden.

JavaScript, 64 Zeichen (ES3) oder 47 Zeichen (ES6)

ES3 (64 Zeichen):

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

ES6 (47 Zeichen):

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

Erläuterung

Der Ausdruck wird n % 100 >> 3 ^ 1für alle positiven nEndungen mit Ziffern 08- mit 0 bewertet 15. So kann jede n mod 100endet in 11, 12, oder 13, die Rendite Lookup - Array undefined, was zu einem Suffix th.

Für jede positive nEnde in anderen Stellen als 08- 15die Expressions n % 100 >> 3 ^ 1auswertet auf eine positive ganze Zahl ist , die Expression Aufruf n % 10für Array - Lookup, Return st, ndoder rdfür nderen Enden mit 1, 2, oder 3. Ansonsten th.

APL (Dyalog Unicode) , 38 36 Bytes

Vielen Dank an ngn für die Behebung eines Fehlers bei gleichzeitiger Beibehaltung der Byteanzahl.

Anonyme implizite Präfixfunktion. Requires ⎕IO( I ndex O rigin) auf gesetzt 0, was bei vielen Systemen Standard ist. Funktioniert sogar für 0!

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

Probieren Sie es online!

{… } Anonymes Lambda; ⍵ist Argument:

 ⍳4 ersten vier ɩ ndices;[0,1,2,3]

 10↑ Nimm die ersten zehn Elemente davon und fülle sie mit Nullen auf: [0,1,2,3,0,0,0,0,0,0]

 ⊂ umschließen, um als einzelnes Element zu behandeln; [[0,1,2,3,0,0,0,0,0,0]]

 1 0 8\ Erweitern auf eine Kopie, eine prototypische Kopie (alle null), acht Kopien;
  [[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 weitere)
   [0,1,2,3,0,0,0,0,0,0]]

 ∊ ϵ nlist (Abflachen);
  [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 weitere)
   0,1,2,3,0,0,0,0,0,0]

 ⍵⌽ Drehe zyklisch so viele Schritte nach links, wie das Argument angibt

 ⊃ wähle die erste Zahl (dh die argument-mod-100'te Zahl)

 2× multiplizieren zwei davon (gibt 0, 2, 4, oder 6)

 'thstndrd'↓⍨Löschen Sie so viele Zeichen aus dieser Zeichenfolge

 2↑ nimm die ersten zwei der verbleibenden Charaktere

⍕, verketten das stringifizierte Argument dazu

PowerShell, 92

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

Arbeitet mit einer Nummer pro Eingabezeile. Die Eingabe erfolgt über die Pipeline. Wenn es nur für eine einzelne Zahl funktioniert, wird die Größe nicht reduziert.

J - 44 Zeichen

Nichts in J? Das ist ein Skandal!

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

Erklärt (beachten Sie, dass 1in J boolescher Wert true und 0false ist):

• 10 10(...)/@#:]- Zuerst nehmen wir das Argument ( ]) und finden die Zehner- und Einerstelle ( 10 10 #:). Dann werden wir (...)zwischen den beiden einfügen .
• (]*[(~:*])4>])- In diesem Unterausdruck, aber nicht im innersten, ]wird auf die Einerstelle und [die Zehnerstelle gezeigt.
• [(~:*])4>]- ~:Ist J für "nicht gleich", so nimmt dies das Ergebnis von 4>](dh ob die eine Ziffer kleiner als 4 ist oder nicht) und multipliziert es mit dem Ergebnis von tens ~: (4>]). Warum sollte jemand das tun? Folgendes berücksichtigen:
  • Wenn wir 10, 11, 12, 13 überprüfen, dann tensist 1(wir sind im Teenageralter) und onesist kleiner als 4, tens ~: (4>])ist also falsch und das Ergebnis ist 0*1= 0.
  • Wenn wir irgendein anderes von {X0, X1, X2, X3} sind, dann tens ~: (4>])ist dies eindeutig wahr und wir steigen aus 1*1= 1.
  • Wenn onesgrößer als vier ist, dann 4>]war 0und es egal ist, was mit dem Test passiert, werden wir trotzdem 0rauskommen.
  • Zusammenfassend lässt [(~:*])4>]sich 1sagen, ob wir uns in {X0, X1, X2, X3} befinden, aber nicht im Teenageralter und 0ansonsten.
• ]*- Schließlich multiplizieren wir dieses Ergebnis mit der Einerstelle. So wird dieses Produkt sein, 0wenn die Zahl ein 'th'Suffix verdient , sonst seinen Wert.
• th`st`nd`rd{::~- Wir verwenden die modifizierte Einerstelle von oben, um die Liste der Suffixe zu indizieren. 0bekommt 'th', 1bekommt 'st'und so weiter.
• ":,- Nehmen Sie zum Schluss die ursprüngliche Nummer, konvertieren Sie sie in eine Zeichenfolge ( ":) und stellen Sie sie vor das Suffix.

Die Verwendung ist offensichtlich, obwohl das Verb wie es ist nur eine Ordnungszahl annehmen kann, keine Liste.

   (":,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 Bytes

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

Vollständiges Programm und Überprüfung:

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 Bytes

SpokenStringDump`SpeakOrdinal

+5 Byte, da die SpeakFunktion aufgerufen werden muss, bevor diese integrierte Funktion verwendet werden kann.

Verwendungszweck

SpokenStringDump`SpeakOrdinal[1]

"1st "

SpokenStringDump`SpeakOrdinal[4707]

"4,707th "

PHP, 151

Ich weiß, dass dieses Programm nicht mit den anderen vergleichbar ist. Ich wollte nur eine Lösung finden.

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

Scala 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 auch:

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"

ungolfed:

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

OCaml

Ich bin ziemlich neu in OCaml, aber dies ist die kürzeste, die ich bekommen konnte.

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

Ich habe eine Funktion n erstellt, die eine Zahl als Parameter verwendet und die Arbeit erledigt. Es ist lang, aber ich dachte, es wäre großartig, ein funktionales Beispiel zu haben.

K - 44 Zeichen

Es kommt also vor, dass dies genau so lang ist wie das J und fast genauso funktioniert.

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

Erklärt:

• x$:- Zuerst konvertieren wir den Operanden xin einen String und weisen diesen dann wieder zu x. Wir werden die Zeichenfolgenwiederholung später noch einmal benötigen. Dadurch werden jetzt Zeichen gespeichert.
• .:'- Wandle ( .:) jede ( ') Ziffer zurück in eine Zahl.
• -2#0, - Fügen Sie der Ziffernliste eine 0 voran (bei einstelligen Zahlen) und nehmen Sie dann die letzten beiden.
• {y*(y<4)*~1=x}.- Verwenden Sie die beiden Ziffern als Argumente xund yfür diese innere Funktion, die zurückgibt, ywenn ykleiner als 4 und xnicht gleich 1 ist, andernfalls 0.
• `th`st`nd`rd@ - Indizieren Sie die Liste der Suffixe nach diesem Ergebnis.
• x,$ - Konvertieren Sie das Suffix von symbol in string und hängen Sie es an die ursprüngliche Nummer an.

Verwendungszweck:

  {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 Zeichen

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

Entgolfet:

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

Wir könnten tun, k=(n-1)%10anstatt 9 zu addieren, aber für n = 0 würden wir ein falsches Verhalten erhalten, weil in C (-1)%10-1 ausgewertet wird, nicht 9.

Javascript, 75

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

PHP, 98 Bytes

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

Das 11-13 Bit bringt mich hier um. Funktioniert für jede ganze Zahl $n >= 0.

Für eine beliebige ganze Zahl $n:

PHP, 103 Bytes

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 Bytes

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

Ungolfed:

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

lambda xDefiniert eine anonyme Funktion mit Parameter x. ((('th','st','nd','rd')+('th',)*6)[int(x[-1])]Definiert ein Tupel der Endungen für Zahlen unter 10, das 0-thElement ist für 0und so weiter. die if ('0'+x)[-2] != '1'überprüft , ob es gibt 11, 12oder eine 13zu beheben, und fügt dann else 'th'fügt thstatt st, rdoder nd.

JavaScript (Node.js) , 51 Byte

Dank an @KevinCruijssen für die Verbesserung der Antwort

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

Probieren Sie es online!

Erklärung:

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 Bytes

Da es noch keine R-Lösung gibt ... hier keine Tricks, grundlegende Vektorindizierung, dank Giuseppe 3 Zeichen weniger. Bereits ausprobierter Index: [1+(x%%10)-(x%%100==11)]und [1+(x%%10)*(x%%100!=11)].

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

Probieren Sie es online!

Mit substr79 Bytes:

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

Probieren Sie es online!

Python 2.7, 137 Zeichen

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 sollte eine Zeichenfolge sein

Ich weiß, dass mich die Konkurrenz hier bereits geschlagen hat, aber ich dachte, ich würde trotzdem meine Idee einbringen

Dies erzeugt im Grunde genommen eine Liste von Schlüsseln, Wertepaaren mit der Endung number (als Zeichenfolge) eund der Ordnungszahl o. Es wird versucht, zuerst 'th' zu finden (daher habe ich kein Wörterbuch verwendet), damit es nicht versehentlich 'st' zurückgibt, zum Beispiel, wenn es 'th' sein sollte. Dies funktioniert für jede positive ganze Zahl

C: 95 Zeichen

Eine lächerlich lange Lösung:

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

Es muss mehr verstümmelt werden.

Javascript, 75

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

Oracle SQL 11.2, 101 Bytes

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 Zeichen

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