Scrivi un programma rettangolare che emette il numero di volte in cui è stato ruotato


63

Il titolo dice tutto. Il tuo obiettivo è quello di scrivere un programma che formi un rettangolo aw × h di caratteri che possano essere ruotati e rieseguiti per generare il numero di rotazioni in senso antiorario (CCW) di 90 ° che sono state eseguite.

Ad esempio, se il programma 3 × 2

abc
def

risolto il problema, inizialmente avrebbe prodotto 0 e successive rotazioni di 90 ° in senso antiorario

cf    fed    da
be    cba    eb
ad           fc

produrrebbe rispettivamente 1, 2 e 3.

L'uso dei commenti rende questo compito banale la maggior parte delle lingue. In Ruby per esempio, può essere fatto in un rettangolo 7 × 7:

###p###
### ###
###1###
p 0#2 p
###3###
### ###
###p###

La sfida è farlo senza alcun tipo di commento.

punteggio

Il tuo punteggio è w * h, l'area del tuo rettangolo. Le nuove righe sono escluse. In altre parole, code-golf, newline non contati.

Il punteggio per l'esempio di Ruby è 49 (anche se ovviamente non è valido poiché ha commenti).

Appunti

  • Il tuo codice deve essere davvero rettangolare senza caratteri mancanti alla fine delle righe.
  • Se lo desideri, puoi generare altri valori "mod 90 °" legali invece di 0 1 2 3. Quindi 8 va bene invece di 0 e -1 va bene invece di 3, ecc.
  • L'output può andare sulla console o in un file.
  • Si applicano scappatoie standard.

Spero che questa, la mia prima domanda, incuriosisca davvero alcune persone. Godere!


1
Per essere più precisi su cosa sia un commento, un commento è un codice non valutato? Codice non analizzato?
Isaacg,

Voglio dire che nessuno dei tradizionali "caratteri di commento" della tua lingua dovrebbe apparire in nessuna delle 4 versioni ruotate. Quindi, per C ++, non dovrebbero mai comparire due barre una accanto all'altra, sebbene una possa essere usata da sola. Allo stesso modo con / *. Spero che questo lo chiarisca.
Hobby di Calvin l'

Che dire delle lingue che non hanno caratteri di commento?
isaacg,

Quindi echo 0;exit;eè permesso codice come in bash?
jimmy23013,

Se non c'è modo di commentare, non devi preoccuparti. @ user23013 Quel bash va bene.
Calvin's Hobbies

Risposte:


43

APL (1x3 = 3)

5!3

Questa soluzione utilizza la regola aggiuntiva che funziona qualsiasi output che sia corretto mod 4.

In APL, x!yè il numero di modi tra cui scegliere gli xelementi y, comunemente noto come binom(y,x)o choose(y,x). Controlliamo che ogni rotazione dia la risposta giusta.

0 rotazioni

5!3

Non c'è modo di scegliere 5 elementi tra 3, quindi otteniamo 0, che viene stampato automaticamente.

1 rotazione antiorario

3
!
5

APL valuta felicemente ogni riga, ottenendo il numero 3, l'operatore !e quindi il numero 5, stampando solo l'ultimo di questi ( 5), che è 1 mod 4.

2 rotazioni in senso antiorario

3!5

Questo è binom(5,3), che è (5*4*3*2*1)/(3*2*1)/(2*1) = 10, che è 2 mod 4.

3 rotazioni in senso antiorario

5
!
3

Come prima, solo l'ultimo valore valutato 3è printer.

In realtà non conosco APL, quindi per favore dimmi se ho sbagliato una spiegazione. L'ho trovato per tentativi ed errori come prima lingua su questo sito che:

  1. Stampa automaticamente il risultato di un'espressione
  2. Date più righe di espressioni, restituisce solo l'ultima
  3. Non ha problemi con un operatore in piedi da solo su una linea
  4. Accetta gli operatori
  5. Ha un operatore binario aritmetico a carattere singolo asimmetrico (aRb! = BRa) e abbastanza flessibile da restituire una varietà di numeri.

