Uma formiga caminha pelas bordas (não faces) de um cubo de estrutura de arame. Cada vértice encontrado apresenta um garfo do qual duas novas arestas se ramificam. A formiga escolhe qual caminho virar - leftou right. Essas direções são relativas à formiga, que está voltada para o vértice e está fora do cubo. Seu objetivo é determinar, a partir da sequência de left/ rightescolhas que a formiga tomou, se termina na mesma posição em que foi iniciada.

Por exemplo, se a formiga virar à esquerda quatro vezes ( left left left left), ela terá percorrido um quadrado no sentido anti-horário e terminado no mesmo local em que foi iniciado. Mas, se for left left left left right, terminará em um local diferente no cubo. Além disso, se continuar left right right right left, termina na aresta inicial, mas de frente para o vértice oposto, que não conta como a mesma posição.

O caminho da formiga pode repetir bordas, incluindo a borda em que começou, mas o que importa é onde termina após toda a sequência.

Escreva uma função nomeada que receba a sequência de voltas da formiga e produza se a formiga está de volta à sua posição inicial após a sequência. Atribuir uma função sem nome a uma variável é suficiente para torná-la uma função nomeada.

(Editar: se o seu idioma não puder criar uma função nomeada, ele poderá implementá-la com entradas e saídas através de STDIN / printing ou da pilha. Se isso não for possível, crie um trecho no qual a entrada e a saída são salvas em variáveis.)

Entrada

Uma sequência de left/ rightdecisões de comprimento 0a 31inclusivo, representada em um formato de sua escolha. Pode ser uma sequência de letras R/ L, uma lista de números 1/ -1ou uma matriz de booleanos. Nada extravagante como tê-los como nomes de métodos ou seqüências de caracteres úteis para o seu código.

Poste os casos de teste em seu formato, se for diferente dos casos de teste abaixo.

Saída

True/ False, 0/ 1, ou os análogos no seu idioma.

Critérios de vitória

Menos bytes ganha. Lembre-se, você precisa atribuir uma função nomeada. Você pode ter código fora da função, mas esses bytes também contam. Sua função deve se comportar corretamente se for chamada várias vezes.

Casos de teste

True casos (um por linha, o segundo é lista vazia):

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 casos (um por linha):

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

Aqui estão os mesmos casos de teste com L's e R' s.

True casos:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False casos:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

Desafio de crédito extra

A mesma coisa, mas com um dodecaedro em vez de um cubo. Veja Hunt the Wumpus para idéias.

GolfScript, 24 caracteres (19 apenas para o corpo da função)

Math FTW!

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

Teste esta solução online.

Esta função recebe como entrada uma matriz binária (0 para a esquerda, 1 para a direita) e retorna 1 para verdadeiro e 0 para falso.

Conceitualmente, ele funciona girando o cubo para que a formiga sempre mantenha a mesma posição e orientação e verificando se o cubo finalmente termina na mesma orientação em que começou.

Em particular, podemos representar as curvas à esquerda e à direita como dois mapas lineares em três dimensões, onde uma curva à esquerda corresponde a uma rotação de 90 ° em torno do eixo x , ou seja, o mapa ( x , y , z ) → ( x , z , - y ) e uma curva à direita corresponde a uma rotação de 90 ° em torno do eixo y , ou seja, o mapa ( x , y , z ) → ( z , y , - x ).

No início da função, simplesmente configuramos um vetor de três elementos contendo os valores positivos distintos (1, 2, 3), aplicamos a sequência de mapas de rotação a ela e verificamos se o vetor resultante é igual ao inicial.

(De fato, para salvar alguns caracteres, eu realmente transformo as coordenadas para que o vetor inicial seja (0, 1, 2) e os mapas sejam ( x , y , z ) → ( x , z , −1− y ) e ( x , y , z ) → ( z , y , −1− x ), mas o resultado final é o mesmo.)

Ps. Agradecemos ao orgulhoso haskeller por detectar o bug na versão original desta solução.

Perl, 58 caracteres

Conforme solicitado nos comentários, aqui está a mesma solução portada para Perl. (Na verdade, esta versão usa coordenadas não transformadas, pois a transformação não salva caracteres no Perl.)

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

