Salida con la misma longitud que el código

97

En este desafío, debe escribir un programa o función que no tome entrada e imprima o devuelva una cadena con el mismo número de bytes que el programa en sí. Hay algunas reglas:

  • Solo puede generar bytes en el rango ASCII imprimible (0x20 a 0x7E, inclusive) o nuevas líneas (0x0A o 0x0D).
  • Su código no debe ser una quine, por lo que el código y la salida deben diferir en al menos un byte.
  • Su código debe tener al menos un byte de longitud.
  • Si su salida contiene nuevas líneas finales, esas son parte del recuento de bytes.
  • Si su código requiere indicadores de línea de comando no estándar, cuéntelos como de costumbre (es decir, agregando la diferencia a una invocación estándar de la implementación de su idioma al recuento de bytes), y la longitud de la salida debe coincidir con la puntuación de su solución. Por ejemplo, si su programa es aby requiere el indicador no estándar -n(asumiremos que no se puede combinar con indicadores estándar, por lo que son 3 bytes), debe generar 5 bytes en total.
  • La salida no siempre tiene que ser la misma, siempre que pueda demostrar que cada salida posible cumple los requisitos anteriores.
  • Las reglas habituales de quine no se aplican. Puede leer el código fuente o su tamaño, pero dudo que sea más corto que codificarlo en la mayoría de los idiomas.

Puede escribir un programa o una función y utilizar cualquiera de los métodos estándar para proporcionar resultados. Tenga en cuenta que si imprime el resultado, puede elegir imprimirlo en la salida estándar o en la secuencia de error estándar, pero solo uno de ellos cuenta.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el , por lo que gana la respuesta válida más corta, medida en bytes .

Tabla de clasificación

Martin Ender
fuente
18
"Su código no debe ser un quine" pero ... pero ... está etiquetado quine
Okx
44
@Okx Debido a que es una quine generalizada, es decir, la salida requerida depende del código fuente.
Martin Ender
44
@MartinEnder Probablemente no debería permitir la salida por código de salida, que es el valor predeterminado. Si lo permite, casi todos los programas de bytes en casi todos los idiomas están permitidos. Un usuario ya ha hecho esto
Wheat Wizard
2
La salida de @WheatWizard por código de salida no es una cadena, por lo que no se aplica aquí.
Martin Ender

Respuestas:

204

C (Linux moderno), 19 bytes

main(){puts('s');}

Cuando se compila y ejecuta, esto imprime:

Segmentation fault
MD XF
fuente
20
Esto es brillante: D
Beta Decay
44
esto es más como "C + English language unix / posix OS;)"
Florian Castellane
55
Creo que sería mejor escribir "C, Linux moderno" que solo "C": en Windows, el mensaje de error es diferente y en los viejos tiempos los programas de Linux incluso se compilaron de manera que la dirección 0x73 ('s') fuera legible así que no se causó ninguna excepción.
Martin Rosenau
99
Me uní al sitio solo para votar esta respuesta.
Nitish
77
Tan impresionante como esto es, que no es realmente el programa C que imprime la salida, pero la cáscara se está ejecutando en.
Dennis
80

Excel, 11 bytes

Versión en noruego:

=SMÅ(13^9)

Versión en inglés (12 bytes):

=LOWER(17^9)

Genera un número de n dígitos y lo convierte a texto convirtiéndolo a minúsculas.

pajonk
fuente
106
Esto le da un significado completamente nuevo a "elegir el idioma adecuado para el trabajo".
Martin Ender
44
Esta es una gran idea. Sería más corto hacer lo =9^7&""que genera un número de 7 dígitos en cualquier idioma y tiene solo 7 bytes.
OpiesDad
@OpiesDad Buena solución, creo que deberías publicarla como respuesta, para que pueda votar.
pajonk
44
@MartinEnder Me divierte cómo su especulación / broma potencial está más votada que esta respuesta (aunque está cerca).
HyperNeutrino
55

Laberinto , 4 bytes

!!>@

Pruébalo en línea!

Huellas dactilares 0000

Explicación

!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
>   Rotate the source code right by one cell, so the code now becomes

    @!!>

    The IP is moved along, so it's now at the end of the line, which is 
    a dead end. So the IP turns around and starts moving left.