Per (5), sono andato giù per l'elenco delle funzioni diadiche APL . La mia prima operazione candidata fu la divisione intera /di C e Python 2, ma la divisione APL ÷dà float. L'esponenziazione è allettante, ma fallisce perché ae a^bha la stessa parità ma sono ottenuti da rotazioni consecutive (a meno che b=0, ma poi b^a=0). Agli operatori booleani piace <dare 0e 1distanti 180 gradi, il che non funziona. Alla fine, ho trovato l'operatore binomiale !e ho provato i numeri fino a quando non ho ottenuto quel lavoro.

Grazie a Quincunx per la sua sicurezza che esiste una soluzione più piccola di 2x2.


6
Amico, è bello vedere una risposta che usa un linguaggio non esoterico e vince .
Stuart P. Bentley,

Ho accettato questa come risposta poiché è la più breve secondo le mie regole, ma voglio fare della risposta di Ventero ( codegolf.stackexchange.com/a/33162/26997 ) una menzione molto onorevole. Segue la vera essenza del problema.
Calvin's Hobbies,

Funziona anche in J nell'esatta forma che hai dato.
ɐɔıʇǝɥʇuʎs,

In realtà, APL non stampa sia il 3 che il 5 con una rotazione di 90 °?
FUZxxl,

@FUZxxl Penso che questo funzioni solo in ngn / apl.
Adám,

40

Rubino, 7 × 9 (63)

 30;p  
0||p=p 
0|0;p;p
;p;p|p;
p=p ||0
;p   p;
2||p =p
 00;1  
     p 

Un po 'più lungo dell'altra soluzione, ma almeno questa soluzione non dipende dalla stampa implicita o dall'abuso di regole. Per tutte e quattro le rotazioni, viene analizzato il codice completo e, a parte alcuni cortocircuiti, viene eseguito tutto. Sorprendentemente, non c'è assolutamente nessuna simmetria nel codice

Questa soluzione si basa sul fatto che è ancora possibile chiamare la pfunzione (che viene utilizzata per stampare i numeri) anche se è già stata definita una variabile con lo stesso nome. Ad esempio, qualcosa come p pchiama la funzione pcon la variabile pcome argomento (quindi, stampa il valore di p).

Spiegazione per alcune delle espressioni comuni utilizzate nel codice:

  • p: Come menzionato sopra, questa è una chiamata di funzione o una variabile. Quando la variabile non è definita, chiama la funzione psenza argomenti, che non fa nulla e restituisce nil.
  • p p: Stampa la variabile p.
  • p|x: Quando pè la funzione, questa è identica a nil|x, che restituisce vero / falso a seconda del valore di x. Se pè un numero intero, è bit a bit o. Ad ogni modo, questa affermazione non ha effetti collaterali.
  • p=p||x: Efficacemente uguale a p||=x(assegnazione condizionale) con il vantaggio di essere sintatticamente valido e di non operare se invertito.

Versione simmetrica (9 × 10 = 90)

    p    

  0 * 0  
  00100  
  0||2* p
p *0||0  
  00300  
  0 * 0  

    p    

Questa è la soluzione simmetrica più breve (C 2 quando si ignorano i numeri da stampare) che ho potuto trovare.

Test script

