... Les nombres ordinaux (ou nombres ordinaux) sont des mots représentant la position ou le rang dans un ordre séquentiel.

De Wikipédia .

Votre tâche consiste, à l'aide de 2 programmes distincts (qui peuvent être créés à partir de 2 langues différentes), à sortir la séquence ordinale du premier au nth. Vous sortirez le mot complet secondpar opposition à 2nd.

Le défi des nombres ordinaux a été soulevé auparavant, en particulier dans cette entrée . Dans ce défi, les ordinaux sont simplement un véhicule pour faciliter les conditions uniques détaillées ci-dessous.

Partie 1

Vous devez créer un programme qui, une fois donné, ndoit produire n'importe quoi .
nsera toujours un entier positif non nul ne dépassant pas 999.

Une sortie valide comprend, mais sans s'y limiter :

• Toute sortie vers stdout/ stderr/ etc
• Création de fichiers / dossiers / etc
• Une interface graphique ou des images de toute nature

Tout va.

Partie 2

Vous devez créer un programme qui utilise la sortie du programme de la partie 1 pour sortir une séquence de nombres ordinaux, à partir de 1 (premier), jusqu'à ce qui a nété analysé dans la partie 1.

Conditions générales:

• Le nombre total d'octets pour la partie 2 ne doit pas dépasser le nombre total d'octets pour la partie 1 (inférieur ou égal à).

Conditions de sortie:

• Pas sensible à la casse.
• La sortie doit contenir uniquement la séquence ordinale (uniquement les caractères aZ) et les espaces (sauts de ligne autorisés).
• Peut être émis vers n'importe quelle source, tant qu'il est visible pendant ou après l'exécution.
• Le programme n'a pas besoin de s'arrêter tant que sa sortie est correcte.
• La sortie n'est pas requise pour avoir une grammaire, mais peut éventuellement l'inclure (tirets, virgules, "ands", etc.). nine hundred ninety ninthest tout aussi acceptable que nine hundred and ninety-ninth.

Exemple de sortie

Où nest 8

FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH

Notation

La hiérarchie des conditions de victoire est la suivante:

1. Le plus petit nombre d'octets de la partie 1
2. Le plus petit nombre d'octets dans la partie 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 octets

Programme 1 (10 octets):

⣘⢷⠾⣃⢖⣎⢅⡨⠱⢳

Décompresse dans cette fonction Wolfram Language:

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

Programme 2 (7 octets):

⡾⡁⢚⣷⣬⠤⣾

Décompresse dans cette fonction Wolfram Language:

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

Essayez-le en ligne!

R (avecenglish package), 16 octets / 16 octets

 Partie 1, 16 octets

f=function(n)1:n

Partie 2, 16 octets

english::ordinal

Nécessite le englishpackage (qui n'est pas installé sur TIO, malheureusement).

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

Bien sûr, la partie 1 pourrait être beaucoup plus courte (3 octets:) seq, mais cela irait à l'encontre de la contrainte que la partie 2 ne doit pas être plus longue que la partie 1.

Wolfram Language (Mathematica) (les deux parties), 18 octets / 15 octets

-5 / -1 grâce au lirtosiast

Partie 1, 18 octets

Range@#|"Ordinal"&

Partie 2, 15 octets

IntegerName@@#&

Essayez-le en ligne!

Deux fonctions qui sortent via la valeur de retour.

Python 3 (partie 1 et partie 2)

Malheureusement, Nodebox est très verbeux ... il n'y a pas beaucoup de place pour le golf.

Partie 1 76 octets

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

Partie 2 (utilise la bibliothèque NodeBox ) 76 octets

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

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

Deux fonctions dans le même environnement Node.js, invoquées comme g(f(n)). Utilise le paquet npm nombre à mots .

Partie 1, 47 octets (40 octets + 7 espaces)

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

Partie 2, 47 octets

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

Essayez-le sur Runkit!

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

Partie 1, 48 octets

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

Partie 2, 43 octets

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

Essayez-le sur Runkit!

Perl 5.10 / Common Lisp, 34/26 octets

Donc, Common Lisp formata cela comme intégré, car bien sûr, il le fait.

Programme 1 (34 octets)

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

Perl fait tout l'itération. Le code Common Lisp équivalent ( (dotimes(i(read)) ...)) est plus long que le Perl beaucoup plus golfeur ... for 1..<>. Perl génère un tas de code Common Lisp.

Programme 2 (26 octets)

(loop(eval(read nil nil)))

C'est un REPL, moins le P. Il lit l'entrée standard et, bien, l'exécute. Ne se termine pas, mais les règles disent explicitement que ça va.