Obviamente, el golf de código se trata de aprovechar al máximo el código mínimo. ¿A quién le importa realmente cuál es el resultado real?

Si bien hemos tenido un reto para la más alta de entrada a salida de relación , esto es un llamado a más finito y determinista de salida con longitudes de código dado. Irónicamente, este desafío no es el código golf .

Reglas:

1. Escriba tres fragmentos independientes (no programas / funciones completos).

2. Los fragmentos deben estar en el mismo idioma.

3. La puntuación es el número total de bytes de salida.

4. Las salidas pueden tener la forma de un resultado, STDOUT, etc.

5. Los fragmentos no pueden causar ningún error.

6. Los fragmentos pueden causar diferentes formas de salida.

7. Los caracteres de nueva línea finales no se cuentan.

8. El primer fragmento debe ser de 1 byte o la longitud mínima que produce al menos 1 byte de salida.

9. El segundo fragmento debe ser un byte más largo que eso.

10. El tercer fragmento debe ser dos bytes más largo que el primero.

gs2, 412 + 5.37 * 10 ⁹⁰² + 10 ^{10 903.1} bytes

1. fempuja 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzcomo una 412cadena de bytes.

2. fôimprime todas sus permutaciones, por lo que los 412! * 412personajes.

3. fôôimprime todas las permutaciones de esa lista de elementos 412!, donde cada elemento tiene 412 caracteres de longitud, por lo que 412 * (412!)!bytes.

EDITAR: Para poner las cosas en perspectiva, esto es al menos

