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!

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.

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

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.

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

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.

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.

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 )

Piet, 49

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.

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.

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.

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]

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.

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.

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.

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

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.

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 ₇ = 4 ₁₀ ≣ 0 (mod 4 )
412 ₇ = 205 ₁₀ ≣ 1 (mod 4 )
2 ₇ = 2 ₁₀ ≣ 2 (mod 4 )
214 ₇ = 109 ₁₀ ≣ 3 (mod 4 )

Soluzioni simili potrebbero essere trovate per qualsiasi base dispari.

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 .

Marbelous, 7 * 14 = 98

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

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

Floater - 9 × 5 = 45

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.

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*

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.

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.