Ecco uno script di prova per verificare il codice sopra (le #estremità alla fine della riga sono state aggiunte in modo che lo spazio bianco non venga rimosso e rimosso prima dell'esecuzione):

rotate=->s{s.split($/).map{|i|i.chars.reverse}.transpose.map(&:join).join($/)}

s=<<EOD.gsub(?#,"")
 30;p  #
0||p=p #
0|0;p;p#
;p;p|p;#
p=p ||0#
;p   p;#
2||p =p#
 00;1  #
     p #
EOD


puts ">>> 0°"
eval s
puts ">>> 90°"
eval rotate[s]
puts ">>> 180°"
eval rotate[rotate[s]]
puts ">>> 270°"
eval rotate[rotate[rotate[s]]]

10
Potrebbe non essere il più breve, ma questo è esattamente il tipo di brillantezza offuscata che stavo cercando: D
Calvin's Hobbies

1
@ Calvin'sHobbies Soddisfa la limitazione "Il tuo codice deve essere davvero rettangolare senza caratteri mancanti alla fine delle righe"?
Joshua Taylor,

@JoshuaTaylor È rettangolare, alcune linee sono solo imbottite di spazi (che, per quanto mi riguarda, è un personaggio). Se ciò non rispondesse alla restrizione per qualsiasi motivo, potrei anche
riempire

@Ventero spero sicuramente questo legale; Sto solo cercando di capire cosa volesse dire nella domanda.
Joshua Taylor,

1
@Ventero L'imbottitura con spazi (o davvero qualsiasi cosa oltre a commenti e righe) va bene.
Calvin's Hobbies,

33

GolfScript, 4 (2x2)

43
12

Stampa 4312che è 0(mod 4). Le rotazioni stampano 3241(1 mod 4), 2134(2 mod 4) e 1423(3 mod 4).

Richiesto da:

Se lo desideri, puoi generare altri valori "mod 90 °" legali invece di 0 1 2 3. Quindi 8 va bene invece di 0 e -1 va bene invece di 3, ecc.

In realtà ci sono molti set di numeri per i quali funziona. Ho trovato questi con questo programma Python:

def f(a,b,c,d):
    return int("%i%i%i%i"%(a,b,c,d))
for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                candidate = f(a,b,c,d) % 4 == 0
                candidate &= f(b,d,a,c) % 4 == 1
                candidate &= f(d,c,b,a) % 4 == 2
                candidate &= f(c,a,d,b) % 4 == 3
                if candidate:
                    print("%i, %i, %i, %i"%(a,b,c,d))

Sebbene il programma produca 0s (che probabilmente non funzionerebbe), le soluzioni valide sono nella forma

ab
cd

Dove a∈{4,8}, b∈{3,7}, c∈{1,5,9}, d∈{2,6}. IE (a,b,c,d)∈{4,8}×{3,7}×{1,5,9}×{2,6}che è 24 soluzioni.


7
Molto intelligente. Onestamente ho pensato che una regola extra fosse innocua.
Calvin's Hobbies

4
@Everybody Nota che questo non è il programma più piccolo possibile. Un 2x1 è possibile ed è il più piccolo possibile. Quindi mettiti al lavoro!
Justin

1
@isaacgYour score is w*h, the area of your rectangle. Newlines are excluded. In other words, code-golf, newlines not counted.
undergroundmonorail

2
@Quincunx Bene, allora pubblicalo!
tomsmeding,

1
Supponendo che la lingua qui stampi semplicemente l'ultimo numero che valuta, non credo che esista una soluzione 1 * n (un numero) per nessuno n. Questo perché la parità dell'intero numero è uguale alla parità della sua cifra più a destra, ma le rotazioni distanti 90 gradi devono produrre parità diverse. Quindi, 2*2è il minimo per questo approccio.
xnor

30

Python - 23 x 23 = 529

Ok, questa domanda ha già un vincitore, ma non esiste ancora una soluzione Python. Quindi ci ho pensato - pesantemente! - e ha trovato un modo per far funzionare il printcomando voluminoso in qualsiasi direzione senza produrre errori quando analizzato da una delle altre direzioni.

La svolta fu la seguente linea:

'"\'';forward_code;"';backward_code;""\'"''

Mentre forward_codeviene eseguito, backward_codefa parte di una stringa e quindi non viene stampato. Questo è esattamente il contrario quando si legge all'indietro.

Quindi, combinato con altre due direzioni e messo a punto per ottenere la corrispondenza corretta di tutte le virgolette, ho la seguente soluzione:

''"''""''"''"''"'"''""'
"  ""                 "
"  \\                 "
'"\'';print 1;"'""\'"''
'"\''"';3 tnirp;""\'"''
"  ;""                "
"  p'                 "
'  r;                 '
'  i2                 '
"  n                  "
"  tt                 "
'   n                 '
'  4i                 '
"  ;r     .-=<>=-.    "
' \"p    /__----__\   '
"  ';'  |/ (')(') \|  "
"  ""    \   __   /   "
'  ""    .`--__--`.   '
"  \\   /    :|    \  "
'  ''  (_)   :|   (_) '
'  ""    |___:|____|  '
"  ''    |_________|  "
''"''""''"''"''"'"''""'

Modifica: ho trovato un modo per gestire tutto quello spazio bianco. ;)


C'è un modo per inserire anche p=printil file, dal momento che hai così tanto spazio bianco al momento? (Python 3, ovviamente)
isaacg,

@isaacg: non la penso così. Anche la definizione p=printè lunga. E ancora più importante: non è possibile riutilizzare pdopo aver ruotato il codice!
Falko,

Credo che tu abbia ragione. Sono due cattivi, però.
isaacg,

12
Nominato: Premio Best Use of Whitespace.
primo

24

BASIC, 64

Non vincerà, ma eccolo qui comunque. (Testato in Chipmunk Basic )

?0:END:?
:::::::1
D:::::::
N::::::E
E::::::N
:::::::D
3:::::::
?:DNE:2?

Nota: ?è una scorciatoia per PRINTvari dialetti di BASIC. Sebbene ci siano molti errori di sintassi nel codice, l' ENDistruzione nella prima riga impedisce loro di essere visti dall'interprete.


1
In realtà, i tuoi punteggi sono 64 e 16, rispettivamente. Le newline non contano. Inoltre, perché non dividere la risposta?
Giustino,

Oh, mi sono perso un po '. Avrei diviso le risposte se non avessero occupato l'ultimo posto in comune. Altrimenti non sembra avere molto senso :-)
ossifrage schizzinoso

