Una hormiga camina a lo largo de los bordes (no caras) de un cubo de estructura metálica. Cada vértice que encuentra le presenta una bifurcación desde la cual se ramifican dos bordes nuevos. La hormiga elige en qué dirección girar - lefto right. Estas direcciones son relativas a la hormiga, que se enfrenta al vértice y está fuera del cubo. Su objetivo es determinar, a partir de la secuencia de left/ rightelecciones que tomó la hormiga, si termina en la misma posición en que comenzó.

Por ejemplo, si la hormiga gira cuatro veces hacia la izquierda ( left left left left), habrá recorrido un cuadrado en el sentido contrario a las agujas del reloj y ha terminado en el mismo lugar donde comenzó. Pero, si se va left left left left right, terminará en un lugar diferente en el cubo. Además, si se va left right right right left, termina en su borde inicial pero mirando hacia el vértice opuesto, que no cuenta como la misma posición.

El camino de la hormiga podría repetir los bordes, incluido el borde en el que comenzó, pero lo que importa es dónde termina después de toda la secuencia.

Escriba una función con nombre que tome la secuencia de giros de la hormiga y muestre si la hormiga está de vuelta en su posición inicial después de la secuencia. Asignar una función sin nombre a una variable es suficiente para convertirla en una función con nombre.

(Editar: si su idioma no puede crear una función con nombre, puede implementar la función con entradas y salidas a través de STDIN / impresión o la pila. Si eso no es posible, conviértalo en un fragmento en el que la entrada y la salida se guardan en variables.)

Entrada

Una secuencia de left/ rightdecisiones de duración 0a 31inclusiva, representada en un formato de su elección. Esto podría ser una cadena de letras R/ L, una lista de números 1/ -1o una matriz de booleanos. Nada cursi como tener nombres de métodos o cadenas útiles para su código.

Publique los casos de prueba en su formato si es diferente de los casos de prueba a continuación.

Salida

True/ False, 0/ 1o los análogos en su idioma.

Criterios ganadores

Pocos bytes ganan. Recuerde, debe asignar una función con nombre. Puede tener código fuera de la función, pero esos bytes también cuentan. Su función debe comportarse correctamente si se llama varias veces.

Casos de prueba

True casos (uno por línea, el segundo es una lista vacía):

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 (uno por línea):

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

Aquí están los mismos casos de prueba con L'sy 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

Desafío de crédito adicional

Lo mismo, pero con un dodecaedro en lugar de un cubo. Ver Hunt the Wumpus para ideas.

GolfScript, 24 caracteres (19 solo para el cuerpo de la función)

Math FTW!

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

Prueba esta solución en línea.

Esta función toma como entrada una matriz binaria (0 para la izquierda, 1 para la derecha) y devuelve 1 para verdadero y 0 para falso.

Conceptualmente, funciona girando el cubo para que la hormiga siempre mantenga la misma posición y orientación, y verificando si el cubo finalmente termina en la misma orientación que comenzó.

En particular, podemos representar los giros a la izquierda y a la derecha como dos mapas lineales en tres dimensiones, donde un giro a la izquierda corresponde a una rotación de 90 ° alrededor del eje x , es decir, el mapa ( x , y , z ) → ( x , z , - y ), y un giro a la derecha corresponde a una rotación de 90 ° alrededor del eje y , es decir, el mapa ( x , y , z ) → ( z , y , - x ).

Al comienzo de la función, simplemente configuramos un vector de tres elementos que contiene los distintos valores positivos (1, 2, 3), le aplicamos la secuencia de mapas de rotación y verificamos si el vector resultante es igual al inicial.

(De hecho, para guardar algunos caracteres, en realidad transformo las coordenadas para que el vector inicial sea (0, 1, 2) y los mapas sean ( x , y , z ) → ( x , z , −1− y ) y ( x , y , z ) → ( z , y , −1− x ), pero el resultado final es el mismo).

PD. Gracias al orgulloso haskeller por detectar el error en la versión original de esta solución.

Perl, 58 caracteres

Como se solicitó en los comentarios, aquí está la misma solución portada a Perl. (Esta versión en realidad usa las coordenadas no transformadas, ya que la transformación no guarda caracteres en Perl).

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

