O desafio é encontrar uma série de caracteres que não possam aparecer em nenhum programa legal na sua linguagem de programação preferida. Isso inclui comentários, seqüências de caracteres ou outras partes "não executáveis".

Desafio

• Seu programa pode ser específico para uma versão ou implementação específica do ambiente de compilação / intérprete / tempo de execução do seu idioma. Em caso afirmativo, especifique os detalhes.
• Somente opções padrão de compilador / intérprete / tempo de execução são permitidas. Você não pode passar algum sinalizador estranho para o seu compilador para obter um resultado específico (por exemplo, passar um sinalizador para converter avisos em erros).
• Se sua linguagem de programação requer uma codificação específica (por exemplo, UTF-8), sua string também deve ser codificada corretamente (ou seja, strings que falham apenas devido a erros de decodificação de caracteres não são permitidas).
• Todo personagem individual em sua submissão deve ser admissível em um programa legal; isto é, você não pode simplesmente usar um personagem que sempre é rejeitado.
• O compilador / intérprete / tempo de execução deve dar um erro quando receber qualquer código-fonte que contenha sua string como uma substring. O erro não precisa ser o mesmo entre os programas - uma incorporação de sua sequência pode causar um erro de sintaxe, enquanto outra pode causar um erro de tempo de execução.

Pontuação

• A menor string ilegal para cada idioma vence.
• Você deve explicar por que sua string é ilegal (por que ela não pode aparecer em nenhum lugar de um programa legal).
• Disputa soluções incorretas nos comentários. Mais especificamente, você deve fornecer um link para o TIO ou equivalente, demonstrando um programa legal (ou seja, que não produza erros) que contenha a substring proposta.
• Alguns idiomas (por exemplo, Bash, Batch, Perl) permitem que dados binários arbitrários sejam anexados a um programa sem afetar a validade (por exemplo, usando __DATA__em Perl). Para esses idiomas, você pode enviar uma solução que possa aparecer apenas em uma seção posterior. Certifique-se de anotar isso na sua resposta. (A definição desta "seção à direita" depende do idioma, mas geralmente significa qualquer texto após o analisador ter parado completamente de ler o script).

Exemplo

Em Python, devo enviar

