Муравей идет по краям (не граням) каркасного куба. Каждая встречаемая вершина представляет его вилкой, от которой отходят два новых ребра. Муравей выбирает, в какую сторону повернуть - leftили right. Эти направления относятся к муравью, который обращен к вершине и находится вне куба. Ваша цель состоит в том, чтобы определить, из последовательности left/ rightвыборов, которые принял муравей, заканчивается ли он в том же положении, в котором он начал.

Например, если муравей повернет налево четыре раза ( left left left left), он пройдет через квадрат против часовой стрелки и закончится в том же месте, где и начал. Но, если он пойдет left left left left right, он закончится в другом месте на кубе. Кроме того, если он идет left right right right left, он заканчивается на своем начальном ребре, но обращен к противоположной вершине, которая не считается той же позицией.

Путь муравья может повторять ребра, включая ребро, с которого он начинался, но важно то, где он заканчивается после всей последовательности.

Напишите именованную функцию, которая принимает последовательность ходов муравья и выводит, вернулся ли муравей в исходное положение после последовательности. Назначение неназванной функции переменной достаточно, чтобы сделать ее именованной функцией.

(Редактировать: если ваш язык не может создать именованную функцию, он может вместо этого реализовать функцию с входами и выходами через STDIN / печать или стек. Если это невозможно, сделайте его фрагментом, в котором вход и выход сохранены в переменные.)

вход

Последовательность left/ rightрешения от длины 0до 31включительно, представленные в формате по вашему выбору. Это может быть строка букв R/ L, список чисел 1/ -1или массив логических значений. Ничего такого, как использование имен методов или строк, полезных для вашего кода.

Пожалуйста, опубликуйте тестовые примеры в вашем формате, если они отличаются от тестовых примеров ниже.

Выход

True/ False, 0/ 1или аналоги на вашем языке.

Критерии победы

Побеждает несколько байтов. Помните, вам нужно дать именованную функцию. Вы можете иметь код вне функции, но эти байты тоже учитываются. Ваша функция должна вести себя правильно, если вызывается несколько раз.

Контрольные примеры

True падежи (по одному на строку, второй - пустой список):

1 1 1 1

-1 -1 -1 -1
1 -1 1 -1 1 -1
1 1 -1 -1 1 1 -1 -1
-1 1 1 -1 -1 1 1 -1
1 1 1 -1 -1 -1 -1 1
1 -1 -1 1 -1 -1
1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1
-1 -1 -1 1 -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 случаи (по одному на строку):

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

Вот те же тесты с L'и R'.

True случаи:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False случаи:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

Дополнительный кредитный вызов

То же самое, но с додекаэдром, а не с кубом. См. « Охота на Вумпуса» для идей.

GolfScript, 24 символа (19 только для функционального тела)

Математика FTW!

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

Протестируйте это решение онлайн.

Эта функция принимает в качестве входных данных двоичный массив (0 для левого, 1 для правого) и возвращает 1 для истинного и 0 для ложного.

Концептуально, он работает, вращая куб так, что муравей всегда сохраняет ту же позицию и ориентацию, и проверяя, заканчивается ли куб в той же ориентации, в которой он начал.

В частности, мы можем представить левый и правый повороты в виде двух линейных карт в трех измерениях, где левый поворот соответствует повороту на 90 ° вокруг оси x , т.е. карта ( x , y , z ) → ( x , z , - y ), а поворот вправо соответствует повороту на 90 ° вокруг оси y , т. Е. Карте ( x , y , z ) → ( z , y , - x ).

В начале функции мы просто устанавливаем трехэлементный вектор, содержащий различные положительные значения (1, 2, 3), применяем к нему последовательность карт вращения и проверяем, равен ли результирующий вектор начальному.

(Фактически, чтобы сохранить несколько символов, я на самом деле преобразую координаты так, чтобы начальный вектор был (0, 1, 2), а карты были ( x , y , z ) → ( x , z , −1− y ) и ( x , y , z ) → ( z , y , −1− x ), но конечный результат тот же.)

Ps. Спасибо гордому haskeller за обнаружение ошибки в оригинальной версии этого решения.

