Sfida:

Il tuo compito è quello di scrivere quanti più programmi / funzioni / frammenti puoi, dove ognuno emette / stampa / restituisce un numero intero. Il primo programma deve generare l'intero 1, il secondo 2e così via.

Non è possibile riutilizzare alcun carattere tra i programmi. Quindi, se il primo programma è:, x==xallora non puoi usare i caratteri xe di =nuovo in nessuno degli altri programmi. Nota: è consentito utilizzare lo stesso personaggio più volte in un programma.

punteggio:

Il vincitore sarà l'invio che conta il più alto. In caso di pareggio, il vincitore sarà l'invio che ha utilizzato il minor numero di byte in totale.

Regole:

• Puoi usare una sola lingua per tutti i numeri interi
• Sono ammessi frammenti!
• Per mantenerlo corretto, tutti i caratteri devono essere codificati utilizzando un singolo byte nella lingua scelta.
• L'output deve essere in decimale. Non è possibile riprodurlo con notazione scientifica o altri formati alternativi. L'output dei float è OK, purché tutte le cifre visualizzate dietro il punto decimale siano 0. Quindi, 4.000è accettato. Le imprecisioni dovute all'FPA sono accettate, purché non vengano visualizzate nell'output.
• ans =, sono consentiti spazi iniziali e finali, newline ecc.
• È possibile ignorare STDERR, purché l'output corretto venga restituito a STDOUT
• È possibile scegliere di inviare l'intero su STDERR, ma solo se STDOUT è vuoto.
• Le lingue indipendenti dai simboli (come Lenguage ) non sono consentite
• Le lettere fanno distinzione tra maiuscole e minuscole a != A.
• I programmi devono essere indipendenti
• Gli spazi bianchi non possono essere riutilizzati
• È necessario utilizzare le cifre ASCII nell'output

Le spiegazioni sono incoraggiate!

JavaScript (ES7), punteggio 17, 176 byte

Hanno detto che non si poteva fare, quindi l'ho fatto: D (grazie al grande aiuto di @FullDecent)

""**""
~(~/~//~/~/)/~/~/
3
4
!NaN- -!NaN- -!NaN- -!NaN- -!NaN
6
7
8
9
++[[]][+[]]+[+[]]
11
'lengthlength'.length
222>>2>>2
`${``^``}xE`^``
0XF
C=CSS==CSS;C<<C<<C<<C<<C
555555555555555555555%55

Personaggi inutilizzati:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

Non penso che 18 sia possibile, ma ho detto la stessa cosa su 17 ...

Spiegazione

JavaScript è un linguaggio tipicamente molto debole; se si tenta di eseguire un'operazione matematica su un valore non numerico, JS farà del proprio meglio per convertirlo prima in un numero. Ciò consente molte soluzioni interessanti. Ho cercato di evitare di utilizzare le cifre il più possibile in modo che possano essere utilizzate in seguito.

1. **è l'operatore esponenziale in ES7. La stringa vuota quando viene forzata su un numero diventa 0, quindi questo calcola 0 ** 0, che è 1secondo JavaScript.
2. Un po 'ridicolo, ma funziona. /~/è un regex letterale e ~/~/restituisce -1, quindi questo è ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2. (crediti a @ GOTO0 per l'idea)
3. Semplicemente 3.
4. Ora semplicemente 4.
5. NaNè falsa, così !NaNè true, che equivale a 1. L'espressione diventa così 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= 5.
6. Semplicemente 6.
7. Semplicemente 7.
8. Semplicemente 8.
9. Semplicemente 9.
10. Questo usa un po 'di magia JSF *** . +[]è 0, quindi [[]][+[]]restituisce il primo elemento di [[]](ovvero, []) e lo ++incrementa a 1. Quindi +[+[]]aggiunge l'array [0], che è costretto a una stringa e crea "10".
11. Semplicemente 11. Inizialmente avevo usato 11&1111per 3 e 33/3per 11 finché non mi sono reso conto ancora una volta di quanto sono stupido ...
12. Questa strategia funzionerebbe su qualsiasi numero: creare una stringa di lunghezza 12e utilizzo .length.
13. Ho appena fatto un casino in giro con 2s e >s per un po 'per ottenere questo. Sono stato di nuovo fortunato: 222 >> 2è 55ed 55 >> 2è 13.
14. Questo è piuttosto complicato. L'idea di base è creare 14in hex ( 0xE), ma abbiamo bisogno della cifra 0altrove. Quindi invece anteponiamo il risultato ``^``alla stringa xE; la stringa vuota forzata a un numero è 0, quindi restituisce 0 ^ 0= 0. Quindi il risultato è XORed con la stringa vuota, che converte entrambi i valori in numeri; "0xE" ^ ""lo è 14.
15. Questo è ora abbastanza semplice: 0XFè un letterale esadecimale con un valore di 15.
16. Il più complicato di tutti? Innanzitutto impostiamo la variabile Csu CSS == CSS(ovvero, true). Quindi prendiamo il risultato ed eseguiamo << Cquattro volte, che sostanzialmente si moltiplica 1per 2 ** 4.
17. JavaScript inizia a perdere la precisione dei numeri interi a 2 ⁵³ , che consente 555...555%55di restituire un numero che non lo è 0o 5. Mi è capitato di essere molto fortunato mentre giocavo qui.

Strategie che potrebbero funzionare su molti numeri:

• -!NaNfunzionerebbe su qualsiasi numero (attualmente 5), anche se si ingrandisce molto velocemente.
• ~/~/funzionerebbe su qualsiasi numero (attualmente 2), anche se diventa molto grande molto velocemente.
• +[]funzionerebbe su qualsiasi numero (attualmente 10), anche se è di gran lunga più semplice su 10o 11.
• .length avrebbe funzionato su qualsiasi numero.
• `${-``}xE`-`` funzionerebbe praticamente su qualsiasi numero se lo fai bene.
• C<<Cfunzionerebbe su qualsiasi potenza di due (attualmente 16) o su qualsiasi int se includessi |.

Gelatina , 47 numeri interi, 519 byte

e
BI$⁼#
⁾⁾⁾Ụ^/
ı***ıḞḞ
5
6
7
.::::
9
EȮ<
⁻GṘ
=`p`VV×`DQV
~A~A~A~A~A~A~A~A~A~A~A~A~A
⁷ṾṾṾw
⁴ḟ€⁴Ṁ
mmmmċ
ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ
+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ
CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC
ĖḌĖḌ
ṫṣȦJṫȦ⁸ȦJ
22
“@ṃ»
!ḤḤ!
³HH
ØaM
;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬
irið8c
⁶ḲĠṂ°İṂĊ
œṡ¹ẆẆTUṖṖṖṖP
ȷ½RṪ
LµdddddµFL
33
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ
ẇɓæ«æ«æ«æ«æ«|æ«|
⁹ṚḢ²
‘‘‘0‘‘‘‘‘‘‘
’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ
-____---__________
”(O
⁵ḶxḶ⁵ị⁵ḶxḶḣṢ
⁽{ʂ%⁽{}
ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®
44
111111l11&K1111111Kl11&
,SS¶ỊỊ,ÇS¶ÇÑÇÇÇÑ
ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

Ogni riga è un programma separato e completo.

Provalo online! (include suite di test e controllo intersezioni)

Come funziona

Ogni programma completo senza argomenti della riga di comando esegue il suo collegamento principale (definito sull'ultima riga) in modo niladico, ovvero senza input. Se il primo collegamento nella catena è un nilad, viene consumato, chiamato e sia l'argomento del collegamento principale che il valore restituito vengono impostati sul risultato; se il primo anello della catena è una monade o una diade, non viene consumato e viene invece utilizzato l'argomento implicito e il valore restituito 0 . In entrambi i casi, il resto della catena viene eseguito monadicamente.

Jelly manipola la sua produzione in diversi casi. In particolare, un array singleton viene stampato senza le parentesi circostanti, quindi 42 e [42] e indistinguibile dopo la stampa. Lo useremo in diverse occasioni.

1 - 10

e

L' atomo esistente verifica se il valore restituito 0 appartiene all'argomento 0 . Lo fa, quindi erestituisce 1 .

BI$⁼#

BI$è un collegamento rapido, in particolare una catena monadica formata dal $raggruppamento rapido dell'atomo binarioB e dell'atomo di incrementiI . Combinati, convertono un numero intero nella matrice delle sue cifre nella base 2, quindi calcolano le differenze in avanti delle cifre risultanti. Se l'array ha un solo elemento, non ci sono differenze in avanti e Irestituisce un array vuoto (falsy); se ci sono almeno due cifre, Irestituisce un array non vuoto (verità).

Il rapido #consuma il collegamento rapido precedente e lo applica a 0 , 1, 2, ... fino a quando non vengono trovate abbastanza corrispondenze e restituisce la matrice di corrispondenze. L'importo richiesto viene calcolato da ⁼, che confronta il valore di ritorno / argomento 0 con se stesso, ottenendo 1 . Pertanto, l'intero programma restituisce [2] , il primo intero non negativo con due cifre in base 2.

⁾⁾⁾Ụ^/

⁾⁾⁾è una stringa letterale, in particolare la stringa ⁾⁾ . L' atomo di grado superioreỤ ordina i suoi indici in base ai loro valori corrispondenti; poiché entrambi i caratteri sono uguali, si ottiene [1, 2] . L'array risultante viene ridotto con XOR bit a bit ^/, quindi l'intero programma restituisce 3 .

ı***ıḞḞ

ıinizializza l'argomento e restituisce valore all'unità immaginaria i . *è la diade di esponenziazione , il cui argomento corretto viene impostato per default sull'argomento del collegamento principale. Quindi, ***ıcalcola ((i ⁱ ) ⁱ ) ⁱ ≈ 4.81 + 0i , l' Ḟatomo ( piano per argomenti reali , parte reale per argomenti complessi) calcola la parte reale ( 4.81 ), quindi Ḟpiani, producendo 4 .

5
6
7

Questi tre programmi consistono in un unico letterale e fanno esattamente quello che ti aspetteresti.

.::::

Il valore letterale .è una scorciatoia per 0,5 e inizializza argomento e valore di ritorno. L' argomento destro della divisione intera della diade ( :) viene impostato automaticamente sull'argomento dei collegamenti principali, quindi ::::calcola 0,5 / 0,5 / 0,5 / 0,5 / 0,5 , producendo 8 .

9

Un altro letterale.

EȮ<

L' atomo tutto ugualeE restituisce 1 se tutti gli elementi nel suo argomento sono uguali e 0 in caso contrario. Un argomento intero z viene promosso a [z] , quindi Erestituirà 1 per l'argomento implicito 0 .

Ora, l' atomo di outputȮ stampa 1 su STDOUT. Confrontiamo quindi 1 con l'argomento implicito 0 utilizzando l' atomo minore di< . Il risultato è (1 <0) = 0 e viene stampato implicitamente al termine del programma.

11 - 20

⁻GṘ

L' atomo della grigliaG cerca di creare una tabella visivamente piacevole dal suo argomento. Per un semplice argomento intero (qui: 0 ), lo avvolge semplicemente in un array. L' atomo piatto non uguale⁻ confronta l'argomento implicito 0 con il risultato a destra ( [0] ), producendo 1 poiché i suoi argomenti non sono uguali. L' atomo di rappresentazioneṘ stampa 1 su STDOUT e restituisce il suo risultato. Alla fine del programma, il valore di ritorno finale viene stampato implicitamente, quindi finiamo con un output di 11 .

=`p`VV×`DQV

L' auto veloce `trasforma una diade in una monade chiamandola con argomenti identici a destra e sinistra. Innanzitutto, =`confronta l'argomento implicito 0 con se stesso, producendo 1 .

L' atomo del prodotto cartesianop prevede elenchi come argomenti, quindi promuove l'intero 1 nell'intervallo [1,…, 1] = [1] . p`prende il prodotto cartesiano di [1] e di se stesso, producendo [[1, 1]] .

L' atomo evalV trasforma tutte le matrici piatte (contenenti solo numeri e caratteri) in stringhe, quindi valuta le stringhe risultanti come programmi jelly niladici. [[1, 1]] viene prima trasformato in [“11”] , quindi Velimina la stringa, producendo [11] . Ancora una volta, Vtrasforma questo array in "11" , quindi lo elimina per ottenere 11 .

