El desafío es encontrar una cadena de caracteres que no puedan aparecer en ningún programa legal en el lenguaje de programación de su elección. Eso incluye comentarios, cadenas u otras partes "no ejecutables".

Desafío

• Su programa puede ser específico para una versión particular o implementación del compilador / intérprete / entorno de tiempo de ejecución de su idioma. En caso afirmativo, especifique los detalles.
• Solo se permiten las opciones estándar de compilador / intérprete / tiempo de ejecución. No puede pasar un indicador extraño a su compilador para obtener un resultado específico (por ejemplo, pasar un indicador para convertir las advertencias en errores).
• Si su lenguaje de programación requiere una codificación específica (por ejemplo, UTF-8), su cadena también debe estar codificada correctamente (es decir, las cadenas que fallan únicamente debido a errores de decodificación de caracteres no están permitidas).
• Cada personaje individual en su presentación debe ser admisible en un programa legal; es decir, no puedes usar un personaje que siempre se rechaza.
• El compilador / intérprete / runtime debe dar un error cuando se le da cualquier código fuente que contenga su cadena como una subcadena. El error no tiene que ser el mismo en todos los programas: una incrustación de su cadena puede causar un error de sintaxis, mientras que otro puede causar un error de tiempo de ejecución.

Puntuación

• La cadena ilegal más corta para cada idioma gana.
• Debe explicar por qué su cadena es ilegal (por qué no puede aparecer en ningún lugar de un programa legal).
• Disputa soluciones incorrectas en los comentarios. Más específicamente, debe proporcionar un enlace a TIO o equivalente que demuestre un programa legal (es decir, uno que no produzca ningún error) que contenga la subcadena propuesta.
• Algunos lenguajes (por ejemplo, Bash, Batch, Perl) permiten agregar datos binarios arbitrarios a un programa sin afectar la validez (por ejemplo, usar __DATA__en Perl). Para dichos idiomas, puede enviar una solución que solo puede aparecer en dicha sección final. Asegúrese de anotar eso en su respuesta. (La definición de esta "sección final" depende del idioma, pero generalmente significa cualquier texto después de que el analizador haya dejado de leer el guión).

Ejemplo

En Python, podría enviar

