Utilizzo dei 74 caratteri della stringa della capsula del tempo 2016

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

scrivere snippet di codice N tutti nella stessa lingua in cui:

• Il primo frammento viene emesso 1.
• Il secondo frammento viene emesso 2.
• Il 3o frammento viene emesso 3.
• ... eccetera. ...
• L'ennesimo frammento di output N(il numero, non la lettera letterale).

Un "frammento di codice" è definito come uno di questi:

• Un programma completo senza input richiesto che genera normalmente il numero .
• Una funzione senza argomenti richiesti che genera / restituisce il numero normalmente .
• Un REPL un'espressione che restituisce il numero.

(Puoi mescolare e abbinare queste tre varianti nei tuoi frammenti N.)

I caratteri che è consentito utilizzare nell'insieme combinato di N frammenti sono esattamente i 74 caratteri della capsula del tempo, più floor(N/2) i byte "jolly" extra che è possibile utilizzare ovunque.

Ad esempio, la capsula del tempo ne contiene tre @, quindi nell'insieme dei tuoi N frammenti potrebbero esserci solo un massimo di tre @, a meno che tu non decida di utilizzare alcuni dei tuoi floor(N/2)caratteri jolly per ulteriori @.

Pertanto, senza contare i caratteri jolly, l'insieme combinato di caratteri nei tuoi frammenti N deve essere un sottoinsieme dei 74 caratteri capsula del tempo. Le loro lunghezze combinate non possono superare 74. Non puoi riutilizzare i caratteri di capsula del tempo o byte jolly tra i frammenti.

Gli appunti

• Non ci sono altri limiti sulla lunghezza dello snippet o su quanti caratteri jolly possono essere utilizzati per snippet.

• Devi scrivere tutti i frammenti da 1 a N. Non è da 0 a N-1, non da k a N + k-1.

• Gli snippet devono essere individuali, non uno snippet che genera l'elenco 1, 2, 3, ..., N.

• Gli output possono essere float come 3.0al posto di 3e puoi usare una base diversa dai decimali se è la base naturale della tua lingua . Devi utilizzare la stessa base per tutti gli snippet.

• I caratteri jolly sono conteggiati come byte nella codifica della tua lingua . Questo sarà probabilmente ASCII ma, ad esempio, se ∞conta come un byte nella codifica, puoi usarlo come un singolo byte jolly.

• È possibile utilizzare byte jolly per caratteri multibyte. ad esempio, normalmente∞ è di tre byte, quindi è possibile utilizzarlo in uno snippet ma costerà tre byte jolly.floor(N/2)

• Newline come \r\npossono essere considerati un byte.

Esempio

In Python, N = 4 è possibile solo usando REPL. Ci sono floor(4/2) = 2caratteri jolly.

1. 1dal tempo la capsula è un'espressione che si evolve in 1.

2. 2è costituito da un singolo carattere jolly, vale a dire il 2. Prove a 2.

3. 3comprende anche un solo carattere jolly. Prove a 3. Niente più caratteri jolly.

4. 4è fortunatamente nella capsula del tempo e si valuta 4.

Questi frammenti sono brevi e banali. Una vera risposta sarebbe probabilmente molto più complessa.

(Cinque e oltre in Python potrebbero certamente essere possibili, ma lo lascerò ai professionisti.)

punteggio

Vince la risposta con la N più alta; cioè quello che sale la scala intera il più alto.

In caso di pareggio, vince la risposta che utilizzava il minor numero di byte jolly.
Nel caso in cui vi sia ancora un pareggio, vince la risposta che utilizzava il minor numero di caratteri cumulativi.
Se c'è ancora un pareggio, vince la risposta precedente.

CJam , 25 frammenti, 12 caratteri jolly, 64 byte

1
Q!)
Z
4
5
6
L``(*$)#
8
9
T!T
B
C
D
E
F
G
H
I
J
K
O`e`~~!!
B`:)
Q``$e`~~@~@=~+
Q!)4
Amf

Provalo online!

I caratteri jolly:

568BBCDEFGJK

Sento che devo pubblicare rapidamente, prima che Dennis mi superi.

CJam , 23 frammenti, 11 caratteri jolly, 45 byte

Q!
Q!)
Z
4
4)
6
7
8
9
A
B
C
D
E
F
G
H
I
J
QT|T+e`
O!)1
L!`e`(:)
6mf

Provalo online! | contatore di caratteri jolly (ignora le nuove righe)

JavaScript, 10 numeri, 5 caratteri jolly

Caratteri rimanenti: !!#$$%&())))*...:=@@@HILOQQQTTZ\^```eefmpy{|||~~~~~~~~~

5/5 personaggi bonus usati: 37680

programmi:

1. 1

2. ! `` +! ``

3. 3
4. 4
5. 4|!``
6. 6
7. 7
8. 8
9. 9
10. 0xA

Speravo che una delle stringhe che avrei potuto usare \xABfosse un numero, ma sfortunatamente nessuna delle combinazioni che ho provato avrebbe prodotto alcun valore. Anche il ^personaggio (XOR) sarebbe interessante da usare, ma al momento non vedo alcuna opportunità in cui possa essere usato per fare un numero abbastanza grande.

Se vedi un'altra combinazione possibile, fammelo sapere nei commenti.

Modifica: aggiunto # 10 grazie ad Arnauld

Pyth, 12 frammenti, 20 byte (6 caratteri jolly)

f@

Trova il primo numero in cui root (n, n) è true, a partire da 1. Output: 1

y!H

Doppio no {}. Uscita: 2

3

Carattere jolly n. 1. Uscita: 3

4

Uscita: 4.

5

Wildcard # 2. Uscita: 5

6

Wildcard # 3. Uscita: 6

7

Wildcard # 4. Uscita: 7

8

Wildcard # 5. Uscita: 8

9

Uscita: 9

T

Variabile preinizializzata. Uscita: 10

+T!Z

Dieci più non zero. Uscita: 11

12

Wildcard # 6 ( 2). Uscita: 12

Ottava, 6 numeri, 3 caratteri jolly

1: ~~I          % not(not(sqrt(-1))) evaluates to true (or 1)
2: 2            % Wildcard
3: 3            % Wildcard
4: 4
5: (T=4)+~~T    % Create a variable T=4, then add not(not(T)) which evaluates to 1.
6: 6            % Wildcard

Ho ancora 1, 9e *lasciato, ma non so se mi aiuterà molto. Vedrò cosa posso fare con quelli :)