Ora, ×`moltiplica 11 con se stesso, producendo 121 . L' atomo decimale trasforma 121 in [1, 2, 1] , l' atomo univocoQ scarta il secondo 1 e Vancora una volta trasforma un elenco di cifre nell'intero che risulta dalla loro concatenazione, restituendo 12 .

~A~A~A~A~A~A~A~A~A~A~A~A~A

~è l' atomo NON bit a bit . Con l'aritmetica del complemento a due, associa un argomento da z a ~ z = - (z + 1) . Aè l' atomo del valore assoluto , quindi mappa - (z + 1) = z + 1 . Con il valore di ritorno iniziale 0 , le tredici copie del ~Areso 13 .

⁷ṾṾṾw

La costante ⁷contiene il carattere di nuova riga '\ n' e inizializza l'argomento e restituisce il valore.

L' atomo irregolareṾ tenta di creare una rappresentazione in forma di stringa del suo argomento z in modo tale che un programma Jelly costituito da questo codice restituisca z .

La prima chiamata restituisce doverosamente la stringa "" \ n " , che è un carattere letterale. La chiamata successiva restituisce "" ”,” \ n " - una coppia di caratteri letterali. La terza e ultima chiamata restituisce "” ”,” ”,” ,, ””, ”\ n" - un quintuplo di caratteri letterali.

Infine, l' atomo di indice di finestraw promuove il suo argomento corretto '\ n' alla stringa "\ n" e trova il primo indice di una sottostringa che inizia con "\ n" . Questo restituisce 14 .

⁴ḟ€⁴Ṁ

⁴è la costante 16 . Il filtro quicklinkse each ( ḟ€) promuove il suo argomento sinistro 16 nell'intervallo [1, ..., 16] , quindi scorre i suoi elementi.

Per ogni elemento z , ḟ⁴viene eseguito, promuovendo prima z in [z] , quindi rimuovendo tutte le occorrenze (se presenti) di 16 . Questo produce l'array [[1], [2],…, [14], [15], []] , dove l'ultimo array è vuoto perché conteneva 16 .

Infine, l' atomo massimoṀ seleziona [15] .

mmmmċ

L' atomo modularem - chiamato con argomenti x (array) e y (intero) di solito prende ogni | y | ^th elemento di x , a partire dal primo se y> 0 , con l'ultimo se y <0 . Tuttavia, quando y = 0 , restituisce x concatenato con il suo contrario.

L'argomento intero sinistro 0 viene prima promosso a [0] . La prima copia di mconcatena [0] con se stessa, producendo [0, 0] . Le copie rimanenti trasformano questo risultato in [0, 0, 0, 0] , quindi [0, 0, 0, 0, 0, 0, 0, 0] e infine [0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .

Alla fine, l' atomo di conteggioċ conta il numero di volte in cui l'argomento implicito 0 appare nella matrice risultante, restituendo 16 .

ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ

ṭè l' atomo di virata e aggiunge il suo argomento di sinistra a quello di destra. Poiché ṭe quanto segue ḍsono diadici, tutte le chiamate per ṭpassare l'argomento implicito 0 come argomento giusto a ṭ. La prima chiamata restituisce [0, 0] , la seconda [0, [0, 0] e l'ottava e l'ultima [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]]] .

ḍè l' atomo di divisibilità ; Per gli argomenti x e y , restituisce 1 è x è divisibile per y , 0 in caso contrario. Ḅè un no-op per numeri interi, quindi ḍḄverifica 0 per divisibilità per ogni numero intero nella matrice costruita. 0 è divisibile per se stesso, quindi otteniamo [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]] .

Ora, il unbinary atomo Ḅopera su matrici piane. Per una coppia [a, b] , restituisce semplicemente 2a + b . Come accennato in precedenza, Ḅè un no-op per numeri interi: un argomento intero c viene promosso a [c] e [c] in qualsiasi base è semplicemente c .

La prima chiamata a Ḅriduce [1, 1] a 3 , dando così [1, [1, [1, [1, [1, [1, [1, 3]]]]]]] . La chiamata successiva riduce [1, 3] a 5 , la successiva [1, 5] a 7 e così via fino a quando la nona Ḅrestituisce 17 .

+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ

Ṇè l' atomo NOT logico piatto e mappa l'argomento implicito da 0 a 1 . +è l'atomo di addizione, quindi ciascuna delle diciotto copie di +Ṇincrementa il valore di ritorno precedente (inizialmente 0 ). L'intero programma restituisce quindi 18 .

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Cè l' atomo del complemento e mappa l'argomento da z a 1-z . Nè l' atomo negativo e mappa il suo argomento da z a -z . Insieme, CNmappa z su - (1-z) = z-1 , quindi le diciotto copie trasformano l'argomento implicito 0 in -18 . Un'applicazione finale dei Crendimenti 1 - (-18) = 19.

ĖḌĖḌ

L'enumerate atomo Ėenumera gli elementi in un array, creando coppie indice di valore. L'argomento implicito 0 viene promosso a [0] , quindi Ėrestituisce [[1, 0]] . L' atomo undecimale converte una matrice piatta dalla base 10 all'intero, producendo [10] in questo caso particolare.

La seconda chiamata per Ėtrasformare [10] in [[1, 10]] , che la seconda Ḍtrasforma infine in [20] .

21-30

ṫṣȦJṫȦ⁸ȦJ

L' atomo di codaṫ (una diade) seleziona il postfisso del suo argomento sinistro che inizia dall'indice (basato su 1 e modulare) specificato nel suo argomento destro, promuovendo un argomento intero sinistro da x a [x] . Quando viene chiamato con entrambi gli argomenti impostati su 0 , ṫrestituisce [0] .

L' atomo any e allȦ restituisce 1 se il suo argomento è veritiero e non contiene zero a nessuna profondità, 0 altrimenti. Qui, lo usiamo semplicemente come una funzione di identità per restituire l'argomento implicito 0 . La divisione atomo ṣsuddivide l'argomento sinistro [0] in occorrenze dell'argomento destro 0 , quindi restituisce [[], []] qui.

L' atomo di indiciJ scarta gli elementi del valore di ritorno e li sostituisce con i loro indici, producendo l'intervallo [1, 2] in questo caso specifico. Ȧed ṫentrambi funzionano come prima, quindi riducono [1, 2] al postfisso che inizia all'ultimo indice, producendo [2] .

Nei collegamenti niladici, la costante ⁸contiene [] . Questo è un nilad non analizzabile, cioè non si adatta alla catena in alcun modo. Di conseguenza, il valore di ritorno precedente ( [2] ) viene stampato su STDOUT, quindi sostituito con il valore di nilad ( [] ).

Poiché [] è falso, lo Ȧtrasforma in 0 . L' Jatomo promuove 0 su [0] , quindi restituisce l'elenco dei suoi indici ( [1] ), che viene stampato implicitamente al termine del programma.

22

Un altro letterale. I rimpiazzi sembrano essere il posto migliore per usarli.

“@ṃ»

Questo utilizza la compressione delle stringhe integrata di Jelly. Gli indici di @ e ṃ nella codepage di Jelly sono 64 e 220 e i letterali di stringa possono contenere 250 caratteri diversi, quindi questo prima calcola l'intero 250 × 65 + 220 = 16470 .

16470 è divisibile per 3, quindi il quoziente 16470/3 = 5490 codifica un carattere ASCII stampabile o un avanzamento di riga. Ce ne sono 96 e 5490 = 96 × 57 + 18 , il che significa che abbiamo decodificato il carattere ASCII stampabile nell'indice 18 basato su 0 , che è '2' .

Siamo lasciati con 57 , che è anche divisibile per 3 , quindi il quoziente 57/3 = 19 = 96 × 0 + 19 codifica caratteri ASCII stampabili in corrispondenza dell'indice 0 a base 18 , che è '3' .

Questo lascia 0 ; il processo di decodifica si interrompe. I caratteri generati vengono concatenati per formare "23"

!ḤḤ!

L' atomo fattoriale! trasforma l'argomento implicito 0 in 1 . Due invocazioni dell'atomo unhalveḤ trasformano 1 in 2 , quindi 2 in 4 . Infine, !calcola 4! = 24 .

³HH

In assenza di argomenti della riga di comando, la costante ³contiene 100 . Due invocazioni delle Hcurve 100 in 50 , quindi 50 in 25 .

ØaM

La costante Øacontiene l'alfabeto minuscolo. L' atomo massimoM produce tutti gli indici degli elementi massimi e poiché z è la più grande lettera minuscola, il risultato è [26] .

;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬

Ventisei copie del concatenate dell'atomo ;concatenare il valore di ritorno iniziale di 0 e ventisei le istanze del argomento di default 0 , la costruzione di una serie di 27 zeri.

¬è l' atomo NOT logico , quindi ;¬aggiunge un 1 alla matrice di zero. Il successivo ¬annulla tutti gli elementi dell'array, lasciandoci con un array di 27 e 1 zero.

ḅè l' atomo unbase e converte un array di cifre dall'argomento sinistro dalla base specificata nell'argomento destro in intero. ḅ¬converte da unario a intero, quindi esegue semplicemente una somma. Per un array di 27, questo restituisce 27 .

irið8c

L' indice di atomo ipromuove l'argomento sinistro da 0 a [0] , quindi trova l'indice dell'argomento destro 0 in quell'array, ottenendo 1 .

L' atomo di intervallor costruisce un intervallo crescente o decrescente dal suo argomento di sinistra a quello di destra. L'argomento giusto è l'argomento implicito 0 , quindi questo produce [1, 0] . Una seconda invocazione di itrova l'indice 0 in [1, 0] , producendo 2 .

ðinizia una nuova catena diadica. Poiché la catena precedente era niladica, l'argomento destro e sinistro di questa catena sarà uguale al valore di ritorno della prima catena ( 2 ). cnelle combinazioni atom. Con l'argomento sinistro 8 e l'argomento destro 2 , conta tutte le 2 combinazioni uniche e non ordinate di un insieme di 8 elementi, restituendo 8C2 = 8! / (6! 2!) = 28 .

⁶ḲĠṂ°İṂĊ

La costante ⁶contiene un carattere spazio e imposta argomento e restituisce valore a "" . Le parole atom Ḳpromuovono il carattere '' nella stringa singleton "" e lo dividono in spazi, producendo [[], []] .

L' atomo del gruppoĠ raggruppa tutti gli indici di elementi uguali. Poiché entrambi gli elementi dell'ultimo valore restituito sono uguali, restituisce [[1, 2]] qui. L' atomo minimo estrae un minimo (unico) elemento di questo array, producendo [1, 2] .

L' atomo di grado° converte entrambi i numeri interi da gradi sessagesimali a radianti, producendo 1 ° × 2π / 360 ° = π / 180 e 2 ° × 2π / 360 ° = π / 90 . L' atomo inverso prende le inversioni moltiplicative, producendo 180 / π ≈ 57,3 e 90 / π ≈ 28,6 .

Quindi, Ṃancora una volta prende il minimo, producendo 28,6 . Infine, l' atomo di ceilĊ trasforma 28,6 in 29 .

œṡ¹ẆẆTUṖṖṖṖP

L' atomo di identità¹ restituisce 0 per l'argomento implicito 0 . La suddivisione attorno all'atomo œṡpromuove entrambi i suoi argomenti (entrambi 0 ) su [0] , quindi suddivide [0] attorno a sottoquarti contigui pari a [0] . Questo produce [[], []] .

L' atomo di finestra scorrevoleẆ crea tutti i contrapposti contigui del suo argomento. La prima istanza trasforma [[], []] in [[[]], [[]], [[], []]] , la seconda istanza trasforma [[[]], [[]], [[] , []]] in
[[[[]]], [[[]]], [[[], []]], [[[]], [[]]], [[[]], [ [], []]], [[[]], [[]], [[], []]]] .

L' atomo di veritàT elenca tutti gli indici degli elementi di verità. Nessuno degli array al primo livello è vuoto, quindi questo produce [1, 2, 3, 4, 5, 6] . L' atomo upendU inverte questo array, producendo [6, 5, 4, 3, 2, 1] .

Quattro copie dell'atomo popṖ rimuovono gli ultimi quattro elementi, lasciandoci con [6, 5] . Infine, l' atomo del prodottoP trasforma questo array in 30 .

31 - 40

ȷ½RṪ

ȷè una scorciatoia per 1 × 10 ³ = 1000 . L' atomo della radice quadrata½ produce 31,6 , che l' atomo della gammaR trasforma in [1,…, 31] . Infine, l' atomo di codaṪ estrae l'ultimo elemento, restituendo 31 .

LµdddddµFL

L' atomo lunghezzaL promuove l'argomento implicito da 0 a [0] , quindi impiega la lunghezza per produrre 1 . µavvia una nuova catena monadica e il risultato 1 diventa il suo argomento.

Per gli argomenti x e y , i divmod atomo drese [x / y, x% y] . Ogni chiamata avrà y = 1 , quindi il risultato sarà sempre [x, 0] .

La prima chiamata inizia con x = 1 , producendo [1, 0] . dopera solo su numeri interi, quindi vettorializza nelle chiamate successive. La seconda chiamata produce [[1, 0], [0, 0]] , la terza [[[1, 0], [0, 0]], [[0, 0], [0, 0]]] , e il quinto e ultimo un array di profondità 5 che contiene un singolo e 31 zero.

µancora una volta inizia una nuova catena monadica e l'array di prima diventa il suo argomento. L' atomo piattoF annulla questa matrice, producendo una matrice piatta di uno singolo e 31 zero. Infine, Lprende la lunghezza del risultato, restituendo 32 .

33

Un altro rimedio, un altro letterale.

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

Ogni istanza dell'atomo di avvolgimento trasforma il suo argomento z in [z] . Con il valore di ritorno iniziale di 0 , tutte e 34 le istanze insieme producono [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Infine, l' atomo di profonditàŒḊ calcola la profondità massima dell'array risultante, restituendo 34 .

ẇɓæ«æ«æ«æ«æ«|æ«|

La finestra esiste atom ẇpromuove entrambi i suoi argomenti (entrambi predefiniti su 0 ) su [0] , quindi verifica se ** [0] ** si presenta come un sottoarray contiguo di [0] . Lo fa, quindi ẇrestituisce 1 .

ɓinizia una nuova catena diadica. Poiché la catena precedente era niladica, l'argomento destro e sinistro di questa catena sarà uguale al valore di ritorno della prima catena ( 1 ). La catena utilizza due diversi atomi diadici: bitshift left ( æ«) e bitwise OR ( |).

Una catena diadica che inizia con tre o più diade inizialmente chiama la prima diade con gli argomenti della catena. Qui, questo dà 1 << 1 = 2 . Le sei diadi successive sono raggruppate in coppie (le cosiddette forcelle ), dove la diade più a destra viene chiamata prima con gli argomenti della catena, quindi quella più a sinistra viene chiamata con i precedenti valori di ritorno su entrambi i lati.

Per æ«æ«, otteniamo 2 << (1 << 1) = 2 << 2 = 8 . Quindi, æ«æ«calcola 8 << (1 << 1) = 8 << 2 = 32 . Ora, |æ«ci ottiene 32 | (1 << 1) = 32 | 2 = 34 .

Infine, il trailing si |comporta come un hook e viene chiamato con il valore di ritorno precedente come argomento di sinistra e l'argomento di destra della catena come di destra. Ciò restituisce 34 | 1 = 35 .

⁹ṚḢ²

In assenza di un secondo argomento, la costante ⁹contiene 256 . L' atomo inverso promuove 256 nell'array [2, 5, 6] e lo inverte per produrre [6, 5, 2] . Quindi, l' atomo capoḢ estrae il primo elemento e l' atomo quadrato² restituisce ** 6² = 36 *.

‘‘‘0‘‘‘‘‘‘‘

L' incremento atomo ‘incrementa sua tesi da 1 , quindi ‘‘‘ruotare il valore restituito iniziale 0 in 3 . Il seguente 0 è un nilad non analizzabile, cioè non si adatta in alcun modo alla catena. Di conseguenza, il valore di ritorno precedente ( 3 ) viene stampato su STDOUT, quindi sostituito con il valore di nilad ( 0 ).

Le seguenti 7 copie ‘trasformano questo 0 in 7 , che viene stampato implicitamente al termine del programma.

’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ

Il decremento atomo ’decrementa sua tesi da 1 , così trentotto copie ruotare il valore iniziale di ritorno 0 in -38 . L' atomo della differenza assolutaạ calcola la differenza senza segno tra -38 e l'argomento implicito 0 , restituendo 38 .

-____---__________

-è una scorciatoia per -1 e imposta l'argomento del collegamento e restituisce il valore a -1 . Ognuna _è un'istanza dell'atomo di sottrazione diadica , il cui argomento destro verrà impostato a -1 se mancante.

Innanzitutto, -____-calcola (-1) - (-1) - (-1) - (-1) - (-1) = 3 . Il seguente -1 è un nilad non analizzabile, quindi il valore di ritorno precedente ( 3 ) viene stampato su STDOUT, quindi sostituito con il valore del nilad ( -1 ).

Quindi, -_calcola (-1) - (-1) = 0 , dove il valore letterale -imposta l' argomento sinistro di _e utilizza il valore restituito come quello giusto. Le seguenti nove copie _sottraggono l'argomento predefinito -1 dal valore restituito, producendo 9 , che viene stampato implicitamente al termine del programma.

”(O

”(è un carattere letterale e l' atomo ordinaleO cerca il suo punto di codice Unicode, producendo 40 .

41 - 47

⁵ḶxḶ⁵ị⁵ḶxḶḣṢ

In assenza di un terzo argomento della riga di comando, la costante ⁵contiene 10 . L' atomo unlengthḶ crea un intervallo basato su 0, in particolare [0,…, 9] per l'argomento 10 , su entrambi i lati dell'atomo ripetuto sul postox . Quest'ultimo abbina gli elementi del suo argomento sinistro con le ripetizioni del suo argomento destro e ripete ciascuno degli elementi il ​​numero corrispondente di volte. Con [0,…, 9] sia come argomento sinistro che destro, otteniamo quindi zero zero, uno uno, due due, ecc.

L' indice in atomo ịrecupera l'elemento dell'argomento destro nell'indice specificato in quello sinistro. Con l'argomento sinistro 10 ( ⁵alla sua sinistra) e l'argomento destro [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (risultato precedente), questo dà 4 .

La catena fino a questo punto è seguita da un nilad non analizzabile ⁵, quindi il valore di ritorno precedente ( 4 ) viene stampato su STDOUT, il valore di ritorno è impostato su 10 e il resto della catena viene analizzato come al solito.

Come prima, ⁵ḶxḶprodurrà l'array [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] . Questa volta, chiamiamo l' atomo ordinatoṢ sull'argomento 10 , che promuove 10 a [1, 0] , quindi lo ordina per produrre [0, 1] . L' atomo di testa diadica ora recupera i prefissi di lunghezze 0 e 1 dal risultato a sinistra, lasciandoci con [[], [1]] . In fase di stampa, altro che 1 rimarrà visibile.

⁽{ʂ%⁽{}

⁽e i suoi due caratteri seguenti costituiscono un valore letterale numerico. Se j e k sono i loro punti di codice nella tabella codici di Jelly e (j, k) <(124, 250) , otteniamo l'intero 1001 + 250j + k . I punti di codice di '{' , '}' e 'ʂ' sono 123 , 125 e 167 , quindi il valore letterale sinistro valuta 1001 + 250 × 123 + 167 (= 31918) , mentre quello destro valuta 1001 + 250 × 123 + 125 (= 31876) .

Poiché il numero intero sinistro è meno del doppio di quello destro, il risultato è (... + 167)% (... + 125) = (... + 167) - (… + 125) = 167-125 = 42 .

ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®

L' atomo shuffleẊ randomizza l'ordine degli elementi del suo argomento; un argomento numerico z viene promosso in anticipo nell'intervallo [1,…, z] . Per l'argomento implicito 0 , questo intervallo è vuoto e Ẋproduce [] . L' atomo tuttoẠ restituisce 1 se tutti gli elementi del suo argomento sono veritieri, 0 in caso contrario. Poiché un array vuoto non contiene elementi falsy, Ạrestituisce 1 qui.

La cerniera con atomo ż(una diade) prende argomenti x e y e traspone la coppia [x, y] . Per interi x ed y , questo produce semplicemente [[x, y]] , quindi questo particolare ż, chiamato con argomenti 1 e 0 (l'argomento implicito), ritorna [[1, 0]] . L' atomo diadico evalv trasforma tutte le matrici piatte (contenenti solo numeri e caratteri) nell'argomento sinistro in stringhe, quindi valuta le stringhe risultanti come programmi monadici di Jelly con il suo argomento giusto come argomenti dei programmi. Da ["10"]è costituito esclusivamente da letterali, questo ignora l'argomentazione corretta ve si limita semplicemente a [10] .

La copia rapida si ©allega ve copia il suo risultato nel registro. Le occorrenze successive dell'atomo di richiamo® (un nilad) prenderanno [10] dal registro.

Le prossime tre copie di żvlavoro come prima, mappando da [10] a [[10, 0] a [100] a ... a [10000] . L' atomo dell'ordineọ verifica quante volte il suo argomento sinistro è divisibile per il suo argomento destro, quindi qui calcola l'ordine di 10 (recuperato con ®) in 10000 = 10 ⁴ , ottenendo [4] .

Quanto segue ®è un nilad non analizzabile, quindi il valore di ritorno precedente ( [4] ) viene stampato su STDOUT, quindi sostituito con il valore di nilad ( 10 ). Applichiamo Ạsuccessivamente, producendo 1 . (Ciò è richiesto in quanto un nilad seguito da una diade sarebbe analizzabile a questo punto.)

Come prima, żvżvżvaggiunge tre zeri al valore di ritorno corrente, trasformando 1 in [1000] . Infine, ọ®calcola l'ordine di 10 in 1000 = 10 ³ e 3 viene stampato su STDOUT al termine del programma.

44

Ancora un altro rimedio, ancora un altro letterale.

111111l11&K1111111Kl11&

Innanzitutto, il valore letterale 111111imposta l'argomento e il valore di ritorno iniziale su 111111 . Le altre serie di 1sono anche letterali.

lè l' atomo logaritmico , che calcola il logaritmo del suo argomento sinistro sulla base specificata in quello destro. Quando viene chiamato 111111 con l'argomento giusto 11 , otteniamo il registro ₁₁ 111111 ≈ 4,85 .

Le parole atomo si Kunisce a un argomento dell'elenco negli spazi, dopo aver promosso un carattere z / numerico da [z] . Qui, lo usiamo semplicemente per trasformare l'argomento 111111 del link in [111111] . (Non abbiamo bisogno di un array qui, ma abbiamo esaurito gli atomi di identità.) L' atomo AND bit a bit& prende i valori di ritorno su entrambi i lati, li lancia a numeri interi se necessario e calcola i loro AND bit a bit. In questo caso particolare, restituisce [4.85 e 111111] = [4 e 111111] = [4] .

Quanto segue 1111111è un Nilad di analizzarlo, quindi il valore restituito precedente ( [4] ) è stampato a STDOUT, poi sostituito con il valore della Nilad ( 1111111 ). Kquindi trasforma questo numero intero in [1111111] . (Ciò non è ancora necessario, ma a questo punto un nilad seguito da una diade sarebbe analizzabile.)

Come prima, l11calcola il registro ₁₁ 1111111 ≈ 5,81 , quindi &restituisce [5.81 e 111111] = [5 e 111111] = [5] .

,SS
ỊỊ,ÇS
ÇÑÇÇÇÑ

Questo è l'unico programma costituito da più collegamenti definiti dall'utente. L'ultimo collegamento è il collegamento principale e viene eseguito all'avvio del programma, i restanti sono collegamenti di supporto. Il rapido Çsi riferisce sempre al collegamento sopra quello corrente e lo esegue in modo monadico. Allo stesso modo, il rapido Ñsi riferisce sempre al link sotto quello corrente (avvolgendo) e lo esegue anche monadicamente.

Il collegamento superiore costituito dalla coppia atomo ,- una diade che trasforma argomenti x e y in [x, y] - e la somma atomo S- una monade che promuove un argomento intero z a [z] e riduce un argomento di matrice per addizione. Quando il collegamento ,SSviene chiamato con un argomento intero n , calcola Σ [n, Σn] = Σ [n, n] = 2n .

Il collegamento centrale è costituito dagli atomi di cui sopra, il suddetto rapido Çe l' atomo insignificanteỊ - una monade che produce 1 per argomenti numerici z con -1 ≤ z ≤ 1 , ma 0 per tutti gli altri. Applicare Ịdue volte a un argomento intero n essenzialmente lo sostituisce con 1 , poiché l'output del primo Ị(l' input del secondo) è sempre insignificante. Questo risultato viene quindi associato al valore restituito di Ç(chiamato con l'argomento n ) e la coppia risultante viene ridotta di S. In totale, calcoliamoΣ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1 .

Con questi due collegamenti helper in atto, il collegamento principale ora può costruire qualsiasi numero intero non negativo osservando le sue cifre binarie. Con un valore di ritorno iniziale pari a 0 , la catena ÇÑÇÇÇÑcalcola il risultato finale (((((((0 × 2 + 1) × 2) × 2 + 1) × 2 + 1) × 2 + 1) × 2 = ((5 × 2 + 1) × 2 + 1) × 2 = 46 .

ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn

Il prossimo atomo primo trova il numero primo positivo più piccolo che è strettamente maggiore del suo argomento. Con il valore di ritorno iniziale 0 , quindici invocazioni Æncalcolano il quindicesimo numero primo, che è 47 .

Brainfuck , punteggio 2, 255 144 10 byte

... Sì, non è la migliore idea dato che ho solo 8 personaggi (tarp che faranno il tarpit) con cui lavorare, ma vediamo quanto è possibile. Penso che sia tutto ciò che è possibile. : P Questa risposta mostra sei degli otto caratteri utilizzati da Brainfuck, mentre gli altri due ,sono input e .output.

+
>--[<->-]

Visualizzalo online!

Spiegazione

Ogni numero viene creato e memorizzato nella cella iniziale sul nastro. Si basa fortemente sulle celle di avvolgimento, che non sono implementate in alcuni interpreti.

1 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

+  increment the current cell

[ 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

2 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-- decrement the current cell twice

[ 0 |254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[  while the current cell is not 0
<  move to the previous cell
-  decrement the current cell

[255|254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-  decrement the current cell

[255|253| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

]  repeat while the current cell is not 0

...

[ 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[ 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

[ 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

Neim , punteggio 38, 327 byte

1: 𝔼
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: β
11: γ
12: δ
13: ε
14: ζ
15: η
16: θ
17: ι
18: κ
19: λ
20: μ
21: ν
22: ξ
23: π
24: ρ
25: σ
26: ς
27: τ
28: υ
29: φ
30: χ
31: ψ
32: ω
33: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
34: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<𝐀
35: 𝐓0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻
36: ℂ𝐋𝐠𝐋𝐠𝐋𝐠𝐋𝐝𝐬𝕏𝐬
37: α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊
38: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

Spiegazione:

• Per 1, usiamo il token 'controlla per uguaglianza', sfruttando qui che quando Neim tenta di apparire su input vuoti, ottiene 0. Dato che 0 e 0 sono equivalenti, questo spinge 1 che è implicitamente stampato
• Da 2 a 9, usiamo solo valori letterali numerici.
• Da 10 a 32, Neim ha in realtà una costante di byte per tutti (sì, è pazzesco).
• Per 33, utilizziamo solo il comando increment. Sul primo byte, Neim tenta di far apparire qualcosa in modo da poterlo incrementare, ma poiché l'input è vuoto, il suo valore predefinito è il pop-up 0.
• Per 34, utilizziamo lo stesso approccio, ma in decremento e assumendo il valore assoluto.
• Per 35, stiamo sfruttando il fatto che zero fattoriale è uno e lo usiamo duplicando quello e aggiungendo ripetutamente
• Per 36, usiamo ℂper controllare 0 e 0 per la co-primalità, che sono. Questo spinge 1. Quindi otteniamo il primo primo utilizzo 𝐋, che risulta in un elenco singleton contenente solo 2. Quindi otteniamo il massimo elemento ( 𝐠), che spinge 2 come numero. Quindi ripetiamo questo processo fino a quando non otteniamo l'elenco [2 3 5 7 11]. Successivamente, utilizziamo 𝐝per calcolare i delta, risultando nell'elenco [1 2 2 4]. Quindi, usiamo 𝐬per ottenere la somma - che è 9 - quindi calcoliamo l'intervallo esclusivo da 0 a 9, risultando in [0 1 2 3 4 5 6 7 8]. Infine, 𝐬viene usato di nuovo per ottenere 37.
• Per 37, αè una costante che rappresenta un valore negativo e la spingiamo e sottraggiamo ripetutamente (sfruttando nuovamente il fatto che quando proviamo a spuntare su un input vuoto, viene premuto 0)
• Per 38, usando nuovamente lo 0 predefinito per input vuoto, continuiamo ad aggiungere 0 a se stesso, creando un lungo elenco, quindi calcolando la lunghezza.

Può essere provato qui

Python 2, 15

Ecco un inizio, alla ricerca di più

Grazie a Leo, la cui mancia mi ha aiutato ad arrivare a 15

[[[]]>[]][[]>[]]>>[[]>[]][[]>[]]

---

2

---

import math
print'%i'%math.pi

---

((()<())<())<<((()<())<())<<((()<())<())

---

5

---

6

---

7

---

8

---

9

---

11^1 

---

33/3

---

4--4--4

---

__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__

---

q=""=="";qq=q=="";qqq=~q*~q*~q;~qqq*~q*~qq

---

0xF

Japt , 448 byte, punteggio 42

Una grande collaborazione tra Shaggy , ETHproductions e Oliver .

v
y
Íà
Qiiii)iiii)âQ
ÂHq
LÁL
´Vn´VnVnVn
8
9
A
B
C
D
E
F
G
J-----J---J---J---J
[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x
;Iìw
~~½e½e½e½e~½e½
++T+++T+++T+++T+++T+++T
22
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
4á
5²
°UU°°°U°°U°°U°°U°°U
»³³
7/¼
$'_____________________________b'$bb
ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa
Sc
33
Mg011
##
6p
Rí í í í í è.
`¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥`l
¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o
º¤¤*º¤*º¤
(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å
Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

Questi caratteri (utili) rimangono:

!%&,:=>?@OPWX\dfhjkrstuz{}¡¢£¦§©ª«¬®¯¸ÀÃÆÇÈÐßãäåæçéêëîïñóôõö×øÿ

---

spiegazioni

Un paio di cose da sapere su Japt prima di iniziare, di cui ho fatto spesso uso. In primo luogo, Japt ha 6 variabili riservate per l'input, quelle sono le lettere maiuscole U-Z. Se nessun input viene passato attraverso quelle variabili, tutte sono predefinite 0. La seconda cosa è trattata in questo suggerimento .

Fai clic su uno snippet per provarlo nell'interprete online .

---

v

Se applicato a un numero, il vmetodo accetta un intero n come argomento e restituisce 1 se il numero è divisibile per n , 0 in caso contrario. Se n non viene fornito, il valore predefinito è 2 . 0 (il valore predefinito per U) è divisibile per 2 , quindi questo ci dà il nostro 1 .

---

y

Molto simile al primo. Se applicato a un numero, il ymetodo accetta un intero n come argomento e restituisce il GCD dei due numeri. Se n non viene fornito, il valore predefinito è 2 . Poiché 0 è divisibile per 2 , GCD (0, 2) ci dà il nostro 2 .

---

Íà

Íè la scorciatoia per n(2)o 2- this. Perché non abbiamo nessun input, abbiamo di default thisa 0, che si traduce in 2-0 = 2.

àrestituisce il numero di combinazioni di [1...this], che restituisce 3

---

Qiiii)iiii)âQ

Qil valore predefinito è un singolo segno di virgolette. isu una stringa inserisce un'altra stringa all'inizio; come spiegato nel n. 3 , ognuno iiii)equivale a .i("i".i("i"))in JS, inserendo quindi due copie iall'inizio della stringa. Fallo due volte e avrai la stringa iiii". âQquindi simula .search(Q), fornendo l'indice del primo "nella stringa, che è 4 .

---

ÂHq

Hè la costante per 32 . Quando viene applicato a un numero il qmetodo, che prende integer n come argomento, restituisce il n ^esima radice di quel numero. Se n non viene fornito, il valore predefinito è 2, quindi Hqci fornisce la radice quadrata di 32 che è circa 5,6568 . Âè la scorciatoia per ~~, che pavimenta il risultato, dandoci 5 .

---

LÁL

Lè preimpostato su 100 ed Áè la scorciatoia per >>>(spostamento a destra bit per riempimento zero). 100>>>100è lo stesso di 100>>>4(l'operando di destra avvolge mod 32), che è 6 .

---

´Vn´VnVnVn

Come notato prima, il Vvalore predefinito è 0 . ´è il collegamento per l' --operatore, quindi il codice è equivalente al seguente JS:

(--V).n((--V).n(V.n(V.n())))

X.n(Y)è equivalente a Y - X o -X + Y ; il primo --Vrestituisce -1 e il secondo -2 , quindi questo equivale a circa - (- 1) + (- (- 2) + (- (- 2) + - (- 2))) . Semplificando, otteniamo 1 + 2 + 2 + 2 = 7 .

---

8
9

Letteralmente, 8 e 9 .

---

A
B
C
D
E
F
G

Queste sono le costanti per 10 - 16 , compreso.

---

J-----J---J---J---J

Jè preimpostato su -1 . L'interprete Japt riesce in qualche modo a analizzarlo correttamente, come (J--) - (--J) - (--J) - (--J) - (--J). Facendo un po 'più di matematica, scopriamo che questo equivale a (-1) - (-3) - (-4) - (-5) - (-6) o -1 + 3 + 4 + 5 + 6 = 17 .

---

[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x

¾è, come puoi immaginare, una scorciatoia per .75. Mettiamo 24 copie di 0,75 in un array, quindi sommiamo con x, dando 0,75 * 24 = 18 .

---

;Iìw

Penso che questo sia il mio preferito. ;all'inizio del programma cambia i valori di alcune delle costanti di Japt; senza Iè 64 , ma con esso Iè 91 . ìwlo converte in un elenco di cifre ed esegue wl'elenco, invertendo l'array, quindi converte nuovamente in un numero per ottenere 19 .

---

~~½e½e½e½e~½e½

½è una scorciatoia per .5. esu un numero x accetta un argomento y e restituisce x * 10 ^y . Quindi la catena di calcoli che succede è:

           ½e½     1.5811  (.5 * sqrt(10))
          ~       -2
        ½e         0.005  (.5 * (10 ** -2))
      ½e           0.5058
    ½e             1.6024
  ½e              20.0138

E il finale ~~serve a reprimerlo su un numero intero, ottenendo il nostro risultato di 20 .

---

++T+++T+++T+++T+++T+++T

Tè preimpostato su 0 . ++è l'operatore di incremento in JS e anche in Japt; T+++Tviene analizzato come (T++) + T, ma ++T+++Tviene analizzato come (++T) + (++T), quindi equivale al codice JS

(++T) + (++T) + (++T) + (++T) + (++T) + (++T)

Il risultato è 1 + 2 + 3 + 4 + 5 + 6 , che si somma a 21 .

---

22

Un letterale 22 .

---

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ

Äè una scorciatoia per +1, quindi questa somma semplicemente 23 1 s.

---

4á

Questo trova il numero di permutazioni di [1, 2, 3, 4], che è 4! = 24 .

---

5²

²è una scorciatoia per p2, che aumenta un numero alla potenza di due. 5 ** 2 è 25 .

---

°UU°°°U°°U°°U°°U°°U

°è un collegamento per ++l'operatore, o se non può essere analizzato come tale, + +. Come notato prima, quando non è presente alcun input, il Uvalore predefinito è 0 . Quindi il codice è equivalente a (++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U), che è molto simile a # 17 : Uviene prima incrementato 1, quindi ripetutamente incrementato e aggiunto in modo tale che il risultato finale sia 1 + 3 + 4 + 5 + 6 + 7 = 26 .

---

»³³

³è la scorciatoia per il pmetodo con un argomento di 3 . Tuttavia, se una lettera minuscola appare direttamente dopo una parentesi sinistra ( »è la scorciatoia per ((), diventa una stringa. Ciò consente di passare a un metodo e di chiamarlo come una funzione (ovvero m³sarebbe mappato da .p(3)). In questo caso, tuttavia, ("p",3)restituisce il nostro 3, quindi lo eleviamo al potere di 3( pè il metodo del potere quando applicato a un numero), che ci dà il nostro 27 .

---

7/¼

¼, come probabilmente saprai ormai, è una scorciatoia per .25, quindi questo calcola 7 / 0,25 = 28 .

---

$'_____________________________b'$bb

Tutto ciò che è racchiuso in $simboli è trattato come puro JavaScript, quindi abbiamo una stringa di 29 caratteri di sottolineatura seguita da un b. (Senza $, 'sarebbe una stringa a carattere singolo.) Il bmetodo applicato a una stringa restituisce il primo indice del suo argomento all'interno di quella stringa. Come spiegato in # 3 , l'ultimo bviene convertito in una stringa, quindi stiamo afferrando il primo indice di bnella nostra stringa, che è 29 .

---

ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ

µè una scorciatoia per -=e Éper -1. L'effetto sottrae 30 copie di -1 da 0 , il che dà 30 .

---

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

Molto simile al n. 29. Il ametodo, quando applicato a una stringa, restituisce l'ultimo indice del suo argomento in quella stringa. Utilizzando 0-indexing, l'ultimo indice di ain una stringa di 32 as è 31 .

---

Sc

Sè predefinito in un singolo spazio e csu una stringa a carattere singolo restituisce il suo codice char, dando 32 .

---

33

Letterale 33 .

---

Mg011

MgNrestituisce l'ennesimo numero di Fibonacci. 011è 9 in ottale; il nono numero di Fibonacci è 34 .

---

##

#restituisce il codice carattere del carattere successivo. Il codice char di per #sé è 35 , il che rende il nostro lavoro particolarmente facile.

---

6p

pè esponenziale, e senza un secondo argomento il valore predefinito è 2 ; quindi, questo stampa 6 ** 2 = 36 .

---

Rí í í í í è.

Questo è piuttosto complicato. Ril valore predefinito è un singolo carattere di nuova riga (che è una nuova riga diventa importante in seguito). ísu una stringa, senza alcun argomento, accetta ogni carattere e aggiunge il suo indice: una trasformazione piuttosto inutile, ma il risultato attraverso 5 iterazioni è questo: (usando Rinvece di una nuova riga letterale)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

Interessante come ogni voce sia semplicemente un prefisso della prossima ... Ma comunque, l'ultima parte è., conta quante corrispondenze /./gsono state trovate nel risultato. Ci sono 38 caratteri nella stringa; tuttavia, poiché /./gcorrisponde solo a caratteri non newline, il risultato è 37 .

---

¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥l

I backtick contrassegnano una stringa compressa e si ¥decomprimono in ll. lsu una stringa dà length, quindi dopo la decompressione, questo dà 38 .

---

¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o

Oooh ragazzo, questo è un doozy. Innanzitutto, generiamo truecon ¨N( ¨sta per >=, e Nsenza input è l'array vuoto), quindi convertiamo quello 1con |N. Da lì in poi diventa piuttosto pazzo:

ò    Inclusive range [0..1],            [0, 1]
 ò   making each an inclusive range.    [[0], [0, 1]]
m·   Join each on newlines.             ["0", "0\n1"]
·    Join on newlines.                  "0\n0\n1"
·    Split on newlines.                 ["0", "0", "1"]
m    Map each item X and index Y to     
 |     X | Y.                           ["0" | 0, "0" | 1, "1" | 2] -> [0, 1, 3]
m    Map each by 
 ò     inclusive range.                 [[0], [0, 1], [0, 1, 2, 3]]
m··· Same as before.                    ["0", "0", "1", "0", "1", "2", "3"]
m|   Bitwise OR thing again.            [0, 1, 3, 3, 5, 7, 7]
mò   Map each by inclusive range.       [[0], [0, 1], ..., [0, 1, 2, 3, 4, 5, 6, 7]]
m··· Same as before.                    ["0", "0", ..., "5", "6", "7"]
m|   Bitwise OR again.                  ["0"|0, "0"|1, ..., "5"|30, "6"|31, "7"|32]
                                        -> [0, 1, ..., 31, 31, 39]

(Gli ¹s sono solo sostituti di parentesi strette e sono stati omessi.) Il finale oquindi si apre e restituisce l'elemento finale nella matrice, dando 39 .

---

º¤¤*º¤

Principalmente lo stesso trucco di # 3 . ¤è la scorciatoia per il smetodo con un argomento di 2 . In questo caso, tuttavia, il codice è transpiled (("s", 2).s(2) * (("s", 2) * (("s", 2)))), o semplificata (2).s(2) * (2 * 2). .s(2)restituisce il numero come una stringa di base 2, che fornisce "10"; * (2 * 2)converte implicitamente questo in un numero e si moltiplica per 4 , dando 40 .

---

(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å

Simile al precedente. Åè la scorciatoia per il smetodo con un argomento di 1 . In questo caso, tuttavia, ogni (Åtranspile a ("s", 1), che restituisce solo 1 . 1<<1<<1<<1<<1<<1è 32 ed 1<<1<<1<<1è 8 ; questi sono XORed insieme 1per ottenere 41 .

---

Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

±è una scorciatoia per +=e ¶per ===. Ciò significa che il codice è effettivamente

Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y

Y===Y è sempre vero, quindi possiamo semplificarlo un po ':

Y+=1,Y+=Y,Y+=Y+=1,Y+=Y,Y+=Y+=1,Y+=Y

0 + 1 = 1 ; 1 + 1 = 2 ; 2 + (2 + 1) = 5 ; 5 + 5 = 10 ; 10 + (10 + 1) = 21 ; 21 + 21 = 42 .

PHP, punteggio 17, 130 byte

personaggi usati ADEFGIKLMOPRSTVXYZ=_![]()<>'"#$,;/-+*|^&0123456789afhnprstwx

Z==Z
FTP_MOREDATA
';'&w
![]<<![]<<![]
5
6
"#"|"$"|"1"
8
SIGKILL
333333>>3>>3>>3>>3>>3
99/9
22-2-2-2-2-2
strspn(XXXXXXXXXXXXXX,X)
7+7
0xf
4*4
ha^YV

1 costante booleana Z (non impostata) uguale costante Z

2 FTP_MOREDATA è una costante in PHP con il valore 2

3 bit per bit e caratteri; e W

4 bit a scorrimento Maiusc a sinistra e logico non cast array vuoto su booleano true con cast su intero 1 tramite l'operatore shift a sinistra

7 bit per bit oppure # e $ e 1

9 SIGKILL è una costante in PHP con il valore 9

10 bit a bit Maiusc a destra ogni passaggio è una divisione intera con 8, quindi abbiamo i passaggi 333333, 41666, 5208, 651, 81, 10

13 conta il carattere X nella stringa X ... dall'inizio

15 valore esadecimale f = 15

17 Xor bit a bit con le stringhe ha e YV

Tutti i frammenti sono elementi in un array

Provalo online!

PHP, punteggio 16, 94 byte

personaggi usati AEIMPRTUZeflnrstvwx^_&|()[]=!.*+/-<>$":0123456789

Z==Z
":"&"w"    
M_PI|[]
TRUE<<TRUE<<TRUE
5
6
A^v    
8
9
!$s.strlen($s)    
77/7
3+3+3+3
111>>1>>1>>1    
22-2-2-2-2
0xf
4*4

1 costante booleana Z (non impostata) uguale costante Z

2 bit per bit e caratteri: ew

3 Pi espressi in valore intero tramite array vuoto convertito in zero

7 caratteri x bit a bit A e v

10 variabili $ s non impostate! $ S = un concat con lunghezza stringa della variabile $ s

13111/2 = 55/2 = 27/2 = 13 Divisione intera bit a bit

15 valore esadecimale f = 15

Tutti i frammenti sono elementi in un array

Provalo online!

PHP, punteggio 14, 84 byte

personaggi usati $!_^[]()%/+~-=AEILMNPRUZ0123456789delnrstx

Z==Z
2
M_PI^[]
4
5
6
ERA%11
8
9
!$s.strlen($s)
77/7
3+3+3+3
0xd    
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-NULL

1 costante booleana Z (non impostata) uguale costante Z

3 Pi espressi in valore intero tramite array vuoto convertito in zero

7 ERA è una costante con il valore 131116 mod 11 = 7

10 variabili $ s non impostate! $ S = un concat con lunghezza stringa della variabile $ s è zero

13 valore esadecimale d = 13 14 bit a bit no e segno meno aumentano NULL a 14

Tutti i frammenti sono elementi in un array

Provalo online!

R, punteggio 13 14

F^F                       # F==0 in R
q=""=="";q--q             # ""=="" is TRUE, TRUE == 1 (Thanks WheatWizard)
3
4
5
6
7
8
9
1e1                       # scientific notation for 10
22/2
T+T+T+T+T+T+T+T+T+T+T+T   # T == 1
0xD                       
sum(mtcars$vs)            # mtcars is a built-in dataset, summing the $vs column gives 14

Ne ho preso uno in più grazie all'utente2390246.

Personaggi usati:

0123456789acemqrstuvxDFT^=";-/+()$

MATL , punteggio 21 22 23 numeri (273 byte)

Grazie a J Doe per l'estensione da 22 a 23 numeri!

0~
'bd'd
{P}gk
HH^
5
6
7
8
9
3 3.333333333333333*
11
IEE
[B]Yq
llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx
KUKUa-
4W
FFFFFFFFFFFFFFFFFn
TTTTTTTTTTTTTTTTTTs
rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz
OOOOOOOOOOOOOOOOOOOOvZyX>
JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/
22
`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Provalo online! Ogni frammento nel collegamento termina conD(visualizza) o]D(chiude in modo esplicito e visualizza) per cancellare lo stack e quindi isolare dallo snippet successivo.