10^{1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

bytes, empequeñeciendo todas las otras respuestas aquí hasta ahora.

Pyth, 26 + 1140850688 + (> 4.37 × 10 ^20201781 )

No tengo idea si es posible calcular la longitud exacta de la salida para el tercer programa. Solo puedo dar límites. Imprimirá algo entre 4.37 × 10^20201781y 1.25 × 10^20201790caracteres.

G
yG
yyG

Esto imprime:

abcdefghijklmnopqrstuvwxyz
['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']
[[], [''], ['a'], ['b'], ['c'], ..., ['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']]

El primero imprime el alfabeto, el segundo todos los subconjuntos del alfabeto y el tercero los subconjuntos de los subconjuntos del alfabeto, que es una lista de longitud 2^(2^26) ~= 1.09 × 10^20201781.

Obviamente, ninguna computadora podrá calcular esta gran lista y generarla.

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 bytes de salida

Para una comparación más fácil, esto es aproximadamente 7.3 * 10 ¹⁹ .

P
PP
Ke!

Huellas dactilares:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Bueno, el último consiste en todas las permutaciones [0 1 2 ... 19]con los números apretados juntos. No recomendaría probarlo ... (Pruébelo como 4e!para probarlo).

Pruébelo aquí: Programa 1 , Programa 2 , Sane versión del programa 3 .

Jelly , 1.2 × 10 ²⁵⁶⁸ bytes de salida

ȷ
ȷ*
ȷ*!

Calcula 1000 , 1000 ¹⁰⁰⁰ y 1000 ^1000! .

Pruébelo en línea: primer programa | segundo programa |tercer programa (modificado)

Para el conteo de bytes, ȷse puede codificar como el byte 0xa0 en la versión actual de Jelly .

Cómo funciona

En Jelly, ȷse puede usar dentro de literales numéricos como Python e(notación científica). Por ejemplo, 3ȷ4devuelve 30000 . En la notación científica de Jelly, el coeficiente predeterminado es 1 y el exponente predeterminado es 3 , entonces ȷ, 1ȷ3y 1000todos devuelven el mismo número.

ȷ      Return 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
 *     Hook; compute 1000 ** 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
  !    Return 1000!.
 *     Fork; compute 1000 ** 1000!.

Hexagonía , 1 + 3 + 6 = 10 bytes de salida

Bueno ... no es un puntaje muy impresionante, pero al menos puedo afirmar que es óptimo. Con un solo byte es imposible imprimir algo y terminar, así que comenzamos con dos bytes:

!@

El código desplegado es

 ! @
. . .
 . .

Esto imprime un byte y termina.

Para tres bytes de código, podemos imprimir tres bytes de salida. Por ejemplo:

o!@

o desplegado:

 o !
@ . .
 . .

impresiones 111. Cualquier letra minúscula de da zfunciona e imprime su código de caracteres. Esas son las únicas 23 formas de imprimir 3 bytes con 3 bytes de código.

Finalmente, para cuatro bytes, hay 169 formas de imprimir 6 bytes. Como ninguno de ellos hace nada más interesante (excepto un flujo de control extraño) que la solución directa, presentaré eso:

o!!@

Desplegado:

 o !
! @ .
 . .

Lo adivinaste. Se imprime 111111.

¿Cómo sé que estos son óptimos? Adapté el forzador bruto que escribí para el catálogo de máquinas de verdad para buscar la salida finita máxima en 7000 ciclos (no creo que pueda escribir un castor ocupado con 4 bytes, que se ejecuta durante 7000 ciclos pero aún termina más tarde).

En serio, 2025409 bytes

1 byte:

N

(produce 11,756 bytes de salida)

2 bytes:

Nñ

Produce 153,717 bytes de salida

3 bytes:

9!!

Produce 1,859,936 bytes de salida

En serio, todavía no presenta cosas como "todos los subconjuntos" o "todas las combinaciones", por lo que las puntuaciones son relativamente bajas en esto.

Pitón 3, 1 + 22 + 23 = 56

9
id
abs

Salida

9
<built-in function id>
<built-in function abs>

Imprima 9 y luego la definición de idy abs.

Laberinto , 1 + 2 + 4 = 7 bytes

Otro puntaje bajo, que publico principalmente porque he demostrado que es óptimo para el idioma.

Al igual que Hexagony, Labyrinth no puede imprimir y terminar con un solo byte, por lo que comenzamos con dos bytes:

!@

Imprime un cero y termina.

Para tres bytes, no podemos superar la solución ingenua:

!!@

Esto imprime dos bytes antes de terminar. Hay algunas otras opciones, como imprimir -1con (!@o ~!@o ,!@. Sin embargo, hay una solución bastante buena que utiliza la rotación del código fuente:

!>@

Esto imprime un cero, luego cambia la fuente para convertirse @!>. En ese punto, llega a un callejón sin salida, se da la vuelta y ejecuta de !nuevo en el camino de regreso, antes de terminar.

Para cuatro bytes, es un poco más divertido, porque la única forma de imprimir 4 caracteres es usar el truco anterior:

!!>@

Imprime dos ceros, cambia a @!!>, imprime otros dos ceros.

En todos estos casos, ignoro que también puede imprimir un byte con \o ., porque siempre imprimirá exactamente un byte, mientras !que imprimirá al menos uno y potencialmente varios.

Bash, 1726 bytes

(Lo arreglé ahora. Por favor considere la posibilidad de votar).

1 byte :"

Salidas:

>

307 bytes: id

Salidas:

uid=501(geokavel) gid=20(staff) groups=20(staff),701(com.apple.sharepoint.group.1),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),33(_appstore),100(_lpoperator),204(_developer),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)

1418 bytes: zip (Imprime en STDOUT)

Copyright (c) 1990-2008 Info-ZIP - Escriba 'zip "-L"' para la licencia de software.
Zip 3.0 (5 de julio de 2008). Uso:
zip [-opciones] [-b ruta] [-t mmddyyyy] [-n sufijos] [lista de archivos zip] [-xi lista]
  La acción predeterminada es agregar o reemplazar entradas de archivos zip de la lista, que
  puede incluir el nombre especial: para comprimir la entrada estándar.
  Si se omiten zipfile y list, zip comprime stdin a stdout.
  -f refrescar: solo archivos modificados -u actualización: solo archivos modificados o nuevos
  -d eliminar entradas en el archivo zip -m mover al archivo zip (eliminar archivos del sistema operativo)
  -r recurse a directorios -j basura (no registrar) nombres de directorio
  -0 solo almacenar -l convertir LF a CR LF (-ll CR LF a LF)
  -1 comprimir más rápido -9 comprimir mejor
  -q operación silenciosa -v operación detallada / información de versión impresa
  -c agregar comentarios de una línea -z agregar comentario de archivo zip
  - @ leer nombres de stdin -o hacer zipfile tan antiguo como la última entrada
  -x excluye los siguientes nombres -i incluye solo los siguientes nombres
  -F arregla el archivo zip (-FF intenta más) -D no agrega entradas de directorio
  -A ajuste autoextraíble exe -J prefijo de archivo zip basura (unzipsfx)
  -T prueba de integridad del archivo zip -X eXclude los atributos del archivo eXtra
  -y almacenar enlaces simbólicos como el enlace en lugar del archivo referenciado
  -e cifrar -n no comprime estos sufijos
  -h2 muestra más ayuda

