N'th: Difference between revisions

{{trans|Python}}

 

 

F nth(n)

 

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

 

{{out}}

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>

 

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

jmp demo

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

dcr b ; Decrement counter

jnz printnums ; If not zero, print next number

 

{{out}}

{{trans|8080 Assembly}}

 

cpu 8086

segment .text

dec bl ; Are we done yet?

jnz printn

 

{{out}}

 

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

CHAR ARRAY sfx

BYTE d

PutE() PutE()

OD

{{out}}

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

=={{header|Ada}}==

 

 

procedure Nth is

Print_Images( 250, 265);

Print_Images(1000, 1025);

 

{{Out}}

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

{{works with|ALGOL 68G|Any - tested with release 2.6.win32}}

PROC nth = ( INT number )STRING:

BEGIN

test nth( 1000, 1025 )

 

{{out}}

<pre>

1016th 1017th 1018th 1019th 1020th 1021st 1022nd 1023rd

1024th 1025th

 

</pre>

{{works with|Dyalog APL}}

 

sfx←4 2⍴'stndrdth'

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

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

 

{{out}}

 

=={{header|AppleScript}}==

 

-- ordinalString :: Int -> String

end |λ|

end script

{{Out}}

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

"1014th", "1015th", "1016th", "1017th", "1018th", "1019th", "1020th",

"1021st", "1022nd", "1023rd", "1024th", "1025th"}}</pre>

 

=={{header|Arturo}}==

