Escriba un programa con las siguientes propiedades:

• Cuando se ejecuta tal cual, el programa no produce salida (es decir, 0 bytes de salida).

• Hay una ubicación dentro del programa (de su elección: podría ser al principio, al final o en algún lugar en el medio) con la siguiente propiedad: modificar el programa colocando cualquier cadena allí hará que el programa resultante imprima esa cadena cuando ejecutado.

  Esto debe funcionar independientemente de si la cadena contiene comillas, barras diagonales inversas, marcas de comentario, delimitadores, bytes NUL, etc. No importa lo que coloque allí, la cadena todavía se interpreta como una cadena y se imprime textualmente. Sin embargo, puede fallar en el manejo de cadenas muy largas si causan que el compilador se quede sin memoria o algo similar (para ser precisos, al menos debería ser capaz de manejar cadenas de hasta 1000 bytes de longitud o tres veces el duración de su programa, el que sea más largo).

Un ejemplo de una solución no válida sería

print("");
#      ^ text goes here

en Python, Perl, Ruby, etc .; aunque funciona para muchas cadenas, no funcionará para una cadena que contenga una comilla doble o una cadena que contenga la subcadena \n(que se interpretaría como una nueva línea).

Tenga en cuenta que este problema es probablemente imposible en la mayoría de los idiomas; El desafío es, al menos en parte, encontrar un idioma donde funcione. El idioma elegido debe ser un lenguaje de programación según la definición de este sitio , por ejemplo, no enviar una solución en Texto .

Como se trata de un código de golf , gana la plantilla de programa más corta. Sin embargo, ¡no se desanime de enviar soluciones incluso si no pueden vencer al ganador actual! Todavía puede competir por el segundo, tercer lugar, etc., o simplemente para encontrar tantas respuestas donde funcione como sea posible. Sin embargo, debe asegurarse de que su programa cumpla con la especificación completa antes de enviarlo; las soluciones aproximadas perderían el punto del problema.

Excel, 1 byte

'

Versión sin golf

'        <-- print the following text,
             and exit the current formula

Jolf, 6 bytes