x
"""
'''

pero esto puede integrarse en el programa más grande

"""
x
"""
'''
y
'''

entonces no es admisible.

Changeling , 2 bytes

Eso es dos avances de línea. Changeling válido siempre debe formar un cuadrado perfecto de caracteres ASCII imprimibles, por lo que no puede contener dos saltos de línea seguidos.

El error siempre es un error del analizador y siempre es el mismo:

This shape is unpleasant.

acompañado por el código de salida 1 .

Pruébalo en línea!

Java, 4 bytes

;\u;

Pruébalo en línea!

Esta es una secuencia de escape Unicode no válida y causará un error en el compilador.

error: illegal unicode escape

COBOL (GNU) , 8 bytes

THEGAME

Primero, un salto de línea para evitar que pongas mi palabra en una línea comentada.

Luego, históricamente, los programas COBOL se imprimieron en hojas de codificación, el compilador se basa en gran medida en líneas limitadas de 80 caracteres, no hay comentarios multilínea y los primeros 6 caracteres son comentarios (a menudo utilizados como números de línea editables), puede poner casi cualquier cosa allí , HASTA DONDE SE. Elegí THEGAMal comienzo de la siguiente línea.

Luego, el séptimo símbolo en cualquier línea solo acepta una lista muy restringida de caracteres: Espacio (sin efecto), Asterisco (comenta el resto de la línea), Guión, Barra oblicua, puede haber otros, pero ciertamente no E.

El error dado por GnuCobol, por ejemplo, es:

error: invalid indicator 'E' at column 7

Pruébalo en línea!

Además, acabas de perder el juego.

JavaScript, 7 bytes

;*/\u)

Tenga en cuenta la nueva línea principal.

• \u) es una secuencia de escape Unicode no válida y es por eso que esta cadena no es válida
• Agregar un //al principio todavía no funcionará debido a la nueva línea principal, dejando la segunda línea sin comentar
• Agregar un /*no descomentará la cadena por completo debido al cierre */que la completa, dejando al \u)descubierto
• Según lo indicado por @tsh, la línea de fondo se puede convertir en una expresión regular al tener una /cadena después de la cadena, por lo que al tener el )frente de la \u, podemos asegurar que el literal de expresión regular siempre sea inválido
• Como dijo @asgallant, se podría hacer 1||1(string)/para evitar tener que evaluar la expresión regular. El punto y coma al principio de la segunda línea evita que eso suceda al terminar la expresión 1||1antes de que llegue a la segunda línea, forzando un SyntaxError con el ;*.

¡Intentalo!

clicky.onclick=a=>{console.clear();console.log(eval(before.value+"\n;*/\\u)"+after.value));}

textarea {
  font-family: monospace;
}

<button onclick="console.clear();">Clear console</button>
<br>
<textarea id=before placeholder="before string"></textarea>
<pre><code>
 */\u)</code></pre>
<textarea id=after placeholder="after string"></textarea>
<br>
<button id=clicky>Evaluate</button>

Python, 10 bytes (no cpython)

?"""?'''?

Tenga en cuenta la nueva línea principal. No se puede comentar debido a la nueva línea, y ninguna combinación de cadenas entre comillas triples debería funcionar si lo pensara correctamente.

@feersum en los comentarios parece haber roto por completo cualquier programa cpython en Windows, por lo que puedo decir, agregando el carácter 0x1A al comienzo de un archivo. Parece que tal vez (?) Esto se deba a la forma en que el sistema operativo maneja este personaje, aparentemente se traduce a un EOF a medida que pasa a través de stdin debido a algún estándar heredado de DOS.

En un sentido muy real, esto no es un problema con Python sino con el sistema operativo. Si crea una secuencia de comandos de Python que lee el archivo y usa el incorporado compileen él, proporciona el comportamiento más esperado de arrojar un error de sintaxis. Pypy (que probablemente hace esto internamente) también arroja un error.

Editar:

¡Debido a la diligencia de @feersum para encontrar formas oscuras de romper el intérprete de Python, esta respuesta es completamente invalidada para cualquier entorno típico de cpython hasta donde puedo decir! (Python 2 y 3 para Windows y Linux) Todavía creo que estas grietas no funcionarán para Pypy en ninguna plataforma (la única otra implementación de Python que he probado).

C (clang) , 16 bytes

 */
#else
#else

Pruébalo en línea!

*/cierra cualquier /*comentario, y el espacio principal se asegura de que no solo hayamos comenzado uno. La nueva línea cierra cualquier //comentario y rompe cualquier cadena literal. Luego, causamos un error #else without #ifo #else after #else(independientemente de cuántos #if 0s podamos tener dentro).

Pyth, 6 bytes

¡¡$¡"¡

¡es un carácter no implementado, lo que significa que si el analizador Pyth lo evalúa alguna vez, generará un error con un PythParseError. El código asegura que esto sucederá en uno de los ¡s.

Hay tres formas en que un byte puede estar presente en un programa Pyth y no analizarse: en un literal de cadena ( "o .", que se analizan de manera equivalente), en un literal de Python ( $) e inmediatamente después de a \.

Este código evita \que se evalúe sin error, porque eso solo afecta el byte inmediatamente siguiente y los segundos ¡errores.

$incrusta el código dentro de la $s directamente en el código compilado de Python. No hago suposiciones sobre lo que podría pasar allí.

Si el programa alcanza este código en un $contexto, terminará en el $, y ¡justo después hará el error del analizador. Los literales de Pyth en Python siempre terminan en el siguiente $, independientemente de lo que esté haciendo el código de Python.

Si el programa se inicia en un "contexto, "finalizará la cadena y el final ¡generará el error del analizador.

Ada - 2 bytes

Creo que esto debería funcionar:

_

Eso es subrayado de nueva línea. Newline termina los comentarios y no está permitido en una cadena. Un guión bajo no puede seguir espacios en blanco; solía permitirse solo después de letras y números, pero la introducción de Unicode hizo las cosas complicadas.

Código de máquina x86 de 32 bits, 11 bytes (y 64 bits a prueba de futuro)

90 90 90 90 90 90 90 90 90 0f 0b

Esto es times 9 nop/ ud2. Básicamente es un trineo NOP , por lo que todavía se ejecuta como 0 o más nopsy luego ud2genera una excepción, independientemente de cuántos 0x90bytes se hayan consumido como operandos a un código operativo anterior. Otras instrucciones de un solo byte (como times 9 xchg eax, ecx) también funcionarían.

Código de máquina x86 de 64 bits, 10 bytes (CPU actuales)

Hay algunas instrucciones ilegales de 1 byte en el modo de 64 bits, hasta que una futura extensión ISA los reutilice como prefijos o partes de códigos de operación de varios bytes solo en el modo de 64 bits, separados de su significado en el modo de 32 bits. 0x0eestá push csen modo de 32 bits, pero es ilegal en las CPU actuales (probadas en Intel Skylake) en 64 bits.

0e 0e 0e 0e 0e 0e 0e 0e 0e 0e

Interpretación de reglas para código máquina ejecutable :

• Los bytes no se pueden saltar (como la restricción "no analizada"), porque las CPU no generan excepciones hasta que realmente intentan decodificar / ejecutar (no especulativamente).

• Los medios ilegales siempre generan una excepción, por ejemplo, una excepción de instrucción ilegal. (Los programas reales pueden detectarlo con un controlador de excepción en el metal desnudo o instalar un controlador de señal del sistema operativo, pero creo que esto captura el espíritu del desafío).

Funciona porque una cadena de bytes más corta que termina en ud2podría aparecer como un imm32 y / o parte del modo de direccionamiento para otra instrucción, o dividirse en un par de instrucciones . Es más fácil pensar en esto en términos de lo que podría poner antes de la cadena para "consumir" los bytes como parte de una instrucción, y dejar algo que no fallará.

Creo que una instrucción puede consumir como máximo 9 bytes de material arbitrario: un byte SIB, un disp32 y un imm32. es decir, los primeros 2 bytes de esta instrucción pueden consumir 8 NOP y un ud2, pero no 9.

c7 84 4b 00 04 00 00 78 56 34 12        mov dword [rbx+rcx*2+0x400],0x12345678

No se puede vencer a 9 nops:

    db 0xc7, 0x84   ; opcode + mod/rm byte: consumes 9 bytes (SIB + disp32 + imm32)
    times 9 nop          ; 1-byte xchg eax, ecx or whatever works, too
    ud2
  ----
   b:   c7 84 90 90 90 90 90 90 90 90 90        mov    DWORD PTR [rax+rdx*4-0x6f6f6f70],0x90909090
  16:   0f 0b                   ud2    

Modo de 64 bits:

 c7 84 0e 0e 0e 0e 0e 0e 0e 0e 0e        mov    DWORD PTR [rsi+rcx*1+0xe0e0e0e],0xe0e0e0e
 0e                      (bad)  

Pero los bytes para 8 NOPs + ud2 (o times 9 db 0x0e) pueden aparecer como parte de otros insns:

    db 0xc7, 0x84   ; defender's opcode + mod/rm that consumes 9 bytes

    times 8 nop          ; attacker code
    ud2

    times 10 nop    ;; defenders's padding to be consumed by the 0b opcode (2nd half of ud2)
----
  18:   c7 84 90 90 90 90 90 90 90 90 0f        mov    DWORD PTR [rax+rdx*4-0x6f6f6f70],0xf909090
  23:   0b 90 90 90 90 90       or     edx,DWORD PTR [rax-0x6f6f6f70]
  29:   90                      nop
  2a:   90                      nop
  ...

C #, 16 bytes

*/"
#endif<#@#>

Funciona porque:

• // el comentario no funcionará debido a la nueva línea
• /* comentario no funcionará debido a la */
• No puedes tener constantes solo en el código
• Agregar #if falseal inicio no funcionará debido a la#endif
• El "cierra cualquier cadena literal
• La <#@#>directiva no tiene nombre, por lo que falla para las plantillas T4.
• La nueva línea lo engaña, por lo que tenerlo /al principio no engañará al*/

Cada variación falla con un error de compilación.

APL y MATL y Fortran , 3 bytes

'

Newline, Quote, Newline siempre arroja un error ya que los comentarios de bloque no existen:

• APL: unbalanced quotes
• MATL: string literal not closed
• Fortran: Invalid character in name

Haskell alfabetizado , 15 bytes

Reparando un intento eliminado por nimi.

\end{code}
5
>

Pruébalo en línea!

El intento original de nimi son las dos últimas líneas, basadas en Literate Haskell que no permite >que el código de estilo literario esté en una línea vecina a una línea de comentario literario ( 5aquí). Falló porque se puede incrustar en un comentario en el estilo de codificación alfabetizado alternativo ("LaTeX"):

\begin{code}
{-
5
>
-}
\end{code}

Sin embargo, el \begin{code}estilo de Literate Haskell no se anida, ni en sí mismo ni en los {- -}comentarios multilínea, por lo que al poner una línea \end{code}justo antes de la línea con el 5, esa solución falla, y no veo uno diferente.

Pascal gratis, 18 bytes

*)}{$else}{$else}

Primero cierre todos los comentarios posibles, luego maneje la compilación condicional.

Comenta aquí si olvidé algo.

Commodore 64 Basic, 2 bytes

B

(esa es una nueva línea seguida de la letra "B").

Cualquier línea en un programa Commodore 64 debe comenzar con un número de línea o una palabra clave BASIC, y los programas almacenados solo permiten números de línea. No hay palabras clave que comiencen con "B" (o "H", "J", "K", "Q", "X", "Y" o "Z").

Brain-Hack (una variación de Brain-Flak ), 3 2 bytes

Gracias a Wheat Wizard por señalar que Brain-Hack no admite comentarios, lo que me ahorra un byte.

(}

Pruébalo en línea!

CJam , 7 bytes

"e#"
:"

Pruébalo en línea!

VBA, 2 bytes

Un salto de línea seguido de un guión bajo: las _funciones como el carácter de continuación de línea en VBA, y como no hay nada en la línea directamente a la izquierda o por encima de la continuación de línea, junto con la falta de comentarios multilínea de VBA significa que esto siempre arrojará la compilación error de tiempoCompile Error: Invalid character

_

SmileBASIC, 2 bytes

!

Nada continúa más allá del final de una línea, por lo que todo lo que necesita es un salto de línea seguido de algo que no puede ser el comienzo de una declaración. !es el operador lógico no, pero no puede ignorar el resultado de una expresión, por lo que incluso algo como !10sería inválido (mientras X=!10funciona, por supuesto)

Cosas similares funcionarán en cualquier idioma donde todo termine al final de una línea, siempre que analice el código antes de ejecutarlo.

Hay muchos caracteres alternativos que podrían usarse aquí, por lo que creo que sería más interesante enumerar los que PODRÍAN ser válidos.

@es el comienzo de una etiqueta, por ejemplo @DATA; (podría ser parte de una expresión como la (X)=1que está permitida por alguna razón; cualquier letra o _podría ser un nombre de variable X=1, llamada de función LOCATE 10,2o palabra clave WHILE 1; 'es un comentario; y ?es la abreviatura de PRINT.

INTERCAL , 12 bytes

DOTRYAGAINDO

¡Intenta descifrarlo en línea!

El enfoque de INTERCAL a los errores de sintaxis es un poco especial. Esencialmente, una declaración inválida no generará un error a menos que el programa intente ejecutarla. De hecho, la sintaxis idiomática para los comentarios es comenzar con ellos PLEASE NOTE, lo que realmente solo comienza una declaración, declara que no se debe ejecutar y luego comienza con la letra E. Si su código está DODOen el medio, puede anteponer DOABSTAINFROM(1)(1)y agregar cualquier declaración válida al final y estará bien, si es así, DODODOpuede doblar la ejecución a su alrededor como (1)DON'TDODODOCOMEFROM(1). Aunque INTERCAL carece de sintaxis literal de cadena para escapar de ellas, no hay forma de usar errores de sintaxis para crear una cadena ilegal, incluso agotando cada número de línea posible con(1)DO(2)DO...(65535)DODODO, ya que parece que es muy posible tener números de línea duplicados COME FROMtrabajando con cualquiera de ellos.

Para hacer una cadena ilegal, que realmente se necesita utilizar una declaración perfectamente válido: TRY AGAIN. Incluso si no se ejecuta, debe ser estrictamente la última declaración de un programa si está en el programa. Según mi conocimiento, 12 bytes es el más corto que puede usar una cadena ilegal TRY AGAIN, porque debe garantizar que haya una declaración después (ejecutada o no), por lo que DOTRYAGAINes solo un código normal, y debe asegurarse de que toda la declaración de hecho TRY AGAIN, TRYAGAINDOno funciona porque puede convertirse fácilmente en un error de sintaxis normal ignorado: DON'TRYAGAINDOGIVEUPo PLEASE DO NOT TRY TO USE TRYAGAINDO NOT THAT IT WOULD WORK. No importa lo que pone a cada lado de DOTRYAGAINDO, usted de error, ya sea con ICL993I I GAVE UP LONG AGO, ICL079I PROGRAMMER IS INSUFFICIENTLY POLITEo ICL099I PROGRAMMER IS OVERLY POLITE.

AWK , 4 bytes

/

Pruébalo en línea!

Como AWKno tiene un método para hacer comentarios de varias líneas, necesita 2 líneas nuevas antes y 1 después /para evitar comentar o convertir esto en una expresión regular, por ejemplo, agregar 1/. El mensaje más común es `nueva línea inesperada o final de cadena.

Con crack anterior

Fortran, 14 bytes

end program
e

No hay comentarios multilínea o directivas de preprocesador en Fortran.

JavaScript (Node.js) , 9 8 bytes

`*/
\u`~

Pruébalo en línea!

Creo que esto debería ser lo suficientemente ilegal.

Intentos anteriores de JS en otras respuestas

; * / \ u)

Por @Cows quack

Como respuesta de ES5, esto debería ser válido, pero en ES6 envolver el código con un par de backticks arruina esto. Como resultado, las respuestas válidas de ES6 deben incluir backticks.

``
`* /} '" `\ u!

Por @iovoid

Esta es una versión mejorada que involucra backticks. Sin embargo, una /vez que el código rompe esto (se convierte en una plantilla literal que se multiplica por una expresión regular, inútil pero sintácticamente válida). @Neil sugirió que cambiara !a ). Teóricamente, esto debería funcionar porque agregar /al final ya no funciona (debido a expresiones regulares mal formadas).

Explicación

`*/
\u`~

Esto es ilegal en sí mismo y también bloquea todas las comillas simples y dobles porque esas comillas no pueden abarcar líneas sin un \al final de una línea

//`*/
\u`~

y

/*`*/
\u`~

Bloquea los comentarios al introducir secuencias de escape ilegales

``*/
\u`~

Bloquea el backtick inicial al introducir el literal RegExp no terminado

console.log`*/
\u`~

Bloquea los literales de plantilla etiquetados mediante la introducción de un operador esperado entre dos backticks

Rockstar , 4 5 bytes

Tachado 4 sigue siendo 4 :(

)
"""

Rockstar es un lenguaje muy ... prolijo.
Si bien "se puede utilizar para definir una cadena, por lo que sé Put "Hello" into myVar, no hay forma de que aparezcan 3 citas fuera de un comentario, y el paréntesis cercano asegura que eso tampoco suceda (Los comentarios en Rockstar están encerrados entre paréntesis, como esta).

Rockstar también tiene una sintaxis literal poética, en la que se ignora la puntuación, por lo que la nueva línea se asegura de que las 3 citas sean el comienzo de una línea de código, que siempre debe ser inválida

Powershell, 10 8 12 14 13 14 16 bytes

^{-2 bytes gracias a Mazzy que encuentra una mejor manera de romperlo
+4 -1 bytes gracias a IsItGreyOrGray}

$#>
'@';
"@";
@=

Espero que esto funcione. 'y "para protegerse de las comillas, #>para romper el comentario de bloque, nuevas líneas para detener el comentario de una sola línea, tanto '@y "@para capturar otro estilo de cadenas, y luego comienza una matriz incorrecta para arrojar un error de sintaxis.

La lógica es que no pueden usar ningún conjunto de comillas para ingresar, no pueden bloquearlo, comentarlo.Si se @"usa, creará una cadena aquí que no puede tener un token después, y si déjalo en paz, intentará hacer una matriz rota. Esta declaración quiere vivir tan duro que sigo encontrando aún más agujeros en la armadura.

Encantamientos rúnicos, 3 bytes

Ṷ

Una de las muchas variaciones posibles.

Pruébalo en línea!

Runic utiliza caracteres de combinación unicode en un " Mmodifica el comportamiento de C" (donde Ces un comando). Como tal, no se permiten dos modificadores para modificar el mismo comando y el analizador arrojará un error si se encuentra tal ocurrencia.

Del mismo modo, ciertos comandos que redirigen la IP no se pueden modificar de ninguna manera, debido a la existencia de caracteres modificadores de modificación de dirección (y ambos en la misma celda no tienen sentido).

No hay forma de escapar o literalizar la cadena para que sea válida. El enlace Tio contiene un ;para evitar el error "sin terminador" de mayor prioridad.

TI-Basic (83 + / 84 + / SE, 24500 bytes)

A

(24500 veces)

TI (-83 + / 84 + / SE) -Basic verifica la sintaxis solo en las declaraciones que alcanza, por lo que incluso 5000 Enddeclaraciones seguidas se pueden omitir con a Return. Esto, por el contrario, no puede caber en la RAM de una TI-83 + / 84 + / SE, por lo que ningún programa puede contener esta cadena. Ser un poco conservador con el personaje cuenta aquí.

La TI-83 original tiene 27000 bytes de RAM, por lo que necesitará 27500 As en ese caso.

TI-Basic (89 / Ti / 92 + / V200, 3 bytes)

"

Nueva línea, presupuesto, nueva línea. La nueva línea cierra cualquier comentario (y no permite incrustar el carácter ilegal en una cadena, ya que las constantes de cadena multilínea AFAIK no están permitidas), la otra nueva línea no permite cerrar la cadena y la cita da un error de sintaxis.

Puedes llegar a 2 bytes con

±

sin la nueva línea, pero no estoy seguro de si esto cuenta porque ±es válido solo en constantes de cadena.

Go , 6 bytes

*/```

¡Intenta descifrarlo en línea!

El acento grave (`) marca un literal de cadena sin procesar, dentro del cual todos los caracteres excepto`, incluidas las líneas nuevas y las barras diagonales inversas, se interpretan literalmente como parte de la cadena. Tres '' seguidos son el núcleo: los literales de cadena adyacentes no son válidos y 'siempre cierra una ' cadena, por lo que no hay forma de darles sentido. Tuve que usar 3 bytes más para evitar la elusión, una nueva línea para que no podamos estar dentro de un comentario de una sola línea o una cadena citada normal, y un * / para que no podamos estar dentro de un comentario de varias líneas.

SILOS , 4 bytes

Silos es competitivo

x+

SILOS se ejecuta en un intérprete / compilador de dos pasos. Antes de la ejecución, un "compilador" intenta simplificar la fuente en una matriz que describe la fuente Cada línea se trata por separado. x + a es un operador de asignación que agregará ea al valor de x y lo almacenará en x. Sin embargo, el "compilador" se romperá. Por lo tanto, tomamos esta cadena y agregamos una nueva línea antes y después de garantizar que esté en su propia línea y rompa el compilador.

Pruébalo en línea!

AutoHotkey , 5 bytes

`es el personaje de escape. Solo puede escapar de un "al asignarlo a una variable.

\ n * / evita que se comente o se asigne a una variable.

*/`"

JavaScript, 11 caracteres

`
`*/}'"`\u)

Los backticks se aseguran de eliminar las cadenas de plantilla, las comillas eliminan las cadenas, la nueva línea evita las líneas comentadas, el final del comentario evita los comentarios de bloque y el último backtick y escape (con un! Para evitar agregar números) intenta iniciar un número inválido cuerda.

Pruébalo en línea!