[Question]
  [
> 
> ...Ordinal numbers (or ordinal numerals) are words representing position or rank in a sequential order.
> 
> 
> 
[![enter image description here](https://i.stack.imgur.com/YOUmZ.png)](https://i.stack.imgur.com/YOUmZ.png)
*From [Wikipedia](https://en.wikipedia.org/wiki/Ordinal_number_(linguistics)).*
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](https://codegolf.stackexchange.com/questions/4707/outputting-ordinal-numbers-1st-2nd-3rd). 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]
# [Sledgehammer 0.5.1](https://github.com/tkwa/Sledgehammer/commit/9e4f8257aae28f8aa0660948d2141e2745c15100) / 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!](https://tio.run/##DYy7DoMgFIZ3n@IPJk4uuDE0Ye1SjY6E4cQeKIkwkLOZPjsyf5dM8uNMkk5qLWi8cO9UIrtR@1mt9ZsKXeo/tbB0dkhNJe4phIvduwhHrh/KDGsx6hkKymMahq1r4npi0Z8WxhjfHg "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [R](https://www.r-project.org/) (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]
## [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/) (both parts), 18 bytes / 15 bytes
-5/-1 thanks to [lirtosiast](https://codegolf.stackexchange.com/questions/188363/output-ordinal-numbers-up-to-n/188367?noredirect=1#comment451280_188367)
### Part 1, 18 bytes
```
Range@#|"Ordinal"&
```
### Part 2, 15 bytes
```
IntegerName@@#&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7PygxLz3VQblGyb8oJTMvMUdJ7X@6LZdnXklqemqRX2JuqoODshpXQFFmXkl0ukOag0UsEsfQyDj2PwA "Wolfram Language (Mathematica) – Try It Online")
Two functions which output via return value.
[Answer]
## 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](https://www.nodebox.net/code/index.php/Linguistics) library) 76 bytes
```
import en.number as n
for i in input().split():print(n.ordinal(n.spoken(i)))
```
[Answer]
# 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](https://www.npmjs.com/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!](https://runkit.com/5d2e1bc6298e33001a1b8926/5d2e1bc68e898b001a939f05)
---
# 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!](https://runkit.com/5d2e1bc6298e33001a1b8926/5d2e1ea4298e33001a1b8e13)
[Answer]
# 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]
# [Vyxal](https://github.com/Vyxal/Vyxal/tree/version-2), 2/2 bytes
```
ɾ, # print range (1,n+1)
```
```
∆o # nth ordinal of each
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyIiLCIiLCLJvixcbuKIhm8iLCIiLCI2Il0=)
]