Non sei più l'ultimo :-)
Justin l'

Ti darei punti bonus per ottenere un bel numero rotondo di personaggi. Il +1 effettivo è per l'uso creativo di END:):
CompuChip,

21

Pyth , 9 caratteri (3x3)

0 1

3 2

In Pyth, tutto viene stampato per impostazione predefinita, a meno che non sia preceduto da uno spazio. Le righe dopo la prima riga sono per l'input dell'utente e non vengono valutate in questo programma.

Un altro modo per ottenere 9 personaggi:

"0"
3 1
"2"

Pyth 1.0.5 , 4 caratteri

Mentre le recenti modifiche a pyth hanno reso più difficile la generazione di numeri a 2 cifre (una modifica che sto considerando di ripristinare), le versioni precedenti di Pyth hanno una facile generazione di numeri a due cifre, che, combinata con la stampa implicita e il fatto che tutte le righe tranne la prima vengono ignorati, fornisce la seguente soluzione:

32
41

Stampa 32,21,14,43.


Bene, è solo divertente. +1
seequ

Merda, speravo non fosse così facile. Nella riga centrale mancano 3 caratteri, ma suppongo che ciò sia dovuto alla formattazione automatica qui.
Calvin's Hobbies

@ Calvin'sHobbies Siamo spiacenti, vedo. Mi ha spezzato gli spazi finali.
isaacg,

@Quincunx Oh, ho perso quella parte del punteggio. Grazie per le correzioni.
Isaacg,

18

Befunge, 16

0.@1
@@@.
.@@@
3@.2

Spiegazione: Cifre da 0per 9inserire il numero corrispondente nello stack, .estrarre un valore dallo stack e stamparlo come intero e @terminare il programma.

(testato qui )


