A differenza di molte sfide C&R, ciò non richiede un posto separato per ladri; l'obiettivo dei ladri è quello di decifrare la risposta precedente e poi postarne una nuova come poliziotto.

Come risponditori, scriverai una serie di poliglotti che assomigliano a questo (ogni colonna è una lingua e ogni voce è l'output della risposta in quella lingua):

Language:  1  2  3  4  5  6  7  8  ...
Answer 1:  0  1  2
Answer 2:     1  2  3
Answer 3:        2  3  4
Answer 4:           3  4  5
Answer 5:              4  5  6
Answer 6:                 5  6  7
...

(spazi vuoti indicano che non è richiesto alcun comportamento in quel caso).

Ogni risposta dovrebbe funzionare in 3 lingue e stampare 3 diversi numeri consecutivi che sono uno più rispetto ai numeri stampati dalla risposta precedente (le prime stampe di risposta 0, 1e 2). Ogni risposta utilizza due lingue della precedente presentazione e una terza nuova lingua. Il risponditore dovrebbe cercare di offuscare qual è questa terza lingua.

Per pubblicare una nuova risposta, dovresti:

• Rompi la risposta più recente trovando qual è la sua terza lingua.
• Preferibilmente, aggiungi una spiegazione per il tuo crack e notifica al poster la risposta. Una volta che la tua richiesta è stata decifrata, dovresti preferibilmente aggiungere anche una spiegazione.
• Scrivi una poliglotta composta dalla seconda e terza lingua di questa risposta, insieme a un'altra lingua di tua scelta. Rivela le tue prime due lingue, ma non rivelare la tua nuova. Sarà il prossimo obiettivo del poster trovare questa lingua (o qualsiasi altra lingua in cui funziona), quindi dovresti cercare di offuscarlo.

specificazioni

• I criteri per un linguaggio di programmazione valido sono gli stessi di The Programming Language Quiz, Mark II - Cops :

  • Ha un articolo di Wikipedia in inglese , un articolo di esolangs o un articolo di Rosetta Code al momento in cui questa sfida è stata pubblicata, oppure è su Provalo online! . Avere un interprete collegato in una di queste pagine rende quell'interprete completamente legale.
  • Deve soddisfare le nostre regole su ciò che costituisce un linguaggio di programmazione .
  • Deve avere un interprete gratuito (come nella birra). Gratuito qui significa che chiunque può utilizzare il programma senza dover pagare per farlo.

• Ogni risposta deve essere eseguita in meno di un minuto su un PC ragionevole.

• È possibile riutilizzare i linguaggi di programmazione, ma ci deve essere almeno due risposte tra (quindi una risposta individuale non può riutilizzare una lingua).
• Craccare un invio consiste nel trovare qualsiasi linguaggio di programmazione che stampa il risultato corretto, non solo quello desiderato. Se un invio viene eseguito in una lingua che non è stata dichiarata o trovata funzionante, non è richiesto alcun intervento.
• Non puoi postare due volte (o più) di seguito.

Criterio vincente

La risposta vincente è qualunque sia la risposta impiegata più tempo per essere risolta. La sfida non finirà mai, quindi è sempre possibile che la risposta vincente cambi.

Hexagony, Klein (101) e ???

  xx={puts/}
gets87!@xx=p

main\

>9.*5,6v

Questo stampa 7in Hexagony , 8in Klein (101) e 9in ???.

Il 9non funziona se viene aggiunta una nuova riga alla fine del codice. Fai attenzione se stai testando localmente.

Modifica: essere in diretta per 20 ore è già un record, quindi darò alcuni suggerimenti da ora in poi. (Anche perché la lingua in questione è l'IMO non ancora nota.)

suggerimenti

1. "Il 9non funziona se viene aggiunta una nuova riga alla fine" è molto significativo, così come i primi due spazi (che sono ignorati sia da Hexagony che da Klein).
2. La lingua è su TIO.
3. I primi due spazi fanno saltare il programma all'ultima riga. (E ' non è una lingua 2D.)
4. Non esiste un comando di output esplicito e il vcomando termina il programma.

Spiegazione ( posta incrinata )

Nel codice sorgente

abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@

Le istruzioni pertinenti in Klein (101) sono:

IP->.....................^...........IP->/
.........................|...................
.........................8
.........................\<-.............IP<-
                         @

Klein è un linguaggio 2D simile a un fungo dove attraversare il confine dell'area del codice (che è un quadrato) dipende dalla topologia di Klein. /e \sono specchi.

L'IP inizia nell'angolo in alto a sinistra rivolto verso destra. Incontra uno specchio verso il limite superiore e rientra nell'area di codice sul lato destro come mostrato sopra. Quindi colpisce di nuovo lo specchio, 8 viene premuto e poi (dopo aver attraversato il confine più volte) si ferma a @. Quindi il contenuto della pila viene stampato su stdout, che è 8 singolo.

Befunge-96, Hexagony e ???

abcd={} -- a gaffe avoiding tactic in C++/C#
abcd[!1]=   1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+8+6<0-0]//35)
if 0>1 then a.next=';' en\
                    >1+6.@.@

