Escreva um programa com as seguintes propriedades:

• Quando executado como está, o programa não produz saída (ou seja, 0 bytes de saída).

• Há um local dentro do programa (de sua escolha: ele pode estar no início, no final ou em algum lugar no meio) com a seguinte propriedade: modificar o programa colocando qualquer string, fará com que o programa resultante imprima essa string quando executado.

  Isso deve funcionar independentemente de a string conter aspas, barras invertidas, marcas de comentários, delimitadores, bytes NUL, etc .; não importa o que você coloque lá, a string ainda será interpretada como uma string e impressa inteiramente literalmente. No entanto, você pode falhar ao lidar com seqüências de caracteres muito muito longas se elas causarem falta de memória no compilador ou algo semelhante (para ser preciso, você deve pelo menos ser capaz de lidar com seqüências de caracteres de até 1000 bytes de comprimento ou três vezes a duração do seu programa, o que for maior).

Um exemplo de solução inválida seria

print("");
#      ^ text goes here

em Python, Perl, Ruby, etc .; embora funcione para muitas cadeias, não funcionará para uma cadeia que contenha aspas duplas ou uma cadeia que contenha a substring \n(que seria interpretada como uma nova linha).

Observe que esse problema é provavelmente impossível na maioria dos idiomas; o desafio é pelo menos parcialmente encontrar uma linguagem em que ela funcione. O idioma escolhido deve ser uma linguagem de programação sob a definição deste site , por exemplo, não enviar uma solução em texto .

Como este é um código de golfe , o modelo de programa mais curto vence. No entanto, não desanime de enviar soluções, mesmo que não possam vencer o atual vencedor! Você ainda pode competir pelo segundo, terceiro, etc. lugar, ou simplesmente encontrar o maior número de respostas possível. No entanto, você deve garantir que seu programa atenda a toda a especificação antes de enviá-la; soluções aproximadas perderiam o objetivo do problema.

Excel, 1 byte

'

Versão ungolfed

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

Jolf, 6 bytes