!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
@   Terminate the program.
Martin Ender
fuente
66
Eso es muy inteligente. Tener un +1, en la casa!
caird coinheringaahing
54

Bash (solo integrado), 8 bytes

{e,,}cho

Impresiones cho choy una nueva línea.

Anders Kaseorg
fuente
40

Retina , 2 bytes

no

Pruébalo en línea!

Impresiones 0y un salto de línea.

Hay muchas soluciones de 2 bytes, pero creo que esto es óptimo. La retina por defecto siempre imprime una nueva línea final y deshacerse de ella requiere demasiados bytes. Por lo tanto, tendríamos que encontrar un programa de 1 byte que deje la entrada vacía sin cambios. Creo que el único programa que hace esto es el programa que contiene un solo salto de línea, que por lo tanto es igual a la salida y, por lo tanto, no está permitido por el desafío.

El siguiente paso más simple es vivir con Retina generando un solo dígito (el número de coincidencias de algunas expresiones regulares contra la entrada vacía), y podemos hacerlo con muchos patrones de 2 bytes que fallan (o coinciden).

Martin Ender
fuente
27
+1 Para el código que me dice que no lo ejecute: P
Christopher
33

Mathematica, 2 bytes

4!

factorial

24

J42161217
fuente
1
Gah! muy listo.
tuskiomi
2
vencerme! +1. ( Creo que debería mencionar que esto está en la versión REPL de Mathematica.)
Greg Martin
Si esta es una respuesta razonable, ¿la respuesta "1" no sería también una respuesta razonable? (Poner '1' en el REPL de Mathematica también devolvería '1' ...)
Mark Segal
3
@ MarkSegal Eso violaría la regla de no quine.
AlexR
66
Reglas: ... "... el código y la salida deben diferir en al menos un byte"
J42161217
29

C, 20 bytes

f(){printf("%20d");}

Emite algún número, rellenado con espacios hasta una longitud de 20. (¿Qué número? Pase lo que pase después en la memoria).

Algunas muestras se ejecutan en mi sistema:

llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           -666605944
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
          -1391039592
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1727404696
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
             10717352
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1485936232

Es una pena que la salida no pueda ser bytes arbitrarios, porque eso habría permitido esta solución de 19 bytes:

f(){write(1,f,19);}

que genera 19 bytes de basura, comenzando en fla dirección de.

Pomo de la puerta
fuente
Me alegra ver una respuesta que hace uso de la regla de salida variable. :)
Martin Ender
¿No podría esto segfault?
Daniel
¿Dónde están los enlaces de TIO?
CalculatorFeline
@Daniel No, el número impreso vendrá de los contenidos anteriores del %esiregistro.
Pomo de la puerta
8
@Doorknob pero todavía es un comportamiento indefinido, por lo tanto, un compilador más sádico podría hacer algo completamente diferente aquí
Sarge Borsch
29

Bash en Linux, 6

uname

(seguido de una nueva línea)

Salidas Linuxseguidas de una nueva línea.

Trauma digital
fuente
2
Técnicamente unameno es un bash incorporado - es un ejecutable separado
Jason Musgrove
@GammaFunction ¿Dónde lo ves unamecomo un bash incorporado? Cada distribución en la que puedo poner mis manos en este momento es un binario separado, incluido TIO . Por el contrario, como muestra su respuesta vinculada, umaskes una función integrada en la mayoría / todos los shells.
Trauma digital
No lo veo unamecomo un edificio. Cuando dije "-1, y en realidad un builtin", quise decir "Esta respuesta utiliza umaskpara -1 bytes, y en umaskrealidad es un builtin".
GammaFunction
@GammaFunction Lo siento: no entendí el significado del "-1" en su comentario, estoy acostumbrado a esos votos negativos y a un comentario que explica por qué.
Trauma digital
27

Javascript ES6, 9 bytes

Usar cadenas de plantillas

_=>`${_}`

f=

_=>`${_}`

console.log(f());
console.log(typeof f());

