Desafío:

Su tarea es escribir tantos programas / funciones / fragmentos como sea posible, donde cada uno genera / imprime / devuelve un número entero. El primer programa debe generar el entero 1, el segundo 2y así sucesivamente.

No puede reutilizar ningún carácter entre los programas. Entonces, si el primer programa es:, x==xentonces no puede usar los caracteres xy =nuevamente en ninguno de los otros programas. Nota: está permitido usar el mismo personaje muchas veces en un programa.

Puntuación:

El ganador será la presentación que cuenta más alto. En caso de empate, el ganador será el envío que utilizó la menor cantidad de bytes en total.

Reglas:

• Solo puede usar un solo idioma para todos los enteros
• ¡Se permiten fragmentos!
• Para que sea justo, todos los caracteres deben codificarse utilizando un solo byte en el idioma que elija.
• La salida debe estar en decimal. No puede enviarlo con notación científica u otro formato alternativo. La salida de flotantes está bien, siempre que todos los dígitos que se muestran detrás del punto decimal lo estén 0. Entonces, 4.000es aceptado. Se aceptan imprecisiones debido a FPA, siempre que no se muestren en la salida.
• ans =, se permiten espacios iniciales y finales y líneas nuevas, etc.
• Puede ignorar STDERR, siempre que la salida correcta se devuelva a STDOUT
• Puede elegir enviar el entero a STDERR, pero solo si STDOUT está vacío.
• Los lenguajes independientes de símbolos (como Lenguage ) no están permitidos
• Las letras distinguen entre mayúsculas y minúsculas a != A.
• Los programas deben ser independientes.
• El espacio en blanco no se puede reutilizar
• Debe usar dígitos ASCII en la salida

¡Se alientan las explicaciones!

JavaScript (ES7), puntaje 17, 176 bytes

