[Question]
  [
I would like to generate (as a return result of a function, or simply as the output of a program) the [ordinal](http://en.wikipedia.org/wiki/Ordinal_number_%28linguistics%29) suffix of a positive integer concatenated to the number.
Samples:
```
1st  
2nd  
3rd  
4th  
...  
11th  
12th  
13th  
...  
20th  
21st
22nd
23rd
24th
```
And so on, with the suffix repeating the initial 1-10 subpattern every 10 until 100, where the pattern ultimately starts over.
The input would be the number and the output the ordinal string as shown above.
What is the smallest algorithm for this?
  
[Answer]
# Python 2, 49 bytes
```
lambda n:`n`+'tsnrhtdd'[n%5*(n%100^15>4>n%10)::4]
```
An anonymous function. A [full program](http://golf.shinh.org/reveal.rb?1st%202nd%203rd%204th/xsot_1456205408&py) would be counted at 55 bytes.
`'tsnrhtdd'[i::4]` encodes the suffixes `th st nd rd` for values of `i` from 0 to 3. Given this, all we need is a way to map the values of `n` to the index of the corresponding suffix, `i`. A straightforward expression that works is `(n%10)*(n%10<4 and not 10<n%100<14)`. We can easily shorten this by dropping the first set of parentheses and observing that `n%5` gives the same results as `n%10` for the values of `n` with the special suffixes. With a bit of trial and error, one may also shorten `not 10<n%100<14` to `n%100^15>4`, which can be chained with the other conditional to save even more bytes.
[Answer]
## Perl, 37 + 1 characters
```
s/1?\d\b/$&.((0,st,nd,rd)[$&]||th)/eg
```
This is a regexp substitution that appends the appropriate ordinal suffix to any numbers in `$_` that are not already followed by a letter. To apply it to file input, use the `p` command line switch, like this:
```
perl -pe 's/1?\d\b/$&.((0,st,nd,rd)[$&]||th)/eg'
```
This is a complete Perl program that reads input from stdin and writes the processed output to stdout. The actual code is 37 chars long, but the `p` switch [counts as one extra character](https://codegolf.meta.stackexchange.com/questions/273/on-interactive-answers-and-other-special-conditions).
### Sample input:
```
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
```
### Output:
```
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
```
Numbers already followed by letters will be ignored, so feeding the output again through the filter won't change it. Spaces, commas and periods between numbers are not treated specially, so they're assumed to separate numbers like any other punctuation. Thus, e.g. `3.14159` becomes `3rd.14159th`.
### How does it work?
* First, this is a global regexp replacement (`s///g`). The regexp being matched is `1?\d\b`, where `\d` matches any digit and `\b` is a zero-width assertion matching the boundary between an alphanumeric and a non-alphanumeric character. Thus, `1?\d\b` matches the last digit of any number, plus the previous digit if it happens to be `1`.
* In the substitution, which is evaluated as Perl code due to the `/e` switch, we take the matched string segment (`$&`) and append (`.`) to it the suffix obtained by using `$&` itself as an integer index to the list `(0,st,nd,rd)`; if this suffix is zero or undefined (i.e. when `$&` is zero or greater than three), the `||` operator replaces it with `th`.
---
**Edit:** If the input is restricted to a single integer, then this 35 character solution will suffice:
```
s/1?\d$/$&.((0,st,nd,rd)[$&]||th)/e
```
[Answer]
## Python, 68 characters
```
i=input()
k=i%10
print"%d%s"%(i,"tsnrhtdd"[(i/10%10!=1)*(k<4)*k::4])
```
[Answer]
# Mathematica ~~39~~ 45 bytes
Note: In recent versions of Mathematica, asking for the `nth` part of `p`, where `p` is undefined, generates an error message, but returns the correct answer anyway. I've added `Quiet` to prevent the error message from printing.
```
Quiet@StringSplit[SpokenString[p[[#]]]][[2]]&
```
**Usage**
```
Quiet@StringSplit[SpokenString[p[[#]]]][[2]] &[31]
```
> 
> 31st
> 
> 
> 
```
Quiet@StringSplit[SpokenString[p[[#]]]][[2]] &/@Range[21]
```
> 
> {"1st", "2nd", "3rd", "4th", "5th", "6th", "7th", "8th", "9th", 
>  "10th", "11th", "12th", "13th", "14th", "15th", "16th", "17th", 
>  "18th", "19th", "20th", "21st"}
> 
> 
> 
---
**How it works**
`SpokenString` writes out an any valid Mathematica expression as it might be spoken. Below are two examples from the documentation for [SpokenString](http://reference.wolfram.com/mathematica/ref/SpokenString.html),
```
SpokenString[Sqrt[x/(y + z)]]
```
> 
> "square root of the quantity x over the quantity y plus z" \*)
> 
> 
> 
```
SpokenString[Graphics3D[Sphere[{{0, 0, 0}, {1, 1, 1}}]], "DetailedGraphics" -> True]
```
> 
> "a three-dimensional graphic consisting of unit spheres centered at 0, 0, 0 and 1, 1, 1"
> 
> 
> 
---
Now, for the example at hand,
```
Quiet@SpokenString[p[[#]]] &[31]
```
> 
> "the 31st element of p"
> 
> 
> 
Let's represent the above string as a list of words:
```
StringSplit[%]
```
> 
> {"the", "31st", "element", "of", "p"}
> 
> 
> 
and take the second element...
```
%[[2]]
```
> 
> 31st
> 
> 
> 
[Answer]
# Javascript (ES6) ~~50~~ 44 Bytes
```
a=>a+=[,"st","nd","rd"][a.match`1?.$`]||"th"
```
### Notes
* takes imput as a string
* Removed 6 bytes, thanks @user81655
[Answer]
## Ruby, 60
It's not as good as the Perl entry, but I figured I'd work on my Ruby skills.
```
def o(n)n.to_s+%w{th st nd rd}[n/10%10==1||n%10>3?0:n%10]end
```
Function takes one integer argument, `n`, and returns a string as the ordinal form.
Works according to the following logic:  
If the tens digit is a 1 or the ones digit is greater than 3 use the suffix 'th'; otherwise find the suffix from the array ['th', 'st', 'nd', 'rd'] using the final digit as the index.
[Answer]
## Javascript, ~~68~~ 71
```
function o(n){return n+([,'st','nd','rd'][~~(n/10%10)-1?n%10:0]||'th')}
```
Joint effort with ItsCosmo.
EDIT: Wasn't working properly with numbers > 100
[Answer]
# JavaScript, 64 characters (ES3) or 47 characters (ES6)
### ES3 (64 characters):
`function(n){return n+=[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'}`
### ES6 (47 characters):
`n=>n+=[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'`
### Explanation
The expression `n % 100 >> 3 ^ 1` evaluates to 0 for any positive `n` ending with digits `08`–`15`. Thus, for any `n mod 100` ending in `11`, `12`, or `13`, the array lookup returns `undefined`, leading to a suffix of `th`.
For any positive `n` ending in other digits than `08`–`15`, the expression `n % 100 >> 3 ^ 1` evaluates to a positive integer, invoking the expression `n % 10` for array lookup, returning `st`,`nd`, or `rd` for `n` which ends with `1`, `2`, or `3`. Otherwise, `th`.
[Answer]
## Haskell, ~~95~~ 100 chars
```
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
```
Testing:
```
*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"]
```
Must be loaded with -XNoMonomorphismRestriction.
[Answer]
# J - ~~44~~ 41 char
Nothing in J? This is an outrage!
```
(":,th`st`nd`rd{::~4|4<.10(|*|~:-~)100&|)
```
Explained (note that `1` is boolean true in J and `0` is false):
* `100&|` - First, reduce the input modulo 100.
* `10(|*|~:-~)` - In this subexpression, `|` is the input mod 10 and `-~` is the input (mod 100) minus 10. You don't get many trains as clean as this one in J, so it's a treat to see here!
	+ `~:` is not-equals, so `|~:-~` is false if the tens digit is 1 and true otherwise.
	+ `*` is just multiplication, so we're taking the input mod 10 and multiplying by a boolean, which will zero it out if false. The result of this is "input mod 10, except 0 on the tens".
* `4|4<.` - Min (`<.`) the above with 4, to clamp down larger values, and then reduce modulo 4 so that they all go to zero.
* `th`st`nd`rd{::~` - Use that as an index into the list of suiffixes. Numbers ending in X1 or X2 or X3, but not in 1X, will find their suffix, and everything else will take the 0th suffix `th`.
* `":,` - Finally, take the original input, convert it to a string (`":`), and append the suffix.
Usage is obvious, though as-is the verb can only take one ordinal, not a list.
```
   (":,th`st`nd`rd{::~4|4<.10(|*|~:-~)100&|) 112         NB. single use
112th
   (":,th`st`nd`rd{::~4|4<.10(|*|~:-~)100&|) 1 2 3 4 5   NB. doing it wrong
|length error
|       (":,th`st`nd`rd{::~4|4<.10(|*|~:-~)100&|)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{::~4|4<.10(|*|~:-~)100&|)&.> 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|
+----+----+----+----+----+----+----+----+----+----+
```
Alternative 41 char solution showing off a couple logical variants:
```
(":;@;st`nd`rd`th{~3<.10(|+3*|=-~)100|<:)
```
Previously I had an overlong explanation of this 44 char hunk of junk. `10 10#:` takes the last two decimal digits and `/@` puts logic between them.
```
(":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:])
```
[Answer]
## Golfscript, 34 characters
```
~.10/10%1=!1$10%*.4<*'thstndrd'2/=
```
[Answer]
# [R](https://www.r-project.org/), ~~79~~ 76 bytes
Since there is no R solution yet... no tricks here, basic vector indexing, golfed down 3 chars thanks to Giuseppe. Previously tried index: `[1+(x%%10)-(x%%100==11)]` and `[1+(x%%10)*(x%%100!=11)]`.
```
function(x)paste0(x,c("th","st","nd","rd",rep("th",6))[1+x%%10*!x%%100==11])
```
[Try it online!](https://tio.run/##K/qfbqP7P600L7kkMz9Po0KzILG4JNVAo0InWUOpJENJR6m4BEjkpQCJIiBRlFoAETfT1Iw21K5QVTU00FIEUwa2toaGsZr/ixMLCnIqNQytDA0NddI1uf4DAA "R – Try It Online")
With `substr`, 79 bytes:
```
function(x,y=1+2*min(x%%10-(x%%100==11),4))paste0(x,substr("thstndrdth",y,y+1))
```
[Try it online!](https://tio.run/##JcrLCoMwEEbhvY8hCJk6Qn7pqpiHSb1Dm4bMCM3TR8HV@RYnlXXoynKEUfdfMH/ODm3/@O6Xmwa2u2OdA4ifRNGLzvYa5XiLJlPrJhqmNOlWc@bcgqiIj/GTDV4AeKWqnA "R – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~38~~ 36 bytes
Thanks to ngn for fixing a bug while maintaining byte count.
Anonymous tacit prefix function. Requires `⎕IO` (**I**ndex **O**rigin) set to `0`, which is default on many systems. Even works for 0!
```
⍕,{2↑'thstndrd'↓⍨2×⊃⍵⌽∊1 0 8\⊂10↑⍳4}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qZv6jtgkG/9OA5KPeqTrVRo/aJqqXZBSX5KUUpag/apv8qHeF0eHpj7qaH/VufdSz91FHl6GCgYJFzKOuJkMDoOJHvZtNav//T1Mw4EpTMARiIwUFIGkMJk2ApLqenp46SM4QLGQIkTc0RpIyMgCLGYG1G4EIYxBhAgA "APL (Dyalog Unicode) – Try It Online")
`{`…`}` anonymous lambda; `⍵` is argument:
 `⍳4` first four **ɩ**ndices; `[0,1,2,3]`
 `10↑` take first ten elements from that, padding with zeros: `[0,1,2,3,0,0,0,0,0,0]`
 `⊂` enclose to treat as single element; `[[0,1,2,3,0,0,0,0,0,0]]`
 `1 0 8\` expand to one copy, a prototypical copy (all-zero), eight copies;  
  `[[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 more)  
   `[0,1,2,3,0,0,0,0,0,0]]` 
 `∊` **ϵ**nlist (flatten);  
  `[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 more)  
   `0,1,2,3,0,0,0,0,0,0]`
 `⍵⌽` cyclically rotate left as many steps as indicated by the argument
 `⊃` pick the first number (i.e. the argument-mod-100'th number)
 `2×` multiply two by that (gives `0`, `2`, `4`, or `6`)
 `'thstndrd'↓⍨`drop that many characters from this string
 `2↑` take the first two of the remaining characters
`⍕,` concatenate the stringified argument to that
[Answer]
# Javascript, ~~75~~ 60
With the new arrow notation:
```
o=(s)=>s+((0|s/10%10)==1?"th":[,"st","nd","rd"][s%10]||"th")
```
*Old version, without arrow notation (75 chars):*
```
function o(s){return s+((0|s/10%10)==1?"th":[,"st","nd","rd"][s%10]||"th")}
```
[Answer]
Bash (Cardinal to ordinal) **91** Bytes:
```
function c(){ case "$1" in *1[0-9]|*[04-9])"$1"th;;*1)"$1"st;;*2)"$1"nd;;*3)"$1"rd;;esac }
```
[Answer]
## PowerShell, 92
```
process{"$_$(switch -r($_){"(?<!1)1$"{'st'}"(?<!1)2$"{'nd'}"(?<!1)3$"{'rd'}default{'th'}})"}
```
Works with one number per line of input. Input is given through the pipeline. Making it work for only a single number doesn't reduce the size.
[Answer]
## PHP, 151
I know that this program is not comparable to the others. Just felt like giving a solution.
```
<?$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";}
```
[Answer]
# K - 44 char
It so happens that this is exactly as long as the J, and works in almost the same way.
```
{x,$`th`st`nd`rd@{y*(y<4)*~1=x}.-2#0,.:'x$:}
```
Explained:
* `x$:` - First, we convert the operand `x` into a string, and then assign that back to `x`. We will need its string rep again later, so doing it now saves characters.
* `.:'` - Convert (`.:`) each (`'`) digit back into a number.
* `-2#0,` - Append a 0 to the front of the list of digits (in case of single-digit numbers), and then take the last two.
* `{y*(y<4)*~1=x}.` - Use the two digits as arguments `x` and `y` to this inner function, which returns `y` if `y` is less than 4 and `x` is not equal to 1, otherwise 0.
* ``th`st`nd`rd@` - Index the list of suffixes by this result.
* `x,$` - Convert the suffix from symbol to string, and append it to the original number.
Usage:
```
  {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")
```
[Answer]
# 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];}
```
The 11-13 bit is killing me here. Works for any integer `$n >= 0`.
For any integer `$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];}
```
[Answer]
# Javascript ES6, 52 chars
```
n=>n+(!/1.$/.test(--n)&&'snr'[n%=10]+'tdd'[n]||'th')
```
[Answer]
# C#, 62 bytes
```
n=>n+(n/10%10==1||(n%=10)<1||n>3?"th":n<2?"st":n<3?"nd":"rd");
```
Full program and verification:
```
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));
        }
    }
}
```
[Answer]
# Mathematica 29 + 5 = 34 bytes
```
SpokenStringDump`SpeakOrdinal
```
+5 bytes because `Speak` function must be called before using this built-in.
**Usage**
```
SpokenStringDump`SpeakOrdinal[1]
```
> 
> `"1st "`
> 
> 
> 
```
SpokenStringDump`SpeakOrdinal[4707]
```
> 
> `"4,707th "`
> 
> 
> 
[Answer]
# Java 7, ~~91~~ 81 bytes
```
String d(int n){return n+(n/10%10==1|(n%=10)<1|n>3?"th":n<2?"st":n<3?"nd":"rd");}
```
Port from [*@adrianmp*'s C# answer](https://codegolf.stackexchange.com/a/94774/52210).
Old answer (**91 bytes**):
```
String c(int n){return n+((n%=100)>10&n<14?"th":(n%=10)==1?"st":n==2?"nd":n==3?"rd":"th");}
```
**Ungolfed & test code:**
[Try it here.](https://ideone.com/pA66N2)
```
class M{
  static String c(int n){
    return n + ((n%=100) > 10 & n < 14
                ?"th"
                : (n%=10) == 1
                   ? "st"
                   : n == 2
                      ? "nd"
                      : n == 3
                         ? "rd"
                         :"th");
  }
  static String d(int n){
    return n + (n/10%10 == 1 | (n%=10) < 1 | n > 3
                 ? "th"
                 : n < 2
                    ? "st"
                    : n < 3
                       ? "nd"
                       :"rd");
  }
  public static void main(String[] a){
    for(int i = 1; i < 201; i++){
      System.out.print(c(i) + ", ");
    }
    System.out.println();
    for(int i = 1; i < 201; i++){
      System.out.print(d(i) + ", ");
    }
  }
}
```
**Output:**
```
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, 50th, 51st, 52nd, 53rd, 54th, 55th, 56th, 57th, 58th, 59th, 60th, 61st, 62nd, 63rd, 64th, 65th, 66th, 67th, 68th, 69th, 70th, 71st, 72nd, 73rd, 74th, 75th, 76th, 77th, 78th, 79th, 80th, 81st, 82nd, 83rd, 84th, 85th, 86th, 87th, 88th, 89th, 90th, 91st, 92nd, 93rd, 94th, 95th, 96th, 97th, 98th, 99th, 100th, 101st, 102nd, 103rd, 104th, 105th, 106th, 107th, 108th, 109th, 110th, 111th, 112th, 113th, 114th, 115th, 116th, 117th, 118th, 119th, 120th, 121st, 122nd, 123rd, 124th, 125th, 126th, 127th, 128th, 129th, 130th, 131st, 132nd, 133rd, 134th, 135th, 136th, 137th, 138th, 139th, 140th, 141st, 142nd, 143rd, 144th, 145th, 146th, 147th, 148th, 149th, 150th, 151st, 152nd, 153rd, 154th, 155th, 156th, 157th, 158th, 159th, 160th, 161st, 162nd, 163rd, 164th, 165th, 166th, 167th, 168th, 169th, 170th, 171st, 172nd, 173rd, 174th, 175th, 176th, 177th, 178th, 179th, 180th, 181st, 182nd, 183rd, 184th, 185th, 186th, 187th, 188th, 189th, 190th, 191st, 192nd, 193rd, 194th, 195th, 196th, 197th, 198th, 199th, 200th, 
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, 50th, 51st, 52nd, 53rd, 54th, 55th, 56th, 57th, 58th, 59th, 60th, 61st, 62nd, 63rd, 64th, 65th, 66th, 67th, 68th, 69th, 70th, 71st, 72nd, 73rd, 74th, 75th, 76th, 77th, 78th, 79th, 80th, 81st, 82nd, 83rd, 84th, 85th, 86th, 87th, 88th, 89th, 90th, 91st, 92nd, 93rd, 94th, 95th, 96th, 97th, 98th, 99th, 100th, 101st, 102nd, 103rd, 104th, 105th, 106th, 107th, 108th, 109th, 110th, 111th, 112th, 113th, 114th, 115th, 116th, 117th, 118th, 119th, 120th, 121st, 122nd, 123rd, 124th, 125th, 126th, 127th, 128th, 129th, 130th, 131st, 132nd, 133rd, 134th, 135th, 136th, 137th, 138th, 139th, 140th, 141st, 142nd, 143rd, 144th, 145th, 146th, 147th, 148th, 149th, 150th, 151st, 152nd, 153rd, 154th, 155th, 156th, 157th, 158th, 159th, 160th, 161st, 162nd, 163rd, 164th, 165th, 166th, 167th, 168th, 169th, 170th, 171st, 172nd, 173rd, 174th, 175th, 176th, 177th, 178th, 179th, 180th, 181st, 182nd, 183rd, 184th, 185th, 186th, 187th, 188th, 189th, 190th, 191st, 192nd, 193rd, 194th, 195th, 196th, 197th, 198th, 199th, 200th, 
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes
```
∆o2NȯJ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLiiIZvMk7Ir0oiLCIiLCIyMyJd)
[Answer]
Python 2.7, 137 chars
```
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` should be a string
I know I'm beaten by the competition here already, but I thought I'd provide my idea anyways
this just basically generates a list of key, value pairs with number (as a string) ending `e` and the ordinal `o`. It attempts to match 'th' first (hence why I didn't use a dictionary), so that it won't accidentally return 'st', for example, when it should be 'th'. This will work for any positive integer
[Answer]
### 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 as well:
```
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))
      }
```
[Answer]
# C: 95 characters
A ridiculously long solution:
```
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");}
```
It needs to be mangled more.
[Answer]
# OCaml
I'm pretty new to OCaml, but this is the shortest i could get.
```
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";;
```
I created a function n that takes a number as a parameter and does the work. Its long but thought it'd be great to have a functional example.
[Answer]
# C - 95 83 characters
```
main(n,k){scanf("%d",&n);k=(n+9)%10;printf("%d%s\n",n,k<3?"st\0nd\0rd"+3*k:"th");}
```
Degolfed:
```
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");
}
```
We could do `k=(n-1)%10` instead of adding 9, but for n=0 we would get an incorrect behaviour,
because in C `(-1)%10` evaluates to -1, not 9.
[Answer]
# Javascript, 75
```
function s(i){return i+'thstndrd'.substr(~~(i/10%10)-1&&i%10<4?i%10*2:0,2)}
```
]