Un quine fragile

Un quine fragile est un quine qui satisfait la propriété d'avoir chaque sous-chaîne faite en supprimant un seul caractère, lorsqu'elle est évaluée, produit une erreur.

Par exemple. Si votre programme asdfest une quine, alors pour qu'il soit fragile, les programmes suivants doivent afficher une erreur:

sdf
adf
asf
asd

Votre programme (et toutes ses sous-chaînes) doit être entièrement déterministe et doit être dans la même langue. Un programme tombant dans une boucle infinie (c'est-à-dire ne se terminant pas), même s'il ne produit finalement pas d'erreur, est considéré comme "produisant une erreur" aux fins de ce défi.

Les failles standard s'appliquent, y compris les restrictions de quine habituelles (par exemple, pas en mesure de lire son propre code source).

Par exemple, print("foo")n'est pas fragile. Toutes ces sous-chaînes doivent contenir des erreurs:

rint("foo")
pint("foo")
prnt("foo")
prit("foo")
prin("foo")
print"foo")
print(foo")
print("oo")
print("fo")
print("fo")
print("foo)
print("foo"

Ceux qui ne font pas d'erreur sont:

print("oo")
print("fo")
print("fo")

Ce n'est donc pas fragile.

Une note importante sur les quines

Par consensus , toute quine possible doit satisfaire à ceci:

Il doit être possible d'identifier une section du programme qui code pour une autre partie du programme. ("Différent" signifie que les deux parties apparaissent dans des positions différentes.)

De plus, un quine ne doit pas accéder à sa propre source, directement ou indirectement.

Exemple

Étant donné que je considère la fonction # toString de JavaScript comme "la lecture de son propre code source", je la rejette. Cependant, si je ne l'interdisais pas, voici une quine fragile en JavaScript:

f=(n=b=`f=${f}`)=>(a=(n)==`f=${f}`,n=0,a)&(n!=b)?b:q

Testeur

Voici un programme qui, compte tenu du code source de votre programme, génère tous les programmes qui doivent être en erreur.

let f = (s) =>
  [...Array(s.length).keys()].map(i =>
    s.slice(0, i) + s.slice(i + 1)).join("\n");

let update = () => {
  output.innerHTML = "";
  output.appendChild(document.createTextNode(f(input.value)));
};

input.addEventListener("change", update);

update();

#output {
  white-space: pre;
}

#input, #output {
  font-family: Consolas, monospace;
}

<input id="input" value="print('foo')">
<div id="output"></div>

Burlesque ,32 28 25 octets

{3SHWD{Je!}.+{Sh}\msh}Je!

Essayez-le ici.

La plupart des instructions en burlesque sont donc composées de 2 caractères. Et il est beaucoup plus facile d'écrire une quine en Burlesque qu'en Marbelous. Je!ou ^^e!signifie _~dans CJam.

Python 3, 45 octets

c='print(end="c=%r;exec(c"%c+c[8*4])';exec(c)

Passer à Python 3 afin que la nouvelle ligne de fin puisse être facilement supprimée.

J'ai commencé avec une structure stupide qui avait 2 variables au lieu de 1, mais le passage à 1 variable ne faisait que 4 octets plus court.

- (4 + 3) octets par Dennis.

Python, 91/92 67 octets

C'était amusant!

Maintenant, je sais affirmer:

s='s=%r;assert len(s)==34;print(s%%s)';assert len(s)==34;print(s%s)

Si un caractère de la chaîne est supprimé, affirmez l'erreur. J'aurais fait cela plus tôt si j'avais eu connaissance de cette fonctionnalité, affirme-t-on.

Python 2, 51 50 46 octets

lambda s='lambda s=%r:s[22:]%%s%%s':s[22:]%s%s

Vérifiez-le sur Ideone .

C #, 145 octets

_=>{var@s="_=>{{var@s={1}{0}{1};for(;79!=s.Length;){{}}System.Console.Write(s,s,'{1}');}};";for(;79!=s.Length;){}System.Console.Write(s,s,'"');};

Je n'ai pas écrit de quine en C # auparavant, mais des scores plus élevés sont meilleurs au golf, non? :)

Boucle infinie si un caractère est supprimé de la chaîne ou un chiffre de la constante magique 79. La suppression de tout autre caractère entraîne une erreur de compilation.

Non golfé:

/* Action<object> Quine = */ _ => // unused parameter
{
    // String of the function (well, mostly).
    // {0} placeholder for s, so the output contains the function and string.
    // {1} placeholder for " since it requires escaping.
    var@s = "_=>{{var@s={1}{0}{1};for(;79!=s.Length;){{}}System.Console.Write(s,s,'{1}');}};";

    // Infinite loop if a char is removed from the above string or if the 7 or 9 is removed.
    for(;79!=s.Length;){}

    // Print the quine.
    System.Console.Write(s,s,'"');
};

JavaScript, 90 octets

a="a=%s;a[44]!=')'?x:console.log(a,uneval(''+a))";a[44]!=')'?x:console.log(a,uneval(''+a))

Fonctionne dans la console de Firefox 48 et devrait fonctionner dans tout autre environnement avec unevalet console.log. Répartition des erreurs:

a="                                             "; [  ]!=' '?x:           (a       (''+a))   // SyntaxError
   a=%s;a[44]!=')'?x:console.log(a,uneval(''+a))  a 44    )                                  // ReferenceError from calling `x`
                                                               console.     ,uneval          // ReferenceError from calling `onsole.log`, `auneval`, etc.
                                                                       log                   // TypeError from calling `console.og`, etc.

Python 2, 59 octets

x='x=%r;1/(len(x)==30);print x%%x';1/(len(x)==30);print x%x

Cela renvoie un ZeroDivisionErrorsi un 0, un 3 ou un caractère est supprimé de la chaîne. La suppression d'un caractère différent entraîne un NameErrorou un SyntaxError.

Un poirier , 50 octets

a="print('a='.repr(a).';eval(a)');#f+QF>";eval(a)

Essayez-le en ligne!

Pas la réponse la plus courte, mais assez complète; toute suppression de caractère de ce programme entraîne l'échec de la somme de contrôle, donc l'interpréteur A Pear Tree ne tentera même pas de l'exécuter. (Par exemple, vous obtenez une erreur si vous supprimez la nouvelle ligne de fin.) Le ;#f+QF>est utilisé pour garantir que le programme dans son ensemble a un CRC-32 de 0 (et f+QF>est l'une des trois chaînes de 5 octets possibles qui pourraient être placées dans le commentaire pour y parvenir tout en restant en ASCII; l'utilisation de l'ASCII est importante ici car reprcela ne permettrait pas de le contourner correctement sinon).