Poliglotti sovrapposti


37

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 :

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


2
Ha aperto una chat room per discutere di possibili crepe e costruzione di poliglotti.
Bubbler,

1
La risposta può generare altre cose oltre al numero desiderato?
NieDzejkob,

1
@NieDzejkob No, il programma dovrebbe emettere solo il numero, e sì, preferirei che i programmi funzionassero in meno di un minuto.
Esolanging Fruit,

3
Ecco una query SEDE che calcola la quantità di tempo in cui le risposte sono rimaste sicure (in ore).
NieDzejkob,

1
@EmbodimentofIgnorance Sì, è possibile richiedere flag della riga di comando in quanto definiscono essenzialmente interpreti separati e sì, il programma deve stampare solo il numero. Il programma può essere inviato a STDERR, ma è rilevante solo l'output a STDOUT.
Esolanging Fruit,

Risposte:


11

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.



9

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.



8

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.


8

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.

Non dirmi che questo è il codice macchina su alcuni processori.
SIGSTACKFAULT,

1
@Blacksilver Lo presumo da due indizi fa: cos'altro sarebbe simile a questo, non essere su Esolang, ma essere ancora abbastanza notevole per Wikipedia?
Ørjan Johansen,

@Blacksilver OK.
NieDzejkob,

@ngm mi dispiace, ma no
NieDzejkob il

Cracked , credo, secondo le regole.
ngm,

7

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.



7

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:

enter image description here

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.


Lo permetterò . Modificherò una spiegazione più tardi oggi. Buon lavoro.
NieDzejkob,


Inoltre, il tuo esadecimale deve essere sbagliato poiché non decodifica come UTF-8 valido ...
NieDzejkob

5

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


Cracked . Grande sfida tra l'altro!
pizzapants184

5

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.


5

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



5

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.

1
Sembra Rust ( fn main(), tra le altre cose), ma in realtà non funziona in Rust ( explicit lifetime required in the type of 's'), né su TIO né su un altro interprete che ho trovato. E non riesco a trovare nessun'altra lingua che usi fncome identificatore di funzione.
Draco18

Eh, anche il suggerimento sembra Rust, che è un composto di Fe e O. Non riesco a pensare ad altro. Forse diverse versioni del compilatore?
Gorgogliatore

1
Ho il sospetto che questo potrebbe essere Rust compilato con mrustc , che è fondamentalmente Rust senza il controllo del prestito.
Esolanging Fruit,

@EsolangingFruit provalo
NieDzejkob,

Tre mesi più tardi, ho finalmente ottenuto intorno a fessurazione questo
Esolanging frutta

4

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.



4

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.

1
Mentre lanciavo le lingue a caso (non avendo trovato molta ricerca di "punti di codice ascii 0x12 esolang"), ho notato che in realtà produce 15 in> <>, quindi è pulito
Stringa non correlata

1
Sembrerebbe che questo non stampi 18 in nessuna lingua su TIO (senza alcuna aggiunta di flag di intestazione, piè di pagina o riga di comando). Spero di non averne perso nessuno, perché sembra che probabilmente sarà un po 'più difficile controllare tutto su esolang, Wikipedia e Rosetta Code ... La mia ipotesi migliore è che si tratti di una sorta di linguaggio 2D in cui neanche @,P , {o minizia un letterale carattere e qualcosa stamperà poi il suo valore di codice in decimale, ma questo non spiega tutti i ++s ...
Estranei String

1
@UnrelatedString Sì, confermo che non è una lingua su TIO.
Esolanging Fruit

1
Beh, avrei potuto perdere una giornata a esplorare 100 lingue su esolang.org cercando di trovarne una adatta ... Poi ho letto la cosa dei caratteri ASCII 18 e ho realizzato che il mio approccio era completamente sbagliato mentre cercavo una classe di lingue completamente diversa ...
IQuick 143

2
@ Le aringhe IQuick143 sono rosse
Esolanging Fruit il


3

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.



3

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!


2
...Sono spaventato. Funziona in runico e produce 16 .
Draco18s

@ Draco18s Intentional
Jo King,

Non lo farà dopo il mio prossimo aggiornamento, poiché ho aggiunto una migliore gestione delle stringhe a diversi operatori (attualmente TIO fa apparire una 1e una stringa che è composta dalla prima riga e va "questo non è un valore" e li scarta, il L'aggiornamento concatenerà, anche se ho un operatore per quello, ma concat opera su caratteri e numeri, nonché su stringhe, dove +li tratta come numeri ). Ma è stato davvero spaventoso essere come "Mi chiedo cosa ... oh dio, questo potrebbe essere lasciato immodificato ed essere la prossima voce ... se solo conoscessi la lingua ??? ..."
Draco18s

Stai definendo la metà per byte, caratteri, linee o qualcosa di specifico?
NieDzejkob,


3

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.


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.