Dijeron que no se podía hacer, así que lo hice: D (gracias a mucha ayuda de @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

Caracteres no utilizados:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

No creo que 18 sea posible, pero dije lo mismo sobre 17 ...

Explicación

JavaScript es un lenguaje muy débilmente escrito; Si intenta realizar una operación matemática en un valor que no sea un número, JS hará todo lo posible para convertirlo primero en un número. Esto permite muchas soluciones interesantes. He tratado de evitar el uso de los dígitos tanto como sea posible para que puedan usarse más adelante.

1. **es el operador de exponenciación en ES7. La cadena vacía cuando se convierte en un número se convierte 0, por lo que esto calcula 0 ** 0, lo que está de 1acuerdo con JavaScript.
2. Un poco ridículo, pero funciona. /~/es un literal regex y ~/~/devuelve -1, por lo que es ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2. (créditos para @ GOTO0 por la idea)
3. Simplemente 3 .
4. Ahora simplemente 4.
5. NaNes falso, también lo !NaNes true, lo que es equivalente a 1. La expresión se convierte así en 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1=5 .
6. Simplemente 6 .
7. Simplemente 7 .
8. Simplemente 8 .
9. Simplemente 9 .
10. Esto usa un poco de magia JSF *** . +[]es decir 0, [[]][+[]]devuelve el primer elemento de [[]](es decir, []) e ++incrementa esto a 1. Luego +[+[]]agrega la matriz [0], que se coacciona a una cadena y hace"10" .
11. En pocas 11. Originalmente había usado11&1111 3 y 33/311 hasta que me di cuenta una vez más de lo tonto que soy ...
12. Esta estrategia funcionaría en cualquier número: crear una cadena de longitud 12y usar.length .
13. Solo jugué un poco con 2sy >s por un tiempo para obtener este. Tuve suerte de nuevo: 222 >> 2es 55y 55 >> 2es13 .
14. Este es bastante complicado. La idea básica es crear 14en hexadecimal ( 0xE), pero necesitamos el dígito en 0otro lugar. Por lo tanto, anteponemos el resultado de ``^``a la cadena xE; la cadena vacía convertida a un número es 0, por lo que esto devuelve 0 ^ 0= 0. Luego, el resultado se XOR con la cadena vacía, que convierte ambos valores en números; "0xE" ^ ""es 14.
15. Esto ahora es bastante fácil: 0XF es un literal hexadecimal con un valor de 15.
16. ¿El más complicado de todos? Primero establecemos la variable Cen CSS == CSS(es decir, true). Luego tomamos el resultado y lo realizamos << Ccuatro veces, que básicamente se multiplica 1por2 ** 4 .
17. JavaScript comienza a perder precisión de enteros en 2 ⁵³ , lo que permite 555...555%55devolver un número que no es 0o 5. Tuve mucha suerte mientras jugaba por aquí.

Estrategias que funcionarían en muchos números:

• -!NaNfuncionaría en cualquier número (actualmente 5), aunque se hace grande muy rápido.
• ~/~/funcionaría en cualquier número (actualmente 2), aunque se hace muy grande muy rápido.
• +[]funcionaría en cualquier número (actualmente 10), aunque es mucho más fácil en10 o 11.
• .length funcionaría en cualquier número.
• `${-``}xE`-`` funcionaría en casi cualquier número si lo haces bien.
• C<<Cfuncionaría en cualquier potencia de dos (actualmente 16), o en cualquier int si lo incluye |.

Gelatina , 47 enteros, 519 bytes

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

Cada línea es un programa separado y completo.

Pruébalo en línea! (incluye conjunto de pruebas y corrector de intersección)

Cómo funciona

Cada programa completo sin argumentos de línea de comandos ejecuta su enlace principal (definido en la última línea) de forma nula, es decir, sin entrada. Si el primer enlace de la cadena es un nilad, se consume, se llama, y ​​tanto el argumento del enlace principal como el valor de retorno se establecen en el resultado; si el primer eslabón de la cadena es una mónada o una díada, se no consumido y el argumento implícito y valor de retorno 0 se utiliza en su lugar. En ambos casos, el resto de la cadena se ejecuta monádicamente.

Jelly destruye su producción en varios casos. Cabe destacar que una matriz singleton se imprime sin los corchetes circundantes, por lo que 42 y [42] son indistinguibles después de la impresión. Usaremos esto en varias ocasiones.

1 - 10

e

El átomo existente prueba si el valor de retorno 0 pertenece al argumento 0 . Lo hace, por lo que edevuelve 1 .

BI$⁼#

BI$es un enlace rápido, específicamente una cadena monádica formada por la $agrupación rápida del átomo binarioB y el átomo incrementalI . Combinados, convierten un número entero en la matriz de sus dígitos en la base 2, luego calculan las diferencias hacia adelante de los dígitos resultantes. Si la matriz tiene solo un elemento, no hay diferencias Idirectas y devuelve una matriz vacía (falso); si hay al menos dos dígitos, Idevuelve una matriz no vacía (verdad).

El rápido #consume el enlace rápido anterior y lo aplica a 0 , 1, 2, ... hasta que se encuentran suficientes coincidencias y devuelve la matriz de coincidencias. La cantidad requerida se calcula mediante ⁼, que compara el valor de retorno / argumento 0 consigo mismo, produciendo 1 . Por lo tanto, todo el programa devuelve [2] , el primer entero no negativo con dos dígitos en la base 2.

⁾⁾⁾Ụ^/

⁾⁾⁾es una cadena literal, específicamente la cadena ⁾⁾ . El átomo de grado superiorỤ clasifica sus índices por sus valores correspondientes; Como ambos caracteres son iguales, esto produce [1, 2] . La matriz resultante se reduce con XOR bit a bit ^/, por lo que todo el programa devuelve 3 .

ı***ıḞḞ

ıinicializa el argumento y devuelve el valor a la unidad imaginaria i . *es la diada de exponenciación , cuyo argumento correcto se predetermina al argumento del enlace principal. Por lo tanto, ***ıcalcula ((i ⁱ ) ⁱ ) ⁱ ≈ 4.81 + 0i , el Ḟátomo ( piso para argumentos reales , parte real para argumentos complejos) calcula la parte real ( 4.81 ), luego Ḟpisos, produciendo 4 .

5
6
7

Estos tres programas consisten en un solo literal y hacen exactamente lo que esperarías.

.::::

El literal .es una abreviatura de 0.5 e inicializa el argumento y el valor de retorno. El argumento derecho de la división entera de la díada ( :) por defecto es el argumento de los enlaces principales, por lo que ::::calcula 0.5 / 0.5 / 0.5 / 0.5 / 0.5 , produciendo 8 .

9

Otro literal

EȮ<

El átomo totalmente igualE devuelve 1 si todos los elementos en su argumento son iguales y 0 si no. Un argumento entero z se promueve a [z] , por Elo que devolverá 1 para el argumento implícito 0 .

Ahora, el átomo de salidaȮ imprime 1 en STDOUT. Luego comparamos 1 con el argumento implícito 0 usando el átomo menor que< . El resultado es (1 <0) = 0 , y se imprime implícitamente cuando finaliza el programa.

11 - 20

⁻GṘ

El átomo de la cuadrículaG intenta hacer una tabla visualmente agradable a partir de su argumento. Para un argumento entero simple (aquí: 0 ), simplemente lo envuelve en una matriz. El átomo plano no igual⁻ compara el argumento implícito 0 con el resultado a la derecha ( [0] ), produciendo 1 ya que sus argumentos no son iguales. El átomo de representaciónṘ imprime 1 en STDOUT y devuelve su resultado. Al final del programa, el valor de retorno final se imprime implícitamente, por lo que terminamos con una salida de 11 .

=`p`VV×`DQV

los auto- rápido `convierte una díada en una mónada llamándola con idénticos argumentos izquierdo y derecho. Primero, =`compara el argumento implícito 0 consigo mismo, produciendo 1 .

El átomo de producto cartesianop espera listas como argumentos, por lo que promueve el entero 1 al rango [1, ..., 1] = [1] . p`toma el producto cartesiano de [1] y en sí mismo, produciendo [[1, 1]] .

El átomo evalV convierte todas las matrices planas (que contienen solo números y caracteres) en cadenas, luego evalúa las cadenas resultantes como programas Jelly niládicos. [[1, 1]] se convierte primero en ["11"] , luego Vevalúa la cadena, produciendo [11] . Una vez más, Vconvierte esta matriz en "11" , luego la evalúa para obtener 11 .

Ahora, ×`multiplica 11 consigo mismo, produciendo 121 . El átomo decimal convierte 121 en [1, 2, 1] , el átomo únicoQ descarta el segundo 1 , y Vuna vez más convierte una lista de dígitos en el entero que resulta de concatenarlos, devolviendo 12 .

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

~es el átomo NO bit a bit . Con la aritmética del complemento a dos, asigna un argumento z a ~ z = - (z + 1) . Aes el átomo de valor absoluto , por lo que asigna - (z + 1) = z + 1 . Con el valor de retorno inicial 0 , las trece copias del ~Aretorno 13 .

⁷ṾṾṾw

La constante ⁷contiene el carácter de nueva línea '\ n' e inicializa el argumento y el valor de retorno.

El átomo no válidoṾ intenta crear una representación de cadena de su argumento z de manera que un programa Jelly que consista en este código devuelva z .

La primera llamada devuelve obedientemente la cadena "” \ n " , que es un carácter literal. La siguiente llamada devuelve "” ”,” \ n " - un par de literales de caracteres. La tercera y última llamada devuelve "” ”,” ”,” ,, ””, ”\ n" - un quintillizo de literales de caracteres.

Finalmente, el átomo del índice de la ventanaw promueve su argumento correcto '\ n' a la cadena "\ n" y encuentra el primer índice de una subcadena que comienza con "\ n" . Esto vuelve 14 .

⁴ḟ€⁴Ṁ

⁴es la constante 16 . El filtro de enlace rápido falla cada ( ḟ€) promueve su argumento izquierdo 16 al rango [1, ..., 16] , luego itera sobre sus elementos.

Para cada elemento z , ḟ⁴se ejecuta, primero promocionando z a [z] , luego eliminando todas (si las hay) ocurrencias de 16 . Esto produce la matriz [[1], [2],…, [14], [15], []] , donde la última matriz está vacía porque contenía 16 .

Finalmente, el átomo máximoṀ selecciona [15] .

mmmmċ

El átomo modularm , llamado con argumentos x (matriz) e y (entero) generalmente toma cada | y | ^th elemento de x , comenzando con el primero si y> 0 , con el último si y <0 . Sin embargo cuando y = 0 , devuelve x concatenado con su reverso.

El argumento entero izquierdo 0 se promueve primero a [0] . La primera copia de mconcatena [0] consigo misma, produciendo [0, 0] . Las copias restantes convierten este resultado en [0, 0, 0, 0] , luego [0, 0, 0, 0, 0, 0, 0, 0] y finalmente [0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .

Por último, el átomo de conteoċ cuenta el número de veces que el argumento implícito 0 aparece en la matriz resultante, devolviendo 16 .

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

ṭes el átomo de tachuela y agrega su argumento izquierdo al derecho. Como ṭy lo siguiente ḍson diádicos, todas las llamadas para ṭpasar el argumento implícito 0 como el argumento correcto para ṭ. La primera llamada devuelve [0, 0] , la segunda [0, [0, 0] y la octava y última [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]]] .

ḍes el átomo de divisibilidad ; Para argumentos x y y , devuelve 1 es x es divisible por y , 0 si no. Ḅes un no-op para enteros, por lo que ḍḄprueba 0 para la divisibilidad por cada entero en la matriz construida. 0 es divisible por sí mismo, por lo que obtenemos [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]] .

Ahora, el átomo no binarioḄ opera en matrices planas. Para un par [a, b] , simplemente devuelve 2a + b . Como se mencionó anteriormente, Ḅes un no-op para enteros: un argumento entero c se promueve a [c] , y [c] en cualquier base es simplemente c .

La primera llamada a Ḅreduce [1, 1] a 3 , dando así [1, [1, [1, [1, [1, [1, [1, 3]]]]]]] . La próxima llamada reduce [1, 3] a 5 , la siguiente [1, 5] a 7 , y así sucesivamente hasta que la novena Ḅdevuelva 17 .

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

Ṇes el átomo NOT lógico plano y asigna el argumento implícito 0 a 1 . +es el átomo de suma, por lo que cada una de las dieciocho copias +Ṇincrementa el valor de retorno anterior (inicialmente 0 ). Todo el programa devuelve así 18 .

CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC

Ces el átomo del complemento y asigna su argumento z a 1-z . Nes el átomo negativo y asigna su argumento z a -z . Juntos, CNasigna z a - (1-z) = z-1 , por lo que las dieciocho copias convierten el argumento implícito 0 en -18 . Una aplicación final de Crendimientos 1 - (-18) = 19.

ĖḌĖḌ

El enumerate átomo Ėenumera los elementos de una matriz, creando pares de índice de valor. El argumento implícito 0 se promueve a [0] , luego Ėproduce [[1, 0]] . El átomo no decimal convierte una matriz plana de base 10 a entero, produciendo [10] en este caso particular.

La segunda llamada a Ėtransforma [10] en [[1, 10]] , que la segunda Ḍfinalmente transforma en [20] .

21 - 30

ṫṣȦJṫȦ⁸ȦJ

El átomo de colaṫ (una díada) selecciona el postfix de su argumento izquierdo que comienza en el índice (basado en 1 y modular) especificado en su argumento derecho, promoviendo un argumento entero izquierdo x a [x] . Cuando se llama con ambos argumentos establecidos en 0 , ṫdevuelve [0] .

El átomo any and allȦ devuelve 1 si su argumento es verdadero y no contiene ceros a ninguna profundidad, 0 de lo contrario. Aquí, simplemente lo usamos como una función de identidad para devolver el argumento implícito 0 . La división en el átomo ṣdivide su argumento izquierdo [0] en las apariciones de su argumento derecho 0 , por lo que devuelve [[], []] aquí.

El átomo de índicesJ descarta los elementos del valor de retorno y los reemplaza con sus índices, produciendo el rango [1, 2] en este caso específico. Ȧy ṫambos funcionan como antes, por lo que reducen [1, 2] al postfix que comienza en el último índice, produciendo [2] .

En enlaces niládicos, la constante se ⁸mantiene [] . Esta es una nilad no analizable, es decir, no cabe en la cadena de ninguna manera. Como resultado, el valor de retorno anterior ( [2] ) se imprime en STDOUT, luego se reemplaza con el valor de nilad ( [] ).

Como [] es falso, lo Ȧtransforma en 0 . El Játomo promueve 0 a [0] , luego devuelve la lista de sus índices ( [1] ), que se imprime implícitamente cuando finaliza el programa.

22

Otro literal Los Repdigits parecen ser el mejor lugar para usarlos.

“@ṃ»

Esto utiliza la compresión de cadena incorporada de Jelly. Los índices de @ y ṃ en la página de códigos de Jelly son 64 y 220 y los literales de cadena pueden contener 250 caracteres diferentes, por lo que esto primero calcula el entero 250 × 65 + 220 = 16470 .

16470 es divisible por 3, por lo que el cociente 16470/3 = 5490 codifica un carácter ASCII imprimible o un salto de línea. Hay 96 de estos y 5490 = 96 × 57 + 18 , lo que significa que hemos decodificado el carácter ASCII imprimible en el índice 18 basado en 0 , que es '2' .

Nos queda 57 , que también es divisible entre 3 , por lo que el cociente 57/3 = 19 = 96 × 0 + 19 codifica el carácter ASCII imprimible en el índice 18 basado en 0 , que es '3' .

Esto deja 0 ; El proceso de decodificación se detiene. Los caracteres generados se concatenan para formar "23"

!ḤḤ!

El átomo factorial! convierte el argumento implícito 0 en 1 . Dos invocaciones del átomo unhalveḤ convierten 1 en 2 , luego 2 en 4 . Finalmente, !calcula 4! = 24 .

³HH

En ausencia de argumentos de línea de comandos, la constante ³contiene 100 . Dos invocaciones de las Hvueltas 100 en 50 , luego 50 en 25 .

ØaM

La constante Øacontiene el alfabeto en minúsculas. El átomo máximoM produce todos los índices de elementos máximos, y dado que z es la letra minúscula más grande, el resultado es [26] .

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

Veintiséis copias de la concatenar átomo de ;concatenar el valor de retorno inicial 0 y veintiséis instancias del argumento por defecto 0 , la construcción de una serie de 27 ceros.

¬es el átomo lógico NOT , por lo que ;¬agrega un 1 a la matriz de ceros. El siguiente ¬niega todos los elementos en la matriz, dejándonos con una matriz de 27 unidades y 1 cero.

ḅes la unbase átomo y convierte una matriz de dígitos de su argumento izquierdo de la base especificado en su argumento de la derecha a un entero. ḅ¬convierte de unario a entero, por lo que simplemente realiza una suma. Para una matriz de 27 unidades, esto devuelve 27 .

irið8c

El índice del átomo ipromueve su argumento izquierdo 0 a [0] , luego encuentra el índice de su argumento derecho 0 en esa matriz, produciendo 1 .

El átomo de rangor construye un rango ascendente o descendente desde su argumento izquierdo al derecho. El argumento correcto es el argumento implícito 0 , por lo que esto produce [1, 0] . Una segunda invocación de iencuentra el índice de 0 en [1, 0] , produciendo 2 .

ðcomienza una nueva cadena diádica. Como la cadena anterior era niládica, tanto el argumento izquierdo como el derecho de esta cadena serán iguales al valor de retorno de la primera cadena ( 2 ). cen las combinaciones atomo. Con el argumento izquierdo 8 y el argumento derecho 2 , cuenta todas las combinaciones 2 únicas y desordenadas de un conjunto de 8 elementos, devolviendo 8C2 = 8! / (6! 2!) = 28 .

⁶ḲĠṂ°İṂĊ

La constante ⁶contiene un carácter de espacio y establece el argumento y el valor de retorno en '' . Las palabras átomo Ḳpromueven el carácter '' a la cadena singleton "" y lo divide en espacios, produciendo [[], []] .

El átomo del grupoĠ agrupa todos los índices de elementos iguales. Como ambos elementos del último valor de retorno son iguales, devuelve [[1, 2]] aquí. El átomo mínimo extrae un elemento mínimo (el único) de esta matriz, produciendo [1, 2] .

El átomo de grado° convierte ambos enteros de grados sexagesimales a radianes, produciendo 1 ° × 2π / 360 ° = π / 180 y 2 ° × 2π / 360 ° = π / 90 . El átomo inverso toma los inversos multiplicativos, produciendo 180 / π ≈ 57.3 y 90 / π ≈ 28.6 .

Luego, Ṃuna vez más toma el mínimo, dando 28,6 . Finalmente, el átomo del techoĊ transforma 28.6 en 29 .

œṡ¹ẆẆTUṖṖṖṖP

El átomo de identidad¹ devuelve 0 para el argumento implícito 0 . El átomo dividido alrededorœṡ promueve sus dos argumentos (ambos 0 ) a [0] , luego divide [0] alrededor de subconjuntos contiguos iguales a [0] . Esto produce [[], []] .

El átomo de la ventana deslizanteẆ construye todas las subconjuntos contiguos de su argumento. La primera instancia transforma [[], []] en [[[]], [[]], [[], []]] , la segunda instancia transforma [[[]], [[]], [[]] , []]] en
[[[[]]], [[[]]], [[[], []]], [[[]], [[]]], [[[]], [ [], []]], [[[]], [[]], [[], []]]] .

El átomo de verdadT enumera todos los índices de elementos de verdad. Ninguna de las matrices en el primer nivel está vacía, por lo que esto produce [1, 2, 3, 4, 5, 6] . El átomo invertidoU invierte esta matriz, produciendo [6, 5, 4, 3, 2, 1] .

Cuatro copias del átomo popṖ eliminan los últimos cuatro elementos, dejándonos con [6, 5] . Finalmente, el átomo del productoP transforma esta matriz en 30 .

31 - 40

ȷ½RṪ

ȷes una abreviatura de 1 × 10 ³ = 1000 . El átomo de raíz cuadrada½ produce 31.6 , que el átomo de rango seR transforma en [1, ..., 31] . Finalmente, el átomo de colaṪ extrae el último elemento, devolviendo 31 .

LµdddddµFL

los átomo de longitudL promueve el argumento implícito 0 a [0] , luego toma la longitud para producir 1 . µcomienza una nueva cadena monádica y el resultado 1 se convierte en su argumento.

Para argumentos x y y , el átomo divmodd produce [x / y, x% y] . Cada llamada tendrá y = 1 , por lo que el resultado siempre será [x, 0] .

La primera llamada comienza con x = 1 , produciendo [1, 0] . dsolo opera en enteros, por lo que se vectoriza en llamadas posteriores. La segunda llamada produce [[1, 0], [0, 0]] , la tercera [[[1, 0], [0, 0]], [[0, 0], [0, 0]]] , y el quinto y último, una matriz de profundidad 5 que contiene uno solo y 31 ceros.

µuna vez más comienza una nueva cadena monádica, y la matriz de antes se convierte en su argumento. los átomo plano noF necesita esta matriz, produciendo una matriz plana de uno solo y 31 ceros. Finalmente, Ltoma la longitud del resultado, devolviendo 32 .

33

Otro repdigito, otro literal.

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ

Cada instancia del átomo de envoltura transforma su argumento z en [z] . Con el valor de retorno inicial de 0 , las 34 instancias juntas producen [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[0]) ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Finalmente, el átomo de profundidadŒḊ calcula la profundidad máxima de la matriz resultante, devolviendo 34 .

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

La ventana existe atom ẇpromueve sus dos argumentos (ambos predeterminados a 0 ) para [0] , luego prueba si ** [0] ** ocurre como un subconjunto contiguo de [0] . Lo hace, por lo que ẇdevuelve 1 .

ɓcomienza una nueva cadena diádica. Como la cadena anterior era niládica, tanto el argumento izquierdo como el derecho de esta cadena serán iguales al valor de retorno de la primera cadena ( 1 ). La cadena utiliza dos átomos diádicos diferentes: desplazamiento a la izquierda ( æ«) y OR ( |) a nivel de bits .

Una cadena diádica que comienza con tres o más díadas inicialmente llama a la primera díada con los argumentos de la cadena. Aquí, esto da 1 << 1 = 2 . Las seis díadas posteriores se agrupan en pares (denominadas horquillas ), donde la díada más a la derecha se llama primero con los argumentos de la cadena, luego la más a la izquierda se llama con los valores de retorno anteriores a ambos lados.

Para æ«æ«, obtenemos 2 << (1 << 1) = 2 << 2 = 8 . Entonces,æ«æ« calcula 8 << (1 << 1) = 8 << 2 = 32 . Ahora, |æ«nos consigue 32 | (1 << 1) = 32 | 2 = 34 .

Finalmente, el rastro |actúa como un gancho y se llama con el valor de retorno anterior como argumento izquierdo y el argumento derecho de la cadena como derecho. Esto devuelve 34 | 1 = 35 .

⁹ṚḢ²

En ausencia de un segundo argumento, la constante ⁹tiene 256 . El átomo inverso promueve 256 a la matriz [2, 5, 6] y lo invierte para producir [6, 5, 2] . Luego, el átomo de cabezaḢ extrae el primer elemento, y el átomo cuadrado² devuelve ** 6² = 36 *.

‘‘‘0‘‘‘‘‘‘‘

El incremento átomo ‘incrementa su argumento 1 , por lo que ‘‘‘a su vez el valor de retorno inicial 0 en 3 . El siguiente 0 es un nilad no analizable, es decir, no cabe en la cadena de ninguna manera. Como resultado, el valor de retorno anterior ( 3 ) se imprime en STDOUT, luego se reemplaza con el valor de nilad ( 0 ).

Las siguientes 7 copias de ‘convertir este 0 en 7 , que se imprime implícitamente cuando finaliza el programa.

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

El decremento átomo ’decrementa su argumento 1 , por lo que treinta y ocho copias a su vez el valor de retorno inicial 0 en -38 . El átomo de diferencia absolutaạ calcula la diferencia sin signo entre -38 y el argumento implícito 0 , devolviendo 38 .

-____---__________

-es una abreviatura de -1 y establece el argumento del enlace y el valor de retorno en -1 . Cada uno _es una instancia de la diádica átomo de sustracción , cuyo argumento correcto tendrá un valor predeterminado de -1 si falta.

Primero, -____-calcula (-1) - (-1) - (-1) - (-1) - (-1) = 3 . El siguiente -1 es un nilad no analizable, por lo que el valor de retorno anterior ( 3 ) se imprime en STDOUT, luego se reemplaza con el valor del nilad ( -1 ).

A continuación, -_calcula (-1) - (-1) = 0 , donde el literal -establece el argumento izquierdo_ y usa el valor de retorno como el derecho. Las siguientes nueve copias _restan el argumento predeterminado -1 del valor de retorno, produciendo 9 , que se imprime implícitamente cuando finaliza el programa.

”(O

”(es un carácter literal y el ordinal átomoO busca su punto de código Unicode, produciendo 40 .

41 - 47

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

En ausencia de un tercer argumento de línea de comando, la constante ⁵contiene 10 . El átomo de longitud libreḶ crea un rango basado en 0, específicamente [0, ..., 9] para el argumento 10 , a ambos lados del átomo de repetición en el lugarx . Este último hace coincidir elementos de su argumento izquierdo con repeticiones de su argumento derecho, y repite cada uno de los elementos el número correspondiente de veces. Con [0, ..., 9] como argumento izquierdo y derecho, obtenemos ceros cero, uno, dos, etc.

El índice en el átomo ịobtiene el elemento de su argumento derecho en el índice especificado en el izquierdo. Con argumento izquierdo 10 ( ⁵a su izquierda) y argumento derecho [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (resultado anterior), esto da 4 .

La cadena hasta este punto es seguida por una nilad no analizable ⁵, por lo que el valor de retorno anterior ( 4 ) se imprime en STDOUT, el valor de retorno se establece en 10 y el resto de la cadena se analiza como de costumbre.

Como antes, ⁵ḶxḶproducirá la matriz [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, ..., 9] . Esta vez, llamamos al átomo ordenadoṢ en el argumento 10 , que promueve 10 a [1, 0] , luego lo ordena para obtener [0, 1] . El átomo de cabeza diádica ahora obtiene los prefijos de longitudes 0 y 1 del resultado a la izquierda, dejándonos con [[], [1]] . Cuando se imprime, nada más que 1 permanecerá visible.

⁽{ʂ%⁽{}

⁽y sus dos siguientes caracteres constituyen un literal numérico. Si j y k son sus puntos de código en la página de códigos de Jelly y (j, k) <(124, 250) , obtenemos el número entero 1001 + 250j + k . Los puntos de código de '{' , '}' y 'ʂ' son 123 , 125 y 167 , por lo que el literal izquierdo se evalúa a 1001 + 250 × 123 + 167 (= 31918) , mientras que el derecho se evalúa a 1001 + 250 × 123 + 125 (= 31876) .

Dado que el entero izquierdo es menos del doble del grande que el derecho, el resultado es (... + 167)% (... + 125) = (... + 167) - (... + 125) = 167-125 = 42 .

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

La reproducción aleatoria átomo Ẋcambia aleatoriamente el orden de los elementos de su argumento; un argumento numérico z se promueve al rango [1, ..., z] de antemano. Para el argumento implícito 0 , este rango está vacío y Ẋproduce [] . El todo átomo Ạdevuelve 1 si todos los elementos de su argumento son Truthy, 0 en caso contrario. Como una matriz vacía no contiene elementos falsos, Ạdevuelve 1 aquí.

El zip con el átomo ż(una díada) toma argumentos x e y y transpone el par [x, y] . Para los enteros x e y , esto simplemente produce [[x, y]] , por lo que este particular ż, llamado con argumentos 1 y 0 (el argumento implícito), devuelve [[1, 0]] . El átomo de evaluación diádicov convierte todas las matrices planas (que contienen solo números y caracteres) en el argumento izquierdo en cadenas, luego evalúa las cadenas resultantes como programas Jelly monádicos con su argumento derecho como argumentos de los programas. Desde ["10"]consiste únicamente en literales, esto ignora el argumento correcto vy simplemente da como resultado [10] .

La copia se© adjunta rápidamente vy copia su resultado en el registro. Las apariciones posteriores del átomo de recuperación® (un nilad) obtendrán [10] del registro.

Las siguientes tres copias del żvtrabajo como antes, asignando [10] a [[10, 0] a [100] a ... a [10000] . El átomo de ordenọ prueba cuántas veces su argumento izquierdo es divisible por el derecho, por lo que aquí, calcula el orden de 10 (obtenido con ®) en 10000 = 10 ⁴ , produciendo [4] .

El siguiente ®es un nilad no analizable, por lo que el valor de retorno anterior ( [4] ) se imprime en STDOUT, luego se reemplaza con el valor del nilad ( 10 ). Aplicamos a Ạcontinuación, produciendo 1 . (Esto se requiere ya que una nilad seguida de una díada sería analizable en este punto).

Como antes, żvżvżvagrega tres ceros al valor de retorno actual, convirtiendo 1 en [1000] . Finalmente, ọ®calcula el orden de 10 en 1000 = 10 ³ , y 3 se imprime en STDOUT cuando finaliza el programa.

44

Sin embargo, otro repdigito, otro literal.

111111l11&K1111111Kl11&

En primer lugar, el literal 111111establece el argumento y el valor de retorno inicial en 111111 . Las otras corridas 1también son literales.

les el átomo de logaritmo , que calcula el logaritmo de su argumento izquierdo a la base especificada en el derecho. Cuando se invoca 111111 con el argumento correcto 11 , obtenemos log ₁₁ 111111 ≈ 4.85 .

Las palabras átomo se Kune a un argumento de lista en espacios, después de promover un carácter numérico / z a [z] . Aquí, simplemente lo usamos para convertir el argumento 111111 del enlace en [111111] . (No requerimos una matriz aquí, pero nos hemos quedado sin átomos de identidad). El átomo AND bit a bit& toma los valores de retorno a ambos lados, los convierte en enteros si es necesario, y calcula su AND bit a bit. En este caso particular, devuelve [4.85 y 111111] = [4 y 111111] = [4] .

El siguiente 1111111es un nilad no analizable, por lo que el valor de retorno anterior ( [4] ) se imprime en STDOUT, luego se reemplaza con el valor del nilad ( 1111111 ). Kluego convierte este número entero en [1111111] . (Una vez más, esto no es realmente necesario, pero una nilad seguida de una díada sería analizable en este punto).

Como antes, l11calcula el registro ₁₁ 1111111 ≈ 5.81 , luego &devuelve [5.81 y 111111] = [5 y 111111] = [5] .

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

Este es el único programa que consta de múltiples enlaces definidos por el usuario. El último enlace es el enlace principal y se ejecuta cuando se inicia el programa, los restantes son enlaces auxiliares. El rápido Çsiempre se refiere al enlace sobre el actual y lo ejecuta monádicamente. Del mismo modo, el rápido Ñsiempre se refiere al enlace debajo del actual (envolviendo) y también lo ejecuta monádicamente.

El enlace superior consiste en el átomo par, , una díada que convierte los argumentos x e y en [x, y] , y el átomo de sumaS , una mónada que promueve un argumento entero z a [z] y reduce un argumento de matriz por adición. Cuando ,SSse llama al enlace con un argumento entero n , calcula Σ [n, Σn] = Σ [n, n] = 2n .

El enlace del medio consiste en los átomos anteriores, el rápido mencionado anteriormente Çy el átomo insignificanteỊ , una mónada que produce 1 para argumentos numéricos z con -1 ≤ z ≤ 1 , pero 0 para todos los demás. Aplicar Ịdos veces a un argumento entero n esencialmente lo reemplaza por 1 , ya que la salida del primero Ị(la entrada del segundo) siempre es insignificante. Este resultado se combina con el valor de retorno de Ç(llamado con el argumento n ), y el par resultante se reduce en S. En total, calculamosΣ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1 .

Con estos dos enlaces auxiliares en su lugar, el enlace principal ahora puede construir cualquier número entero no negativo mirando sus dígitos binarios. Con un valor de retorno inicial de 0 , la cadena ÇÑÇÇÇÑcalcula el resultado final ((((((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

El siguiente átomo primo encuentra el número primo positivo más pequeño que es estrictamente mayor que su argumento. Con el valor de retorno inicial 0 , quince invocaciones de Æncalcular el decimoquinto número primo, que es 47 .

brainfuck , la puntuación de 2, 255 144 10 bytes

... Sí, no es la mejor idea, ya que solo tengo 8 caracteres (las lonas van a jugar), pero veamos cuánto es posible. Creo que esto es todo lo que es posible. : P Esta respuesta demuestra seis de los ocho caracteres que utiliza Brainfuck, siendo los otros dos ,, que es entrada y .salida.

+
>--[<->-]

¡Visualízalo en línea!

Explicación

Cada número se crea y almacena en la celda inicial de la cinta. Se basa en gran medida en las celdas de ajuste, que no se implementan en algunos intérpretes.

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 , puntaje 38, 327 bytes

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: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

Explicación:

• Para 1, usamos el token 'verificar la igualdad', explotando aquí que cuando Neim intenta hacer estallar una entrada vacía, obtiene 0. Como 0 y 0 son equivalentes, esto empuja a 1 que se imprime implícitamente
• Del 2 al 9, solo usamos literales numéricos.
• Del 10 al 32, Neim en realidad tiene constantes de un byte para todos ellos (sí, es una locura).
• Para 33, solo usamos el comando de incremento. En el primer byte, Neim intenta hacer estallar algo para poder incrementarlo, pero como la entrada está vacía, el valor predeterminado es estallar 0.
• Para 34, usamos el mismo enfoque, pero decrementamos y tomamos el valor absoluto.
• Para 35, estamos explotando el hecho de que factorial cero es uno, y lo usamos duplicando el uno y agregando repetidamente
• Para 36, ​​usamos ℂpara verificar 0 y 0 para co-primalidad, que son. Esto empuja 1. Luego obtenemos el primer primo usando 𝐋, lo que resulta en una lista singleton que contiene solo 2. Luego obtenemos el elemento más grande ( 𝐠), que empuja 2 como número. Luego repetimos este proceso hasta que obtengamos la lista [2 3 5 7 11]. Después de eso, usamos 𝐝para calcular los deltas, dando como resultado la lista [1 2 2 4]. Luego, usamos 𝐬para obtener la suma, que es 9, luego calculamos el rango exclusivo de 0 a 9, lo que resulta en [0 1 2 3 4 5 6 7 8]. Finalmente, 𝐬se usa nuevamente para obtener 37.
• Para 37, αes una constante que representa una negativa, y repetidamente la presionamos y restamos (nuevamente explotando el hecho de que cuando intentamos hacer estallar una entrada vacía, se presiona 0)
• Para 38, una vez más usando el 0 predeterminado para la entrada vacía, seguimos agregando 0 a sí mismo, creando una lista larga y luego calculando la longitud.

Puede ser probado aquí

Pitón 2, 15

Aquí hay un comienzo, buscando más

Gracias a leo, cuyo consejo me ayudó a llegar 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 bytes, puntaje 42

Una gran colaboración entre Shaggy , ETHproductions y 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

Estos caracteres (útiles) quedan:

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

---

Explicaciones

Un par de cosas que debes saber sobre Japt antes de comenzar, que he utilizado con frecuencia. En primer lugar, Japt tiene 6 variables reservadas para la entrada, que son las letras mayúsculas U-Z. Si no se pasa ninguna entrada a través de esas variables, todas tienen el valor predeterminado 0. Lo segundo está cubierto en este consejo .

Haga clic en cualquier fragmento para probarlo en el intérprete en línea .

---

v

Cuando se aplica a un número, el v método toma un número entero n como argumento, y devuelve 1 si el número es divisible por n , 0 si no. Si no se proporciona n , el valor predeterminado es 2 . 0 (el valor predeterminado para U) es divisible por 2 , por lo que nos da nuestro 1 .

---

y

Muy similar al primero. Cuando se aplica a un número, el ymétodo toma un número entero n como argumento y devuelve el MCD de los dos números. Si no se proporciona n , el valor predeterminado es 2 . Como 0 es divisible por 2 , GCD (0, 2) nos da nuestro 2 .

---

Íà

Íes el atajo para n(2)o 2- this. Porque no tenemos ninguna entrada, que por defecto thisa 0, lo que resulta en 2-0 = 2.

àdevuelve el número de combinaciones de [1...this], que devuelve 3

---

Qiiii)iiii)âQ

Qel valor predeterminado es una comilla simple. ien una cadena inserta otra cadena al principio; como se explica en el n . ° 3 , cada uno iiii)es equivalente a .i("i".i("i"))JS, insertando dos copias ial principio de la cadena. Haz esto dos veces y tienes la cuerda iiii". âQluego simula .search(Q), dando el índice del primero "en la cadena, que es 4 .

---

ÂHq

Hes la constante para 32 . Cuando se aplica a un número del qmétodo, que se lleva número entero n como un argumento, devuelve el n ^º raíz de ese número. Si no se proporciona n, el valor predeterminado es 2, por lo Hqque nos da la raíz cuadrada de 32, que es aproximadamente 5.6568 . Âes el acceso directo para ~~, que da el resultado, dándonos 5 .

---

LÁL

Lestá preestablecido en 100 y Áes el acceso directo para >>>(desplazamiento a la derecha de relleno cero a la derecha). 100>>>100es lo mismo que 100>>>4(el operando correcto envuelve mod 32), que es 6 .

---

´Vn´VnVnVn

Como se señaló anteriormente, el valor Vpredeterminado es 0 . ´es el acceso directo para el --operador, por lo que el código es equivalente al siguiente JS:

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

X.n(Y) es equivalente a Y - X , o -X + Y ; el primero --Vdevuelve -1 y el segundo -2 , por lo que es aproximadamente equivalente a - (- 1) + (- (- 2) + (- (- 2) + - (- 2))) . Simplificando, obtenemos 1 + 2 + 2 + 2 = 7 .

---

8
9

Literalmente, 8 y 9 .

---

A
B
C
D
E
F
G

Estas son las constantes de 10 - 16 , inclusive.

---

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

Jestá preestablecido a -1 . El intérprete de Japt de alguna manera logra analizar esto correctamente, como (J--) - (--J) - (--J) - (--J) - (--J). Haciendo un poco más de matemáticas, encontramos que esto es equivalente a (-1) - (-3) - (-4) - (-5) - (-6) , o -1 + 3 + 4 + 5 + 6 = 17 .

---

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

¾ es, como puede suponer, un atajo para .75 . Ponemos 24 copias de 0.75 en una matriz, luego sumamos con x, dando 0.75 * 24 = 18 .

---

;Iìw

Creo que este es mi favorito. ;al comienzo del programa cambia los valores de algunas de las constantes de Japt; sin ella Ies 64 , pero con ella Ies 91 . ìwlo convierte en una lista de dígitos y se ejecuta wen la lista, invierte la matriz, luego vuelve a convertirlo en un número para obtener 19 .

---

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

½es un acceso directo para .5. een un número x toma un argumento y y devuelve x * 10 ^y . Entonces, la cadena de cálculos que sucede es:

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

Y la final ~~sirve para poner esto en un número entero, produciendo nuestro resultado de 20 .

---

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

Testá preestablecido a 0 . ++es el operador de incremento en JS y también en Japt; T+++Tse analiza como (T++) + T, pero ++T+++Tse analiza como (++T) + (++T), por lo que esto es equivalente al código JS

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

El resultado es 1 + 2 + 3 + 4 + 5 + 6 , que suma 21 .

---

22

Un literal 22 .

---

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

Äes un atajo para +1, así que esto simplemente suma 23 1 s.

---

4á

¡Esto encuentra el número de permutaciones de [1, 2, 3, 4], que es 4! = 24 .

---

5²

²es un atajo para p2, que eleva un número a la potencia de dos. 5 ** 2 es 25 .

---

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

°es un acceso directo para el ++operador, o si no se puede analizar como tal, + +. Como se señaló anteriormente, cuando no hay entrada, el valor Upredeterminado es 0 . Entonces, el código es equivalente a (++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U), que es muy similar al # 17 : Uprimero se incrementa 1, luego se incrementa y agrega repetidamente de modo que el resultado final sea 1 + 3 + 4 + 5 + 6 + 7 = 26 .

---

»³³

³es el acceso directo para el pmétodo con un argumento de 3 . Sin embargo, si una letra minúscula aparece directamente después de un paréntesis izquierdo ( »es el acceso directo para ((), se convierte en una cadena. Esto le permite pasar a un método y llamarlo como una función (es decir m³, sería mapeado por .p(3)). En este caso, sin embargo, ("p",3)devuelve nuestro 3, luego lo elevamos al poder de 3( pes el método de poder cuando se aplica a un número), lo que nos da nuestro 27 .

---

7/¼

¼, como probablemente ya sepa, es un atajo para .25, así que esto calcula 7 / 0.25 = 28 .

---

$'_____________________________b'$bb

Cualquier cosa envuelta en $símbolos se trata como JavaScript puro, por lo que tenemos una cadena de 29 guiones bajos seguidos de a b. (Sin el $, 'sería una cadena de un solo carácter). El bmétodo cuando se aplica a una cadena devuelve el primer índice de su argumento dentro de esa cadena. Como se explica en el n . ° 3 , el último bse convierte en una cadena, por lo que estamos tomando el primer índice de bnuestra cadena, que es 29 .

---

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

µes un atajo para -=y Épara -1. El efecto es restar 30 copias de -1 de 0 , lo que da 30 .

---

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

Muy parecido al # 29. El amétodo, cuando se aplica a una cadena, devuelve el último índice de su argumento en esa cadena. Usando 0-indexing, el último índice de aen una cadena de 32 as es 31 .

---

Sc

Sestá predefinido a un solo espacio, y cen una cadena de un solo carácter devuelve su código de carácter, dando 32 .

---

33

Literal 33 .

---

Mg011

MgNdevuelve el enésimo número de Fibonacci. 011es 9 en octal; el noveno número de Fibonacci es 34 .

---

##

#devuelve el código de carácter del siguiente carácter. El código char en #sí mismo es 35 , lo que hace que nuestro trabajo aquí sea especialmente fácil.

---

6p

pes exponenciación, y sin un segundo argumento, el valor predeterminado es 2 ; así, esto imprime 6 ** 2 = 36 .

---

Rí í í í í è.

Este es bastante complicado. Rel valor predeterminado es un solo carácter de nueva línea (que es una nueva línea se vuelve importante más adelante). íen una cadena, sin ningún argumento, toma cada carácter y agrega su índice: una transformación bastante inútil, pero el resultado a través de 5 iteraciones es este: (usando en Rlugar de una nueva línea literal)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

Interesante cómo cada entrada es simplemente un prefijo de la siguiente ... Pero de todos modos, la última parte è., cuenta cuántas coincidencias /./gse encuentran en el resultado. Hay 38 caracteres en la cadena; sin embargo, dado que /./gsolo coincide con caracteres que no son de nueva línea, el resultado es 37 .

---

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

Los backticks marcan una cadena comprimida y se ¥descomprimen en ll. len una cadena da lprofundidad, así que después de la descompresión, esto da 38 .

---

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

Oooh chico, este es un doozy. Primero, generamos truecon ¨N( ¨significa >=, y Nsin entradas es la matriz vacía), luego lo convertimos a 1con |N. A partir de ahí se vuelve bastante loco:

ò    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]

(Los ¹s son solo sustitutos de parentescos cercanos y se han omitido). El final oaparece y devuelve el elemento final en la matriz, dando 39 .

---

º¤¤*º¤

Principalmente el mismo truco que con el # 3 . ¤es el acceso directo para el smétodo con un argumento de 2 . En este caso, sin embargo, el código es transpiled (("s", 2).s(2) * (("s", 2) * (("s", 2))))o simplificado, (2).s(2) * (2 * 2). .s(2)devuelve el número como una cadena de base 2, que da "10"; * (2 * 2)implícitamente convierte esto en un número y se multiplica por 4 , dando 40 .

---

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

Similar al anterior. Åes el acceso directo para el smétodo con un argumento de 1 . En este caso, sin embargo, cada uno se (Åtransfiere a ("s", 1), que solo devuelve 1 . 1<<1<<1<<1<<1<<1es 32 y 1<<1<<1<<1es 8 ; estos son XORed junto con 1para obtener 41 .

---

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

±es un atajo para +=y ¶para ===. Esto significa que el código es en realidad

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

Y===Y siempre es cierto, por lo que podemos simplificar esto:

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, puntaje 17, 130 Bytes

personajes utilizados 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 constante booleana Z (no establecida) igual constante Z

2 FTP_MOREDATA es una constante en PHP con el valor 2

3 bit a bit y caracteres; y W

4 bit a la izquierda Desplazar a la izquierda y lógico no convertir la matriz vacía a booleana verdadera con convertir al entero 1 a través del operador de desplazamiento a la izquierda

7 bitwise O caracteres # y $ y 1

9 SIGKILL es una constante en PHP con el valor 9

10 bits a la derecha Desplazar a la derecha cada paso es una división entera con 8, por lo que tenemos los pasos 333333, 41666, 5208, 651, 81, 10

13 cuenta char X en la cadena X ... desde el principio

15 valor hexadecimal f = 15

17 bitor Xor con las cuerdas ha y YV

Todos los fragmentos son elementos de una matriz.

Pruébalo en línea!

PHP, puntaje 16, 94 bytes

personajes utilizados 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 constante booleana Z (no establecida) igual constante Z

2 bitwise y caracteres: y w

3 Pi convertidos a valor entero a través de una matriz vacía convertida a cero

7 bits xor caracteres A y v

¡10 variables $ s no configuradas! $ S = una concat con longitud de cadena de la variable $ s

13 111/2 = 55/2 = 27/2 = 13 División entera a nivel de bits

15 valor hexadecimal f = 15

Todos los fragmentos son elementos de una matriz.

Pruébalo en línea!

PHP, puntaje 14, 84 bytes

personajes utilizados $!_^[]()%/+~-=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 constante booleana Z (no establecida) igual constante Z

3 Pi convertidos a valor entero a través de una matriz vacía convertida a cero

7 ERA es una constante con el valor 131116 mod 11 = 7

10 variable $ s no establecida! $ S = un concat con longitud de cadena de la variable $ s es cero

13 valor hexadecimal d = 13 14 bit a bit no y el signo menos eleva NULL a 14

Todos los fragmentos son elementos de una matriz.

Pruébalo en línea!

R, puntaje 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

Conseguí uno extra gracias al usuario 2390246.

Caracteres utilizados:

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

MATL , puntaje 21 22 23 números (273 bytes)

¡Gracias a J Doe por extender de 22 a 23 números!

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@@<

Pruébalo en línea!Cada fragmento del enlace finaliza con D(display) o ]D(close loop explícitamente y display) para borrar la pila y aislarlo del siguiente fragmento.

Explicación

0~

Empujar 0. Negar. Da true, que se muestra como 1.

'bd'd

Cadena de empuje 'bd' . Diferencia consecutiva entre los puntos de código de los personajes.

{P}gk

Empuje la matriz de celdas que contiene el número pi . Convierte a matriz numérica (es decir, a un solo número). Redondear a la baja.

HH^

empujar 2 dos veces. Poder.

5

Literal numérico.

6

Literal numérico.

7

Literal numérico.

8

Literal numérico.

9

Literal numérico.

3 3.333333333333333*

Empujar 3. Empujar 3.333333333333333. Multiplicar. Debido a la precisión del punto flotante esto da10 .

11

Literal numérico.

IEE

Empujar 3. Multiplicar por2 dos.

[B]Yq

Empujar [6](que es lo mismo que 6). Calcular n -ésima prima.

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

empujar 1 14 veces. Número de elementos en la pila. Despeja el resto de la pila.

KUKUa-

Empujar 4. Cuadrado. Hacer lo mismo. Cualquiera: da 1. Sustraer.

4W

Empujar 4. 2elevado a eso.

FFFFFFFFFFFFFFFFFn

Empuje la matriz [false false ... false](17 veces). Número de elementos en la matriz.

TTTTTTTTTTTTTTTTTTs

Empuje de matriz [true true ... true](18 veces). Suma de matriz.

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

Empuje 19 números aleatorios tomados del intervalo (0,1). Concatenar horizontalmente 18 veces. Número de elementos distintos de cero en la matriz.

OOOOOOOOOOOOOOOOOOOOvZyX>

Empuje 020 veces. Concatena el contenido de la pila verticalmente (da un vector de columna). Tamaño: da la matriz [20 1]. Máximo de matriz.

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

Empuje 1j(unidad imaginaria) 21 veces. Añadir 20 veces. Dividir por 1j.

22

Literal numérico

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Hacer ... while loop ( `) con final implícito. En la primera iteración, empuja el índice de iteración ( @) y lo incrementa (Q ) 22 veces, lo que produce 23. La condición de bucle ( @@<) es falsa, por lo que se cierra el bucle.

