La sfida è trovare una serie di caratteri che non possono apparire in nessun programma legale nel tuo linguaggio di programmazione preferito. Ciò include commenti, stringhe o altre parti "non eseguibili".

Sfida

• Il tuo programma potrebbe essere specifico per una particolare versione o implementazione dell'ambiente del compilatore / interprete / runtime della tua lingua. In tal caso, si prega di specificare i dettagli.
• Sono consentite solo opzioni standard di compilatore / interprete / runtime. Non è possibile passare un flag strano al compilatore per ottenere un risultato specifico (ad esempio passare un flag per convertire gli avvisi in errori).
• Se il tuo linguaggio di programmazione richiede una codifica specifica (ad es. UTF-8), anche la tua stringa deve essere codificata correttamente (non sono consentite stringhe che falliscono solo a causa di errori di decodifica dei caratteri).
• Ogni singolo personaggio nella tua presentazione deve essere ammissibile in un programma legale; cioè, non puoi semplicemente usare un personaggio che viene sempre rifiutato.
• Il compilatore / interprete / runtime deve dare un errore quando viene dato qualsiasi codice sorgente che contiene la stringa come sottostringa. L'errore non deve essere lo stesso tra i programmi: un incorporamento della stringa potrebbe causare un errore di sintassi, mentre un altro potrebbe causare un errore di runtime.

punteggio

• Vince la stringa illegale più corta per ogni lingua.
• Dovresti spiegare perché la tua stringa è illegale (perché non può apparire da nessuna parte in un programma legale).
• Disputa soluzioni errate nei commenti. Più specificamente, è necessario fornire un collegamento a TIO o equivalente che dimostri un programma legale (ovvero uno che non produce alcun errore) che contenga la sottostringa proposta.
• Alcune lingue (ad es. Bash, Batch, Perl) consentono di aggiungere dati binari arbitrari a un programma senza influire sulla validità (ad es. Utilizzando __DATA__in Perl). Per tali lingue, è possibile inviare una soluzione che può apparire solo in tale sezione finale. Assicurati di prenderne nota nella tua risposta. (La definizione di questa "sezione finale" dipende dalla lingua, ma generalmente indica qualsiasi testo dopo che il parser ha smesso completamente di leggere lo script).

Esempio

In Python, potrei inviarlo