Perl, 58 символов

Как и просили в комментариях, вот то же решение, портированное на Perl. (Эта версия фактически использует нетрансформированные координаты, поскольку преобразование не сохраняет символов в Perl.)

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

Протестируйте это решение онлайн.

Бонус: муравей на додекаэдре (GolfScript, 26 символов)

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

Протестируйте это решение онлайн.

Как и в приведенной выше функции ant-on-a-cube, эта функция принимает в качестве входных данных двоичный массив (0 для левого, 1 для правого) и возвращает 1, если муравей оказывается в той же позиции и ориентации, в которой он был запущен, или 0 иначе.

Это решение использует немного более абстрактное представление, чем решение куба выше. В частности, он использует тот факт, что группа вращательной симметрии додекаэдра изоморфна знакопеременной группе A ₅ , то есть группе четных перестановок из пяти элементов. Таким образом, каждое возможное вращение додекаэдра (которое отображает ребра в ребра и вершины в вершины) может быть уникально представлено как перестановка массива из пяти элементов с последовательными вращениями, соответствующими применению соответствующих перестановок в последовательности.

Таким образом, все, что нам нужно сделать, это найти две перестановки L и R, которые могут представлять левый и правый повороты. В частности, эти перестановки должны быть 5-тактными (чтобы их применение пять раз возвращалось к исходному состоянию), они не должны быть степенями друг друга (т. Е. R ≠ L ⁿ для любого n ), и они должны удовлетворять соотношению ( LR ) ⁵ = (1), где (1) обозначает тождественную перестановку. (По сути, этот критерий утверждает, что путь LRLRLRLRLRдолжен вернуться в исходное положение.)

