Usando los 74 caracteres de la cadena de cápsulas del tiempo 2016

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

escribir fragmentos de código N en el mismo idioma donde:

• Las salidas del primer fragmento 1.
• Las salidas del segundo fragmento 2.
• Las salidas del 3er fragmento 3.
• ... etc. ...
• Las salidas del fragmento N-ésimo N(el número, no la letra literal).

Un "fragmento de código" se define como cualquiera de estos:

• Un programa completo sin entrada requerida que genera el número normalmente .
• Una función sin argumentos necesarios que genera / devuelve el número normalmente .
• Una expresión REPL que evalúa el número.

(Puede mezclar y combinar estas tres variantes en sus N fragmentos).

Los caracteres que puede usar en el conjunto combinado de N fragmentos son precisamente los 74 caracteres de la cápsula del tiempo, más floor(N/2) los bytes "comodín" adicionales que puede usar en cualquier lugar.

Por ejemplo, la cápsula del tiempo contiene tres @, por lo que en la totalidad de sus N fragmentos solo puede haber hasta tres @presentes a menos que decida utilizar algunos de sus floor(N/2)bytes comodín para obtener @más.

Por lo tanto, sin contar los comodines, el conjunto combinado de caracteres en sus N fragmentos debe ser un subconjunto de los 74 caracteres de la cápsula del tiempo. Sus longitudes combinadas no pueden exceder 74. No puede reutilizar caracteres de cápsula de tiempo o bytes comodín entre fragmentos.

Notas

• No hay otros límites en la longitud del fragmento o cuántos comodines se pueden usar por fragmento.

• Debe escribir todos los fragmentos del 1 al N. No es 0 para N-1, ni k para N + k-1.

• Los fragmentos deben ser individuales, no un fragmento que muestre la lista 1, 2, 3, ..., N.

• Las salidas pueden ser flotantes como 3.0en lugar de 3y puede usar una base que no sea decimal si es la base natural de su idioma . Debe usar la misma base para todos los fragmentos.

• Los comodines se cuentan como bytes en la codificación de su idioma . Probablemente sea ASCII pero, por ejemplo, si ∞cuenta como un byte en su codificación, puede usarlo como un solo byte comodín.

• Puede usar bytes comodín para caracteres multibyte. por ejemplo, ∞es normalmente tres bytes por lo que podría utilizarlo en un fragmento pero va a costar tres de sus floor(N/2)bytes comodín.

• Nuevas líneas como \r\npueden considerarse un byte.

Ejemplo

En Python, N = 4 es posible simplemente usando REPL. Hay floor(4/2) = 2comodines.

1. 1de la cápsula del tiempo es una expresión que evalúa 1.

2. 2consiste en un solo comodín, a saber, el 2. Evalúa a 2.

3. 3También consta de un solo comodín. Evalúa a 3. No más comodines.

4. 4está afortunadamente en la cápsula del tiempo y se evalúa 4.

Estos fragmentos son cortos y triviales. Una respuesta real probablemente sería mucho más compleja.

(Cinco y más en Python pueden ser posibles, pero lo dejaré a los profesionales).

Tanteo

La respuesta con la N más alta gana; es decir, el que sube la escalera entera más alto.

En caso de empate, la respuesta que usó la menor cantidad de bytes comodín gana.
En caso de que todavía haya un empate, la respuesta que usó la menor cantidad de caracteres acumulativos gana.
Si todavía hay un empate, la respuesta anterior gana.

CJam , 25 fragmentos, 12 comodines, 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

Pruébalo en línea!

Comodines:

568BBCDEFGJK

Siento que tengo que publicar rápidamente, antes de que Dennis me supere.

CJam , 23 fragmentos, 11 comodines, 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

Pruébalo en línea! El | contador de comodines (ignore las nuevas líneas)

JavaScript, 10 números, 5 comodines

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

5/5 caracteres de bonificación utilizados: 37680

Programas:

1. 1

2. ! `` +! ``

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

Tenía la esperanza de que una de las cuerdas que pudiera hacer \xABsería un número, pero desafortunadamente ninguna de las combinaciones que probé produciría ninguna. los^ personaje (XOR) también sería interesante de usar, pero actualmente no veo ninguna oportunidad en la que pueda usarse para hacer un número lo suficientemente grande.

Si ve otra combinación factible, hágamelo saber en los comentarios.

Editar: Agregado # 10 gracias a Arnauld

Pyth, 12 fragmentos, 20 bytes (6 comodines)

f@

Encuentre el primer número donde la raíz (n, n) es verdadera, comenzando desde 1. Salida: 1

y!H

No doble {}. Salida: 2

3

Comodín n. ° 1. Salida: 3

4

Salida: 4.

5

Comodín n. ° 2. Salida: 5

6

Comodín n. ° 3. Salida: 6

7

Comodín n. ° 4. Salida: 7

8

Comodín n. ° 5. Salida: 8

9

Salida: 9

T

Variable preinicializada. Salida: 10

+T!Z

Diez más no cero. Salida: 11

12

Comodín n. ° 6 ( 2). Salida: 12

Octava, 6 números, 3 comodines

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

Todavía tengo 1, 9y *me fui, pero no sé si me ayudará mucho. Veré qué puedo hacer con esos :)

No es fácil obtener muchos números cuando no se usa Esolang. Espero poder obtener uno o dos más, pero creo que será difícil.

Pushy , 10 números (4 comodines)

Todos estos son fragmentos que dejan el resultado en la pila. Puede probar esto en el intérprete en línea agregando #cada fragmento (para imprimir el 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

Esta respuesta aún no está completa, aunque parece poco probable que llegue mucho más lejos.

05AB1E, 12 números, 6 comodines

 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

Hexagonía , 6 números, 3 comodines, 23 bytes

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

Pruébalo en línea!

El sexto programa completo está hecho de comodines.

El único realmente interesante es 3. Si bien podría hacer eso como 4(!@, eso me dejaría sin una 4para generar 5fácilmente, así que en lugar de eso decidí:

 ) |
\ @ $
 ! .

Debido a que |, )en la primera línea se ejecuta dos veces, antes de que la IP se ajuste a la esquina derecha. $salta sobre @, y luego \redirige la IP por )tercera vez. La IP se ajusta a la esquina inferior izquierda, !imprime 3y@ finaliza el programa.

No creo que sean posibles más de 6 fragmentos, porque solo hay 5 comandos de impresión ( !!!!!) y 5 comandos que pueden usarse para terminar el programa ( @@@%:). Entonces, después del quinto fragmento, necesitamos al menos dos comodines por fragmento. Por lo tanto, incluso si lograra obtener 6sin usar un comodín para ello, no quedarían suficientes comodines para el fragmento siete.

JavaScript, 8 números, 4 comodines

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

Podría intentarlo más tarde: estoy desperdiciando personajes en 2 y 6, cuando lo haces.

Befunge-98, 4 fragmentos, 18 bytes, 2 comodines

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

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

Dudo que sean posibles más, ya que cada programa adicional requerirá una forma de salida, y todos .,ya están agotados. Si puedo encontrar una manera de hacer 3 y 5 sin un comodín, entonces es posible.

El último programa finalmente terminará debido a que la pila se está llenando. Ay Hsin huellas dactilares cargadas se reflejará, y el programa seguirá presionando 9's.

SmileBASIC, 12 fragmentos, 5 comodines, 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)

También podría haber usado una variable en lugar de .(las variables comienzan en 0) y una variable de cadena (como Q$) en lugar de@Q

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

Comodines utilizados: 67813

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