Prueba esta solución en línea.

Bonus: Hormiga en un dodecaedro (GolfScript, 26 caracteres)

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

Prueba esta solución en línea.

Al igual que la función ant-on-a-cube anterior, esta función toma como entrada una matriz binaria (0 para la izquierda, 1 para la derecha) y devuelve 1 si la hormiga termina en la misma posición y orientación que cuando comenzó, o 0 de otra manera.

Esta solución utiliza una representación un poco más abstracta que la solución de cubo anterior. Específicamente, hace uso del hecho de que el grupo de simetría rotacional del dodecaedro es isomorfo al grupo alterno A ₅ , es decir, el grupo de permutaciones pares de cinco elementos. Por lo tanto, cada posible rotación del dodecaedro (que asigna bordes a bordes y vértices a vértices) puede representarse de manera única como una permutación de una matriz de cinco elementos, con rotaciones consecutivas correspondientes a la aplicación de las permutaciones correspondientes en secuencia.

Por lo tanto, todo lo que necesitamos hacer es encontrar dos permutaciones L y R que puedan representar las rotaciones izquierda y derecha. Específicamente, estas permutaciones deben ser de 5 ciclos (de modo que aplicarlas cinco veces vuelve al estado original), no deben ser potencias entre sí (es decir, R ≠ L ⁿ para cualquier n ), y deben satisfacer la relación ( LR ) ⁵ = (1), donde (1) denota la permutación de identidad. (En efecto, este criterio establece que la ruta LRLRLRLRLRdebe volver a la posición original).

Fijar la permutación L para que sea un simple desplazamiento de barril a la izquierda, es decir, mapeo ( a , b , c , d , e ) → ( b , c , d , e , a ), ya que se puede implementar en GolfScript en solo dos chars ( (+), encontramos que hay cinco opciones posibles para la permutación R. De esos, elegí el mapeo ( a , b , c , d , e ) → ( c , e , d ,b , a ), ya que también tiene una implementación relativamente compacta de GolfScript. (De hecho, implemento por primera intercalación de los elementos con 2*2%para obtener ( una , c , e , b , d ), entonces el intercambio de los dos últimos elementos con [~\], y finalmente la aplicación de la L permutación incondicionalmente para mover una hasta el final.)

El enlace de demostración en línea anterior incluye algunos casos de prueba de rutas válidas en un Dodecaedro que regresan al origen, 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

Toma una lista de 1 y -1. Basado en rotaciones 3D: comprueba si el punto (3,2,1) termina en la misma posición después de aplicar una serie de rotaciones. Hay dos rotaciones posibles, correspondientes a 1 y -1. Cada uno se realiza permutando dos coordenadas y cambiando el signo de una de ellas. Las coordenadas exactas a cambiar y qué signo permutar no son importantes.

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

EDITAR: esta es en realidad la misma solución que "Perl, 58".

Mathematica

Inspirado en la solución de Ilmari Karonen. El grupo de simetría rotacional de un cubo es isomorfo a S ₄ .

Cubo, 51 bytes

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

Toma una lista de 1s y -1s como entrada.

Pruébalo en línea!

Dodecaedro, 55 bytes

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

Toma una lista de 1s y -1s como entrada.

Pruébalo en línea!

C (gcc) , 118 116 107 105 bytes

-2 bytes gracias 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;}

Pruébalo en línea!

Supongamos que le dimos al cubo las siguientes 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)

Si comenzamos en la esquina D, se puede pensar que pasar a C o H gira el cubo a nuestro alrededor. Moverse hacia la derecha significaría girar en sentido antihorario alrededor del eje Z, y moverse hacia la izquierda significaría girar en sentido horario alrededor del eje X. Estas son las dos únicas rotaciones que debemos preocuparnos. Dado que cada rotación es exactamente 90 grados, podemos imaginar las esquinas "deslizándose" a lo largo de los bordes. Para moverse hacia la derecha, esto significa A -> B, B -> C, C -> D, D -> A con el otro lado haciendo E -> F, etc. Para moverse hacia la izquierda, en su lugar obtenemos A -> E, E - > H etc.