Weedoze
fuente
¿Se undefinedconsidera una cuerda?
Shaggy
3
@Shaggy Vea la edición. Estoy usando la interpolación de cadenas
Weedoze
¡Wow, esta es mi segunda publicación sobre PPCG y 14 votos a favor! Gracias
Weedoze
1
¿Por qué simple suero puede tener dificultades? (_=>_+'').
GOTO 0
1
@ GOTO0 Oh, ok, mantén el paréntesis. Esta es otra opción. Yo personalmente prefiero el mío jeje
Weedoze
24

Esquema piramidal , 74 43 42 bytes

¡Ahorré 31 bytes gracias a Khuldraeseth na'Barya! ¡Ahorrado 1 byte gracias a la solución rediseñada de JoKing!

  ^
 /^\
^---^
-^ ^-
 -^-
 /2\
/ 8 \
-----

Pruébalo en línea! Emite el número de 41 dígitos 28^28 = 33145523113253374862572728253364605812736, seguido de una nueva línea final.


Versión antigua

  ^
 / \
/out\
-----^
    /^\
   ^---^
  /1\ /9\
 /606\---
/51015\
-------

Pruébalo en línea!

Salidas 71277303925397560663333806233294794013421332605135474842607729452115234375= 160651015 ** 9, o aproximadamente 10 74 .

Conor O'Brien
fuente
66
Oye, ¿estás tratando de vender tu idioma? Si es así, estás bajo arresto. - The Cops
NoOneIsHere
2
@NoOneIsHere perdón?
Conor O'Brien
3
Lo sentimos, se llama Pyramid Scheme, que también es el nombre de un tipo de estafa.
NoOneIsHere
1
ohhhhhhhhhhhh rofl
Conor O'Brien
1
La salida implícita lo lleva a 43 bytes .
Khuldraeseth na'Barya
23

Python 2 , 9 bytes

print{+1}

Esto imprime set([1])y un salto de línea.

Pruébalo en línea!

Dennis
fuente
11
Desde los programas de fuerza bruta que comienzan con print, no hay soluciones más cortas, y los únicos de 9 bytes son variantes de esto y de Luis Mendo print 1e5 .
xnor
23

Python 2 , 9 bytes

print 1e5

La salida mostrada contiene una nueva línea final.

Pruébalo en línea!

Luis Mendo
fuente
¿Las nuevas líneas finales cuentan como un carácter hasta la salida? De lo contrario, esto imprime ocho bytes.
OldBunny2800
@ OldBunny2800 Sí, el desafío dice que si su salida contiene nuevas líneas finales, esas son parte del recuento de bytes . De todos modos, aclararé eso en mi respuesta
Luis Mendo
18

brainfuck , 25 bytes

--[-->+<]+++++[->-.....<]

Pruébalo en línea! Nota: Requiere una implementación con celdas sin signo de 8 bits

Salida:

~~~~~}}}}}|||||{{{{{zzzzz

Explicación

--[         254
 -->+<]      /2 = 127 into the second cell
+++++[      Five times
 ->-.....<]  Print the second cell - 1 five times
Zack C.
fuente
44
Hay muchas variaciones de BF, como una cinta infite de celda de 8 bits. o una cinta limitada y celdas infinitas. Estoy bastante seguro de que el suyo es un modelo de celda de 8 bits sin firmar, pero creo que sería bueno si incluye eso en su respuesta.
Roman Gräf
@ RomanGräf Buen punto! Normalmente incluyo esa información si se requiere una implementación no estándar. Esta respuesta debería funcionar en cualquier implementación estándar (celdas sin signo de 8 bits, cualquier cinta), pero agregaré una nota para aclarar.
Zack C.
¿No podría tener un programa de 1 byte .que imprima el NULLcarácter no imprimible ?
Graviton
@ Graviton Eso violaría la primera regla de este desafío. Sin embargo, esa es una solución válida en un derivado BF que por defecto es un valor imprimible (ver: mi respuesta brainbool ).
Zack C.
24 bytes
Jo King
16

C (Ideone), 14 bytes

f(){warn(0);}

En Ideone , que nombra su ejecutable prog, esto genera lo siguiente con una nueva línea final.

prog: Success

C (GCC), 15 bytes

f(){warn(00);}

Debido a que GCC escribe un ejecutable nombrado a.outpor defecto (en ausencia de indicadores adicionales que costarían bytes), esto genera lo siguiente con una nueva línea final.

a.out: Success
Anders Kaseorg
fuente
77
@MDXF La especificación dice programa o función, por lo que el envío de una función es perfectamente válido. Dado que el nombre de archivo no es elegido por el usuario aquí (tanto Ideone como gcc tienen valores predeterminados), creo que está bien (opinión personal).
Dennis
15

C (gcc) , 18 17 bytes

f(){puts('@C');}

Tenga en cuenta que hay un byte STX ( 0x02 ) entre @y C.

Pruébalo en línea!

Portabilidad

Esto se ha probado con gcc 6.3.1 y clang 3.9.1 en Fedora 25, gcc 4.8.4 en Ubuntu 14.04.4 y gcc 4.8.3 en openSUSE 13.2, donde imprime el siguiente resultado.

inux-x86-64.so.2

Espero que esto produzca el mismo resultado con todas las versiones de gcc, siempre que se compile en un ejecutable del siguiente tipo.

ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2

Las diferentes plataformas requerirán una dirección de memoria diferente y posiblemente un orden diferente para los bytes en la constante de caracteres de varios caracteres.

Por ejemplo, reemplazando @\2Ccon @\2\4impresiones exec/ld-elf.so.1y una nueva línea en FreeBSD 11 con clang 3.8.0.

Verificación fuera de línea

$ printf "%b\n" "f(){puts('@\2C');}main(){f();}" > quine.c
$ gcc -w -o quine quine.c
$ ./quine
inux-x86-64.so.2
$ ./quine | wc -c
17

Cómo funciona

Por defecto, ld usa 0x400000 como la dirección base del segmento de texto, lo que significa que podemos encontrar el contenido del ELF comenzando en la dirección de memoria 0x400000 .

Los primeros 640 bytes del ELF son en gran medida independientes del código fuente real. Por ejemplo, si la declaración de f es seguida por main(){f();}y nada más, se ven de la siguiente manera.

00000000: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00  .ELF............
00000010: 02 00 3e 00 01 00 00 00 00 04 40 00 00 00 00 00  ..>.......@.....
00000020: 40 00 00 00 00 00 00 00 e8 19 00 00 00 00 00 00  @...............
00000030: 00 00 00 00 40 00 38 00 09 00 40 00 1e 00 1b 00  [email protected]...@.....
00000040: 06 00 00 00 05 00 00 00 40 00 00 00 00 00 00 00  ........@.......
00000050: 40 00 40 00 00 00 00 00 40 00 40 00 00 00 00 00  @.@.....@.@.....
00000060: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000070: 08 00 00 00 00 00 00 00 03 00 00 00 04 00 00 00  ................
00000080: 38 02 00 00 00 00 00 00 38 02 40 00 00 00 00 00  8.......8.@.....
00000090: 38 02 40 00 00 00 00 00 1c 00 00 00 00 00 00 00  8.@.............
000000a0: 1c 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00  ................
000000b0: 01 00 00 00 05 00 00 00 00 00 00 00 00 00 00 00  ................
000000c0: 00 00 40 00 00 00 00 00 00 00 40 00 00 00 00 00  ..@.......@.....
000000d0: 04 07 00 00 00 00 00 00 04 07 00 00 00 00 00 00  ................
000000e0: 00 00 20 00 00 00 00 00 01 00 00 00 06 00 00 00  .. .............
000000f0: 08 0e 00 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..........`.....
00000100: 08 0e 60 00 00 00 00 00 1c 02 00 00 00 00 00 00  ..`.............
00000110: 20 02 00 00 00 00 00 00 00 00 20 00 00 00 00 00   ......... .....
00000120: 02 00 00 00 06 00 00 00 20 0e 00 00 00 00 00 00  ........ .......
00000130: 20 0e 60 00 00 00 00 00 20 0e 60 00 00 00 00 00   .`..... .`.....
00000140: d0 01 00 00 00 00 00 00 d0 01 00 00 00 00 00 00  ................
00000150: 08 00 00 00 00 00 00 00 04 00 00 00 04 00 00 00  ................
00000160: 54 02 00 00 00 00 00 00 54 02 40 00 00 00 00 00  T.......T.@.....
00000170: 54 02 40 00 00 00 00 00 44 00 00 00 00 00 00 00  [email protected].......
00000180: 44 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00  D...............
00000190: 50 e5 74 64 04 00 00 00 b0 05 00 00 00 00 00 00  P.td............
000001a0: b0 05 40 00 00 00 00 00 b0 05 40 00 00 00 00 00  ..@.......@.....
000001b0: 3c 00 00 00 00 00 00 00 3c 00 00 00 00 00 00 00  <.......<.......
000001c0: 04 00 00 00 00 00 00 00 51 e5 74 64 06 00 00 00  ........Q.td....
000001d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001f0: 00 00 00 00 00 00 00 00 10 00 00 00 00 00 00 00  ................
00000200: 52 e5 74 64 04 00 00 00 08 0e 00 00 00 00 00 00  R.td............
00000210: 08 0e 60 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..`.......`.....
00000220: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000230: 01 00 00 00 00 00 00 00 2f 6c 69 62 36 34 2f 6c  ......../lib64/l
00000240: 64 2d 6c 69 6e 75 78 2d 78 38 36 2d 36 34 2e 73  d-linux-x86-64.s
00000250: 6f 2e 32 00 04 00 00 00 10 00 00 00 01 00 00 00  o.2.............
00000260: 47 4e 55 00 00 00 00 00 02 00 00 00 06 00 00 00  GNU.............
00000270: 20 00 00 00 04 00 00 00 14 00 00 00 03 00 00 00   ...............

El uso, por ejemplo, main(int c, char**v){f();}cambia algunos bytes, pero no el desplazamiento de la cadena /lib64/ld-linux-x86-64.so.2, que usaremos para producir la salida.

El desplazamiento de dicha cadena es 0x238 y tiene 27 bytes de longitud. Solo queremos imprimir 17 bytes (y el último será una nueva línea si usamos puts), por lo que agregamos 11 al desplazamiento para obtener 0x243 , el desplazamiento de inux-x86-64.so.2. Agregar 0x400000 y 0x243 da 0x400243 , la ubicación de memoria de inux-x86-64.so.2.

Para obtener esta dirección de memoria, podemos usar constantes de caracteres de varios caracteres, que exhiben un comportamiento definido por la implementación. 0x400243 es (64) (2) (67) en la base 256 y las constantes de caracteres de varios caracteres de gcc usan el orden de bytes big-endian, por lo que '@\2C'produce la dirección de memoria de la cadena deseada.

Finalmente, putsimprime la picadura (terminada en nulo) en esa ubicación de memoria y una nueva línea final, creando 17 bytes de salida.

Dennis
fuente
Esto es magia ... ¿asume esto el orden de bytes del ensamblado compilado o algo así?
Patrick Roberts
Salida en mi sistema (Linux con GCC 6.3.1): Ual compilar con -Df=main. Ual compilar con main(){f();}.
MD XF
@PatrickRoberts En este momento, no estoy realmente seguro de cuáles son los supuestos. Como se asoma en el archivo ELF ensamblado, depende de todo lo que el compilador escribe antes del código real.
Dennis
@MDXF Se encontró una forma más corta de obtener una dirección de memoria adecuada. Funciona en mi Ubuntu 14.04 VPS ahora, pero ymmv.
Dennis
@Dennis funciona bien ahora (dang). La recompensa es suya si al final de la semana nadie encuentra una solución más corta.
MD XF
13

Brainfuck auto modificable , 5 bytes

<[.<]

Pruébalo en línea!

Salida:

]<.[<

Explicación:

Muy simple, imprime la fuente en reversa. En SMBF, el contenido del programa se almacena en la cinta, a la izquierda de la posición inicial del puntero. Si se desliza hacia la izquierda e imprime, el código fuente saldrá hacia atrás.

Dado que la fuente de lectura está permitida en este desafío, esto definitivamente debería estar dentro de las reglas.

Zack C.
fuente
13

Calculadora aritmética básica , 2 bytes

1=

impresiones 1.o:

    |
    |
    |  .

en esas tontas pantallas de siete segmentos.

Para reproducir, tome cualquier calculadora al azar; Todos tienen este lenguaje de programación instalado de alguna manera.

OldBunny2800
fuente
1
¿Es esto cierto para todas las calculadoras? Estoy seguro de que muestran constantemente el punto decimal
Decaimiento Beta
¿No es en 1.lugar de 1x? Además, esta es una quine, que no está permitida por las reglas.
Erik the Outgolfer
No, es que 1=me equivoqué. Quise decir 1xque es igual a implícito, pero olvidé que =es un botón.
OldBunny2800
Solo sale 1en mi TI-36 y TI-84 CE. ¿No cuentan como calculadoras "básicas"?
Benjamin Urquhart
No, una TI 84 no es una calculadora aritmética, es una calculadora gráfica. No sé sobre el 36, pero estoy bastante seguro de que es una calculadora científica. Esta respuesta es para calculadoras de cuatro funciones.
OldBunny2800
13

Fourier, 26 22 20 bytes

5^(`na`&i)` Batman!`

Pruébalo en FourIDE!

Salidas:

nananananana Batman!

Para una capitalización adecuada, son 4 bytes adicionales:

`N`7^(`an`i^~i)`a Batman!`

Pruébalo en FourIDE!

Nanananananananana Batman!

RIP Adam West

Decaimiento Beta
fuente
1
No tiene que incluir NC (solo si realizó una impresión de cadena para este desafío (y eso sería una tontería)
Christopher
@Christopher Huh, no lo sabía
Beta Decay
12

Brachylog , 1 byte

w

Pruébalo en línea!

Explicación

wes el "escribir" incorporado. Aquí, escribirá la entrada. Como la entrada es una variable libre, la wetiquetará como un entero antes de imprimir. El primer entero que intenta es 0.

Fatalizar
fuente
Here, it will write the Input.¿Es 'la entrada' el programa en sí? ¿No cuenta esto como leer la fuente, que por defecto es hacer trampa en una quine?
MD XF
44
@MDXF "Las reglas habituales de quine no se aplican"
Rob Watts
3
@MDXF La entrada es una variable especial de Brachylog que puede establecer al llamar a un programa Brachylog. Entra en la parte de entrada de TryItOnline. Aquí no establecemos nada en la entrada, por lo que es efectivamente una variable. No es el programa.
Fatalize
10

Java (OpenJDK 8) , 11 bytes

o->1e8-1+""

Pruébalo en línea!

Salida:

9.9999999E7

Sólo un poco más elaborada que la respuesta obvia, ()->"".format("%23s",0).

Ahorra

  • 18 -> 16 bytes: combinación más ventajosa de redondeo y potencia de 10, gracias a PunPun1000
  • 16 -> 13 bytes: mejor fórmula, gracias a JollyJoker
  • 13 -> 11 bytes: fórmula mejorada, gracias a Kevin Cruijssen
Olivier Grégoire
fuente
2
()->1E10-1+"", "9.999999999E9" (13)ahorra tres bytes más
JollyJoker
1
Puede guardar 1 byte cambiando 1e10a 1e9, o 2 bytes usando una entrada vacía en lugar de() esto: o->1e8-1+""(salidas 9.9999999E7; longitud y conteo de bytes 11 ).
Kevin Cruijssen
9

05AB1E , 1 byte

õ

Emite una nueva línea nueva. õempuja una cadena vacía, y se genera implícitamente con una nueva línea.

Pruébalo en línea!

Algunas otras soluciones de 2 bytes, para su placer visual (la salida está entre paréntesis y toda la salida tiene una nueva línea final):

X, (1)
Y, (2)
¾, (0)
¼, (1)
¶, (newline)
ð, (space)
Î, (0)

Sin embargo, hay muchas más soluciones de 2 bytes.

Okx
fuente
"que es un método de salida aceptado" solo para soluciones de funciones, no para programas completos.
Martin Ender
@MartinEnder ¿Entonces esas soluciones contarían como funciones? No estoy realmente seguro, ya que no suelo usar funciones aquí.
Okx
No sé lo suficiente sobre 05AB1E, pero solo se consideran funciones si en realidad son expresiones que evalúan un objeto de función (lo cual dudo que lo hagan, ya que usarlas inmediatamente hace que se ejecute el comando).
Martin Ender
9

V / vim, 1 byte

o

Esto imprime una nueva línea.

Pruébalo en línea!

Hay un montón de variantes en esto que también funcionarían. Por ejemplo,

O

en vim, y

Ä
ä
ï
Ï

en V.

También hay muchas, muchas, muchas soluciones de tres bytes. Por ejemplo:

3ii
i³i
¬ac

Todos estos son específicos de V.

DJMcMayhem
fuente
3ii no se expande hasta que presiona escape, ¿deberían ser tres o cuatro bytes (o pulsaciones de teclas, más bien)?
algmyr
@algmyr En vim, tienes razón. Tendría que ser 4ii<ESC>Sin embargo, V rellena implícitamente el escape al final del programa.
DJMcMayhem
8

Lote, 12 bytes.

@echo %OS%

El recuento de bytes incluye una nueva línea final para el script y la salida, que es

Windows_NT
Neil
fuente
Parece que son 11 bytes, no 12.
Erik the Outgolfer
@EriktheOutgolfer cmd.exe, por supuesto, hará eco de un CRLF después de Windows_NT, por lo tanto, 12 bytes.
Neil
Entonces deberías aclarar?
Erik the Outgolfer
8

Hexagonía , 3 bytes.

o!@

Pruébalo en línea!

Impresiones 111.

Desplegado:

 o !
@ . .
 . .

Pero el código realmente solo se ejecuta en el orden o!@.

o   Set the memory edge to 111, the code point of 'o'.
!   Print this value as a decimal integer.
@   Terminate the program.
Martin Ender
fuente
8

R, 7 bytes

mode(T)

Impresiones "lógicas"

Ivanneke
fuente
Bienvenido a PPCG!
Martin Ender
7

MATL , 2 bytes

H

Hay una nueva línea final.

Pruébalo en línea!

Explicación

Portapapeles H contiene número 2por defecto. Hempuja ese contenido a la pila, que se muestra implícitamente con una nueva línea final.

Luis Mendo
fuente
7

Carbón , 2 bytes

→¹

Pruébalo en línea!

Imprime una línea horizontal de longitud 1 -a la derecha y una nueva línea.

Solo ASCII
fuente
El carbón de leña es un lenguaje realmente ingenioso, debería aprenderlo en algún momento
Skidsdev
7

Gelatina , 1 byte

V

Un buen número de Jelly one byters, este es uno, evalúa el argumento izquierdo que, cuando no se proporciona nada como entrada, el valor predeterminado es cero, que a su vez se evalúa a cero y el resultado se imprime implícitamente, a 0.

Pruébalo en línea!

De hecho, de los 256 bytes en la página de códigos, solo hay 95 que actualmente no producen una salida de un byte diferente dentro del rango especificado cuando se ejecutan como un programa completo; estos son (como caracteres de página de códigos en orden de bytes):

¡¢£¦©½¿€ÇÑÞßçıȷñ÷þ"#&',-./0123456789:;?@IMRTVZ\`dmpstxyz{}~°³⁴⁵⁹ƓƈɠḶỌṬḊĖİĿṄȮṖṘẆẊṃọṣṭḃḟḣŀṁṗṡẋż’“

Notas:

  • La mayoría de los programas de 1 byte imprimen un 0(no-ops / dando una lista con un solo cero, que imprime a 0), la mayoría de los otros imprimen un 1( 0=0y similares)

  • es el programa de una que hace dar un byte diferente, pero una que está fuera del intervalo según la especificación - se produce el null-byte (yesos la 0de carácter)

  • produce un espacio (un literal)

  • produce un avance de línea (un literal)

  • Es posible que algunos bytes que funcionan ahora no lo hagan en el futuro: creo que hay unos pocos bytes reservados (creo) para valores niládicos que, cuando se asignan, es casi seguro que no producirán una salida de un byte.

Jonathan Allan
fuente
1
Enlace byte
inactivo