Algunas ideas para mejorar

• (espacio) en el fragmento 10 podría reemplazarse por |
• X> en el fragmento 20 podría ser reemplazado por p , liberando así el prefijo X.
• Actualmente no se usa y potencialmente útil: :,A

Vim 8 en Windows, puntaje 13, 104 bytes

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}representa <C-{keystroke}>, así ^Xes <C-x>, excepto por^@ que es <C-j>. Todavía estoy tratando de agregar más números a esta lista y <CR>representa un salto de línea.

Nota: para ejecutar estos comandos, inicie vim usando -u NONE -U NONE . Esto es para asegurar que sus configuraciones no interferirán con el código.

Los fragmentos del 1 al 10 comienzan en modo de inserción. Mientras que los fragmentos 12 y 13 comienzan en modo normal.

Explicaciones

El fragmento 8 es :^R=&ts^@. Tengo que agradecer a @ L3viathan para dar con esto y @ nmjcman101 por sugerir ^@como un reemplazo para el avance de línea y @ ØrjanJohansen para acortar &tabstopa &ts.&tsluego evalúa el tamaño de la pestaña, que por defecto es 8, y este valor se inserta en el editor.

El fragmento 10 es 8^O^A^O^A . Insertamos un 8 y luego lo incrementamos dos veces para obtener 10.