Исправление перестановки L в простой сдвиг бочки влево, т. Е. Отображение ( a , b , c , d , e ) → ( b , c , d , e , a ), поскольку это может быть реализовано в GolfScript всего за два chars ( (+), мы находим, что есть пять возможных вариантов для перестановки R. Из них я выбрал отображение ( a , b , c , d , e ) → ( c , e , d ,b , a ), поскольку он также имеет относительно компактную реализацию GolfScript. (Фактически, я реализую это, сначала чередуя элементы с, 2*2%чтобы получить ( a , c , e , b , d ), затем поменяв местами последние два элемента с [~\]и, наконец, безоговорочно применяя перестановку L, чтобы переместить a в конец.)

Приведенная выше демонстрационная онлайн-ссылка включает в себя несколько тестовых примеров действительных путей на додекаэдре, которые возвращаются к источнику, например:

           # 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

Принимает список из 1 и -1. На основе трехмерных поворотов: проверяет, окажется ли точка (3,2,1) в одной и той же позиции после применения серии поворотов. Есть два возможных поворота, соответствующих 1 и -1. Каждая из них выполняется путем перестановки двух координат и изменения знака одной из них. Точные координаты, которые нужно изменить, и какой знак переставлять не важны.

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

РЕДАКТИРОВАТЬ: это на самом деле в основном то же решение, что и "Perl, 58".

Mathematica

Вдохновленный решением Ильмари Каронена. Группа вращательной симметрии куба изоморфна S ₄ .

Куб, 51 байт

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

Принимает список 1s и -1s в качестве входных данных.

Попробуйте онлайн!

Додекаэдр, 55 байт

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

Принимает список 1s и -1s в качестве входных данных.

Попробуйте онлайн!

C (gcc) , 118 116 107 105 байтов

-2 байта благодаря потолку

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

Попробуйте онлайн!

Предположим, мы дали кубу следующие координаты:

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

Если мы начнем с угла D, то движение к С или Н можно будет рассматривать как вращение куба вокруг нас. Движение вправо означало бы вращение против часовой стрелки вокруг оси Z, а движение влево означало бы вращение по часовой стрелке вокруг оси X. Это только два поворота, о которых нам нужно заботиться. Поскольку каждое вращение составляет ровно 90 градусов, мы можем представить, как углы «скользят» по краям. Для движения вправо это означает, что A -> B, B -> C, C -> D, D -> A, а другая сторона выполняет E -> F и т. Д. Для перемещения влево мы вместо этого получаем A -> E, E - > H и т. Д.

Поскольку каждый угол скользит только вдоль края, это означает, что для каждого поворота изменяется только одно из размеров каждой точки. Когда B перемещается в C, изменяется только его компонент y, а когда H перемещается в D, изменяется только его компонент z и так далее. Кроме того, поскольку координаты ограничены 0 и 1, мы можем думать о каждой точке как о двоичном числе, с соответствующим битом, переключаемым при движении.

Мы можем видеть, что для движения вправо, A и C переворачивают свои x, а D и B переворачивают свои y. Если мы изменим перспективу, чтобы посмотреть на эту сторону куба, и проигнорируем компонент z (который в любом случае не изменяется для этого вращения), мы получим:

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

Возникает закономерность: для точек, которые переворачивают свои x, x == y, тогда как для точек, переворачивающих их y, верно обратное. Это верно для другого типа вращения, но с z вместо x.

Другими словами:

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

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

Теперь мы можем легко пройти все повороты и в конце посмотреть, соответствует ли финальный D нашему первоначальному D.

Хранить каждую точку в виде одного числа - это данность, но в C назначение массива char намного компактнее, чем массива int. Мы стараемся выбирать символы, чьи младшие три бита соответствуют 000..111, что позволяет просто игнорировать остальные биты. Переключение координат - это просто XOR с соответствующей битовой маской.

Питон - 110, 150

Принимает список целых чисел с -1для поворота налево, 1для поворота направо.

Куб, 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

Тест:

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

Додекаэдр, 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

Бесстыдная кража алгоритма Илмари Каронена с целью показать новый язык.

Этот сценарий ожидает строку 0x00 для левого и 0x01 для правого на стандартный ввод, за которым следует 0x0A (перевод строки). Он выводит «0» для неудачного случая и «1» для успеха.

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

пример выполнения:

# 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 байт

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

Попробуйте онлайн!

Это использует представление перестановки

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

где левый и правый (0 и 1) соответствуют циклам длины-4 на 4 элементах. Мы перебираем входные данные, применяя указанную перестановку, и проверяем, равно ли результат исходному значению.

Мы начинаем a,b,c,dкак список из четырех элементов 0,1,2,3. Мы сжимаем их в одно число n=abcdс основанием 4 , причем начальное значение n=27соответствует 0123основанию 4. Каждую перестановку инстанцируем арифметически n.

Поскольку оба результата начинаются с d, мы можем n%4извлечь d, а затем n%4*64переместить его в правильную позицию d___. Остальные цифры abcизвлекаются как n/4. Нам нужно вставить их в три нижних значения.

Для направления x=0мы вставляем abcкак есть, а для x=1, мы вращаем их как cab. Вращение может быть достигнуто *16%63, которое принимает abcна abc00к cab. (Операция %63может пойти не так a==b==c==3, но эти значения невозможны.) Так как простое выполнение не %63является операцией, выражение, зависящее от направления, *16**x%63выдает abcили по cabмере необходимости.

Python 2 , 55 байт

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

Попробуйте онлайн!

Haskell, 104 103 99 97 96/ 67 64 символов

Я чувствую, что эквивалентом right / left будет Direction типа данных:

Direction = R | L

поэтому я предположил в своем ответе, что они были доступны.
редактировать: на самом деле понял, что логическое приведет к сокращению кода. True представляет левый поворот, а False представляет правый поворот (хотя, технически, код работал бы так же, если бы он был перевернут; он симметричный)

96 символов:

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 - функция, которая, учитывая список Direction, будет возвращать погоду, когда муравей не вернулся на свое место.

объяснение представления положения: положение муравья закодировано как три кортежа целых чисел. первое целое число представляет вершину, к которой направляется муравей. первый бит представляет собой, если вершина находится в верхней / нижней половине, второй - в левой / правой половине, а третий - в задней / передней половине. это делается для того, чтобы перейти от вершины к соседней вершине можно, щелкнув один бит.

второе целое число - это величина, которую вершина муравья изменит, если она пойдет влево. например, если муравей находился в вершине 3, а второе целое число было 4, то после поворота влево вершина была бы 7. Обратите внимание, что это всегда будет степень 2, потому что ровно один бит переворачивается при перемещении одной вершины.

третье целое число то же самое, но для правильного пути; я знаю, что это можно рассчитать по первым двум, но я не знаю, как это сделать. если у вас есть идея, пожалуйста, скажите мне.

Следует обратить внимание на то, что при повороте налево третье целое число останется прежним, а второе станет значением от 1 2 до 4, которое не будет ни вторым целым числом, ни третьим, что будет совпадать с 7 - второе целое число - третье целое число.

Я выбрал этот способ представления позиции, потому что (как было только что сказано в предыдущем параграфе) вычисление следующей позиции было тривиальным.

объяснение функций:

функция (%) - это функция, которая берет текущую вершину и сумму, чтобы изменить ее, и изменяет ее. он попадает в бит, который будет меняться, и переворачивает его (очень числовым образом).

Функция m - это функция, которая принимает положение муравья и направление и возвращает новую позицию, используя примечание, которое мы отметили ранее.

затем функция m объединяется с использованием foldl (что-то вроде как reduceв javascript, но немного более выразительно), чтобы создать функцию g, ответ на этот вопрос.

Хаскель, 64 символа

Вдохновленный ответом @ alphaalpha, вот его версия, портированная на 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]