Non è facile ottenere molti numeri quando non si utilizza un Esolang. Spero di poterne ottenere uno o due in più, ma penso che sarà difficile.

Pushy , 10 numeri (4 caratteri jolly)

Tutti questi sono frammenti che lasciano il risultato in pila. Puoi verificarlo nell'interprete online aggiungendo #a ciascun frammento (per stampare il numero)

A(      \ 1:  Get alphabet and check that 'Z' >= 'Y'. Results in 1 (True)
x&+     \ 2:  Check stack equality (True - both are empty) then duplicate and sum.
3       \ 3:  Push 3 (1 wildcard)
4       \ 4:  Push 4
1 4+    \ 5:  1 + 4 in postfix, leaves 5 on the stack (1 wildcard)
`L`T%   \ 6:  Get character code of 'L' and modulo by T (ten) - leaves 6 on the stack
7       \ 7:  Push 7 (1 wildcard)
8       \ 8:  Push 8 (1 wildcard)
9       \ 9:  Push 9
T       \ 10: Push 10

Questa risposta non è ancora completa - anche se sembra improbabile che andrò molto più avanti.

05AB1E, 12 numeri, 6 caratteri jolly

 1:    1                                   -> 1
 2:    )O!x                                -> sum([])!*2
 3:    4L`\                                -> 2nd_last(range(1...4))
 4:    4                                   -> 4
 5:    5        # wildcard 1 = 5           -> 5
 6:    6        # wildcard 2 = 6           -> 6
 7:    Tf`~                                -> or(last2(prime_factors(10)))
 8:    8        # wildcard 3 = 8           -> 8
 9:    9                                   -> 9
10:    T                                   -> 10
11:    A`Q!T+   # wildcard 4 = T           -> (y==z)!+10
12:    TÌ       # wildcard 5,6 = T,Ì       -> 10+2

Esagonia , 6 numeri, 3 caratteri jolly, 23 byte

1!@
))!@
)|\@$!
4!%
4)!:
6!@

Provalo online!

L'intero sesto programma è composto da caratteri jolly.

L'unico davvero interessante è 3. Mentre potrei farlo così 4(!@, questo mi lascerebbe senza 4a generare 5facilmente, quindi sono andato con questo invece:

 ) |
\ @ $
 ! .

A causa di |, )sulla prima riga viene eseguita due volte, prima che l'IP si sposti nell'angolo a destra. $salta su @, quindi \reindirizza l'IP per la )terza volta. L'IP si sposta nell'angolo in basso a sinistra, !stampa 3e @termina il programma.

Non credo che siano possibili più di 6 frammenti, perché ci sono solo 5 comandi di stampa ( !!!!!) e 5 comandi che possono essere usati per terminare il programma ( @@@%:). Pertanto, dopo il quinto frammento, sono necessari almeno due caratteri jolly per frammento. Quindi, anche se riuscissi a ottenere 6senza usare un jolly per esso, non ci sarebbero abbastanza jolly per andare allo snippet sette.

JavaScript, 8 numeri, 4 caratteri jolly

 1: 1
 2: -~!``
 3: 4+~!$
 4: ~!``*~!``
 5: 4|!$
 6: 0xf^9
 7: 7
 8: 8

Potrei riprovare più tardi - sto sprecando i personaggi in 2 e 6, quando ci riesci.

Befunge-98, 4 frammenti, 18 byte, 2 caratteri jolly

!.@
!:+.@
41-.@    wildcard 1 = -
4.#A9H   wildcard 2 = .

Caratteri rimanenti: !!!$$%&())))*=ILOQQQTTZ\^`````````eefmpxy{||||~~~~~~~~~

Dubito che sia possibile farlo di più, poiché ogni programma aggiuntivo richiederà una forma di output e tutti .,sono già esauriti. Se riesco a capire un modo per fare 3 e 5 senza un carattere jolly, allora è possibile.

L'ultimo programma alla fine terminerà a causa del riempimento dello stack. Ae Hsenza impronte digitali caricate si rifletterà, e il programma continuerà a spingere 9.

SmileBASIC, 12 frammenti, 5 caratteri jolly, 31 byte

!.     '. is parsed as the number 0.0; taking the logical not gives 1
!.+!.  'Previous value added to itself
@Q||Q  '@Q is a label string and Q is a variable. For some reason, certain comparison/logical operations between strings and numbers return 3 rather than 1 or 0. 
4      '4
#TLIme 'Constant for the text color lime green, value is 5.
6      '6 (wildcard)
7      '7 (wildcard)
8      '8 (wildcard)
9      '9
&HA    'Hexadecimal A
11     '11 (one of them is a wildcard)
4*3    '4 multiplied by 3 (3 is wildcard)

Avrei potuto anche usare una variabile invece di .(le variabili iniziano da 0) e una variabile stringa (come Q$) invece di@Q

Personaggi usati: !!!#&*+...1449@AHILQQTem||

Caratteri jolly utilizzati: 67813

personaggi inutilizzati: !!$$%()))):=@@OQTZ\\^`````````efpxy{||~~~~~~~~~