El fragmento 11 es 0^[^X^X^X^X^X^X^X^X^X^X^X0x. Escribimos un 0 y lo disminuimos 11 veces para obtener -11. Luego eliminamos el menos para obtener 11.

El fragmento 12 es :h<CR>wwwwwwwwwwwy$:q<CR>p. Esto abre el menú de ayuda de Vim 8, que contiene la siguiente información:

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

Y la secuencia de ws se mueve al 12, en cuyo punto y$copia el número. Luego se pega en el editor usando p.

Snippet 13 es grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDgracias a @DJMcMayhem por proponerlo. Esto solo funciona en Windows. El fragmento busca en el menú de ayuda los comandos que comienzan con g. Luego se mueve hacia abajo usando jpara llegar a esta línea:

|g?|        g?      2  Rot13 encoding operator

después de lo cual lo copia y lo pega en el búfer. Después de eso, todo menos el 13 se elimina del búfer.

Mathematica, puntaje 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 , puntaje 18, 67 bytes

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

Pruébalo en línea!

Ping pong , puntaje 127

En PingPong, cada personaje tiene su propio valor numérico distintivo, lo que hace que contar hasta 127 sea una tarea trivial. El lenguaje funciona leyendo el valor de cada personaje y empujándolo a la parte superior de una pila, donde se realizan todas las operaciones. PingPong teóricamente puede pasar de 127 pero requeriría pasar un bloque de caracteres que simplemente aparecen como espacios en un editor de texto, por lo que los dejé fuera de mi solución.

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: ÿ

Octava, puntaje 14, 74 bytes

Estoy bastante seguro de que estoy cerca del límite ahora.

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

Tenido que quitar strchrpues ya tengo cen el número 10. Todavía tengo j, ^, =,! , espacio y tabulador horizontal (ASCII-9) a la izquierda, lo que podría ser posible exprimir uno más en.

La pestaña horizontal se puede usar como un espacio, por lo que el truco se usa con strchry nnzse puede usar una vez más. Las únicas letras minúsculas que quedan son abdfgjkmoquvwxy. No hay muchas funciones que se puedan hacer con estas.modpodría funcionar, pero no puede tomar la entrada de cadena.

Es fácil usar los caracteres restantes para obtener 1, pero no sé cómo puedo obtener nada más.

Prueba todo .

Posiblemente útil: fun aes lo mismo que fun('a'), fun a bes lo mismo fun('a','b')y así sucesivamente. Esto se puede usar en varios lugares:

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

Usar esto estará 0disponible, pero no puedo ver cómo hacerlo útil todavía.

e (2.71828...)y jtodavía no se usan. Sin embargo, debe eliminar ceilpara usar e.

Alternativas (inspiración):

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 enteros, 137 130 128 bytes

Tomé respuesta @ETHproductions' y corrió con ella durante un tiempo; ha cambiado tanto que lo estoy publicando por separado. Las ideas son bienvenidas. :)

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

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

O, si el fragmento de 1 se reemplaza con !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

---

JavaScript (ES7), 16 enteros, 127 bytes

Un byte más corto. :PAGS

""**""
-~-~{}
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

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

Dyalog APL, puntaje 15, 89 bytes

≡''
≢###
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

_{Las nuevas líneas anteriores l:lson parte de 12.}

_{Los espacios en 14 representan pestañas.}

> <> , puntaje 20, 93 90 74 65 bytes

(3 bytes guardados por Teal Pelican, ¡muchos bytes guardados por 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::+:++:+:+

¡Pruébalos en el parque de peces! Puede hacer que los fragmentos impriman sus resultados agregándolos n;al final de cada uno. Tenga en cuenta que el noveno fragmento contiene una pestaña, que se come mediante el intercambio de pila.

Explicación:

• En iii((, cada uno iintenta obtener entrada, pero como no hay ninguno, empujan EOF = en su -1lugar. Luego (está la instrucción menor que, y como -1no es menor que -1, empuja una falsey 0; pero el segundo (pregunta si -1es menor 0, que es, por lo que empuja una verdad 1.
• 2y 3son obvios
• Para ll{lll{[, el primero lempuja la longitud de la pila, que es 0, luego el segundo empuja la nueva longitud, trayendo la pila a 0, 1. Los {gira la pila a la izquierda, el intercambio de 1e 0. Tres ls más traen la pila 1, 0, 2, 3, 4. Luego {gira el 1frente y [saca la primera 1cosa de la pila, que es 4.
• 5, 6, 7Y 8son evidentes también.
• En !\t00=0g(donde \trepresenta una pestaña), !omite la pestaña, luego 00=empuja dos ceros y comprueba si son iguales, lo son, por lo que obtenemos una verdad 1. Después de presionar otro 0, gobtiene el carácter en la posición 1,0del código, que es la pestaña con el código del carácter 9.
• ahasta fcada impulso 10a 15respectivamente (presumiblemente para hacer hexadecimal agradable).
• 44*empuja dos 4sy los multiplica, para 16.
• 'RA'empuja los códigos de caracteres de Ry A(82 y 65 respectivamente) a la pila, luego %calcula 82 mod 65 = 17.
• 999-9--evalúa a 9 - ((9 - 9) - 9) = 18.
• "&F#"empuja los códigos de caracteres de &, Fy #, que son 38, 70y 35respectivamente. Entonces ,hay división, así que obtenemos 38 / (70 / 35) = 19.
• Finalmente, 1::empuja 1ay lo duplica dos veces, +agrega dos de las juntas para obtener 2; :+duplica el 2y lo agrega a sí mismo para obtener 4; +agrega los restos 1para obtener 5; luego :+:+duplica y agrega dos veces, lo que resulta en 20.

Esta es la puntuación máxima posible con> <>. Cualquier fragmento debe incluir una instrucción alguna parte que convierte una pila vacía en una pila no está vacía, y sólo hay 18> <> instrucciones que pueden hacer eso (a saber i, ly los dígitos 0–9y a–f), más el modo de cadena. (Todas las demás instrucciones no hacen nada a una pila vacía ><v^/\|_#x!{}ro intentan hacer estallar algo y errores ?.+-*,%=():~$@[]on&gp). Al ingresar al modo de cadena se usa uno de los dos "o ', por lo que, como máximo, hay 18 + 2 = 20fragmentos posibles.

---

Si se siente más cómodo con los no imprimibles que yo, esto es posible en 53 bytes, gracias a Jo King:, 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"donde X, Yy Zson reemplazados por caracteres con códigos 17, 19y 20respectivamente.

MathGolf , 48 51 53 enteros, 324 bytes

î
ª∞~
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 puntaje (y -2 bytes distintos utilizados para 40 ) gracias a @maxb .

Cada línea es un programa separado.

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

Explicación y enlaces TIO:

MathGolf es un nuevo lenguaje de golf especializado en desafíos matemáticos de golf. Tiene un montón de incorporaciones de un solo byte para números, lo que lo convierte en un desafío perfecto para él.

1) î: empuje el valor indexado 1 del bucle, que es 1 por defecto: Pruébelo en línea.
2) ª∞~: Presione [1]; doblarlo ([2]); lista emergente e inserte su contenido en la pila: Pruébelo en línea.
3) c±b±+: Empuje -2; luego explote y empuje su valor absoluto; empujar -1; luego explote y empuje su valor absoluto; y agréguelos juntos Pruébelo en línea.
4) φⁿ_¥-: empuje la proporción áurea (1.618033988749895); cúbralo (4.23606797749979); duplicar la parte superior de la pila; tomar módulo 2 (0.23606797749979); restarlos unos de otros: Pruébelo en línea.
5,6,7) Los números mismos: Pruébelo en línea.
8) Pruébalo en línea. 9) : empujar -3; al cuadrado: Pruébelo en línea.○¢i♀/ : empuje 2048; convertir a una cadena hexadecimal (800); emitido a entero; empuje 100; dividir:
d² 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) Empuje incorporados para los números mismos ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): Pruébelo en línea.
39) ♫¼¼¼¼: empuje 10000; dividido en cuatro enteros cuatro veces: Pruébelo en línea.
40) 88888]Σ: Presione 8 cinco veces; envolverlos en una lista; suma esa lista: Pruébalo en línea.
41) El número en sí: Pruébelo en línea.
42) ╔½½½½½½½½½½½: Presione 86400; dividido en entero por 2 once veces: Pruébelo en línea.
43) π░3§3: Presione PI (3.141592653589793); fundido a cuerda; pop y empuje su tercer carácter indexado a 0 (4); empuje 3; genera la pila completa unida implícitamente: 44)Pruébalo en línea. 45) 48)
22#22#: Presione 2 dos veces; tomar el poder de los dos (4); hazlo otra vez; genera la pila completa unida implícitamente: Pruébelo en línea. : Presione 2 * PI (6.283185307179586); pop y empuje el poder de 2 debajo de él que está más cerca (4); empuje la parte superior de la pila + 1 sin reventar (5); genera la pila completa unida implícitamente: Pruébelo en línea. 46) : empuje 64; decremento por 2 nueve veces: Pruébelo en línea. 47) : Push gamma (n + 1) (1 por defecto); incremente en 2 veintitrés veces: Pruébelo en línea. : Empuje el valor ordinal del carácter '0': Pruébelo en línea. 49) : cadena de empuje ; pop y empujar su longitud (4); empuje 9; generar la pila completa unida implícitamente:
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$
ÿ@@@@£9"@@@@"Pruébalo en línea.
50) )))))))))))))))))))))))))))))))))))))))))))))))))): Incremente en 1 cincuenta veces: Pruébelo en línea. : Empuje 1,000,000; Empuje 10,000,000; explotar ambos y dividirlos entre sí (10); empuje 512; pop ambos y enteros-dividirlos entre sí: Pruébelo en línea. 52) : cadena de empuje ; empuje su longitud (sin reventar la cadena); elimina todo de la pila excepto el último elemento: Pruébalo en línea. 53) : Empuje 128; decrementado por 1 setenta y cinco veces: Pruébelo en línea.
51)►◄╠•╠
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