x
"""
'''

mas isso pode ser incorporado ao programa maior

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

então não é admissível.

Changeling , 2 bytes

São dois feeds de linha. O Changeling válido sempre deve formar um quadrado perfeito de caracteres ASCII imprimíveis, para que não possa conter dois feeds de linha em uma linha.

O erro é sempre um erro do analisador e sempre o mesmo:

This shape is unpleasant.

acompanhado pelo código de saída 1 .

Experimente online!

Java, 4 bytes

;\u;

Experimente online!

Esta é uma sequência de escape Unicode inválida e causará um erro no compilador.

error: illegal unicode escape

COBOL (GNU) , 8 bytes

THEGAME

Primeiro, um avanço de linha para impedir que você coloque minha palavra em uma linha comentada.

Em seguida, historicamente, os programas COBOL eram impressos em folhas de código, o compilador se apóia fortemente em linhas limitadas de 80 caracteres, não há comentários de várias linhas e os 6 primeiros caracteres são comentários (geralmente usados ​​como números de linhas editáveis), você pode colocar quase tudo , ATÉ ONDE SEI. Eu escolhi THEGAMno início da próxima linha.

Então, o sétimo símbolo em qualquer linha aceita apenas uma lista muito restrita de caracteres: Espaço (sem efeito), Asterisco (comenta o resto da linha), Hífen, Slash, pode haver outros, mas certamente não E.

O erro dado pelo GnuCobol, por exemplo, é:

error: invalid indicator 'E' at column 7

Experimente online!

Além disso, você acabou de perder o jogo.

JavaScript, 7 bytes

;*/\u)

Observe a nova linha principal.

• \u) é uma sequência de escape Unicode inválida e é por isso que esta sequência é inválida
• Adicionar um //no início ainda não funcionará devido à nova linha principal, deixando a segunda linha descomentada
• Adicionar a /*não removerá o comentário da string por causa do fechamento */que a completa, deixando o \u)exposto
• Conforme afirmado por @tsh, a linha inferior pode ser transformada em uma expressão regular /após a sequência, portanto, mantendo-a )na frente da \u, podemos garantir que o literal da expressão regular sempre será inválido
• Como afirma @asgallant, é possível 1||1(string)/evitar a avaliação do regex. O ponto-e-vírgula no início da segunda linha impede que isso aconteça, encerrando a expressão 1||1antes que ela atinja a segunda linha, forçando assim um SyntaxError com o ;*.

Tente!

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 (não cpython)

?"""?'''?

Observe a nova linha principal. Não pode ser comentado devido à nova linha, e nenhuma combinação de seqüências de caracteres triplas entre aspas deve funcionar se eu pensar sobre isso corretamente.

@feersum nos comentários parece ter quebrado completamente qualquer programa cpython no Windows, tanto quanto eu posso dizer, adicionando o caractere 0x1A ao início de um arquivo. Parece que talvez (?) Isso se deva à maneira como esse personagem é tratado pelo sistema operacional, aparentemente sendo traduzido para um EOF ao passar pelo stdin por causa de algum padrão herdado do DOS.

Em um sentido muito real, isso não é um problema do python, mas do sistema operacional. Se você criar um script python que lê o arquivo e usa o interno compile, ele oferece o comportamento mais esperado ao gerar um erro de sintaxe. Pypy (que provavelmente faz isso internamente) também gera um erro.

Editar:

Devido à diligência do @ feersum em encontrar maneiras obscuras de interromper o interpretador Python, esta resposta é completamente invalidada para qualquer ambiente cpython típico, até onde eu sei! (Python 2 e 3 para Windows e Linux) Ainda acredito que essas falhas não funcionarão para o Pypy em nenhuma plataforma (a única outra implementação do Python que testei).

C (clang) , 16 bytes

 */
#else
#else

Experimente online!

*/fecha qualquer /*comentário, e o espaço principal garante que não apenas comecemos um. A nova linha fecha qualquer //comentário e quebra qualquer string literal. Em seguida, causamos um erro #else without #ifou #else after #else(independentemente de quantos #if 0s possamos estar dentro).

Pitão, 6 bytes

¡¡$¡"¡

¡é um caractere não implementado, o que significa que, se o analisador Pyth o avaliar, ocorrerá um erro com um PythParseError. O código garante que isso aconteça em um dos ¡s.

Existem três maneiras pelas quais um byte pode estar presente em um programa Pyth e não ser analisado: Em uma string literal ( "ou .", que são analisadas equivalentemente), em uma literal Python ( $) e imediatamente após a \.

Esse código impede \que seja avaliado sem erros, porque isso afeta apenas o byte imediatamente seguinte e o segundo ¡erro.

$incorpora o código dentro dos $s no código Python compilado diretamente. Não faço suposições sobre o que pode acontecer lá.

Se o programa atingir esse código em um $contexto, ele terminará em $, e ¡logo após cometerá o erro do analisador. Os literais Python de Pyth sempre terminam no próximo $, independentemente do que o código Python possa estar fazendo.

Se o programa iniciar em um "contexto, o "final da string será finalizado e o final ¡cometerá o erro do analisador.

Ada - 2 bytes

Eu acho que isso deve funcionar:

_

Isso é sublinhado de nova linha. A nova linha encerra comentários e não é permitida em uma sequência. Um sublinhado não pode seguir o espaço em branco; só era permitido depois de letras e números, mas a introdução do Unicode tornava as coisas mais complicadas.

código de máquina x86 de 32 bits, 11 bytes (e 64 bits à prova de futuro)

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

Isso é times 9 nop/ ud2. É basicamente um trenó NOP , de modo que ainda funciona como 0 ou mais nops e, em seguida, ud2para levantar uma excepção, independentemente de quantos dos 0x90bytes foram consumidos como operandos para um código de operação anterior. Outras instruções de byte único (como times 9 xchg eax, ecx) também funcionariam.

código de máquina x86 de 64 bits, 10 bytes (CPUs atuais)

Existem algumas instruções ilegais de 1 byte no modo de 64 bits, até que alguma extensão futura do ISA os redistribua como prefixos ou partes de códigos de operação de vários bytes apenas no modo de 64 bits, separados do significado no modo de 32 bits. 0x0eestá push csno modo de 32 bits, mas ilegal nas CPUs atuais (testadas no Intel Skylake) em 64 bits.

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

Interpretação de regras para código de máquina executável :

• Os bytes não podem ser saltados (como a restrição "não analisada"), porque as CPUs não geram exceções até que tentem decodificar / executar (não especulativamente).

• Meios ilegais sempre geram uma exceção, por exemplo, uma exceção de instrução ilegal. (Programas reais podem capturar isso com um manipulador de exceção no bare metal ou instalar um manipulador de sinal do SO, mas acho que isso captura o espírito do desafio.)

Funciona porque uma sequência de bytes mais curta que termina em ud2pode aparecer como um imm32 e / ou parte do modo de endereçamento de outra instrução ou dividir-se em um par de instruções . É mais fácil pensar sobre isso em termos do que você poderia colocar antes da string para "consumir" os bytes como parte de uma instrução e deixar algo que não falha.

Eu acho que uma instrução pode consumir no máximo 9 bytes de coisas arbitrárias: um byte SIB, um disp32 e um imm32. ou seja, os 2 primeiros bytes desta instrução podem consumir 8 NOPs e um ud2, mas não 9.

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

Não pode vencer 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)  

Mas os bytes para 8 NOPs + ud2 (ou times 9 db 0x0e) podem aparecer como parte de outros 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:

• // o comentário não funcionará por causa da nova linha
• /* comentário não vai funcionar por causa do */
• Você não pode ter constantes apenas no código
• Adicionar #if falseao início não funcionará por causa do#endif
• O "fecha qualquer string literal
• A <#@#>é uma diretiva sem nome, portanto falha nos modelos T4.
• A nova linha o engana, portanto, ter /no início não enganará o*/

Cada variação falha com um erro de compilação.

APL e MATL e Fortran , 3 bytes

'

Nova linha, Citação, Nova linha sempre gera um erro, pois não existem comentários em bloco:

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

Haskell alfabético , 15 bytes

Reparando uma tentativa excluída por nimi.

\end{code}
5
>

Experimente online!

A tentativa original de nimi são as duas últimas linhas, baseadas em Literate Haskell, não permitindo que o >código alfabético de estilo esteja em uma linha vizinha a uma linha de comentário alfabetizada ( 5aqui). Falhou porque pode ser incorporado em um comentário no estilo de codificação alternativo ("LaTeX"):

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

No entanto, o \begin{code}estilo de Literate Haskell não se aninha, nem em si nem nos {- -}comentários de várias linhas; portanto, ao colocar uma linha \end{code}imediatamente antes da linha com o 5, a solução alternativa falha e não vejo outra.

Pascal livre, 18 bytes

*)}{$else}{$else}

Primeiro feche todos os comentários possíveis e depois lide com a compilação condicional.

Por favor, comente aqui se eu esqueci alguma coisa.

Commodore 64 Básico, 2 bytes

B

(é uma nova linha seguida da letra "B").

Qualquer linha em um programa Commodore 64 deve começar com um número de linha ou uma palavra-chave BASIC, e os programas armazenados permitem apenas números de linha. Não há palavras-chave começando com "B" (ou "H", "J", "K", "Q", "X", "Y" ou "Z").

Brain-Hack (uma variação do Brain-Flak ), 3 2 bytes

Obrigado ao Wheat Wizard por apontar que o Brain-Hack não suporta comentários, economizando um byte.

(}

Experimente online!

CJam , 7 bytes

"e#"
:"

Experimente online!

VBA, 2 bytes

Um avanço de linha seguido de um sublinhado - as _funções como o caractere de continuação de linha no VBA e como não há nada na linha diretamente à esquerda ou acima da continuação de linha, juntamente com a falta de comentários de várias linhas do VBA significa que isso sempre gerará a compilação erro de tempoCompile Error: Invalid character

_

SmileBASIC, 2 bytes

!

Nada continua além do final de uma linha, então tudo o que você precisa é de uma quebra de linha seguida por algo que não pode ser o início de uma declaração. !é o operador lógico, mas você não tem permissão para ignorar o resultado de uma expressão, portanto, mesmo algo como !10seria inválido (enquanto X=!10funciona, é claro)

Coisas semelhantes funcionarão em qualquer idioma em que tudo termine no final de uma linha, desde que ele analise o código antes de executá-lo.

Existem muitos caracteres alternativos que podem ser usados ​​aqui, então acho que seria mais interessante listar aqueles que PODEM ser válidos.

@é o início de um rótulo, por exemplo @DATA; (pode fazer parte de uma expressão como a (X)=1que é permitida por algum motivo; qualquer letra ou _pode ser um nome de variável X=1, chamada de função LOCATE 10,2ou palavra-chave WHILE 1; 'é um comentário; e ?é a abreviação de PRINT.

INTERCAL , 12 bytes

DOTRYAGAINDO

Tente decifrá-lo online!

A abordagem da INTERCAL para erros de sintaxe é um pouco especial. Essencialmente, uma declaração inválida não irá realmente errar, a menos que o programa tente executá-la. De fato, a sintaxe idiomática dos comentários é iniciá-los PLEASE NOTE, o que realmente inicia uma declaração, declara que não deve ser executada e, em seguida, inicia com a letra E. Se o seu código estiver DODOno meio dele, você pode anexar DOABSTAINFROM(1)(1)e anexar qualquer instrução válida até o final e você ficará bem, se for o caso, DODODOvocê pode apenas dobrar a execução em torno dele como (1)DON'TDODODOCOMEFROM(1). Embora INTERCAL não possua sintaxe literal de string para evitá-los, não há como usar erros de sintaxe para criar uma string ilegal, esgotando até todo número de linha possível com(1)DO(2)DO...(65535)DODODO, pois parece ser possível ter números de linhas duplicados COME FROMtrabalhando com qualquer um deles.

Para fazer uma cadeia ilegal, nós realmente precisa usar uma declaração perfeitamente válido: TRY AGAIN. Mesmo que não seja executado, deve ser estritamente a última declaração de um programa, se estiver no programa. 12 bytes é, pelo que sei, o menor número de caracteres que uma cadeia ilegal pode usar TRY AGAIN, porque ela precisa garantir que exista uma declaração depois dela (executada ou não), por isso DOTRYAGAINé apenas código normal, e precisa garantir que toda a declaração de fato TRY AGAIN, TRYAGAINDOnão funciona, pois pode ser facilmente transformado em um erro de sintaxe normal e ignorado: DON'TRYAGAINDOGIVEUPou PLEASE DO NOT TRY TO USE TRYAGAINDO NOT THAT IT WOULD WORK. Não importa o que você colocar em cada lado de DOTRYAGAINDO, você erro, ou com ICL993I I GAVE UP LONG AGO, ICL079I PROGRAMMER IS INSUFFICIENTLY POLITEou ICL099I PROGRAMMER IS OVERLY POLITE.

AWK , 4 bytes

/

Experimente online!

Como AWKnão possui um método para fazer comentários com várias linhas, é necessário 2 novas linhas antes e 1 depois /para evitar comentar ou transformar isso em um regex, por exemplo, adicionar 1/. A mensagem mais comum é `nova linha inesperada ou final de string.

Com crack anterior

Fortran, 14 bytes

end program
e

Não há comentários de várias linhas ou diretivas de pré-processador no Fortran.

JavaScript (Node.js) , 9 8 bytes

`*/
\u`~

Experimente online!

Eu acho que isso deve ser ilegal o suficiente.

Tentativas anteriores de JS em outras respostas

;*/\você)

Por @Cows quack

Como resposta do ES5, isso deve ser válido, mas no ES6, a quebra do código com um par de reticentes destrói isso. Como resultado, as respostas ES6 válidas devem envolver backticks.

`
`* /} '" `\ u!

Por @iovoid

Esta é uma versão aprimorada envolvendo backticks. No entanto, um único /após o código quebra isso (torna-se um literal de modelo sendo multiplicado por uma regex, inútil, mas sintaticamente válido.) @Neil fez uma sugestão de que a mudança !para ). Teoricamente, isso deve funcionar porque adicionar /no final não funciona mais (devido a regex malformado).

Explicação

`*/
\u`~

Isso por si só é ilegal e também bloqueia todas as aspas simples e duplas, porque essas aspas não podem se estender por linhas sem a \no final de uma linha

//`*/
\u`~

e

/*`*/
\u`~

Bloqueia comentários introduzindo sequências de escape ilegais

``*/
\u`~

Bloqueia o backtick inicial, introduzindo literal RegExp não terminado

console.log`*/
\u`~

Blocos etiquetados literais de modelo, introduzindo um operador esperado entre dois backticks

Rockstar , 4 5 bytes

Riscado 4 ainda é 4 :(

)
"""

Rockstar é uma linguagem muito ... prolixo.
Embora "possa ser usado para definir uma cadeia de caracteres, como Put "Hello" into myVar, pelo que sei , não é possível que três aspas apareçam fora de um comentário, e o parêntese fechado garante que isso também não aconteça (os comentários no Rockstar estão entre parênteses, como esta).

A Rockstar também possui uma sintaxe literal poética, na qual a pontuação é ignorada; portanto, a nova linha garante que as três aspas sejam o início de uma linha de código, que sempre deve ser inválida.

Powershell, 10 8 12 14 13 14 16 bytes

^{-2 bytes graças ao Mazzy encontrando uma maneira melhor de quebrá-lo
+4 -1 bytes graças a IsItGreyOrGray}

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

Eu espero que isso funcione. 'e "para se proteger contra aspas, #>para interromper o comentário em bloco, novas linhas para interromper o comentário em uma única linha '@e "@para capturar outro estilo de cadeias de caracteres e, em seguida, inicia uma matriz imprópria para gerar um erro de sintaxe.

A lógica é que eles não podem usar nenhum conjunto de aspas para entrar, não podem comentar com um bloco. Se @"for usado, ele criará uma string aqui que não poderá receber um token posteriormente e, se deixe em paz, ele tentará criar uma matriz quebrada. Esta declaração quer viver tanto, que continuo encontrando ainda mais buracos na armadura.

Encantos Rúnicos, 3 bytes

Ṷ

Uma das muitas variações possíveis.

Experimente online!

O Runic utiliza caracteres combinados unicode em um " Mmodifica o comportamento de C" (onde Cestá um comando). Como tal, não há dois modificadores autorizados a modificar o mesmo comando e o analisador emitirá um erro se tal ocorrência for encontrada.

Da mesma forma, certos comandos que redirecionam o IP não podem ser modificados de maneira alguma, devido à existência de caracteres modificadores de modificação de direção (e ambos na mesma célula não fazem sentido).

Não há como escapar ou literalizar a string para torná-la válida. O link Tio contém um ;para ignorar o erro de prioridade mais alta "sem terminador".

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

A

(24500 vezes)

A TI (-83 + / 84 + / SE) -Basic faz a verificação de sintaxe apenas nas instruções atingidas, portanto, até 5000 Endinstruções consecutivas podem ser puladas com a Return. Isso, por outro lado, não pode caber na RAM de uma TI-83 + / 84 + / SE, portanto, nenhum programa pode conter essa sequência. Ser um pouco conservador com a contagem de caracteres aqui.

A TI-83 original possui 27000 bytes de RAM, portanto, você precisará de 27500 As nesse caso.

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

"

Nova linha, citação, nova linha. A nova linha fecha todos os comentários (e não permite incorporar o caractere ilegal em uma sequência, pois as constantes de sequência multilinha de AFAIK não são permitidas), a outra nova linha não permite fechar a sequência e a cotação gera um erro de sintaxe.

Você pode obter 2 bytes com

±

sem a nova linha, mas não tenho certeza se isso conta, porque ±é válido apenas em constantes de string.

Vá , 6 bytes

*/```

Tente decifrá-lo online!

O acento grave (`) marca um literal de string bruto, dentro do qual todos os caracteres, exceto`, incluindo novas linhas e barras invertidas, são interpretados literalmente como parte da string. Três `` seguidos '' são o núcleo: os literais de string adjacentes são inválidos e `sempre fecha um` ` , portanto não há como entendê-los. Eu tive que usar mais 3 bytes para evitar a evasão, uma nova linha para que não possamos estar dentro de um comentário de linha única ou uma string entre aspas normal e um * / para que não possamos estar dentro de um comentário de várias linhas.

SILOS , 4 bytes

Silos é competitivo \ o /

x+

O SILOS é executado em um interpretador / compilador de duas passagens. Antes da execução, um "compilador" tenta simplificar a fonte em uma matriz que descreve o código fonte Cada linha é tratada separadamente. x + a é um operador de atribuição que adiciona ea ao valor de x e o armazena em x. No entanto, o "compilador" será interrompido. Portanto, pegamos essa string e adicionamos uma nova linha antes e depois de garantir que ela esteja em sua própria linha e quebre o compilador.

Experimente online!

AutoHotkey , 5 bytes

`é o caractere de escape. Você só pode escapar de "ao atribuí-lo a uma variável.

\ n * / impede que seja comentado ou atribuído a uma variável.

*/`"

JavaScript, 11 caracteres

`
`*/}'"`\u)

Os backticks certificam-se de eliminar as strings do modelo, as aspas se livram das strings, a nova linha evita as linhas comentadas, o final do comentário evita comentários em bloco e o último backtick e escape (com um! Para evitar anexar números) tenta iniciar um inválido corda.

Experimente online!