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

• выход [x] = реверс (вход [вход [x]])
• повторение

Например: [2,1,0]становится [0,1,2]и наоборот есть [2,1,0]. [0,2,1]становится [0,1,2]и обратное [2,1,0].

Пример 1

In:   0 1 2
S#1:  2 1 0
S#2:  2 1 0
Output: 1

Пример 2

In:   2 1 0
S#1:  2 1 0
Output: 0

Пример 3

In:   3 0 1 2
S#1:  1 0 3 2
S#2:  3 2 1 0
S#3:  3 2 1 0
Output: 2

Пример 4

In:   3 0 2 1
S#1:  0 2 3 1
S#2:  2 1 3 0
S#3:  2 0 1 3
S#4:  3 0 2 1
Output: 3

Ваша задача - определить функцию (или программу), которая принимает перестановку целых чисел 0..Nи возвращает (или выводит) количество шагов, пока не произойдет перестановка, которая уже произошла. Если Xпреобразуется в, Xто выход должен быть нулевым, если Xпреобразуется в Yи Yв X(или Y), то выход должен быть 1.

Y -> Y: 0 steps
Y -> X -> X: 1 step
Y -> X -> Y: 1 step
A -> B -> C -> D -> C: 3 steps
A -> B -> C -> D -> A: 3 steps
A -> B -> C -> A: 2 steps
A -> B -> C -> C: 2 steps
A -> B -> C -> B: also 2 steps

Testcases:

4 3 0 1 2 -> 0 3 4 1 2 -> 4 3 2 1 0 -> 4 3 2 1 0: 2 steps 
4 3 2 1 0 -> 4 3 2 1 0: 0 steps
4 3 1 2 0 -> 4 1 3 2 0 -> 4 3 2 1 0 -> 4 3 2 1 0: 2 steps
1 2 3 0 4 -> 4 1 0 3 2 -> 0 3 4 1 2 -> 4 3 2 1 0 -> 4 3 2 1 0: 3 steps
5 1 2 3 0 4 -> 0 5 3 2 1 4 -> 1 5 3 2 4 0 -> 1 4 3 2 0 5 -> 
  5 1 3 2 0 4 -> 0 5 3 2 1 4: 4 steps

Если ваш язык не поддерживает «функции», вы можете предположить, что последовательность задана в виде списка целых чисел, разделенных пробелами, таких как 0 1 2или 3 1 0 2в одной строке.

Забавные факты:

• последовательность 0,1,2,3, .., N всегда преобразуется в N, ..., 3,2,1,0
• последовательность N, .., 3,2,1,0 всегда преобразуется в N, .., 3,2,1,0
• последовательность 0,1,3,2, ..., N + 1, N всегда преобразуется в N, ..., 3,2,1,0

Бонусное задание : выяснить математическую формулу.

Необязательные правила :

• Если первый индекс вашего языка равен 1 вместо 0, вы можете использовать перестановки 1..N(вы можете просто добавить один к каждому целому числу в примере и тестовых случаях).

JavaScript (ES6), 54 байта

a=>~(g=a=>g[a]||~-g(g[a]=a.map(i=>a[i]).reverse()))(a)

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

Python 2 , 67 байт

f=lambda l,*h:len(h)-1if l in h else f([l[i]for i in l][::-1],l,*h)

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

Pyth, 10 9 8 байт

tl.u@LN_

Объяснение:

t               One less than
 l              the number of values achieved by
  .u            repeating the following lambda N until already seen value:
    @LN_N         composing permutation N with its reverse
         Q      starting with the input.

Тестовый пакет .

Haskell, 52 байта

([]#)
a#x|elem x a= -1|n<-x:a=1+n#reverse(map(x!!)x)

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

a # x                -- function '#' takes a list of all permutations
                     -- seen so far (-> 'a') and the current p. (-> 'x')
  | elem x a = -1    -- if x has been seen before, return -1 
  | n<-x:a =         -- else let 'n' be the new list of seen p.s and return
    1 +              -- 1 plus
       n #           -- a recursive call of '#' with the 'n' and
        reverse ...  -- the new p.

([]#)                -- start with an empty list of seen p.s 

Perl 6 , 44 35 байт

-9 байт благодаря nwellnhof

{($_,{.[[R,] |$_]}...{%.{$_}++})-2}

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

Объяснение:

{                              }  # Anonymous code block
                  ...    # Create a sequence where:
  $_,  # The first element is the input list
     {.[[R,] |$_]} # Subsequent elements are the previous element reverse indexed into itself
                     {        }    # Until
                      %.{$_}       # The index of the listt in an anonymous hash is non-zero
                            ++     # Then post increment it
 (                            )-2  # Return the length of the sequence minus 2

J, 33 27 26 байт

-7 благодаря барботеру

_1(+~:i.0:)|.@C.~^:(<@!@#)

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

как

оригинальное объяснение. мое последнее улучшение только изменяет часть, которая находит «индекс первого элемента, который мы уже видели». теперь он использует "сито", чтобы сделать это в меньшем количестве байтов.

1 <:@i.~ [: ({: e. }:)\ |.@C.~^:(<@!@#)
                        |.@C.~          NB. self-apply permutation and reverse
                              ^:        NB. this many times:
                                (<@!@#) NB. the box of the factorial of the
                                        NB. the list len.  this guarantees
                                        NB. we terminate, and the box means
                                        NB. we collect all the results
         [: ({: e. }:)\                 NB. apply this to those results:
                      \                 NB. for each prefix
             {: e. }:                   NB. is the last item contained in 
                                        NB. the list of previous items?
1 <:@i.~                                NB. in that result find:
1    i.~                                NB. the index of the first 1
  <:@                                   NB. and subtract 1

Обратите внимание, что вся последняя фраза 1<:@i.~[:({:e.}:)\посвящена поиску «указателя первого элемента, который уже был замечен». Это кажется ужасно долгим для получения этого, но я больше не мог играть в гольф. Предложения приветствуются.

Желе , 6 байт

Ṛị$ƬL’

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

1-индексироваться.

Дьялог АПЛ, 29 28 27 байт

¯2∘+∘≢{⍵,⍨⊂⌽(⍋⍳⊢)⊃⍵}⍣{⍺≢∪⍺}

Принимает в штучной упаковке массивы. Обучу и объясню позже.

Попробуйте это здесь как набор тестов .

Чисто , 90 байт

import StdEnv
$l=length(until(\[h:t]=any((==)h)t)(\[h:t]=[reverse(map((!!)h)h),h:t])[l])-2

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