Intentaremos agregar algo más más adelante. Todavía me quedan algunas cosas útiles, incluido el módulo %y la multiplicación *.

Java 8, 11 12 13, 39 bytes

Java solo tiene 10 símbolos para los números (0-9) y todas las llamadas a métodos y constantes requieren un punto, por lo que no estoy seguro de poder obtener más de 11 salidas

Aparentemente, los caracteres se convierten en enteros de forma predeterminada cuando se aplican operaciones

+1 con la ayuda de @ OlivierGrégoire

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

Explicaciones:

i->-~i

entero lambda que no toma entrada y devuelve 1. Cuando un parámetro no toma entrada, el valor predeterminado se usa de acuerdo con la meta publicación anterior, que para enteros es 0

2
3
4
5
6
7
8
9

enteros literales

'P'^'Z'

XOR de dos personajes para devolver 10

11

entero literal

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

expresión lambda que devuelve la longitud de una cadena de 12 caracteres

0xD

Hexadecimal 13

TIO Link si quieres verificarlo.

Gaia , puntaje 25, 203 bytes

§‼
..⌉+⌉
₵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 que este es un puntaje perfecto, ya que no se pueden usar más nilas dadas las limitaciones de los personajes.

Explicaciones

1) §‼

§es un carácter de espacio, ‼es coercitivo a booleano, por lo que el resultado es 1.