a Lq6(

Explicación

a Lq6(
a       print
  L 6   all but the first 6 characters of
   q    the source code
     (  and exit

Perl 5 , 30 21 19 bytes

imprimir <DATA> __END__

Pruébalo en línea!

Nueva línea final. Esto hace uso de una función Perl que permite agregar datos arbitrarios al archivo fuente, que luego puede leerse a través del DATAcontrolador de archivos. Cuando damos un identificador de archivo como argumento paraprint identificador de archivo , se le da un contexto de lista, lo que hace que el identificador de archivo devuelva una lista de todas las líneas del archivo, incluidas las nuevas líneas (del mismo modo, se omitirá una nueva línea en la línea final). Luego printlos concatena implícitamente a todos, deshaciendo la división en líneas y dándonos la cadena original exacta independientemente de dónde se encontraban las nuevas líneas.

Gracias a @Dada, quien se dio cuenta de que no había necesidad de manejar nuevas líneas manualmente, y @ninjalj y @b_jonas, quienes vieron un personaje que podía ser eliminado.

Zsh, 6 bytes

<<'
'

Hay una nueva línea final. La cadena se inserta al final del programa.

Golpetazo, 20 17 bytes

Gracias a Adam por eliminar 3 bytes.

exec sed 1d "$0"

* script de shell nix, 21 14 bytes

Gracias a Adam por eliminar 7 bytes.

#!/bin/sed 1d

brainfuck ( Brainfuck ilegible ), 9 bytes

,+[-.,+]!

Agregue la entrada al final. No hay una nueva línea final, esta vez.

Al buscar idiomas que aceptasen la información adjunta al final del programa, el ataque mental parecía una posibilidad distinta; Muchos intérpretes de brainfuck escritos en esolangs toman tanto el programa como la entrada del programa de la entrada estándar y, por lo tanto, necesitan alguna forma de distinguir entre ellos. Hay una convención que se usa en este caso en la que un !personaje diferencia entre el programa y la entrada, un truco que a menudo se usa para escribir programas cortos como brainfuck ,[.,]!Hello, world!; Esto básicamente crea un dialecto diferente de brainfuck en el que !tiene un significado diferente al normal.

En teoría, por lo tanto, podríamos encontrar uno de estos intérpretes y darle un catprograma para cumplir con la especificación. Sin embargo, hay una gran sutileza; brainfuck generalmente usa 256 valores para cada celda, hay 256 octetos y uno debe usarse para EOF. Entonces, si queremos poder hacer eco de los 256 octetos literalmente, no podemos detectar EOF en absoluto y tendremos que finalizar el programa de alguna otra manera. En otras palabras, necesitamos encontrar una implementación que proporcione a los 256 octetos y al EOF 257 valores diferentes, o que se bloquee en EOF.

Ingrese ilegible . Hay un intérprete de brainfuck en Unreadable que es anterior a este desafío y que acepta aportes después de un !; Además, a diferencia de la mayoría de los intérpretes de brainfuck, utiliza células bignum y -1 para EOF, lo que permite distinguir EOF de los otros 256 octetos posibles. Por lo tanto, mediante el uso de Brainreack ilegible como el intérprete específico para el programa, podemos resolver el desafío en solo 9 bytes, escribiendo un catprograma brainfuck que se detenga en EOF = -1.

¿Es posible hacerlo mejor? Bueno, podríamos probar el siguiente programa de 7 bytes, que intenta generar EOF al final de la cadena antes de que salga del bucle:

+[,.+]!

El comportamiento de este programa depende del comportamiento del intérprete ilegible en condiciones de error (por lo tanto, depende no solo de la implementación de brainfuck, sino de la implementación utilizada para ejecutar la implementación de brainfuck). Desafortunadamente, el intérprete ilegible que uso produce errores en la salida estándar , lo que significa que este ahorro no funciona. Si alguien sabe de un intérprete ilegible que sale en un intento de generar EOF, o se salta el intento en silencio, hágamelo saber; esa sería una solución de siete bytes allí mismo.

Dyalog APL , 11 bytes

El siguiente es el cuerpo de la función f :

2↓⎕CR'f'⋄→

Hay una nueva línea final, después de la cual se puede insertar cualquier cosa.

2↓ suelte las dos primeras líneas (encabezado y esta línea) de

⎕CR'f'el C r incón dele R ePresentation de f

⋄ luego

→ dejar

Rubí, 20 bytes.

imprimir * DATOS
__FIN__

La entrada va al final (después de la nueva línea final). El DATAidioma es uno de los muchos que Ruby le robó a Perl .

Pruébelo en eval.in: https://eval.in/684370

JavaScript + HTML5 DOM, 163 bytes

<html><body><script>fetch(location).then((r)=>r.text().then((t)=>console.log(t.slice(145,t.lastIndexOf("</b")))));document.body.remove()</script></body></html>

Puede insertar cualquier cosa que desee directamente antes de la etiqueta de cierre del cuerpo. Esto funciona buscando la fuente de la página y quitando el código de apertura y las etiquetas de cierre.

El verdadero pateador estaba descubriendo cómo escapar de un bucle infinito. Poner while(true){}en la página bloquea todas las devoluciones de llamadas para siempre, congelando la ejecución, y JavaScript no tiene forma de pausar el hilo principal. Sin embargo, el código que ya no existe nunca se ejecuta, por lo que el cuerpo del documento confirma seppuku en el último comando, eliminándose a sí mismo mientras espera que se cargue su clon.

Sí, es largo y rotundo, pero el simple hecho de que sea posible en JS es algo sorprendente.

PHP, 46 bytes

(incluido el salto de línea final)

<?=join([""]+file(__FILE__));halt_compiler();
STRING HERE

Sí: incluso la filefunción es binaria segura.

[""]+ reemplaza el índice 0 (primera línea del archivo) con una cadena vacía

gs2 , 4 bytes

╥¶=☼

Utiliza la codificación CP437. La cuerda va al final. ╥obtiene el código fuente, ¶presiona 4, =suelta la cantidad de caracteres principales y ☼sale.

Pruébalo en línea!

PHP 94 bytes

<?$f=fopen(__FILE__,'rb');fseek($f,93);while(false!==($c=fgetc($f)))echo$c;__halt_compiler();

Coloque su cadena después del punto y coma final.

¿Yay por características oscuras, supongo? __halt_compiler () hace exactamente lo que esperarías del nombre. El código anterior simplemente abre el archivo y escribe los bytes después del último punto y coma en stdout. NUL, BEL, etc. salen bien. Los literales Unicode (♪) se arruinan en Windows, pero creo que es solo un error de cmd de Windows en Unicode.

Perl 6 , 23 bytes

print $=finish
=finish

La cadena se coloca comenzando en la nueva línea después =finish.

PHP, 48 60 bytes

<?=substr(file_get_contents(__FILE__),60);__halt_compiler();STRING HERE

Acabo de darme cuenta de que cerrar PHP no impide que la cadena contenga <?.

Cálculo Lambda Binario , 1 byte

 [text goes here]

Ese es un espacio único (0x20) antes del texto.

Pruébalo en línea!

Cómo funciona

0x20 = 00100000 ₂ se analiza como

00    λx.
01        x
0000  (ignored, can be anything)

(De hecho, cualquiera de los personajes !"#$%&\'()*+,-./funcionará igual de bien).

Como se trata de una expresión completa, el resto del programa se interpreta como datos de entrada y, según las convenciones de E / S de cálculo binario lambda, la función de identidad λ x. x copia la entrada directamente a la salida.

Bash, 17 bytes

tail -n+3 $0
exit
<string here>

Desarrollado independientemente de la respuesta de jimmy23013 .

RProgN , 19 Bytes

Q 19 Q L sub exit 

Tenga en cuenta el espacio final.

Inserte cualquier texto después de ese fragmento y se imprimirá.

Basado en la respuesta gs2 de Lynn .

Pruébalo en línea!

Excel VBA, 6 bytes

Esto es principalmente para responder la pregunta de cómo imprimir el texto tal como se encuentra en la Respuesta de Adam a la Ventana Inmediatos en el entorno VBA

Configuración básica:

En la celda A1 en la hoja activa, use la fórmula a continuación para mantener la cadena que se imprimirá. En aras del conteo de bytes, esto agregará 1 byte

'[Your Text Here]

p.ej:

'Hello 
World

Función de ventana inmediata, 5 + 1 = 6 bytes

?[A1]

+1 Byte para un 'en la celda A1

Vim (en modo ex), 28 bytes

#!/bin/ex -c ':1d' -c ':wq'
[string]

28 bytes incluye la última línea nueva.

Vim, 738 bytes

:imap <esc> <c-v><esc>
:imap <c-a> <c-v><c-a>
:imap <c-b> <c-v><c-b>
:imap <c-c> <c-v><c-c>
:imap <c-d> <c-v><c-d>
:imap <c-e> <c-v><c-e>
:imap <c-f> <c-v><c-f>
:imap <c-g> <c-v><c-g>
:imap <c-h> <c-v><c-h>
:imap <c-i> <c-v><c-i>
:imap <c-j> <c-v><c-j>
:imap <c-k> <c-v><c-k>
:imap <c-l> <c-v><c-l>
:imap <c-m> <c-v><c-m>
:imap <c-n> <c-v><c-n>
:imap <c-o> <c-v><c-o>
:imap <c-p> <c-v><c-p>
:imap <c-q> <c-v><c-q>
:imap <c-r> <c-v><c-r>
:imap <c-s> <c-v><c-s>
:imap <c-t> <c-v><c-t>
:imap <c-u> <c-v><c-u>
:imap <c-v> <c-v><c-v>
:imap <c-w> <c-v><c-w>
:imap <c-x> <c-v><c-x>
:imap <c-y> <c-v><c-y>
:imap <c-z> <c-v><c-z>
:imap <c-@> <c-v><c-@>
:imap <c-\> <c-v><c-\>
:imap <c-]> <c-v><c-]>
:imap <c-^> <c-v><c-^>
:imap <c-?> <c-v><c-?>
i

Vuelve a unir todos los caracteres de control en modo de inserción <c-v>, seguido de ese carácter de control, que los ingresará literalmente. ^ _ (separador de unidades) no parece necesitar un nuevo enlace, ya que se genera literalmente de forma predeterminada.

El texto variable viene al final, por supuesto.