Grazie a FryAmTheEggman per l'ispirazione necessaria per la soluzione XOR.
0000 !@
0001 ?.|@!
0010 #?#!)@
0011 ?!@
0100 +?|@!?
0101 ??!@
0110 ?<@!!<_\~(
0111 ?<<@!
1000 )\!#?@{
1001 (~?/@#!
1010 ??|@!)
1011 \#??!1@
1100 ?(~!@
1101 ?.|@!)
1110 ?$@#)!<
1111 1!@
Tutti i programmi usano 0per falso e 1per vero.
Provalo online! Questa non è una suite di test, dovrai copiare i vari programmi e input da solo.
La soluzione sopra è entro 2 byte di ottimalità (a meno che non rilassiamo l'interpretazione verità / falsa, immagino). Ho lasciato un bruto corsa di ricerca forza per quasi due giorni più di tutti i programmi che rientrano in parte di lunghezza 2, vale a dire fino a 7 byte (non abbastanza tutti i programmi - ho fatto un paio di ipotesi su ciò che ogni esigenza programma valido e cosa no programma valido potrebbe avere). La ricerca ha trovato soluzioni per 15 delle 16 possibili porte - e spesso molto più di una sola. Puoi trovare un elenco di tutte le soluzioni alternative in questo pastebin in cui le ho anche raggruppate per comportamento equivalente. Quelli che sto mostrando sopra li ho selezionati perché sono la soluzione più semplice o più interessante e domani aggiungerò spiegazioni per loro.
Per quanto riguarda la 16a porta: XOR è l'unica porta che apparentemente non può essere implementata in 7 byte. Sfortunatamente una ricerca di forza bruta su programmi più grandi non è fattibile con il codice che ho attualmente. Quindi XOR doveva essere scritto a mano. Il più breve che ho trovato finora è il programma da 10 byte sopra, che si basa su un tentativo fallito (ma molto vicino) di FryAmTheEggman. È possibile che esista una soluzione a 8 o 9 byte, ma a parte ciò, tutte le soluzioni dovrebbero essere effettivamente ottimali.
spiegazioni
Attenzione: muro di testo. Per caso qualcuno è interessato a come funzionano questi programmi Hexagony altamente compressi, ho incluso spiegazioni per ciascuno di essi di seguito. Ho cercato di scegliere la soluzione più semplice per ogni gate nei casi in cui esiste più di un programma ottimale, al fine di mantenere le spiegazioni ragionevolmente brevi. Tuttavia, alcuni di loro continuano a confondere la mente, quindi ho pensato che meritassero un po 'più di elaborazione.
0000: Falso
Non credo che avremo bisogno di un diagramma per questo:
! @
. . .
. .
Poiché l'intera griglia di memoria è inizializzata su zero, !stampa semplicemente uno zero e @termina il programma.
Questa è anche l'unica soluzione a 2 byte.
0001: E
? .
| @ !
. .
Questo in pratica implementa il corto circuito . Il diagramma grigio in basso mostra l'inizio del programma, in cui viene letto il primo input ?e il puntatore dell'istruzione (IP) si avvolge nell'angolo sinistro dove lo |specchio lo riflette. Ora l'angolo funge da condizionale, quindi esistono due diversi percorsi di esecuzione a seconda del valore del primo input. Il diagramma rosso mostra il flusso di controllo per A = 0e il diagramma verde per A = 1:
Come puoi vedere, quando lo Aè 0, lo stampiamo e terminiamo semplicemente (ricorda che tutti .sono vietati). Ma quando lo Aè 1, l'IP attraversa di nuovo la prima riga, leggendola Be stampandola invece.
In totale ci sono sedici soluzioni a 5 byte per questo gate. Quattordici di questi sono essenzialmente gli stessi di cui sopra, o usando >invece |o sostituendo il .con un comando che è effettivamente un no-op, o mettendo ?in seconda posizione:
?.|@! .?|@! ?=|@! =?|@! ?_|@! _?|@! ?0|@!
?.>@! .?>@! ?=>@! =?>@! ?_>@! _?>@! ?0>@!
E poi ci sono altre due soluzioni (che sono equivalenti tra loro). Questi implementano anche la stessa logica di corto circuito, ma i percorsi di esecuzione sono un po 'più folli (e lasciati come esercizio al lettore):
?<!@|
?<!@<
0010: A e non B
# ?
# ! )
@ .
Questo implementa anche una forma di corto circuito, ma a causa dell'uso del #flusso di controllo è molto più complicato. #è uno switch IP condizionale. Hexagony in realtà è dotato di sei indirizzi IP etichettati 0a 5, che partono nei sei angoli della griglia, indicando lungo il loro bordo in senso orario (e il programma inizia sempre con IP 0). Quando #viene rilevato un, il valore corrente viene assunto modulo 6e il flusso di controllo continua con l'IP corrispondente. Non sono sicuro di quale forma di follia mi abbia fatto aggiungere questa funzionalità, ma certamente consente alcuni programmi sorprendenti (come questo).
Distingueremo tre casi. Quando A = 0, il programma è abbastanza semplice, perché il valore è sempre 0quando #viene rilevato in modo tale che non avvenga alcuna commutazione IP:
#non fa nulla, ?legge A(cioè non fa nulla), #non fa ancora nulla, !stampa il 0, lo )incrementa (questo è importante, altrimenti l'IP non salterebbe alla terza riga), @termina il programma. Abbastanza semplice. Consideriamo ora il caso (A, B) = (1, 0):
Il percorso rosso corrisponde ancora a IP 0e ho aggiunto il percorso verde per IP 1. Vediamo che dopo le ?letture A( 1questa volta), #passa all'IP che inizia nell'angolo in alto a destra. Ciò significa che ?può leggere B( 0). Ora lo )incrementa a 1, in modo tale che #nell'angolo in alto a sinistra non faccia nulla e rimaniamo con IP 1. La !stampa 1e l'IP si avvolgono attorno alla diagonale sinistra. #continua a non fare nulla e @termina il programma.
Infine, il caso davvero strano in cui entrambi gli input sono 1:
Questa volta, anche il secondo input è 1e lo )incrementa a 2. Ciò significa che #nell'angolo in alto a sinistra provoca un altro IP switch su IP 2, indicato in blu. Su quel percorso, prima lo incrementiamo ulteriormente 3(anche se questo è irrilevante) e quindi passiamo la ?terza volta. Dato che ora abbiamo premuto EOF (ovvero l'input è esaurito), ?ritorna 0, lo !stampa e @termina il programma.
In particolare, questa è l'unica soluzione a 6 byte per questo gate.
0011: A
? !
@ . .
. .
Questo è abbastanza semplice che non avremo bisogno di un diagramma: ?legge A, !stampa, @termina.
Questa è l'unica soluzione a 3 byte per questo gate. (In linea di principio, sarebbe anche possibile farlo ,;@, ma la ricerca non ha incluso ;, perché non credo che potrà mai salvare byte !per questa attività.)
0100: B e non A
+ ?
| @ !
? .
Questo è molto più semplice del suo "fratello" 0010. Il flusso di controllo è in realtà lo stesso che abbiamo visto sopra per 0001(And). Se A = 0, quindi l'IP attraversa la riga inferiore, leggendola Be stampandola prima di terminare. Se A = 1poi l'IP attraversa di nuovo la prima riga, leggendo anche B, ma +aggiunge due bordi di memoria inutilizzati, quindi tutto ciò che fa è resettare il valore corrente 0, in modo che venga !sempre stampato 0.
Ci sono molte alternative a 6 byte (42 in totale). Innanzitutto, ci sono un sacco di soluzioni equivalenti a quanto sopra. Possiamo di nuovo scegliere liberamente tra |e >e +può essere sostituito con qualsiasi altro comando che ci dia un bordo vuoto:
"?|@!? &?|@!? '?|@!? *?|@!? +?|@!? -?|@!? ^?|@!? {?|@!? }?|@!?
"?>@!? &?>@!? '?>@!? *?>@!? +?>@!? -?>@!? ^?>@!? {?>@!? }?>@!?
Inoltre, possiamo anche usare al ]posto di ?. ]passa all'IP successivo (ovvero seleziona l'IP 1), in modo che questo ramo riutilizzi invece l' ?angolo superiore destro. Questo offre altre 18 soluzioni:
"?|@!] &?|@!] '?|@!] *?|@!] +?|@!] -?|@!] ^?|@!] {?|@!] }?|@!]
"?>@!] &?>@!] '?>@!] *?>@!] +?>@!] -?>@!] ^?>@!] {?>@!] }?>@!]
E poi ci sono altre sei soluzioni che funzionano in modo diverso con vari livelli di follia:
/[<@!? ?(#!@] ?(#>@! ?/@#/! [<<@!? [@$\!?
0101: B
? ?
! @ .
. .
Woohoo, un altro semplice: leggi A, leggi B, stampa B, termina. In realtà ci sono alternative a questo però. Dato che Aè solo un singolo personaggio, possiamo anche leggerlo con ,:
,?!@
E c'è anche la possibilità di utilizzare un singolo ?e utilizzare un mirror per eseguirlo due volte:
?|@! ?>@!
0110: Xor
? < @
! ! < _
\ ~ ( . .
. . . .
. . .
Come ho detto sopra, questo era l'unico cancello che non si adattava alla lunghezza laterale 2, quindi questa è una soluzione scritta a mano da FryAmTheEggman e da me, e c'è una buona probabilità che non sia ottimale. Vi sono due casi da distinguere. Se A = 0il flusso di controllo è abbastanza semplice (perché in quel caso dobbiamo solo stampare B):
Iniziamo sul sentiero rosso. ?legge A, <è un ramo che devia lo zero sinistro. L'IP si sposta in basso, quindi _è un altro mirror e quando l'IP colpisce l'angolo, si sposta nell'angolo in alto a sinistra e continua sul percorso blu. ?legge B, !stampa. Ora lo (diminuisce. Questo è importante perché garantisce che il valore non sia positivo (sia 0o sia -1adesso). Ciò fa avvolgere l'IP nell'angolo destro, dove @termina il programma.
Quando le A = 1cose si fanno un po 'più complicate. In tal caso, vogliamo stampare not B, che di per sé non è troppo difficile, ma il percorso di esecuzione è un po 'lento.
Questa volta, <devia l'IP a destra e poi <agisce solo come mirror. Quindi l'IP percorre lo stesso percorso al contrario, leggendo Bquando si incontra di ?nuovo. L'IP si avvolge nell'angolo destro e continua sul percorso verde. It prossimi incontri (~che è "decremento, moltiplicare per -1", quali swap 0e 1e calcola quindi not B. \è solo uno specchio e !stampa il risultato desiderato. Quindi ?tenta di restituire un altro numero ma restituisce zero. L'IP ora continua nell'angolo in basso a sinistra sul percorso blu. (diminuisce, <riflette,(diminuisce nuovamente, in modo che il valore corrente sia negativo quando l'IP colpisce l'angolo. Si sposta attraverso la diagonale in basso a destra e infine colpisce @per terminare il programma.
0111: O
? <
< @ !
. .
Più corto circuito.
Il A = 0caso (il percorso rosso) è un po 'confuso qui. L'IP viene deviato a sinistra, si avvolge nell'angolo in basso a sinistra, viene immediatamente riflesso da <e torna ?alla lettura B. Si avvolge poi verso l'angolo rigt, stampa Bcon !e termina.
Il A = 1caso (il percorso verde) è un po 'più semplice. Il <ramo devia l'IP a destra, quindi stampiamo semplicemente !, torniamo in alto a sinistra e terminiamo a @.
Esiste solo un'altra soluzione a 5 byte:
\>?@!
Funziona essenzialmente allo stesso modo, ma i percorsi di esecuzione effettivi sono piuttosto diversi e utilizza un angolo per la ramificazione anziché a <.
1000: Né
) \
! # ?
@ {
Questo potrebbe essere il mio programma preferito trovato in questa ricerca. La cosa più interessante è che questa implementazione norfunziona fino a 5 input. Dovrò entrare un po 'nei dettagli del modello di memoria per spiegarlo. Così come un rapido aggiornamento, modello di memoria di Hexagony è una griglia esagonale separata, dove ogni bordo conserva un valore intero (inizialmente tutti zero). C'è un puntatore di memoria (MP) che indica un bordo e una direzione lungo quel bordo (in modo tale che ci siano due bordi vicini davanti e dietro il bordo corrente, con i vicini significativi sinistro e destro). Ecco un diagramma dei bordi che useremo, con la MP che inizia come mostrato in rosso:
Consideriamo innanzitutto il caso in cui entrambi gli input sono 0:
Iniziamo sul percorso grigio, che semplicemente incrementa il bordo A in 1modo che passi #a IP 1che è il percorso blu, iniziando nell'angolo in alto a destra. \non fa nulla lì e ?legge un input. Si avvolge nell'angolo in alto a sinistra dove )incrementa tale input. Ora fino a quando l'input è zero, questo si tradurrà in a 1, quindi #non fa nulla. Poi {sposta il MP a fianco, cioè alla prima iterazione da A a B . Poiché questo fronte ha ancora il suo zero iniziale, l'IP torna all'angolo in alto a destra e su un nuovo bordo di memoria. Quindi questo ciclo continuerà finché ?legge zero, spostando il MP attorno all'esagono da Ba C a D e così via. Non importa se ?restituisce uno zero perché era un input o perché era EOF.
Dopo sei iterazioni attraverso questo ciclo, {torna a A . Questa volta, il bordo contiene già il valore 1sin dalla prima iterazione, quindi l'IP si sposta nell'angolo sinistro e continua invece sul percorso verde. !semplicemente lo stampa 1e @termina il programma.
E se uno qualsiasi degli input fosse 1?
Quindi lo ?legge 1ad un certo punto e lo )incrementa a 2. Ciò significa #che ora cambierà di nuovo gli IP e continueremo nell'angolo destro sul percorso rosso. ?legge un altro input (se ce n'è uno), che non ha molta importanza e si {sposta ulteriormente di un vantaggio. Questo deve essere un vantaggio inutilizzato, quindi funziona fino a 5 ingressi. L'IP si sposta in alto a destra dove viene immediatamente riflesso e si sposta nell'angolo sinistro. !stampa il 0bordo inutilizzato e #ritorna su IP 0. Quell'IP stava ancora aspettando sul #, andando a sud-ovest (percorso grigio), quindi colpisce immediatamente @e termina il programma.
In totale ci sono sette soluzioni a 7 byte per questo gate. 5 di questi funzionano allo stesso modo e usano semplicemente altri comandi per spostarsi su un bordo inutilizzato (e possono camminare attorno a un esagono diverso o in una direzione diversa):
)\!#?@" )\!#?@' )\!#?@^ )\!#?@{ )\!#?@}
E c'è un'altra classe di soluzioni che funziona solo con due input, ma i cui percorsi di esecuzione sono in realtà ancora più complicati:
?]!|<)@ ?]!|<1@
1001: Uguaglianza
( ~
? / @
# !
Questo fa anche un uso molto intelligente della selezione IP condizionale. Dobbiamo distinguere di nuovo tra A = 0e A = 1. Nel primo caso vogliamo stampare not B, nel secondo vogliamo stampare B. Per A = 0noi anche distinguere i due casi per B. Cominciamo con A = B = 0:
Iniziamo sul sentiero grigio. (~può essere ignorato, l'IP si sposta nell'angolo sinistro (sempre sul percorso grigio) e legge Acon ?. (lo decrementa, così otteniamo -1e IP avvolgiamo nell'angolo in basso a sinistra. Ora, come ho detto prima, #prende il valore modulo 6prima di scegliere l'IP, quindi un valore di -1effettivamente esce IP 5, che inizia nell'angolo sinistro sul percorso rosso. ?legge B, (decrementa anche quello in modo da rimanere su IP 5quando colpiamo di #nuovo. ~annulla il -1modo in cui l'IP si sposta nell'angolo in basso a destra, stampa 1e termina.
Ora, se Bè 1invece, il valore corrente sarà 0quando premiamo #la seconda volta, quindi torniamo a IP 0(ora sul percorso verde). Ciò colpisce ?una terza volta, cedendo 0, !stampandolo e @termina.
Infine, il caso in cui A = 1. Questa volta il valore corrente è già zero quando colpiamo #per la prima volta, quindi questo non passa mai all'IP 5in primo luogo. Continuiamo semplicemente immediatamente sul sentiero verde. ?ora non solo dà uno zero ma ritorna Binvece. !lo stampa e @termina di nuovo.
In totale ci sono tre soluzioni a 7 byte per questo gate. Gli altri due funzionano in modo molto diverso (anche gli uni dagli altri) e ne fanno un uso ancora più strano #. In particolare leggono uno o più valori con ,(leggendo un codice carattere anziché un numero intero) e quindi usano quel valore modulo 6 per scegliere un IP. È pazzesco.
),)#?@!
?~#,~!@
1010: Non B
? ?
| @ !
) .
Questo è abbastanza semplice. Il percorso di esecuzione è il ramo orizzontale che già conosciamo da andprima. ??legge Ae poi immediatamente B. Dopo aver riflettuto su |e ramificato, B = 0eseguiremo il ramo inferiore, dove )incrementa il valore su 1cui viene quindi stampato !. Sul ramo superiore (se B = 1) ?semplicemente reimpostare il bordo su 0cui viene anche stampato da !.
Esistono otto programmi a 6 byte per questo gate. Quattro di loro sono praticamente uguali, usando o >invece di |o 1invece di )(o entrambi):
??>@!) ??>@!1 ??|@!) ??|@!1
Due usano un singolo ?che viene utilizzato due volte a causa di uno specchio. La negazione si verifica quindi come abbiamo fatto xorcon uno (~o ~).
?>!)~@ ?>!~(@
E infine, due soluzioni utilizzano uno switch IP condizionale, perché perché usare il modo semplice se anche quello contorto funziona:
??#)!@ ??#1!@
1011: B implica A
\ #
? ? !
1 @
Questo utilizza una commutazione IP piuttosto elaborata. Inizierò con il A = 1caso questa volta, perché è più semplice:
Iniziamo sul percorso grigio, che legge Acon ?e poi colpisce il #. Poiché Aè 1presente commuta IP 1(percorso verde). Lo !stampa immediatamente, l'IP si sposta in alto a sinistra, legge B(inutilmente) e termina.
Quando le A = 0cose diventano un po 'più interessanti. Per prima cosa consideriamo A = B = 0:
Questa volta, il #non fa nulla e restiamo su IP 0(percorso rosso da quel punto in poi). ?legge Be lo 1trasforma in a 1. Dopo esserci spostati nell'angolo in alto a sinistra, premiamo di #nuovo, quindi alla fine finiamo sul percorso verde e stampiamo 1come prima, prima di terminare.
Infine, ecco (A, B) = (0, 1)il caso falso:
Nota che ho rimosso il percorso grigio iniziale per chiarezza, ma il programma inizia allo stesso modo e finiamo sul percorso rosso di prima. Quindi questa volta il secondo ?ritorna 1. Ora incontriamo il 1. A questo punto è importante capire cosa fanno effettivamente le cifre in Esagonia (finora le abbiamo usate solo sugli zeri): quando si incontra una cifra, il valore corrente viene moltiplicato per 10 e quindi la cifra viene aggiunta. Questo è normalmente usato per scrivere numeri decimali alla lettera nel codice sorgente, ma significa che B = 1è effettivamente associato al valore 11. Quindi, quando colpiamo #, questo è preso modulo 6per dare 5e quindi passiamo a IP 5(invece di 1come prima) e continuiamo sul percorso blu. colpire?una terza volta restituisce uno zero, quindi !stampa che, e dopo altre due ?, l'IP si sposta in basso a destra dove termina il programma.
Esistono quattro soluzioni a 7 byte e funzionano tutte in modo diverso:
#)/!?@$ <!?_@#1 \#??!1@ |/)#?@!
1100: Non A
? (
~ ! @
. .
Semplicemente lineare: leggi Acon ?, nega con (~, stampa con !, termina con @.
C'è una soluzione alternativa, e questo invece sta negando ~):
?~)!@
1101: A implica B
? .
| @ !
) .
Questo è molto più semplice dell'implicazione opposta di cui abbiamo appena parlato. È di nuovo uno di quei programmi di diramazione orizzontale, come quello per and. Se lo Aè 0, viene semplicemente incrementato 1sul ramo inferiore e stampato. Altrimenti, il ramo superiore viene eseguito di nuovo dove ?legge Be poi lo !stampa invece.
Ci sono un sacco di alternative qui (66 soluzioni in totale), principalmente a causa della libera scelta di no-op efficaci. Per cominciare, possiamo variare la soluzione sopra in tutti gli stessi modi in cui potremmo ande possiamo anche scegliere tra )e 1:
?.|@!) .?|@!) ?=|@!) =?|@!) ?_|@!) _?|@!) ?0|@!)
?.|@!1 .?|@!1 ?=|@!1 =?|@!1 ?_|@!1 _?|@!1 ?0|@!1
?.>@!) .?>@!) ?=>@!) =?>@!) ?_>@!) _?>@!) ?0>@!)
?.>@!1 .?>@!1 ?=>@!1 =?>@!1 ?_>@!1 _?>@!1 ?0>@!1
E poi c'è una versione diversa che utilizza la selezione IP condizionale, in cui il primo comando può essere scelto quasi arbitrariamente, e c'è anche una scelta tra )e 1per alcune di quelle opzioni:
"?#1!@ &?#1!@ '?#1!@ )?#1!@ *?#1!@ +?#1!@ -?#1!@ .?#1!@
0?#1!@ 1?#1!@ 2?#1!@ 3?#1!@ 4?#1!@ 5?#1!@ 6?#1!@ 7?#1!@
8?#1!@ 9?#1!@ =?#1!@ ^?#1!@ _?#1!@ {?#1!@ }?#1!@
"?#)!@ &?#)!@ '?#)!@ *?#)!@ +?#)!@ -?#)!@
0?#)!@ 2?#)!@ 4?#)!@ 6?#)!@
8?#)!@ ^?#)!@ _?#)!@ {?#)!@ }?#)!@
1110: Nand
? $
@ # )
! <
L'ultima complicata. Se stai ancora leggendo, ce l'hai quasi fatta. :) Diamo un'occhiata A = 0prima:
?legge Ae poi colpiamo $. Questo è un comando di salto (come quello di Befunge #) che salta le istruzioni successive in modo da non terminare su @. Invece l'IP continua a #. Tuttavia, dato che Aè 0, questo non fa nulla. )lo incrementa in 1modo che l'IP continui sul percorso inferiore in cui 1è stampato. Il <devia l'IP a destra dove si avvolge nell'angolo sinistro e il programma termina.
Successivamente, quando l'input è (A, B) = (1, 0), otteniamo questa situazione:
E 'essenzialmente la stessa di prima, tranne che al #si passa a IP 1(percorso verde), ma dal momento che Bè 0si passa di nuovo a IP 0quando colpiamo #una seconda volta (ora blu percorso), dove viene stampato 1come prima.
Infine, il A = B = 1caso:
Questa volta, quando siamo #la seconda volta, il valore corrente è ancora in 1modo da non modificare nuovamente l'IP. Il <riflesso e la terza volta che colpiamo ?otteniamo uno zero. Quindi l'IP si sposta in basso a sinistra dove !stampa lo zero e il programma termina.
Ci sono nove soluzioni a 7 byte in totale per questo. La prima alternativa utilizza semplicemente 1invece di ):
?$@#1!<
Quindi ci sono due soluzioni che faranno la tua testa con la quantità di commutazione IP che sta succedendo:
)?#_[!@ 1?#_[!@
Questi in realtà mi hanno fatto impazzire: la parte interessante è che la commutazione IP può essere utilizzata come condizione differita. Le regole di commutazione IP della lingua sono tali che l'IP corrente fa un altro passo prima che avvenga lo switch. Se succede che quel passaggio attraversi un angolo, allora il valore corrente decide su quale ramo continuerà l'IP se dovessimo tornare ad esso. Questo succede esattamente quando l'ingresso è A = B = 1. Sebbene tutto ciò sia coerente con il modo in cui ho progettato la lingua, non sono mai stato consapevole di questa implicazione delle specifiche, quindi è bello quando la mia lingua mi insegna alcuni nuovi trucchi: D.
Poi c'è una terza soluzione la cui quantità di commutazione IP è ancora peggiore (anche se non utilizza quell'effetto condizionato differito):
>?1]#!@
E poi ce n'è un altro:
?$@#)!<
E poi ci sono queste quattro soluzioni equivalenti, che usano una commutazione IP non condizionale e implementano invece tutta la logica tramite rami e angoli:
]<?<@!) ]<?<@!1 ]|?<@!) ]|?<@!1
1111: Vero
1 !
@ . .
. .
Ti sei guadagnato qualcosa di semplice per la fine: imposta il bordo su 1, stampa con !, termina con @. :)
Certo, c'è un'alternativa:
)!@
Come al solito, tutti i diagrammi di flusso di controllo creati con HexagonyColorer di Timwi e il diagramma di memoria con il suo EsotericIDE .
