Trova una stringa illegale


81

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.


2
Un contro-esempio può fare affidamento sull'input di STDIN?
Zacharý,

5
Questo farebbe un buon CnR?
Calcolatrice

2
Troppo tardi ora credo, ma sembra che questa potrebbe essere stata una sfida per poliziotti e ladri. C'è molta abilità evidente nei tentativi di rendere validi i programmi, oltre a inventare le stringhe in primo luogo.
user2390246

4
Le mie condoglianze ai tentativi del Perl. :)
Kaz,

2
Sono abbastanza sicuro che sia completamente impossibile in Haskell non alfabetizzato, grazie ai commenti annidati.
Dfeuer

Risposte:


57

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!


Questo funziona anche con 2Col . Provalo online! . Ma la ragione per cui questo si interrompe in 2Col è che ogni riga deve contenere esattamente 2 caratteri, ma la riga vuota lo interrompe.
Kritixi Lithos,

2
+1 perché questo è automaticamente il vincitore, poiché le soluzioni a 1 byte non sono consentite perché "non puoi semplicemente usare un personaggio che viene sempre rifiutato".
Zacharý,

1
@Cowsquack tfw Ho dimenticato la mia lingua
Skidsdev il

1
@Skidsdev tfw Ho dimenticato di nuovo la mia lingua e ho dimenticato di me dimenticando la mia lingua
Skidsdev

@ Zacharý Che dire delle soluzioni a 0 byte?
PyRulez,

32

Java, 4 byte

;\u;

Provalo online!

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

error: illegal unicode escape

Non funziona - si potrebbe avere una stringa letterale come "\\u;".
febbraio

@feersum Risolto al costo di un byte
Kritixi Lithos il

21
@TheLethalCoder: Java elabora il codice sorgente per modificare le escape \uXXXXprima di fare qualsiasi altra cosa , quindi sì, questo funzionerà anche all'interno dei commenti.za
nneonneo,

3
Penso che questa sia la risposta Java più breve nella storia di questo sito ancora ..
Magic Octopus Urn

1
@MagicOctopusUrn In realtà, c'è questa risposta Java a 0 byte (che non è più rilevante nel meta corrente, dato che emette su STDERR invece che su STDOUT). Sebbene entrambi siano piuttosto sorprendenti e intelligenti. :)
Kevin Cruijssen,

25

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.


30
Also, you just lost the game.Ho quasi annullato il voto
Stephen,

24

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!


2
/* */\u0045 = 3sembra un codice JavaScript valido.
TSH

2
3 */\u;/è ancora valido.
TSH

3
È interessante notare che a partire da ES2018 (che non sarà ufficiale fino alla fine di quest'anno), puoi semplicemente avvolgere il tutto in backtick a causa di ciò . Probabilmente potresti risolvere questo problema semplicemente inserendo un backtick dopo il /(non che è necessario risolverlo). (Inoltre, il ;non forza l'analisi del regex cattivo, forza un SyntaxError con il *.)
ETHproductions

1
@Leushenko Ma questo non funziona #if 0come visto qui: provalo online!
Kritixi Lithos,

3
Nelle versioni JS più recenti, String.raw con una stringa di modello può impedire che ciò non si interrompa, poiché la fuga non valida non riesce. Sarebbe: String.raw`code here`
iovoid

15

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).


1
@officialaimm considera"""?'''"""
KSab il

3
Ho creato un programma con questa sottostringa che gira sulla mia macchina. Tuttavia, penso che non funzioni su molti interpreti / piattaforme / versioni. Puoi specificare quale versione dell'interprete e del sistema operativo Python è indirizzata a questa risposta?
febbraio

1
Python 3 su Windows 7 sembra essere esattamente dove funziona il mio crack. Pastebin del programma con codifica base64
febbraio

1
Posso rompere anche questo. Inserisci semplicemente un carattere 0x1A all'inizio del file e tutto il resto viene ignorato (questo funziona anche con Python 3).
feersum

1
So che è davvero vecchio, ma dopo aver lavorato con alcune persone in Python Discord, abbiamo trovato questo crack , anche se non so se cambiare la codifica possa essere considerato un imbroglio
EdgyNerd,

