A diferencia de muchos desafíos de C&R, esto no requiere una publicación de ladrones por separado; El objetivo de los ladrones es descifrar la respuesta anterior y luego publicar una nueva como policía.

Como respondedores, escribirás una serie de políglotas que se verán así (cada columna es un idioma y cada entrada es la salida de la respuesta en ese 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
...

(los espacios en blanco significan que no se requiere comportamiento en ese caso).

Cada respuesta debe trabajar en 3 idiomas e imprimir 3 números consecutivos diferentes que son cada uno más de los números impresos por la respuesta anterior (impresa la primera respuesta 0, 1y 2). Cada respuesta utiliza dos idiomas de la presentación anterior y un tercer idioma nuevo. El respondedor debe tratar de ofuscar lo que es este tercer idioma.

Para publicar una nueva respuesta, debes:

• Encuentra la respuesta más reciente al encontrar cuál es su tercer idioma.
• Preferiblemente, agregue una explicación para su crack y notifique al afiche la respuesta. Una vez que se haya descifrado su envío, también debe agregar una explicación.
• Escriba un políglota que consista en el segundo y tercer idioma de esta respuesta, junto con otro idioma de su elección. Revela tus dos primeros idiomas, pero no reveles el nuevo. El objetivo del próximo póster será encontrar este idioma (o cualquier otro idioma en el que funcione), por lo que debe intentar ofuscarlo.

Presupuesto

• Los criterios para un lenguaje de programación válido son los mismos que los de The Programming Language Quiz, Mark II - Cops :

  • Tiene un artículo de Wikipedia en inglés , un artículo de esolangs o un artículo de Rosetta Code en el momento en que se publicó este desafío, o está en ¡ Pruébelo en línea! . Tener un intérprete vinculado en cualquiera de estas páginas hace que ese intérprete sea completamente legal.
  • Debe satisfacer nuestras reglas sobre lo que constituye un lenguaje de programación .
  • Debe tener un intérprete gratuito (como en cerveza). Gratis aquí significa que cualquiera puede usar el programa sin tener que pagar para hacerlo.

• Cada respuesta debe ejecutarse en menos de un minuto en una PC razonable.

• Usted puede volver a utilizar lenguajes de programación, pero debe haber al menos dos respuestas en el medio (por lo que una respuesta individual no puede volver a utilizar un lenguaje).
• Romper una presentación consiste en encontrar cualquier lenguaje de programación que imprima el resultado correcto, no solo el deseado. Si se ejecuta un envío en cualquier idioma que no se haya declarado o encontrado que funciona, no hay requisitos para hacer nada.
• No puede publicar dos veces (o más) seguidas.

Criterio ganador

La respuesta ganadora es la que tomó más tiempo en descifrar. El desafío nunca terminará, por lo que siempre es posible que la respuesta ganadora cambie.

Hexagony, Klein (101) y ???

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

main\

>9.*5,6v

Esto se imprime 7en Hexagony , 8en Klein (101) y 9en ???.

El 9no funciona si se añade una nueva línea al final del código. Ten cuidado si estás probando localmente.

Editar: Estar en vivo durante 20 horas ya es un récord, por lo que daré algunas pistas a partir de ahora. (También porque el idioma en cuestión es IMO aún no es muy conocido).

Consejos

1. " 9No funciona si se agrega una nueva línea al final" es muy significativo, así como los dos primeros espacios (que Hexagony y Klein ignoran).
2. El idioma está en TIO.
3. Los primeros dos espacios hacen que el programa salte a la última línea. (Es no un lenguaje 2D).
4. No hay un comando de salida explícito, y el vcomando finaliza el programa.

Explicación ( publicación agrietada )

En el código fuente

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

Las instrucciones relevantes en Klein (101) son:

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

Klein es un lenguaje 2D fungelike donde cruzar el límite del área de código (que es un cuadrado) depende de la topología de Klein. /Y \son espejos.

La IP comienza en la esquina superior izquierda hacia la derecha. Se encuentra con un espejo hacia el límite superior y vuelve a entrar en el área del código en el lado derecho como se muestra arriba. Luego golpea el espejo nuevamente, se presiona 8 y luego (después de pasar por el límite varias veces) se detiene en @. Luego, el contenido de la pila se imprime en stdout, que es solo 8.

Befunge-96, Hexagony and ???

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

Esto se imprime 6en Befunge-96 , 7en hexagonía y 8en ???.

Explicación

El código de hexagonía, cuando está "prettificado" es:

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

El camino de ejecución comienza en la esquina superior izquierda en dirección Este. La fila superior no hace mucho. -cambia el borde de memoria actual para que el valor en él sea 0. La ejecución continúa hacia el este en la fila central, donde las 7!cargas 7en el borde de la memoria actual y las impresiones son como un número entero. [cambia el puntero de instrucciones a North East a partir de 7. Después 7+3, la ejecución alcanza [y cambia el puntero de instrucción a Noroeste comenzando en la esquina sureste. Finalmente la ruta es ..@donde @termina el programa.

Lua, cerebro, ???

abcd = {} - una táctica para evitar errores en C ++
abcd [falso] = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14
print (abcd [0> 1 + 2 + 3 y 4 + 5 + 6 <0-0] // 35)
si 0> 1 entonces a.next = ';' fin

Imprime 3 en Lua, 4 en brainfuck y 5 en ???.

Explicación de la publicación agrietada :

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.
imprimir (f)

• En Python 3, 3--(-1)es 2, por lo que print(f)imprime 2 (las otras cosas son innecesarias)
• En Lua, --nuevamente hay un comentario, por lo que 3--(-1)es solo 3, por lo que print(f)imprime 3 (otras cosas son innecesarias)
• En brainfuck, hay 57 más y 5 menos que configuran la primera celda de la cinta en 52, y el .carácter de salida 52, que es 4.

Gatillo , JavaScript y ???

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

Huellas dactilares 11 en Trigger , 12en JavaScript y 13en REDACTED.

Dado que esto no se ha descifrado por más tiempo que cualquier otra respuesta hasta ahora, aquí hay algunos consejos:

• En caso de que no lo haya notado, el Тy еen la primera línea son caracteres multibyte.
• [ //y \\ ][ //son no-ops.
• La segunda línea, así como -²52, es código muerto.
• El lenguaje no tiene un concepto de terminación, por lo que ²6forma un bucle infinito.
• Para ser específicos, el segundo byte de la codificación UTF-8 de ², junto con 6, forma un bucle infinito.
• El número que se emite está codificado por el /!'!/
• El idioma no está en Try It Online, Rosetta Code o Esolangs.
• La única forma de salida disponible es una pantalla de 1 bpp.
• La relación de aspecto de la pantalla es 2.
• Si bien el lenguaje no fue pensado originalmente como código de máquina, existen implementaciones de FPGA.
• Según Wikipedia, el propósito del lenguaje eran los videojuegos.
• La única forma de acceder a la pantalla es una instrucción especial, que toma coordenadas en registros seleccionables, y la altura como inmediata, y XOR un mapa de bits de 8 por n en la pantalla. Para facilitar la detección de colisiones, así como para limpiar la pantalla, uno de los registros se establecerá cuando cualquier píxel se vuelva a desactivar.

Explicación

Bueno, esto tomó algún tiempo para quebrarse. Veamos cómo se ve el código:

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.

Esto significa que, si bien muchos emuladores disponibles se comportan correctamente, la implementación de las reglas está vinculada a la segunda oración de la página de Wikipedia . Por supuesto, no se puede ejecutar directamente en una PC promedio, pero he encontrado que el emulador Emma 02 vinculado en la página VIP de COSMAC funciona mejor.

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

Esto imprime 1 en Python 2, 2 en Python 3 y 3 en ???.

Explicación de la grieta (publicación agrietada) :

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

• 0: C: La primera línea define una macro similar a una función printque ignora su argumento único y se evalúa como main(){puts("0");}un programa completo que imprime 0y sale. Toda la expresión 1+bool(1/2)se ignora cuando la print( )macro en la segunda línea se expande a main(){puts("0");}.

• 1: Python 2: la primera línea es un comentario. 1/2usa la división de enteros en Python 2, dando 0. Este valor se interpreta como un booleano ( bool(0)-> False) y luego se agrega a 1( 1+False-> 1), y luego se imprime.

• 2: Python 3: la primera línea es un comentario. 1/2usa la división flotante en Python 3, dando 0.5. Este valor se interpreta como un booleano ( bool(0.5)-> True) y luego se agrega a 1( 1+True-> 2), y luego se imprime.

JavaScript , CHIP-8 y ???

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

12en JavaScript , 13en CHIP-8 y 14en ???

Voy a arriesgarme y llamarlo agrietado, aunque no puedo hacer que funcione, estoy seguro del idioma (que parece ser lo que piden las reglas).

Aquí hay una explicación imperfecta de la publicación agrietada

El código en hexadecimal "es" (podría estar un poco apagado):

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

Se puede ir aquí , hacer clic en "Herramientas binarias" y pegar esto en el cuadro de matriz de bytes. Haga clic en "Descompilar".

Los elementos clave del código son: instrucciones para decir dónde está el "número", el sprite comando que imprime el número, la cantidad correcta de basura aquí y allá, y lo siguiente:

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

Para ver lo que esto representa, puede hacer clic en "Editor de Sprite" y pegar estos hexadecimales en el cuadro debajo. Verás la respuesta:

Estoy bastante seguro de que puede poner lo que quiera al final y el resultado de CHIP-8 no cambiará, de ahí la nueva entrada.

Me encantaría que alguien pudiera hacer que esto funcione por completo, en lugar de la "prueba" de la respuesta que he dado aquí.

C, Python 2, ???

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

Esto se imprime 0en C, 1en Python 2 y2 en ???.

Esto será extremadamente fácil de descifrar para las personas que conocen Python, pero quería un punto de partida para otras respuestas. Las respuestas posteriores deberían tratar de ofuscar el tercer idioma (no hice esto).

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 en Python 3, 3 en Lua y 4 en ???.

Explicación de la publicación agrietada :

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

• En Lua, - es un comentario. En Python 2 y 3, - indica doble negativo en aritmética.
• En Python 2 y 3, # es un comentario. En Lua, # es el operador de longitud.
• En Python 2, 1/2 es la división del piso, por lo que se evalúa a cero. En Python 3 este no es el caso. Debido a que ambas versiones de Python evalúan 0 a False, bool (1/2) se evalúa a False en Python 2 y True en Python 3. Cuando se usa en aritmética, False se convierte a 0 y True se convierte a 1.

> <>, Befunge-96 y ???

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><> pulgadas , 6 pulgadasBefunge-96 y7 in ???.

Sé que la solución prevista era Befunge-93, pero no pude resistirme.

Explicación:

Befunge-96 sigue el mismo camino que ><>, pero ignora las instrucciones desconocidas, termina agregando uno al 5 y multiplicándolo por 9 para obtener 54, el código ascii para 6.

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

Salidas 15 en comentarista , 16 en Beatnik y 17 en el único idioma que se supone que debes encontrar.

Bien, es hora de pistas:

• El nombre del lenguaje se refiere a un compuesto de dos elementos, los cuales componen su cuerpo, pero con porcentajes muy variables (dependiendo de si es un robot).
• El lenguaje en sí está en TIO, pero la implementación no.
• Oh vamos.

Brainfuck,> <> y ???

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 4en Brainfuck, 5en> <> y 6en ???

• En brainfuck, nada cambia.
• En> <>, vredirige el flujo del programa hacia abajo. El nse N salida Umeric. ;finaliza la ejecución

Klein (101), Z80Golf, ???

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

Imprime 8en Klein (101) , 9en Z80Golf y 10en ??? .

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

Esto imprime 16 en Beatnik, 17 en Rust y 18 en ???.

El �carácter en la línea 4 debe reemplazarse con el carácter ASCII 18 (esto no se hizo en los enlaces TIO ya que no es relevante para ninguno de ellos).

Explicación ( agrietada ):

El lenguaje de la respuesta anterior era Rust: específicamente, Rust compilado con mrustc . mrustc es un compilador experimental, y como está destinado principalmente a arrancar una versión válida derustc , ignora la verificación de préstamos y la verificación de mutabilidad, permitiendo que el fragmento de @ NieDzejkob se compile sin errores.

Este programa funcionará con el compilador Rust normal, por lo que no necesita instalar mrustc para probarlo.

Consejos

Dado que esta respuesta ha sido la más larga sin agrietarse, dejaré una pista y continuaré haciéndolo regularmente hasta que se agriete:

• El lenguaje secreto es bidimensional.
• Como mencioné en los comentarios, el idioma no está en TIO.
• El �personaje es un arenque rojo y tiene muy poca importancia. La mayoría de los bytes se pueden sustituir en su lugar y el programa seguirá funcionando.

Z80Golf , Somme , ???

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

Esto imprime 9 en Z80Golf , 10 en Somme y 11 en ???.

Gracias a Bubbler por descifrar la publicación anterior como Somme, que toma la suma de la columna como las instrucciones. Las primeras tres columnas evalúan

A.;

Que empuja 10, lo imprime y sale.

Somme, Trigger and ???

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

This prints 10 in Somme, 11 in Trigger, and 12 in ???.

Since the last two languages are easy to polyglot, I decided to mix that language in.

Explanation (cracked post)

Trigger sees the whole code as a series of tokens (tokenization is greedy):

• Single byte (denote A)
• Two same bytes followed by a different byte (denote AAB)
• Three same bytes (denoted AAA)
• Four same bytes (denoted AAAA)

In the source code

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

the significant tokens are ((1 11+ 111 111, where the first two does nothing and the last two prints 1 each - thus 11.

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

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

Outputs 13 in CHIP-8 (I assume), 14 in Klein, and 15 in ???.

Another Klein topology, tsk tsk. I've preserved the code before the @, since I don't know what will affect CHIP-8.

Clues

I'm kinda overdue for these, sorry. I'll try and add one a day.

• Removing the first half (first three lines) of the program still works.
• This is not a 2D language
• The language is on TIO
• The nots and the say can be removed without affecting the program

For reference, the program without that stuff looks like this:

 %/    <#> 13
        14
 +   15

Try it online!

Klein (100), Commentator, ???

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

Outputs 14 in Klein (100), 15 in Commentator, 16 in ???.

I'm seriously bad at obfuscating polyglots.

Explanation (Cracked post)

 %/    <#> 13
        14
 +   15

In Commentator, common comment tokens and spaces are the important commands, and any other characters are ignored.

• Space increments the current memory cell.
• <# does XOR 1 on the current memory cell.
• % is used to reset the current memory cell to zero.

Wait, there are 16 spaces after %, what happened?

It's actually a small bug (or feature?) in the interpreter. / is treated as the start of a 2-char command, so the space after it is consumed. But /<space> is undefined command (thus a no-op), so the space is effectively skipped.