N'th: Difference between revisions

Line 20:

<~~lang~~ 11l>V _suffix = [‘th’, ‘st’, ‘nd’, ‘rd’, ‘th’, ‘th’, ‘th’, ‘th’, ‘th’, ‘th’]

<syntaxhighlight lang="11l">V _suffix = [‘th’, ‘st’, ‘nd’, ‘rd’, ‘th’, ‘th’, ‘th’, ‘th’, ‘th’, ‘th’]

F nth(n)

Line 26:

L(j) (0..1000).step(250)

print_elements(Array(j.+25).map(i -> nth(i)))</~~lang~~>

print_elements(Array(j.+25).map(i -> nth(i)))</syntaxhighlight>

Line 39:

=={{header|68000 Assembly}}==

The function itself:

<~~lang~~ 68000devpac>Nth:

<syntaxhighlight lang="68000devpac">Nth:

MOVEQ #1,D1

.loop:

Line 97:

rd:

dc.b "rd",255

even</~~lang~~>

even</syntaxhighlight>

And the test cases (each was executed in separate builds of the Sega Genesis cartridge to have enough room to see them all at once)

<~~lang~~ 68000devpac>MOVE.w #0,D0

<syntaxhighlight lang="68000devpac">MOVE.w #0,D0

MOVE.W #25,D7

JSR Nth

Line 112:

JSR Nth

jmp * ;stop the cpu - we're done.</~~lang~~>

jmp * ;stop the cpu - we're done.</syntaxhighlight>

Line 120:

=={{header|8080 Assembly}}==

<~~lang~~ asm> org 100h

<syntaxhighlight lang="asm"> org 100h

jmp demo

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Line 196:

dcr b ; Decrement counter

jnz printnums ; If not zero, print next number

ret</~~lang~~>

ret</syntaxhighlight>

Line 212:

<~~lang~~ asm> bits 16

<syntaxhighlight lang="asm"> bits 16

cpu 8086

segment .text

Line 269:

dec bl ; Are we done yet?

jnz printn

ret</~~lang~~>

ret</syntaxhighlight>

Line 283:

=={{header|Action!}}==

<~~lang~~ ~~Action~~!>PROC Nth(CARD val,CHAR ARRAY s)

<syntaxhighlight lang="action!">PROC Nth(CARD val,CHAR ARRAY s)

CHAR ARRAY sfx

BYTE d

Line 321:

PutE() PutE()

OD

RETURN</~~lang~~>

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/N'th.png Screenshot from Atari 8-bit computer]

Line 334:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_IO;

<syntaxhighlight lang="ada">with Ada.Text_IO;

procedure Nth is

Line 359:

Print_Images( 250, 265);

Print_Images(1000, 1025);

end Nth;</~~lang~~>

end Nth;</syntaxhighlight>

Line 368:

=={{header|ALGOL 68}}==

<~~lang~~ algol68># PROC to suffix a number with st, nd, rd or th as appropriate #

<syntaxhighlight lang="algol68"># PROC to suffix a number with st, nd, rd or th as appropriate #

PROC nth = ( INT number )STRING:

BEGIN

Line 416:

test nth( 1000, 1025 )

)</~~lang~~>

)</syntaxhighlight>

<pre>

Line 437:

<~~lang~~ ~~APL~~> nth←{

<syntaxhighlight lang="apl"> nth←{

sfx←4 2⍴'stndrdth'

tens←(10<100|⍵)∧20>100|⍵

(⍕⍵),sfx[(4×tens)⌈(⍳3)⍳10|⍵;]

}</~~lang~~>

}</syntaxhighlight>

Line 459:

=={{header|AppleScript}}==

<~~lang~~ ~~AppleScript~~>-- ORDINAL STRINGS -----------------------------------------------------------

<syntaxhighlight lang="applescript">-- ORDINAL STRINGS -----------------------------------------------------------

-- ordinalString :: Int -> String

Line 540:

end |λ|

end script

end uncurry</~~lang~~>

end uncurry</syntaxhighlight>

<pre>{{"0th", "1st", "2nd", "3rd", "4th", "5th", "6th", "7th", "8th", "9th",

Line 553:

=={{header|Applesoft BASIC}}==

<~~lang~~ ~~ApplesoftBasic~~>0 OP = 1

<syntaxhighlight lang="applesoftbasic">0 OP = 1

10 FOR N = 0 TO 25 : GOSUB 100 : NEXT

20 FOR N = 250 TO 265 : GOSUB 100 : NEXT

Line 571:

260 IF NOT OP THEN NTH$ = "'" + NTH$

270 NTH$ = STR$(N) + NTH$

280 RETURN</~~lang~~>

280 RETURN</syntaxhighlight>

=={{header|Arturo}}==

<~~lang~~ rebol>suffixes: ["th" "st" "nd" "rd" "th" "th" "th" "th" "th" "th"]

<syntaxhighlight lang="rebol">suffixes: ["th" "st" "nd" "rd" "th" "th" "th" "th" "th" "th"]

nth: function [n][

Line 589:

prints (nth i)++" "

print ""

]</~~lang~~>

]</syntaxhighlight>

Line 601:

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>for k, v in [[0, 25], [250, 265], [1000, 1025]] {

<syntaxhighlight lang="autohotkey">for k, v in [[0, 25], [250, 265], [1000, 1025]] {

while v[1] <= v[2] {

Out .= Ordinal(v[1]) " "

Line 616:

s1 := Mod(n, 10)

return n (s1 = 1 ? "st" : s1 = 2 ? "nd" : s1 = 3 ? "rd" : "th")

}</~~lang~~>

}</syntaxhighlight>

<pre>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

Line 623:

=={{header|AWK}}==

# syntax: GAWK -f NTH.AWK

BEGIN {

Line 656:

return(nthday)

}

</syntaxhighlight>

</lang>

<pre>

Line 666:

=={{header|Babel}}==

<~~lang~~ babel>((irregular ("st" "nd" "rd"))

<syntaxhighlight lang="babel">((irregular ("st" "nd" "rd"))

(main

Line 693:

. . }

{ -> %d "'th" . }

ifte }))</~~lang~~>

ifte }))</syntaxhighlight>

Line 707:

=={{header|BaCon}}==

<~~lang~~ freebasic>' Nth (sans apostrophes)

<syntaxhighlight lang="freebasic">' Nth (sans apostrophes)

FUNCTION nth$(NUMBER n) TYPE STRING

LOCAL suffix

Line 734:

DATA 0, 25, 250, 265, 1000, 1025, -20, -11</~~lang~~>

DATA 0, 25, 250, 265, 1000, 1025, -20, -11</syntaxhighlight>

Line 750:

=={{header|BASIC}}==

==={{header|BASIC256}}===

function ordinal(n)

ns$ = string(n)

Line 779:

call imprimeOrdinal (1000, 1025)

end

</syntaxhighlight>

</lang>

==={{header|Commodore BASIC}}===

<~~lang~~ basic>

0 REM ROSETTACODE.ORG

1 REM N'TH

Line 813:

270 NTH$ = STR$(N) + NTH$

280 RETURN

</syntaxhighlight>

</lang>

Commodore 64 (40 column text)

Line 837:

<~~lang~~ basic>

10 REM N'th

20 LOLIM=0

Line 865:

1540 SUF$="th"

1550 RETURN

</syntaxhighlight>

</lang>

<pre>

Line 874:

==={{header|QBasic}}===

<~~lang~~ basic>

DECLARE FUNCTION sufijo$ (n%)

DECLARE SUB imprimeOrdinal (loLim%, hiLim%)

Line 911:

END IF

END FUNCTION

</syntaxhighlight>

</lang>

=={{header|Batch File}}==

<~~lang~~ dos>@echo off

<syntaxhighlight lang="dos">@echo off

::Main thing...

call :Nth 0 25

Line 934:

)

echo."!range_output:~1!"

goto :EOF</~~lang~~>

goto :EOF</syntaxhighlight>

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

Line 943:

=={{header|BBC BASIC}}==

<~~lang~~ bbcbasic> PROCNth( 0, 25)

<syntaxhighlight lang="bbcbasic"> PROCNth( 0, 25)

PROCNth( 250, 265)

PROCNth(1000,1025)

Line 958:

PRINT

ENDPROC</~~lang~~>

ENDPROC</syntaxhighlight>

Line 967:

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

// Generate ASCII string of number n with ordinal suffix

Line 1,006:

for i = 250 to 265 do writef("%S*N", nth(i, buf))

for i = 1000 to 1025 do writef("%S*N", nth(i, buf))

$)</~~lang~~>

$)</syntaxhighlight>

<pre style="height:50ex">0th

Line 1,079:

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

<syntaxhighlight lang="befunge">0>55*:>1-\:0\`!v

#v$#$<^:\+*8"}"_

>35*:>1-\:0\`!v

Line 1,090:

htdd >$>:#,_$:vg

v"d"\*!`3:%+55<9

>%55+/1-!!*:8g,^</~~lang~~>

>%55+/1-!!*:8g,^</syntaxhighlight>

Line 1,096:

=={{header|BQN}}==

<~~lang~~ bqn>Nth ← {

<syntaxhighlight lang="bqn">Nth ← {

sfx ← ⟨"th","st","nd","rd"⟩

(•Fmt 𝕩)∾sfx⊑˜ (1≠10|⌊𝕩÷10)×(3≥10|𝕩)×10|𝕩

}

∘‿4⥊ Nth¨ (↕26) ∾ (250+↕16) ∾ (1000+↕26)</~~lang~~>

∘‿4⥊ Nth¨ (↕26) ∾ (250+↕16) ∾ (1000+↕26)</syntaxhighlight>

<pre>┌─

Line 1,123:

┘</pre>

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

char* addSuffix(int num, char* buf, size_t len)

Line 1,174:

return 0;

}</~~lang~~>

}</syntaxhighlight>

Another method with dynamic memory allocation

<~~lang~~ c>#include <stdlib.h>

<syntaxhighlight lang="c">#include <stdlib.h>

#include <stdio.h>

Line 1,208:

print_range(250, 265);

print_range(1000, 1025);

}</~~lang~~>

}</syntaxhighlight>

<pre>Set [0,25] :

Line 1,219:

=={{header|C sharp|C#}}==

<~~lang~~ csharp>using System;

<syntaxhighlight lang="csharp">using System;

using System.Linq;

Line 1,250:

Console.WriteLine(string.Join(" ", Enumerable.Range(1000, 26).Select(Ordinalize)));

}

}</~~lang~~>

}</syntaxhighlight>

Dotnet 5 version without LINQ

<~~lang~~ csharp>using System;

<syntaxhighlight lang="csharp">using System;

static string Ordinalize(int i)

Line 1,273:

PrintRange(0, 25);

PrintRange(250, 265);

PrintRange(1000, 1025);</~~lang~~>

PrintRange(1000, 1025);</syntaxhighlight>

Line 1,281:

=={{header|C++}}==

<~~lang~~ cpp>#include <string>

<syntaxhighlight lang="cpp">#include <string>

#include <iostream>

Line 1,321:

return 0;

}</~~lang~~>

}</syntaxhighlight>

<pre>Set [0,25] :

Line 1,331:

=={{header|Clojure}}==

<~~lang~~ clojure>

(defn n-th [n]

(str n

Line 1,346:

(apply str (interpose " " (map n-th (range 250 266))))

(apply str (interpose " " (map n-th (range 1000 1026))))

</syntaxhighlight>

</lang>

<pre>

Line 1,357:

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))))

</syntaxhighlight>

</lang>

<pre>

Line 1,366:

=={{header|CLU}}==

<~~lang~~ clu>nth = proc (n: int) returns (string)

<syntaxhighlight lang="clu">nth = proc (n: int) returns (string)

num: string := int$unparse(n)

sfx: array[string] := array[string]$[0: "th", "st", "nd", "rd"]

Line 1,396:

do_range(250,265)

do_range(1000,1025)

end start_up</~~lang~~>

end start_up</syntaxhighlight>

<pre>0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th

Line 1,411:

=={{header|COBOL}}==

COBOL stores numbers in decimal form, so there is no need to use a modulo function: the last digit or the last two digits can be extracted directly.

<~~lang~~ cobol>IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol">IDENTIFICATION DIVISION.

PROGRAM-ID. NTH-PROGRAM.

DATA DIVISION.

Line 1,441:

IF LAST-DIGIT IS EQUAL TO 1 THEN MOVE 'ST' TO SUFFIX.

IF LAST-DIGIT IS EQUAL TO 2 THEN MOVE 'ND' TO SUFFIX.

IF LAST-DIGIT IS EQUAL TO 3 THEN MOVE 'RD' TO SUFFIX.</~~lang~~>

IF LAST-DIGIT IS EQUAL TO 3 THEN MOVE 'RD' TO SUFFIX.</syntaxhighlight>

