Una quina frágil

Una quina frágil es una quine que satisface la propiedad de tener cada subcadena hecha mediante la eliminación de un solo carácter, cuando se evalúa, produce un error.

Por ejemplo. Si su programa asdfes una quine, entonces para que sea frágil, deben fallar los siguientes programas:

sdf
adf
asf
asd

Su programa (y todas sus subcadenas) deben ser totalmente deterministas y deben estar en el mismo idioma. Un programa que cae en un bucle infinito (es decir, que no termina), incluso si finalmente no produce un error, se considera que "produce un error" a los efectos de este desafío.

Se aplican las lagunas estándar, incluidas las restricciones habituales de quine (por ejemplo, no se puede leer el código fuente propio).

Por ejemplo, print("foo")no es frágil. Todas estas subcadenas deben error:

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

Los que no fallan son:

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

Entonces no es frágil.

Una nota importante sobre quines

Por consenso , cualquier posible quine debe satisfacer esto:

Debe ser posible identificar una sección del programa que codifique una parte diferente del programa. ("Diferente" significa que las dos partes aparecen en diferentes posiciones).

Además, una quine no debe acceder a su propia fuente, directa o indirectamente.

Ejemplo

Dado que considero que la función # toString de JavaScript es "leer su propio código fuente", no lo estoy permitiendo. Sin embargo, si no fuera a prohibirlo, aquí hay una frase frágil en JavaScript:

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

Ensayador

Aquí hay un programa que, dado el código fuente de su programa, genera todos los programas que deben error.

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>

Burlesco ,32 28 25 bytes

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

Pruébalo aquí.

Entonces, la mayoría de las instrucciones en Burlesque son de 2 caracteres. Y es mucho más fácil escribir una quine en Burlesque que en Marbelous. Je!o ^^e!significa _~en CJam.

Python 3, 45 bytes

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

Cambiar a Python 3 para que la nueva línea final se pueda eliminar fácilmente.

Comencé con una estructura estúpida que tenía 2 variables en lugar de 1, pero cambiar a 1 variable solo lo hizo 4 bytes más corto.

- (4 + 3) bytes por Dennis.

Python, 91/92 67 bytes

¡Esto fue divertido!

Ahora sé sobre afirmar:

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

Si se elimina un carácter de cadena, afirme el error. Habría hecho esto antes si hubiera sabido de esta característica, afirma.

Python 2, 51 50 46 bytes

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

Verifíquelo en Ideone .

C #, 145 bytes

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

No he escrito una quine en C # antes, pero las puntuaciones más altas son mejores en golf, ¿verdad? :)

Bucle infinito si se elimina un carácter de la cadena o un dígito de la constante mágica 79. La eliminación de cualquier otro carácter produce un error de compilación.

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

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

Funciona en la consola de Firefox 48, y debería funcionar en cualquier otro entorno con unevaly console.log. Desglose de errores:

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 bytes

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

Esto arroja un ZeroDivisionErrorsi se elimina un 0, un 3 o un carácter de la cadena. Eliminar un carácter diferente da como resultado a NameErroro a SyntaxError.

Un peral , 50 bytes

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

Pruébalo en línea!

No es la respuesta más corta, sino bastante completa; cualquier eliminación de caracteres de este programa hace que falle la suma de comprobación, por lo que el intérprete de A Pear Tree ni siquiera intentará ejecutarlo. (Por ejemplo, obtiene un error si elimina la nueva línea final). Se ;#f+QF>utiliza para garantizar que el programa en su conjunto tenga un CRC-32 de 0 (y f+QF>es una de las tres posibles cadenas de 5 bytes que podrían colocarse en el comentario para lograr eso mientras se está en ASCII; usar ASCII es importante aquí porque de lo reprcontrario no podría hacer un viaje de ida y vuelta correctamente).