Questo non genera il numero di volte in cui è stato ruotato in senso antiorario?
Seequ,

@TheRare Sì. Lo fa. Questo è ciò che dovrebbe fare.
Giustino,

1
Mi sembra del tutto cieco. Prendi un +1 per questo.
Seequ,

Befunge !!! Comunque la mia lingua preferita di tutti i tempi per sempre per sempre così!
Steffen,

16

Piet, 49

Un programma Piet

Ho fatto un punto solo per usare i colori giallo e rosso e per provare a renderlo approssimativamente simmetrico. Quando viene ruotato, stampa 0, 1, 2 o 3. Uscire dal programma in Piet è difficile e, purtroppo, occupa circa la metà dello spazio nella foto.


1
Sembra lo strumento giusto per il lavoro.
Robert Fraser,

O_o, ho pianto scoprendo questo linguaggio di programmazione! Proprio adesso. Bellissimo. In tanti modi! Grazie!
Steffen,

15

GNU cc , 6 (3x2)

Penso che questa sia la risposta più breve per non richiedere il "relax mod 90 °":

3z1
0p2

Uscite 0, 1, 2o 3per ogni rotazione.

Per il 0, 2e le 3rotazioni, il ppop semplicemente e stampa l'ultimo numero letterale che è stato inserito nella pila. Per la 1rotazione, zspinge la profondità della pila corrente (1) nella pila, quindi si papre e la stampa.


1
Quindi anche 311 / 0p2 funzionerebbe?
Neil,

@Neil Sì, buono. Tuttavia, ciò non influisce sul punteggio del golf :)
Digital Trauma,

Influisce sul punteggio del golf, ma negativamente, poiché le newline non vengono conteggiate, ma le barre.
M.Herzkamp,

@ M.Herzkamp La mia ipotesi era che Neil intendesse 311\n0p2, dove si \ntrova un personaggio newline. Altrimenti sarebbe privo di significato nel contesto di DC.
Trauma digitale

10

GolfScript, 9 (3x3)

0}1
} }
3}2

Una specie di abuso delle regole. Il }accade per terminare il programma se non c'è corrispondenza {, e il contenuto della pila vengono stampate a fine ciclo.


Non dimenticare di contare la newline come personaggio.
isaacg,

2
@isaacgYour score is w*h, the area of your rectangle. Newlines are excluded. In other words, code-golf, newlines not counted.
undergroundmonorail

Non sapevo che }potesse essere sbilanciato. Bel trucco.
Peter Taylor,

9

JavaScript, 4

03
12

Quando si esegue questo programma (o una rotazione di questo programma) in una console javaScript, solo l'ultima riga viene valutata ed eco nella console.

Così:

12 modulo 4 == 0
01 modulo 4 == 1
30 modulo 4 == 2
23 modulo 4 == 3

Ecco tutti i programmi 2x2 simili che funzionano anche:

03
12

03
16

03
52

03
56

03
92

03
96

07
12

07
16

07
52

07
56

07
92

07
96

43
12

43
16

43
52

43
56

43
92

43
96

47
12

47
16

47
52

47
56

47
92

47
96

83
12

83
16

83
52

83
56

83
92

83
96

87
12

87
16

87
52

87
56

87
92

87
96

In altri termini,

ab
cd

dove a è in [0,4,8], b è in [3,7], c è in [1,5,9] e d è in [2,6]


8

CJam / GolfScript - 3 * 3

2;3
;7;
1;0

Il punto e virgola fa apparire il numero precedente, quindi viene stampato solo l'angolo in basso a destra.


6

Aheui , 8

바몽희뷸
뷷희몽반

Dato che Aheui non ha una lettera che spinge 1 nella pila, ho deciso di stampare 0, 5, 2 e 3.

