Una formica cammina lungo i bordi (non le facce) di un cubo wireframe. Ogni vertice che incontra lo presenta con una forcella da cui si diramano due nuovi bordi. La formica sceglie da che parte girare - lefto right. Queste direzioni sono relative alla formica, che si trova di fronte al vertice ed è al di fuori del cubo. Il tuo obiettivo è determinare, dalla sequenza left/ rightscelte della formica, se finisce nella stessa posizione in cui è iniziata.

Ad esempio, se la formica gira a sinistra quattro volte ( left left left left), avrà attraversato un quadrato in senso antiorario e si è conclusa nello stesso punto in cui è iniziata. Ma, se va left left left left right, finirà in un punto diverso sul cubo. Inoltre, se va left right right right left, finisce sul suo bordo iniziale ma rivolto verso il vertice opposto, che non conta come la stessa posizione.

Il percorso della formica potrebbe ripetere i bordi, incluso il bordo da cui è iniziato, ma ciò che conta è dove finisce dopo l'intera sequenza.

Scrivi una funzione con nome che accetta la sequenza di turni della formica ed emette se la formica è tornata alla sua posizione iniziale dopo la sequenza. L'assegnazione di una funzione senza nome a una variabile è sufficiente per renderla una funzione con nome.

(Modifica: se la tua lingua non è in grado di creare una funzione con nome, può invece implementare la funzione con input e output tramite STDIN / stampa o stack. Se ciò non è possibile, rendilo uno snippet in cui input e output sono salvati in variabili.)

Ingresso

Una sequenza di left/ rightdecisioni di lunghezza 0per 31inclusiva, rappresentati in un formato di vostra scelta. Potrebbe trattarsi di una stringa di lettere R/ L, un elenco di numeri 1/ -1o una matrice di booleani. Niente di strano come averli come nomi di metodi o stringhe utili per il tuo codice.

Si prega di pubblicare i casi di test nel proprio formato se è diverso dai casi di test di seguito.

Produzione

True/ False, 0/ 1o analoghi nella tua lingua.

Criteri vincenti

Vince il minor numero di byte. Ricorda, devi dare una funzione con nome. Puoi avere del codice al di fuori della funzione, ma contano anche quei byte. La tua funzione dovrebbe comportarsi correttamente se chiamata più volte.

Casi test

True casi (uno per riga, il secondo è un elenco vuoto):

1 1 1 1

-1 -1 -1 -1
1 -1 1 -1 1 -1
1 1 -1 -1 1 1 -1 -1
-1 1 1 -1 -1 1 1 -1
1 1 1 -1 -1 -1 -1 1
1 -1 -1 1 -1 -1
1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1
-1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

False casi (uno per riga):

1
1 1
1 1 1
-1 1
1 -1 -1 -1 1
1 -1 -1 1 1
-1 1 -1 1
1 1 1 1 -1
-1 -1 1 -1 1 -1 -1 1
1 -1 1 1 1 1 -1 -1 -1 1 1 -1 -1 -1

Ecco gli stessi casi di test con L"se R".

True casi:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False casi:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

Sfida di credito extra

Stessa cosa, ma con un dodecaedro anziché un cubo. Vedi Hunt the Wumpus per idee.

GolfScript, 24 caratteri (19 solo per il corpo della funzione)

Math FTW!

{3,.@{[+~@\{@}*~]}/=}:f;

Prova questa soluzione online.

Questa funzione accetta come input un array binario (0 per sinistra, 1 per destra) e restituisce 1 per true e 0 per false.

Concettualmente, funziona ruotando il cubo in modo che la formica mantenga sempre la stessa posizione e orientamento e controllando se il cubo alla fine finisce con lo stesso orientamento in cui era iniziato.

In particolare, possiamo rappresentare le svolte a sinistra e a destra come due mappe lineari in tre dimensioni, in cui una svolta a sinistra corrisponde a una rotazione di 90 ° attorno all'asse x , ovvero la mappa ( x , y , z ) → ( x , z , - y ) e una svolta a destra corrisponde a una rotazione di 90 ° attorno all'asse y , ovvero la mappa ( x , y , z ) → ( z , y , - x ).