Questo stampa 6in Befunge-96 , 7in esagonia e 8in ???.

Spiegazione

Il codice esagonico, quando "preimpostato" è:

       a b c d = { } - 
      - a g a f f e a v 
     o i d i n g t a c t 
    i c i n C + + a b c d 
   [ f a l s e ] = 1 + 2 + 
  3 + 4 + 5 + 6 + 7 + 8 + 9 
 + 1 0 + 1 1 + 1 2 + 1 3 + 1 
7 ! p r i n t ( a b c d [ 0 > 
 1 + 2 + 3 a n d 4 + 5 + 6 < 
  0 - 0 ] / / 3 5 ) i f 0 > 
   1 t h e n a . n e x t = 
    ' ; ' e n d > 1 + 6 . 
     @ . . . . . . . . . 
      . . . . . . . . . 
       . . . . . . . . 

Il percorso di esecuzione inizia in alto a sinistra in direzione est. La riga superiore non fa molto. -cambia il bordo di memoria corrente in modo che il valore sia 0. L'esecuzione continua verso est sulla riga centrale dove viene 7!caricato 7il bordo di memoria corrente e le stampe sono un numero intero. [cambia il puntatore dell'istruzione in Nord Est a partire da 7. Successivamente 7+3, viene eseguita l'esecuzione [che modifica il puntatore dell'istruzione in Nord Ovest a partire dall'angolo Sud-Est. Finalmente il percorso è ..@dove @termina il programma.

Lua, brainfuck, ???