x
"""
'''

ma questo può essere incorporato nel programma più grande

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

quindi non è ammissibile.

Modifica , 2 byte

Sono due avanzamenti di riga. La modifica valida deve sempre formare un quadrato perfetto di caratteri ASCII stampabili, quindi non può contenere due avanzamenti di riga di fila.

L'errore è sempre un errore del parser e sempre lo stesso:

This shape is unpleasant.

accompagnato dal codice di uscita 1 .

Provalo online!

Java, 4 byte

;\u;

Provalo online!

Questa è una sequenza di escape Unicode non valida e causerà un errore nel compilatore.

error: illegal unicode escape

COBOL (GNU) , 8 byte

THEGAME

Innanzitutto, un avanzamento di riga per impedirti di inserire la mia parola in una riga commentata.

Quindi, storicamente, i programmi COBOL sono stati stampati su fogli di codifica, il compilatore si basa fortemente su righe limitate di 80 caratteri, non ci sono commenti multilinea e i primi 6 caratteri sono commenti (spesso usati come numeri di riga modificabili), puoi inserire quasi tutto lì , PER QUANTO NE SO. Ho scelto THEGAMall'inizio della riga successiva.

Quindi, il settimo simbolo in qualsiasi riga accetta solo un elenco di caratteri molto limitato: Spazio (nessun effetto), Asterisco (commenta il resto della riga), Trattino, Barra, potrebbero essercene altri, ma certamente no E.

L'errore fornito da GnuCobol, ad esempio, è:

error: invalid indicator 'E' at column 7

Provalo online!

Inoltre, hai appena perso il gioco.

JavaScript, 7 byte

;*/\u)

Nota la nuova riga principale.

• \u) è una sequenza di escape Unicode non valida ed è per questo motivo che questa stringa non è valida
• L'aggiunta di //a all'inizio non funzionerà ancora a causa della nuova riga iniziale, lasciando la seconda riga senza commenti
• L'aggiunta di a /*non decommenterà completamente la stringa a causa della chiusura */che la completa, lasciando \u)esposto
• Come affermato da @tsh, la linea di fondo può essere trasformata in una regex avendo un /after la stringa, quindi avendo il )davanti a \u, possiamo assicurarci che il regex letterale non sia sempre valido
• Come affermato da @asgallant, si potrebbe fare 1||1(string)/per evitare di dover valutare la regex. Il punto e virgola all'inizio della seconda riga impedisce che ciò accada terminando l'espressione 1||1prima che colpisca la seconda riga, forzando così un SyntaxError con il ;*.

Provalo!

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 byte (non cpython)

?"""?'''?

Nota la nuova riga principale. Non è possibile commentare a causa della nuova riga e nessuna combinazione di stringhe tra virgolette triple dovrebbe funzionare se ci pensassi correttamente.

@feersum nei commenti sembra aver completamente rotto qualsiasi programma cpython su Windows per quanto posso dire aggiungendo il carattere 0x1A all'inizio di un file. Sembra che forse (?) Ciò sia dovuto al modo in cui questo personaggio è gestito dal sistema operativo, apparentemente essendo tradotto in un EOF mentre passa attraverso lo stdin a causa di alcuni standard DOS legacy.

In un senso molto reale questo non è un problema con Python ma con il sistema operativo. Se si crea uno script Python che legge il file e utilizza il built-in compilesu di esso, fornisce il comportamento più atteso di generare un errore di sintassi. Anche Pypy (che probabilmente fa proprio questo internamente) genera un errore.

Modificare:

A causa della diligenza di @ feersum nel trovare modi oscuri per rompere l'interprete Python, questa risposta è completamente invalidata per qualsiasi tipico ambiente cpython, per quanto posso dire! (Python 2 e 3 sia per Windows che per Linux) Credo ancora che queste crepe non funzioneranno per Pypy su nessuna piattaforma (l'unica altra implementazione di Python che ho testato).

C (clang) , 16 byte

 */
#else
#else

Provalo online!

*/chiude qualsiasi /*commento e lo spazio iniziale fa in modo che non ne iniziamo uno. La nuova riga chiude qualsiasi //commento e interrompe qualsiasi stringa letterale. Quindi causiamo un errore #else without #ifo #else after #else(indipendentemente da quanti #if 0s potremmo essere dentro).

Pyth, 6 byte

¡¡$¡"¡

¡è un carattere non implementato, il che significa che se il parser Pyth lo valuta, verrà fuori un errore PythParseError. Il codice garantisce che ciò accada su una delle ¡s.

Esistono tre modi in cui un byte può essere presente in un programma Pyth e non essere analizzato: in una stringa letterale ( "o .", che sono analizzati in modo equivalente), in una Python letterale ( $) e immediatamente dopo a \.

Questo codice impedisce \di valutarlo senza errori, poiché ciò influisce solo sul byte immediatamente successivo e sui secondi ¡errori.

$incorpora direttamente il codice all'interno di $s nel codice Python compilato. Non faccio ipotesi su cosa potrebbe accadere lì.

Se il programma raggiunge questo codice in un $contesto, finirà con il $, e ¡subito dopo farà l'errore del parser. I letterali di Python Python finiscono sempre al successivo $, indipendentemente da ciò che il codice Python potrebbe fare.

Se il programma si avvia in un "contesto, la "stringa terminerà e il finale ¡farà l'errore del parser.

Ada - 2 byte

Penso che dovrebbe funzionare:

_

Questo è il carattere di sottolineatura di nuova riga. Newline termina i commenti e non è consentito in una stringa. Un carattere di sottolineatura non può seguire gli spazi bianchi; era consentito solo dopo lettere e numeri, ma l'introduzione di Unicode rendeva le cose complicate.

codice macchina x86 a 32 bit, 11 byte (e 64 bit a prova di futuro)

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

Questo è times 9 nop/ ud2. È fondamentalmente una slitta NOP , quindi funziona ancora come 0 o più se nopquindi ud2solleva un'eccezione, indipendentemente da quanti 0x90byte sono stati consumati come operandi a un precedente codice operativo. Anche altre istruzioni a byte singolo (come times 9 xchg eax, ecx) funzionerebbero.

codice macchina x86 a 64 bit, 10 byte (CPU correnti)

Esistono alcune istruzioni illegali a 1 byte in modalità 64 bit, fino a quando qualche futura estensione ISA le ripropone come prefissi o parti di codici operativi multibyte solo in modalità 64 bit, separate dal loro significato in modalità 32 bit. 0x0eè push csin modalità a 32 bit, ma illegale su CPU attuali (testato su Intel Skylake) in 64 bit.

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

Interpretazione delle regole per il codice macchina eseguibile :

• I byte non possono essere saltati (come la restrizione "non analizzata"), poiché le CPU non sollevano eccezioni finché non tentano effettivamente di decodificare / eseguire (non speculativamente).

• I mezzi illegali generano sempre un'eccezione, ad esempio un'eccezione di istruzione illegale. (I programmi reali possono catturarlo con un gestore di eccezioni su bare metal o installare un gestore di segnali del sistema operativo, ma penso che questo catturi lo spirito della sfida.)

Funziona perché una stringa di byte più breve che termina in ud2potrebbe apparire come imm32 e / o parte della modalità di indirizzamento per un'altra istruzione o divisa in una coppia di istruzioni . È più facile pensarci in termini di ciò che potresti mettere davanti alla stringa per "consumare" i byte come parte di un'istruzione e lasciare qualcosa che non si guasterà.

Penso che un'istruzione possa consumare al massimo 9 byte di cose arbitrarie: un byte SIB, un disp32 e un imm32. cioè i primi 2 byte di questa istruzione possono consumare 8 NOP e un ud2, ma non 9.

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

Impossibile battere 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    

Modalità a 64 bit:

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

Ma i byte per 8 NOP + ud2 (o times 9 db 0x0e) possono apparire come parte di altri insn:

    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 byte

*/"
#endif<#@#>

Funziona perché:

• // il commento non funzionerà a causa della nuova riga
• /* il commento non funzionerà a causa del */
• Non puoi avere costanti nel solo codice
• L'aggiunta #if falseall'inizio non funzionerà a causa di#endif
• Il "chiude qualsiasi stringa letterale
• La <#@#>è una direttiva senza nome così non riesce per modelli T4.
• La nuova linea lo inganna, quindi avere /all'inizio non ingannare*/

Ogni variazione ha esito negativo con un errore di compilazione.

APL e MATL e Fortran , 3 byte

'

Newline, Quote, Newline genera sempre un errore poiché non esistono commenti di blocco:

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

Letterato Haskell , 15 byte

Riparando un tentativo cancellato di nimi.

\end{code}
5
>

Provalo online!

Il tentativo originale di nimi sono le ultime due righe, basate su Literate Haskell che non consente >al codice letterato di stile di trovarsi su una riga vicina a una riga di commento alfabetizzata ( 5qui). Non è riuscito perché può essere incorporato in un commento nello stile di codifica alternativo ("LaTeX"):

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

Tuttavia, lo \begin{code}stile di Literate Haskell non nidifica, né in sé né nei {- -}commenti multilinea, quindi inserendo una linea \end{code}appena prima della linea con la 5, quella soluzione alternativa non riesce e non ne vedo una diversa.

Free Pascal, 18 byte

*)}{$else}{$else}

Prima chiudi tutti i commenti possibili, quindi gestisci la compilazione condizionale.

Per favore, commenta qui se ho dimenticato qualcosa.

Commodore 64 Basic, 2 byte

B

(questa è una nuova riga seguita dalla lettera "B").

Qualsiasi riga in un programma Commodore 64 deve iniziare con un numero di riga o una parola chiave BASIC e i programmi memorizzati consentono solo numeri di riga. Non ci sono parole chiave che iniziano con "B" (o "H", "J", "K", "Q", "X", "Y" o "Z").

Brain-Hack (una variante di Brain-Flak ), 3 2 byte

Grazie a Wheat Wizard per aver sottolineato che Brain-Hack non supporta i commenti, salvandomi un byte.

(}

Provalo online!

CJam , 7 byte

"e#"
:"

Provalo online!

VBA, 2 byte

Un avanzamento di riga seguito da un carattere di sottolineatura: le _funzioni come carattere di continuazione della riga in VBA e poiché non vi è nulla nella riga direttamente a sinistra o sopra la continuazione della riga, unitamente alla mancanza di commenti multilinea di VBA significa che ciò genererà sempre la compilazione errore temporaleCompile Error: Invalid character

_

SmileBASIC, 2 byte

!

Nulla continua oltre la fine di una riga, quindi tutto ciò che serve è un'interruzione di riga seguita da qualcosa che non può essere l'inizio di una frase. !è l'operatore logico non, ma non ti è permesso ignorare il risultato di un'espressione, quindi anche qualcosa del genere non !10sarebbe valido (mentre X=!10funziona, ovviamente)

Cose simili funzioneranno in qualsiasi lingua in cui tutto termina alla fine di una riga, purché analizzi il codice prima di eseguirlo.

Ci sono molti personaggi alternativi che potrebbero essere usati qui, quindi penso che sarebbe più interessante elencare quelli che POTREBBERO essere validi.

@è l'inizio di un'etichetta, ad esempio @DATA; (potrebbe far parte di un'espressione come quella (X)=1consentita per qualche motivo; qualsiasi lettera o _potrebbe essere un nome variabile X=1, una chiamata di funzione LOCATE 10,2o una parola chiave WHILE 1; 'è un commento; ed ?è l'abbreviazione di PRINT.

INTERCAL , 12 byte

DOTRYAGAINDO

Prova a decifrarlo online!

L'approccio di INTERCAL agli errori di sintassi è un po 'speciale. Sostanzialmente, un'istruzione non valida non commetterà effettivamente errori a meno che il programma non tenti di eseguirla. In effetti, la sintassi idiomatica per i commenti è di avviarli PLEASE NOTE, che in realtà inizia solo un'istruzione, dichiara che non deve essere eseguita e quindi inizia con la lettera E. Se il tuo codice ha DODOnel mezzo di esso, potresti anteporre DOABSTAINFROM(1)(1)e virare qualsiasi istruzione valida alla fine e andrà tutto bene, se è DODODOpossibile piegare l'esecuzione attorno ad esso come (1)DON'TDODODOCOMEFROM(1). Anche se INTERCAL manca di una sintassi letterale di stringa per sfuggirle, non c'è modo di usare gli errori di sintassi per creare una stringa illegale, anche esaurendo ogni possibile numero di riga con(1)DO(2)DO...(65535)DODODO, poiché sembra che sia possibile avere numeri di riga duplicati COME FROMlavorando con uno qualsiasi di essi.

Per fare una stringa illegale, abbiamo effettivamente bisogno di usare una dichiarazione perfettamente valida: TRY AGAIN. Anche se non viene eseguito, deve essere rigorosamente l'ultima istruzione in un programma se è nel programma. 12 byte è, per quanto ne sappia, il più breve che una stringa illegale possa usare TRY AGAIN, perché deve garantire che ci sia un'istruzione dopo (eseguita o meno), quindi DOTRYAGAINè solo un codice normale e deve assicurarsi che l'intera istruzione è effettivamente TRY AGAIN, quindi TRYAGAINDOnon funziona perché può essere facilmente trasformato in un errore di sintassi normale ignorato:, DON'TRYAGAINDOGIVEUPo PLEASE DO NOT TRY TO USE TRYAGAINDO NOT THAT IT WOULD WORK. Non importa ciò che si mette su entrambi i lati DOTRYAGAINDO, sarà errore, sia con ICL993I I GAVE UP LONG AGO, ICL079I PROGRAMMER IS INSUFFICIENTLY POLITEo ICL099I PROGRAMMER IS OVERLY POLITE.

AWK , 4 byte

/

Provalo online!

Dato AWKche non ha un metodo per fare commenti su più righe, sono necessarie 2 nuove righe prima e 1 dopo /per evitare di commentare o trasformare questo in una regex, ad esempio aggiungere 1/. Il messaggio più comune è `newline inatteso o fine della stringa.

Con crack precedente

Fortran, 14 byte

end program
e

Nessun commento su più righe o direttive preprocessore in Fortran.

JavaScript (Node.js) , 9 8 byte

`*/
\u`~

Provalo online!

Penso che questo dovrebbe essere abbastanza illegale.

Tentativi precedenti di JS in altre risposte

; * / \ U)

Di @Cows ciarlatano

Come risposta ES5 questo dovrebbe essere valido, ma in ES6 il wrapping del codice con una coppia di backtick lo rovina. Di conseguenza, le risposte ES6 valide devono comprendere backtick.

`
`* /} '" `\ U!

Di @iovoid

Questa è una versione migliorata che coinvolge backtick. Comunque un singolo /dopo che il codice lo rompe (diventa un modello letterale che viene moltiplicato per una regex, inutile ma sintatticamente valido.) @Neil ha suggerito che cambiando !in ). Questo dovrebbe teoricamente funzionare perché l'aggiunta /alla fine non funziona più (a causa di regex malformato).

Spiegazione

`*/
\u`~

Questo è di per sé illegale e blocca anche tutte le virgolette singole e doppie perché tali virgolette non possono estendersi attraverso le righe senza un \alla fine di una riga

//`*/
\u`~

e

/*`*/
\u`~

Blocca i commenti introducendo sequenze di escape illegali

``*/
\u`~

Blocca il backtick iniziale introducendo il valore letterale RegExp non terminato

console.log`*/
\u`~

Blocca i letterali dei template con tag introducendo un operatore previsto tra due backtick

Rockstar , 4 5 byte

Barrato 4 è ancora 4 :(

)
"""

Rockstar è un linguaggio molto ... prolisso.
Sebbene "possa essere utilizzato per definire una stringa, ad esempio Put "Hello" into myVar, per quanto ne sappia, non è possibile che vengano visualizzate 3 virgolette al di fuori di un commento e la parentesi chiusa garantisce che non accada nemmeno (I commenti in Rockstar sono racchiusi tra parentesi, come Questo).

Rockstar ha anche una sintassi letterale poetica, in cui la punteggiatura viene ignorata, quindi la nuova riga si assicura che le 3 virgolette siano l'inizio di una riga di codice, che dovrebbe sempre essere non valido

Powershell, 10 8 12 14 13 14 16 byte

^{-2 byte grazie a Mazzy che trova un modo migliore per romperlo
+4 -1 byte grazie a IsItGreyOrGray}

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

Spero che funzioni. 'e "per evitare il rischio di citazioni, #>per rompere il blocco-commento, nuove linee per fermare il commento a riga singola, sia '@e "@per la cattura di un altro stile di stringhe, e poi inizia una serie improprio di gettare un errore di sintassi.

La logica è che non possono usare nessuna serie di virgolette per entrare, non possono bloccare-commentarla, se @"usata, creerà una stringa qui che non può avere un token in seguito, e se loro lascia perdere, proverà a creare un array rotto. Questa affermazione vuole vivere così duramente, continuo a trovare ancora più buchi nell'armatura.

Incantesimi runici, 3 byte

Ṷ

Una delle tante varianti possibili.

Provalo online!

Runic utilizza unicode che combina i caratteri in un " Mmodifica il comportamento di C" (dove Cè un comando). Pertanto, non è consentito a due modificatori modificare lo stesso comando e il parser genererà un errore se viene rilevata una tale occorrenza.

Allo stesso modo, alcuni comandi che reindirizzano l'IP non possono essere modificati in alcun modo, a causa dell'esistenza di caratteri modificatori di direzione (ed entrambi nella stessa cella non hanno senso).

Non c'è modo di scappare o letteralmente ridimensionare la stringa per renderla valida. Tio link contiene ;a per evitare l'errore "no terminator" con priorità più alta.

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

A

(24500 volte)

TI (-83 + / 84 + / SE) -Basic fa la sintassi controllando solo le istruzioni che raggiunge, quindi anche 5000 Endistruzioni di fila possono essere saltate con a Return. Questo, al contrario, non può adattarsi alla RAM di una TI-83 + / 84 + / SE, quindi nessun programma può contenere questa stringa. Essere un po 'conservatore con il conteggio dei personaggi qui.

La TI-83 originale ha 27000 byte di RAM, quindi Ain questo caso avrai bisogno di 27500 s.

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

"

Newline, preventivo, newline. La nuova riga chiude tutti i commenti (e non consente l'incorporamento del carattere illegale in una stringa, poiché le costanti di stringa multilinea AFAIK non sono consentite), l'altra riga non consente di chiudere la stringa e la citazione restituisce un errore di sintassi.

È possibile arrivare a 2 byte con

±

senza la nuova riga, ma non sono sicuro se questo conta perché ±è valido solo nelle costanti di stringa.

Vai , 6 byte

*/```

Prova a decifrarlo online!

L'accento grave (`) segna una stringa grezza letterale, all'interno della quale tutti i caratteri tranne`, inclusi newline e barre rovesciate, vengono interpretati letteralmente come parte della stringa. Tre `` di fila '' sono il nucleo: i letterali di stringa adiacenti non sono validi e `chiude sempre una` stringa, quindi non c'è modo di dar loro un senso. Ho dovuto usare altri 3 byte per l'antielusione, una nuova riga in modo da non poter essere all'interno di un commento a riga singola o una stringa tra virgolette normale e un * / quindi non possiamo essere all'interno di un commento a più righe.

SILOS , 4 byte

I silos sono competitivi \ o /

x+

SILOS viene eseguito su un interprete / compilatore a due passaggi. Prima dell'esecuzione, un "compilatore" tenta di semplificare l'origine in un array che descrive l'origine. Ogni riga viene trattata separatamente. x + a è un operatore di assegnazione che aggiungerà ea al valore di x e lo memorizzerà in x. Tuttavia, il "compilatore" si interromperà. Pertanto, prendiamo questa stringa e aggiungiamo una nuova riga prima e dopo assicurandoci che sia sulla propria riga e interrompa il compilatore.

Provalo online!

Tasto di scelta automatica , 5 byte

`è il personaggio di fuga. Puoi evitare un "quando lo assegni a una variabile.

\ n * / impedisce di essere commentato o assegnato a una variabile.

*/`"

JavaScript, 11 caratteri

`
`*/}'"`\u)

I backtick assicurano di eliminare le stringhe del modello, le virgolette si liberano delle stringhe, la newline evita le righe commentate, la fine del commento evita i commenti in blocco e l'ultimo backtick e escape (con un! Per evitare di aggiungere numeri) provano a iniziare un invalido corda.

Provalo online!