Teste esta solução online.

Bônus: Formiga em um dodecaedro (GolfScript, 26 caracteres)

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

Teste esta solução online.

Como a função formiga em um cubo acima, essa função recebe como entrada uma matriz binária (0 para a esquerda, 1 para a direita) e retorna 1 se a formiga terminar na mesma posição e orientação em que foi iniciada, ou 0 de outra forma.

Esta solução usa uma representação um pouco mais abstrata que a solução de cubo acima. Especificamente, utiliza o fato de que o grupo de simetria rotacional do dodecaedro é isomórfico ao grupo alternativo A ₅ , ou seja, o grupo de permutações pares de cinco elementos. Assim, cada rotação possível do dodecaedro (que mapeia arestas para arestas e vértices para vértices) pode ser representada exclusivamente como uma permutação de uma matriz de cinco elementos, com rotações consecutivas correspondentes à aplicação das permutações correspondentes em sequência.

Assim, tudo o que precisamos fazer é encontrar duas permutações L e R que possam representar as rotações esquerda e direita. Especificamente, essas permutações precisam ter 5 ciclos (de modo que aplicá-las cinco vezes retorne ao estado original), não devem ser poderes uma da outra (ou seja, R ≠ L ⁿ para qualquer n ) e precisam satisfazer a relação ( LR ) ⁵ = (1), onde (1) indica a permutação de identidade. (Com efeito, este critério afirma que o caminho LRLRLRLRLRdeve retornar à posição original.)

Corrigir a permutação L para ser um deslocamento simples do barril para a esquerda, ou seja, mapeamento ( a , b , c , d , e ) → ( b , c , d , e , a ), pois ele pode ser implementado no GolfScript em apenas dois chars ( (+), descobrimos que existem cinco opções possíveis para a permutação de R. Dessas, escolhi o mapeamento ( a , b , c , d , e ) → ( c , e , d ,b , a ), pois também possui uma implementação GolfScript relativamente compacta. (Na verdade, eu o implemento intercalando primeiro os elementos com 2*2%para obter ( a , c , e , b , d ), depois trocando os dois últimos com [~\]e, finalmente, aplicando a permutação L incondicionalmente para mover a até o fim.)

O link de demonstração on-line acima inclui alguns casos de teste de caminhos válidos em um dodecaedro que retornam à origem, como:

           # 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

Leva uma lista de 1 e -1. Baseado em rotações 3D: verifica se o ponto (3,2,1) termina na mesma posição após a aplicação de uma série de rotações. Existem duas rotações possíveis, correspondentes a 1 e -1. Cada uma delas é feita permutando duas coordenadas e alterando o sinal de uma delas. As coordenadas exatas para alterar e qual sinal permutar não é importante.

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

EDIT: na verdade, é basicamente a mesma solução que "Perl, 58".

Mathematica

Inspirado na solução de Ilmari Karonen. O grupo de simetria rotacional de um cubo é isomórfico para S ₄ .

Cubo, 51 bytes

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

Recebe uma lista de 1s e -1s como entrada.

Experimente online!

Dodecaedro, 55 bytes

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

Recebe uma lista de 1s e -1s como entrada.

Experimente online!

C (gcc) , 118 116 107 105 bytes

-2 bytes graças ao 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;}

Experimente online!