Spiegazione

0~

Push 0. Negare. Dà true, che viene visualizzato come 1.

'bd'd

Spingere la stringa 'bd'. Differenza consecutiva tra i punti di codice dei personaggi.

{P}gk

Matrice di celle push contenente numero pi. Converti in array numerico (cioè in un singolo numero). Arrotondare.

HH^

Spingere 2due volte. Energia.

5

Letterale numerico.

6

Letterale numerico.

7

Letterale numerico.

8

Letterale numerico.

9

Letterale numerico.

3 3.333333333333333*

Push 3. Push 3.333333333333333. Moltiplicare. Ciò è dovuto alla precisione in virgola mobile 10.

11

Letterale numerico.

IEE

Push 3. Moltiplicare per 2due volte.

[B]Yq

Push [6](che è uguale a 6). Calcola n -esimo primo.

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

Premi 114 volte. Numero di elementi in pila. Cancella il resto della pila.

KUKUa-

Push 4. Piazza. Fai lo stesso. Qualsiasi: dà 1. Sottrarre.

4W

Push 4. 2sollevato a quello.

FFFFFFFFFFFFFFFFFn

Push array [false false ... false](17 volte). Numero di elementi nella matrice.

TTTTTTTTTTTTTTTTTTs

Push array [true true ... true](18 volte). Somma di matrice.

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