a Lq6(

Explicação

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__

Experimente online!

Nova linha à direita. Isso faz uso de um recurso Perl que permite que dados arbitrários sejam anexados ao arquivo de origem, que pode ser lido através do DATAmanipulador de arquivos . Quando damos um tratamento de arquivo como argumento print, é fornecido um contexto de lista, o que faz com que o tratamento de arquivo retorne uma lista de todas as linhas do arquivo, incluindo novas linhas (da mesma forma, uma nova linha na linha final será omitida). Em seguida, printconcatena implicitamente todos eles, desfazendo a divisão em linhas e fornecendo a string original exata, independentemente de onde estavam as novas linhas.

Agradecemos a @Dada, que percebeu que não havia necessidade de lidar com novas linhas manualmente, e a @ninjalj e @b_jonas, que descobriram um personagem que poderia ser jogado fora.

Zsh, 6 bytes

<<'
'

Há uma nova linha à direita. A sequência é inserida no final do programa.

Bater, 20 17 bytes

Agradecemos a Adam por remover 3 bytes.

exec sed 1d "$0"

* script nix shell, 21 14 bytes

Agradecimentos a Adam por remover 7 bytes.

#!/bin/sed 1d

brainfuck ( Brainfuck ilegível ), 9 bytes

,+[-.,+]!

Anexe a entrada ao final. Não há uma nova linha à direita, desta vez.

Procurando por linguagens que aceitassem informações anexadas ao final do programa, o cérebro parecia uma possibilidade distinta; muitos intérpretes escritos em esolangs recebem tanto do programa quanto da entrada do programa da entrada padrão e, portanto, precisam de alguma maneira de diferenciar entre eles. Existe uma convenção usada neste caso em que um !caractere diferencia entre o programa e a entrada, um truque que costuma ser usado para escrever programas curtos de foda cerebral ,[.,]!Hello, world!; isso basicamente cria um dialeto diferente do cérebro em que !tem um significado diferente do normal.

Em teoria, portanto, poderíamos apenas encontrar um desses intérpretes e dar a ele um catprograma para atender às especificações. Há uma grande sutileza, no entanto; O brainfuck normalmente usa 256 valores para cada célula, existem 256 octetos e um precisa ser usado para EOF. Portanto, se queremos ecoar todos os 256 octetos literalmente, não conseguimos detectar o EOF e precisamos encerrar o programa de outra maneira. Em outras palavras, precisamos encontrar uma implementação que dê aos 256 octetos e ao EOF 257 valores diferentes ou que trava no EOF.

Digite Ilegível . Existe um intérprete com cérebro em Unreadable que antecede esse desafio e que aceita informações após um !; Além disso, ao contrário da maioria dos intérpretes de cérebro, ele usa células bignum e -1 para EOF, permitindo que o EOF se diferencie dos outros 256 octetos possíveis. Assim, usando o Uninfable Brainfuck como intérprete específico para o programa, podemos resolver o desafio em apenas 9 bytes, escrevendo um catprograma de brainfuck que pára em EOF = -1.

É possível fazer melhor? Bem, podemos tentar o seguinte programa de 7 bytes, que tentativas de saída EOF no final da corda antes de quebrar fora do loop:

+[,.+]!

O comportamento deste programa depende do comportamento do intérprete ilegível em condições de erro (portanto, depende não apenas da implementação do brainfuck, mas da implementação usada para executar a implementação do brainfuck). Infelizmente, o intérprete ilegível que utilizo gera erros na saída padrão , o que significa que essa economia não funciona. Se alguém souber de um intérprete ilegível que sai em uma tentativa de gerar EOF ou ignora a tentativa silenciosamente, informe-me; isso seria uma solução de sete bytes ali.

Dyalog APL , 11 bytes

A seguir está o corpo da função f :

2↓⎕CR'f'⋄→

Há uma nova linha à direita, após a qual qualquer coisa pode ser inserida.

2↓ solte as duas primeiras linhas (cabeçalho e esta linha) de

⎕CR'f'o C haracter R ePresentation de f

⋄ então

→ Sair

Ruby, 20 bytes

print * DATA
__FIM__

A entrada vai no final (após a nova linha à direita). O DATAidioma é um dos muitos que Ruby roubou do Perl .

Experimente no eval.in: https://eval.in/684370

JavaScript + DOM HTML5, 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>

Você pode inserir qualquer coisa diretamente antes da etiqueta do corpo de fechamento. Isso funciona buscando a fonte da página e removendo o código de abertura e as tags de fechamento.

O verdadeiro kicker estava descobrindo como escapar de um loop infinito. A inserção while(true){}da página bloqueia todos os retornos de chamada para sempre, congelando a execução, e o JavaScript não tem como interromper o encadeamento principal. No entanto, o código que não existe mais nunca é executado, portanto, o corpo do documento confirma seppuku no último comando, excluindo-se enquanto aguarda o carregamento do clone.

Sim, é longo e indireto, mas o simples fato de ser possível no JS é incrível.

PHP, 46 bytes

(incluindo a quebra de linha à direita)

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

Sim: até a filefunção é binária segura.

[""]+ substitui o índice 0 (primeira linha do arquivo) por uma sequência vazia

gs2 , 4 bytes

╥¶=☼

Usa a codificação CP437. A corda vai no final. ╥obtém o código-fonte, ¶pressiona 4, =descarta muitos caracteres ☼iniciais e sai.

Experimente online!

PHP 94 bytes

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

Coloque sua sequência após o ponto e vírgula final.

Yay para características obscuras, eu acho? __halt_compiler () faz exatamente o que você esperaria do nome. O código anterior apenas abre o arquivo e grava todos os bytes após esse último ponto e vírgula em stdout. NUL, BEL etc sair bem. Literais Unicode (♪) são estragados no Windows, mas acho que é apenas o cmd do Windows que falha no unicode.

Perl 6 , 23 bytes

print $=finish
=finish

A string é colocada começando na nova linha depois =finish.

PHP, 48 60 bytes

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

Apenas percebi que o fechamento do PHP não impede que a string contenha <?.

Cálculo binário de Lambda , 1 byte

 [text goes here]

Esse é um espaço único (0x20) antes do texto.

Experimente online!

Como funciona

0x20 = 00100000 ₂ é analisado como

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

(De fato, qualquer um dos personagens !"#$%&\'()*+,-./funcionará igualmente bem.)

Como essa é uma expressão completa, o restante do programa é interpretado como dados de entrada e, nas convenções de E / S do cálculo lambda binário, a função de identidade λ x. x copia a entrada diretamente para a saída.

Bash, 17 bytes

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

Desenvolvido independentemente da resposta de jimmy23013 .

RProgN , 19 bytes

Q 19 Q L sub exit 

Observe o espaço à direita.

Insira qualquer texto após esse pedaço e ele será impresso.

Baseado na resposta gs2 de Lynn .

Experimente Online!

Excel VBA, 6 bytes

Isso é principalmente para responder à pergunta de como imprimir o texto, conforme mantido na resposta de Adam à janela Immediates no ambiente VBA

Configuração básica:

Na célula A1 da planilha ativa, use a fórmula abaixo para manter a sequência a ser impressa. Por uma questão de contagem de bytes, isso adicionará 1 Byte

'[Your Text Here]

por exemplo:

'Hello 
World

Função de janela de intermediários, 5 + 1 = 6 bytes

?[A1]

+1 byte para um 'na célula A1

Vim (no modo ex), 28 bytes

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

28 bytes está incluindo a última nova linha.

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

Reinicia todos os caracteres de controle no modo de inserção <c-v>, seguidos por esse caractere de controle, que os inserirá literalmente. ^ _ (separador de unidade) não parece precisar ser religado, pois é gerado literalmente por padrão.

O texto variável vem no final, é claro.