2) ..⌉+⌉

.es un atajo para 0.5, así que esto es ceil(0.5+ceil(0.5)).

3) ₵P~~

₵P es pi ~ es negación bit a bit. La doble negación bit a bit es simplemente truncamiento.

4) 4

5) 5

6) 6

7) ∂Ql

∂Qes una lista que contiene los nombres de los días de la semana, les la longitud.

8) 8

9) 9

10) ¶c

Punto cde código de salto de línea ¶.

11) 11

12) '¡ċ⌋u⌋

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

13) --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-es una abreviatura de -1, ⁻es resta. Entonces esto es -1 - -1 - -1...suficiente para hacer 13.

14) 7:,Σ

Empuje 7, duplique :, empareje ,los dos 7 en una lista y sume Σ.

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

Øes una cadena vacía, por lo que Ø!es 1. Incrementa )1 14 veces.

dieciséis. øø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) ⟩‘

Cerrar una cadena con lo ‘convierte en un literal de número base-250. ⟩está en el valor de byte 17 en la página de códigos de 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

Cada uno ]envuelve la pila en la lista. Haga esto 19 veces y obtenga la profundidad nde la lista.

20) ⇑’e

Cerrar una cadena con la ’convierte en una lista de puntos de código de página de códigos. evuelca la lista en la pila.⇑tiene un punto de código de 20 en la página de códigos.