abcd = {} - una gaffe che evita la tattica in C ++
abcd [false] = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14
stampa (abcd [0> 1 + 2 + 3 e 4 + 5 + 6 <0-0] // 35)
se 0> 1 allora a.next = ';' fine

Stampa 3 in Lua, 4 in brainfuck e 5 in ???.

Spiegazione per posta incrinata :

a = 1 + 2 + 3 + 3 + 4 + 5 + 6 + 7 + 8 + 9
b = 1 + 1 + 1
f = 3 - (- 1)
c = + 9 + 7 13 + 11 + 12 + 3--1
g = a + b + c + 1 + 2 + 3 + 4 + 5
j = 9 + 7 + g + c + b + a + g + g + g + g + g + g + 2 + 1 + 3 + 4 + 1 + 1
h = 1 + 1 + 1 + 1 + 333 + 1 + 1 + 1 + 111 + 1 + 1 + 1 + 333 + 1 + 1 + 1 + 1 + 1.
stampare (f)

• In Python 3, 3--(-1)è 2, quindi print(f)stampa 2 (le altre cose non sono necessarie)
• In Lua, di --nuovo è un commento, quindi 3--(-1)è solo 3, quindi print(f)stampa 3 (altre cose non sono ancora necessarie)
• In Brainfuck, ci sono 57 assi e 5 inconvenienti che impostano la prima cella sul nastro su 52 e il .carattere di output 52 che è 4.

Trigger , JavaScript e ???

[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52

Stampa 11in Trigger , 12in JavaScript e 13inREDACTED .

Dal momento che questo non è stato risolto da più tempo di qualsiasi altra risposta finora, ecco alcuni suggerimenti:

• Nel caso in cui non l'avessi notato, il Тeе sulla prima riga sono caratteri multibyte.
• [ // e \\ ][ // non ci sono operazioni.
• La seconda linea, così come -²52 , è un codice morto.
• La lingua non ha un concetto di terminazione, quindi ²6 forma un ciclo infinito.
• Per essere precisi, il secondo byte della codifica UTF-8 di ², insieme a6 , forma un ciclo infinito.
• Il numero in uscita viene codificato dal /!'!/
• La lingua non è su Try It Online, Rosetta Code o Esolangs.
• L'unica forma disponibile di output è una schermata 1bpp.
• Le proporzioni dello schermo sono 2.
• Mentre il linguaggio non era originariamente inteso come codice macchina, esistono implementazioni FPGA.
• Secondo Wikipedia, lo scopo previsto della lingua erano i videogiochi.
• L'unico modo per accedere allo schermo è un'istruzione speciale, che prende le coordinate in registri selezionabili, e l'altezza come immediata, e XORs un bitmap 8 per n sullo schermo. Per facilitare il rilevamento delle collisioni e per rendere possibile la pulizia dello schermo, uno dei registri verrà impostato quando un pixel viene disattivato.

Spiegazione

Bene, ci è voluto del tempo per incrinarsi. Vediamo come appare il codice:

0200 5b20    SE VB, V2   ; Skip the next instruction if VB = V2. Since all
0202 2f2f    CALL 0xF2F  ; registers start at 0, this call will be skipped. This
                         ; hides the bytecode from JavaScript.
0204 61d0    LD V1, 0xD0 ; A useless load. Necessary to use a UTF-8 continuation
0206 a22f    LD I, 0x22F ; byte as an instruction and load the address of
                         ; the sprite.
0208 5c5c    SE VC, V5   ; A red herring supposed to suggest symmetry is
                         ; important, as well as a totally intended eliminator
                         ; of inaccurate implementations. Most documentation
                         ; claims that the lowest nibble must be zero, but in
                         ; the original COSMAC VIP implementation it's
                         ; a don't-care.

Ciò significa che, sebbene molti emulatori disponibili si comportino correttamente, l'implementazione secondo le regole è collegata nella seconda frase della pagina di Wikipedia . Naturalmente, non può essere eseguito direttamente su un PC medio, ma ho trovato l' emulatore Emma 02 collegato alla pagina VIP COSMAC per funzionare al meglio.

020A 205d    CALL 0x05D    ; Skipped.
020C 5b20    SE VB, V2     ; Same as with the very beginning. Red herring.
020E 2f2f    CALL 0xF2F
0210 d0b5    DRW V0, VB, 5 ; Draw the sprite pointed to by I. Since V0 and VB
                           ; haven't been written to yet, the sprite will be drawn
                           ; in the top-left corner of the screen. The height is
                           ; an immediate.
0212 2236    CALL 0x236    ; Jump over the JavaScript and Trigger code. It doesn't
                           ; matter that we never return.
0214-022E *never used*
022F 2f      DB %00101111  ; Sprite data.
0230 21      DB %00100001
0231 27      DB %00100111
0232 21      DB %00100001
0233 2f      DB %00101111
0234-0235 *never used*
0236 b236    JP V0, 0x236  ; Since V0 is still zero, this is an infinite loop.
0238-023C *never used*     ; Together with the previous two lines, it's the
                           ; -²6-²52. It's a red herring supposed to suggest
                           ; prefix, or Polish, notation.

Python 2, Python 3, ???

a={1,2}
print(1+#a
--bool(1/2)
)

Stampa 1 in Python 2, 2 in Python 3 e 3 in ???.

Spiegazione del crack (Post crackato) :

#define print(A) main(){puts("0");}
print(1+bool(1/2))

• 0: C: La prima riga definisce una macro simile a una funzione printche ignora il suo singolo argomento e lo valuta main(){puts("0");}, un programma completo che stampa 0ed esce. L'intera espressione 1+bool(1/2)viene ignorata quando print( )viene espansa la macro sulla seconda riga main(){puts("0");}.

• 1: Python 2: la prima riga è un commento. 1/2usa la divisione intera in Python 2, dando 0. Questo valore viene quindi interpretato come un valore booleano ( bool(0)-> False) e quindi aggiunto a 1( 1+False-> 1), quindi stampato.

• 2: Python 3: la prima riga è un commento. 1/2usa la divisione float in Python 3, dando 0,5. Questo valore viene quindi interpretato come un valore booleano ( bool(0.5)-> True), quindi aggiunto a 1( 1+True-> 2) e quindi stampato.

JavaScript , CHIP-8 e ???

[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345

12in JavaScript , 13in CHIP-8 e 14in ???

Ho intenzione di uscire su un arto e chiamarlo incrinato, anche se non riesco proprio a farlo funzionare, sono sicuro della lingua (che sembra essere ciò che le regole chiedono).

Ecco una spiegazione imperfetta del post rotto

Il codice in esadecimale "è" (potrei essere leggermente disattivato):

[ 0x5b, 0x20, 0x2f, 0x2f, 0x61, 0xD0, 0xA2, 0x2f, 0x5c, 
0x5c, 0x20, 0x5d, 0x5b, 0x20, 0x2f, 0x2f, 0xD0, 0xB5, 
0x22, 0x36, 0x0a, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 
0x6c, 0x65, 0x2e, 0x6c, 0x6f, 0x67, 0x28, 0x31, 
0x31, 0x31, 0x2d, 0x31, 0x31, 0x31, 0x2b, 0x31, 
0x32, 0x29, 0x5d, 0x0a, 0x2f, 0x2f, 0x21, 0x27, 
0x21, 0x2f, 0x2d, 0xb2, 0x36, 0x2d, 0xb2, 0x35, 0x32 ]

Puoi andare qui , fare clic su "Strumenti binari" e incollarlo nella casella array di byte. Fai clic su "Decompila".

Gli elementi chiave del codice sono: istruzioni per dire dove si trova il "numero", il spritecomando che stampa il numero, la quantità corretta di posta indesiderata qua e là e quanto segue:

: label-0
    0x2F
    0x21
    0x27
    0x21
    0x2F

Per vedere cosa rappresenta, puoi fare clic su "Sprite Editor" e incollare questi esadecimali nella casella sottostante. Vedrai la risposta:

Sono abbastanza sicuro che alla fine puoi mettere tutto ciò che ti piace e il risultato CHIP-8 non cambierà, quindi la nuova voce.

Sarei felice se qualcuno riuscisse a farlo funzionare pienamente, piuttosto che la "prova" della risposta che ho dato qui.

C, Python 2, ???

#define print(A) main(){puts("0");}
print(1+bool(1/2))

Questo stampa 0in C, 1in Python 2 e 2in ???.

Questo sarà estremamente facile da decifrare per le persone che conoscono Python, ma volevo un punto di partenza per altre risposte. Le risposte successive dovrebbero cercare di offuscare la terza lingua (non l'ho fatto).

Python 3, Lua, ???

a=1+2+3+3+4+5+6+7+8+9
b=1+1+1
f=3--(-1)
c=7+9+13+11+12+3--1
g=a+b+c+1+2+3+4+5
j=9+7+g+c+b+a+g+g+g+g+g+g+1+2+3+4+1+1
h=1+1+1+1+333+1+1+1+111+1+1+1+333+1+1+1+1+1.
print(f)

Stampa 2 in Python 3, 3 in Lua e 4 in ???.

Spiegazione per posta incrinata :

a={1,2}
print(1+#a
--bool(1/2)
)

• In Lua, - è un commento. In Python 2 e 3, - indica il doppio negativo in aritmetica.
• In Python 2 e 3, # è un commento. In Lua, # è l'operatore lunghezza.
• In Python 2, 1/2 è la divisione del piano, quindi viene valutata a zero. In Python 3 non è così. Poiché entrambe le versioni di Python valutano 0 su False, bool (1/2) restituisce False in Python 2 e True in Python 3. Se usato in aritmetica, False viene lanciato su 0 e True viene lanciato su 1.

> <>, Befunge-96 e ???

abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+17!
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+6.@

Questo stampa 5 in><> , 6 inBefunge-96 e7 in ???.

So che la soluzione prevista era Befunge-93, ma non ho resistito.

Spiegazione:

Befunge-96 segue lo stesso percorso di ><>, ma ignora le istruzioni sconosciute, finendo per aggiungerne uno al 5 e moltiplicandolo per 9 per ottenere 54, il codice ASCII per 6.

Commentatore , Beatnik , ???

// k... nak... naKaka pagpAbaGaBag
static answer: Option<&String> = None;
 
fn llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(s: &String){
  answer = Some(s);
}
 
fn pneumonoultramicroscopicsilicovolcanoconiosis(){
  println!("{}", answer.unwrap());
}
 
fn main(){
  let s = String::from("17");
  let t = "Hi! I am a cat. AOOOWRRRWWW! Me need Whiskas! Noow! Mee hungry hast bekommen. Feedme! sudo !!. Sad... six cable hostage wire cable diediediediee #               */";
  llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch(&s);
  pneumonoultramicroscopicsilicovolcanoconiosis();
}

Produce 15 in Commentatore , 16 in Beatnik e 17 nella speranza che si possa trovare una lingua.

Va bene, è tempo di indizio:

• Il nome della lingua si riferisce a un composto di due elementi, entrambi i quali compongono il tuo corpo, ma con percentuali selvaggiamente variabili (in che modo a seconda che tu sia un robot).
• Il linguaggio stesso è su TIO, ma l'implementazione no.
• Oh andiamo.

Brainfuck,> <> e ???

abcd={} -- a gaffe avoiding tactic in C++
abcd[false]=1+2+3+4+5+6+7+8+9+10+11+12+13+14
print(abcd[0>1+2+3 and 4+5+6<0-0]//35)
if 0>1 then a.next=';' end
                    >1+9*,@

Stampa 4in Brainfuck, 5in> <> e 6in ???

• In brainfuck, nulla cambia.
• In> <>, vreindirizza il flusso del programma verso il basso. L' nè N uscita umeric. ;termina l'esecuzione.

Klein (101), Z80Golf, ???

!!8@e6v+4>9 \
Almost everything you can find on the internet is true
~Albert Einstein
 ~HUMAN IMAGE MACROS

Stampa 8in Klein (101) , 9in Z80Golf e 10in ??? .

Beatnik , Rust , ???

fn avreg(){}
fn/*azxzzz avreg k zqyzzz ax quke    
>>P0 ++puts++puts[pov]
\@�{>*}++puts++puts++puts++puts++puts++puts++puts++puts%
*/main(){print!("17")}

Questo stampa 16 in Beatnik, 17 in Rust e 18 in ???.

Il � carattere sulla riga 4 dovrebbe essere sostituito con il carattere ASCII 18 (questo non è stato fatto nei collegamenti TIO poiché non è rilevante per nessuno dei due).

Spiegazione ( incrinata ):

Il linguaggio della risposta precedente era Rust: in particolare, Rust compilato con mrustc . mrustc è un compilatore sperimentale e poiché è principalmente destinato al bootstrap di una versione valida dirustc , ignora il controllo dei prestiti e il controllo della mutabilità, consentendo allo snippet di @ NieDzejkob di compilare senza errori.

Questo programma funzionerà con il normale compilatore Rust, quindi non è necessario installare mrustc per testarlo.

suggerimenti

Dal momento che questa risposta è andata più a lungo senza essere crackata, lascerò un suggerimento e continuerò a farlo regolarmente fino a quando non verrà risolta:

• Il linguaggio segreto è bidimensionale.
• Come ho detto nei commenti, la lingua non è su TIO.
• Il � personaggio è un'aringa rossa e ha ben poco significato. La maggior parte dei byte può essere sostituita al suo posto e il programma continuerà a funzionare.

Z80Golf , Somme , ???

!!8@e6v+4>9 \
1((111+111)/111)
00
~tz

Questo stampa 9 in Z80Golf , 10 in Somme e 11 in ??? .

Ringraziamo Bubbler per aver decifrato il precedente post come Somme, che prende la somma della colonna come da istruzioni. Le prime tre colonne valutano

A.;

Che spinge 10, lo stampa ed esce.

Somme , Trigger e ???

[,,E,D,,$,H,_,K,,$,,_,F,L]=!
[]+[]+!![]+[][111]
_=[111][F+L+E+E];[,J,,A,I,,B,C,S]=
[]+_;$=A+B+C+D+I+H+J+A+I+B+H
R=_[$](H+K+I+J+H+C+S+H+B+B+I)();G=($[$]+[])[14]
R[A+B+C+D+B+E+K][E+B+G](12);`
iP<`

Questo stampa 10in Somme , 11in Trigger e 12in ???.

Dato che le ultime due lingue sono facili da poliglotta, ho deciso di combinare quella lingua in.

Spiegazione (posta incrinata )

Trigger vede l'intero codice come una serie di token (la tokenizzazione è avida):

• Singolo byte (denota A )
• Due byte uguali seguiti da un byte diverso (indica AAB )
• Tre stessi byte (indicato AAA )
• Quattro stessi byte (indicato AAAA )

Nel codice sorgente

!!8@e6v+4>9 \
1((111+111)/111)
00
~tz

i token significativi sono ((1 11+ 111 111, in cui i primi due non fanno nulla e le ultime due stampe 1 ciascuno - quindi 11.

CHIP-8 , Klein (100) , ???

[ //aТ/\\ ][ //е"6
console.log(111-111+12)]
//!'!/-²6-²52@++++2345
 %/    <#> 13
       say 14
 + not not 15

Uscite 13 in CHIP-8 (presumo), 14 in Klein e 15 in ???.

Un altro topologia di Klein, tsk tsk. Ho conservato il codice prima del @, poiché non so cosa influenzerà CHIP-8.

indizi

Sono un po 'in ritardo per questi, scusa. Proverò ad aggiungerne uno al giorno.

• La rimozione della prima metà (prime tre righe) del programma funziona ancora.
• Questo non è un linguaggio 2D
• La lingua è su TIO
• Le nots e le saypossono essere rimosse senza influire sul programma

Per riferimento, il programma senza quella roba si presenta così:

 %/    <#> 13
        14
 +   15

Provalo online!

Klein (100), commentatore , ???

/@++++2345
start:
program:
 db 'function',10
 add program,program
 jp null+$8
 sbc rbp,rbp
 jnz program
 jr program
 add start
 halt
ex:

Produce 14 in Klein (100) , 15 in Commentatore , 16 in ???.

Sono seriamente cattivo a offuscare i poliglotti.

Spiegazione ( posta incrinata )

 %/    <#> 13
        14
 +   15

In Commentator, i token e gli spazi dei commenti comuni sono i comandi importanti e tutti gli altri caratteri vengono ignorati.

• Lo spazio incrementa la cella di memoria corrente.
• <# fa XOR 1 sulla cella di memoria corrente.
• % viene utilizzato per ripristinare la cella di memoria corrente a zero.

Aspetta, ci sono 16 spazi dopo % , cosa è successo?

In realtà è un piccolo bug (o funzione?) Nell'interprete. /viene considerato come l'inizio di un comando a 2 caratteri, quindi lo spazio dopo viene consumato. Ma /<space>è un comando indefinito (quindi un no-op), quindi lo spazio viene effettivamente ignorato.