Spiegazione: 바 e 반 spingono 0 e 2, rispettivamente, sulla pila e spostano il cursore a destra di un carattere. 뷸 e 뷷 spingono 5 e 3 rispettivamente sulla pila e spostano il cursore verso il basso di due caratteri. 몽 apre e stampa il numero nella pila e sposta il cursore verso l'alto di un carattere. 희 termina il programma.


5

JavaScript

(Inserito nella console del browser, shell o altro REPL, quindi il risultato viene stampato)

1+2
-3-
4+5

Dovrebbe funzionare per qualsiasi altra lingua con espressioni, newline non significative e stampa automatica del risultato.


2
Mi piace l'idea alla base, ma non stampa sempre 1 (mod 4)?
zennehoy,

2
Una variazione più semplice potrebbe essere '2,3\n,0,\n1,0'.
Appassionato del

Dà risultati diversi quando viene ruotato. @Cory, è intelligente! Sono troppo abituato a lavorare in una lingua senza l'operatore virgola.
lrn,

@lrn Sì, dà risultati diversi, ma non è questo il requisito. Il programma deve stampare 0 (mod 4) quando non viene ruotato e 1, 2 o 3 (mod 4) quando viene ruotato il rispettivo numero di volte ...
zennehoy

La seconda nota del poster originale consente qualsiasi valore per le versioni ruotate, purché siano distinte.
lrn,

5

Matlab / Octave - 144 100

Golfato: 10 x 10 = 100

....d.....
....i.....
....s.....
... p2 ...
disp  1...
...3  psid
... 4p ...
.....s....
.....i....
.....d....

Soluzione alternativa: 15 x 15 = 225

.......d.......
.......i.......
.......s.......
...    p    ...
...         ...
...    4    ...
...    .    ...
disp 1...3 psid
...    .    ...
...    2    ...
...         ...
...    p    ...
.......s.......
.......i.......
.......d.......

La prima soluzione può essere ridotta alle dimensioni 8x8, se gli operatori verticali e orizzontali 'disp' condividono la lettera 'p'? ...d.... ...i.... ...s2... disp 1.. ..3 psid ...4s... ....i... ....d...
AMK,

@AMK: Sfortunatamente, questo produce un errore di sintassi in linea ..3 psid. Sono necessari almeno tre punti all'inizio di ogni riga per indicare un'interruzione di riga e ignorare i caratteri rimanenti.
Falko,

5

Perl 5x7 (35)

1+p+t+1
-print+
1+i+i+1
+tnirp+
1+t+p+1

Un po 'in ritardo alla festa. Il solitario -determina quale numero è stampato.


4

JavaScript, 3

2
1
4

Funziona ... nella base 7.

Versione base 9:

2
7
0

Spiegazione

Quando eseguito in modo interattivo, ad esempio da una console di debug, verrà emesso il valore dell'ultima istruzione / espressione.

4 7 = 4 100 (mod 4 )
412 7 = 205 101 (mod 4 )
2 7 = 2 102 (mod 4 )
214 7 = 109 103 (mod 4 )

Soluzioni simili potrebbero essere trovate per qualsiasi base dispari.


Questo è stato segnalato, ma non capisco la domanda o la risposta, quindi ho dovuto saltare. Sarebbe bello se i downvoter lasciassero un commento che spiegava i loro downvotes.
Rainbolt,

@Rusher Sospetto che non abbiano capito la base a 7 bit.
primo

3

Befunge, 12 (6x2)

Sono riuscito a trovare un leggero miglioramento rispetto alla risposta esistente di Befunge sfruttando al massimo la natura bidimensionale di Befunge e facendo in modo che il percorso del codice si muovesse verticalmente in due degli orientamenti.

0.@.1v
v3.@.2

Provalo online: avvio 0 , rotazione 1 , rotazione 2 , rotazione 3 .


2

Marbelous, 7 * 14 = 98

.. \/ \/ .. ..
.. 31 \\ 32 \/
\/ \\ \/ \\ \/
\/ 30 \\ 33 ..
.. .. \/ \/ ..