21) 0(((((((((((((((((((((_

Disminuya (0 21 veces, luego niegue _.

22) 22

23) “B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B

Convierta la cadena “B”de base-24, donde están los dígitos de 0-23 ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B. El resultado es 23.

24) 3₈×

3 × 8.

25) ℍḥḥ

100 ℍreducido a la mitad ḥy reducido a la mitad de nuevo.

C, puntaje 13

Estas son solo un montón de constantes enteras.

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==0evalúa a 1
2. Asume que el código está en la línea 2. __LINE__= 2
3. Constante entera
4. Constante entera
5. Constante entera
6. Constante entera
7. Constante entera
8. Constante entera
9. Constante entera
10. 1+1+1...= 1*10= 10
11. 'o'es 111, '.'representa el ASCII no imprimible 0x10. 111/10 = 11
12. (2<<2)= 8, 8*2= 16, 16-2-2= 12
13. longitud de cadena de "strlenstrlens"= 13

Ohm , puntaje 21 22, 160 bytes totales

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

Pruébalo en línea!

Explicaciones

1) ╓S@Ri

Presione los segundos de la fecha / hora actual ( ╓S). Obtenga el rango inclusivo de 1 a segundos ( @), inviértalo ( R), obtenga el último elemento (i ), que siempre es 1.

2) ΓΓ-Γ-Γ-

Γ es -1, entonces esto es (-1) - (-1) - (-1) - (-1), que es 2.

3) αê⌠

αêes el número de Euler (2.71828 ...), ⌠es el techo. 3 es el resultado.

4) ¡¡¡¡¼

¡incrementa el contador, ¼empuja el contador.

5) 5

Solo un literal.

6) ▀lll▀l

▀lll▀es un literal de cadena comprimido que es equivalente a "of >ic". ltoma la longitud, por lo que el resultado es 6.

7) ÑÑÑÑÑÑÑÿWÿk

Primero presionamos 7 caracteres de nueva línea ( Ñ) y luego una cadena vacía ( ÿ). La pila se envuelve en una matriz ( W) y luego se encuentra el índice de la cadena vacía en esa matriz.

8) ü`½½

üEs un personaje espacial. `empuja su valor ASCII (32), luego se reduce a la mitad dos veces ( ½½).

9) 9

Solo un literal.

10) ..≥°

..Es un .personaje literal . Se incrementa ( ≥), lo que analiza la cadena como un número, por defecto a 0 ya que no es un número válido, y lo incrementa a 1. Luego calculamos 10 ¹ ( °).

11) $$J

$ empuja el valor actual del registro, inicialmente 1. Entonces, presione 1 dos veces, una la pila e imprima.

12) 3dd

Presione 3 y duplíquelo dos veces.

13) 7ƒ

Empuja el séptimo número de Fibonacci.

14) 2≡≡≡Σ

Presiona 2, triplicalo tres veces, dejando 7 2 en la pila. Luego toma la suma de la pila ( Σ).

15. ║F

║es el delimitador para literales de base-220. Dado que esto está al final de una línea, no necesita ser terminado.

dieciséis. 4º

Calcular 2 ⁴ .

17) 0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~

ò es negado a nivel de bits, ~ es negado aritmético. Combinando estos operadores, podemos incrementar 0 17 veces.

18) 6DD++

Presione 6, duplíquelo dos veces y calcule 6 + 6 + 6.

19) 8π

Empuje el octavo número primo.

20) τ╛hτ*

