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:
Escriba tres fragmentos independientes (no programas / funciones completos).
Los fragmentos deben estar en el mismo idioma.
La puntuación es el número total de bytes de salida.
Las salidas pueden tener la forma de un resultado, STDOUT, etc.
Los fragmentos no pueden causar ningún error.
Los fragmentos pueden causar diferentes formas de salida.
Los caracteres de nueva línea finales no se cuentan.
El primer fragmento debe ser de 1 byte o la longitud mínima que produce al menos 1 byte de salida.
El segundo fragmento debe ser un byte más largo que eso.
El tercer fragmento debe ser dos bytes más largo que el primero.
Respuestas:
gs2, 412 + 5.37 * 10 902 + 10 10 903.1 bytes
f
empuja1\n2\nFizz\n4\nBuzz\n...\nFizzBuzz
como una412
cadena de bytes.fô
imprime todas sus permutaciones, por lo que los412! * 412
personajes.fôô
imprime todas las permutaciones de esa lista de elementos 412!, donde cada elemento tiene 412 caracteres de longitud, por lo que412 * (412!)!
bytes.EDITAR: Para poner las cosas en perspectiva, esto es al menos
bytes, empequeñeciendo todas las otras respuestas aquí hasta ahora.
fuente
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^20201781
y1.25 × 10^20201790
caracteres.Esto imprime:
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.
fuente
CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 bytes de salida
Para una comparación más fácil, esto es aproximadamente 7.3 * 10 19 .
Huellas dactilares:
Bueno, el último consiste en todas las permutaciones
[0 1 2 ... 19]
con los números apretados juntos. No recomendaría probarlo ... (Pruébelo como4e!
para probarlo).Pruébelo aquí: Programa 1 , Programa 2 , Sane versión del programa 3 .
fuente
Jelly , 1.2 × 10 2568 bytes de salida
Calcula 1000 , 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 Pythone
(notación científica). Por ejemplo,3ȷ4
devuelve 30000 . En la notación científica de Jelly, el coeficiente predeterminado es 1 y el exponente predeterminado es 3 , entoncesȷ
,1ȷ3
y1000
todos devuelven el mismo número.fuente
⍳
?ı
esR
(rango).ı
yȷ
hacer algo completamente ajeno a Jelly. Agregaré una explicación en unos minutos.ȷRR
causa?ȷRR
es⍳¨⍳1000
. Quería⍳⍳1000
. En Dyalog,⍳⍳7
puntajes 91244,⍳⍳8
puntajes 803487,⍳⍳9
puntajes 7904816, porque enumera todos los índices en una matriz 1 × 2 × 3 × 4 × .... ¡Entonces⍳⍳1000
teóricamente (WS FULL!) Generaría una matriz de! 1000 listas de 1000 elementos cada una!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 desplegado:
impresiones
111
. Cualquier letra minúscula ded
az
funciona 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:
Desplegado:
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).
fuente
12345
y se detienen. . . Solo por curiosidad entiendes.En serio, 2025409 bytes
1 byte:
(produce 11,756 bytes de salida)
2 bytes:
Produce 153,717 bytes de salida
3 bytes:
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.
fuente
N
eso que produce tanta producción?Pitón 3, 1 + 22 + 23 = 56
Salida
Imprima 9 y luego la definición de
id
yabs
.fuente
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
-1
con(!@
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.fuente
Bash, 1726 bytes
(Lo arreglé ahora. Por favor considere la posibilidad de votar).
1 byte :
"
Salidas:
307 bytes:
id
Salidas:
1418 bytes:
zip
(Imprime en STDOUT)fuente
MATL , 313
Se utiliza la versión actual del lenguaje ( 3.1.0 ), que es anterior a este desafío.
Código (literal predefinido: produce el número 2, que se imprime implícitamente):
Salida (1 byte):
Código (produce el número pi, que se imprime implícitamente con 15 decimales):
Salida (17 bytes):
Código (números del 1 al 99, que se imprimen de forma predeterminada con espacios en el medio):
Salida (295 bytes):
fuente
Procesamiento, 39 bytes
Determinista
1 byte :
Salidas
0
.9 bytes :
Salidas
3.1415927
29 bytes :
Salidas
processing.opengl.PGraphics3D
No determinista,> = 129 bytes
> = 32 bytes:
Salidas
processing.awt.PGraphicsJava2D@ + [mem-address]
> = 32 bytes:
Salidas
processing.awt.PGraphicsJava2D@ + [mem-address]
> = 65 bytes: (Gracias a @anOKsquirrel por esta sugerencia).
Salidas
fuente
JavaScript, 1 + 3 + 18 =
1822No es una respuesta muy interesante, pero probablemente el mejor JavaScript es capaz de hacerlo.
¡Agregó 4 puntajes gracias a @UndefinedFunction !
Salidas como texto:
fuente
alert()
, obtendrá la salida deundefined
(al menos en Safari).alert(.1)
da0.1
yalert(1/9)
da0.1111111111111111
alert
me dafunction alert() { [native code] }
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):fuente
..<@
Imprime 8 bytes.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.
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.
Programa 3:
Con 3 caracteres, puede escribir números de notación electrónica:
fuente
HQ9 +, 71304
Imprime la letra de 11,884 caracteres de "99 botellas de cerveza"
Imprime "99 botellas de cerveza" dos veces
Imprime "99 botellas de cerveza" tres veces
fuente
Japt
-Q
, Salidas1.0123378918474279e+150
bytesEl número completo es
bytes
# 1
Salidas
Para 67 bytes. (Crédito a Shaggy)
# 2
Salidas
que es de 501 bytes.
(Crédito a @Shaggy)
# 3
Muestra todas las permutaciones de los 95 caracteres ASCII imprimibles en el formato
["...","...","..."...]
, que esPuede obtener una cantidad infinita de bytes de salida si usa la
-F
bandera 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.fuente
undefined
en 1 byte:$
.K
y obtener 26 bytes de salida, pero su byte 501 es simplemente genialMalbolge , 1 + 2 + 3 = 6 bytes
Pruébelo en línea: primero , segundo , tercero
Salidas:
Bruto forzado. Asume
\0
que no es un carácter de salida válidoCon
\0
:Salidas:
fuente
scg , 1 + 27 + 188 = 216
El primero:
Solo imprime 1, ya que la pila sale al final del programa.
Segundo:
Imprime información de depuración, que debería verse así:
Tercero:
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)
fuente
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:
imprima "B" y termine, con un comentario EOL vacío
imprimir "CD" y terminar:
fuente
Mathematica, 6 + 461 + 763 = 1230
1225618163bytes de salidaActualmente, los dos últimos se utilizan
Information
para 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.1MathKernel
.fuente
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
36 bytes:
run
Salidas
fuente
js
en la línea de comando, obtienes un shell de JavaScript.-bash: js: command not found
Por favor especifique más.js
en la última versión de Bash.gc
no parece existir en el nodo TIO, por lo tanto, busque una implementación o elimine esta respuesta.Octava, 2818417 bytes
14 bytes para
ans = 2.7183\n
14 bytes para
ans = 3.1416\n
Mostrar toda la documentación. 2818389 bytes, contados con ¡
dd
Pruébelo en línea! porqueevalc
no funcionófuente
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 quePRINT
qué 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.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.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 deINSPECT
es básicamente libre. Entonces lo uso para imprimir una cadena de etiquetas. Esto es 15 bytes.El total es de 29 bytes.
fuente
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>
(\d
representa 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.
fuente
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:Longitud 2, 113 bytes
Este es un alias para
Remove-ItemProperty
. Producirá una solicitud de usuario que solicita información adicional:Solo un poco más largo que el fragmento de longitud 1.
Longitud 3, ~ 4100 bytes
Este es un alias para el
Get-Process
cual generará una tabla formateada de todos los procesos en ejecución en el sistema:fuente
Javascript, 312 + 318 + 624 = 1254 bytes de salida
Las dos funciones
$
y$$
están disponibles en todas las principales consolas de navegadores, como atajos paradocument.querySelector
ydocument.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:
(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:
Longitud de resultados por navegador:
{}
es utilizable) + 32 = 38 (o 48) bytes{}
es utilizable) + 38 = 44 (o 54){}
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:
Object.getOwnPropertyNames(window).filter(x=>x.length<=3)
y luegomap
a 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).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 ser0o
,0x
o0b
(o mayúsculas formas), seguido de uno o más dígitos. Para nuestros propósitos, podemos deducir lo siguiente:$
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.{}
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()
.if
,in
,do
,new
,for
,try
,var
, ylet
serían todos requieren un mínimo de otros dos personajes a utilizar, excediendo el límite.~
,+
,-
,!
,++
, 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 produceNaN
. Los otros cuatro operadores se pueden usar con cualquier valor de uno o dos caracteres, de los cuales hay:$
,$_
,$0
,$1
,$2
,$3
,$4
,$
,$$
,$x
). Cuando se utiliza con estos operadores, los resultados se limitan a-1
,true
,false
, yNaN
.true
,false
.-1
,0
(-0
se convierte0
en toString),true
.+
,-
,*
,/
,%
,<
,>
,&
,|
,^
. 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 incluyenInfinity
, algunos números y valores binarios mencionados anteriormente, y numerosas fracciones que se convierten en cadenas de 19 caracteres o menos (1/7
es 19 caracteres, a diferencia de lo1/9
sugerido 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..
requiere una variable existente y un identificador que haga referencia a una propiedad. Todos los usos de este resultado aquí enundefined
. 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.fuente
dc , 2 + 5 + 18 = 25 bytes
1:
Ff
rendimientos (¡ Pruébelo en línea! ):2:
Fdf
rendimientos (¡ Pruébelo en línea! ):3:
Fd^f
rendimientos (¡ Pruébelo en línea! )Ninguno de los cuales es particularmente interesante, pero
dc
no es realmente genial para escupir montones de salida. Me gusta que cada respuesta se base en la anterior. De todos modos,F
es solo el número 15;f
imprime toda la pila;d
duplica 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 completardc
.fuente
Ruby, 3 + 14 + 28 = 45 bytes
¿Por qué hice esto?
Impresiones
nil
.Impresiones
#<IO:<STDOUT>>
.Imprime algo en la línea de
#<Object:0x0000000003610988>
.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^D
o 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.fuente
Perl 6, 53 (17 + 18 + 18) bytes
e
salidas-e
salidase*e
salidasfuente
Encantamientos rúnicos, 4,000,000 bytes de salida
El primer programa es:
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:
Las impresiones
10000
, de nuevo,a
podrí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:E
Son las únicas opciones reales.aY@
es solo el que genera el mayor rendimiento.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.
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:
A
desde entonces, la instrucción se ha convertido enMath
metainstrucció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 seA
asigna@
a una función matemática como porque dos llamadas posteriores resultan en un desbordamiento de pila.fuente