nth: function [n][

prints (nth i)++" "

print ""

 

{{out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

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

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

s1 := Mod(n, 10)

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

{{Out}}

<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

 

=={{header|AWK}}==

# syntax: GAWK -f NTH.AWK

BEGIN {

return(nthday)

}

{{out}}

<pre>

=={{header|Babel}}==

 

 

(main

. . }

{ -> %d "'th" . }

 

{{out}}

1008'th 1007'th 1006'th 1005'th 1004'th 1003'rd 1002'nd 1001'st 1000'th</pre>

 

FUNCTION nth$(NUMBER n) TYPE STRING

LOCAL suffix

NEXT

NEXT

 

{{out}}

-20 -19 -18 -17 -16 -15 -14 -13 -12 -11</pre>

 

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

function ordinal(n)

ns$ = string(n)

call imprimeOrdinal (1000, 1025)

end

 

 

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

DECLARE FUNCTION sufijo$ (n%)

DECLARE SUB imprimeOrdinal (loLim%, hiLim%)

END IF

END FUNCTION

 

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

::Main thing...

call :Nth 0 25

setlocal enabledelayedexpansion

for /l %%n in (%~1,1,%~2) do (

)

echo."!range_output:~1!"

{{Out}}

"250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th"

</pre>

 

=={{header|BCPL}}==

 

// Generate ASCII string of number n with ordinal suffix

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

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

{{out}}

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

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.

 

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

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

htdd >$>:#,_$:vg

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

 

{{out}}

 

=={{header|BQN}}==

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

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

}

 

{{out}}

<pre>┌─

┘</pre>

=={{header|C}}==

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

 

return 0;

Another method with dynamic memory allocation

#include <stdio.h>

 

print_range(250, 265);

print_range(1000, 1025);

{{out}}

<pre>Set [0,25] :

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

{{trans|Ruby}}

using System.Linq;

 

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

}

Dotnet 5 version without LINQ

 

static string Ordinalize(int i)

PrintRange(0, 25);

PrintRange(250, 265);

 

{{Out}}

 

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

#include <iostream>

 

 

return 0;

{{out}}

<pre>Set [0,25] :

 

=={{header|Clojure}}==

(defn n-th [n]

(str n

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

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

{{out}}

<pre>

 

Alternatively, if you want to print the full ordinal English, it becomes trivial with pprint:

(apply str (interpose " " (map #(clojure.pprint/cl-format nil "~:R" %) (range 0 26))))

{{out}}

<pre>

 

=={{header|CLU}}==

num: string := int$unparse(n)

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

do_range(250,265)

do_range(1000,1025)

{{out}}

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

=={{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.

PROGRAM-ID. NTH-PROGRAM.

DATA DIVISION.

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

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

Output:

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

 

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

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

(last2 (mod number 100))

(svref suffixes last-digit))))

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

 

 

A more concise, albeit less readable version:

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

 

 

Display the results:

do (progn

(format t "~a to ~a: " low high)

(loop for n from low to high

do (format t "~a " (add-suffix n))

 

{{Out}}

 

=={{header|Cowgol}}==

include "strings.coh";

 

test(0, 25);

test(250,265);

 

{{out}}

=={{header|Crystal}}==

{{trans|Ruby}}

def ordinalize

num = self.abs

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

{{out}}

<pre>

=={{header|D}}==

{{trans|Python}}

 

string nth(in uint n) pure {

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

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

{{out}}

<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

=={{header|Delphi}}==

See [https://www.rosettacode.org/wiki/N%27th#Pascal Pascal].

 

=={{header|Elena}}==

{{trans|C#}}

import system'math;

import system'routines;

{

int i := self.Absolute;

{

^ i.toPrintable() + "th"

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

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

{{out}}

<pre>

 

=={{header|Elixir}}==

def ordinalize(n) do

num = abs(n)

Enum.each([0..25, 250..265, 1000..1025], fn range ->

Enum.map(range, fn n -> RC.ordinalize(n) end) |> Enum.join(" ") |> IO.puts

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM NTH_SOLVE

 

NTH(1000,1025)

END PROGRAM

{{out}}

<pre>

 

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

 

let ordinalsuffix n =

[1000..1025] |> show

0

{{out}}

<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

 

=={{header|Factor}}==

sequences ;

IN: rosetta-code.nth

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

 

{{out}}

<pre>

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|Forth}}==

: .nth ( n -- )

dup 0 .r 10 mod 3 * 'nth + 3 type ;

 

26 0 test 266 250 test 1026 1000 test ;

 

 

{{out}}

1000th 1001st 1002nd 1003rd 1004th

1005th 1006th 1007th 1008th 1009th

1015th 1016th 1017th 1018th 1019th

1020th 1021st 1022nd 1023rd 1024th

 

=={{header|Fortran}}==

 

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

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

!

end function ordinate

 

 

=={{header|Go}}==

{{trans|Raku}}

 

import "fmt"

}

fmt.Println()

{{out}}

<pre>

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

</pre>

 

=={{header|Haskell}}==

 

ordSuffs :: Array Integer String

printOrdSuffs [ 0.. 25]

printOrdSuffs [ 250.. 265]

{{out}}

<pre>

 

The following works in both languages.

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

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

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

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

 

{{out}}

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

->

</pre>

 

Implementation:

 

 

Task:

 

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

250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th

nth 1000 thru 1025

 

=={{header|Java}}==

public static String ordinalAbbrev(int n){

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

}

}

{{works with|Java|8+}}

 

import java.util.stream.IntStream;

;

}

{{out}}

<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

===ES5===

 

 

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

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

 

 

{{Out}}

 

 

250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th

 

 

 

===ES6===

 

'use strict'

 

);

 

 

 

"1014th", "1015th", "1016th", "1017th", "1018th", "1019th", "1020th",

"1021st", "1022nd", "1023rd", "1024th", "1025th"]]</pre>

 

=={{header|jq}}==

# ordinalize an integer input, positive or negative

def ordinalize:

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

| map(ordinalize)

{{out}}

<pre>

 

=={{header|Julia}}==

'''Function''':

n < 0 && throw(DomainError())

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

end

return string(n, suf)

 

'''Main''':

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

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

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

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

'''Main2''':

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

 

{{out}}

 

=={{header|Kotlin}}==

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

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

fun main(args: Array<String>) {

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

 

=={{header|Lambdatalk}}==

Translation from the javascript entry

{def fnOrdinalForm

{lambda {:n}

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

1021st 1022nd 1023rd 1024th 1025th

 

=={{header|Lua}}==

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

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

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

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

 

{{out}}

 

=={{header|Maple}}==

if 1 <= n and n <= 10 then

if n >= 4 then

end do;

printf("\n\n");

{{out}}

<pre>

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

I borrowed the logic from the Python code.

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

suffix = Which[

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

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

{{out}}

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

 

=={{header|MATLAB}}==

tens = mod(n, 100);

if tens > 9 && tens < 20

end

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

{{out}}

<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

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

 

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

if n % 10 == 2 then return n + "nd"

end function

 

test = function(from, to)

for i in range(from, to)

out.push ordinal(i)

end for

end function

 

test 250, 265

test 1000, 1025

 

{{out}}

 

=={{header|Modula-2}}==

{{trans|Ada}}

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

MODULE Nth;

 

PrintImages(1000, 1025);

END Nth.

 

=={{header|Nanoquery}}==

{{trans|Java}}

if int(n % 100 / 10) = 1

return "th"

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

end

{{out}}

<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

=={{header|Nim}}==

{{trans|Python}}

 

proc nth(n: Natural): string =

for i in j..j+24:

stdout.write nth(i), " "

{{out}}

<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

=={{header|Objeck}}==

{{trans|Java}}

function : OrdinalAbbrev(n : Int ) ~ String {

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

};

}

 

{{output}}

=={{header|OCaml}}==

 

let show_nth n =

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

 

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

 

{{out}}

=={{header|Oforth}}==

 

| r |

n "th" over 10 mod ->r

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

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

 

{{out}}

(Spurious apostrophes intentionally omitted, following Raku.)

 

apply(ordinal, [0..25])

apply(ordinal, [250..265])

apply(ordinal, [1000..1025])

{{out}}

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

=={{header|Pascal}}==

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

 

function Suffix(N: NativeInt):AnsiString;

Print_Images( 250, 265);

Print_Images(1000, 1025);

{{Out}} shortened

<pre>

{{Trans|Raku}}

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

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

2 => 'nd',

 

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

{{out}}

<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

Alternatively, can use a library.

{{libheader|Lingua&#58;&#58;EN&#58;&#58;Numbers&#58;&#58;Ordinate}}

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

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

 

=={{header|Phix}}==

<span style="color: #008080;">constant</span> <span style="color: #000000;">ordinals</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"th"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"st"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"nd"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"rd"</span><span style="color: #0000FF;">}</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

</pre>

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

<span style="color: #008080;">function</span> <span style="color: #000000;">do_one</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">apostrophe</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">pad_head</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d%s%s"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">apostrophe</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">ord</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)}),</span><span style="color: #000000;">7</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">constant</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">rs</span><span style="color: #0000FF;">,</span><span style="color: #000000;">re</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">25</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">250</span><span style="color: #0000FF;">,</span><span style="color: #000000;">265</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1025</span><span style="color: #0000FF;">}})</span>

<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #000000;">do_set</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">re</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rs</span><span style="color: #0000FF;">}),{</span><span style="color: #004600;">false</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">}})</span>

 

=={{header|PHP}}==

$os = "th";

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

}

echo "\n";

{{out}}

<pre>

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|PicoLisp}}==

(mapcar

'((I)

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

 

{{out}}

<pre>

 

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

declare i fixed (10);

 

end enth;

 

{{out}}

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

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

1022nd 1023rd 1024th 1025th</pre>

 

=={{header|PowerShell}}==

 

}

 

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

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

{{Out}}

250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th

 

===An Alternate Version===

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

function Get-Nth ([int]$Number)

{

$suffix = "th"

 

}

 

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

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

{{Out}}

<pre>

 

 

 

 

</pre>

 

Following Icon:

 

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

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

nl, nl,

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

 

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

true.

</pre>

 

=={{header|Python}}==

 

def nth(n):

if __name__ == '__main__':

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

{{out}}

<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

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

 

def ord(n):

print(*(ord(n) for n in range(26)))

print(*(ord(n) for n in range(250,266)))

{{out}}

<pre>

=={{header|Quackery}}==

 

 

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

250 265 test

cr

 

{{out}}

{{trans|Python}}

Note that R vectors are 1-indexed.

{

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

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

 

{{out}}

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

=={{header|Racket}}==

 

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

(define (Nth n)

 

(for ((range (list (in-range 26) (in-range 250 266) (in-range 1000 1026))))

{{out}}

<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

(formerly Perl 6)

(Spurious apostrophes intentionally omitted.)

 

sub nth ($n) { $n ~ ( %irregulars{$n % 100} // %irregulars{$n % 10} // 'th' ) }

 

{{out}}

<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

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:

 

sub nth ($n) { $n ~ ( %irregulars{$n % 100} // %irregulars{$n % 10} // 'ᵗʰ' ) }

 

{{out}}

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

 

=={{header|Red}}==

 

nth: function [n][

d: n % 10

rejoin [n pick ["st" "nd" "rd" "th"] suffix]

]

test 0 25

test 250 265

{{out}}

<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

250th 251st 252nd 253rd 254th 255th 256th 257th 258th 259th 260th 261st 262nd 263rd 264th 265th

</pre>

 

=={{header|REXX}}==

This version adds suffixes without apostrophes.

 

'''output''' &nbsp; using the default inputs:

<pre>

 

=={{header|Ring}}==

for nr = 0 to 25

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

func Nth n

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

 

=={{header|Ruby}}==

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

def ordinalize

num = self.abs

 

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

{{out}}

<pre>

 

=={{header|Rust}}==

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

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

println!();

}

 

{{out}}

 

=={{header|Scala}}==

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

 

println();

(1000 to 1025).foreach(abbrevNumber)

 

=={{header|Seed7}}==

 

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

printImages( 250, 265);

printImages(1000, 1025);

 

{{out}}

</pre>

 

=={{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.

set t 50

set h 51

set ! R

set ! D

Input: I, Output: O

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

=={{header|Sidef}}==

{{trans|Raku}}

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

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

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

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

{{out}}

<pre>

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

</pre>

 

=={{header|SQL}}==

Oracle

select level card,

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

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

from dual;

<pre>

CARD ORD

 

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

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

fun getSuffix x =

(* some test ouput *)

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

{{out}}

<pre>0th 250th 1000th

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

 

function maps(f,a) {

nr = rows(a)

 

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

 

'''Output:'''

26 | 25th 275th 1025th |

+----------------------------+</pre>

 

=={{header|Swift}}==

if n % 100 / 10 == 1 {

return "th"

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

}

{{out}}

<pre>

 

=={{header|Tcl}}==

if {$n%100<10 || $n%100>20} {

set suff [lindex {th st nd rd th th th th th th} [expr {$n % 10}]]

}

puts $l

{{out}}

<pre>

</pre>

 

 

{{out}}

<pre>

</pre>

 

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

{{works with|Bourne Again Shell}}

local ordinals=(th st nd rd)

local -i n=$1 i

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

nth $n

 

{{Out}}

6th 13th 20th 251st 258th 265th 1006th 1013th 1020th</pre>

 

 

 

 

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

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

for (r in ranges) {

System.print("\n")

 

{{out}}

 

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|XLISP}}==

(COND

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

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

 

{{out}}

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

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

 

 

 

 

end

 

=={{header|zkl}}==

Two versions, your choice

fcn addSuffix(n){

z:=n.abs()%100;

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

}

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

{{out}}

<pre>

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>