Ti aspetti che ogni cella rimanga intatta quando viene ruotata?
Sparr,

2

Argh! / Aargh! (4 * 4 = 16)

Cos'era quello di usare lo strumento giusto per il lavoro? Non ci sono commenti (nella lingua in generale).

L'intera famiglia di programmi (generata in J: ((|.@:|:) ^: (i. 4)) >'hpqh';'q01p';'p32q';'hqph'o ((|.@:|:) ^: (i. 4)) 4 4 $ 'hpqhq01pp32qhqph')

hpqh
q01p
p32q
hqph

ruotato una volta:

hpqh
q12p
p03q
hqph

ruotato due volte:

hpqh
q23p
p10q
hqph

ruotato tre volte:

hpqh
q30p
p21q
hqph

Per spiegare questo, potrebbe essere meglio guardare una versione "rientrata" (che funziona anche in tutte le rotazioni):

hhpq h
  0  h
q   1p
p3   q
h  2  
h qphh

Questa versione mostra che il programma è composto da 4 parti separate, una per ogni singola rotazione.

  • h - imposta il flusso di controllo a sinistra

  • p - stampa l'elemento in dati / codice raster sottostante

  • q - uscire dal programma


2

Floater - 9 × 5 = 45

inserisci qui la descrizione dell'immagine

Stampa 4, 1, 2 o 3 sulla console.

Si noti che "Nero" è un'istruzione valida (NOP) ed è sintattico. Senza di essa, non riesce a trovare la posizione di partenza. Pertanto, tutte le posizioni nel rettangolo sono occupate.


1

Elemento, 2x3 = 6

1*
`2
3 

Questo è un miglioramento rispetto alla soluzione ingenua 3x3, che ha una `al centro con un numero su ciascun lato. Il caso 0, mostrato sopra, è il più interessante, dal momento che *viene usato per moltiplicare il 3 per nulla per ottenere 0. A parte questo, non è così complicato.

Se trovi lo spazio imbarazzante, puoi sostituirlo con praticamente qualsiasi altro personaggio, escluso []{}`_.

Per riferimento, ecco le altre tre rotazioni:

case 1
*2 
1`3

case 2
 3
2`
*1

case 3
3`1
 2*

0

Chip, (2x5) 10

b~
+a
~t
e*
 f

*attiva tutti gli elementi vicini: nord, est, sud e ovest (sorgente)
~se non attivato da ovest, attiva il vicino est (NOT-gate) (mai attivato qui)
ttermina l'esecuzione dopo aver stampato il byte corrente
aimposta il bit 0x01dei
bset di output il bit 0x02dell'uscita
eimposta il bit 0x10dell'uscita
fimposta il bit 0x20dell'uscita
+se attivato da qualsiasi vicino, attiva tutti gli altri vicini (filo)

Il chip richiede il -wflag (per consentire l'esecuzione senza input) o un input per l'esecuzione.

Stampe 0, 1, 2, o 3in ASCII. Se i punti di codice 0x00a 0x03sono desiderati, rimuovere la ee f, quindi spostare lo spazio per riempire il vuoto.


0

Japt , 3 * 1 = 3 byte

5zB

Provalo online: così com'è , ruotato una volta , due volte , tre volte .

Uscite 0, 5, 2, 11 rispettivamente.

La variabile Bcontiene il valore 11 ed Number.z(other)è la divisione del piano (apparentemente tutti cercavano: p). Per il codice multilinea, l'ultima riga viene passata all'output, che qui è semplicemente una costante.


2 * 2 = 4 byte

2J
1T

Provalo online: così com'è , ruotato una volta , due volte , tre volte .

Uscite 0, 21, 2, -1 rispettivamente.

Tcontiene 0 e Jcontiene -1.

Il trucco è che, se due letterali o variabili vengono messi fianco a fianco, viene inserita una virgola e l'output è solo l'ultimo.

La soluzione JS 2 * 2 funziona anche in Japt.

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.