... I numeri ordinali (o numeri ordinali) sono parole che rappresentano la posizione o il rango in un ordine sequenziale.

Da Wikipedia .

Il tuo compito è, usando 2 programmi separati (di cui può essere fatto da 2 lingue diverse), di produrre la sequenza ordinale dal primo al nth. Proporrai l'intera parola secondinvece di 2nd.

La sfida dei numeri ordinali è stata sollevata in precedenza, in particolare in questa voce . In questa sfida, gli ordinali sono semplicemente un veicolo per facilitare le condizioni uniche descritte di seguito.

Parte 1

È necessario creare un programma che, quando viene immesso, ndeve produrre qualsiasi cosa .
nsarà sempre un numero intero positivo, diverso da zero, non maggiore di 999.

L'output valido include ma non è limitato a :

Qualsiasi output in stdout/ stderr/ ecc
Creazione di file / cartelle / ecc
Un'interfaccia grafica o immagini di qualsiasi tipo

Tutto va bene.

Parte 2

È necessario creare un programma che utilizza l'output del programma della parte 1 per generare una sequenza di numeri ordinali, a partire da 1 (prima), fino a tutto ciò che è nstato analizzato nella parte 1.

Condizioni generali:

I byte totali per la parte 2 non devono superare i byte totali per la parte 1 (minore o uguale a).

Condizioni di uscita:

Non sensibile a maiuscole e minuscole.
L'output deve contenere solo la sequenza ordinale (solo caratteri aZ) e gli spazi bianchi (nuove righe consentite).
Può essere inviato a qualsiasi sorgente, purché sia visibile durante o dopo l'esecuzione.
Il programma non ha bisogno di terminare fintanto che il suo output è corretto.
L'output non è tenuto ad avere una grammatica, ma può facoltativamente includerlo (trattini, virgole, "e", ecc.). nine hundred ninety ninthè accettabile come nine hundred and ninety-ninth.

Uscita campione

Dov'è n8

FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH

punteggio

La gerarchia delle condizioni di vittoria è:

Il numero più basso di byte nella parte 1

Il numero più basso di byte nella 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

code-golf

— BDM
fonte

5

Qual è il punto nella parte 1 (come in, perché non è stato possibile segnare questa sfida solo con la domanda più breve per la parte 2)? Inoltre, nel tuo secondo esempio di punteggio, la prima voce non è valida (parte 2> parte 1) e, in caso contrario, non batterebbe la seconda voce? Inoltre, raccomando di avere almeno un collegamento a un insieme di regole formali per la definizione di ordinali; per esempio, 111 dovrebbe dire one hundred and eleventho one hundred eleventh?

— HyperNeutrino,

3

@HyperNeutrino Penso che l'idea sia quella di cercare di dividere il lavoro tra i due il più uniformemente possibile durante il golf - se faccio output p1 [30, 'second']per 32allora p2 ha meno lavoro da fare se avesse output, giusto 32.

— Jonathan Allan il

4

Forse mi manca qualcosa di stupido, ma delle ultime due voci negli esempi di punteggio, perché la voce 1 non vince? la parte 1 ha gli stessi byte, la parte 2 è inferiore o uguale alla parte 1 per entrambi e la voce 1 parte 2 ha meno byte della voce 2 parte 2.

— Patrick Roberts,

@PatrickRoberts Poiché la Parte 2 deve contenere un numero uguale o inferiore di byte alla Parte 1. Poiché la Parte 1 è di 21 byte, ma la Parte 2 è di 33 byte, la Voce n. 1 è squalificata. Sfortunatamente, tali informazioni sono nascoste e non dichiarate esplicitamente nelle condizioni di vittoria al momento.

— Chronocidal,

@PatrickRoberts Questo è importante, perché altrimenti potresti usare un linguaggio che passa implicitamente l'input come output quando viene eseguito un programma a 0 byte per la Parte 1

— Chronocidal,

14

Mazza 0.5.1 / Mazza 0.5.1, 10 byte

Programma 1 (10 byte):

⣘⢷⠾⣃⢖⣎⢅⡨⠱⢳

Si decomprime in questa funzione del linguaggio Wolfram:

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

Programma 2 (7 byte):

⡾⡁⢚⣷⣬⠤⣾

Si decomprime in questa funzione del linguaggio Wolfram:

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

Provalo online!

— lirtosiast
fonte

9

R (con `english`pacchetto), 16 byte / 16 byte

Parte 1, 16 byte

f=function(n)1:n

Parte 2, 16 byte

english::ordinal

Richiede il englishpacchetto (che purtroppo non è installato su TIO).

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

Naturalmente, la parte 1 potrebbe essere resa molto più breve (3 byte:) seq, ma ciò andrebbe contro il vincolo che la parte 2 non deve essere più lunga della parte 1.

— Robin Ryder
fonte

@Giuseppe Sicuro. Anche se direi che i pacchetti CRAN fanno parte di R, e quindi dovrebbero essere permessi fintanto che contiamo i caratteri necessari per caricarli e collegarli.

— Robin Ryder,

Credo che il meta consenso sia che l'uso di una libreria esterna conta essenzialmente come "un'altra lingua"; vedi per esempio questo post che parla dei flag del compilatore, ma ha una nota sulle librerie esterne di Python. La risposta qui è istruttiva con molti esempi ma non riesco a usare la funzione di ricerca su meta per trovare l'affermazione definitiva.

— Giuseppe,

@Giuseppe Continua nella chat: chat.stackexchange.com/transcript/message/51052875#51052875

— Robin Ryder il

8

Wolfram Language (Mathematica) (entrambe le parti), 18 byte / 15 byte

-5 / -1 grazie a lirtosiast

Parte 1, 18 byte

Range@#|"Ordinal"&

Parte 2, 15 byte

IntegerName@@#&

Provalo online!

Due funzioni che vengono emesse tramite il valore di ritorno.

— attinat
fonte

2

Range@#|"Ordinal"&è più breve e IntegerNamevettorializza sul primo argomento. Penso che potrebbe essere necessario un output separato dallo spazio.

— Lirtosiast

4

Python 3 (parte 1 e parte 2)

Sfortunatamente Nodebox è molto prolisso ... non c'è molto spazio per giocare a golf.

Parte 1 76 byte

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

Parte 2 (utilizza la libreria NodeBox ) 76 byte

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

— UN
fonte

5

La tua risposta deve essere valida; in questo caso, la parte 2 è più lunga della parte 1, che non è valida. Non puoi contrassegnare una risposta come "non competitiva" e inviare un invio non valido; l'etichetta "non competitiva" è un'etichetta deprecata per le sfide presentate in lingue o versioni linguistiche che postdatano la sfida, che in genere era vietata, ma consentita in stato di "non concorrenza" per invii interessanti comunque.

— HyperNeutrino,

1

@HyperNeutrino Mi dispiace, ho pensato che le regole richiedessero che la Parte 1 fosse più corta della Parte 2. Ho contrassegnato questo come non competitivo perché ha usato una libreria per risolvere questo problema.

— A̲̲

2

Tecnicamente, l'utilizzo di librerie esterne sembra andare bene: codegolf.meta.stackexchange.com/q/188

— Jono 2906,

1

import en.number as nti salva quattro byte in ogni parte.

— Khuldraeseth na'Barya,

1

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

Due funzioni nello stesso ambiente Node.js, invocate come g(f(n)). Usa il pacchetto npm da numero a parole .

Parte 1, 47 byte (40 byte + 7 spazi)

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

Parte 2, 47 byte

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

Provalo su Runkit!

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

Parte 1, 48 byte

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

Parte 2, 43 byte

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