... Los números ordinales (o números ordinales) son palabras que representan posición o rango en un orden secuencial.

De Wikipedia .

Su tarea es, utilizando 2 programas separados (de los cuales se pueden hacer desde 2 idiomas diferentes), para generar la secuencia ordinal de primero a nth. Saldrá la palabra completa seconden lugar de 2nd.

El desafío de los números ordinales se ha mencionado anteriormente, particularmente en esta entrada . En este desafío, los ordinales son simplemente un vehículo para facilitar las condiciones únicas que se detallan a continuación.

Parte 1

Debe hacer un programa que, cuando se le da la entrada, ndebe generar cualquier cosa .
nsiempre será un entero positivo, distinto de cero, no mayor que 999.

La salida válida incluye, pero no se limita a :

• Cualquier salida a stdout/ stderr/ etc.
• Creación de archivos / carpetas / etc.
• Una interfaz gráfica o imágenes de cualquier tipo.

Todo vale.

Parte 2

Debe crear un programa que utilice la salida del programa de la parte 1 para generar una secuencia de números ordinales, comenzando desde 1 (primero), hasta lo que nse analizó en la parte 1.

Condiciones generales:

• El total de bytes para la parte 2 no debe exceder el total de bytes para la parte 1 (menor o igual que).

Condiciones de salida:

• No entre mayúsculas y minúsculas.
• La salida debe contener solo la secuencia ordinal (solo caracteres aZ) y espacios en blanco (se permiten nuevas líneas).
• Se puede enviar a cualquier fuente, siempre que sea visible durante o después de la ejecución.
• El programa no necesita terminar mientras su salida sea correcta.
• No se requiere que la salida tenga ninguna gramática, pero opcionalmente puede incluirla (guiones, comas, "ands", etc.). nine hundred ninety ninthes tan aceptable como nine hundred and ninety-ninth.

Salida de muestra

Donde nes 8

FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH

Puntuación

La jerarquía de las condiciones de victoria es:

1. El menor número de bytes en la parte 1
2. El menor número de bytes en la parte 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

Sledgehammer 0.5.1 / Sledgehammer 0.5.1, 10 bytes

Programa 1 (10 bytes):

⣘⢷⠾⣃⢖⣎⢅⡨⠱⢳

Se descomprime en esta función Wolfram Language:

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

Programa 2 (7 bytes):

⡾⡁⢚⣷⣬⠤⣾

Se descomprime en esta función Wolfram Language:

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

Pruébalo en línea!

R (con englishpaquete), 16 bytes / 16 bytes

 Parte 1, 16 bytes

f=function(n)1:n

Parte 2, 16 bytes

english::ordinal

Requiere el englishpaquete (que desafortunadamente no está instalado en TIO).

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

Por supuesto, la parte 1 podría hacerse mucho más corta (3 bytes:) seq, pero eso iría en contra de la restricción de que la parte 2 no debe ser más larga que la parte 1.

Wolfram Language (Mathematica) (ambas partes), 18 bytes / 15 bytes

-5 / -1 gracias al lirtosiast

Parte 1, 18 bytes

Range@#|"Ordinal"&

Parte 2, 15 bytes

IntegerName@@#&

Pruébalo en línea!

Dos funciones que salen a través del valor de retorno.

Python 3 (parte 1 y parte 2)

Lamentablemente, Nodebox es muy prolijo ... no hay mucho espacio para jugar al golf.

Parte 1 76 bytes

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

Parte 2 (Utiliza la biblioteca NodeBox ) 76 bytes

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

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

Dos funciones en el mismo entorno Node.js, invocadas como g(f(n)). Utiliza el paquete npm número a palabras .

Parte 1, 47 bytes (40 bytes + 7 espacios)

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

Parte 2, 47 bytes

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

Pruébalo en Runkit!

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

Parte 1, 48 bytes

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

Parte 2, 43 bytes

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

Pruébalo en Runkit!

Perl 5.10 / Common Lisp, 34/26 bytes

Entonces, Lisp común format tiene esto como algo incorporado, porque por supuesto que sí.

Programa 1 (34 bytes)

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

Perl hace toda la iteración. El código Common Lisp equivalente ( (dotimes(i(read)) ...)) es más largo que el mucho más golfista Perl... for 1..<> . Perl genera un montón de código Common Lisp.

Programa 2 (26 bytes)

(loop(eval(read nil nil)))

Es una REPL, menos la P. Lee la entrada estándar y, bueno, la ejecuta. No termina, pero las reglas dicen explícitamente que está bien.