Un Fragile Quine

Un quine fragile è un quine che soddisfa la proprietà di avere ogni sottostringa rimuovendo un singolo carattere, quando valutato, produce un errore.

Per esempio. Se il tuo programma asdfè un quine, quindi per essere fragile, i seguenti programmi devono errori:

sdf
adf
asf
asd

Il tuo programma (e tutte le sue sottostringhe) deve essere completamente deterministico e deve essere nella stessa lingua. Un programma che cade in un ciclo infinito (cioè non riesce a terminare), anche se alla fine non produce un errore è considerato "produrre un errore" ai fini di questa sfida.

Si applicano scappatoie standard, comprese le consuete restrizioni di quine (ad esempio, impossibile leggere il proprio codice sorgente).

Ad esempio, print("foo")non è fragile. Tutte queste sottostringhe devono contenere errori:

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

Quelli che non sbagliano sono:

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

Quindi non è fragile.

Una nota importante sulle quines

Per consenso , ogni possibile quine deve soddisfare questo:

Deve essere possibile identificare una sezione del programma che codifica una parte diversa del programma. ("Diverso" significa che le due parti appaiono in posizioni diverse.)

Inoltre, un quine non deve accedere alla propria fonte, direttamente o indirettamente.

Esempio

Dato che considero la funzione # toString di JavaScript "lettura del proprio codice sorgente", non lo autorizzo. Tuttavia, se non dovessi escluderlo, ecco un fragile quine in JavaScript:

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

Tester

Ecco un programma che, dato il codice sorgente del tuo programma, genera tutti i programmi che devono presentare errori.

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 byte

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

Provalo qui.

Quindi la maggior parte delle istruzioni in Burlesque sono di 2 caratteri. Ed è molto più facile scrivere un quine in Burlesque che in Marbelous. Je!o ^^e!significa _~in CJam.

Python 3, 45 byte

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

Passare a Python 3 in modo che la nuova riga finale possa essere facilmente rimossa.

Ho iniziato con una struttura stupida che aveva 2 variabili invece di 1, ma il passaggio a 1 variabile ha reso solo 4 byte più brevi.

- (4 + 3) byte di Dennis.

Python, 91/92 67 byte

È stato divertente!

Ora so di asserire:

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

Se viene rimosso un carattere dalla stringa, asserire errore. Lo avrei fatto prima se avessi saputo di questa caratteristica, asserire.

Python 2, 51 50 46 byte

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

Verifica su Ideone .

C #, 145 byte

_=>{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,'"');};

Non ho mai scritto un quine in C # prima, ma i punteggi più alti sono migliori nel golf, giusto? :)

Ciclo infinito se un carattere viene rimosso dalla stringa o una cifra dalla const magica 79. La rimozione di qualsiasi altro carattere provoca un errore di compilazione.

Ungolfed:

/* 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 byte

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

Funziona nella console di Firefox 48 e dovrebbe funzionare in qualsiasi altro ambiente con unevale console.log. Ripartizione degli errori:

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 byte

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

Questo genera un ZeroDivisionErrorse uno 0, un 3 o un carattere viene rimosso dalla stringa. La rimozione di un carattere diverso si traduce in a NameErroro a SyntaxError.

Un albero di pere , 50 byte

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

Provalo online!

Non la risposta più breve, ma abbastanza completa; qualsiasi cancellazione di caratteri da questo programma fa sì che non riesca a fare il checksum, quindi l'interprete di A Pear Tree non tenterà nemmeno di eseguirlo. (Ad esempio, si ottiene un errore se si elimina la nuova riga finale.) ;#f+QF>Viene utilizzato per assicurarsi che il programma nel suo insieme abbia un CRC-32 di 0 (ed f+QF>è una delle tre possibili stringhe a 5 byte che potrebbero essere inserite in il commento per ottenerlo rimanendo in ASCII; l'uso di ASCII è importante qui perché reprnon riuscirebbe a fare il giro di andata e ritorno correttamente altrimenti).