14

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).



2
Anche dal momento che le stringhe raw di C ++ 11 sembrano funzionare, una soluzione è impossibile con gcc.
febbraio

@feersum Huh, TIL che GCC accetta quelli nel codice C. Potrei specificare -std=c99, ma proviamo a passare al clang.
Anders Kaseorg,

3
Sono davvero sorpreso che gcc accetti stringhe raw C ++ 11. Specificare la versione del compilatore o l'implementazione è perfettamente OK, quindi se è illegale in Clang, è un gioco equo.
nneonneo,

1
@ l4m2 Non riesco ad analizzare la tua domanda (chi sono e cosa intendi di nuovo?), ma nota che una stringa raw C ++ letterale supporta un delimitatore personalizzato: R"foobar(...)foobar"e solo una parentesi destra seguita dal delimitatore corrispondente e un la citazione lo chiuderà.
Anders Kaseorg,

11

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.


11

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.


2
Benvenuti nel sito! :)
DJMcMayhem

9

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
  ...

Le regole qui non erano abbastanza chiare per me da considerare di pubblicare una risposta asm / codice macchina. Ad esempio, perché non puoi semplicemente farlo ud2? Sembra che tu stia dicendo che interpreti le regole come vietare di saltare sui byte, quindi ud2funzionerebbe bene da solo, no? Oh ... immagino tu stia dicendo che il problema è che ud2può apparire come prefisso a un'istruzione valida? La seconda parte di questa risposta è stata per me un po 'difficile da capire.
Cody Gray,

@CodyGray: giusto, i 2 byte che codificano ud2possono apparire in imm32qualsiasi istruzione. Stavo pensando a questo in termini di byte che puoi mettere davanti a una stringa del genere che "consuma" 0f 0bcome parte di un'istruzione precedente anziché decodificarla come ud2. Non ero completamente contento di come ho finito per presentarlo, ma volevo illustrare perché solo 8 nops non erano abbastanza e cosa è successo con 9 nops + ud2.
Peter Cordes,

@CodyGray: un programma sorgente asm sarebbe una risposta totalmente diversa. Ciò dovrebbe comportare l'errore del parser utilizzato dall'assemblatore, senza produrre codice macchina difettoso. Quindi qualcosa come %else/ %elsepotrebbe funzionare per sconfiggere %if 0, che normalmente può proteggere qualsiasi testo non valido dall'analisi. (idea da una risposta del CPP)
Peter Cordes,

Non del tutto soddisfacente. La tua soluzione potrebbe essere solo in .data. (anche se lo rende impossibile)
l4m2

@ l4m2: per rendere la domanda responsabile / interessante, ho dovuto limitarla al codice eseguito (e non saltato). Vedi i punti elenco di interpretazione delle regole nella mia risposta. Ciò escluderebbe anche i dati statici, ovviamente. Perché allora non è affatto un codice macchina, sono solo dati. Questa domanda ha richiesto più adattamento rispetto alla maggior parte per una risposta in codice macchina per avere un senso, perché non esiste una fase di compilazione / assemblaggio in cui è possibile errore il parser, stiamo solo parlando di byte già in memoria.
Peter Cordes,

7

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.


1
Strano che tu abbia deciso di includere modelli T4 nel tuo codice. T4 non è considerato una lingua separata?
Arturo Torres Sánchez,

1
@ ArturoTorresSánchez Non so di non averne mai sentito parlare. Qualcuno ha commentato che non ha funzionato quando hai incluso i modelli T4, quindi ho aggiunto la correzione.
TheLethalCoder il


5

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.


4

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.


3
@ user902383 Il tuo esempio contiene la nuova riga principale del suo snippet?
Brian J,

@BrianJ no, ho pensato che fosse solo un problema di formattazione, mio ​​cattivo
user902383

Non penso sia possibile in Free Pascal. Li metti solo dopo begin end..
jimmy23013,

@ jimmy23013 ma sembra che i codici dopo la end.validità diventino consentiti dalla domanda.
TSH