All'inizio della funzione, impostiamo semplicemente un vettore a tre elementi contenente i valori positivi distinti (1, 2, 3), applichiamo ad esso la sequenza di mappe di rotazione e controlliamo se il vettore risultante è uguale a quello iniziale.

(In effetti, per salvare alcuni caratteri, in realtà trasformo le coordinate in modo che il vettore iniziale sia (0, 1, 2) e le mappe siano ( x , y , z ) → ( x , z , −1− y ) e ( x , y , z ) → ( z , y , −1− x ), ma il risultato finale è lo stesso.)

Ps. Grazie a fiero haskeller per aver individuato il bug nella versione originale di questa soluzione.

Perl, 58 caratteri

Come richiesto nei commenti, ecco la stessa soluzione trasferita a Perl. (Questa versione utilizza effettivamente le coordinate non trasformate, poiché la trasformazione non salva alcun carattere in Perl.)

sub f{@a=@b=1..3;@a[$_,2]=($a[2],-$a[$_])for@_;"@a"eq"@b"}

Prova questa soluzione online.

Bonus: Formica su un dodecaedro (GolfScript, 26 caratteri)

{5,.@{{2*2%[~\]}*(+}/=}:f;

Prova questa soluzione online.

Come la funzione ant-on-a-cube sopra, questa funzione accetta come input un array binario (0 per sinistra, 1 per destra) e restituisce 1 se la formica finisce nella stessa posizione e orientamento nella sua posizione iniziale, oppure 0 altrimenti.

Questa soluzione utilizza una rappresentazione leggermente più astratta rispetto alla soluzione cubica sopra. In particolare, si avvale del fatto che il gruppo di simmetria rotazionale del dodecaedro è isomorfo al gruppo alternato A ₅ , cioè al gruppo di permutazioni pari di cinque elementi. Pertanto, ogni possibile rotazione del dodecaedro (che mappa i bordi ai bordi e i vertici ai vertici) può essere rappresentata in modo univoco come una permutazione di una matrice di cinque elementi, con rotazioni consecutive corrispondenti all'applicazione delle corrispondenti permutazioni in sequenza.

Pertanto, tutto ciò che dobbiamo fare è trovare due permutazioni L e R che possano rappresentare le rotazioni sinistra e destra. In particolare, queste permutazioni devono essere di 5 cicli (in modo che applicarle cinque volte ritorni allo stato originale), non devono essere poteri l'uno dell'altro (cioè R ≠ L ⁿ per qualsiasi n ) e devono soddisfare la relazione ( LR ) ⁵ = (1), dove (1) indica la permutazione dell'identità. (In effetti, questo criterio afferma che il percorsoLRLRLRLRLR deve tornare alla posizione originale.)

Fissare la permutazione L come un semplice spostamento del barilotto a sinistra, ovvero mappatura ( a , b , c , d , e ) → ( b , c , d , e , a ), poiché può essere implementata in GolfScript in soli due chars ( a ), poiché ha anche un'implementazione GolfScript relativamente compatta. (In effetti, lo implemento prima interfoliando gli elementi con(+ ), troviamo che ci sono cinque possibili scelte per la permutazione R. Tra questi, ho scelto la mappatura ( a , b , c , d , e ) → ( c , e , d , b ,2*2% per ottenere ( a , c , e , b , d ), quindi scambiando gli ultimi due elementi con [~\], e infine applicando la permutazione L incondizionatamente per spostare un alla fine.)

Il link demo online sopra include alcuni casi di test di percorsi validi su un dodecaedro che ritornano all'origine, come:

           # empty path
1 1 1 1 1  # clockwise loop
0 0 0 0 0  # counterclockwise loop
1 0 0 0 0 1 1 0 0 0 0 1  # figure of 8
1 0 1 0 1 0 1 0 1 0      # grand circle
1 0 0 0 1 0 0 0          # loop around two faces 
1 0 0 0 1 1 1 0 1 0 1 0 0 0 1 1 1 0 1 0  # Hamilton cycle

Python, 68

Prende un elenco di 1 e -1. Basato su rotazioni 3D: controlla se il punto (3,2,1) finisce nella stessa posizione dopo aver applicato una serie di rotazioni. Esistono due possibili rotazioni, corrispondenti a 1 e -1. Ognuno è fatto permutando due coordinate e cambiando il segno di una di esse. Le coordinate esatte da cambiare e il segno da permutare non sono importanti.

def f(l):
 p=[3,2,1]
 for d in l:p[d],p[0]=-p[0],p[d]
 return[3,2]<p

EDIT: questa è in realtà la stessa soluzione di "Perl, 58".

matematica

Ispirato alla soluzione di Ilmari Karonen. Il gruppo di simmetria rotazionale di un cubo è isomorfo rispetto a S ₄ .

Cubo, 51 byte

Fold[Part,r=Range@4,{{2,3,4,1},{3,4,2,1}}[[#]]]==r&

Prende una lista di 1s e -1s come input.

Provalo online!

Dodecaedro, 55 byte

Fold[Part,r=Range@5,{{2,3,4,5,1},{3,5,4,2,1}}[[#]]]==r&

Prende una lista di 1s e -1s come input.

Provalo online!

C (cc) , 118 116 107 105 byte

-2 byte grazie a ceilingcat

f(char*s){char*p,n[]="@ABCDEFG",y;for(;*s;s++)for(p=n;*p;*p++^=*s^82?y%2+1:4-(y&2))y=*p/2^*p;y=n[2]==66;}

Provalo online!

Supponiamo di aver dato al cubo le seguenti coordinate:

            (1,1,1)       (1,1,0)
          G +--------------+ C
           /|             /|
          / |            / |
         /  |    (0,1,0)/  |
(0,1,1) +--------------+ D |
      H |   |          |   |
        |   |          |   |
        | F +----------|---+ (1,0,0)
        |  /(1,0,1)    |  / B           x
        | /            | /           y / 
        |/             |/            |/  
      E +--------------+ A      z ---*   
        (0,0,1)       (0,0,0)

Se iniziamo dall'angolo D, passare a C o H può invece essere pensato come rotazione del cubo attorno a noi. Muoversi a destra significherebbe ruotare in senso antiorario attorno all'asse Z, e spostarsi a sinistra significherebbe ruotare in senso orario attorno all'asse X. Queste sono le uniche due rotazioni di cui dobbiamo preoccuparci. Poiché ogni rotazione è esattamente di 90 gradi, possiamo immaginare che gli angoli "scivolino" lungo i bordi. Per spostarsi a destra, questo significa A -> B, B -> C, C -> D, D -> A con l'altro lato che fa E -> F ecc. Per spostarsi a sinistra, invece otteniamo A -> E, E - > H ecc.

Poiché ogni angolo scorre solo lungo un bordo, ciò significa che solo una delle dimensioni di ciascun punto cambia per ogni rotazione. Quando B si sposta su C, cambia solo il suo componente y, e quando H si sposta su D, cambia solo il suo componente z, e così via. Inoltre, poiché le coordinate sono limitate a 0 e 1, possiamo considerare ogni punto come un numero binario, con il bit appropriato capovolto al movimento.

Possiamo vedere che per un movimento a destra, A e C capovolgono le loro x, mentre D e B capovolgono le loro y. Se cambiamo prospettiva per guardare su quel lato della testa del cubo e ignoriamo il componente z (che comunque non cambia per questa rotazione) otteniamo:

D (0,1)         C (1,1)
 +-------------+
 |             |
 |             |
 |             |
 |             |
 |             |
 |             |
 +-------------+
A (0,0)         B (1,0)

Emerge un modello: per i punti che cambiano la loro x, x == y, mentre è vero il contrario per i punti che cambiano la loro y. Questo vale per l'altro tipo di rotazione, ma con z invece di x.

In altre parole:

Right
    if (x == y) x = !x
    if (x != y) y = !y

Left
    if (z == y) z = !z
    if (z != y) y = !y

Ora possiamo facilmente passare attraverso tutte le rotazioni e alla fine vedere se la D finale corrisponde alla nostra D. iniziale

Memorizzare ogni punto come un singolo numero è un dato, ma in C l'assegnazione di un array di caratteri è molto più compatta di un array int. Ci prendiamo cura di scegliere i caratteri i cui tre bit inferiori corrispondono a 000..111, rendendo possibile ignorare il resto dei bit. Capovolgere le coordinate è semplicemente una questione di XOR con la maschera di bit appropriata.

Python - 110, 150

Visualizza un elenco di numeri interi con -1per girare a sinistra, 1per girare a destra.

Cubo, 110:

def f(l):
    c,p='07'
    for d in l:a="100134462634671073525275"[int(c)::8];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

Test:

l=map(int,'1 1 1 1'.split())
print f(l)

Dodecaedro, 150:

def f(l):
    c,p='0J'
    for d in l:a="I5H76E8BBA8F76543100JI0J21D3A5C7E9CJI2132H4GF94C6D98AHGBEDGF"[int(c,36)::20];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

Marbelous 188

Furto spudorato dell'algoritmo di Ilmari Karonen allo scopo di mostrare una nuova lingua.

Questo script prevede una stringa di 0x00 per sinistra e 0x01 per destra su stdin, seguita da una 0x0A (newline). Emette "0" per un caso non riuscito e "1" per un successo.

......@5@3FF
@0@1@2\\]]@5
010203@4=A@4
&0&0&0&0/\
MVMVMVMV..
@0@1@2@3..!!
:MV
}2}2}1}0}1}0}3
&0&1&0&1~~~~<A@P
{0{1{1{0&1&0=0&1
}0}1}2@P{2{2&030
=1=2=3&2FF}3..//
&2&2&231&2{3
\/\/\/&2!!..//

esempio di esecuzione:

# echo -e "\x0\x0\x0\x1\x0\x0\x1\x1\x0\x1\x0\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1" | marbelous.py ant-on-a-cube.mbl
1

Python 2 , 57 byte

f=lambda l:reduce(lambda n,x:n%4*64+n/4*16**x%63,l,27)<28

Provalo online!

Questo utilizza la rappresentazione della permutazione

0: abcd -> dabc
1: abcd -> dcab

dove sinistra e destra (0 e 1) corrispondono a cicli di lunghezza-4 su 4 elementi. Esaminiamo l'input applicando la permutazione indicata e controlliamo se il risultato è uguale al valore iniziale.

Iniziamo a,b,c,dcome l'elenco di quattro elementi 0,1,2,3. Li compattiamo in un singolo numero base-4 n=abcd, con il valore iniziale n=27corrispondente a 0123in base 4. Istanziamo ciascuna la permutazione aritmeticamente su n.

Poiché entrambi i risultati iniziano con d, possiamo fare n%4per estrarre d, quindi n%4*64per spostarlo nella giusta posizione d___. Le altre cifre sono abc, estratte come n/4. Dobbiamo inserirli nei tre valori inferiori.

Per la direzione x=0, inseriamo così abccom'è, e per x=1, li ruotiamo come cab. La rotazione può essere realizzato come *16%63, che prende abca abc00acab . ( %63Andrebbe storto a==b==c==3, ma questi valori non sono possibili.) Dato che semplicemente fare %63è un no-op, l'espressione dipendente dalla direzione *16**x%63dà abco cabcome richiesto.

Python 2 , 55 byte

f=lambda l:reduce(lambda n,x:n^(n*8%63|7*8**x),l,10)<11

Provalo online!

Haskell, 104 103 99 97 96/ 67 64 caratteri

Penso che l'equivalente di destra / sinistra sarebbe un tipo di dati Direzione in questo modo:

Direction = R | L

così ho assunto nella mia risposta che erano disponibili.
modificare: realtà capito che i booleani porterebbero a un codice più breve. True rappresenta una svolta a sinistra e False rappresenta una svolta a destra (anche se, tecnicamente, il codice funzionerebbe allo stesso modo se fosse capovolto; è simmetrico)

96 caratteri:

m[p,l,r]b|b=[p%l,7-r-l,r]|0<1=[p%r,l,7-r-l]
p%x|odd$div p x=p-x|0<1=p+x
g l=foldl m[0..2]l<[0,2]

g è una funzione che, dato un elenco di Direzioni, restituirebbe il tempo in cui la formica non è tornata al suo posto.

spiegazione della rappresentazione della posizione: la posizione della formica è codificata come una tre tupla di numeri interi. il primo intero rappresenta il vertice verso cui si sta dirigendo la formica. il primo bit rappresenta se il vertice è nella metà su / giù, il secondo è la metà sinistra / destra e il terzo è la parte posteriore / anteriore. questo viene fatto in modo che il passaggio da un vertice a un vertice vicino possa essere eseguito capovolgendo un bit.

il secondo numero intero è la quantità che il vertice della formica cambierebbe se andasse a sinistra. per esempio, se la formica era al vertice 3 e il secondo numero intero era 4, che dopo aver girato a sinistra il vertice sarebbe 7. si noti che questa sarebbe sempre una potenza di 2, perché esattamente un bit viene capovolto spostando un vertice.

il terzo numero intero è lo stesso, ma per andare a destra; so che questo può essere calcolato dai primi due, ma non so come. se hai un'idea, per favore dimmelo.

qualcosa da notare è che quando si gira a sinistra, il terzo numero intero rimarrebbe lo stesso, e il secondo diventerebbe quello tra 1 2 e 4 che non era né il secondo numero intero né il terzo, che risulta essere uguale a 7 - secondo numero intero - terzo numero intero.

ho scelto questo modo di rappresentare la posizione perché (come è stato appena affermato nel paragrafo precedente) era banale calcolare la posizione successiva.

spiegazione delle funzioni:

la funzione (%) è la funzione che accetta il vertice corrente e la quantità per cambiarlo e lo cambia. arriva al bit che sta per cambiare e lo gira (in modo molto numerico).

la funzione m è una funzione che prende la posizione della formica e la direzione e restituisce la nuova posizione usando la nota che abbiamo notato in precedenza.

quindi la funzione m viene combinata usando foldl (che è reduceun po ' come in javascript, ma un po' più espressivo) per creare la funzione g, la risposta a questa domanda.

Haskell, 64 caratteri

ispirato alla risposta di @ alphaalpha, ecco la sua versione portata su haskell:

m[a,b,c,d]p|p=[b,c,d,a]|0<1=[b,d,a,c]
g l=foldl m[0..3]l<[0,1,3]

modifica: ora mi sento incredibilmente stupido a causa della risposta di lmari Karonen. forse porterò la sua risposta a haskell. un'altra modifica: non sentirsi così stupidi quanto la sua risposta è sbagliata
modifica: passare dall'usare effettivamente le tuple all'utilizzo degli elenchi come la loro Ordistanza e lo [ ... ]zucchero sintattico lo rende più breve

Haskell , 53 byte

f=(<28).foldl(\n x->mod n 4*64+mod(div n 4*16^x)63)27

Provalo online!

Stessa logica della mia risposta Python , anche pensato mode divsono più lunghi da scrivere.

Haskell , 58 byte

r=[1..3]
f=(==r).foldl(\[x,y,z]->(!!)[[x,-z,y],[-z,y,x]])r

Provalo online!

APL (Dyalog Unicode) , 22 byte ( Adám's SBCS )

f←{x∊(-@3∘⌽⌽)/⍵,x←⊂⍳3}

Provalo online!

H.PWiz ha suggerito che l'inversione dei passaggi non fa differenza e ciò ha comportato -2 byte.

Bene, questo è imbarazzante, poiché doveva essere molto più corto di GolfScript. Almeno ci ho provato.

La funzione è denominata fe, nei casi di test, 1rappresenta una svolta a sinistra (booleano true) e 0rappresenta una svolta a destra (booleano false). ⍬rappresenta l'elenco vuoto.

APL (Dyalog) , 21 byte

f←{x≡(↓∪⊢∘⌽)/⍵,x←⊂⍳4}

Provalo online! (Utilizzando l'ambiente di test di Erik la risposta dell'Outgolfer )

Prendo a destra e sinistra come 1e 2. Questo utilizza le seguenti permutazioni di abcd:

1 : bcda
2 : cdba

Applico le permutazioni corrispondenti a 1ed 2a ⍳4 : 1 2 3 4, e controllare se è invariato

Bash , 71 65 byte

f()(a=1234;for i;{ a=`tr 1-4 4$[$i?123:312]<<<$a`;};((a==1234));)

Provalo online!

Come molte risposte precedenti, utilizza una rappresentazione del gruppo di rotazioni del cubo generato da 1234-> 4123 e 1234-> 4312. Utilizza numeri anziché lettere in modo da poter utilizzare un operatore ternario con un'espansione aritmetica. Si aspetta il suo input come 0 e 1 separati da spazi e output tramite il codice di uscita.

6 byte salvati grazie al commento di @ manatwork!

Brainfuck , 119 byte, 137 byte

Utilizza il fatto che il gruppo di rotazione del cubo è isomorfo $S_4$. Brainfuck non ha alcuna funzione, nominata o meno, quindi questo è un programma completo che accetta input tramite STDIN e output su STDOUT. (Se insisti su una variabile, fai finta che il valore della cella su cui termina il programma sia una variabile.)

Cubo, 119 byte

++++>+++>++>+>,[+++[->+++<]<<<<[->>>>+<<<<]>[>]<+[[-]<[->+<]<<<[->>>+<<<]>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

Provalo online!

++++>+++>++>+    Initialize tape as 4 3 2 1

>,[              For each input byte:

  +++[->+++<]       Add 3 and multiply by 3; if input is R, this will be 255

  <<<<[->>>>+<<<<]  Move first number to end (BCDA)

  >[>]<+[           If input wasn't R:

    [-]                Zero input cell (which is now negative 18)

    <[->+<]            Move previously moved number one slot further (BCD_A)

    <<<[->>>+<<<]      Move first number into vacated slot (CDBA)

  >[>]]

,]

<[[<]>[->]<[>>]<]     Determine whether tape is still 4 3 2 1

<[>>-<]               If not: subtract 1 from output cell

-[----->+<]>--.       Create "1" in output cell and output

Dodecaedro, 137 byte

+++++>++++>+++>++>+>,[+++[->+++<]<<<<<[>>>>>+[<]>-]>[>]<+[[-]<<[[->>+<<]<<]>[>>>>>>+[<]<-]>>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

Provalo online!

Le uniche differenze tra i due programmi sono l'installazione e le permutazioni. La permutazione di sinistra usata qui è DCAEB, che sembrava essere il coniugato più golfoso disponibile.

Gelatina , 14 byte

3RðW;ṙN1¦ṚƊ/⁼⁸

Provalo online!

1 = svolta a sinistra, 0 = svolta a destra. Basato sulla mia soluzione Dyalog.

Sfortunatamente, Jelly non ha funzioni nominate. Se non riesco a utilizzare un input implicito e devo supporre che sia in una variabile, questa versione della stessa lunghezza farà:

3RµW;®ṙN1¦ṚƊ/⁼

Presuppone che l'ingresso sia nel registro (© / ®).

Perl - 120, 214

Accetta un array (elenco) di booleani.

Cubo (120):

sub e{$a=$b=0;for$c(@_){$_=(13,62,53,40,57,26,17,'04')[$b];$d=s/$a/($b-1)%8/e;($a,$b)=($b,substr($_,$c^$d,1))}return!$b}

Dodecaedro (214):

sub e{$a=$b='00';for$c(@_){$_=('01041102090307040500061807160308091502101114121019131714151016081706131819051200'=~/\d{4}/g)[$b];$d=s/$a/sprintf'%02d',($b-1)%20/e;($a,$b)=($b,substr($_,($c^$d)*2,2));}return!($b+0)}