N'th: Difference between revisions
m Made apostrophes consistent in task example |
jq |
||
Line 735:
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 </pre>
=={{header|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:<lang jq>
["-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"]
</lang>
=={{header|Mathematica}}==
I borrowed the logic from the Python code.
Line 756 ⟶ 781:
{"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"}</pre>
=={{Header|MATLAB}}==
|
Revision as of 05:57, 26 July 2014
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>
This code produces the following output when run:
<lang babel>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</lang>
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
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 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)))
(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
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
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:<lang jq> ["-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"] </lang>
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
Nimrod
<lang nimrod>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
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
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ᵗʰ
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
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
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
Scala
<lang Scala>object Nth extends App {
def ordinalAbbrev(n: Int) = { val ans = "th" //most of the time it should be "th" if (n % 100 == 10 ) ans //teens are all "th" else (n % 10) match { case 1 => "st" case 2 => "nd" case 3 => "rd" case _ => ans } }
def abbrevNumber(i: Int) { print(i + ordinalAbbrev(i) + " ") }
(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
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