4

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").


Se aggiungo, =0questa diventa una dichiarazione di incarico ...
Neil,

1
@Neil, sarebbe un comando valido in modalità immediata, ma non un programma valido.
Segna il

4

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!


Come si fanno commenti in Brain-Flak? Non so come fare.
Erik the Outgolfer,

@EriktheOutgolfer # TIO
Riley

Huh comportamento senza documenti.
Erik the Outgolfer,

@EriktheOutgolfer Ho sempre pensato che fossero documentati da qualche parte. Vedrò di aggiungerli.
Riley,

Non è necessaria la nuova riga in BrainHack o Craneflak, Rain-Flak è l'unica delle tre versioni con commenti di riga. Sebbene Craneflak analizzi al volo, quindi è impossibile risolverlo in Craneflak, qualsiasi soluzione potrebbe essere battuta anticipando (()){()}.
Wheat Wizard


3

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


_

Dipendi dal tuo modello a partire da una nuova riga ... quindi aggiungi una nuova riga.
Deduplicatore,

@Deduplicator ha già una nuova linea, - non importa cosa segue la _, solo che non esiste una linea valida a sinistra o sopra di essa
Taylor Scott

Cosa succede se è incorporato in questo modo myfunction( \n_ ):?
Deduplicatore,

@Deduplicatore il carattere di continuazione della riga deve trovarsi sulla stessa riga in quanto continua, ovvero Public Function Foo( ByVal bar as Integer, _ (nuova riga) bas as long) as double- quindi sì, comporterebbe un errore se si chiamasse la funzione descritta
Taylor Scott

Ok, in quel caso è più simile myfunction( _ \n_ ). Dispiace per la confusione. Per dirla in altro modo, avresti dovuto usare due nuove righe.
Deduplicatore,

3

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.


oh, per qualche ragione quando ho modificato il post è stato duplicato ...
12Me21

3

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.


Potrebbero esserci alcuni altri errori di compilazione che possono essere attivati ​​in precedenza ICL993I I GAVE UP LONG AGO.
Corda non correlata

Se, mentre usi ogni etichetta di linea, hai anche COME FROMogni etichetta di linea, potrebbe essere un po 'difficile deviare il flusso di controllo attorno al blocco, ma non c'è nulla che ti impedisca di farlo GIVING UP!
Corda non correlata

3

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


2

Fortran, 14 byte


end program
e

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


1
C'è un buon modo per testarlo online? Inoltre, quale versione / compilatore di Fortran?
Robert Benson,

2

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


2

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


Che dire (()"""), non sarebbe una no-op?
ბიმო

@BMO il primo paren apre un commento, il secondo paren non fa nulla perché è commentato, il terzo paren chiude il commento, quindi sei """)stato analizzato come codice, il che non è valido
Skidsdev

Hmm, i commenti nidificati non sono nelle specifiche. I commenti sembrano comunque scoraggiati. Ma hai supervisionato letterali poetici di stringhe che consentono qualsiasi stringa, quindi Goethe says )"""è valido .
ბიმო

@BMO buon punto, può essere risolto inserendo una nuova riga tra )e"""
Skidsdev

2

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.


1
O protettori +@=
mazzy

1
@IsItGreyOrGray AAAAAAAAAAAw diamine.
Veskah,

2
Sembra che la modifica di #> in $ #> lo interromperà come "non riconosciuto come il nome di un cmdlet ..." Potrebbe essere reso di nuovo legale in qualche modo, ma non ho modo. Ancora. :)
GreyOrGray il

1
@IsItGreyOrGray Sonofagun. Ora con l'armatura semi-colon?
Veskah,

1
Bello! Non ho niente Tutto ciò che ho provato è fallito.
GreyOrGray,

2

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.


2

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.


Fatto, grazie :)
bb94,

2

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.


1

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!


Perché non ax+errore?
Erik the Outgolfer,

comportamento del compilatore indefinito @EriktheOutgolfer
Rohan Jhunjhunwala


1

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!



La risposta ES5 ha usato un )dopo il \u, forse avrebbe funzionato qui?
Neil
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.