Presione 10 ( τ), obtenga el primer elemento ( h) de sus factores primos (╛ ), multiplique eso por 10.

21) "≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A

De manera similar a los fragmentos anteriores, la cadena "≤" se analiza como 0. La decrementamos 21 veces y luego tomamos el valor absoluto.

22) 1111 11v11%L1111 11v11%L

Aquí calculamos 1111 div 11 mod 11, que es 2, luego imprimimos 2. Luego lo hacemos nuevamente.

PowerShell, puntaje 12, 91 bytes. 14, 176 bytes

[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)

Editar:

• Gracias a Ørjan Johansen por sugerir el literal hexadecimal 0xd para 13 y la reorganización de 5 para liberar 1 + 1 + 1 + 1 .. como una opción.
• Cambió la longitud de la matriz a la longitud de la cadena, [int] a [byte] y la tabla hash para usar tablas hash como valores, liberando (),""Ponder 15 con algo como, "ZZZZZZZZZZZZZZZA".InDeXof("A")pero no puede reutilizar el punto o la 'e'.

PowerShell no puede hacer variables sin $, no puede hacer exponenciación, desplazamiento de bits, Pi, ceil (), etc. con símbolos básicos, y en su mayoría escribe coercian a / from bool y to / from numbers-as-strings, por lo que hay relativamente poco margen para la generación de números de baja sintaxis.

TI-Basic (serie 83), puntaje 21 22 23 24 25 (1003 bytes)

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

Referirse a http://tibasicdev.wikidot.com/one-byte-tokens para obtener una lista de las cosas que el desafío hace y no permite aquí.

Todos estos pueden ser programas completos, ya que la última línea de un programa se imprime automáticamente. Pero (a excepción de 17, que tiene varias líneas de longitud) también pueden ser fragmentos en la pantalla de inicio.

En este punto, no veo otra manera de conseguir cualquier valor distinto de cero de los tokens restantes disponibles. Si hay que hacer alguna mejora, tendrá que implicar primero hacer que algunas de las soluciones anteriores sean más conservadoras.

Explicaciones

• A=Aes un booleano 1 porque la variable Aes igual a sí misma.
• Bes 0 por defecto, tan(tan(cos(cos(cos(Bes aproximadamente 2.21, y luego tomamos la palabra.
• C!°es 1 grado en radianes, aproximadamente 0.017. Algún poder positivo de esto es tanh (2), aproximadamente 0.964. Codificamos ese poder en binario usando multiplicación implícita √(y luego tomamos tanh⁻¹(.
• 4 es sencillo
• cosh(sinh⁻¹(X simplifica a $\sqrt{1+X^2}$, y usado 25 veces nos da 5.
• 6-9 son sencillos
• ₁₀^( es un byte incorporado para potencias de 10 y 10 ^ 10 ^ 0 = 10 ^ 1 = 10.
• 11 es 11.
• Otra instancia del truco utilizado en 5. F nPr Fes 1. sin(tan⁻¹(Xsimplifica a$\frac{1}{\sqrt{1+1/X^2}}$, y usado 143 veces comenzando con 1 nos da 1/12. Dividiendo 1 por este número es 12.
• G≤G es 1, entonces [[G≤G]...[G≤G]] es un vector de columna de 13x1. Tomar el producto de su transposición consigo mismo da la matriz [[13]], cuyo determinante es 13.
• not(H)es 1. tanh(not(H))es solo un número que no es igual a 0 o 1, y ln(XXX....X)ln(X)^⁻1se simplificará al número de X's en el primer registro siempre queX no sea 0 (para que el registro exista) y no 1 (para que no estemos dividiendo por 0).
• e^(e^(e^(F evalúa a aproximadamente 15.15, y luego tomamos la palabra.
• J≥Jes 1. identity(construye una matriz de identidad 1x1, dim(encuentra sus dimensiones de fila y columna, ysum( agrega para obtener 2. Luego hacemos esto nuevamente, agregando las dimensiones de una matriz 2x2 para obtener 4, y nuevamente, agregando las dimensiones de una matriz 4x4 para obtener 8, y nuevamente, agregando las dimensiones de una matriz de 8x8 para obtener 16.
• K nCr K es el coeficiente binomial 0, elija 0 o 1. Sumar 17 1 da 17.
• i-i-...-ise simplifica a ⁻18i, y tomar abs(da 18.
• rand→Lalmacena un número real aleatorio en L, pero no nos importa cuál sea. Estamos computando log(L)⁻¹log(L^19), lo que simplifica a 19.
• sinh(sinh(cos⁻¹(Itiene un poco más de 4, así que seq(III,I,I,sinh(sinh(cos⁻¹(Ida la lista{0 1 8 27 64} cuya media aritmética es 20.
• Otra instancia del truco utilizado para obtener 3. Aquí, algún poder de πdebería dar 21; codificamos ese poder en ternario usando multiplicación implícita y³√( .
• 22 es 22.
• Otra instancia del truco utilizado para obtener 3 y 21. Codificamos la potencia de 3 que es igual a 23 en ternario, utilizando 3×√(como raíz cúbica y (para la multiplicación.
• Fix 0es la configuración para mostrar 0 dígitos después del decimal, redondeando todos los valores a enteros. sin⁻¹(ᴇ0evalúa a π / 2, y π / 2 multiplicado por sí mismo 7 veces da aproximadamente 23.59, que se redondea a 24.
• 5*5es 25. (Sería más conservador usar 5para obtener 5, y adaptar la solución utilizada allí para 25. Pero de esta manera ahorra mucho espacio, y *no es un carácter muy útil porque existe multiplicación implícita).

SOGL , puntaje 16 18 20, 109 bytes, 47 caracteres utilizados

=                    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 enteros, 86 bytes

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

Pruébalo en línea!(La entrada controla qué programa se ejecuta, de 1 a N)

Explicación

                       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 , puntaje 22, 177 bytes

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

Pruebe todo de una vez o intente uno a la vez (el argumento es qué salida desea).

Caracteres no utilizados:

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

Reng, puntaje 40, 149 bytes

Pruébalo aquí!

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±±±±$±$

Todas las letras mayúsculas son números, así que está bien. Todos menos dos de estos son fragmentos. Los dos que son programas:

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

El enlace proporcionado le permite a uno ver la pila mientras se ejecuta. Escribiré una explicación más tarde.

CJam, puntaje 27, 168 bytes

1-3: X , Y,Z

Las variables X , Yy Zse inicializan a 1, 2 y 3, respectivamente.

4: ",,,,",

Empujar la cuerda ,,,, y toma la longitud.

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

Literales numéricos

10-20 :A -K

Variables preinicializadas.

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

La variable Use inicializa en 0. empujarU e increméntalo 22 veces.

22: 22

Literal numérico.

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

Empuja el personaje ;y decreméntalo 9 veces para obtenerlo 2, luego presiona ;nuevamente y decreméntalo 8 veces para obtener3 .

24: 4m!

Toma el factorial de 4.

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

TT=empuja 1. Este código es equivalente a1 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-

Nempuja una cadena que contiene una nueva línea. :ilo convierte en una lista de códigos de caracteres, produciendo [10]. ~lo desempaca, dando 10. W-es el equivalente de sumar uno. Incrementar 10 dieciseis veces da 26.

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

Encuentre el índice de 0 en una lista donde 0 está en el índice 27.

Personajes aún disponibles: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

Algunas notas para una posible expansión:

• Podría tener que cambiar 10-20 para usar las variables para otra cosa. Si obtengo números superiores a 1, puedo usar *(y posiblemente operadores bit a bit, pero no creo que me ayuden mucho).

• Todavía tengo S, lo que sea bueno que me haga.

• Si cambio 26 a N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, entonces :estará disponible.

• Puedo empujar algunas listas vacías y obtener más ceros con las variables existentes. También puedo obtener π, pero eso no parece muy útil a menos que pueda convertirlo a un número entero de alguna manera, y m(para m[) y iya esté tomado.

• En términos de manipulación de matriz, puedo:

  • Use un mapa con %of
  • Use un pliegue con *
  • Haz algunas operaciones seguras
  • Conversión base (esto parece prometedor, pero no sé cómo obtendría el número base)
  • Construya matrices usando |:M1|2|3|

Haskell , puntaje 13, 86 bytes

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

Pruébalo en línea!

Gracias a Ørjan Johansen por encontrar una manera de arreglar la superposición de mi carta y preservar la puntuación de trece. (También por hacer todo lo posible para notificarme sobre esto mientras se borraba esta respuesta).

pi/pies 1.0.
sum[]evalúa a 0, 0^0a 1, y sum[1,1]a 2. 3para 9decodificarse ellos mismos.
length"eeeeeeeeee"produce la longitud de la cadena, que es 10.
2+2+2+2+2+2es 12.
0xDes hexadecimal para 13.