редактировать: теперь я чувствую себя невероятно глупо из-за ответа Имари Каронен. возможно я перенесу его ответ на haskell. другое редактирование: не чувствуя себя глупо , как его ответ будет не так
править: переключился с использованием фактически кортежей с использованием списков , их Ordпримером и [ ... ]синтаксический сахар делает его короче

Haskell , 53 байта

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

Попробуйте онлайн!

Та же логика, что и у моего Python-ответа , даже подумала modи divдольше писать.

Haskell , 58 байт

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

Попробуйте онлайн!

APL (Dyalog Unicode) , 22 байта ( SBCS Адама )

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

Попробуйте онлайн!

H.PWiz предположил, что изменение шагов не имеет значения, и это привело к -2 байта.

Что ж, это неловко, так как он должен был быть намного короче, чем GolfScript. По крайней мере, я пытался.

Функция названа f, и в тестовых примерах 1представляет левый поворот (логическое значение true) и 0представляет правый поворот (логическое значение false). ⍬представляет пустой список.

APL (Дьялог) , 21 байт

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

Попробуйте онлайн! (Используя среду тестирования из ответа Эрика Аутгольфера )

Я беру налево и направо как 1и 2. Это использует следующие перестановки abcd:

1 : bcda
2 : cdba

Я применяю перестановки , соответствующие 1и 2к ⍳4 : 1 2 3 4, и проверить , если она не изменится

Баш , 71 65 байт

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

Попробуйте онлайн!

Как и во многих предыдущих ответах, используется представление группы вращений куба, сгенерированных 1234-> 4123 и 1234-> 4312. Использует числа вместо букв, чтобы я мог использовать троичный оператор с арифметическим расширением. Ожидает, что его ввод в виде 0 и 1 разделены пробелами, и выводит через код выхода.

6 байтов сохранено благодаря комментарию @ manatwork!

брейкфук , 119 байт, 137 байт

$S_4$

Куб, 119 байт

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

Попробуйте онлайн!

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

Додекаэдр, 137 байт

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

Попробуйте онлайн!

Единственные различия между этими двумя программами - установка и перестановки. Здесь используется левая перестановка DCAEB, которая, казалось, была самой лучшей из доступных в мире конъюгатов.

Желе , 14 байт

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

Попробуйте онлайн!

1= левый поворот, 0= правый поворот. Основано на моем решении Dyalog.

К сожалению, у желе нет названных функций. Если я не могу использовать неявный ввод и нужно предположить, что он находится в переменной, эта версия той же длины подойдет:

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

Предполагается, что вход находится в регистре (© / ®).

Perl - 120, 214

Принимает массив (список) логических значений.

Куб (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}

Додекаэдр (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)}