Suponha que demos ao cubo as seguintes coordenadas:

            (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 começarmos no canto D, passar para C ou H pode ser pensado como girar o cubo ao nosso redor. Mover para a direita significaria girar no sentido anti-horário em torno do eixo Z, e mover para a esquerda significaria girar no sentido horário em torno do eixo X. Essas são as únicas duas rotações que precisamos nos preocupar. Como cada rotação é exatamente 90 graus, podemos imaginar os cantos "deslizando" ao longo das bordas. Para mover para a direita, isso significa A -> B, B -> C, C -> D, D -> A com o outro lado fazendo E -> F etc. Para mover para a esquerda, obtemos A -> E, E - > H etc.

Como cada canto desliza apenas ao longo de uma aresta, isso significa que apenas uma das dimensões de cada ponto muda para cada rotação. Quando B se move para C, apenas seu componente y é alterado e quando H se move para D, apenas seu componente z é alterado e assim por diante. Além disso, como as coordenadas estão restritas a 0 e 1, podemos pensar em cada ponto como um número binário, com o bit apropriado invertido durante o movimento.

Podemos ver que, para um movimento para a direita, A e C sacudem seus x's, enquanto D e B sacudem seus y's. Se mudarmos de perspectiva para olhar desse lado do cubo de frente e ignorarmos o componente z (que não muda para essa rotação de qualquer maneira), obtemos:

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

Surge um padrão: para os pontos que invertem seus x, x == y, enquanto o oposto é verdadeiro para os pontos que invertem seus y's. Isso vale para o outro tipo de rotação, mas com z em vez de x.

Em outras palavras:

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

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

Agora podemos facilmente passar por todas as rotações e, no final, ver se o D final corresponde ao nosso D. inicial

Armazenar cada ponto como um número único é um dado, mas em C, atribuir uma matriz de caracteres é muito mais compacto que uma matriz int. Tomamos o cuidado de escolher caracteres cujos três bits inferiores correspondam a 000..111, tornando possível ignorar o restante dos bits. Inverter as coordenadas é simplesmente uma questão de fazer XOR com a máscara de bit apropriada.

Python - 110, 150

Leva em uma lista de números inteiros com -1para virar à esquerda, 1para virar à direita.

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

Teste:

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

Roubo desavergonhado do algoritmo de Ilmari Karonen com o objetivo de exibir uma nova linguagem.

Esse script espera uma sequência de 0x00 para a esquerda e 0x01 para a direita no stdin, seguida por um 0x0A (nova linha). Emite "0" para um caso com falha e "1" para um sucesso.

......@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!!..//

exemplo execute:

# 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 bytes

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

Experimente online!

Isso usa a representação de permutação

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

onde esquerda e direita (0 e 1) correspondem a ciclos de comprimento-4 em 4 elementos. Repetimos a entrada aplicando a permutação indicada e verificamos se o resultado é igual ao valor inicial.

Começamos a,b,c,dcomo a lista de quatro elementos 0,1,2,3. Nós os compactamos em um único número base-4 n=abcd, com o valor inicial n=27correspondente 0123na base 4. Instanciamos cada permutação aritmeticamente n.

Como os dois resultados começam d, podemos n%4extrair de n%4*64movê-lo para a posição correta d___. Os outros dígitos são abcextraídos como n/4. Precisamos inseri-los nos três valores inferiores.

Para direção x=0, inserimos abccomo está e para x=1, rotacionamos como cab. A rotação pode ser conseguida como *16%63, o que leva abca abc00que cab. ( %63Isso daria errado a==b==c==3, mas esse valor não é possível.) Como apenas fazer %63é um não-op, a expressão dependente da direção *16**x%63fornece abcou cabconforme necessário.

Python 2 , 55 bytes

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

Experimente online!

Haskell, 104 103 99 97 96/ 67 64 caracteres

Eu sinto que o equivalente à direita / esquerda seria um tipo de dados Direction assim:

Direction = R | L

então assumi na minha resposta que eles estavam disponíveis.
edit: realmente percebi que os booleanos levariam a um código mais curto. True representa uma curva à esquerda e False representa uma curva à direita (embora, tecnicamente, o código funcione da mesma forma se for invertido; é simétrico)

96 caracteres:

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 é uma função que, dada uma lista de Direção, retornaria o tempo em que a formiga não voltou ao seu lugar.

explicação da representação da posição: a posição da formiga é codificada como três tuplas de números inteiros. o primeiro inteiro representa o vértice para o qual a formiga está indo. o primeiro bit representa se o vértice está na metade superior / inferior, o segundo é a metade esquerda / direita e o terceiro é a metade traseira / dianteira. isso é feito para que a mudança de um vértice para um vizinho possa ser feita invertendo um bit.

o segundo número inteiro é a quantidade que o vértice da formiga mudaria se fosse para a esquerda. por exemplo, se a formiga estava no vértice 3 e o segundo inteiro era 4, então, depois de virar à esquerda, o vértice seria 7. observe que isso sempre seria uma potência de 2, porque exatamente um bit é invertido movendo um vértice.

o terceiro inteiro é o mesmo, mas para dar certo; Eu sei que isso pode ser calculado pelos dois primeiros, mas não sei como. se você teve uma idéia, por favor me diga.

algo a ser observado é que, ao virar à esquerda, o terceiro número inteiro permanecerá o mesmo, e o segundo se tornará aquele entre 1 2 e 4, que não é o segundo número inteiro ou o terceiro, que é o mesmo que 7 - segundo inteiro - terceiro inteiro.

eu escolhi essa maneira de representar a posição porque (como foi dito no parágrafo anterior) era trivial calcular a próxima posição.

explicação das funções:

a função (%) é a função que pega o vértice atual e a quantidade para alterá-lo e o altera. chega ao bit que vai mudar e vira (de uma maneira muito numérica).

a função m é uma função que assume a posição da formiga e a direção e retorna a nova posição usando a nota que observamos anteriormente.

então a função m é combinada usando foldl (que é como o reducejavascript, mas um pouco mais expressivo) para criar a função g, a resposta para esta pergunta.

Haskell, 64 caracteres

inspirado na resposta de @ alphaalpha, aqui está sua versão portada para 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]

