Ao contrário de muitos desafios de C&R, isso não requer um posto de ladrão separado; o objetivo dos ladrões é decifrar a resposta anterior e postar uma nova como policial.

Como respondentes, você escreverá uma série de poliglotas que se parecem com isso (cada coluna é um idioma e cada entrada é a saída da resposta nesse idioma):

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

(espaços em branco significam que nenhum comportamento é necessário nesse caso).

Cada resposta deve funcionar em 3 idiomas e imprimir 3 diferentes números consecutivos que são cada um mais do que os números impressos pela resposta anterior (a primeira resposta impressões 0, 1e 2). Cada resposta usa dois idiomas do envio anterior e um terceiro novo idioma. O atendedor deve tentar ofuscar qual é esse terceiro idioma.

Para postar uma nova resposta, você deve:

• Quebre a resposta mais recente descobrindo qual é a terceira língua.
• De preferência, adicione uma explicação para o seu crack e notifique o pôster da resposta. Depois que seu envio for quebrado, você também deverá adicionar uma explicação.
• Escreva um poliglota composto pelos segundo e terceiro idiomas desta resposta, juntamente com outro idioma de sua escolha. Revele seus dois primeiros idiomas, mas não revele o seu novo. Será o objetivo do próximo pôster encontrar esse idioma (ou qualquer outro idioma em que ele funcione), portanto, você deve tentar ofuscá-lo.

Especificações

• Os critérios para uma linguagem de programação válida são os mesmos do The Programming Language Quiz, Mark II - Cops :

  • Tem um artigo da Wikipedia em inglês , um artigo da esolangs ou um artigo do Rosetta Code no momento em que este desafio foi publicado ou está no Try It Online! . Ter um intérprete vinculado em qualquer uma dessas páginas torna esse intérprete completamente legal.
  • Ele deve satisfazer nossas regras sobre o que constitui uma linguagem de programação .
  • Ele deve ter um intérprete gratuito (como na cerveja). Grátis aqui significa que qualquer pessoa pode usar o programa sem ter que pagar para fazê-lo.

• Cada resposta deve ser executada em menos de um minuto em um PC razoável.

• Vocês pode reutilizar linguagens de programação, mas deve haver pelo menos duas respostas entre elas (para que uma resposta individual não possa reutilizar uma linguagem).
• Quebrar uma submissão consiste em encontrar qualquer linguagem de programação que imprima o resultado correto, não apenas o pretendido. Se um envio for executado em qualquer idioma que não foi declarado ou encontrado para funcionar, não há requisitos para fazer nada.
• Você não pode postar duas vezes (ou mais) seguidas.

Critério vencedor

A resposta vencedora é aquela que levou mais tempo para ser quebrada. O desafio nunca termina, por isso é sempre possível que a resposta vencedora mude.

Hexagonia, Klein (101) e ???

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

main\

>9.*5,6v

Isso é impresso 7em hexagonia , 8em Klein (101) e 9em ???.

O 9não funciona se uma nova linha for adicionada no final do código. Tenha cuidado se estiver testando localmente.

Editar: Estar vivo por 20 horas já é um recorde, então darei algumas dicas a partir de agora. (Também porque o idioma em questão ainda não é conhecido pela IMO.)

Dicas

1. "O 9não funciona se uma nova linha for adicionada no final" é muito significativa, assim como os dois primeiros espaços (que são ignorados pelo Hexagony e Klein).
2. O idioma está no TIO.
3. Os dois primeiros espaços fazem o programa pular para a última linha. (É não uma linguagem 2D).
4. Não há comando de saída explícito, e o vcomando finaliza o programa.

Explicação ( post rachado )

No código fonte

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

As instruções relevantes em Klein (101) são:

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

Klein é uma linguagem 2D do tipo fungel, onde cruzar o limite da área de código (que é um quadrado) depende da topologia de Klein. /e\ são espelhos.

O IP começa no canto superior esquerdo, voltado para a direita. Encontra um espelho em direção ao limite superior e entra novamente na área de código no lado direito, como mostrado acima. Então ele bate no espelho novamente, 8 é pressionado e depois (depois de passar pelo limite várias vezes) para @. Em seguida, o conteúdo da pilha é impresso no stdout, que é único 8.

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

Imprime 6em Befunge-96 , 7em hexagonia e 8em ???.

Explicação

O código hexagônico, quando "prettified" é:

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

