Usando os 74 caracteres da sequência da cápsula do tempo de 2016

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

escreva trechos de código N, todos no mesmo idioma em que:

• O primeiro fragmento é gerado 1.
• O segundo fragmento é gerado 2.
• O terceiro trecho é exibido 3.
• ... etc ...
• O trecho N é o resultado N(o número, não a letra literal).

Um "snippet de código" é definido como qualquer um destes:

• Um programa completo sem entrada necessária que gera o número normalmente .
• Uma função sem argumentos necessários que gera / retorna o número normalmente .
• Uma expressão REPL que avalia o número.

Você pode misturar e combinar essas três variantes nos seus snippets N.

Os caracteres que você pode usar no conjunto combinado de N snippets são precisamente os 74 caracteres da cápsula do tempo, além de floor(N/2) bytes extras "curinga" que você pode usar em qualquer lugar.

Por exemplo, a cápsula do tempo contém três @, portanto, na totalidade de seus N snippets, pode haver apenas três @presentes, a menos que você decida usar alguns de seus floor(N/2)caracteres curinga para obter @mais.

Portanto, sem contar caracteres curinga, o conjunto combinado de caracteres em seus N snippets deve ser um subconjunto dos 74 caracteres da cápsula do tempo. Seus comprimentos combinados não podem exceder 74. Você não pode reutilizar caracteres da cápsula do tempo ou bytes curinga entre os snippets.

Notas

• Não existem outros limites no comprimento do trecho ou quantos curingas podem ser usados ​​por trecho.

• Você deve escrever todos os trechos de 1 a N. Não é 0 a N-1, nem k a N + k-1.

• Os trechos devem ser individuais, não um trecho que produza a lista 1, 2, 3, ..., N.

• As saídas podem ser flutuantes, como 3.0no lugar de, 3e você pode usar uma base que não seja decimal se for a base natural do seu idioma . Você deve usar a mesma base para todos os trechos.

• Os curingas são contados como bytes na codificação do seu idioma . Provavelmente será ASCII, mas, por exemplo, se ∞contar como um byte na sua codificação, você poderá usá-lo como um único byte curinga.

• Você pode usar bytes curinga para caracteres multibyte. por exemplo, normalmente∞ tem três bytes, portanto você pode usá-lo em um trecho, mas custará três dos seus bytes curinga.floor(N/2)

• Novas linhas , como \r\npodem ser consideradas um byte.

Exemplo

Em Python, N = 4 é possível apenas usando o REPL. Existem floor(4/2) = 2curingas.

1. 1da cápsula do tempo é uma expressão que evals para 1.

2. 2consiste em um único curinga, ou seja, o 2. Evals to 2.

3. 3também consiste em um único curinga. Evals to 3. Não há mais curingas.

4. 4é felizmente na cápsula do tempo e evals para 4.

Esses trechos são curtos e triviais. Uma resposta real provavelmente seria muito mais complexa.

(Cinco e mais além em Python certamente podem ser possíveis, mas deixarei para os profissionais.)

Pontuação

A resposta com o N mais alto ganha; ou seja, aquele que sobe mais alto na escada inteira.

Em caso de empate, a resposta que usou o menor número de bytes curinga vence.
Caso ainda haja um empate, a resposta que usou o menor número de caracteres acumulados vence.
Se ainda houver um empate, a resposta anterior vence.

CJam , 25 trechos, 12 curingas, 64 bytes

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

Experimente online!

Curingas:

568BBCDEFGJK

Sinto que tenho que postar rapidamente, antes que Dennis me derrote.

CJam , 23 trechos, 11 curingas, 45 bytes

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

Experimente online! | contador curinga (ignore as novas linhas)

JavaScript, 10 números, 5 curingas

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

5/5 caracteres de bônus usados: 37680

Programas:

1. 1

2. ! `` +! ``

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

Eu esperava que uma das cordas que eu pudesse usar \xABfosse um número, mas infelizmente nenhuma das combinações que eu tentei produziria nenhuma. O ^caractere (XOR) também seria interessante de usar, mas atualmente não vejo oportunidades em que possa ser usado para criar um número grande o suficiente.

Se você vir outra combinação viável, informe-me nos comentários.

Edit: Added # 10 thanks to Arnauld

Pyth, 12 trechos, 20 bytes (6 caracteres curinga)

f@

Encontre o primeiro número em que a raiz (n, n) é verdadeira, começando em 1. Saída: 1

y!H

Dobro não {}. Saída: 2

3

Curinga # 1. Saída: 3

4

Saída: 4.

5

Curinga # 2. Saída: 5

6

Curinga # 3. Saída: 6

7

Curinga # 4. Saída: 7

8

Curinga # 5. Saída: 8

9

Saída: 9

T

Variável pré-inicializada. Saída: 10

+T!Z

Dez mais não zero. Saída: 11

12

Curinga # 6 ( 2). Saída: 12

Oitava, 6 números, 3 curingas

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

Eu ainda tenho 1, 9e *à esquerda, mas eu não sei se ele vai me ajudar muito. Vou ver o que posso fazer com esses :)

Não é fácil obter muitos números quando não estiver usando um Esolang. Espero conseguir mais um ou dois, mas acho que será difícil.

Pushy , 10 números (4 curingas)

Todos esses são trechos que deixam o resultado na pilha. Você pode testar isso no intérprete on - line anexando #a cada trecho (para imprimir o número)

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

Essa resposta ainda não está completa - embora pareça improvável que eu vá muito além.

05AB1E, 12 números, 6 curingas

 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

Hexagonia , 6 números, 3 curingas, 23 bytes

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

Experimente online!

O sexto programa inteiro é feito de caracteres curinga.

O único realmente interessante é 3. Embora eu pudesse fazer isso assim 4(!@, isso me deixaria sem a 4para gerar 5facilmente, então fui com isso:

 ) |
\ @ $
 ! .

Devido a isso |, a )primeira linha é executada duas vezes, antes do IP passar para o canto direito. $pula sobre o @e \redireciona o IP pela )terceira vez. O IP passará para o canto inferior esquerdo, !imprime o 3e@ finaliza o programa.

Acho que não são possíveis mais de 6 trechos, porque existem apenas 5 comandos de impressão ( !!!!!) e 5 comandos que podem ser usados ​​para finalizar o programa ( @@@%:). Portanto, após o quinto snippet, precisamos de pelo menos dois curingas por snippet. Portanto, mesmo se eu conseguisse ficar 6sem usar um curinga, não haveria curingas suficientes para ir para o snippet sete.

JavaScript, 8 números, 4 curingas

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

Posso tentar novamente mais tarde - estou meio que desperdiçando personagens nos dias 2 e 6, quando você se dedica a isso.

Befunge-98, 4 trechos, 18 bytes, 2 curingas

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

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

Duvido que mais sejam possíveis, pois todo programa extra exigirá uma forma de saída e todos .,já estão esgotados. Se eu conseguir descobrir uma maneira de fazer 3 e 5 sem um curinga, é possível.

O último programa será finalizado devido ao preenchimento da pilha. Ae Hsem impressões digitais carregadas refletirá, e o programa continuará pressionando 9.

SmileBASIC, 12 trechos, 5 curingas, 31 bytes

!.     '. 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)

Eu também poderia ter usado uma variável em vez de .(variáveis ​​começam em 0) e uma variável de string (comoQ$ ) em vez de@Q

Caracteres utilizados: !!!#&*+...1449@AHILQQTem||

Curingas usados: 67813

caracteres não utilizados: !!$$%()))):=@@OQTZ\\^`````````efpxy{||~~~~~~~~~