editar: Agora me sinto incrivelmente estúpido por causa da resposta de lmari Karonen. talvez eu leve sua resposta para haskell. outra edição: não parecer tão estúpido quanto a resposta está errada
editar: passou de usar tuplas para usar listas como sua Ordinstância e o [ ... ]açúcar sintático diminui

Haskell , 53 bytes

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

Experimente online!

A mesma lógica da minha resposta Python , até pensei mode divdemoramos mais para escrever.

Haskell , 58 bytes

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

Experimente online!

APL (Dyalog Unicode) , 22 bytes ( SBCS de Adám )

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

Experimente online!

H.PWiz sugeriu que reverter as etapas não faz diferença, e isso resultou em -2 bytes.

Bem, isso é embaraçoso, pois ele pretendia ser bem menor que o GolfScript. Pelo menos eu tentei.

A função é nomeada fe, nos casos de teste, 1representa uma curva à esquerda (boolean true) e 0representa uma curva à direita (boolean false). ⍬representa a lista vazia.

APL (Dyalog) , 21 bytes

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

Experimente online! (Usando o ambiente de teste da resposta de Erik the Outgolfer )

Tomo à esquerda e à direita como 1e2 . Isso usa as seguintes permutações de abcd:

1 : bcda
2 : cdba

I aplicar as permutações correspondente a 1e 2a ⍳4 : 1 2 3 4, e verificar se ele permanece inalterado

Bash , 71 65 bytes

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

Experimente online!

Como muitas respostas anteriores, usa uma representação do grupo de rotações do cubo gerado por 1234-> 4123 e 1234-> 4312. Usa números em vez de letras para que eu possa usar um operador ternário com uma expansão aritmética. Espera sua entrada como 0 e 1 separados por espaços e saídas via código de saída.

6 bytes salvos graças ao comentário de @ manatwork!

brainfuck , 119 bytes, 137 bytes

Usa o fato de que o grupo de rotação do cubo é isomórfico para $S_4$. O Brainfuck não possui nenhuma função, nomeada ou não, portanto, este é um programa completo que recebe entradas através de STDIN e sai para STDOUT. (Se você insistir em uma variável, finja que o valor da célula na qual o programa termina é uma variável).

Cubo, 119 bytes

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

Experimente 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 bytes

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

Experimente online!

As únicas diferenças entre os dois programas são a configuração e as permutações. A permutação esquerda usada aqui é a DCAEBque parecia ser o conjugado de golfe disponível.

Gelatina , 14 bytes

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

Experimente online!

1= virar à esquerda, 0= virar à direita. Com base na minha solução Dyalog.

Infelizmente, Jelly não possui funções nomeadas. Se eu não puder usar uma entrada implícita e precisar assumir que ela está em uma variável, esta versão do mesmo comprimento fará:

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

Assume que a entrada está no registro (© / ®).

Perl - 120, 214

Toma uma matriz (lista) de booleanos.

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