Dado que cada esquina solo se desliza a lo largo de un borde, eso significa que solo una de las dimensiones de cada punto cambia para cada rotación. Cuando B se mueve a C, solo cambia su componente y, y cuando H se mueve a D, solo cambia su componente z, y así sucesivamente. Además, dado que las coordenadas están restringidas a 0 y 1, podemos pensar en cada punto como un número binario, con el bit apropiado invertido en el movimiento.

Podemos ver que para un movimiento a la derecha, A y C cambian sus x, mientras que D y B invierten sus y. Si cambiamos la perspectiva para mirar de ese lado del cubo de frente e ignoramos el componente z (que de todos modos no cambia para esta rotación) obtenemos:

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

Surge un patrón: para los puntos que invierten su x, x == y, mientras que lo opuesto es cierto para los puntos que invierten sus y. Esto es válido para el otro tipo de rotación, pero con z en lugar de x.

En otras palabras:

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

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

Ahora podemos pasar fácilmente por todas las rotaciones, y al final ver si la D final coincide con nuestra D. inicial

Almacenar cada punto como un número único es un hecho, pero en C, asignar una matriz de caracteres es mucho más compacto que una matriz int. Nos encargamos de elegir caracteres cuyos tres bits inferiores coincidan con 000..111, lo que hace posible ignorar el resto de los bits. Voltear las coordenadas es simplemente una cuestión de XOR'ing con la máscara de bits adecuada.

Python - 110, 150

Toma una lista de enteros con -1para girar a la izquierda, 1para girar a la derecha.

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

Prueba:

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

Desvergonzado robo del algoritmo de Ilmari Karonen con el fin de mostrar un nuevo lenguaje.

Este script espera una cadena de 0x00 para la izquierda y 0x01 para la derecha en stdin, seguido de un 0x0A (nueva línea). Produce "0" para un caso fallido y "1" para un éxito.

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

ejemplo ejecutado:

# 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

Pruébalo en línea!

Esto usa la representación de permutación

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

donde izquierda y derecha (0 y 1) corresponden a longitud-4 ciclos en 4 elementos. Repetimos la entrada aplicando la permutación indicada y verificamos si el resultado es igual al valor inicial.

Comenzamos a,b,c,dcomo la lista de cuatro elementos 0,1,2,3. Los compactamos en un solo número de base 4 n=abcd, con el valor inicial n=27correspondiente 0123en la base 4. Instanciamos cada permutación aritméticamente enn .

Dado que ambos resultados comienzan con d, podemos hacer n%4para extraer d, luego n%4*64moverlo a la posición correcta d___. Los otros dígitos son abc, extraídos como n/4. Necesitamos insertarlos en los tres valores de posición inferiores.

Para la dirección x=0, los insertamos abctal cual y para x=1los rotamos como cab. La rotación se puede lograr como *16%63, que se lleva abca abc00a cab. (El %63saldría mal a==b==c==3, pero estos valores no son posibles). Dado que solo hacer %63es un no-op, la expresión dependiente de la dirección *16**x%63da abco cabsegún sea necesario.

Python 2 , 55 bytes

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

Pruébalo en línea!

Haskell, 104 103 99 97 96/ 67 64 caracteres

Siento que el equivalente de derecha / izquierda sería una dirección de tipo de datos así:

Direction = R | L

