N'th
You are encouraged to solve this task according to the task description, using any language you may know.
Write a function/method/subroutine/... that when given an integer greater than or equal to zero returns a string of the number followed by an apostrophe then the ordinal suffix.
Example returns would include 1'st 2'nd 3'rd 11'th 111'th 1001'st 1012'th
- Task
Use your routine to show here the output for at least the following (inclusive) ranges of integer inputs:
0..25, 250..265, 1000..1025
Note: apostrophes are now optional to allow correct apostrophe-less English.
Ada
<lang Ada>with Ada.Text_IO;
procedure Nth is
function Suffix(N: Natural) return String is
begin
if N mod 10 = 1 and then N mod 100 /= 11 then return "st";
elsif N mod 10 = 2 and then N mod 100 /= 12 then return "nd";
elsif N mod 10 = 3 and then N mod 100 /= 13 then return "rd";
else return "th";
end if;
end Suffix;
procedure Print_Images(From, To: Natural) is
begin
for I in From .. To loop
Ada.Text_IO.Put(Natural'Image(I) & Suffix(I));
end loop;
Ada.Text_IO.New_Line;
end Print_Images;
begin
Print_Images( 0, 25); Print_Images( 250, 265); Print_Images(1000, 1025);
end Nth;</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
ALGOL 68
<lang algol68># PROC to suffix a number with st, nd, rd or th as appropriate # PROC nth = ( INT number )STRING: BEGIN
INT number mod 100 = number MOD 100;
- RESULT #
whole( number, 0 )
+ IF number mod 100 >= 10 AND number mod 100 <= 20
THEN
# numbers in the range 10 .. 20 always have "th" #
"th"
ELSE
# not in the range 10 .. 20, suffix is st, nd, rd or th #
# depending on the final digit #
CASE number MOD 10
IN # 1 # "st"
, # 2 # "nd"
, # 3 # "rd"
OUT "th"
ESAC
FI
END; # nth #
- PROC to test nth, displays nth for all numbers in the range from .. to #
PROC test nth = ( INT from, INT to )VOID: BEGIN
INT test count := 0;
FOR test value FROM from TO to
DO
STRING test result = nth( test value );
print( ( " "[ 1 : 8 - UPB test result ], nth( test value ) ) );
test count +:= 1;
IF test count MOD 8 = 0
THEN
print( ( newline ) )
FI
OD;
print( ( newline ) )
END; # test nth #
main: (
test nth( 0, 25 ); test nth( 250, 265 ); test nth( 1000, 1025 )
)</lang>
- Output:
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
250th 251st 252nd 253rd 254th 255th 256th 257th
258th 259th 260th 261st 262nd 263rd 264th 265th
1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th
1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th
1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd
1024th 1025th
Applesoft BASIC
<lang ApplesoftBasic>0 OP = 1 10 FOR N = 0 TO 25 : GOSUB 100 : NEXT 20 FOR N = 250 TO 265 : GOSUB 100 : NEXT 30 FOR N = 1000 TO 1025 : GOSUB 100 : NEXT 40 END
100 GOSUB 200"NTH 110 PRINT NTH$ " "; 120 RETURN
200 M1 = N - INT(N / 10) * 10 210 M2 = N - INT(N / 100) * 100 220 NTH$ = "TH" 230 IF M1 = 1 AND M2 <> 11 THEN NTH$ = "ST" 240 IF M1 = 2 AND M2 <> 12 THEN NTH$ = "ND" 250 IF M1 = 3 AND M2 <> 13 THEN NTH$ = "RD" 260 IF NOT OP THEN NTH$ = "'" + NTH$ 270 NTH$ = STR$(N) + NTH$ 280 RETURN</lang>
- Output:
0'TH 1'ST 2'ND 3'RD 4'TH 5'TH 6'TH 7'TH 8'TH 9'TH 10'TH 11'TH 12'TH 13'TH 14'TH 15'TH 16'TH 17'TH 18'TH 19'TH 20'TH 21'ST 22'ND 23'RD 24'TH 25'TH 250'TH 251'ST 252'ND 253'RD 254'TH 255'TH 256'TH 257'TH 258'TH 259'TH 260'TH 261'ST 262'ND 263'RD 264'TH 265'TH 1000'TH 1001'ST 1002'ND 1003'RD 1004'TH 1005'TH 1006'TH 1007'TH 1008'TH 1009'TH 1010'TH 1011'TH 1012'TH 1013'TH 1014'TH 1015'TH 1016'TH 1017'TH 1018'TH 1019'TH 1020'TH 1021'ST 1022'ND 1023'RD 1024'TH 1025'TH
AutoHotkey
<lang AutoHotkey>for k, v in [[0, 25], [250, 265], [1000, 1025]] { while v[1] <= v[2] { Out .= Ordinal(v[1]) " " v[1]++ } Out .= "`n" } MsgBox, % Out
Ordinal(n) { s2 := Mod(n, 100) if (s2 > 10 && s2 < 14) return n "th" s1 := Mod(n, 10) return n (s1 = 1 ? "st" : s1 = 2 ? "nd" : s1 = 3 ? "rd" : "th") }</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
AWK
<lang AWK>
- syntax: GAWK -f NTH.AWK
BEGIN {
prn(0,25) prn(250,265) prn(1000,1025) exit(0)
} function prn(start,stop, i) {
printf("%d-%d: ",start,stop)
for (i=start; i<=stop; i++) {
printf("%d%s ",i,nth(i))
}
printf("\n")
} function nth(yearday, nthday) {
if (yearday ~ /1[1-3]$/) { # 11th,12th,13th
nthday = "th"
}
else if (yearday ~ /1$/) { # 1st,21st,31st,etc.
nthday = "st"
}
else if (yearday ~ /2$/) { # 2nd,22nd,32nd,etc.
nthday = "nd"
}
else if (yearday ~ /3$/) { # 3rd,23rd,33rd,etc.
nthday = "rd"
}
else if (yearday ~ /[0456789]$/) { # 4th-10th,20th,24th-30th,etc.
nthday = "th"
}
return(nthday)
} </lang>
- Output:
0-25: 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 250-265: 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000-1025: 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Babel
<lang babel>((irregular ("st" "nd" "rd"))
(main
{(0 250 1000)
{ test ! "\n" << }
each})
(test {
<-
{iter 1 - -> dup <- + ordinalify ! <<
{iter 10 %} {" "} {"\n"} ifte << }
26 times})
(ordinalify {
<-
{{ -> dup <- 100 % 10 cugt } !
{ -> dup <- 100 % 14 cult } !
and not
{ -> dup <- 10 % 0 cugt } !
{ -> dup <- 10 % 4 cult } !
and
and}
{ -> dup
<- %d "'"
irregular -> 10 % 1 - ith
. . }
{ -> %d "'th" . }
ifte }))</lang>
- Output:
25'th 24'th 23'rd 22'nd 21'st 20'th 19'th 18'th 17'th 16'th 15'th 14'th 13'th 12'th 11'th 10'th 9'th 8'th 7'th 6'th 5'th 4'th 3'rd 2'nd 1'st 0'th 275'th 274'th 273'rd 272'nd 271'st 270'th 269'th 268'th 267'th 266'th 265'th 264'th 263'rd 262'nd 261'st 260'th 259'th 258'th 257'th 256'th 255'th 254'th 253'rd 252'nd 251'st 250'th 1025'th 1024'th 1023'rd 1022'nd 1021'st 1020'th 1019'th 1018'th 1017'th 1016'th 1015'th 1014'th 1013'th 1012'th 1011'th 1010'th 1009'th 1008'th 1007'th 1006'th 1005'th 1004'th 1003'rd 1002'nd 1001'st 1000'th
Batch File
<lang dos>@echo off
- Main thing...
call :Nth 0 25 call :Nth 250 265 call :Nth 1000 1025 pause exit /b
- The subroutine
- Nth <lbound> <ubound>
setlocal enabledelayedexpansion for /l %%n in (%~1,1,%~2) do ( set curr_num=%%n set "out=%%nth" if !curr_num:~-1!==1 (set "out=%%nst") if !curr_num:~-1!==2 (set "out=%%nnd") if !curr_num:~-1!==3 (set "out=%%nrd") set "range_output=!range_output! !out!" ) echo."!range_output:~1!" goto :EOF</lang>
- Output:
"0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th 11st 12nd 13rd 14th 15th 16th 17th 18th 19th 20th 21st 22nd 23rd 24th 25th" "250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th" "1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011st 1012nd 1013rd 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th" Press any key to continue . . .
BBC BASIC
<lang bbcbasic> PROCNth( 0, 25)
PROCNth( 250, 265)
PROCNth(1000,1025)
END
DEF PROCNth(s%,e%)
LOCAL i%,suff$
FOR i%=s% TO e%
suff$="th"
IF i% MOD 10 = 1 AND i% MOD 100 <> 11 suff$="st"
IF i% MOD 10 = 2 AND i% MOD 100 <> 12 suff$="nd"
IF i% MOD 10 = 3 AND i% MOD 100 <> 13 suff$="rd"
PRINT STR$i%+suff$+" ";
NEXT
PRINT
ENDPROC</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Befunge
The bottom section of code contains the "subroutine" that calculates the ordinal of a given number; the top section generates the list of values to test.
<lang befunge>0>55*:>1-\:0\`!v
- v$#$<^:\+*8"}"_
>35*:>1-\:0\`!v
- v$#$<^:\+*2"}"_
5< v$_v#!::-<0*5 @v <,*>#81#4^# _
>>:0\>:55+%68*v: tsnr |:/+ 55\+<, htdd >$>:#,_$:vg v"d"\*!`3:%+55<9 >%55+/1-!!*:8g,^</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
C
<lang c>#include <stdio.h>
char* addSuffix(int num, char* buf, size_t len) {
char *suffixes[4] = { "th", "st", "nd", "rd" };
int i;
switch (num % 10)
{
case 1 : i = (num % 100 == 11) ? 0 : 1;
break;
case 2 : i = (num % 100 == 12) ? 0 : 2;
break;
case 3 : i = (num % 100 == 13) ? 0 : 3;
break;
default: i = 0;
};
snprintf(buf, len, "%d%s", num, suffixes[i]);
return buf;
}
int main(void) {
int i;
printf("Set [0,25]:\n");
for (i = 0; i < 26; i++)
{
char s[5];
printf("%s ", addSuffix(i, s, 5));
}
putchar('\n');
printf("Set [250,265]:\n");
for (i = 250; i < 266; i++)
{
char s[6];
printf("%s ", addSuffix(i, s, 6));
}
putchar('\n');
printf("Set [1000,1025]:\n");
for (i = 1000; i < 1026; i++)
{
char s[7];
printf("%s ", addSuffix(i, s, 7));
}
putchar('\n');
return 0;
}</lang>
- Output:
Set [0,25] : 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 Set [250,265] : 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th Set [1000,1025] : 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
C++
<lang cpp>#include <string>
- include <iostream>
using namespace std;
string Suffix(int num) {
switch (num % 10)
{
case 1 : if(num % 100 != 11) return "st";
break;
case 2 : if(num % 100 != 12) return "nd";
break;
case 3 : if(num % 100 != 13) return "rd";
}
return "th";
}
int main() {
cout << "Set [0,25]:" << endl;
for (int i = 0; i < 26; i++)
cout << i << Suffix(i) << " ";
cout << endl;
cout << "Set [250,265]:" << endl;
for (int i = 250; i < 266; i++)
cout << i << Suffix(i) << " ";
cout << endl;
cout << "Set [1000,1025]:" << endl;
for (int i = 1000; i < 1026; i++)
cout << i << Suffix(i) << " ";
cout << endl;
return 0;
}</lang>
- Output:
Set [0,25] : 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 Set [250,265] : 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th Set [1000,1025] : 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
C#
<lang csharp> class Program {
private static string Ordinalize(int i)
{
i = Math.Abs(i);
if (new[] {11, 12, 13}.Contains(i%100))
return i + "th";
switch (i%10)
{
case 1:
return i + "st";
case 2:
return i + "nd";
case 3:
return i + "rd";
default:
return i + "th";
}
}
static void Main()
{
Console.WriteLine(string.Join(" ", Enumerable.Range(0, 26).Select(Ordinalize)));
Console.WriteLine(string.Join(" ", Enumerable.Range(250, 16).Select(Ordinalize)));
Console.WriteLine(string.Join(" ", Enumerable.Range(1000, 26).Select(Ordinalize)));
}
} </lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Clojure
<lang clojure> (defn n-th [n]
(str n
(let [rem (mod n 100)]
(if (and (>= rem 11) (<= rem 13))
"th"
(condp = (mod n 10)
1 "st"
2 "nd"
3 "rd"
"th")))))
(apply str (interpose " " (map n-th (range 0 26)))) (apply str (interpose " " (map n-th (range 250 266)))) (apply str (interpose " " (map n-th (range 1000 1026)))) </lang>
- Output:
"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" "250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th" "1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th"
Alternatively, if you want to print the full ordinal English, it becomes trivial with pprint: <lang clojure> (apply str (interpose " " (map #(clojure.pprint/cl-format nil "~:R" %) (range 0 26)))) </lang>
- Output:
"zeroth first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventeenth eighteenth nineteenth twentieth twenty-first twenty-second twenty-third twenty-fourth twenty-fifth"
Common Lisp
<lang lisp>(defun add-suffix (number)
(let* ((suffixes #10("th" "st" "nd" "rd" "th"))
(last2 (mod number 100))
(last-digit (mod number 10))
(suffix (if (< 10 last2 20)
"th"
(svref suffixes last-digit))))
(format nil "~a~a" number suffix)))
(defun add-suffix (n)
"A more compact and efficient, albeit less readable version" (format nil "~d'~:[~[th~;st~;nd~;rd~:;th~]~;th~]" n (< (mod (- n 10) 100) 10) (mod n 10)))
(loop for (low high) in '((0 25) (250 265) (1000 1025))
do (progn
(format t "~a to ~a: " low high)
(loop for n from low to high
do (format t "~a " (add-suffix n))
finally (terpri))))</lang>
- Output:
0 to 25: 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 250 to 265: 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000 to 1025: 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
D
<lang d>import std.stdio, std.string, std.range, std.algorithm;
string nth(in uint n) pure {
static immutable suffix = "th st nd rd th th th th th th".split;
return "%d'%s".format(n, (n % 100 <= 10 || n % 100 > 20) ?
suffix[n % 10] : "th");
}
void main() {
foreach (r; [iota(26), iota(250, 266), iota(1000, 1026)])
writefln("%-(%s %)", r.map!nth);
}</lang>
- Output:
0'th 1'st 2'nd 3'rd 4'th 5'th 6'th 7'th 8'th 9'th 10'th 11'th 12'th 13'th 14'th 15'th 16'th 17'th 18'th 19'th 20'th 21'st 22'nd 23'rd 24'th 25'th 250'th 251'st 252'nd 253'rd 254'th 255'th 256'th 257'th 258'th 259'th 260'th 261'st 262'nd 263'rd 264'th 265'th 1000'th 1001'st 1002'nd 1003'rd 1004'th 1005'th 1006'th 1007'th 1008'th 1009'th 1010'th 1011'th 1012'th 1013'th 1014'th 1015'th 1016'th 1017'th 1018'th 1019'th 1020'th 1021'st 1022'nd 1023'rd 1024'th 1025'th
Elixir
<lang elixir>defmodule RC do
def ordinalize(n) do
num = abs(n)
ordinal = if rem(num, 100) in 4..20 do
"th"
else
case rem(num, 10) do
1 -> "st"
2 -> "nd"
3 -> "rd"
_ -> "th"
end
end
"#{n}#{ordinal}"
end
end
Enum.each([0..25, 250..265, 1000..1025], fn range ->
Enum.map(range, fn n -> RC.ordinalize(n) end) |> Enum.join(" ") |> IO.puts
end)</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
ERRE
<lang ERRE> PROGRAM NTH_SOLVE
! ! for rosettacode.org !
PROCEDURE NTH(S%,E%)
LOCAL I%,SUFF$
FOR I%=S% TO E% DO
SUFF$="th"
IF I% MOD 10=1 AND I% MOD 100<>11 THEN SUFF$="st" END IF
IF I% MOD 10=2 AND I% MOD 100<>12 THEN SUFF$="nd" END IF
IF I% MOD 10=3 AND I% MOD 100<>13 THEN SUFF$="rd" END IF
PRINT(STR$(I%)+SUFF$+" ";)
END FOR
PRINT
END PROCEDURE
BEGIN
NTH(0,25) NTH(250,265) NTH(1000,1025)
END PROGRAM </lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Forth
<lang forth>: 'nth ( -- c-addr ) s" th st nd rd th th th th th th " drop ;
- .nth ( n -- )
dup 10 20 within if 0 .r ." th " exit then dup 0 .r 10 mod 3 * 'nth + 3 type ;
- test ( n n -- ) cr do i 5 mod 0= if cr then i .nth loop ;
- tests ( -- )
26 0 test 266 250 test 1026 1000 test ;
tests</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011st 1012nd 1013rd 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1024th ok
Fortran
Please find the compilation instructions and examples in comments at the start of the source.
<lang Fortran>!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Fri Jun 6 15:40:18
!
!a=./f && make -k $a && echo 0 25 | $a && echo 250 265 | $a && echo 1000 1025 | $a
!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none -g f.f08 -o f
! 0'th 1'st 2'nd
! 3'rd 4'th 5'th
! 6'th 7'th 8'th
! 9'th 10'th 11'th
! 12'th 13'th 14'th
! 15'th 16'th 17'th
! 18'th 19'th 20'th
! 21'st 22'nd 23'rd
! 24'th 25'th
! 250'th 251'st
! 252'nd 253'rd 254'th
! 255'th 256'th 257'th
! 258'th 259'th 260'th
! 261'st 262'nd 263'rd
! 264'th 265'th
! 1000th 1001st
! 1002nd 1003rd 1004th
! 1005th 1006th 1007th
! 1008th 1009th 1010th
! 1011th 1012th 1013th
! 1014th 1015th 1016th
! 1017th 1018th 1019th
! 1020th 1021st 1022nd
! 1023rd 1024th 1025th
!
!Compilation finished at Fri Jun 6 15:40:18
program nth
implicit none
logical :: need
integer :: here, there, n, i, iostat
read(5,*,iostat=iostat) here, there
if (iostat .ne. 0) then
write(6,*)'such bad input never before seen.'
write(6,*)'I AYE EYE QUIT!'
call exit(1)
end if
need = .false.
n = abs(there - here) + 1
i = 0
do while (0 /= mod(3+mod(here-i, 3), 3))
write(6,'(a22)',advance='no')
i = i+1
end do
do i = here, there, sign(1, there-here)
write(6,'(a22)',advance='no') ordinate(i)
if (2 /= mod(i,3)) then
need = .true.
else
write(6,'(a)')
need = .false.
end if
end do
if (need) write(6,'(a)')
contains
character(len=22) function ordinate(n)
character(len=19) :: a
character(len=20), parameter :: &
&a09 = "thstndrdthththththth",&
&ateen = "thththththththththth"
integer :: ones, tens, ones_index
integer, intent(in) :: n
write(a,'(i19)') n
ones = mod(n,10)
tens = mod(n,100)
ones_index = ones*2+1
if (n < 1000) then
if ((10 .le. tens) .and. (tens .lt. 20)) then
ordinate = a // "'" // ateen(ones_index:ones_index+1)
else
ordinate = a // "'" // a09(ones_index:ones_index+1)
end if
else
if ((10 .le. tens) .and. (tens .lt. 20)) then
ordinate = a // ateen(ones_index:ones_index+1)
else
ordinate = a // a09(ones_index:ones_index+1)
end if
end if
end function ordinate
end program nth</lang>
Go
<lang go>package main
import "fmt"
func ord(n int) string {
s := "th"
switch c := n % 10; c {
case 1, 2, 3:
if n%100/10 == 1 {
break
}
switch c {
case 1:
s = "st"
case 2:
s = "nd"
case 3:
s = "rd"
}
}
return fmt.Sprintf("%d%s", n, s)
}
func main() {
for n := 0; n <= 25; n++ {
fmt.Printf("%s ", ord(n))
}
fmt.Println()
for n := 250; n <= 265; n++ {
fmt.Printf("%s ", ord(n))
}
fmt.Println()
for n := 1000; n <= 1025; n++ {
fmt.Printf("%s ", ord(n))
}
fmt.Println()
}</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Haskell
<lang haskell>import Data.Array
ordSuffs :: Array Integer String ordSuffs = listArray (0,9) ["th", "st", "nd", "rd", "th",
"th", "th", "th", "th", "th"]
ordSuff :: Integer -> String ordSuff n = show n ++ suff n
where suff m | (m `rem` 100) >= 11 && (m `rem` 100) <= 13 = "th"
| otherwise = ordSuffs ! (m `rem` 10)
printOrdSuffs :: [Integer] -> IO () printOrdSuffs = putStrLn . unwords . map ordSuff
main :: IO () main = do
printOrdSuffs [ 0.. 25] printOrdSuffs [ 250.. 265] printOrdSuffs [1000..1025]</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Icon and Unicon
The following works in both languages. <lang unicon>procedure main(A)
every writes(" ",nth(0 to 25) | "\n")
every writes(" ",nth(250 to 265) | "\n")
every writes(" ",nth(1000 to 1025) | "\n")
end
procedure nth(n)
return n || ((n%10 = 1, n%100 ~= 11, "st") |
(n%10 = 2, n%100 ~= 12, "nd") |
(n%10 = 3, n%100 ~= 13, "rd") | "th")
end</lang>
- Output:
->nth 0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th 11th 12th 13h 14th 15th 16th 17th 18th 19th 20th 21st 22nd 23rd 24th 25th 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013h 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th ->
J
Implementation:
<lang J>suf=: (;:'th st nd rd th') {::~ 4 <. 10 10 (* 1&~:)~/@#: ] nth=: [: ;:inv (": , suf)each</lang>
Task:
<lang J> thru=: <./ + i.@(+ *)@-~
nth 0 thru 25
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
nth 250 thru 265
250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th
nth 1000 thru 1025
1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th</lang>
Java
<lang java>public class Nth { public static String ordinalAbbrev(int n){ String ans = "th"; //most of the time it should be "th" if(n % 100 / 10 == 1) return ans; //teens are all "th" switch(n % 10){ case 1: ans = "st"; break; case 2: ans = "nd"; break; case 3: ans = "rd"; break; } return ans; }
public static void main(String[] args){ for(int i = 0; i <= 25;i++){ System.out.print(i + ordinalAbbrev(i) + " "); } System.out.println(); for(int i = 250; i <= 265;i++){ System.out.print(i + ordinalAbbrev(i) + " "); } System.out.println(); for(int i = 1000; i <= 1025;i++){ System.out.print(i + ordinalAbbrev(i) + " "); } } }</lang>
<lang java>package nth;
import java.util.stream.IntStream; import java.util.stream.Stream;
public interface Nth {
public static String suffix(int n){
if(n % 100 / 10 == 1){
return "th"; //teens are all "th"
}
switch(n % 10){
case 1: return "st";
case 2: return "nd";
case 3: return "rd";
default: return "th"; //most of the time it should be "th"
}
}
public static void print(int start, int end) {
IntStream.rangeClosed(start, end)
.parallel()
.mapToObj(i -> i + suffix(i) + " ")
.reduce(String::concat)
.ifPresent(System.out::println)
;
}
public static void print(int[] startAndEnd) {
print(startAndEnd[0], startAndEnd[1]);
}
public static int[] startAndEnd(int start, int end) {
return new int[] {
start,
end
};
}
public static void main(String... arguments){
Stream.of(
startAndEnd(0, 25),
startAndEnd(250, 265),
startAndEnd(1000, 1025)
)
.forEach(Nth::print)
;
}
}</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
JavaScript
ES5 Functional
<lang JavaScript>console.log(function () {
var lstSuffix = 'th st nd rd th th th th th th'.split(' '),
fnOrdinalForm = function (n) {
return n.toString() + (
11 <= n % 100 && 13 >= n % 100 ?
"th" : lstSuffix[n % 10]
);
},
range = function (m, n) {
return Array.apply(
null, Array(n - m + 1)
).map(function (x, i) {
return m + i;
});
};
return [[0, 25], [250, 265], [1000, 1025]].map(function (tpl) {
return range.apply(null, tpl).map(fnOrdinalForm).join(' ');
}).join('\n\n');
}());</lang>
Output:
<lang JavaScript>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
250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th
1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th</lang>
jq
<lang jq>
- ordinalize an integer input, positive or negative
def ordinalize:
(if . < 0 then -(.) else . end) as $num
| ($num % 100) as $small
| (if 11 <= $small and $small <= 13 then "th"
else
( $num % 10)
| (if . == 1 then "st"
elif . == 2 then "nd"
elif . == 3 then "rd"
else "th"
end)
end) as $ordinal
| "\(.)\($ordinal)" ;
([range(-5; -1)], [range(0;26)], [range(250;266)], [range(1000;1026)])
| map(ordinalize)
</lang>
- Output:
["-5th","-4th","-3rd","-2nd"] ["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"] ["250th","251st","252nd","253rd","254th","255th","256th","257th","258th","259th","260th","261st","262nd","263rd","264th","265th"] ["1000th","1001st","1002nd","1003rd","1004th","1005th","1006th","1007th","1008th","1009th","1010th","1011th","1012th","1013th","1014th","1015th","1016th","1017th","1018th","1019th","1020th","1021st","1022nd","1023rd","1024th","1025th"]
Julia
Function <lang Julia> function sprintfordinal{T<:Integer}(n::T)
const sfixes = ["st", "nd", "rd"]
0 <= n || throw(ArgumentError("number to be formatted must be ≥ 0, got $n"))
u = n%10
t = div(n, 10)%10
if 3 < u || u == 0 || t == 1
sf = "th"
else
sf = sfixes[u]
end
@sprintf "%d%s" n sf
end </lang>
Main <lang Julia> println("Tests of ordinal formatting of integers.") for (i, n) in enumerate(0:25)
if (i-1)%10 == 0
print("\n ")
end
print(@sprintf("%7s", sprintfordinal(n)))
end println()
for (i, n) in enumerate(250:265)
if (i-1)%10 == 0
print("\n ")
end
print(@sprintf("%7s", sprintfordinal(n)))
end println()
for (i, n) in enumerate(1000:1025)
if (i-1)%10 == 0
print("\n ")
end
print(@sprintf("%7s", sprintfordinal(n)))
end println() </lang>
- Output:
Tests of ordinal formatting of integers.
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
250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th
260th 261st 262nd 263rd 264th 265th
1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th
1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th
1020th 1021st 1022nd 1023rd 1024th 1025th
Mathematica
I borrowed the logic from the Python code. <lang Mathematica>suffixlist = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th","th"}; addsuffix[n_] := Module[{suffix},
suffix = Which[ Mod[n, 100] <= 10, suffixlist[[Mod[n, 10] + 1]], Mod[n, 100] > 20, suffixlist[[Mod[n, 10] + 1]], True, "th" ]; ToString[n] <> suffix ]
addsuffix[#] & /@ Range[0, 25] (* test 1 *) addsuffix[#] & /@ Range[250, 265] (* test 2 *) addsuffix[#] & /@ Range[1000, 1025] (* test 3 *) </lang>
- Output:
{"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"}
{"250th", "251st", "252nd", "253rd", "254th", "255th", "256th", "257th", "258th", "259th", "260th", "261st", "262nd", "263rd", "264th", "265th"}
{"1000th", "1001st", "1002nd", "1003rd", "1004th", "1005th", "1006th", "1007th", "1008th", "1009th", "1010th", "1011th", "1012th", "1013th", "1014th", "1015th", "1016th", "1017th", "1018th", "1019th", "1020th", "1021st", "1022nd", "1023rd", "1024th", "1025th"}
MATLAB
<lang MATLAB>function s = nth(n)
tens = mod(n, 100);
if tens > 9 && tens < 20
suf = 'th';
else
switch mod(n, 10)
case 1
suf = 'st';
case 2
suf = 'nd';
case 3
suf = 'rd';
otherwise
suf = 'th';
end
end
s = sprintf('%d%s', n, suf);
end</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Nim
<lang nim>const suffix = ["th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"]
proc nth(n): string =
$n & "'" & (if n mod 100 <= 10 or n mod 100 > 20: suffix[n mod 10] else: "th")
for j in countup(0, 1000, 250):
for i in j..j+24: stdout.write nth(i), " " echo ""</lang>
- Output:
0'th 1'st 2'nd 3'rd 4'th 5'th 6'th 7'th 8'th 9'th 10'th 11'th 12'th 13'th 14'th 15'th 16'th 17'th 18'th 19'th 20'th 21'st 22'nd 23'rd 24'th 250'th 251'st 252'nd 253'rd 254'th 255'th 256'th 257'th 258'th 259'th 260'th 261'st 262'nd 263'rd 264'th 265'th 266'th 267'th 268'th 269'th 270'th 271'st 272'nd 273'rd 274'th 500'th 501'st 502'nd 503'rd 504'th 505'th 506'th 507'th 508'th 509'th 510'th 511'th 512'th 513'th 514'th 515'th 516'th 517'th 518'th 519'th 520'th 521'st 522'nd 523'rd 524'th 750'th 751'st 752'nd 753'rd 754'th 755'th 756'th 757'th 758'th 759'th 760'th 761'st 762'nd 763'rd 764'th 765'th 766'th 767'th 768'th 769'th 770'th 771'st 772'nd 773'rd 774'th 1000'th 1001'st 1002'nd 1003'rd 1004'th 1005'th 1006'th 1007'th 1008'th 1009'th 1010'th 1011'th 1012'th 1013'th 1014'th 1015'th 1016'th 1017'th 1018'th 1019'th 1020'th 1021'st 1022'nd 1023'rd 1024'th
Oforth
<lang Oforth>func: nth(n) { | r |
n "th" over 10 mod ->r r 1 == ifTrue: [ n 100 mod 11 == ifFalse: [ drop "st" ] ] r 2 == ifTrue: [ n 100 mod 12 == ifFalse: [ drop "nd" ] ] r 3 == ifTrue: [ n 100 mod 13 == ifFalse: [ drop "rd" ] ] +
}</lang>
- Output:
seqFrom(0, 25) map(#nth) println [0th, 1st, 2nd, 3rd, 4th, 5th, 6th, 7th, 8th, 9th, 10th, 11th, 12th, 13th, 14th, 15th, 16t h, 17th, 18th, 19th, 20th, 21st, 22nd, 23rd, 24th, 25th] seqFrom(250, 265) map(#nth) println [250th, 251st, 252nd, 253rd, 254th, 255th, 256th, 257th, 258th, 259th, 260th, 261st, 262nd , 263rd, 264th, 265th] seqFrom(1000, 1025) map(#nth) println [1000th, 1001st, 1002nd, 1003rd, 1004th, 1005th, 1006th, 1007th, 1008th, 1009th, 1010th, 1 011th, 1012th, 1013th, 1014th, 1015th, 1016th, 1017th, 1018th, 1019th, 1020th, 1021st, 102 2nd, 1023rd, 1024th, 1025th]
PARI/GP
(Spurious apostrophes intentionally omitted, following Perl 6.)
<lang parigp>ordinal(n)=my(k=n%10,m=n%100); Str(n,if(m<21&&m>3,"th",k==1,"st",k==2,"nd",k==3,"rd","th")); apply(ordinal, [0..25]) apply(ordinal, [250..265]) apply(ordinal, [1000..1025]) apply(ordinal, [111, 1012])</lang>
- Output:
%1 = ["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"] %2 = ["250th", "251st", "252nd", "253rd", "254th", "255th", "256th", "257th", "258th", "259th", "260th", "261st", "262nd", "263rd", "264th", "265th"] %3 = ["1000th", "1001st", "1002nd", "1003rd", "1004th", "1005th", "1006th", "1007th", "1008th", "1009th", "1010th", "1011th", "1012th", "1013th", "1014th", "1015th", "1016th", "1017th", "1018th", "1019th", "1020th", "1021st", "1022nd", "1023rd", "1024th", "1025th"] %4 = ["111th", "1012th"]
Perl
Requires Perl 5.10 or newer for the Defined OR operator (//). <lang perl>my %irregulars = ( 1 => 'st',
2 => 'nd',
3 => 'rd',
11 => 'th',
12 => 'th',
13 => 'th');
sub nth {
my $n = shift;
$n . # q(') . # Uncomment this to add apostrophes to output
($irregulars{$n % 100} // $irregulars{$n % 10} // 'th');
}
sub range { join ' ', map { nth($_) } @{$_[0]} } print range($_), "\n" for ([0..25], [250..265], [1000..1025]); </lang>
- Output:
Same as Perl 6
<lang Perl>use Lingua::EN::Numbers::Ordinate 'ordinate'; foreach my $i (0..25, 250..265, 1000..1025) {
print ordinate($i),"\n";
}</lang>
Perl 6
(Spurious apostrophes intentionally omitted.) <lang perl6>my %irregulars = <1 st 2 nd 3 rd>, (11..13 X=> 'th');
sub nth ($n) { $n ~ ( %irregulars{$n % 100} // %irregulars{$n % 10} // 'th' ) }
say .list».&nth for [^26], [250..265], [1000..1025];</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
If you want to get Unicodally fancy, use this version instead: <lang perl6>my %irregulars = <1 ˢᵗ 2 ⁿᵈ 3 ʳᵈ>, (11..13 X=> 'ᵗʰ');
sub nth ($n) { $n ~ ( %irregulars{$n % 100} // %irregulars{$n % 10} // 'ᵗʰ' ) }
say .list».&nth for [^26], [250..265], [1000..1025];</lang>
- Output:
0ᵗʰ 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ᵗʰ
250ᵗʰ 251ˢᵗ 252ⁿᵈ 253ʳᵈ 254ᵗʰ 255ᵗʰ 256ᵗʰ 257ᵗʰ 258ᵗʰ 259ᵗʰ 260ᵗʰ 261ˢᵗ 262ⁿᵈ 263ʳᵈ 264ᵗʰ 265ᵗʰ
1000ᵗʰ 1001ˢᵗ 1002ⁿᵈ 1003ʳᵈ 1004ᵗʰ 1005ᵗʰ 1006ᵗʰ 1007ᵗʰ 1008ᵗʰ 1009ᵗʰ 1010ᵗʰ 1011ᵗʰ 1012ᵗʰ 1013ᵗʰ 1014ᵗʰ 1015ᵗʰ 1016ᵗʰ 1017ᵗʰ 1018ᵗʰ 1019ᵗʰ 1020ᵗʰ 1021ˢᵗ 1022ⁿᵈ 1023ʳᵈ 1024ᵗʰ 1025ᵗʰ
PHP
<lang PHP>function nth($num) {
$os = "th";
if ($num % 100 <= 10 or $num % 100 > 20) {
switch ($num % 10) {
case 1:
$os = "st";
break;
case 2:
$os = "nd";
break;
case 3:
$os = "rd";
break;
}
}
return $num . $os;
}
foreach ([[0,25], [250,265], [1000,1025]] as $i) {
while ($i[0] <= $i[1]) {
echo nth($i[0]) . " ";
$i[0]++;
}
echo "\n";
}</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
PicoLisp
<lang PicoLisp>(de rangeth (A B)
(mapcar
'((I)
(pack I
(if (member (% I 100) (11 12 13))
'th
(case (% I 10)
(1 'st)
(2 'nd)
(3 'rd)
(T 'th) ) ) ) )
(range A B) ) )
(prinl (glue " " (rangeth 0 25))) (prinl (glue " " (rangeth 250 265))) (prinl (glue " " (rangeth 1000 1025)))
(bye)</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
PL/I
<lang>Nth: procedure options (main); /* 1 June 2014 */
declare i fixed (10);
do i = 0 to 25, 250 to 265, 1000 to 1025;
if i = 250 | i = 1000 then put skip (2);
put edit (enth(i)) (x(1), a);
end;
enth: procedure (i) returns (character (25) varying);
declare i fixed (10); declare suffix character (2);
select (mod(i, 10));
when (1) suffix = 'st';
when (2) suffix = 'nd';
when (3) suffix = 'rd';
otherwise suffix = 'th';
end;
select (mod(i, 100));
when (11, 12, 13) suffix = 'th';
otherwise ;
end;
return ( trim(i) || suffix );
end enth;
end Nth;</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
PowerShell
<lang powershell>function nth($inp){ $suffix = "th"
switch($inp % 10){ 1{$suffix="st"} 2{$suffix="nd"} 3{$suffix="rd"} } return "$inp$suffix " }
0..25 | %{Write-host -nonewline (nth "$_")};"" 250..265 | %{Write-host -nonewline (nth "$_")};"" 1000..1025 | %{Write-host -nonewline (nth "$_")};""</lang>
- Output:
0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th 11st 12nd 13rd 14th 15th 16th 17th 18th 19th 20th 21st 22nd 23rd 24th 25th 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011st 1012nd 1013rd 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Prolog
Following Icon:
<lang prolog>nth(N, N_Th) :-
( tween(N) -> Th = "th" ; 1 is N mod 10 -> Th = "st" ; 2 is N mod 10 -> Th = "nd" ; 3 is N mod 10 -> Th = "rd" ; Th = "th" ), string_concat(N, Th, N_Th).
tween(N) :- Tween is N mod 100, between(11, 13, Tween).
test :-
forall( between(0,25, N), (nth(N, N_Th), format('~w, ', N_Th)) ),
nl, nl,
forall( between(250,265,N), (nth(N, N_Th), format('~w, ', N_Th)) ),
nl, nl,
forall( between(1000,1025,N), (nth(N, N_Th), format('~w, ', N_Th)) ).
</lang>
- Output:
of `test/0`
?- test. 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, 250th, 251st, 252nd, 253rd, 254th, 255th, 256th, 257th, 258th, 259th, 260th, 261st, 262nd, 263rd, 264th, 265th, 1000th, 1001st, 1002nd, 1003rd, 1004th, 1005th, 1006th, 1007th, 1008th, 1009th, 1010th, 1011th, 1012th, 1013th, 1014th, 1015th, 1016th, 1017th, 1018th, 1019th, 1020th, 1021st, 1022nd, 1023rd, 1024th, 1025th, true.
Python
<lang python>_suffix = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th']
def nth(n):
return "%i'%s" % (n, _suffix[n%10] if n % 100 <= 10 or n % 100 > 20 else 'th')
if __name__ == '__main__':
for j in range(0,1001, 250):
print(' '.join(nth(i) for i in list(range(j, j+25))))</lang>
- Output:
0'th 1'st 2'nd 3'rd 4'th 5'th 6'th 7'th 8'th 9'th 10'th 11'th 12'th 13'th 14'th 15'th 16'th 17'th 18'th 19'th 20'th 21'st 22'nd 23'rd 24'th 250'th 251'st 252'nd 253'rd 254'th 255'th 256'th 257'th 258'th 259'th 260'th 261'st 262'nd 263'rd 264'th 265'th 266'th 267'th 268'th 269'th 270'th 271'st 272'nd 273'rd 274'th 500'th 501'st 502'nd 503'rd 504'th 505'th 506'th 507'th 508'th 509'th 510'th 511'th 512'th 513'th 514'th 515'th 516'th 517'th 518'th 519'th 520'th 521'st 522'nd 523'rd 524'th 750'th 751'st 752'nd 753'rd 754'th 755'th 756'th 757'th 758'th 759'th 760'th 761'st 762'nd 763'rd 764'th 765'th 766'th 767'th 768'th 769'th 770'th 771'st 772'nd 773'rd 774'th 1000'th 1001'st 1002'nd 1003'rd 1004'th 1005'th 1006'th 1007'th 1008'th 1009'th 1010'th 1011'th 1012'th 1013'th 1014'th 1015'th 1016'th 1017'th 1018'th 1019'th 1020'th 1021'st 1022'nd 1023'rd 1024'th
Alternate version <lang python>#!/usr/bin/env python3
def ord(n):
try:
s = ['st', 'nd', 'rd'][(n-1)%10]
if (n-10)%100//10:
return str(n)+s
except IndexError:
pass
return str(n)+'th'
if __name__ == '__main__':
print(*(ord(n) for n in range(26))) print(*(ord(n) for n in range(250,266))) print(*(ord(n) for n in range(1000,1026)))</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
R
Note that R vectors are 1-indexed. <lang rsplus>nth <- function(n) {
if (length(n) > 1) return(sapply(n, nth))
mod <- function(m, n) ifelse(!(m%%n), n, m%%n)
suffices <- c("th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th")
if (n %% 100 <= 10 || n %% 100 > 20)
suffix <- suffices[mod(n+1, 10)]
else
suffix <- 'th'
paste(n, "'", suffix, sep="")
}
range <- list(0:25, 250:275, 500:525, 750:775, 1000:1025)
sapply(range, nth)</lang>
- Output:
[,1] [,2] [,3] [,4] [,5] [1,] "0'th" "250'th" "500'th" "750'th" "1000'th" [2,] "1'st" "251'st" "501'st" "751'st" "1001'st" [3,] "2'nd" "252'nd" "502'nd" "752'nd" "1002'nd" [4,] "3'rd" "253'rd" "503'rd" "753'rd" "1003'rd" [5,] "4'th" "254'th" "504'th" "754'th" "1004'th" [6,] "5'th" "255'th" "505'th" "755'th" "1005'th" [7,] "6'th" "256'th" "506'th" "756'th" "1006'th" [8,] "7'th" "257'th" "507'th" "757'th" "1007'th" [9,] "8'th" "258'th" "508'th" "758'th" "1008'th" [10,] "9'th" "259'th" "509'th" "759'th" "1009'th" [11,] "10'th" "260'th" "510'th" "760'th" "1010'th" [12,] "11'th" "261'st" "511'th" "761'st" "1011'th" [13,] "12'th" "262'nd" "512'th" "762'nd" "1012'th" [14,] "13'th" "263'rd" "513'th" "763'rd" "1013'th" [15,] "14'th" "264'th" "514'th" "764'th" "1014'th" [16,] "15'th" "265'th" "515'th" "765'th" "1015'th" [17,] "16'th" "266'th" "516'th" "766'th" "1016'th" [18,] "17'th" "267'th" "517'th" "767'th" "1017'th" [19,] "18'th" "268'th" "518'th" "768'th" "1018'th" [20,] "19'th" "269'th" "519'th" "769'th" "1019'th" [21,] "20'th" "270'th" "520'th" "770'th" "1020'th" [22,] "21'st" "271'st" "521'st" "771'st" "1021'st" [23,] "22'nd" "272'nd" "522'nd" "772'nd" "1022'nd" [24,] "23'rd" "273'rd" "523'rd" "773'rd" "1023'rd" [25,] "24'th" "274'th" "524'th" "774'th" "1024'th" [26,] "25'th" "275'th" "525'th" "775'th" "1025'th"
Racket
<lang racket>#lang racket (define (teen? n) (<= 11 (modulo n 100) 19)) (define (Nth n)
(format
"~a'~a" n
(match* ((modulo n 10) n)
[((or 1 2 3) (? teen?)) 'th] [(1 _) 'st] [(2 _) 'nd] [(3 _) 'rd] [(_ _) 'th])))
(for ((range (list (in-range 26) (in-range 250 266) (in-range 1000 1026))))
(displayln (string-join (for/list ((nth (sequence-map Nth range))) nth) " ")))</lang>
- Output:
0'th 1'st 2'nd 3'rd 4'th 5'th 6'th 7'th 8'th 9'th 10'th 11'th 12'th 13'th 14'th 15'th 16'th 17'th 18'th 19'th 20'th 21'st 22'nd 23'rd 24'th 25'th 250'th 251'st 252'nd 253'rd 254'th 255'th 256'th 257'th 258'th 259'th 260'th 261'st 262'nd 263'rd 264'th 265'th 1000'th 1001'st 1002'nd 1003'rd 1004'th 1005'th 1006'th 1007'th 1008'th 1009'th 1010'th 1011'th 1012'th 1013'th 1014'th 1015'th 1016'th 1017'th 1018'th 1019'th 1020'th 1021'st 1022'nd 1023'rd 1024'th 1025'th
REXX
This version adds suffixes without apostrophes.
Negative numbers and fractions are also handled. <lang rexx>/*REXX pgm shows ranges of numbers with ordinal (st/nd/rd/th) suffixes.*/ call tell 0, 25 /*show the 1st range of numbers. */ call tell 250, 265 /* " " 2nd " " " */ call tell 1000, 1025 /* " " 3rd " " " */ exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────TELL subroutine─────────────────────*/ tell: procedure; parse arg L,H; $= /*get Low & High #s, nullify list*/
do j=L to H /*process the range, low───►high.*/
$=$ j || th(j) /*append the Nth number to list*/
end /*j*/ /* [↑] $ has a leading blank. */
say 'numbers from ' L " to " H ' (inclusive):' /*display the title.*/ say strip($) /*display the list. */ say /*display blank line*/ return /*return to invoker.*/ /*──────────────────────────────────TH subroutine───────────────────────*/ th: procedure; parse arg x; x=abs(x) /*just use ABS value*/ return word('th st nd rd', 1 + x//10 * (x//100%10 \== 1) * (x//10 < 4) )</lang>
- Output:
using the default inputs
numbers from 0 to 25 (inclusive): 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 numbers from 250 to 265 (inclusive): 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th numbers from 1000 to 1025 (inclusive): 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Ruby
Code (slightly adapted) and methodname taken from ActiveSupport (Ruby on Rails). <lang ruby>class Integer
def ordinalize
num = self.abs
ordinal = if (11..13).include?(num % 100)
"th"
else
case num % 10
when 1; "st"
when 2; "nd"
when 3; "rd"
else "th"
end
end
"#{self}#{ordinal}"
end
end
[(0..25),(250..265),(1000..1025)].each{|r| puts r.map(&:ordinalize).join(", "); puts} </lang>
- Output:
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 250th, 251st, 252nd, 253rd, 254th, 255th, 256th, 257th, 258th, 259th, 260th, 261st, 262nd, 263rd, 264th, 265th 1000th, 1001st, 1002nd, 1003rd, 1004th, 1005th, 1006th, 1007th, 1008th, 1009th, 1010th, 1011th, 1012th, 1013th, 1014th, 1015th, 1016th, 1017th, 1018th, 1019th, 1020th, 1021st, 1022nd, 1023rd, 1024th, 1025th
Rust
<lang rust>fn nth(num: i32) -> String {
format!("{}{}", num, match (num % 10, num % 100) {
(1, 11) => "th",
(1, _) => "st",
(2, 12) => "th",
(2, _) => "nd",
(3, 13) => "th",
(3, _) => "rd",
_ => "th"
})
}
fn main() {
let ranges = vec![
(0, 26),
(250, 266),
(1000, 1026)
];
for &(s, e) in ranges.iter() {
println!("[{}, {}) :", s, e);
for i in s..e {
print!("{}, ", nth(i));
}
println!("");
}
}</lang>
- Output:
[0, 26) : 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, [250, 266) : 250th, 251st, 252nd, 253rd, 254th, 255th, 256th, 257th, 258th, 259th, 260th, 261st, 262nd, 263rd, 264th, 265th, [1000, 1026) : 1000th, 1001st, 1002nd, 1003rd, 1004th, 1005th, 1006th, 1007th, 1008th, 1009th, 1010th, 1011th, 1012th, 1013th, 1014th, 1015th, 1016th, 1017th, 1018th, 1019th, 1020th, 1021st, 1022nd, 1023rd, 1024th, 1025th,
Scala
<lang Scala>object Nth extends App {
def abbrevNumber(i: Int) = print(s"$i${ordinalAbbrev(i)} ")
def ordinalAbbrev(n: Int) = {
val ans = "th" //most of the time it should be "th"
if (n % 100 / 10 == 1) ans //teens are all "th"
else (n % 10) match {
case 1 => "st"
case 2 => "nd"
case 3 => "rd"
case _ => ans
}
}
(0 to 25).foreach(abbrevNumber) println() (250 to 265).foreach(abbrevNumber) println(); (1000 to 1025).foreach(abbrevNumber)
}</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
const func string: suffix (in integer: num) is func
result var string: suffix is ""; begin if num rem 10 = 1 and num rem 100 <> 11 then suffix := "st"; elsif num rem 10 = 2 and num rem 100 <> 12 then suffix := "nd"; elsif num rem 10 = 3 and num rem 100 <> 13 then suffix := "rd"; else suffix := "th"; end if; end func;
const proc: printImages (in integer: start, in integer: stop) is func
local
var integer: num is 0;
begin
for num range start to stop do
write(num <& suffix(num) <& " ");
end for;
writeln;
end func;
const proc: main is func
begin printImages( 0, 25); printImages( 250, 265); printImages(1000, 1025); end func;</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Sidef
<lang ruby>func nth(n) {
var irregulars = Hash.new(<1 ˢᵗ 2 ⁿᵈ 3 ʳᵈ 11 ᵗʰ 12 ᵗʰ 13 ᵗʰ>...); n.to_s + (irregulars[n % 100] \\ irregulars[n % 10] \\ 'ᵗʰ');
}
[range(0, 25), range(250, 265), range(1000, 1025)].each { |r|
say r.map {|n| nth(n) }.join(" ");
};</lang>
- Output:
0ᵗʰ 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ᵗʰ 250ᵗʰ 251ˢᵗ 252ⁿᵈ 253ʳᵈ 254ᵗʰ 255ᵗʰ 256ᵗʰ 257ᵗʰ 258ᵗʰ 259ᵗʰ 260ᵗʰ 261ˢᵗ 262ⁿᵈ 263ʳᵈ 264ᵗʰ 265ᵗʰ 1000ᵗʰ 1001ˢᵗ 1002ⁿᵈ 1003ʳᵈ 1004ᵗʰ 1005ᵗʰ 1006ᵗʰ 1007ᵗʰ 1008ᵗʰ 1009ᵗʰ 1010ᵗʰ 1011ᵗʰ 1012ᵗʰ 1013ᵗʰ 1014ᵗʰ 1015ᵗʰ 1016ᵗʰ 1017ᵗʰ 1018ᵗʰ 1019ᵗʰ 1020ᵗʰ 1021ˢᵗ 1022ⁿᵈ 1023ʳᵈ 1024ᵗʰ 1025ᵗʰ
Swift
<lang Swift>func addSuffix(n:Int) -> String {
if n % 100 / 10 == 1 {
return "th"
}
switch n % 10 {
case 1:
return "st"
case 2:
return "nd"
case 3:
return "rd"
default:
return "th"
}
}
for i in 0...25 {
print("\(i)\(addSuffix(i)) ")
} println() for i in 250...265 {
print("\(i)\(addSuffix(i)) ")
} println() for i in 1000...1025 {
print("\(i)\(addSuffix(i)) ")
} println()</lang>
- Output:
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 250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th 1000th 1001st 1002nd 1003rd 1004th 1005th 1006th 1007th 1008th 1009th 1010th 1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd 1024th 1025th
Tcl
<lang tcl>proc ordinal {n} {
if {$n%100<10 || $n%100>20} {
set suff [lindex {th st nd rd th th th th th th} [expr {$n % 10}]]
} else {
set suff th
} return "$n'$suff"
}
foreach start {0 250 1000} {
for {set n $start; set l {}} {$n<=$start+25} {incr n} {
lappend l [ordinal $n]
} puts $l
}</lang>
- Output:
0'th 1'st 2'nd 3'rd 4'th 5'th 6'th 7'th 8'th 9'th 10'th 11'th 12'th 13'th 14'th 15'th 16'th 17'th 18'th 19'th 20'th 21'st 22'nd 23'rd 24'th 25'th 250'th 251'st 252'nd 253'rd 254'th 255'th 256'th 257'th 258'th 259'th 260'th 261'st 262'nd 263'rd 264'th 265'th 266'th 267'th 268'th 269'th 270'th 271'st 272'nd 273'rd 274'th 275'th 1000'th 1001'st 1002'nd 1003'rd 1004'th 1005'th 1006'th 1007'th 1008'th 1009'th 1010'th 1011'th 1012'th 1013'th 1014'th 1015'th 1016'th 1017'th 1018'th 1019'th 1020'th 1021'st 1022'nd 1023'rd 1024'th 1025'th
uBasic/4tH
<lang>For x = 0 to 25 ' Test range 0..25
Push x : GoSub _PrintOrdinal
Next x : Print
For x = 250 to 265 ' Test range 250..265
Push x : GoSub _PrintOrdinal
Next x : Print
For x = 1000 to 1025 ' Test range 1000..1025
Push x : GoSub _PrintOrdinal
Next x : Print
End ' End test program
' ( n --)
_PrintOrdinal ' Ordinal subroutine
If Tos() > -1 Then ' If within range then
Print Using "____#";Tos();"'"; ' Print the number
' Take care of 11, 12 and 13
If (Tos()%100 > 10) * (Tos()%100 < 14) Then
Gosub (Pop() * 0) + 100 ' Clear stack and print "th"
Return ' We're done here
EndIf
Push Pop() % 10 ' Calculate n mod 10 GoSub 100 + 10 * ((Tos()>0) + (Tos()>1) + (Tos()>2) - (3 * (Pop()>3))) Else ' And decide which ordinal to use Print Pop();" is less than zero" ' Otherwise, it is an error EndIf
Return
' Select and print proper ordinal
100 Print "th"; : Return 110 Print "st"; : Return 120 Print "nd"; : Return 130 Print "rd"; : Return</lang>
- Output:
0'th 1'st 2'nd 3'rd 4'th 5'th 6'th 7'th 8'th 9'th 10'th 11'th 12'th 13'th 14'th 15'th 16'th 17'th 18'th 19'th 20'th 21'st 22'nd 23'rd 24'th 25'th 250'th 251'st 252'nd 253'rd 254'th 255'th 256'th 257'th 258'th 259'th 260'th 261'st 262'nd 263'rd 264'th 265'th 1000'th 1001'st 1002'nd 1003'rd 1004'th 1005'th 1006'th 1007'th 1008'th 1009'th 1010'th 1011'th 1012'th 1013'th 1014'th 1015'th 1016'th 1017'th 1018'th 1019'th 1020'th 1021'st 1022'nd 1023'rd 1024'th 1025'th
zkl
Two versions, your choice <lang zkl>#if 0 fcn addSuffix(n){
z:=n.abs()%100; if(11<=z<=13) return(String(n,"th")); z=z%10; String(n,(z==1 and "st") or (z==2 and "nd") or (z==3 and "rd") or "th");
}
- else
fcn addSuffix(n){
var suffixes=T("th","st","nd","rd","th","th","th","th","th","th"); //0..10
z:=n.abs()%100;
String(n,(z<=10 or z>20) and suffixes[z%10] or "th");
}
- endif</lang>
<lang zkl>[0..25] .apply(addSuffix).concat(",").println(); [250..265] .apply(addSuffix).concat(",").println(); [1000..1025].apply(addSuffix).concat(",").println();</lang>
- Output:
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 250th,251st,252nd,253rd,254th,255th,256th,257th,258th,259th,260th,261st,262nd,263rd,264th,265th 1000th,1001st,1002nd,1003rd,1004th,1005th,1006th,1007th,1008th,1009th,1010th,1011th,1012th,1013th,1014th,1015th,1016th,1017th,1018th,1019th,1020th,1021st,1022nd,1023rd,1024th,1025th
- Programming Tasks
- Ordinal numbers
- String manipulation
- Ada
- ALGOL 68
- Applesoft BASIC
- AutoHotkey
- AWK
- Babel
- Batch File
- BBC BASIC
- Befunge
- C
- C++
- C sharp
- Clojure
- Common Lisp
- D
- Elixir
- ERRE
- Forth
- Fortran
- Examples needing attention
- Go
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Julia
- Mathematica
- MATLAB
- Nim
- Oforth
- PARI/GP
- Perl
- Lingua::EN::Numbers::Ordinate
- Perl 6
- PHP
- PicoLisp
- PL/I
- PowerShell
- Prolog
- Python
- R
- Racket
- REXX
- Ruby
- Rust
- Scala
- Seed7
- Sidef
- Swift
- Tcl
- UBasic/4tH
- Zkl