MATL , 313

Se utiliza la versión actual del lenguaje ( 3.1.0 ), que es anterior a este desafío.

1. Código (literal predefinido: produce el número 2, que se imprime implícitamente):

   H
   

   Salida (1 byte):

   2
   

2. Código (produce el número pi, que se imprime implícitamente con 15 decimales):

   YP
   

   Salida (17 bytes):

   3.141592653589793
   

3. Código (números del 1 al 99, que se imprimen de forma predeterminada con espacios en el medio):

    99:
   

   Salida (295 bytes):

   1  2  3  4  5  6  7  8  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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 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
   

Procesamiento, 39 bytes

Determinista

1 byte :

print(X);

Salidas 0.

9 bytes :

print(PI);

Salidas 3.1415927

29 bytes :

print(P3D);

Salidas processing.opengl.PGraphics3D

No determinista,> = 129 bytes

> = 32 bytes:

print(g);

Salidas processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 bytes:

print( g);

Salidas processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 bytes: (Gracias a @anOKsquirrel por esta sugerencia).

print(g,g);

Salidas

processing.awt.PGraphicsJava2D@ + [mem-address]
processing.awt.PGraphicsJava2D@ + [mem-address]

JavaScript, 1 + 3 + 18 = 18 22

No es una respuesta muy interesante, pero probablemente el mejor JavaScript es capaz de hacerlo.

alert(1)
alert(.1)
alert(1/9)

¡Agregó 4 puntajes gracias a @UndefinedFunction !

Salidas como texto:

1
0.1
0.1111111111111111

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

Cualquier fragmento más corto que la longitud 2 no puede salir o no puede terminar su salida.

En Befunge, .muestra el valor superior de la pila como un entero, seguido de un espacio. Un espacio no es una nueva línea, por lo que se incluye en el recuento. Además, la pila está "infinitamente" llena de ceros, por lo que los programas generan (respectivamente):

0 
0 0 
0 0 0 

SmileBASIC, 1 + 4 + 10 = 15 bytes

Programa 1:

¿La forma más corta de imprimir algo es con? (IMPRIMIR) y un solo carácter. Puede ser un número o un nombre de variable, y no importa, ya que todos tienen la misma longitud.

?1
1

Programa 2:

Ahora tenemos acceso a algunas cosas más. La expresión más larga que se puede hacer sería una de las constantes #Y, #L o #R, que tienen valores 128, 256 y 512, respectivamente. Sin embargo, en lugar de eso, uso una coma para que (en este caso) se impriman 3 espacios adicionales.

?1,
1   

Programa 3:

Con 3 caracteres, puede escribir números de notación electrónica:

?1E9
1000000000

HQ9 +, 71304

9

Imprime la letra de 11,884 caracteres de "99 botellas de cerveza"

99

Imprime "99 botellas de cerveza" dos veces

999

Imprime "99 botellas de cerveza" tres veces

Japt -Q, Salidas 1.0123378918474279e+150bytes

El número completo es

1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,568

bytes

# 1

M

Salidas

{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}

Para 67 bytes. (Crédito a Shaggy)

# 2

LÆ

Salidas

[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]

que es de 501 bytes.

(Crédito a @Shaggy)

# 3

;Eá

Muestra todas las permutaciones de los 95 caracteres ASCII imprimibles en el formato ["...","...","..."...], que es

$1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,001$ bytes de salida.