Output:

=={{header|Common Lisp}}==

<~~lang~~ lisp>(defun add-suffix (number)

<syntaxhighlight lang="lisp">(defun add-suffix (number)

(let* ((suffixes #10("th" "st" "nd" "rd" "th"))

(last2 (mod number 100))

Line 1,454:

(svref suffixes last-digit))))

(format nil "~a~a" number suffix)))

</syntaxhighlight>

</lang>

A more concise, albeit less readable version:

<~~lang~~ lisp>(defun add-suffix (n)

<syntaxhighlight lang="lisp">(defun add-suffix (n)

(format nil "~d'~:[~[th~;st~;nd~;rd~:;th~]~;th~]" n (< (mod (- n 10) 100) 10) (mod n 10)))

</syntaxhighlight>

</lang>

Display the results:

<~~lang~~ lisp>(loop for (low high) in '((0 25) (250 265) (1000 1025))

<syntaxhighlight lang="lisp">(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~~>

finally (terpri))))</syntaxhighlight>

Line 1,477:

=={{header|Cowgol}}==

<~~lang~~ cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

include "strings.coh";

Line 1,516:

test(0, 25);

test(250,265);

test(1000,1025);</~~lang~~>

test(1000,1025);</syntaxhighlight>

Line 1,531:

=={{header|Crystal}}==

<~~lang~~ ruby>struct Int

<syntaxhighlight lang="ruby">struct Int

def ordinalize

num = self.abs

Line 1,549:

[(0..25),(250..265),(1000..1025)].each{|r| puts r.map{ |n| n.ordinalize }.join(", "); puts}

</syntaxhighlight>

</lang>

<pre>

Line 1,561:

=={{header|D}}==

<~~lang~~ d>import std.stdio, std.string, std.range, std.algorithm;

<syntaxhighlight lang="d">import std.stdio, std.string, std.range, std.algorithm;

string nth(in uint n) pure {

Line 1,572:

foreach (r; [iota(26), iota(250, 266), iota(1000, 1026)])

writefln("%-(%s %)", r.map!nth);

}</~~lang~~>

}</syntaxhighlight>

<pre>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

Line 1,582:

=={{header|Draco}}==

<~~lang~~ draco>proc nonrec nth(word n; *char buf) *char:

<syntaxhighlight lang="draco">proc nonrec nth(word n; *char buf) *char:

channel output text ch;

open(ch, buf);

Line 1,613:

print_range(250, 265);

print_range(1000, 1025)

corp</~~lang~~>

corp</syntaxhighlight>

<pre>0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th

Line 1,627:

ELENA 5.0 :

<~~lang~~ elena>import extensions;

<syntaxhighlight lang="elena">import extensions;

import system'math;

import system'routines;

Line 1,655:

console.printLine(new Range(250,26).selectBy(mssgconst ordinalize<op>[1]));

console.printLine(new Range(1000,26).selectBy(mssgconst ordinalize<op>[1]))

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 1,664:

=={{header|Elixir}}==

<~~lang~~ elixir>defmodule RC do

<syntaxhighlight lang="elixir">defmodule RC do

def ordinalize(n) do

num = abs(n)

Line 1,683:

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~~>

end)</syntaxhighlight>

Line 1,693:

=={{header|ERRE}}==

PROGRAM NTH_SOLVE

Line 1,717:

NTH(1000,1025)

END PROGRAM

</syntaxhighlight>

</lang>

<pre>

Line 1,730:

=={{header|F_Sharp|F#}}==

<~~lang~~ fsharp>open System

<syntaxhighlight lang="fsharp">open System

let ordinalsuffix n =

Line 1,745:

[1000..1025] |> show

0

</syntaxhighlight>

</lang>

<pre> 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

Line 1,752:

=={{header|Factor}}==

<~~lang~~ factor>USING: io kernel math math.order math.parser math.ranges qw

<syntaxhighlight lang="factor">USING: io kernel math math.order math.parser math.ranges qw

sequences ;

IN: rosetta-code.nth

Line 1,765:

[ [ n'th write bl ] each nl ] tri@ ;

MAIN: n'th-demo</~~lang~~>

MAIN: n'th-demo</syntaxhighlight>

<pre>

Line 1,774:

=={{header|Forth}}==

<~~lang~~ forth>: 'nth ( -- c-addr ) s" th st nd rd th th th th th th " drop ;

<syntaxhighlight 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

Line 1,783:

26 0 test 266 250 test 1026 1000 test ;

tests</~~lang~~>

tests</syntaxhighlight>

Line 1,814:

Please find the compilation instructions and examples in comments at the start of the source.

<~~lang~~ ~~Fortran~~>!-*- mode: compilation; default-directory: "/tmp/" -*-

<syntaxhighlight lang="fortran">!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Fri Jun 6 15:40:18

!

Line 1,904:

end function ordinate

end program nth</~~lang~~>

end program nth</syntaxhighlight>

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>' FB 1.05.0 Win64

<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64

' Apostrophes NOT used as incorrect English

Line 1,945:

Print "Press any key to quit"

Sleep</~~lang~~>

Sleep</syntaxhighlight>

<pre>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

Line 1,956:

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=6d60749ae886a37f128e75cffc6c7118 Click this link to run this code]'''

<~~lang~~ gambas>Public Sub Main()

<syntaxhighlight lang="gambas">Public Sub Main()

Dim siNums As Short[] = [0, 25, 250, 265, 1000, 1025]

Dim siCount, siNumbers As Short

Line 1,972:

End </~~lang~~>

End </syntaxhighlight>

Output:

<pre>

Line 1,984:

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import "fmt"

Line 2,020:

}

fmt.Println()

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 2,031:

<~~lang~~ qbasic>

10 ' N'th

20 LET LOLIM% = 0

Line 2,060:

1800 LET SUF$ = "th"

2000 RETURN

</syntaxhighlight>

</lang>

<pre>

Line 2,069:

=={{header|Haskell}}==

<~~lang~~ haskell>import Data.Array

<syntaxhighlight lang="haskell">import Data.Array

ordSuffs :: Array Integer String

Line 2,087:

printOrdSuffs [ 0.. 25]

printOrdSuffs [ 250.. 265]

printOrdSuffs [1000..1025]</~~lang~~>

printOrdSuffs [1000..1025]</syntaxhighlight>

<pre>

Line 2,098:

The following works in both languages.

<~~lang~~ unicon>procedure main(A)

<syntaxhighlight lang="unicon">procedure main(A)

every writes(" ",nth(0 to 25) | "\n")

every writes(" ",nth(250 to 265) | "\n")

Line 2,108:

(n%10 = 2, n%100 ~= 12, "nd") |

(n%10 = 3, n%100 ~= 13, "rd") | "th")

end</~~lang~~>

end</syntaxhighlight>

Line 2,123:

Implementation:

<~~lang~~ J>suf=: (;:'th st nd rd th') {::~ 4 <. 10 10 (* 1&~:)~/@#: ]

<syntaxhighlight lang="j">suf=: (;:'th st nd rd th') {::~ 4 <. 10 10 (* 1&~:)~/@#: ]

nth=: [: ;:inv (": , suf)each</~~lang~~>

nth=: [: ;:inv (": , suf)each</syntaxhighlight>

Task:

<~~lang~~ J> thru=: <./ + i.@(+ *)@-~

<syntaxhighlight 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

Line 2,134:

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~~>

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</syntaxhighlight>

=={{header|Java}}==

<~~lang~~ java>public class Nth {

<syntaxhighlight lang="java">public class Nth {

public static String ordinalAbbrev(int n){

String ans = "th"; //most of the time it should be "th"

Line 2,162:

}

}</~~lang~~>

}</syntaxhighlight>

<~~lang~~ java>package nth;

<syntaxhighlight lang="java">package nth;

import java.util.stream.IntStream;

Line 2,211:

;

}

}</~~lang~~>

}</syntaxhighlight>

<pre>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

Line 2,221:

===ES5===

<~~lang~~ ~~JavaScript~~>console.log(function () {

<syntaxhighlight lang="javascript">console.log(function () {

var lstSuffix = 'th st nd rd th th th th th th'.split(' '),

Line 2,244:

}).join('\n\n');

}());</~~lang~~>

}());</syntaxhighlight>

<~~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

<syntaxhighlight 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~~>

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</syntaxhighlight>

===ES6===

<~~lang~~ ~~JavaScript~~>(function (lstTestRanges) {

<syntaxhighlight lang="javascript">(function (lstTestRanges) {

'use strict'

Line 2,283:

);

})([[0, 25], [250, 265], [1000, 1025]]);</~~lang~~>

})([[0, 25], [250, 265], [1000, 1025]]);</syntaxhighlight>

Line 2,298:

=={{header|jq}}==

# ordinalize an integer input, positive or negative

def ordinalize:

Line 2,316:

([range(-5; -1)], [range(0;26)], [range(250;266)], [range(1000;1026)])

| map(ordinalize)

</syntaxhighlight>

</lang>

<pre>

Line 2,326:

=={{header|Julia}}==

<lang julia>using Printf</~~lang~~>

<syntaxhighlight lang="julia">using Printf</syntaxhighlight>

'''Function''':

<~~lang~~ julia>function ordinal(n::Integer)

<syntaxhighlight lang="julia">function ordinal(n::Integer)

n < 0 && throw(DomainError())

suffixes = ("st", "nd", "rd")

Line 2,339:

end

return string(n, suf)

end</~~lang~~>

end</syntaxhighlight>

'''Main''':

<~~lang~~ julia>println("Tests of ordinal formatting of integers.")

<syntaxhighlight lang="julia">println("Tests of ordinal formatting of integers.")

for (i, n) in enumerate(0:25)

(i - 1) % 10 == 0 && println()

Line 2,358:

(i - 1) % 10 == 0 && println()

@printf("%7s", ordinal(n))

end</~~lang~~>

end</syntaxhighlight>

'''Main2''':

<~~lang~~ julia>Nth(x::Integer) = if x % 100 ∈ [11, 12, 13] "th" else ["th", "st", "nd", "rd", "th"][min(x % 10 + 1, 5)] end

<syntaxhighlight lang="julia">Nth(x::Integer) = if x % 100 ∈ [11, 12, 13] "th" else ["th", "st", "nd", "rd", "th"][min(x % 10 + 1, 5)] end

NthA(x::Integer) = "$(x)'$(Nth(x)) "

[0:25..., 250:265..., 1000:1025...] .|> NthA .|> print;</~~lang~~>

[0:25..., 250:265..., 1000:1025...] .|> NthA .|> print;</syntaxhighlight>

Line 2,379:

=={{header|Kotlin}}==

<~~lang~~ scala>fun Int.ordinalAbbrev() =

<syntaxhighlight lang="scala">fun Int.ordinalAbbrev() =

if (this % 100 / 10 == 1) "th"

else when (this % 10) { 1 -> "st" 2 -> "nd" 3 -> "rd" else -> "th" }

Line 2,387:

fun main(args: Array<String>) {

listOf((0..25), (250..265), (1000..1025)).forEach { println(it.ordinalAbbrev()) }

}</~~lang~~>

}</syntaxhighlight>

=={{header|Lambdatalk}}==

Translation from the javascript entry

<~~lang~~ scheme>

{def fnOrdinalForm

{lambda {:n}

Line 2,411:

1011th 1012th 1013th 1014th 1015th 1016th 1017th 1018th 1019th 1020th

1021st 1022nd 1023rd 1024th 1025th

</syntaxhighlight>

</lang>

=={{header|Liberty BASIC}}==

call printImages 0, 25

call printImages 250, 265

Line 2,449:

end if

end function

</syntaxhighlight>

</lang>

<pre>

Line 2,459:

=={{header|Lua}}==

The apostrophe just looks weird if you ask me. No one did, obviously.

<~~lang~~ ~~Lua~~>function getSuffix (n)

<syntaxhighlight lang="lua">function getSuffix (n)

local lastTwo, lastOne = n % 100, n % 10

if lastTwo > 3 and lastTwo < 21 then return "th" end

Line 2,470:

function Nth (n) return n .. "'" .. getSuffix(n) end

for i = 0, 25 do print(Nth(i), Nth(i + 250), Nth(i + 1000)) end</~~lang~~>

for i = 0, 25 do print(Nth(i), Nth(i + 250), Nth(i + 1000)) end</syntaxhighlight>

Line 2,503:

=={{header|Maple}}==

<~~lang~~ maple>toOrdinal := proc(n:: nonnegint)

<syntaxhighlight lang="maple">toOrdinal := proc(n:: nonnegint)

if 1 <= n and n <= 10 then

if n >= 4 then

Line 2,527:

end do;

printf("\n\n");

end do;</~~lang~~>

end do;</syntaxhighlight>

<pre>

Line 2,539:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

I borrowed the logic from the Python code.

<~~lang~~ ~~Mathematica~~>suffixlist = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th","th"};

<syntaxhighlight lang="mathematica">suffixlist = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th","th"};

addsuffix[n_] := Module[{suffix},

suffix = Which[

Line 2,550:

addsuffix[#] & /@ Range[0, 25] (* test 1 *)

addsuffix[#] & /@ Range[250, 265] (* test 2 *)

addsuffix[#] & /@ Range[1000, 1025] (* test 3 *)</~~lang~~>

addsuffix[#] & /@ Range[1000, 1025] (* test 3 *)</syntaxhighlight>

<pre>{"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"}

Line 2,559:

=={{header|MATLAB}}==

<~~lang~~ ~~MATLAB~~>function s = nth(n)

<syntaxhighlight lang="matlab">function s = nth(n)

tens = mod(n, 100);

if tens > 9 && tens < 20

Line 2,576:

end

s = sprintf('%d%s', n, suf);

end</~~lang~~>

end</syntaxhighlight>

<pre>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

Line 2,585:

=={{header|Microsoft Small Basic}}==

<~~lang~~ microsoftsmallbasic>

loLim = 0

hiLim = 25

Line 2,618:

EndIf

EndSub

</syntaxhighlight>

</lang>

=={{header|MiniScript}}==

To get the output all on one line, we append it to a list as we go, and then print the list all at once at the end.

<~~lang~~ ~~MiniScript~~>ordinal = function(n)

<syntaxhighlight lang="miniscript">ordinal = function(n)

if n > 3 and n < 20 then return n + "th"

if n % 10 == 1 then return n + "st"

Line 2,641:

test 250, 265

test 1000, 1025

print out.join</~~lang~~>

print out.join</syntaxhighlight>

Line 2,649:

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

<~~lang~~ modula2>

MODULE Nth;

Line 2,695:

PrintImages(1000, 1025);

END Nth.

</syntaxhighlight>

</lang>

=={{header|Nanoquery}}==

<~~lang~~ nanoquery>def ordinalAbbrev(n)

<syntaxhighlight lang="nanoquery">def ordinalAbbrev(n)

if int(n % 100 / 10) = 1

return "th"

Line 2,728:

print (i + "'" + ordinalAbbrev(i) + " ")

end

println</~~lang~~>

println</syntaxhighlight>

<pre>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

Line 2,736:

=={{header|Nim}}==

<~~lang~~ nim>const Suffix = ["th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"]

<syntaxhighlight lang="nim">const Suffix = ["th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"]

proc nth(n: Natural): string =

Line 2,744:

for i in j..j+24:

stdout.write nth(i), " "

echo ""</~~lang~~>

echo ""</syntaxhighlight>

<pre>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

Line 2,754:

=={{header|Objeck}}==

<~~lang~~ objeck>class Nth {

<syntaxhighlight lang="objeck">class Nth {

function : OrdinalAbbrev(n : Int ) ~ String {

ans := "th"; # most of the time it should be "th"

Line 2,788:

};

}

}</~~lang~~>

}</syntaxhighlight>

Line 2,799:

=={{header|OCaml}}==

let show_nth n =

if (n mod 10 = 1) && (n mod 100 <> 11) then "st"

Line 2,815:

List.iter show_ordinals [ (0,25); (250,265); (1000,1025) ]

</syntaxhighlight>

</lang>

Line 2,826:

=={{header|Oforth}}==

<~~lang~~ ~~Oforth~~>: nth(n)

<syntaxhighlight lang="oforth">: nth(n)

| r |

n "th" over 10 mod ->r

Line 2,832:

r 2 == ifTrue: [ n 100 mod 12 == ifFalse: [ drop "nd" ] ]

r 3 == ifTrue: [ n 100 mod 13 == ifFalse: [ drop "rd" ] ]

+ ;</~~lang~~>

+ ;</syntaxhighlight>

Line 2,853:

(Spurious apostrophes intentionally omitted, following Raku.)

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

<syntaxhighlight 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~~>

apply(ordinal, [111, 1012])</syntaxhighlight>

<pre>%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"]

Line 2,866:

=={{header|Pascal}}==

nearly copy of [[N'th#Ada|Ada]]

<~~lang~~ pascal>Program n_th;

<syntaxhighlight lang="pascal">Program n_th;

function Suffix(N: NativeInt):AnsiString;

Line 2,898:

Print_Images( 250, 265);

Print_Images(1000, 1025);

end.</~~lang~~>

end.</syntaxhighlight>

{{Out}} shortened

<pre>

Line 2,909:

Requires Perl 5.10 or newer for the Defined OR operator (//).

<~~lang~~ perl>use 5.10.0;

<syntaxhighlight lang="perl">use 5.10.0;

my %irregulars = ( 1 => 'st',

2 => 'nd',

Line 2,924:

sub range { join ' ', map { nth($_) } @{$_[0]} }

print range($_), "\n" for ([0..25], [250..265], [1000..1025]);</~~lang~~>

print range($_), "\n" for ([0..25], [250..265], [1000..1025]);</syntaxhighlight>

<pre>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

Line 2,932:

Alternatively, can use a library.

<~~lang~~ perl>use Lingua::EN::Numbers::Ordinate 'ordinate';

<syntaxhighlight lang="perl">use Lingua::EN::Numbers::Ordinate 'ordinate';

foreach my $i (0..25, 250..265, 1000..1025) {

print ordinate($i),"\n";

}</~~lang~~>

}</syntaxhighlight>

=={{header|Phix}}==

constant ordinals = {"th","st","nd","rd"}

Line 2,955:

puts(1,"\n")

end for

<pre>

Line 2,970:

</pre>

Alternatively you can use the builtin ord(), and a more functional style, as follows (same output)

function do_one(integer n, string apostrophe)

return pad_head(sprintf("%d%s%s",{n,apostrophe,ord(n)}),7)

Line 2,979:

constant {rs,re} = columnize({{0,25},{250,265},{1000,1025}})

papply(true,do_set,{apply(true,tagset,{re,rs}),{false,true,false}})

=={{header|PHP}}==

<~~lang~~ ~~PHP~~>function nth($num) {

<syntaxhighlight lang="php">function nth($num) {

$os = "th";

if ($num % 100 <= 10 or $num % 100 > 20) {

Line 3,006:

}

echo "\n";

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 3,018:

===Prolog style===

<~~lang~~ ~~Picat~~>nth2(N) = N.to_string() ++ Th =>

<syntaxhighlight lang="picat">nth2(N) = N.to_string() ++ Th =>

( tween(N) -> Th = "th"

; 1 = N mod 10 -> Th = "st"

Line 3,024:

; 3 = N mod 10 -> Th = "rd"

; Th = "th" ).

tween(N) => Tween = N mod 100, between(11, 13, Tween).</~~lang~~>

tween(N) => Tween = N mod 100, between(11, 13, Tween).</syntaxhighlight>

===Function with explicit conditions===

<~~lang~~ ~~Picat~~>nth3(N) = cc(N,"th"), tween(N) => true.

<syntaxhighlight lang="picat">nth3(N) = cc(N,"th"), tween(N) => true.

nth3(N) = cc(N,"st"), N mod 10 = 1 => true.

nth3(N) = cc(N,"nd"), N mod 10 = 2 => true.

Line 3,033:

nth3(N) = cc(N,"th") => true.

% helper function

cc(N,Th) = N.to_string() ++ Th.</~~lang~~>

cc(N,Th) = N.to_string() ++ Th.</syntaxhighlight>

===List of suffixes===

<~~lang~~ ~~Picat~~>nth4(N) = Nth =>

Suffix = ["th","st","nd","rd","th","th","th","th","th","th"],

Nth = N.to_string() ++ cond((N mod 100 <= 10; N mod 100 > 20), Suffix[1 + N mod 10], "th").</~~lang~~>

Nth = N.to_string() ++ cond((N mod 100 <= 10; N mod 100 > 20), Suffix[1 + N mod 10], "th").</syntaxhighlight>

===Test===

<~~lang~~ ~~Picat~~>go =>

Ranges = [ 0..25, 250..265, 1000..1025],

foreach(Range in Ranges) println([nth2(I) : I in Range])

end,

nl.</~~lang~~>

nl.</syntaxhighlight>

Line 3,054:

=={{header|PicoLisp}}==

<~~lang~~ ~~PicoLisp~~>(de rangeth (A B)

<syntaxhighlight lang="picolisp">(de rangeth (A B)

(mapcar

'((I)

Line 3,071:

(prinl (glue " " (rangeth 1000 1025)))

(bye)</~~lang~~>

(bye)</syntaxhighlight>

<pre>

Line 3,080:

=={{header|PL/I}}==

<lang>Nth: procedure options (main); /* 1 June 2014 */

<syntaxhighlight lang="text">Nth: procedure options (main); /* 1 June 2014 */

declare i fixed (10);

Line 3,105:

end enth;

end Nth;</~~lang~~>

end Nth;</syntaxhighlight>

<pre> 0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th 11th 12th 13th 14th 15th 16th

Line 3,118:

=={{header|PowerShell}}==

<~~lang~~ powershell>function nth($inp){

<syntaxhighlight lang="powershell">function nth($inp){

$suffix = "th"

Line 3,131:

0..25 | %{Write-host -nonewline (nth "$_")};""

250..265 | %{Write-host -nonewline (nth "$_")};""

1000..1025 | %{Write-host -nonewline (nth "$_")};""</~~lang~~>

1000..1025 | %{Write-host -nonewline (nth "$_")};""</syntaxhighlight>

<pre>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

Line 3,139:

===An Alternate Version===

This is, I think, is a more "PowerShelly" way:

function Get-Nth ([int]$Number)

{

Line 3,157:

251..265 | ForEach-Object {Get-Nth $_} | Format-Wide {$_} -Column 5 -Force

1001..1025 | ForEach-Object {Get-Nth $_} | Format-Wide {$_} -Column 5 -Force

</syntaxhighlight>

</lang>

<pre>

Line 3,184:

Following Icon:

<~~lang~~ prolog>nth(N, N_Th) :-

<syntaxhighlight lang="prolog">nth(N, N_Th) :-

( tween(N) -> Th = "th"

; 1 is N mod 10 -> Th = "st"

Line 3,200:

nl, nl,

forall( between(1000,1025,N), (nth(N, N_Th), format('~w, ', N_Th)) ).

</syntaxhighlight>

</lang>

{{out}} of `test/0`:

Line 3,214:

=={{header|PureBasic}}==

<~~lang~~ ~~PureBasic~~>Procedure.s Suffix(n.i)

<syntaxhighlight lang="purebasic">Procedure.s Suffix(n.i)

Select n%10

Case 1 : If n%100<>11 : ProcedureReturn "st" : EndIf

Line 3,232:

put(250,265)

put(1000,1025)

Input()</~~lang~~>

Input()</syntaxhighlight>

<pre>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

Line 3,239:

=={{header|Python}}==

<~~lang~~ python>_suffix = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th']

<syntaxhighlight lang="python">_suffix = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th']

def nth(n):

Line 3,246:

if __name__ == '__main__':

for j in range(0,1001, 250):

print(' '.join(nth(i) for i in list(range(j, j+25))))</~~lang~~>

print(' '.join(nth(i) for i in list(range(j, j+25))))</syntaxhighlight>

<pre>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

Line 3,254:

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</pre>

'''Alternate version'''

<~~lang~~ python>#!/usr/bin/env python3

<syntaxhighlight lang="python">#!/usr/bin/env python3

def ord(n):

Line 3,268:

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~~>

print(*(ord(n) for n in range(1000,1026)))</syntaxhighlight>

<pre>

Line 3,282:

=={{header|Quackery}}==

<~~lang~~ ~~Quackery~~> [ table ] is suffix ( n --> $ )

<syntaxhighlight lang="quackery"> [ table ] is suffix ( n --> $ )

$ "th st nd rd th th th th th th"

Line 3,305:

250 265 test

cr

1000 1025 test</~~lang~~>

1000 1025 test</syntaxhighlight>

Line 3,324:

Note that R vectors are 1-indexed.

<~~lang~~ rsplus>nth <- function(n)

<syntaxhighlight lang="rsplus">nth <- function(n)

{

if (length(n) > 1) return(sapply(n, nth))

Line 3,341:

range <- list(0:25, 250:275, 500:525, 750:775, 1000:1025)

sapply(range, nth)</~~lang~~>

sapply(range, nth)</syntaxhighlight>

<pre> [,1] [,2] [,3] [,4] [,5]

Line 3,374:

=={{header|Racket}}==

<~~lang~~ racket>#lang racket

<syntaxhighlight lang="racket">#lang racket

(define (teen? n) (<= 11 (modulo n 100) 19))

(define (Nth n)

Line 3,383:

(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~~>

(displayln (string-join (for/list ((nth (sequence-map Nth range))) nth) " ")))</syntaxhighlight>

<pre>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

Line 3,392:

(formerly Perl 6)

(Spurious apostrophes intentionally omitted.)

<lang ~~perl6~~>my %irregulars = <1 st 2 nd 3 rd>, (11..13 X=> 'th');

<syntaxhighlight lang="raku" line>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~~>

say .list».&nth for [^26], [250..265], [1000..1025];</syntaxhighlight>

<pre>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

Line 3,402:

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>

If you want to get Unicodally fancy, use this version instead:

<lang ~~perl6~~>my %irregulars = <1 ˢᵗ 2 ⁿᵈ 3 ʳᵈ>, (11..13 X=> 'ᵗʰ');

<syntaxhighlight lang="raku" line>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~~>

say .list».&nth for [^26], [250..265], [1000..1025];</syntaxhighlight>

<blockquote>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ᵗʰ

Line 3,413:

=={{header|Red}}==

<~~lang~~ rebol>Red[]

<syntaxhighlight lang="rebol">Red[]

nth: function [n][

Line 3,430:

test 0 25

test 250 265

test 1000 1025</~~lang~~>

test 1000 1025</syntaxhighlight>

<pre>

Line 3,442:

Negative numbers and fractions are also handled.

<~~lang~~ rexx>/*REXX program shows ranges of numbers with ordinal (st/nd/rd/th) suffixes attached.*/

<syntaxhighlight lang="rexx">/*REXX program shows ranges of numbers with ordinal (st/nd/rd/th) suffixes attached.*/

call tell 0, 25 /*display the 1st range of numbers. */

call tell 250, 265 /* " " 2nd " " " */

Line 3,454:

return /*return to invoker. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

th: parse arg z; x=abs(z); return z||word('th st nd rd',1+x//10*(x//100%10\==1)*(x//10<4))</~~lang~~>

th: parse arg z; x=abs(z); return z||word('th st nd rd',1+x//10*(x//100%10\==1)*(x//10<4))</syntaxhighlight>

'''output'''   using the default inputs:

<pre>

Line 3,470:

=={{header|Ring}}==

<~~lang~~ ring>

for nr = 0 to 25

see Nth(nr) + Nth(nr + 250) + Nth(nr + 1000) + nl

Line 3,486:

func Nth n

return "" + n + "'" + getSuffix(n) + " "

</syntaxhighlight>

</lang>

=={{header|Ruby}}==

Code (slightly adapted) and methodname taken from ActiveSupport (Ruby on Rails).

<~~lang~~ ruby>class Integer

<syntaxhighlight lang="ruby">class Integer

def ordinalize

num = self.abs

Line 3,508:

[(0..25),(250..265),(1000..1025)].each{|r| puts r.map(&:ordinalize).join(", "); puts}

</syntaxhighlight>

</lang>

<pre>

Line 3,519:

=={{header|Rust}}==

<~~lang~~ rust>fn nth(num: isize) -> String {

<syntaxhighlight lang="rust">fn nth(num: isize) -> String {

format!("{}{}", num, match (num % 10, num % 100) {

(1, 11) | (2, 12) | (3, 13) => "th",

Line 3,538:

println!();

}

}</~~lang~~>

}</syntaxhighlight>

Line 3,550:

=={{header|Scala}}==

{{libheader|Scala}}<~~lang~~ ~~Scala~~>object Nth extends App {

{{libheader|Scala}}<syntaxhighlight lang="scala">object Nth extends App {

def abbrevNumber(i: Int) = print(s"$i${ordinalAbbrev(i)} ")

Line 3,569:

println();

(1000 to 1025).foreach(abbrevNumber)

}</~~lang~~>

}</syntaxhighlight>

=={{header|Seed7}}==

<~~lang~~ seed7>$ include "seed7_05.s7i";

<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

const func string: suffix (in integer: num) is func

Line 3,600:

printImages( 250, 265);

printImages(1000, 1025);

end func;</~~lang~~>

end func;</syntaxhighlight>

Line 3,611:

=={{header|Set lang}}==

Due to the language's specification, the input can only contain one character. Therefore, the following code only works with 0-9.

<~~lang~~ set_lang>set o 49

<syntaxhighlight lang="set_lang">set o 49

set t 50

set h 51

Line 3,631:

set ! R

set ! D

> EOF</~~lang~~>

> EOF</syntaxhighlight>

Input: I, Output: O

<pre>I: 1, O: 1'ST

Line 3,642:

=={{header|Sidef}}==

<~~lang~~ ruby>func nth(n) {

<syntaxhighlight lang="ruby">func nth(n) {

static irregulars = Hash(<1 ˢᵗ 2 ⁿᵈ 3 ʳᵈ 11 ᵗʰ 12 ᵗʰ 13 ᵗʰ>...)

n.to_s + (irregulars{n % 100} \\ irregulars{n % 10} \\ 'ᵗʰ')

Line 3,649:

for r in [0..25, 250..265, 1000..1025] {

say r.map {|n| nth(n) }.join(" ")

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 3,659:

=={{header|Sinclair ZX81 BASIC}}==

Works flawlessly with 2k or more of RAM. With 1k, the subroutine itself works but you can't quite print all the tests: the program crashes with an 'out of memory' error code after 1017th. (A slightly less useful and readable version gets as far as 1023rd; 1025th is probably attainable, but might involve obfuscating the program more than is appropriate for this site.)

<~~lang~~ basic> 10 FOR N=0 TO 25

<syntaxhighlight lang="basic"> 10 FOR N=0 TO 25

20 GOSUB 160

30 PRINT N$;" ";

Line 3,682:

220 IF N$(LEN N$)="3" THEN LET S$="RD"

230 LET N$=N$+S$

240 RETURN</~~lang~~>

240 RETURN</syntaxhighlight>

<pre>

Line 3,691:

=={{header|SQL}}==

Oracle

select level card,

to_char(to_date(level,'j'),'fmjth') ord

Line 3,699:

select to_char(to_date(5373485,'j'),'fmjth')

from dual;

</syntaxhighlight>

</lang>

<pre>

CARD ORD

Line 3,728:

=={{header|Standard ML}}==

<~~lang~~ sml>local

<syntaxhighlight lang="sml">local

val v = Vector.tabulate (10, fn 1 => "st" | 2 => "nd" | 3 => "rd" | _ => "th")

fun getSuffix x =

Line 3,739:

(* some test ouput *)

val () = (print o concat o List.tabulate)

(26, fn i => String.concatWith "\t" (map nth [i, i + 250, i + 1000]) ^ "\n")</~~lang~~>

(26, fn i => String.concatWith "\t" (map nth [i, i + 250, i + 1000]) ^ "\n")</syntaxhighlight>

<pre>0th 250th 1000th

Line 3,771:

We reuse here the '''maps''' function defined in the task [[Apply a callback to an array]].

<~~lang~~ stata>mata

<syntaxhighlight lang="stata">mata

function maps(f,a) {

nr = rows(a)

Line 3,788:

maps(&nth(),((0::25),(250::275),(1000::1025)))

end</~~lang~~>

end</syntaxhighlight>

'''Output:'''

Line 3,823:

=={{header|Swift}}==

<~~lang~~ ~~Swift~~>func addSuffix(n:Int) -> String {

<syntaxhighlight lang="swift">func addSuffix(n:Int) -> String {

if n % 100 / 10 == 1 {

return "th"

Line 3,851:

print("\(i)\(addSuffix(i)) ")

}

println()</~~lang~~>

println()</syntaxhighlight>

<pre>

Line 3,860:

=={{header|Tcl}}==

<~~lang~~ tcl>proc ordinal {n} {

<syntaxhighlight 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}]]

Line 3,874:

}

puts $l

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 3,884:

=={{header|True BASIC}}==

<~~lang~~ basic>

SUB sufijo (n)

LET n = INT(n)

Line 3,920:

CALL imprimeOrdinal (1000, 1025)

END

</syntaxhighlight>

</lang>

== {{header|TypeScript}} ==

<~~lang~~ javascript>

// N'th

function suffix(n: number): string {

Line 3,948:

printImages( 250, 265);

printImages(1000, 1025);

</syntaxhighlight>

</lang>

<pre>

Line 3,957:

=={{header|uBasic/4tH}}==

<lang>For x = 0 to 25 ' Test range 0..25

<syntaxhighlight lang="text">For x = 0 to 25 ' Test range 0..25

Push x : GoSub _PrintOrdinal

Next x : Print

Line 3,991:

110 Print "st"; : Return

120 Print "nd"; : Return

130 Print "rd"; : Return</~~lang~~>

130 Print "rd"; : Return</syntaxhighlight>

<pre>

Line 4,001:

=={{header|UNIX Shell}}==

<~~lang~~ sh>nth() {

<syntaxhighlight lang="sh">nth() {

local ordinals=(th st nd rd)

local -i n=$1 i

Line 4,016:

for n in {0..25} {250..265} {1000..1025}; do

nth $n

done | column</~~lang~~>

done | column</syntaxhighlight>

Line 4,028:

=={{header|VBA}}==

{{trans|Phix}}<~~lang~~ vb>Private Function ordinals() As Variant

{{trans|Phix}}<syntaxhighlight lang="vb">Private Function ordinals() As Variant

ordinals = [{"th","st","nd","rd"}]

End Function

Line 4,047:

Debug.Print

Next i

End Sub</~~lang~~>{{out}}

End Sub</syntaxhighlight>{{out}}

<pre> 0th 1st 2nd 3rd 4th 5th 6th 7th 8th 9th

10th 11th 12th 13th 14th 15th 16th 17th 18th 19th

Line 4,061:

=={{header|Vlang}}==

<~~lang~~ vlang>fn ord(n int) string {

<syntaxhighlight lang="vlang">fn ord(n int) string {

mut s := "th"

c := n % 10

Line 4,097:

}

println('')

}</~~lang~~>

}</syntaxhighlight>

Line 4,108:

=={{header|Wren}}==

<~~lang~~ ecmascript>import "/fmt" for Conv

<syntaxhighlight lang="ecmascript">import "/fmt" for Conv

var ranges = [ 0..25, 250..265, 1000..1025 ]

Line 4,114:

r.each { |i| System.write("%(Conv.ord(i)) ") }

System.print("\n")

}</~~lang~~>

}</syntaxhighlight>

Line 4,128:

<~~lang~~ xbasic>

PROGRAM "nth"

VERSION "0.0002"

Line 4,164:

END FUNCTION

END PROGRAM

</syntaxhighlight>

</lang>

<pre>

Line 4,173:

=={{header|XLISP}}==

<~~lang~~ xlisp>(DEFUN NTH (N)

<syntaxhighlight lang="xlisp">(DEFUN NTH (N)

(COND

((AND (> (MOD N 100) 3) (< (MOD N 100) 21)) `(,N TH))

Line 4,192:

(DISPLAY (MAPCAR NTH (RANGE 1000 1025))))

(TEST-NTH)</~~lang~~>

(TEST-NTH)</syntaxhighlight>

<pre>((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))

Line 4,201:

<~~lang~~ xpl0>

\N'th

code Rem=2, CrLf=9, IntIn=10, IntOut=11, Text=12;

Line 4,238:

PrintImages(1000, 1025)

end

</syntaxhighlight>

</lang>

<pre>

Line 4,248:

=={{header|Yabasic}}==

<~~lang~~ xbasic>

sub ordinal$ (n)

NMod10 = mod(n, 10)

Line 4,278:

imprimeOrdinal (1000, 1025)

end

</syntaxhighlight>

</lang>

=={{header|zkl}}==

Two versions, your choice

<~~lang~~ zkl>#if 0

<syntaxhighlight lang="zkl">#if 0

fcn addSuffix(n){

z:=n.abs()%100;

Line 4,296:

String(n,(z<=10 or z>20) and suffixes[z%10] or "th");

}

#endif</~~lang~~>

#endif</syntaxhighlight>

<~~lang~~ zkl>[0..25] .apply(addSuffix).concat(",").println();

<syntaxhighlight lang="zkl">[0..25] .apply(addSuffix).concat(",").println();

[250..265] .apply(addSuffix).concat(",").println();

[1000..1025].apply(addSuffix).concat(",").println();</~~lang~~>

[1000..1025].apply(addSuffix).concat(",").println();</syntaxhighlight>

<pre>

Line 4,308:

=={{header|ZX Spectrum Basic}}==

<~~lang~~ basic> 10 FOR n=0 TO 25

<syntaxhighlight lang="basic"> 10 FOR n=0 TO 25

20 GO SUB 140

30 PRINT n$;" ";

Line 4,329:

200 IF n$(LEN n$)="3" THEN LET s$="rd"

210 LET n$=n$+s$

220 RETURN</~~lang~~>

220 RETURN</syntaxhighlight>