Spingere 19 numeri casuali presi dall'intervallo (0,1). Concatenare orizzontalmente 18 volte. Numero di elementi diversi da zero nella matrice.

OOOOOOOOOOOOOOOOOOOOvZyX>

Premi 020 volte. Concatena i contenuti dello stack in verticale (fornisce un vettore colonna). Dimensione: fornisce l'array [20 1]. Massimo di array.

JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/

Premi 1j(unità immaginaria) 21 volte. Aggiungi 20 volte. Dividi per 1j.

22

Letterale numerico

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Do ... while loop ( `) con fine implicita. Nella prima iterazione spinge l'indice di iterazione ( @) e lo incrementa ( Q) 22 volte, il che produce 23. La condizione del loop ( @@<) è falsa, quindi il loop viene chiuso.

Alcune idee per un ulteriore miglioramento

• (spazio) nello snippet 10 potrebbe essere sostituito da |
• X>nello snippet 20 potrebbe essere sostituito da p, liberando così il prefisso X.
• Attualmente non utilizzato e potenzialmente utile: :,A

Vim 8 su Windows, punteggio 13, 104 byte

1
2
3
4
5
6
7
^R=&ts^@
9
8^O^A^O^A
0^[^X^X^X^X^X^X^X^X^X^X^X0x
:h<CR>wwwwwwwwwwwy$:q<CR>p
grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD

^{keystroke}rappresenta <C-{keystroke}>, così ^Xè <C-x>, tranne per il ^@quale è <C-j>. Sto ancora cercando di aggiungere più numeri a questo elenco e <CR>rappresenta un avanzamento riga.

Nota: per eseguire questi comandi, avviare vim utilizzando -u NONE -U NONE. Questo per garantire che le tue configurazioni non interferiscano con il codice.

Gli snippet da 1 a 10 iniziano in modalità inserimento. Mentre gli snippet 12 e 13 iniziano in modalità normale.

spiegazioni

Lo snippet 8 è :^R=&ts^@. Devo ringraziare @ L3viathan per venire con questo e @ nmjcman101 per aver suggerito ^@come un sostituto per l'avanzamento riga e @ ØrjanJohansen per accorciare &tabstopa &ts. &tsquindi valuta la dimensione della scheda, che per impostazione predefinita è 8, e questo valore viene inserito nell'editor.

Lo snippet 10 è 8^O^A^O^A. Inseriamo un 8, quindi lo incrementiamo due volte per ottenere 10.

Lo snippet 11 è 0^[^X^X^X^X^X^X^X^X^X^X^X0x. Annotiamo uno 0 e lo diminuiamo di 11 volte per ottenere -11. Quindi rimuoviamo il meno per ottenere 11.

Lo snippet 12 è :h<CR>wwwwwwwwwwwy$:q<CR>p. Questo apre il menu di aiuto di Vim 8, che contiene le seguenti informazioni:

*help.txt*  For Vim version 8.0.  Last change: 2016 Sep 12

E la sequenza di ws si sposta sul 12, a quel punto y$copia il numero. Quindi viene incollato nell'editor usando p.

Lo snippet 13 è grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDgrazie a @DJMcMayhem per averlo inventato. Funziona solo su Windows. Lo snippet cerca nel menu di aiuto i comandi che iniziano con g. Quindi si sposta in basso usando jper arrivare a questa linea:

|g?|        g?      2  Rot13 encoding operator

dopodiché lo copia e lo incolla nel buffer. Dopodiché, tutto tranne il 13 viene rimosso dal buffer.

Mathematica, punteggio 13

x~D~x
⌊E⌋
3
⌈Pi⌉
5
6
LucasL@4
8
9
0!+0!+0!+0!+0!+0!+0!+0!+0!+0!
77/7
Tr[{11,1}]
-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I

05AB1E , punteggio 18, 67 byte

X     Variable is initialized to 1
Y     Variable is initialized to 2
2>     2 + 1
4
5
6
7
8
9
T     Constant 10
3b     3 in binary
•C     Ascii code of 'C'
11Ì     11 in hex
A'ok     Index of 'o' in the alphabet
žz¨¤x+     Middle character of '256' times 2, plus itself
¾<<<<n     Variable initialized to 0, 4 times -1, squared
‘c‘‘c‘QDJH     'c' equals itself (true = 1), duplicated, converted from hex to dec
тD÷·±D*·     Constant 100, divided by itself, * 2, bitwise not, times itself, * 2
"d"aÐÐÐÐÐÐÐÐÐ)O     "d" is_alpha (true = 1), triplicated 9 times, total sum

Provalo online!

Ping pong , punteggio 127

In PingPong, ogni personaggio ha il suo distinto valore numerico, rendendo il conteggio fino a 127 un compito banale. La lingua funziona leggendo il valore di ogni personaggio e spingendolo in cima a una pila, dove vengono eseguite tutte le operazioni. In teoria PingPong può superare 127, ma richiederebbe il passaggio di un blocco di caratteri che appaiono semplicemente come spazi in un editor di testo, quindi li ho lasciati fuori dalla mia soluzione.

1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: A
11: B
12: C
13: D
14: E
15: F
16: G
17: H
18: I
19: J
20: K
21: L
22: M
23: N
24: O
25: P
26: Q
27: R
28: S
29: T
30: U
31: V
32: W
33: X
34: Y
35: Z
36: a
37: b
38: c
39: d
40: e
41: f
42: g
43: h
44: i
45: j
46: k
47: l
48: m
49: n
50: o
51: p
52: q
53: r
54: s
55: t
56: u
57: v
58: w
59: x
60: y
61: z
62: ©
63: ®
64: À
65: Á
66: Â
67: Ã
68: Ä
69: Å
70: Æ
71: Ç
72: È
73: É
74: Ê
75: Ë
76: Ì
77: Í
78: Î
79: Ï
80: Ð
81: Ñ
82: Ò
83: Ó
84: Ô
85: Õ
86: Ö
87: ×
88: Ø
89: Ù
90: Ú
91: Û
92: Ü
93: Ý
94: Þ
95: ß
96: à
97: á
98: â
99: ã
100: ä
101: å
102: æ
103: ç
104: è
105: é
106: ê
107: ë
108: ì
109: í
110: î
111: ï
112: ð
113: ñ
114: ò
115: ó
116: ô
117: õ
118: ö
119: ÷
120: ø
121: ù
122: ú
123: û
124: ü
125: ý
126: þ
127: ÿ

Ottava, punteggio 14, 74 byte

Abbastanza sicuro di essere vicino al limite ora.

1:  ~0                        % Not 0 == 1
2:  "H"/"$"                   % "H" = 72, "$" = 36. H/$ = 2
3:  3                         % Literal
4:  4                         % Literal
5:  5                         % Literal
6:  6                         % Literal
7:  7                         % Literal
8:  8                         % Literal
9:  9                         % Literal
10: ceil(pi*pi)               % pi*pi = 9.87. ceil(9.87) = 10
11: 11                        % Literal
12: 2+2+2+2+2+2               % Well, not much to say
13: ['','RT'-'!']             % 'RT' = [82,84]. Subtract '!' (33) to get ['',49,51]=13
14: nnz...                    % Number of non-zero elements in the string...
    nnnnnnnnnnnnnn            % on this line. (This is an awesome trick by the way!)

Dovuto rimuovere strchrdato che già cin numero 10. Ho ancora j, ^, =, !, spazio e tabulazione orizzontale (ASCII-9) sinistro, quindi potrebbe essere possibile comprimere uno più.

La scheda orizzontale può essere utilizzata come spazio, quindi il trucco usato con strchre nnzpuò essere usato ancora una volta. Le uniche lettere minuscole rimaste sono abdfgjkmoquvwxy. Non ci sono molte funzioni che possono essere create da queste. modpotrebbe funzionare, ma non può richiedere l'input di stringhe.

È facile usare i personaggi rimanenti per ottenere 1, ma non so come posso ottenere qualcos'altro.

Prova tutto .

Forse utile: fun aè lo stesso di fun('a'), fun a bè lo stesso di fun('a','b')e così via. Questo può essere utilizzato in diversi luoghi:

gt t g    % Equivalent to 't'>'g'. Returns 1. Uses space (available)
or o r    % Equivalent to 'o' | 'r'. Returns 1. 

L'uso di questo renderà 0disponibile, ma non riesco ancora a vedere come renderlo utile.

e (2.71828...)e jsono ancora inutilizzati. Deve rimuovere ceilper usare eperò.

Alternative (ispirazione):

1:  ~0             % Not 0 = 1
2:  2              % Numeral
3:  3              % Numeral
4:  fix(i^i^i^i)   % Numeral
5:  5              % Numeral
6:  6              % Numeral
7:  7              % Numeral
8:  8              % Numeral
9:  9              % Numeral 
10: 1+1+1+1+1+1+1+1+1+1   % Well, not much to explain
11: ['','RR'-'!']  % RR are [82,82] in ASCII, subtract 33 (!) to get
                   % [49,49], and concatenate with the empty string to convert [49,49] to 11 
12: nnz nnnnnnnnnnnn   % Number of non-zero elements in the string containing 12 n
13: "4"/4          % "4" = 52. Divide it by 4 to get 13.

JavaScript (ES7), 16 numeri interi, 137 130 128 byte

Ho preso la risposta di @ETHproductions e ho corso per un po '; è cambiato così tanto che lo sto postando separatamente. Le idee sono benvenute :)

""**""
-~-~{}
3
C=CSS==CSS;C<<C<<C
5
6
7
8
9
++[[]][+[]]+[+[]]
11
4444444444444444444%44
222>>2>>2
`..............i`.indexOf`i`
0XF
atob('MTY')

Rimanente:
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

Oppure, se lo snippet per 1 viene sostituito con !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

---

JavaScript (ES7), 16 numeri interi, 127 byte

Un byte più breve. : P

""**""
-~-~{}
3
4
5
6
7
C=CSS==CSS;C<<C<<C<<C
9
++[[]][+[]]+[+[]]
11
`............i`.indexOf`i`
222>>2>>2
0XE
atob('MTU')
88888888888888888%88

Rimanente: $_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz

Dyalog APL, punteggio 15, 89 byte

≡''
≢###
3
4
⍴⍬⍬⍬⍬⍬
6
⌈○2
8
9
1E1
⎕D⍳⊂⎕D











l:l
7--7-×7
(~0 0 0 0 0 0 0 0 0 0 0 0 0 0)⊥~0
5+5+5

_{Le newline prima l:lfanno parte del 12.}

_{Gli spazi in 14 rappresentano le schede.}

> <> , punteggio 20, 93 90 74 65 byte

(3 byte salvati da Teal Pelican, molti byte salvati da Jo King!)

iii((
2
3
ll{lll{[
5
6
7
8
!   00=0g
a
b
c
d
e
f
44*
'RA'%
999-9--
"&F#",,
1::+:++:+:+

Provali al parco giochi per pesci! Puoi fare in modo che i frammenti stampino i loro risultati aggiungendoli n;alla fine di ciascuno. Tieni presente che il nono frammento contiene una scheda che viene utilizzata dallo scambio di stack.

Spiegazione:

• In iii((, ognuno icerca di ottenere input, ma poiché non ce ne sono, spingono -1invece EOF = . Quindi (è l'istruzione minore di, e poiché -1non è inferiore a -1, spinge una falsità 0; ma il secondo( chiede se -1è inferiore a 0, che è, quindi spinge una verità 1.
• 2e 3sono ovvi.
• Perché ll{lll{[, il primo lspinge la lunghezza dello stack, che è 0, quindi il secondo spinge la nuova lunghezza, portando lo stack a 0, 1. I {ruota la pila a sinistra, scambiando la 1e 0. Altre tre ls portano lo stack a 1, 0, 2, 3, 4. Quindi {ruota 1in avanti e[ preleva la prima 1cosa dalla pila, che è 4.
• 5, 6, 7E 8sono evidenti anche.
• In !\t00=0g(dove \trappresenta una scheda), !salta la scheda, quindi 00=spinge due zeri e verifica se sono uguali: lo sono, quindi otteniamo un dato di verità 1. Dopo averne premuto un altro 0, il gpersonaggio viene posizionato in posizione 1,0del codice, che è la scheda con il codice carattere 9.
• aattraverso fogni spinta 10a 15rispettivamente (presumibilmente per rendere bella esadecimale).
• 44*spinge due se le 4moltiplica insieme, per 16.
• 'RA'inserisce i codici carattere di Re A(82 e 65 rispettivamente) nello stack, quindi %calcola 82 mod 65 = 17.
• 999-9--valuta 9 - ((9 - 9) - 9) = 18.
• "&F#"spinge i codici di carattere di &, Fe #che sono 38, 70e 35rispettivamente. Quindi ,è divisione, quindi otteniamo 38 / (70 / 35) = 19.
• Infine, 1::preme a 1e lo duplica due volte, +aggiunge due di quelli insieme per ottenere 2; :+duplica 2e lo aggiunge a se stesso per ottenere 4; +aggiunge il rimanente 1per ottenere 5; quindi :+:+duplica e aggiunge due volte, risultando in 20.

Questo è il punteggio massimo possibile con> <>. Qualsiasi frammento deve includere un'istruzione qualche parte che trasforma uno stack vuoto in una pila non vuota, e ci sono solo 18> <> istruzioni che possono farlo (cioè i, le le cifre 0–9e a–f), più modalità stringa. (Ogni altra istruzione o non fa nulla per uno stack vuoto ><v^/\|_#x!{}r, o cerca di far apparire qualcosa ed errori ?.+-*,%=():~$@[]on&gp). L'accesso alla modalità stringa utilizza uno "o ', quindi ci sono al massimo 18 + 2 = 20snippet possibili.

---

Se siete più confortevole con unprintables di me, questo è possibile in 53 byte, grazie a Jo Re: 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z", dove la X, Ye Zvengono sostituiti da personaggi con i codici 17, 19e 20, rispettivamente.

MathGolf , 48 51 53 numeri interi, 324 byte

î
ª∞~
c±b±+
φⁿ_¥-
5
6
7
○¢i♀/
d²
♂
A
B
C
D
E
☻
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
♥
U
V
W
X
Y
Z
♫¼¼¼¼
88888]Σ
41
╔½½½½½½½½½½½
π░3§3
22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$
ÿ@@@@£9
))))))))))))))))))))))))))))))))))))))))))))))))))
►◄╠•╠
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h 
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

+2 punteggio (e -2 byte distinti utilizzati per 40) grazie a @maxb .

Ogni riga è un programma separato.

Byte usati (92 byte distinti): îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(

Spiegazione e collegamenti TIO:

MathGolf è un nuovo linguaggio del golf specializzato nelle sfide matematiche del golf. Ha un sacco di builtin a byte singolo per i numeri, rendendolo una sfida perfetta per questo.

1) î: invia il valore 1 indicizzato del loop, che è 1 per impostazione predefinita: provalo online.
2) ª∞~: premere [1]; raddoppiarlo ([2]); pop list e inseriscilo nello stack: provalo online.
3) c±b±+: premere -2; quindi pop e spingere il suo valore assoluto; spingere -1; quindi pop e spingere il suo valore assoluto; e aggiungili insieme Provalo online.
4) φⁿ_¥-: spingere il rapporto aureo (1.618033988749895); cubalo (4.23606797749979); duplicare la parte superiore della pila; prendere il modulo 2 (0.23606797749979); sottrarli l'uno dall'altro: provalo online.
5,6,7) I numeri stessi: provalo online.
8) ○¢i♀/: premere 2048; converti in una stringa esadecimale (800); cast in numero intero; spingere 100; dividere:Provalo online.
9) d²: premere -3; al quadrato: provalo online. 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34, 35,36,37,38) Push builtin per i numeri stessi ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): provalo online.
39) ♫¼¼¼¼: premere 10000; intero diviso per 4 quattro volte: provalo online.
40) 88888]Σ: premi 8 cinque volte; avvolgerli in un elenco; somma quell'elenco: provalo online.
41) Il numero stesso: provalo online.
42) ╔½½½½½½½½½½½: premere 86400; intero diviso per 2 undici volte: provalo online.
43) π░3§3: Push PI (3.141592653589793); cast alla corda; pop e premi il suo terzo carattere indicizzato 0 (4); spingere 3; produce l'intero stack unito implicitamente: provalo online.
44)22#22# : premere 2 due volte; prendere il potere dei due (4); fallo ancora; produce l'intero stack unito implicitamente: provalo online.
45) τ╥└: premere 2 * PI (6.283185307179586); fai scoppiare e spingi la potenza di 2 al di sotto di quella più vicina (4); spingere la parte superiore della pila + 1 senza saltar fuori (5); produce l'intero stack unito implicitamente: provalo online.
46) ♦⌡⌡⌡⌡⌡⌡⌡⌡⌡: Push 64; decrementa di 2 nove volte: provalo online.
47) !⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠: Push gamma (n + 1) (1 di default); incrementare di 2 ventitre volte: provalo online.
48)'0$: Invia il valore ordinale del carattere '0': provalo online.
49) ÿ@@@@£9: spingere la stringa "@@@@"; pop e spingere la sua lunghezza (4); spingere 9; produce l'intero stack unito implicitamente: provalo online.
50) )))))))))))))))))))))))))))))))))))))))))))))))))): Incrementa di 1 cinquanta volte: provalo online.
51) ►◄╠•╠: Push 1,000,000; Push 10.000.000; pop entrambi e interi-dividerli tra loro (10); spingere 512; pop entrambi e interi-dividerli tra loro: provalo online.
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : spingere la stringa "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; spingere la sua lunghezza (senza far scoppiare la corda); rimuovi tutto dallo stack tranne l'ultimo elemento: provalo online.
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: premere 128; decrementato di 1 settantacinque volte: provalo online.

Proverò ad aggiungerne altri in seguito. Mi restano ancora alcune cose utili, tra cui modulo %e moltiplicare *.

Java 8, 11 12 13, 39 byte

Java ha solo 10 simboli per i numeri (0-9) e tutte le chiamate ai metodi e le costanti richiedono un punto, quindi non sono sicuro di poter superare gli 11 output

Apparentemente i caratteri vengono espressi in numeri interi di default quando vengono applicate le operazioni

+1 con l'aiuto di @ OlivierGrégoire

i->-~i
2
3
4
5
6
7
8
9
'P'^'Z'
11
"::::::::::::"::length
0xD

spiegazioni:

i->-~i

numero intero lambda che non accetta input e restituisce 1. Quando un parametro non accetta input, viene utilizzato il valore predefinito secondo il precedente post precedente, che per gli interi è 0

2
3
4
5
6
7
8
9

numeri interi letterali

'P'^'Z'

XOR di due caratteri per restituire 10

11

intero letterale

":::::::::::"::length

espressione lambda che restituisce la lunghezza di una stringa di 12 caratteri

0xD

Esadecimale 13

Link TIO se si desidera verificare.

Gaia , punteggio 25, 203 byte

§‼
..⌉+⌉
₵P~~
4
5
6
∂Ql
8
9
¶c
11
'¡ċ⌋u⌋
--⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻
7:,Σ
Ø!))))))))))))))
øøw<øøw<«øøw<«øøw<«øøw<«
⟩‘
₸ḣ₸K$₸ḣ₸/S₸₸/=$
]]]]]]]]]]]]]]]]]]]n
⇑’e
0(((((((((((((((((((((_
22
“B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B
3₈×
ℍḥḥ

Considero questo un punteggio perfetto, poiché non è possibile utilizzare più nilad a causa delle limitazioni del personaggio.

spiegazioni

1. §‼

§è un personaggio spaziale, ‼è forzato a booleano, quindi il risultato è 1.

2. ..⌉+⌉

.è una scorciatoia per 0.5, quindi questo è ceil(0.5+ceil(0.5)).

3. ₵P~~

₵Pè pi, ~è negazione bit a bit. La doppia negazione bit a bit è semplicemente troncamento.

4. 4

5. 5

6. 6

7. ∂Ql

∂Qè un elenco contenente i nomi dei giorni della settimana, lè lunghezza.

8. 8

9. 9

10. ¶c

Codice punto cdi avanzamento riga ¶.

11. 11

12. '¡ċ⌋u⌋

'¡  The string "¡"
ċ   Turn it into a list of code points: [161]
⌋   Minimum: 161
u⌋  Floored square root: 12

13. --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-è una scorciatoia per -1, ⁻è sottrazione. Quindi questo è -1 - -1 - -1...abbastanza volte per fare 13.

14. 7:,Σ

Spingi 7, duplica :, abbina ,i due 7 in un elenco e somma Σ.

15. Ø!))))))))))))))

Øè una stringa vuota, quindi Ø!è 1. Incrementa )1 14 volte.

16. øøw<øøw<«øøw<«øøw<«øøw<«

øø    Push two empty lists
w     Wrap one of them
<     [] < [[]]? (it is, so push 1)
øøw<  Do the same thing again to push another 1
«     Bitshift 1 left by 1
      Do that same thing again 3 more times to get 16

17. ⟩‘

Chiudere una stringa con ‘diventa letterale un numero base-250. ⟩è al valore di byte 17 nella tabella codici di Gaia.

18. ₸ḣ₸K$₸ḣ₸/S₸₸/=$

₸     10
ḣ     doubled
₸     10
K     20 choose 10 (184756)
$     Digit list
₸ḣ₸/  20/10 (2)
S     Split the digit list at index 2 ([[1 8][4 7 5 6]])
₸₸/   10/10 (1)
=     Get the first element of that split ([1 8])
$     Join together and print 18

19. ]]]]]]]]]]]]]]]]]]]n

Ciascuno ]avvolge la pila in elenco. Fallo 19 volte e ottieni la profondità ndell'elenco.

20. ⇑’e

La chiusura di una stringa con la ’rende un elenco di punti di codice della tabella codici. escarica l'elenco nello stack. ⇑ha un punto di codice di 20 nella tabella codici.

21. 0(((((((((((((((((((((_

Diminuisci (0 21 volte, quindi annulla _.

22. 22

23. “B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B

Converti la stringa “B”da base-24, dove sono le cifre da 0 a 23 ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B. Il risultato è 23.

24. 3₈×

3 × 8.

25. ℍḥḥ

100 ℍdimezzato ḥe dimezzato di nuovo.

C, punteggio 13

Queste sono solo un gruppo di costanti intere.

0==0
__LINE__
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
'o'/'.' 
2*2*2*2-2-2
strlen("strlenstrlens")

1. 0==0valuta 1
2. Presuppone che il codice sia sulla riga 2. __LINE__= 2
3. Costante intera
4. Costante intera
5. Costante intera
6. Costante intera
7. Costante intera
8. Costante intera
9. Costante intera
10. 1+1+1...= 1*10= 10
11. 'o'è 111, '.'rappresenta l'ASCII 0x10 non stampabile. 111/10 = 11
12. (2<<2)= 8, 8*2= 16, 16-2-2= 12
13. lunghezza della stringa di "strlenstrlens"= 13

Ohm , punteggio 21 22, 160 byte totali

╓S@Ri
ΓΓ-Γ-Γ-
αê⌠
¡¡¡¡¼
5
▀lll▀l
ÑÑÑÑÑÑÑÿWÿk
ü`½½
9
..≥°
$$J
3dd
7ƒ
2≡≡≡Σ
║F
4º
0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~
6DD++
8π
τ╛hτ*
"≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A
1111 11v11%L1111 11v11%L

Provalo online!

spiegazioni

1. ╓S@Ri

Premere i secondi della data / ora correnti ( ╓S). Ottieni l'intervallo compreso tra 1 e secondi ( @), inverti ( R), ottieni l'ultimo elemento ( i), che è sempre 1.

2. ΓΓ-Γ-Γ-

Γ è -1, quindi questo è (-1) - (-1) - (-1) - (-1), che è 2.

3. αê⌠

αêè il numero di Eulero (2.71828 ...), ⌠è il soffitto. 3 è il risultato.

4. ¡¡¡¡¼

¡incrementa il contatore, ¼spinge il contatore.

5. 5

Solo un letterale.

6. ▀lll▀l

▀lll▀è un valore letterale di stringa compressa equivalente a "of >ic". lprende la lunghezza, quindi il risultato è 6.

7. ÑÑÑÑÑÑÑÿWÿk

Innanzitutto inseriamo 7 caratteri newline ( Ñ) e poi una stringa vuota ( ÿ). Lo stack viene racchiuso in un array ( W), quindi viene trovato l'indice della stringa vuota in tale array.

8. ü`½½

üè un personaggio spaziale. `spinge il suo valore ASCII (32), quindi viene dimezzato due volte ( ½½).

9. 9

Solo un letterale.

10. ..≥°

..è un .personaggio letterale . Viene incrementato ( ≥), che analizza la stringa come un numero, il valore predefinito è 0 poiché non è un numero valido e lo incrementa a 1. Quindi calcoliamo 10 ¹ ( °).

11. $$J

$ spinge il valore corrente del registro, inizialmente 1. Quindi, premere 1 due volte, unire la pila e stampare.

12. 3dd

Premere 3 e raddoppiarlo due volte.

13. 7ƒ

Spinge il 7 ° numero di Fibonacci.

14. 2≡≡≡Σ

Spingere 2, triplicarlo tre volte, lasciando 7 2 in pila. Quindi prendi la somma dello stack ( Σ).

15. ║F

║è il delimitatore per i letterali di numeri base-220. Poiché questo è alla fine di una riga, non è necessario terminarlo.

16. 4º

Calcola 2 ⁴ .

17. 0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~

òè negato bit per bit, ~negato aritmetico. Combinando questi operatori, possiamo incrementare 0 17 volte.

18. 6DD++

Premi 6, duplicalo due volte e calcola 6 + 6 + 6.

19. 8π

Premere l'ottavo numero primo.

20. τ╛hτ*

Premi 10 ( τ), ottieni il primo elemento ( h) dei suoi fattori primi ( ╛), moltiplicalo per 10.

21. "≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A

Analogamente ai frammenti precedenti, la stringa "≤"viene analizzata come 0. La diminuiamo di 21 volte, quindi prendiamo il valore assoluto.

22. 1111 11v11%L1111 11v11%L

Qui calcoliamo 1111 div 11 mod 11, che è 2, quindi stampiamo 2. Quindi eseguiamo di nuovo.

PowerShell, punteggio 12, 91 byte. 14, 176 byte

[byte]!![byte]                    # type gets cast to bool false, inverted, to int = 1
-   -$?-shl$?                   # -bool true is -1, shift left, negative. (Tab not space)
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
22/2                                           # use the 2
'uuuuuuuuuuuu'.LENGTH                          # string length
0xd
@{z=@{};Y=@{};YY=@{};w=@{};v=@{};U=@{};zz=@{};S=@{};r=@{};q=@{};p=@{};J=@{};K=@{};m=@{}}|% COU*             # count items in hashtable (space)

Modificare:

• Grazie a Ørjan Johansen per aver suggerito il valore letterale esadecimale 0xd per 13 e il riordino di 5 per liberare 1 + 1 + 1 + 1 .. come opzione.
• Modificato la lunghezza dell'array in lunghezza della stringa, da [int] a [byte] e la tabella hash per usare gli hashtable come valori, liberando (),""Pondering 15 con qualcosa di simile "ZZZZZZZZZZZZZZZA".InDeXof("A")ma non è possibile riutilizzare il punto o la 'e' ..

PowerShell non può fare variabili senza $, non può fare esponenziazione, spostamento di bit, Pi, ceil (), ecc. Con simboli di base, e per lo più digita coerciano da / a bool e a / da numeri come stringhe, quindi c'è relativamente poco spazio per la generazione di numeri a bassa sintassi.

TI-Basic (serie 83), punteggio 21 22 23 24 25 (1003 byte)

1:  A=A
2:  int(tan(tan(cos(cos(cos(B
3:  tanh⁻¹(√(√(√(√(√(√(√(√(√(√(C!°√(√(C!°
        √(√(√(√(√(√(C!°√(√(√(√(√(√(C!°√(
        C!°√(√(√(C!°√(C!°√(C!°√(√(√(√(√(
        √(C!°√(C!°√(C!°√(C!°
4:  4
5:  cosh(sinh⁻¹(cosh(sinh⁻¹(...sinh⁻¹(cosh(D    with 25 repetitions of cosh(
6:  6
7:  7
8:  8
9:  9
10: ₁₀^(₁₀^(E
11: 11
12: F nPr F/sin(tan⁻¹(...(sin(tan⁻¹(F nPr F     with 143 repetitions of sin(tan⁻¹(
13: det([[G≤G]...[G≤G]]ᵀ[[G≤G]...[G≤G           with 26 repetitions of G≤G
14: ln(tanh(not(H))...tanh(not(H)))
        ln(tanh(not(H)))^⁻not(H                 with 14+1 repetitions of tanh(not(H))
15: iPart(e^(e^(e^(I
16: sum(dim(identity(sum(dim(identity(sum(
        dim(identity(sum(dim(identity(J≥J
17: K nCr K+K nCr K+...+K nCr K                 with 17 repetitions of K nCr K
18: abs(i-i-...-i                               with 20 repetitions of i
19: rand→L:log(LL...LL→M:log(L→N:N⁻¹M           with 19 L's inside the log
20: mean(seq(OOO,O,O,sinh(sinh(cos⁻¹(O
21: ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(³√(ππ³√(π³
        √(π³√(ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(
        π³√(³√(ππ³√(ππ
22: 22
23: 3(3(3×√(3(3(3×√(3(3×√(3(3(3×√(3×√(3×√(
        3(3×√(3(3×√(3(3(3×√(3(3×√(3×√(3(3(
        3×√(3(3×√(3×√(3×√(3(3(3×√(3(3×√(3(
        3(3×√(3×√(3(3(3×√3
24: Fix 0
    sin⁻¹(ᴇ0
    AnsAnsAnsAnsAnsAnsAns
25: 5*5

Fare riferimento a http://tibasicdev.wikidot.com/one-byte-tokens per un elenco di ciò che la sfida fa e non consente qui.

Tutti questi possono essere programmi completi, poiché l'ultima riga di un programma viene stampata automaticamente. Ma (tranne 17, che è lungo più righe) possono anche essere frammenti nella schermata principale.

A questo punto, non vedo altro modo per ottenere un valore diverso da zero dai token rimanenti disponibili. Se c'è qualche miglioramento da apportare, sarà necessario prima rendere alcune delle soluzioni sopra più conservative.

spiegazioni

• A=Aè un valore booleano 1 perché la variabile Aè uguale a se stessa.
• Bè 0 per impostazione predefinita, tan(tan(cos(cos(cos(Bè circa 2,21 e quindi prendiamo la parola.
• C!°è di 1 grado in radianti, circa 0,017. Un certo potere positivo di questo è tanh (2), circa 0,964. Codifichiamo quella potenza in binario usando la moltiplicazione implicita e √(, quindi, prendiamo tanh⁻¹(.
• 4 è semplice
• cosh(sinh⁻¹(X$\sqrt{1+X^2}$
• 6-9 sono semplici
• ₁₀^( è un byte incorporato per potenze di 10 e 10 ^ 10 ^ 0 = 10 ^ 1 = 10.
• 11 è 11.
• F nPr Fsin(tan⁻¹(X$\frac{1}{\sqrt{1+1/X^2}}$
• G≤Gè 1, quindi [[G≤G]...[G≤G]]è un vettore di colonna 13x1. Prendere il prodotto della sua trasposizione con se stesso dà la matrice [[13]], il cui determinante è 13.
• not(H)è 1. tanh(not(H))è solo un numero non uguale a 0 o 1 e ln(XXX....X)ln(X)^⁻1si semplifica al numero di X's nel primo registro a condizione che Xnon sia 0 (in modo che il registro esista) e non 1 (in modo che non stiamo dividendo per 0).
• e^(e^(e^(F valuta circa 15.15 e poi prendiamo la parola.
• J≥Jè 1. identity(costruisce una matrice di identità 1x1, dim(trova le dimensioni di riga e colonna e le sum(aggiunge per ottenere 2. Quindi lo facciamo di nuovo, aggiungendo le dimensioni di una matrice 2x2 per ottenere 4, e ancora, aggiungendo le dimensioni di una matrice 4x4 per ottenere 8 e ancora, aggiungendo le dimensioni di una matrice 8x8 per ottenere 16.
• K nCr K è il coefficiente binomiale 0 scegli 0 o 1. Sommando 17 1 si ottiene 17.
• i-i-...-isemplifica a ⁻18i, e prendendo abs(dà 18.
• rand→Lmemorizza un numero reale casuale su L, ma non ci importa di cosa si tratti. Stiamo elaborando log(L)⁻¹log(L^19), il che semplifica a 19.
• sinh(sinh(cos⁻¹(Iè un po 'più di 4, quindi seq(III,I,I,sinh(sinh(cos⁻¹(Ifornisce l'elenco la {0 1 8 27 64}cui media aritmetica è 20.
• Un'altra istanza del trucco usata per ottenere 3. Qui, un po 'di potere di πdovrebbe dare 21; codifichiamo quel potere in ternario usando la moltiplicazione implicita e ³√(.
• 22 è 22.
• Un'altra istanza del trucco usata per ottenere 3 e 21. Codifichiamo la potenza di 3 che equivale a 23 in ternario, usando 3×√(come radice cubica e (per moltiplicazione.
• Fix 0è l'impostazione per la visualizzazione di 0 cifre dopo il decimale, arrotondando tutti i valori a numeri interi. sin⁻¹(ᴇ0restituisce π / 2 e π / 2 moltiplicato per 7 volte dà circa 23,59, che arrotondano a 24.
• 5*5è 25. (Sarebbe più prudente usare 5per ottenere 5 e adattare la soluzione usata lì per 25. Ma in questo modo risparmia molto spazio e *non è un personaggio molto utile perché esiste una moltiplicazione implicita.)

SOGL , punteggio 16 18 20, 109 byte, 47 caratteri utilizzati

=                    push ""=""
ρ:¾/U                ceil(isPalindrome("")/(isPalindrome("")*(3/4))) -> ceil(1/(3/4)) -> ceil(4/3)
3                    push 3
MM¼÷                 100/(100*1/4)
æ⁄                   length of "aeiou"
6                    push 6
7                    push 7
Nτ                   log2(256)
9                    push 9
L                    push 10
⁹’                   byte with the 11th SOGL code point
Ιζrkk"⁸              `⁸`s UTF-8 codepoint to string, take off 1st 2 chars
'⁰                   messy compression
īuHHHHHHHHHHHHHH±    floor(0.1) `-1` 14 times, then change sign
aIIIIIIIIIIIIIII     A `+1` 15 times, A = 0
4²                   4^2
lllllllllllllllll”l  length of "lllllllllllllllll"
222222222++++++++    2+2+2+2+2+2+2+2+2
δ“○“-                429-420
Μ℮‘                  compressed string of "2ŗ" where ŗ defaults to 0

Brachylog , 16 numeri interi, 86 byte

1
2
3
4
5
6
7
8
9
ℕ<<<<<<<<<<
≜+₁₁
Ịbkkkkkkkị
Ḥl
ℤ₇×₂ṅ
"____**"pᶜ¹
⟦h>>>>>>>>>>>>>>>>ȧ

Provalo online! (L'ingresso controlla quale programma viene eseguito, da 1 a N)

Spiegazione

                       The output is...

1                      1
2                      2
3                      3
4                      4
5                      5
6                      6
7                      7
8                      8
9                      9
ℕ<<<<<<<<<<            Strictly bigger than ... strictly bigger than 0
≜+₁₁                   0 + 11
Ịbkkkkkkkị             "12" converted to an integer
Ḥl                     The length of "Hello, World!"
ℤ₇×₂ṅ                  -(-7 × 2)
"____**"pᶜ¹            The number of unique permutations of "____**"
⟦h>>>>>>>>>>>>>>>>ȧ    The absolute value of stricly less than ... stricly less than 0

Jelly , punteggio 22, 177 byte

1: Ṇ  : logical NOT. When there is no input, 0 is assumed, so this returns NOT(0)=1
2: ~A~A  : ~ is bitwise NOT and A is absolute value, implicit 0 input
         : 0~ = -1;   0~A = 1;   0~A~ = -2;  0~A~A = 2.
3: 3  : literal 3
4: -ı-²²×-Ḟ:
   -ı-     : literal complex number -1-1j
   ²²×-    : square (2j), then square(-4), then multiply by (×) negative 1 (-) to get 4+0i
   Ḟ       : get the real component, which is 4
5: 5  : literal 5
6: 6  : literal 6
7: 7  : literal 7
8: 8  : literal 8
9: ØDṪ : tail(Ṫ) of list of digits (ØD) to return 9
10: ⁵  : literal 10
11: 11 : literal 11
12: CNCNCNCNCNCNCNCNCNCNCNC : again, 0 is taken as input because there is no input
                            : C is complement and N is negate
                            : so each NC returns 1-(-n)=n+1 and is equivalent to increment, returning 12
13: “>>>>>»L    : encodes "#GlomAbducens" with “>>>>>» then returns the length in characters (13) with L
14: ‘‘‘‘‘‘‘‘‘‘‘‘‘‘   : default input is 0 again, and each ‘ increments it to get 14
15: Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;ỊS : default input is 0 again.
                                   : each Ị returns abs(0)<1 = 1
                                   : these are concatenated together with ; then summed with S to get 15
16: ⁴  : builtin literal 16
17: ,,,,,,,,,,,,,,,,,ŒḂŒḊ : Each , is the pair dyad: x,y = [x,y] and x,[y,z] = [x,[y,z]]. 
                          : Thus each , increased the depth by 1, then ŒḊ returns the depth: 17
18: 9Ḥ : 9 doubled = 18
19: E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E : each E returns areallelementsidentical([0]) = 1
                                          : 19 of these are summed with +
20: 44440b44ạ/ : 44440 base 44 = [22,42,0].
               : ạ/ takes the absolute difference of terms: ||22-42|-0| = 20
21: ”TOHH : ”T is the character literal "T". OHH returns its ascii value 84 (O) halved twice (HH) = 21
22: literal 22

Prova tutto in una volta o Prova uno alla volta (l'argomento è quale output vuoi).

Personaggi inutilizzati:

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑÞßæçðȷñ÷øœþ !"#$%&'()*.:<=?@BFGIJKMPQRUVWXYZ[\]^_`acdefghijklmnopqrstuvwxyz{|}¶°¹³⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḲḶṂỌṚṢṬỤṾẈỴẒȦĊĖḞĠḢİĿṀṄȮṖṘṠẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«’

Reng, punteggio 40, 149 byte

Provalo qui!

1.  e
2.  2
3.  ::l
4.  4
5.  5
6.  i`i`i`i`i`i`+++++
7.  7
8.  8
9.  9
10. A
11. ÇÇÇǹ
12. C
13* [[[[[[[[[[[[[mn~
14. E
15. F
16. G
17. H
18. I
19. J
20. K
21. L
22. M
23. N
24. O
25. P
26. Q
27. R
28. S
29. T
30. U
31. V
32. W
33. X
34. Y
35. Z
36. 6²
37. "%"
38* &fæ¦
39. D3*
40. 11±$1±±±±±±±±$11±$1±±±±$±$

Tutte le lettere maiuscole sono numeri, quindi è carino. Tutti tranne due sono frammenti. I due che sono programmi:

13. [[[[[[[[[[[[[mn~
38. &fæ¦

Il collegamento fornito consente di vedere lo stack durante l'esecuzione. Scriverò una spiegazione più tardi.

CJam, punteggio 27, 168 byte

1-3: X , Y,Z

Le variabili X, Ye Zsono inizializzati a 1, 2, e 3, rispettivamente.

4: ",,,,",

Spingere la corda ,,,,e prendere la lunghezza.

5-9: 5 , 6, 7, 8,9

Letterali numerici.

10-20 : A-K

Variabili preinizializzate.

21: U)))))))))))))))))))))

La variabile Uè inizializzata su 0. Spingilo Ue incrementalo 22 volte.

22: 22

Letterale numerico.

23: ';(((((((((';((((((((

Spingi il personaggio ;e diminuiscilo 9 volte per ottenere 2, quindi premi di ;nuovo e diminuiscilo 8 volte per ottenere 3.

24: 4m!

Prendi il fattoriale di 4.

25: TT=TT=+TT=TT=TT=TT=TT=++++

TT=spinge 1. Questo codice è equivalente a 1 1+1 1 1 1 1++++.

26: N:i~W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-

Nspinge una stringa contenente una nuova riga. :ilo converte in un elenco di codici carattere, cedendo [10]. ~decomprime, dando 10. W-è l'equivalente di aggiungerne uno. Incrementare 10 sedici volte dà 26.

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

Trova l'indice di 0 in un elenco in cui 0 si trova al 27 ° indice.

Personaggi ancora disponibili: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

Alcune note per una potenziale espansione:

• Potrei dover cambiare 10-20 per usare le variabili per qualcos'altro. Se ottengo numeri superiori a 1, posso usare *(e possibilmente operatori bit a bit, ma non credo che mi aiuteranno molto).

• Ho ancora S, qualunque cosa buona che mi farà.

• Se cambio 26 in N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, allora :sarà disponibile.

• Posso inserire alcune liste vuote e ottenere più zero con le variabili esistenti. Posso anche ottenere π, ma ciò non sembra molto utile a meno che non riesca a trasmetterlo a un numero intero in qualche modo, e m(per m[) e isia già preso.

• In termini di manipolazione dell'array, posso:

  • Usa una mappa con %of
  • Usa una piega con *
  • Fai alcune operazioni su rete
  • Conversione di base (questo sembra promettente, ma non so come ottenere il numero di base)
  • Costruire array usando |:M1|2|3|

Haskell , punteggio 13, 86 byte

pi/pi
sum[sum[]^sum[],sum[]^sum[]]
3
4
5
6
7
8
9
length"eeeeeeeeee"
11
2+2+2+2+2+2
0xD

Provalo online!

Grazie a Ørjan Johansen per aver trovato il modo di sistemare la mia lettera sovrapponendola mantenendo il punteggio di tredici. (Anche per aver fatto di tutto per avvisarmi mentre questa risposta è stata cancellata.)

pi/pilo è 1.0.
sum[]valuta a 0, 0^0a 1e sum[1,1]a 2. 3a 9decodificare solo se stessi.
length"eeeeeeeeee"restituisce la lunghezza della stringa, ovvero 10.
2+2+2+2+2+2lo è 12.
0xDè esadecimale per 13.