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 código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Tabla de clasificación

var QUESTION_ID=121056,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

C (Linux moderno), 19 bytes

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

Cuando se compila y ejecuta, esto imprime:

Segmentation fault

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.

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.

Bash (solo integrado), 8 bytes

{e,,}cho

Impresiones cho choy una nueva línea.

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

Mathematica, 2 bytes

4!

factorial

24

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.

Bash en Linux, 6

uname

(seguido de una nueva línea)

Salidas Linuxseguidas de una nueva línea.

Javascript ES6, 9 bytes

Usar cadenas de plantillas

_=>`${_}`

f=

_=>`${_}`

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

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 ⁷⁴ .

Python 2 , 9 bytes

print{+1}

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

Pruébalo en línea!

Python 2 , 9 bytes

print 1e5

La salida mostrada contiene una nueva línea final.

Pruébalo en línea!

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

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

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  ....@.8...@.....
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  T.@.....D.......
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.

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.

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.

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}

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.

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

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.

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.

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

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.

/// , 12 bytes

/a/bcd/aaaa/

Pruébalo en línea!

Esto se imprime bcdbcdbcdbcd, y como son 12 bytes, agregué un código inofensivo / al final del código para rellenarlo.

R, 7 bytes

mode(T)

Impresiones "lógicas"

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.

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.

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.

Befunge , 2 bytes

.@

Pruébalo en línea!

Imprime 0con un espacio final. También funciona en Befunge 98.