Scrivi un programma con le seguenti proprietà:

• Quando eseguito così com'è, il programma non produce output (ovvero 0 byte di output).

• C'è una posizione all'interno del programma (di tua scelta: potrebbe essere all'inizio, alla fine o da qualche parte nel mezzo) con la seguente proprietà: modificando il programma posizionando qualsiasi stringa, il programma risultante stampa quella stringa quando eseguito.

  Questo deve funzionare indipendentemente dal fatto che la stringa contenga virgolette, barre rovesciate, segni di commento, delimitatori, byte NUL, ecc .; indipendentemente da ciò che si inserisce, la stringa viene comunque interpretata come una stringa e stampata interamente alla lettera. Tuttavia, è possibile non riuscire a gestire stringhe molto lunghe se causano l'esaurimento della memoria del compilatore o simili (per essere precisi, si dovrebbe almeno essere in grado di gestire stringhe fino a 1000 byte di lunghezza o tre volte la lunghezza del programma, a seconda di quale è più lungo).

Un esempio di soluzione non valida sarebbe

print("");
#      ^ text goes here

in Python, Perl, Ruby, ecc .; sebbene funzioni per molte stringhe, non funzionerà per una stringa contenente una virgoletta doppia o una stringa contenente la sottostringa \n(che sarebbe interpretata come una nuova riga).

Si noti che questo problema è probabilmente impossibile nella maggior parte delle lingue; la sfida riguarda almeno parzialmente la ricerca di una lingua in cui funziona. La lingua scelta deve essere un linguaggio di programmazione in base alla definizione di questo sito , ad esempio non inviare una soluzione in testo .

Poiché si tratta di un codice-golf , vince il modello di programma più breve. Tuttavia, non scoraggiarti dal presentare soluzioni anche se non possono battere l'attuale vincitore! Puoi ancora competere per il secondo, terzo, ecc., O semplicemente per trovare quante più risposte possibili dove funziona. Tuttavia, è necessario assicurarsi che il programma soddisfi l'intera specifica prima di inviarlo; soluzioni approssimative perderebbero il punto del problema.

Excel, 1 byte

'

Versione Ungolfed

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

Jolf, 6 byte

a Lq6(

Spiegazione

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

Perl 5 , 30 21 19 byte

stampare <DATI> __ END__

Provalo online!

Newline finale. Questo utilizza una funzione Perl che consente di aggiungere dati arbitrari al file sorgente, che possono quindi essere letti tramite il DATAfilehandle. Quando diamo un filehandle come argomento a print, viene dato un contesto di lista, che fa sì che il filehandle restituisca un elenco di tutte le linee nel file, comprese le nuove linee (allo stesso modo, una nuova linea sull'ultima linea verrà omessa). Quindi printli concatena implicitamente tutti, annullando la divisione in linee e dandoci l'esatta stringa originale indipendentemente da dove fossero le nuove linee.

Grazie a @Dada, che ha capito che non era necessario gestire manualmente le nuove linee, e @ninjalj e @b_jonas, che hanno individuato ognuno un personaggio che poteva essere eliminato.

Zsh, 6 byte

<<'
'

C'è una nuova riga finale. La stringa viene inserita alla fine del programma.

bash, 20 17 byte

Grazie ad Adam per aver rimosso 3 byte.

exec sed 1d "$0"

* script di shell nix, 21 14 byte

Grazie ad Adam per aver rimosso 7 byte.

#!/bin/sed 1d

brainfuck ( Brainfuck illeggibile ), 9 byte

,+[-.,+]!

Aggiungi l'input alla fine. Non c'è una nuova riga finale, questa volta.

Alla ricerca di lingue che accettassero input aggiunti alla fine del programma, Brainfuck sembrava una possibilità distinta; molti interpreti brainfuck scritti in esolang prendono il programma e l'input del programma dall'input standard e quindi hanno bisogno di un modo per distinguerli. C'è una convenzione che viene utilizzata in questo caso in cui un !personaggio distingue tra il programma e l'input, un trucco che viene spesso usato per scrivere brevi programmi brainfuck come ,[.,]!Hello, world!; questo fondamentalmente crea un dialetto diverso di brainfuck in cui !ha un significato diverso dal normale.

In teoria, quindi, potremmo semplicemente trovare uno di questi interpreti e dargli un catprogramma per soddisfare le specifiche. C'è una grande finezza, però; brainfuck usa tipicamente 256 valori per ogni cella, ci sono 256 ottetti e uno deve essere usato per EOF. Quindi, se vogliamo essere in grado di echeggiare letteralmente tutti i 256 ottetti, non possiamo affatto rilevare EOF e dovremo terminare il programma in altro modo. In altre parole, dobbiamo trovare un'implementazione che dia ai 256 ottetti e 257 EOF valori diversi o che si arresti in modo anomalo su EOF.

Inserisci illeggibile . C'è un interprete brainfuck in Unreadable che precede questa sfida e che accetta input dopo un !; inoltre, a differenza della maggior parte degli interpreti brainfuck, utilizza cellule di bignum e -1 per EOF, permettendo a EOF di distinguersi dagli altri 256 possibili ottetti. Pertanto, utilizzando Illeggibile Brainfuck come interprete specifico per il programma, possiamo risolvere la sfida in soli 9 byte, scrivendo un catprogramma Brainfuck che si arresta su EOF = -1.

È possibile fare di meglio? Bene, potremmo provare il seguente programma a 7 byte, che tenta di emettere EOF alla fine della stringa prima che si interrompa dal ciclo:

+[,.+]!

Il comportamento di questo programma dipende dal comportamento dell'interprete illeggibile dalle condizioni di errore (quindi, dipende non solo dall'implementazione di brainfuck, ma dall'implementazione utilizzata per eseguire l'implementazione di brainfuck). Sfortunatamente, l'interprete illeggibile che utilizzo genera errori di output su output standard , il che significa che questo salvataggio non funziona. Se qualcuno è a conoscenza di un interprete illeggibile che esce nel tentativo di emettere EOF o salta silenziosamente il tentativo, fammi sapere; sarebbe una soluzione a sette byte proprio lì.

Dyalog APL , 11 byte

Di seguito è riportato il corpo della funzione f :

2↓⎕CR'f'⋄→

C'è una nuova riga finale, dopo la quale è possibile inserire qualsiasi cosa.

2↓ rilasciare le prime due righe (intestazione e questa riga) di

⎕CR'f'il C haracter R appresentanza di f

⋄ poi

→ smettere

Rubino, 20 byte

stampa * DATI
__FINE__

L'input va alla fine (dopo la nuova riga finale). Il DATAlinguaggio è uno dei tanti che Ruby ha rubato al Perl .

Provalo su eval.in: https://eval.in/684370

JavaScript + HTML5 DOM, 163 byte

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

Puoi inserire qualsiasi cosa ti piaccia direttamente prima del tag body di chiusura. Funziona recuperando l'origine della pagina e rimuovendo il codice di apertura e i tag di chiusura.

Il vero kicker stava scoprendo come sfuggire a un loop infinito. Mettere while(true){}nella pagina blocca per sempre tutti i callback, bloccando l'esecuzione e JavaScript non ha modo di mettere in pausa il thread principale. Tuttavia, il codice che non esiste più non viene mai eseguito, quindi il corpo del documento commette seppuku nell'ultimo comando, cancellandosi mentre attende il caricamento del suo clone.

Sì, è lunga e rotonda, ma il semplice fatto che sia possibile in JS è sorprendente.

PHP, 46 byte

(incluso l'interruzione di riga finale)

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

Sì: anche la filefunzione è binaria sicura.

[""]+ sostituisce l'indice 0 (prima riga del file) con una stringa vuota

gs2 , 4 byte

╥¶=☼

Utilizza la codifica CP437. La stringa va alla fine. ╥ottiene il codice sorgente, ¶spinge 4, =rilascia molti personaggi principali ed ☼esce.

Provalo online!

PHP 94 byte

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

Posiziona la stringa dopo il punto e virgola finale.

Sì per le caratteristiche oscure immagino? __halt_compiler () fa esattamente quello che ti aspetteresti dal nome. Il codice precedente apre semplicemente il file e scrive tutti i byte dopo l'ultimo punto e virgola su stdout. NUL, BEL ecc. Escono bene. I letterali Unicode (♪) si rovinano su Windows ma penso che sia solo un errore del cmd di Windows in Unicode.

Perl 6 , 23 byte

print $=finish
=finish

La stringa viene posizionata a partire dalla riga successiva dopo =finish.

PHP, 48 60 byte

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

Ho appena saputo che la chiusura di PHP non impedisce al contenuto della stringa <?.

Calcolo lambda binario , 1 byte

 [text goes here]

Questo è un singolo spazio (0x20) prima del testo.

Provalo online!

Come funziona

0x20 = 00100000 ₂ viene analizzato come

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

(Quindi, in effetti, tutti i personaggi !"#$%&\'()*+,-./funzioneranno ugualmente bene.)

Poiché questa è un'espressione completa, il resto del programma viene interpretato come dati di input e, in base alle convenzioni di I / O sul calcolo del lambda binario, la funzione di identità λ x. x copia l'input direttamente nell'output.

Bash, 17 byte

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

Sviluppato indipendentemente dalla risposta di jimmy23013 .

RProgN , 19 byte

Q 19 Q L sub exit 

Nota lo spazio finale.

Inserisci qualsiasi testo dopo quel pezzo e verrà stampato.

Basato sulla risposta gs2 di Lynn .

Provalo online!

Excel VBA, 6 byte

Ciò serve principalmente a rispondere alla domanda su come stampare il testo contenuto nella risposta di Adam alla finestra immediata nell'ambiente VBA

Configurazione di base:

Nella cella A1 del foglio attivo utilizzare la formula seguente per contenere la stringa da stampare. Per motivi di conteggio dei byte, questo deve aggiungere 1 byte

'[Your Text Here]

per esempio:

'Hello 
World

Funzione finestra immediata, 5 + 1 = 6 byte

?[A1]

+1 byte per a 'nella cella A1

Vim (in modalità ex), 28 byte

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

28 byte include l'ultima riga.

Vim, 738 byte

: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

Ricollega tutti i caratteri di controllo in modalità inserimento a <c-v> , seguiti da quel carattere di controllo, che li inserirà letteralmente. ^ _ (separatore unità) non sembra aver bisogno di essere ricollegato, poiché viene emesso letteralmente per impostazione predefinita.

Il testo della variabile arriva alla fine, ovviamente.