así que supuse en mi respuesta que estaban disponibles.
editar: en realidad me di cuenta de que los booleanos conducirían a un código más corto. Verdadero representa un giro a la izquierda, y Falso representa un giro a la derecha (aunque, técnicamente, el código funcionaría igual si se voltea; es 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 es una función que, dada una lista de Dirección, devolvería el clima sin que la hormiga volviera a su lugar.

explicación de representación de posición: la posición de la hormiga se codifica como tres tuplas de enteros. el primer entero representa el vértice al que se dirige la hormiga. el primer bit representa si el vértice está en la mitad superior / inferior, el segundo es la mitad izquierda / derecha y el tercero es la mitad posterior / frontal. esto se hace para poder pasar de un vértice a un vértice vecino volteando un bit.

el segundo entero es la cantidad que el vértice de la hormiga cambiaría si fuera a la izquierda. por ejemplo, si la hormiga estaba en el vértice 3, y el segundo entero era 4, que después de girar a la izquierda el vértice sería 7. tenga en cuenta que esto siempre sería una potencia de 2, porque exactamente un bit se voltea moviendo un vértice.

el tercer entero es el mismo, pero para ir a la derecha; Sé que esto se puede calcular por los dos primeros, pero no sé cómo. Si tienes una idea, por favor dime.

Algo a tener en cuenta es que al girar a la izquierda, el tercer entero se mantendría igual, y el segundo se convertiría en uno entre 1 2 y 4 que no era el segundo entero o el tercero, que resulta ser el mismo que 7 - segundo entero - tercer entero.

Elegí esta forma de representar la posición porque (como se indicó en el párrafo anterior) era trivial calcular la siguiente posición.

explicación de funciones:

la función (%) es la función que toma el vértice actual y la cantidad para cambiarlo, y lo cambia. llega al bit que va a cambiar y lo voltea (de una manera muy numérica).

La función m es una función que toma la posición de la hormiga y la dirección, y devuelve la nueva posición utilizando la nota que anotamos anteriormente.

entonces la función m se combina usando foldl (que es como reduceJavaScript, pero un poco más expresivo) para crear la función g, la respuesta a esta pregunta.

Haskell, 64 personajes

inspirado en la respuesta de @ alphaalpha, aquí está su versión portada a 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: ahora me siento increíblemente estúpido por la respuesta de lmari Karonen. tal vez transmita su respuesta a Haskell. otra edición: no se siente tan estúpido como su respuesta es que estaba mal
de edición: pasado de utilizar realmente tuplas a utilizar listas como su Ordinstancia y el [ ... ]azúcar sintáctico hace que sea más corto

Haskell , 53 bytes

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

Pruébalo en línea!

La misma lógica que mi respuesta de Python , incluso pensé mody divson más largas para escribir.

Haskell , 58 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

H.PWiz sugirió que invertir los pasos no hace la diferencia, y eso resultó en -2 bytes.

Bueno, esto es vergonzoso, ya que estaba destinado a ser mucho más corto que GolfScript. Al menos lo intenté.

La función se nombra fy, en los casos de prueba, 1representa un giro a la izquierda (booleano verdadero) y 0representa un giro a la derecha (booleano falso). ⍬representa la lista vacía.

APL (Dyalog) , 21 bytes

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

Pruébalo en línea! (Usando el entorno de prueba de la respuesta de Erik the Outgolfer )

Tomo izquierda y derecha como 1y 2. Utiliza las siguientes permutaciones de abcd:

1 : bcda
2 : cdba

Aplico las permutaciones correspondiente a 1y 2a ⍳4 : 1 2 3 4, y comprobar si se ha modificado

Bash , 71 65 bytes

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

Pruébalo en línea!

Como muchas respuestas anteriores, utiliza una representación del grupo de rotaciones del cubo generado por 1234-> 4123 y 1234-> 4312. Utiliza números en lugar de letras para poder usar un operador ternario con una expansión aritmética. Espera su entrada como 0 y 1 separados por espacios, y sale a través del código de salida.

¡6 bytes guardados gracias al comentario de @ manatwork!

brainfuck , 119 bytes, 137 bytes

Utiliza el hecho de que el grupo de rotación del cubo es isomorfo a $S_4$. Brainfuck no tiene ninguna función, nombrada o no, por lo que este es un programa completo que recibe entradas a través de STDIN y salidas a STDOUT. (Si insiste en una variable, imagine que el valor de la celda en la que termina el programa es una variable).

Cubo, 119 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Las únicas diferencias entre los dos programas son la configuración y las permutaciones. La permutación izquierda utilizada aquí es DCAEB, que parecía ser el conjugado más golfista disponible.

Jalea , 14 bytes

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

Pruébalo en línea!

1= giro a la izquierda, 0= giro a la derecha. Basado en mi solución Dyalog.

Desafortunadamente, Jelly no tiene funciones con nombre. Si no puedo usar una entrada implícita y necesito suponer que está en una variable, esta versión de la misma longitud funcionará:

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

Se supone que la entrada está en el registro (© / ®).

Perl - 120, 214

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