Using two linked programs, output ordinal numbers up to n

Question

...Ordinal numbers (or ordinal numerals) are words representing position or rank in a sequential order.

From Wikipedia.

Your task is, using 2 separate programs (of which can be made from 2 different languages), to output the ordinal sequence from first to nth. You will be outputting the full word second as opposed to 2nd.

The challenge of ordinal numbers has been brought up before, particularly in this entry. In this challenge, ordinals are merely a vehicle to facilitate the unique conditions detailed below.

---

Part 1

You must make a program that, when given the input of n must output anything.
n will always be a positive, non-zero integer no larger than 999.

Valid output includes but is not limited to:

• Any output to stdout / stderr / etc
• Creation of files / folders / etc
• A graphical interface or images of any kind

Anything goes.

---

Part 2

You must make a program that uses the output of part 1's program to output a sequence of ordinal numbers, starting from 1 (first), up to whatever n was parsed in part 1.

General Conditions:

• The total bytes for part 2 must not exceed the total bytes for part 1 (less than or equal to).

Output conditions:

• Not case sensitive.
• Output must contain only the ordinal sequence (only characters a-Z) and whitespace (newlines allowed).
• Can be output to any source, so long as it is visible either during or after execution.
• Program does not need to terminate so long as its output is correct.
• Output is not required to have any grammar, but may optionally include it (hyphens, commas, "ands", etc). nine hundred ninety ninth is just as acceptable as nine hundred and ninety-ninth.

Sample Output

Where n is 8

FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH

---

Scoring

The hierarchy of win conditions is:

1. The lowest number of bytes in part 1
2. The lowest number of bytes in part 2

Entry #1 | Part 1 = 32 bytes, Part 2 = 22 bytes
Entry #2 | Part 1 = 31 bytes, part 2 = 30 bytes

Entry #2 wins - Part 1 contains 31 bytes vs 32 bytes

---

Entry #1 | Part 1 = 21 bytes, Part 2 = 33 bytes
Entry #2 | Part 1 = 80 bytes, Part 2 = 70 bytes

Entry #2 wins - Entry #1 disqualified (Part 2 contains more bytes than Part 1)

---

Entry #1 | Part 1 = 50 bytes, Part 2 = 49 bytes
Entry #2 | Part 1 = 50 bytes, Part 2 = 50 bytes

Entry #1 wins - Part 1 is equal, Part 2 contains 49 bytes vs 50 bytes

Answer 1

Sledgehammer 0.5.1 / Sledgehammer 0.5.1, 10 bytes

Program 1 (10 bytes):

⣘⢷⠾⣃⢖⣎⢅⡨⠱⢳

Decompresses into this Wolfram Language function:

{Range[#1], "Ordinal"} &

Program 2 (7 bytes):

⡾⡁⢚⣷⣬⠤⣾

Decompresses into this Wolfram Language function:

StringRiffle[IntegerName @@ #1, " "] &

Try it online!

Answer 2

R (with english package), 16 bytes / 16 bytes

 Part 1, 16 bytes

f=function(n)1:n

Part 2, 16 bytes

english::ordinal

Requires the english package (which is not installed on TIO, unfortunately).

english::ordinal(f(22)) outputs first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventeenth eighteenth nineteenth twentieth twenty first twenty second.

Of course, part 1 could be made much shorter (3 bytes: seq), but that would go against the constraint that part 2 has to be no longer than part 1.

Answer 3

Wolfram Language (Mathematica) (both parts), 18 bytes / 15 bytes

-5/-1 thanks to lirtosiast

Part 1, 18 bytes

Range@#|"Ordinal"&

Part 2, 15 bytes

IntegerName@@#&

Try it online!

Two functions which output via return value.

Answer 4

Python 3(part 1 & part 2)

Unfortunately Nodebox is very wordy... there is not much room for golfing.

Part 1 76 bytes

for  i  in  range  (  1 ,  int  (  input  (  ) ) + 1 ) : print ( i ,end=" ")

Part 2 (Uses the NodeBox library) 76 bytes

import en.number as n
for i in input().split():print(n.ordinal(n.spoken(i)))

Answer 5

JavaScript (Node.js), 47 bytes / 47 bytes

Two functions in the same Node.js environment, invoked like g(f(n)). Uses the npm package number-to-words.

Part 1, 47 bytes (40 bytes + 7 spaces)

n=>H=>{for(i=0;i<n;)console.log(H(++i))}       

Part 2, 47 bytes

F=>F(require("number-to-words").toWordsOrdinal)

Try it on Runkit!

---

JavaScript (Node.js), 48 bytes / 43 bytes

Part 1, 48 bytes

n=>[n,require("number-to-words").toWordsOrdinal]

Part 2, 43 bytes

([n,F])=>{for(i=0;i<n;)console.log(F(++i))}

Try it on Runkit!

Answer 6

Perl 5.10 / Common Lisp, 34 / 26 bytes

So, Common Lisp format has this as a built-in, because of course it does.

Program 1 (34 bytes)

say"(format t\"~:r \"$_)"for 1..<>

Perl does all the iterating. The equivalent Common Lisp code ((dotimes(i(read)) ...)) is longer than the much golfier Perl ... for 1..<>. Perl outputs a bunch of Common Lisp code.

Program 2 (26 bytes)

(loop(eval(read nil nil)))

It's a REPL, minus the P. It reads standard input and, well, executes it. Doesn't terminate, but the rules explicitly say that's fine.

Answer 7

Vyxal, 2/2 bytes

ɾ, # print range (1,n+1)

∆o # nth ordinal of each

Try it Online!