Ecrivez un programme avec les propriétés suivantes:

• Lorsqu'il est exécuté tel quel, le programme ne génère aucune sortie (c'est-à-dire 0 octet de sortie).

• Il y a un emplacement dans le programme (de votre choix: il pourrait être au début, à la fin ou quelque part au milieu) avec la propriété suivante: modifier le programme en y plaçant une chaîne quelconque entraînera son impression par le programme résultant réalisé.

  Cela doit fonctionner que la chaîne contienne des guillemets, des barres obliques inverses, des marques de commentaire, des délimiteurs, des octets NUL, etc. peu importe ce que vous placez là-bas, la chaîne est toujours interprétée comme une chaîne et imprimée intégralement. Cependant, vous pouvez ne pas gérer de très longues chaînes si le compilateur manque de mémoire ou autre (pour être plus précis, vous devriez au moins pouvoir gérer des chaînes allant jusqu'à 1000 octets de long ou trois fois plus longues). durée de votre programme, selon la durée la plus longue).

Un exemple de solution non valide serait

print("");
#      ^ text goes here

en Python, Perl, Ruby, etc .; bien que cela fonctionne pour de nombreuses chaînes, cela ne fonctionnera pas pour une chaîne contenant un guillemet double ou une chaîne contenant la sous-chaîne \n(qui serait interprétée comme une nouvelle ligne).

Notez que ce problème est probablement impossible dans la plupart des langues; le défi consiste au moins partiellement à trouver une langue où cela fonctionne. La langue que vous avez choisie doit être un langage de programmation au sens de la définition de ce site , par exemple, aucune soumission de solution en texte .

S'agissant d'un code-golf , le modèle de programme le plus court l'emporte. Cependant, ne vous découragez pas de soumettre des solutions, même s'ils ne peuvent pas battre le gagnant actuel! Vous pouvez toujours concourir pour les deuxième, troisième places, etc. ou simplement pour trouver autant de réponses que possible. Cependant, vous devez vous assurer que votre programme respecte l'intégralité de la spécification avant de le soumettre. Des solutions approximatives passeraient à côté du problème.

Excel, 1 octet

'

Version non-golfée

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

Jolf, 6 octets

a Lq6(

Explication

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

Perl 5 , 30 21 19 octets

print <DATA> __ END__

Essayez-le en ligne!

Retour à la ligne. Cela utilise une fonctionnalité Perl qui permet d’ajouter des données arbitraires au fichier source, qui peuvent ensuite être lues via le DATAdescripteur de fichier . Lorsque nous donnons un descripteur de fichier en argument print, un contexte de liste lui est attribué, ce qui lui permet de renvoyer une liste de toutes les lignes du fichier, y compris les nouvelles lignes (de même que les nouvelles lignes de la dernière ligne seront omises). Puis, printimplicitement, tous les enchaînent, annulant la division en lignes et nous donnant la chaîne originale exacte, quel que soit l'emplacement des nouvelles lignes.

Merci à @Dada, qui s'est rendu compte qu'il n'était pas nécessaire de gérer les nouvelles lignes manuellement, et à @ninjalj et @b_jonas, qui ont repéré un personnage qui pourrait être joué au golf.

Zsh, 6 octets

<<'
'

Il y a un retour à la ligne. La chaîne est insérée à la fin du programme.

Frapper, 20 17 octets

Merci à Adam d' avoir supprimé 3 octets.

exec sed 1d "$0"

* script shell nix, 21 14 octets

Merci à Adam d' avoir supprimé 7 octets.

#!/bin/sed 1d

brainfuck ( Unfeadable Brainfuck ), 9 octets

,+[-.,+]!

Ajoutez l'entrée à la fin. Il n'y a pas de retour à la ligne, cette fois.

À la recherche de langues acceptant les contributions ajoutées à la fin du programme, le brainfuck semblait être une possibilité distincte; de nombreux interprètes de brainfuck écrits en esolangs prennent à la fois le programme et l'entrée du programme dans l'entrée standard, et ont donc besoin d'un moyen de faire la distinction entre eux. Dans ce cas, il existe une convention selon laquelle un !personnage différencie le programme de l'entrée, une astuce souvent utilisée pour écrire de courts programmes de type brainfuck ,[.,]!Hello, world!. cela crée fondamentalement un dialecte différent de brainfuck dans lequel !a une signification différente de la normale.

En théorie, nous pourrions donc simplement trouver un de ces interprètes et lui donner un catprogramme afin de répondre à la spécification. Il y a une grande subtilité, cependant; brainfuck utilise généralement 256 valeurs pour chaque cellule, il y a 256 octets et il faut en utiliser une pour EOF. Donc, si nous voulons pouvoir faire écho littéralement les 256 octets, nous ne pouvons pas détecter EOF du tout et nous devrons mettre fin au programme d'une autre manière. En d'autres termes, nous devons trouver une implémentation donnant soit des valeurs différentes aux 256 octets et 257 EOF, soit une panne sur EOF.

Entrez illisible . Un illisible interprète un cerveau qui précède ce défi et accepte les entrées après un !; de plus, contrairement à la plupart des interpréteurs brainfuck, il utilise des cellules bignum et -1 pour EOF, ce qui permet de distinguer EOF des 256 autres octets possibles. Ainsi, en utilisant Unfeadable Brainfuck comme interprète spécifique du programme, nous pouvons résoudre le problème en seulement 9 octets, via l'écriture d'un catprogramme de brainfuck qui s'arrête sur EOF = -1.

Est-il possible de faire mieux? Eh bien, nous pourrions essayer le programme suivant de 7 octets, qui tente de produire un fichier EOF à la fin de la chaîne avant qu'elle ne sorte de la boucle:

+[,.+]!

Le comportement de ce programme dépend du comportement de l'interprète Unreadable sur les conditions d'erreur (donc, cela dépend non seulement de la mise en œuvre de brainfuck, mais de la mise en œuvre utilisée pour exécuter la mise en œuvre de brainfuck). Malheureusement, l'interpréteur illisible que j'utilise génère des erreurs de sortie sur une sortie standard , ce qui signifie que cette sauvegarde ne fonctionne pas. Si quelqu'un connaît un interprète illisible qui tente de produire une sortie EOF ou l'ignore silencieusement, faites-le-moi savoir; ce serait une solution de sept octets juste là.

Dyalog APL , 11 octets

Ce qui suit est le corps de la fonction f :

2↓⎕CR'f'⋄→

Il y a une fin de ligne, après quoi tout peut être inséré.

2↓ déposer les deux premières lignes (en-tête et cette ligne) de

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

⋄ puis

→ quitter

Ruby, 20 octets

print * DATA
__FIN__

L'entrée se termine à la fin (après la fin de la dernière ligne). L' DATAidiome est l'un des nombreux objets que Ruby a volés à Perl .

Essayez-le sur eval.in: https://eval.in/684370

JavaScript + HTML5 DOM, 163 octets

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

Vous pouvez insérer ce que vous voulez directement avant la balise body de fermeture. Cela fonctionne en récupérant le source de la page et en supprimant le code d'ouverture et les balises de fermeture.

Le vrai kicker était de savoir comment échapper à une boucle infinie. Mettre while(true){}dans la page bloque tous les rappels pour toujours, geler l'exécution, et JavaScript n'a aucun moyen de suspendre le thread principal. Cependant, le code qui n'existe plus ne s'exécute jamais et le corps du document valide alors seppuku dans la toute dernière commande, puis se supprime pendant l'attente du chargement de son clone.

Oui, c'est long et détourné, mais le simple fait que ce soit possible dans JS est assez surprenant.

PHP, 46 octets

(y compris le saut de ligne de fuite)

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

Oui, même la filefonction est sécurisée en binaire.

[""]+ remplace l'index 0 (première ligne du fichier) par une chaîne vide

gs2 , 4 octets

╥¶=☼

Utilise le codage CP437. La chaîne va à la fin. ╥récupère le code source, ¶appuie sur 4, =supprime le nombre de caractères principaux et ☼quitte.

Essayez-le en ligne!

PHP 94 octets

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

Placez votre chaîne après le dernier point-virgule.

Yay pour les fonctionnalités obscures je suppose? __halt_compiler () fait exactement ce que vous attendez du nom. Le code précédent ouvre simplement le fichier et écrit tous les octets postérieurs au dernier point-virgule sur la sortie standard. NUL, BEL etc. vont bien. Les littéraux Unicode () sont bousillés sous Windows mais je pense que c'est juste que Windows cmd échoue à Unicode.

Perl 6 , 23 octets

print $=finish
=finish

La chaîne est placée à partir de la nouvelle ligne après =finish.

PHP, 48 60 octets

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

Je viens de prendre conscience que la fermeture de PHP n'empêche pas la chaîne de contenir <?.

Lambda Calcul binaire , 1 octet

 [text goes here]

C'est un espace unique (0x20) avant le texte.

Essayez-le en ligne!

Comment ça marche

0x20 = 00100000 ₂ est analysé comme

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

(Donc, en fait, tous les personnages !"#$%&\'()*+,-./fonctionneront aussi bien.)

S'agissant d'une expression complète, le reste du programme est interprété comme une donnée d'entrée et, selon les conventions d'entrée-sortie du calcul lambda binaire, la fonction d'identité λ x. x copie directement l'entrée dans la sortie.

Bash, 17 octets

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

Développé indépendamment de la réponse de jimmy23013 .

RProgN , 19 octets

Q 19 Q L sub exit 

Notez l'espace de fuite.

Insérez n'importe quel texte après ce morceau et il sera imprimé.

Basé sur la réponse GS2 de Lynn .

Essayez-le en ligne!

Excel VBA, 6 octets

Il s’agit principalement de répondre à la question de savoir comment imprimer le texte tel la fenêtre Réponse de Adam à la fenêtre Immédiat dans l'environnement VBA.

Configuration de base:

Dans la cellule A1 de la feuille active, utilisez la formule ci-dessous pour contenir la chaîne à imprimer. Pour bien compter les octets, il faut ajouter 1 octet.

'[Your Text Here]

par exemple:

'Hello 
World

Fonction de fenêtre immédiate, 5 + 1 = 6 octets

?[A1]

+1 octet pour un 'dans la cellule A1

Vim (en mode ex), 28 octets

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

28 octets incluent la dernière nouvelle ligne.

Vim, 738 octets

: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

Rappelle tous les caractères de contrôle en mode insertion à <c-v> , suivi de ce caractère de contrôle, qui les entrera littéralement. ^ _ (unité séparateur) ne semble pas avoir besoin d'être ré-associé, car il est sorti littéralement par défaut.

Le texte variable vient à la fin, bien sûr.