Contrairement à de nombreux défis C & R, cela ne nécessite pas un poste séparé pour les voleurs; le but des voleurs est de déchiffrer la réponse précédente, puis d’en poster une nouvelle en tant que policier.

En tant que répondeurs, vous allez écrire une série de polyglottes ressemblant à ceci (chaque colonne est une langue et chaque entrée est la sortie de la réponse dans cette langue):

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

(Les espaces vides signifient qu'aucun comportement n'est requis dans ce cas).

Chaque réponse doit travailler en 3 langues et imprimer 3 différents numéros consécutifs qui sont chacun plus que les chiffres imprimés par la réponse précédente (les premières impressions de réponse 0, 1et 2). Chaque réponse utilise deux langues de la soumission précédente et une troisième nouvelle langue. Le répondant devrait essayer de dissimuler ce qu'est cette troisième langue.

Pour poster une nouvelle réponse, vous devez:

• Casser la réponse la plus récente en trouvant quelle est sa troisième langue.
• De préférence, ajoutez une explication à votre fissure et informez l'affiche de la réponse. Une fois votre soumission fissurée, vous devez également ajouter une explication.
• Ecrivez un polyglotte composé des deuxième et troisième langues de cette réponse, ainsi que d'une autre langue de votre choix. Révélez vos deux premières langues, mais ne révélez pas la nouvelle. La prochaine affiche ayant pour objectif de trouver cette langue (ou toute autre langue dans laquelle elle fonctionne), vous devez donc essayer de la dissimuler.

Caractéristiques

• Les critères de validité d'un langage de programmation sont les mêmes que ceux de The Programming Language Quiz, Mark II - Cops :

  • Il contient un article sur Wikipedia anglais , un article sur esolangs ou un article sur Rosetta Code au moment de la publication du défi ou est sur Essayez-le en ligne! . Avoir un interprète lié dans l'une de ces pages le rend tout à fait légal.
  • Il doit satisfaire nos règles sur ce qui constitue un langage de programmation .
  • Il doit y avoir un interprète gratuit (comme dans la bière). Gratuit ici signifie que tout le monde peut utiliser le programme sans avoir à payer pour le faire.

• Chaque réponse doit être exécutée en moins d’une minute sur un PC raisonnable.

• Vous pouvez réutiliser des langages de programmation, mais il doit y avoir au moins deux réponses (une réponse individuelle ne peut donc pas réutiliser un langage).
• Cracker une soumission consiste à rechercher tout langage de programmation imprimant le résultat correct, et pas seulement celui souhaité. Si une soumission est exécutée dans une langue qui n'a pas été déclarée ou qui n'a pas fonctionné, il n'y a aucune obligation de faire quoi que ce soit.
• Vous ne pouvez pas poster deux (ou plus) de suite.

Critère gagnant

La réponse gagnante est celle qui a pris le plus de temps pour être fissurée. Le défi ne finira jamais, il est donc toujours possible que la réponse gagnante change.

Hexagony, Klein (101) et ???

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

main\

>9.*5,6v

Ceci est imprimé 7en hexagone , 8en Klein (101) et 9en ???.

Le 9ne fonctionne pas si une nouvelle ligne est ajoutée à la fin du code. Faites attention si vous testez localement.

Edit: Être en direct pendant 20 heures est déjà un disque, je vais donc vous donner quelques indices à partir de maintenant. (Également parce que la langue en question est l’OMI pas encore connue.)

Astuces