Puede obtener una cantidad infinita de bytes de salida si usa la -Fbandera en Japt. Lo que hace es que si la última expresión del programa se evalúa como falsa, genera el valor especificado en la bandera. Así que supongo que el puntaje para Japt -F"Insert Super Long String Here"es infinito.

Malbolge , 1 + 2 + 3 = 6 bytes

(=aN
(&a`M
(=a`_L

Pruébelo en línea: primero , segundo , tercero

Salidas:

r
ll
xxx

Bruto forzado. Asume \0que no es un carácter de salida válido

Con \0:

cP
cbO
cbaN

Salidas:

\0
\0\0
\0\0\0

scg , 1 + 27 + 188 = 216

El primero:

1

Solo imprime 1, ya que la pila sale al final del programa.

Segundo:

.d

Imprime información de depuración, que debería verse así:

Stack: []
Array Markers: []

Tercero:

99r

agrega 99 a la pila, luego usa la función de rango. Salidas 01234567891011 .... (esta es una de esas veces que desearía haber implementado la función factorial. No lo he hecho)

Marbelous 1 + 1 + 2 = 4 bytes de salida

A Marbelous se le entorpece tener instrucciones de dos bytes. Los comentarios sin sentido o los espacios en blanco innecesarios son las únicas formas de obtener un recuento de bytes impar.

imprime "A" y termina:

`A

imprima "B" y termine, con un comentario EOL vacío

`B#

imprimir "CD" y terminar:

`C`D

Mathematica, 6 + 461 + 763 = 1230 1225 618 163 bytes de salida

%  (* -> Out[0] *)

?D  (* ->

D[f, x] gives the partial derivative ∂ f/∂ x. 
                                              n        n
D[f, {x, n}] gives the multiple derivative ∂  f/∂ x . 
D[f, x, y, …] differentiates f successively with respect to x, y, ….
D[f, {{x , x , …}}] for a scalar f
        1   2
     gives the vector derivative (∂ f/∂ x , ∂ f/∂ x , …). 
                                             1             2
D[f, {array}] gives a tensor derivative.

*)

?Do (* ->

Do[expr, {i   }] evaluates expr i    times. 
           max                   max
Do[expr, {i, i   }] evaluates expr with the variable i successively taking on the values 1 through i    (in steps of 1). 
              max                                                                                   max
Do[expr, {i, i   , i   }] starts with i = i   . 
              min   max                    min
Do[expr, {i, i   , i   , di}] uses steps di. 
              min   max
Do[expr, {i, {i , i , …}}] uses the successive values i , i , ….
               1   2                                     1   2
Do[expr, {i, i   , i   }, {j, j   , j   }, …] evaluates expr looping over different values of j, etc. for each i. 
              min   max        min   max

*)

Actualmente, los dos últimos se utilizan Informationpara obtener documentación sobre los símbolos, que pueden generar muchos bytes. Tenga en cuenta que esto se ejecutó en la línea de comandos 10.1 MathKernel.

Javascript, 72 bytes

Esto funciona en el JSShell de Mozilla intérprete de línea de comandos Javascript de .

1 byte: 1

Salidas 1

35 bytes: gc

Salidas

function gc() {
    [native code]
}

36 bytes: run

Salidas

function run() {
    [native code]
}

Octava, 2818417 bytes

e

14 bytes para ans = 2.7183\n

pi

14 bytes para ans = 3.1416\n

doc

Mostrar toda la documentación. 2818389 bytes, contados con ¡ dd Pruébelo en línea! porque evalcno funcionó

SmileBASIC 4, 1 + 13 + 15 = 29 bytes

Esto será similar a la respuesta SmileBASIC 3 de 12Me21, con un par de ajustes.

1

Como antes, la cantidad más corta de código para producir alguna salida es 2 bytes: ?( PRINT) y alguna expresión de un solo byte. El consenso es que PRINTqué no producir una nueva línea cuando avanza a la siguiente línea, debido a la forma en que funciona la pantalla de texto. Entonces esto resulta en un byte de salida.

?1
1

2

Con 3 bytes, podemos hacer algo diferente. SB4 presenta INSPECT, alias como ??, que imprime información sobre un solo valor. Si le damos una cadena vacía, por ejemplo, esto puede producir mucho más salida que SB3 podría. Esto nos da 13 bytes.

??"
STRING: (0)""

3

Tenemos 4 bytes con los que trabajar, por lo que tenemos que decidir qué debemos hacer para maximizar nuestra salida. Ir con ??es una apuesta segura; solo tenemos 2 bytes para usar en nuestra expresión, pero la salida adicional de INSPECTes básicamente libre. Entonces lo uso para imprimir una cadena de etiquetas. Esto es 15 bytes.

??@A
STRING: (2)"@A"

El total es de 29 bytes.

Microscript II, 23 + 47 + 71 = 141 bytes

1: C

La secuenciación de las continuaciones no está estrictamente definida por las especificaciones, pero en la implementación de referencia esto, ejecutado por sí solo, produce una cadena de 23 bytes.

<Continuation @t=\d\d\dus>( \drepresenta un dígito, cuyos dígitos varían).

En mi computadora, al menos, esto, de hecho, siempre tarda entre 180 y 400 microsegundos en ejecutarse.

El primer uso que he tenido para esta instrucción.

2: CP

47 bytes de salida: la salida del primero dos veces con una nueva línea en el medio.

3: CPP

Bastante sencillo. 71 bytes de salida: la salida del primero tres veces con líneas nuevas en el medio.

PowerShell, ~ 4300 bytes

Longitud de salida aproximada, dado el sistema en el que se ejecuta. Todos los fragmentos a continuación son deterministas, en el sentido de que si se le da el mismo estado inicial de la computadora generará el mismo texto, solo que en la práctica el resultado podría cambiar de ejecución en ejecución.

Longitud 1, 107 bytes

?

Este es un alias para Where-Object. Producirá una solicitud de usuario que solicita información adicional:

cmdlet Where-Object at command pipeline position 1
Supply values for the following parameters:
Property: 

Longitud 2, 113 bytes

rp

Este es un alias para Remove-ItemProperty. Producirá una solicitud de usuario que solicita información adicional:

cmdlet Remove-ItemProperty at command pipeline position 1
Supply values for the following parameters:
Path[0]: 

Solo un poco más largo que el fragmento de longitud 1.

Longitud 3, ~ 4100 bytes

gps

Este es un alias para el Get-Processcual generará una tabla formateada de todos los procesos en ejecución en el sistema:

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                                                          
-------  ------    -----      ----- -----   ------     -- -----------                                                                                
     85       8     1232       4452    46     0.14    544 armsvc                                                                                               
    151      10     6800       9888    39     0.58   5116 audiodg                                                                                              
    480      25     6060      17200   124     0.84   4536 AuthManSvr            
...

Javascript, 312 + 318 + 624 = 1254 bytes de salida

$
$$
$+$

Las dos funciones $y $$están disponibles en todas las principales consolas de navegadores, como atajos para document.querySelectorydocument.querySelectorAll respectivamente. Los diferentes navegadores tienen código nativo forzado a cadenas de forma algo diferente entre sí, e IE usa JS simple en cada función, lo que resulta en una representación mucho más larga.

Para el recuento de bytes, tomo la longitud de la representación de cadena de cada uno en lugar de la pantalla de la consola a veces modificada, por lo que los bytes totales son, para cada uno de los siguientes navegadores:

• Chrome: 56 + 57 + 112 = 225 bytes
• IE: 312 + 318 + 624 = 1254
• Firefox: 33 + 33 + 66 = 132

(Estoy considerando que el resultado de IE es el recuento "oficial" porque es el más largo).

Para entornos de navegador que no son de consola, los resultados más grandes provienen de lo siguiente:

1
!1 // Or '{}' if being fed to a function instead of beginning a statement
Map

Longitud de resultados por navegador:

• Chrome: 1 + 5 (o 15 si {} es utilizable) + 32 = 38 (o 48) bytes
• IE: 1 + 5 (o 15 si {}es utilizable) + 38 = 44 (o 54)
• Firefox: 1 + 5 (o 15 si {}es utilizable) + 36 = 42 (o 52)

Estos dos conjuntos de entrada producen la mayor salida posible en todos estos navegadores y consolas. Para probar esto, verifiquemos todas las alternativas:

• Variables existentes: podemos encontrar todas las variables nativas disponibles con un máximo de tres caracteres Object.getOwnPropertyNames(window).filter(x=>x.length<=3)y luego mapa sus salidas de cadena para determinar las más grandes. (Tenga en cuenta que en algunos navegadores como Firefox, no se puede acceder a ciertas variables especiales de la consola de esta manera, ya que no son propiedad de la ventana).
• JS tiene un número limitado de tipos de literales que se pueden crear con tan pocos caracteres:
  • Según la especificación, los números decimales deben ser un dígito decimal ( 1234567890) opcionalmente seguido de .y más dígitos decimales y / o una parte exponente, o ser .seguido por uno o más dígitos decimales y opcionalmente una parte exponente. Otros tipos de números deben ser 0o, 0xo 0b(o mayúsculas formas), seguido de uno o más dígitos. Para nuestros propósitos, podemos deducir lo siguiente:
    • Solo hay diez números de un solo carácter, que son los enteros del 0 al 9. Los únicos números de dos caracteres son los enteros del 0-99 (0-9 al agregar un decimal después), y los números del 0.1 al 0.9 omitiendo el cero inicial . Los únicos números de tres caracteres son 0-999, incluidos 0x0-0xf, 0o0-0o7, ​​0b0 y 0b1, los exponenciales 1e1 a 9e9 (10 caracteres) y los números 0.1-9.9 y .01 a .99. Aunque técnicamente no es un número literal, NaN también puede ser referenciado en tres caracteres.
  • Cadenas, matrices y expresiones regulares, cada una de las cuales puede tomar como máximo un solo carácter de contenido. Una matriz podría llenarse con $una coma o un número de un solo dígito. Las matrices con un solo elemento se convierten en cadenas como el elemento mismo. Las matrices vacías se convierten en cadenas vacías.
  • Dependiendo del entorno, puede o no ser posible crear objetos simples con tres caracteres. Normalmente, {}solo al comienzo de un script se trataría como un recinto en lugar de crear un objeto. eval({})devuelve indefinido, eval({$})devuelve la $función. No hay suficientes caracteres para rodear el {}en ().
• No hay palabras clave que sean lo suficientemente cortas para usar. Las palabras clave if, in, do, new, for, try, var, y letserían todos requieren un mínimo de otros dos personajes a utilizar, excediendo el límite.
• Disponible operadores unitarios incluyen ~, +, -, !, ++, y --. Los operadores de dos caracteres solo se pueden usar con una variable de un solo carácter, de los cuales solo hay uno ( $), que produce NaN. Los otros cuatro operadores se pueden usar con cualquier valor de uno o dos caracteres, de los cuales hay:
  • Varias variables (En algunas consolas $, $_, $0, $1, $2, $3, $4, $, $$, $x). Cuando se utiliza con estos operadores, los resultados se limitan a -1, true, false, y NaN.
  • 109 números. Resultados: Los enteros -100 a 99, -0.9 -0.1 través de, true, false.
  • Cadenas vacías. Resultados: -1, 0( -0se convierte 0en toString), true.
  • Los resultados de cualquiera de los valores de un carácter anteriores asociados con un operador unario de un carácter. Nuevos resultados: ninguno.
• Operadores binarios utilizables (que debe ser un único carácter para tener espacio dejado por ambos operadores) son +, -, *, /, %, <, >, &, |, ^. Solo se pueden usar con un valor de un solo carácter en cada lado. Las opciones para valores incluyen $y enteros 0-9. Los resultados de todas las combinaciones de estos incluyen Infinity, algunos números y valores binarios mencionados anteriormente, y numerosas fracciones que se convierten en cadenas de 19 caracteres o menos ( 1/7es 19 caracteres, a diferencia de lo 1/9sugerido anteriormente, que es solo 18), y la representación de texto $precedida o seguido de un entero de un solo dígito o de sí mismo.
• Finalmente, todos los operadores y expresiones restantes: el operador miembro .requiere una variable existente y un identificador que haga referencia a una propiedad. Todos los usos de este resultado aquí en undefined. Rodear un valor en ( )devuelve el valor, al igual que asignarlo con =. Usar ()o `` para llamar a un valor como función da como resultado errores indefinidos o con todos los valores disponibles.

Sumando todo esto, hay un gran total de 1651 salidas posibles cuando se usa una consola Chrome. Las salidas más largas para uno, dos, y tres caracteres son de $, $$y $+$respectivamente.

dc , 2 + 5 + 18 = 25 bytes

1: Ffrendimientos (¡ Pruébelo en línea! ):

15

2: Fdfrendimientos (¡ Pruébelo en línea! ):

15
15

3: Fd^frendimientos (¡ Pruébelo en línea! )

437893890380859375

Ninguno de los cuales es particularmente interesante, pero dcno es realmente genial para escupir montones de salida. Me gusta que cada respuesta se base en la anterior. De todos modos, Fes solo el número 15; fimprime toda la pila; dduplica la parte superior de la pila; ^eleva el siguiente al tope de la pila a la potencia del tope de la pila (en este caso, 15 ^ 15). No creo que esto se pueda completar dc.

Ruby, 3 + 14 + 28 = 45 bytes

¿Por qué hice esto?

p

Impresiones nil.

$>

Impresiones #<IO:<STDOUT>>.

dup

Imprime algo en la línea de #<Object:0x0000000003610988>.

irb

Lanza una instancia de Interactive Ruby. Al salir, el objeto devuelto es #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>>para 121, pero dado que requiere presionar ^Do algo para salir de la instancia irb, no estaba seguro de si realmente contaría como una solución en "3 bytes", así que no estoy en realidad incluirlo en el puntaje a menos que obtenga un OK.

Perl 6, 53 (17 + 18 + 18) bytes

e
-e
e*e

1. e salidas $e$ hasta 15 decimales
2. -e salidas $-e$ hasta 15 decimales
3. e*e salidas $e^2$, pero extrañamente, da un decimal más

Encantamientos rúnicos, 4,000,000 bytes de salida

El primer programa es:

a@

Toma 2 bytes para: insertar un valor en la pila, imprimir un valor desde la pila y finalizar. En este caso se imprime 10(aunque cualquier valor entero de 0 a 16 también es igual de válido)

Para 3 bytes:

aY@

Las impresiones 10000, de nuevo, apodrían ser del 1 al 16 inclusive (para generar más resultados que el programa original, 0 es potencialmente válido bajo otros operadores) y no hay muchos operadores que toman una sola entrada y producen cualquier salida, salida mucho menos larga . XCYZ:ESon las únicas opciones reales. aY@es solo el que genera el mayor rendimiento.

P$!;

Según la especificación del lenguaje, esto se ejecuta infinitamente. Sin embargo, como el intérprete tiene un límite de ejecución máximo "ok, eso es suficiente" incorporado, este es el mayor rendimiento que se puede lograr en 4 caracteres (y TIO corta la ejecución después de ~ 130,000 bytes por exceder 128kib) y como el intérprete define el lenguaje , esto trabajos. Y aunque he elevado ese umbral una vez antes (de 10k pasos a 1 millón), no planeo jugar con él en el corto plazo.

¿Más grande?

Si invoco los tres supuestos que hice aquí , entonces seguro.

`AA@

Lo que funciona Ack(65,Ack(65,64)), que no son valores terriblemente grandes para ir a la función de Ackerman inicialmente, ciertamente más pequeños que los 255 en la publicación anterior, pero está bien, podemos llamar a Ack dos veces en 4 instrucciones.

Y solo Dios sabe lo que imprimirá.

_{Nota: Adesde entonces, la instrucción se ha convertido en Mathmetainstrucción, que consume 3 objetos en la pila: un carácter para qué instrucción realizar y luego dos entradas, x e y. Como tal, este programa en realidad no hace nada, tanto porque ni se Aasigna @a una función matemática como porque dos llamadas posteriores resultan en un desbordamiento de pila.}