O caminho da execução começa no canto superior esquerdo, na direção leste. A linha superior não faz muito. -altera a borda da memória atual para que o valor esteja 0. A execução continua indo para o leste na linha do meio, onde as 7!cargas 7na borda da memória atual e as impressões são como um número inteiro. [altera o ponteiro de instruções para Nordeste a partir de 7. Depois 7+3, a execução atinge o [que muda o ponteiro de instrução para Noroeste, começando no canto Sudeste. Finalmente, o caminho é ..@onde@ termina o programa.

Lua, foda-se, ???

abcd = {} - uma gafe evitando tática em C ++
abcd [false] = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14
print (abcd [0> 1 + 2 + 3 e 4 + 5 + 6 <0-0] // 35)
se 0> 1 então a.next = ';' fim

Imprime 3 em Lua, 4 em brainfuck e 5 em ???.

Explicação para postagem rachada :

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.
impressão (f)

• No Python 3, 3--(-1)é 2, então print(f)imprime 2 (o restante é desnecessário)
• Em Lua, --novamente é um comentário, 3--(-1)apenas 3, então print(f)imprime 3 (outras coisas são novamente desnecessárias)
• No cérebro, existem 57 pontos positivos e 5 negativos configurando a primeira célula da fita para 52 e o .caractere de saída 52, que é 4.

Gatilho , JavaScript e ???

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

Imprime 11no gatilho , 12no JavaScript e 13noREDACTED .

Como isso não foi quebrado por mais tempo do que qualquer outra resposta até agora, aqui estão algumas dicas:

• Caso você não tenha notado, os caracteres Тe еna primeira linha são caracteres multibyte.
• [ //e \\ ][ //não são ops.
• A segunda linha, assim como -²52, é um código morto.
• A linguagem não tem um conceito de terminação, portanto ²6forma um loop infinito.
• Para ser específico, o segundo byte da codificação UTF-8 ², juntamente com o 6, forma um loop infinito.
• O número que está sendo emitido é codificado pelo /!'!/
• O idioma não está no Try It Online, no Código Rosetta ou no Esolangs.
• A única forma de saída disponível é uma tela de 1bpp.
• A proporção da tela é 2.
• Embora o idioma não tenha sido originalmente concebido como código de máquina, existem implementações de FPGA.
• Segundo a Wikipedia, o objetivo pretendido do idioma eram os videogames.
• A única maneira de acessar a tela é uma instrução especial, que recebe coordenadas em registros selecionáveis ​​e a altura como imediata, e XOR coloca um bitmap de 8 por n na tela. Para facilitar a detecção de colisão e para limpar a tela, um dos registros será definido quando qualquer pixel for desativado.

Explicação

Bem, isso levou algum tempo para ser quebrado. Vamos ver como o código fica:

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.

Isso significa que, enquanto muitos emuladores disponíveis se comportam corretamente, a implementação das regras está vinculada à segunda frase da página da Wikipedia . Obviamente, ele não pode ser executado diretamente em um PC comum, mas eu achei o emulador Emma 02 vinculado à página VIP do COSMAC para funcionar da melhor maneira.

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

Isso imprime 1 no Python 2, 2 no Python 3 e 3 em ???

Explicação do crack (Post crackeado) :

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

• 0: C: A primeira linha define uma macro semelhante à função printque ignora seu argumento único e avalia como main(){puts("0");}, um programa completo que imprime 0e sai. A expressão inteira 1+bool(1/2)é ignorada quando a print( )macro na segunda linha é expandida para main(){puts("0");}.

• 1: Python 2: A primeira linha é um comentário. 1/2usa divisão inteira no Python 2, fornecendo 0. Esse valor é interpretado como um booleano ( bool(0)-> False) e, em seguida, adicionado a 1( 1+False-> 1) e, em seguida, impresso.

• 2: Python 3: A primeira linha é um comentário. 1/2usa a divisão float no Python 3, fornecendo 0,5. Esse valor é então interpretado como um booleano ( bool(0.5)-> True) e, em seguida, adicionado ao1 ( 1+True-> 2) e, em seguida, impresso.

JavaScript , CHIP-8 e ???

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

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

Vou sair do ramo e chamar isso de rachado, embora não consiga fazê-lo funcionar. Tenho certeza do idioma (que parece ser o que as regras pedem).

Aqui está uma explicação imperfeita do post rachado

O código em hexadecimal "é" (talvez eu esteja um pouco desligado):

[ 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 ]

Você pode ir aqui , clicar em "Ferramentas binárias" e colá-lo na caixa de matriz de bytes. Clique em "Descompilar".

Os principais elementos do código são: instruções para dizer onde está o "número", o sprite comando que imprime o número, a quantidade correta de lixo eletrônico aqui e ali e o seguinte:

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

Para ver o que isso representa, clique em "Editor de Sprite" e cole esses hexadecimais na caixa abaixo. Você verá a resposta:

Tenho certeza que você pode colocar o que quiser no final e o resultado do CHIP-8 não será alterado, daí a nova entrada.

Eu ficaria encantado se alguém pudesse fazer isso funcionar plenamente, em vez da "prova" da resposta que eu dei aqui.

C, Python 2, ???

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

Isso é impresso 0em C, 1em Python 2 e 2em ???.

Isso será extremamente fácil de entender para quem conhece Python, mas eu queria um ponto de partida para outras respostas. As respostas subsequentes devem tentar ofuscar o terceiro idioma (eu não fiz isso).

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)

Imprime 2 em Python 3, 3 em Lua e 4 em ???.

Explicação para postagem rachada :

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

• Em Lua, - é um comentário. Nos Python 2 e 3, - indica duplo negativo na aritmética.
• Nos Python 2 e 3, # é um comentário. Em Lua, # é o operador de comprimento.
• No Python 2, 1/2 é a divisão do piso e, portanto, é avaliada como zero. No Python 3, esse não é o caso. Como as duas versões do Python avaliam 0 como False, o bool (1/2) avalia como False no Python 2 e True no Python 3. Quando usado na aritmética, False é convertido em 0 e True é convertido em 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.@

Imprime 5 pol><> , 6 polBefunge-96 e 7pol ???.

Eu sei que a solução pretendida era o Befunge-93, mas não pude resistir.

Explicação:

O Befunge-96 segue o mesmo caminho que ><>, mas ignora instruções desconhecidas, acabando adicionando um ao 5 e multiplicando por 9 para obter 54, o código ascii para 6.

Comentador , 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();
}

Resultados 15 no Commentator , 16 no Beatnik e 17 no esperançosamente um idioma que você deve encontrar.

Ok, é hora da pista:

• O nome do idioma refere-se a um composto de dois elementos, que compõem o seu corpo, mas com porcentagens muito variadas (dependendo da forma como você é um robô).
• A linguagem em si está no TIO, mas a implementação não está.
• Oh vamos lá.

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*,@

Imprime 4em Brainfuck, 5em> <> e 6em ???

• No cérebro, nada muda.
• Em> <>, vredireciona o fluxo do programa para baixo. A né n para saída umeric. ;termina a execução.

Klein (101), Z80Golf, ???

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

Imprime 8em Klein (101) , 9em Z80Golf e 10em ??? .

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

Imprime 16 em Beatnik, 17 em Rust e 18 em ???.

O �caractere na linha 4 deve ser substituído pelo caractere ASCII 18 (isso não foi feito nos links do TIO, pois não é relevante para nenhum deles).

Explicação ( rachada ):

A linguagem da resposta anterior era Rust: especificamente, Rust compilado com mrustc . O mrustc é um compilador experimental e, como se destina principalmente à inicialização de uma versão válida dorustc , ignora a verificação de empréstimos e a verificação de mutabilidade, permitindo que o snippet de @ NieDzejkob seja compilado sem erros.

Este programa funcionará com o compilador Rust normal, portanto você não precisa instalar o mrustc para testá-lo.

Dicas

Como essa resposta agora foi mais longa sem ser quebrada, deixarei uma dica e continuarei a fazê-lo regularmente até que seja quebrada:

• A linguagem secreta é bidimensional.
• Como mencionei nos comentários, o idioma não está no TIO.
• O �personagem é um arenque vermelho e tem muito pouco significado. A maioria dos bytes pode ser substituída em seu lugar e o programa ainda funcionará.

Z80Golf , Somme , ???

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

Imprime 9 em Z80Golf , 10 em Somme e 11 em ???.

Agradecemos a Bubbler por quebrar a postagem anterior como Somme, que usa a soma da coluna conforme as instruções. As três primeiras colunas avaliam como

A.;

Que empurra 10, imprime e sai.

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

Imprime 10em Somme , 11em Trigger e 12em ???.

Como os dois últimos idiomas são fáceis de poliglota, decidi misturar esse idioma .

Explicação ( postagem rachada )

O gatilho vê o código inteiro como uma série de tokens (a tokenização é gananciosa):

• Byte único (denotar A)
• Dois mesmos bytes seguidos por um byte diferente (denote AAB)
• Três mesmos bytes (indicados AAA)
• Quatro mesmos bytes (indicados AAAA)

No código fonte

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

os tokens significativos são ((1 11+ 111 111, onde os dois primeiros não fazem nada e os dois últimos imprimem 1 cada - portanto, 11.

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

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

Saídas 13 em CHIP-8 (presumo), 14 em Klein e 15 em ???.

Outra topologia Klein, tsk tsk. Eu preservei o código antes do @, pois não sei o que afetará o CHIP-8.

Pistas

Estou meio atrasado por isso, desculpe. Vou tentar adicionar um por dia.

• A remoção da primeira metade (três primeiras linhas) do programa ainda funciona.
• Esta não é uma linguagem 2D
• O idioma está no TIO
• A notS e o saypode ser removido sem afectar o programa

Para referência, o programa sem essas coisas é assim:

 %/    <#> 13
        14
 +   15

Experimente online!

Klein (100), comentarista , ???

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

Saídas 14 em Klein (100) , 15 em Comentador , 16 em ???.

Sou muito ruim em ofuscar poliglotas.

Explicação ( postagem rachada )

 %/    <#> 13
        14
 +   15

No Commentator, tokens e espaços comuns de comentários são os comandos importantes e outros caracteres são ignorados.

• O espaço incrementa a célula de memória atual.
• <# faz XOR 1 na célula de memória atual.
• % é usado para redefinir a célula de memória atual para zero.

Espere, há 16 espaços depois %, o que aconteceu?

Na verdade, é um pequeno bug (ou recurso?) No intérprete. /é tratado como o início de um comando 2-char, portanto, o espaço após ser consumido. Mas /<space>é um comando indefinido (portanto, não operacional), para que o espaço seja efetivamente ignorado.