1. " 9Cela ne fonctionne pas si une nouvelle ligne est ajoutée à la fin" est très important, de même que les deux premiers espaces (ignorés par Hexagony et Klein).
2. La langue est sur TIO.
3. Les deux premiers espaces font que le programme passe à la dernière ligne. (Ce n'est pas un langage 2D.)
4. Il n'y a pas de commande de sortie explicite, et la vcommande termine le programme.

Explication ( poteau fissuré )

Dans le code source

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

Les instructions pertinentes dans Klein (101) sont les suivantes:

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

Klein est un langage 2D similaire à celui de gabarit où le franchissement de la limite de la zone de code (qui est un carré) dépend de la topologie de Klein. /et \sont des miroirs.

L'adresse IP commence dans le coin supérieur gauche en direction de droite. Il rencontre un miroir vers la limite supérieure et entre à nouveau dans la zone de code du côté droit, comme indiqué ci-dessus. Ensuite, il frappe à nouveau le miroir, 8 est poussé, puis (après avoir traversé la limite plusieurs fois) s'arrête à @. Ensuite, le contenu de la pile est imprimé sur la sortie standard, qui est unique 8.

Befunge-96, Hexagony et ???

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

Cela imprime 6en Befunge-96 , 7en hexagone et 8en ???.

Explication

Le code hexagone, quand "prettified" est:

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

Le chemin d'exécution commence en haut à gauche en direction est. La rangée du haut ne fait pas grand chose. -change le bord actuel de la mémoire pour que sa valeur soit 0. L'exécution se poursuit vers l'est sur la rangée du milieu, où elle se 7!charge 7dans le bord de la mémoire en cours et s'imprime sous la forme d'un entier. [change le pointeur d’instruction sur Nord-Est à partir de 7. Ensuite 7+3, l'exécution atteint [ce qui change le pointeur d'instruction en direction du nord-ouest à partir du coin sud-est. Enfin, le chemin est l' ..@endroit où se @termine le programme.

Lua, brainfuck, ???

abcd = {} - une tactique gaffe en C ++
abcd [false] = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 14
print (abcd [0> 1 + 2 + 3 et 4 + 5 + 6 <0-0] // 35)
si 0> 1 alors a.next = ';' fin

Imprime 3 à Lua, 4 à la merde et 5 à ???.

Explication pour poste fissuré :

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 + 1.
imprimer (f)

• En Python 3, 3--(-1)vaut 2, donc print(f)affiche 2 (les autres éléments ne sont pas nécessaires)
• En Lua, à --nouveau il y a un commentaire, donc il 3--(-1)n'y en a que 3, donc on en print(f)imprime 3
• Dans brainfuck, il y a 57 points positifs et 5 points négatifs, définissant la première cellule de la bande sur 52, et le .caractère de sortie 52, qui est 4.

Déclencheur , JavaScript et ???

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

Impressions 11en déclencheur , 12en JavaScript et 13en REDACTED.

Comme cela n'a pas été craqué depuis plus longtemps que toute autre réponse jusqu'à présent, voici quelques astuces:

• Au cas où vous ne l'auriez pas remarqué, les caractères Тet еsur la première ligne sont des caractères multi-octets.
• [ //et \\ ][ //sont des no-ops.
• La deuxième ligne, ainsi que -²52, est du code mort.
• Le langage n'a pas de concept de terminaison, il ²6forme donc une boucle infinie.
• Pour être précis, le deuxième octet du codage UTF-8 de ², avec le 6, forme une boucle infinie.
• Le nombre en sortie est codé par le /!'!/
• La langue n'est pas sur Try It Online, Rosetta Code ou Esolangs.
• La seule forme de sortie disponible est un écran 1bpp.
• Le format de l'écran est 2.
• Bien que le langage n'ait pas été conçu à l'origine comme code machine, des implémentations FPGA existent.
• Selon Wikipedia, la langue était destinée aux jeux vidéo.
• La seule façon d'accéder à l'écran est une instruction spéciale, qui prend les coordonnées dans des registres sélectionnables, la hauteur immédiate, et XOR un bitmap 8 sur n sur l'écran. Pour faciliter la détection des collisions et effacer l’écran, l’un des registres sera défini lorsqu’un pixel est désactivé.

Explication

Eh bien, cela a pris du temps pour se fissurer. Voyons à quoi ressemble le code:

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.

Cela signifie que, bien que de nombreux émulateurs disponibles se comportent correctement, l'implémentation conforme aux règles est liée à la deuxième phrase de la page Wikipedia . Bien sûr, il ne peut pas être exécuté directement sur un PC ordinaire , mais j'ai trouvé l' émulateur Emma 02 associé à la page VIP COSMAC pour fonctionner au mieux.

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

Ceci affiche 1 en Python 2, 2 en Python 3 et 3 en ???.

Explication de fissure (poteau fissuré) :

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

• 0: C: La première ligne définit une macro de type fonction printqui ignore son argument unique et évalue main(){puts("0");}un programme complet qui s'imprime 0et se ferme. L'expression entière 1+bool(1/2)est ignorée lorsque la print( )macro de la deuxième ligne est étendue à main(){puts("0");}.

• 1: Python 2: La première ligne est un commentaire. 1/2utilise la division entière en Python 2, donnant 0. Cette valeur est ensuite interprétée comme un booléen ( bool(0)-> False), puis ajoutée à 1( 1+False-> 1), puis imprimée.

• 2: Python 3: La première ligne est un commentaire. 1/2utilise la division float dans Python 3, donnant 0,5. Cette valeur est ensuite interprétée comme un booléen ( bool(0.5)-> True), puis ajoutée à 1( 1+True-> 2), puis imprimée.

JavaScript , CHIP-8 et ???

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

12en JavaScript , 13dans CHIP-8 et 14dans ???

Je vais m'engager et dire que celui-ci est fissuré, même si je ne parviens pas à le faire fonctionner, je suis sûr du langage (ce qui semble être ce que les règles exigent.)

Voici une explication imparfaite du poteau fissuré

Le code hexadécimal "est" (il se peut que je sois légèrement désactivé):

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

Vous pouvez aller ici , cliquez sur "Outils binaires" et collez-le dans le tableau d'octets. Cliquez sur "Décompiler".

Les éléments clés du code sont les suivants: des instructions pour indiquer où se trouve le "numéro", la spritecommande qui imprime le nombre, la quantité correcte de déchets indésirables ici et là et les suivants:

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

Pour voir ce que cela représente, vous pouvez cliquer sur "Éditeur de sprite" et coller ces hexadécimaux dans la zone située en dessous. Vous verrez la réponse:

Je suis presque sûr que vous pouvez ensuite mettre ce que vous voulez à la fin et le résultat de CHIP-8 ne changera pas, d'où la nouvelle entrée.

Je serais ravi si quelqu'un pouvait faire en sorte que cela fonctionne pleinement, plutôt que la "preuve" de la réponse que j'ai donnée ici.

C, Python 2, ???

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

Ceci est imprimé 0en C, 1en Python 2 et 2en ???.

Ce sera extrêmement facile à craquer pour les personnes qui connaissent Python, mais je voulais un point de départ pour d’autres réponses. Les réponses ultérieures doivent essayer d’obscurcir la troisième langue (je ne l’ai pas fait).

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 et 4 en ???.

Explication pour poste fissuré :

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

• En Lua, - est un commentaire. En Python 2 et 3, - indique un double négatif en arithmétique.
• En Python 2 et 3, # est un commentaire. En Lua, # est l'opérateur de longueur.
• En Python 2, 1/2 est la division du sol, donc elle est évaluée à zéro. En Python 3, ce n'est pas le cas. Étant donné que les deux versions de Python évaluent 0 sur False, bool (1/2) donne False en Python 2 et True en Python 3. Lorsqu'il est utilisé en arithmétique, False est converti en 0 et True en 1.

> <>, Befunge-96 et ???

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

Ceci imprime 5 dans><> , 6 dansBefunge-96 et 7dans ???.

Je sais que la solution envisagée était Befunge-93, mais je n'ai pas pu résister.

Explication:

Befunge-96 suit le même chemin que ><>, mais ignore les instructions inconnues, en ajoutant un à 5 et en le multipliant par 9 pour obtenir 54, le code ascii pour 6.

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

Les sorties 15 dans Commentator , 16 dans Beatnik et 17 dans une langue que vous êtes supposé trouver.

Ok, c'est l'heure des indices:

• Le nom de la langue fait référence à un composé de deux éléments, les deux constituant votre corps, mais avec des pourcentages extrêmement variables (quelle que soit la méthode choisie, que vous soyez robot ou non).
• Le langage lui-même est sur TIO, mais l'implémentation ne l'est pas.
• Oh allez!

Brainfuck,> <>, et ???

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 4dans Brainfuck, 5dans> <> et 6dans ???

• En brainfuck, rien ne change.
• Dans> <>, vredirige le flux du programme vers le bas. La nest n sortie umérique. ;termine l'exécution.

Klein (101), Z80Golf, ???

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

Estampes 8à Klein (101) , 9à Z80Golf et 10à ??? .

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

Cela imprime 16 à Beatnik, 17 à Rust et 18 en ???.

Le �caractère de la ligne 4 doit être remplacé par le caractère ASCII 18 (cela n'a pas été fait dans les liens TIO car il ne concerne aucun des deux).

Explication ( fissurée ):

La réponse précédente était Rust: spécifiquement, Rust compilé avec mrustc . mrustc est un compilateur expérimental, et comme il est principalement destiné à amorcer une version valide de rustc, il ignore la vérification d'emprunt et la vérification de la mutabilité, ce qui permet à l'extrait de code de @ NieDzejkob de se compiler sans erreur.

Ce programme fonctionnera avec le compilateur Rust normal, vous n’avez donc pas besoin d’installer mrustc pour le tester.

Astuces

Puisque cette réponse a maintenant duré le plus longtemps sans être fissurée, je laisserai un indice et continuerai à le faire régulièrement jusqu'à ce qu'elle soit fissurée:

• Le langage secret est bidimensionnel.
• Comme je l'ai mentionné dans les commentaires, le langage n'est pas sur TIO.
• Le �personnage est un hareng rouge et a très peu de signification. La plupart des octets peuvent être remplacés à la place et le programme fonctionnera toujours.

Z80Golf , Somme , ???

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

Cela imprime 9 en Z80Golf , 10 en Somme et 11 en ??? .

Nous remercions Bubbler pour avoir craqué le message précédent sous le nom de Somme, qui prend la somme de la colonne comme indiqué dans les instructions. Les trois premières colonnes évaluent à

A.;

Ce qui pousse 10, l'imprime et sort.

Somme , Trigger et ???

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

Ceci est imprimé 10dans la Somme , 11dans Trigger et 12dans ???.

Comme les deux dernières langues sont faciles à polygloter, j'ai décidé de mélanger cette langue .

Explication ( poteau fissuré )

Trigger voit tout le code comme une série de jetons (la tokénisation est gourmande):

• Seul octet (dénoter A)
• Deux mêmes octets suivis d'un octet différent (notez AAB)
• Trois mêmes octets (notés AAA)
• Quatre mêmes octets (notés AAAA)

Dans le code source

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

les jetons significatifs sont ((1 11+ 111 111, où les deux premiers ne font rien et les deux derniers empreintes 1, donc 11.

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

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

Les sorties 13 dans CHIP-8 (je suppose), 14 dans Klein et 15 dans ???.

Une autre topologie de Klein, tsk tsk. J'ai conservé le code avant le @, car je ne sais pas ce qui va affecter CHIP-8.

Des indices

Je suis un peu en retard pour ça, désolé. Je vais essayer d'en ajouter un par jour.

• Supprimer la première moitié (les trois premières lignes) du programme fonctionne toujours.
• Ce n'est pas un langage 2D
• La langue est sur TIO
• Le nots et le saypeuvent être enlevés sans affecter le programme

Pour référence, le programme sans ce genre de choses ressemble à ceci:

 %/    <#> 13
        14
 +   15

Essayez-le en ligne!

Klein (100), commentateur , ???

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

Sorties 14 en Klein (100) , 15 en commentateur , 16 en ???.

Je suis sérieusement mauvais pour obscurcir les polyglottes.

Explication ( poteau fissuré )

 %/    <#> 13
        14
 +   15

Dans Commentator, les commandes les plus importantes sont les jetons de commentaire et les espaces. Tous les autres caractères sont ignorés.

• L'espace incrémente la cellule de mémoire actuelle.
• <# fait XOR 1 sur la cellule de mémoire actuelle.
• % est utilisé pour remettre à zéro la cellule de mémoire actuelle.

Attendez, il y a 16 espaces après %, que s'est-il passé?

C'est en fait un petit bug (ou fonctionnalité?) Dans l'interprète. /est considéré comme le début d'une commande à 2 caractères, donc l'espace après sa consommation. Mais il /<space>s'agit d'une commande non définie (donc non-op), l'espace est donc effectivement ignoré.