Bei einer gegebenen Folge von ganzen Zahlen oder genauer gesagt einer Permutation der 0..N Transformation lautet diese Folge wie folgt:

• ausgang [x] = rückwärts (eingang [eingang [x]])
• wiederholen

Zum Beispiel: [2,1,0]wird [0,1,2]und umgekehrt ist [2,1,0]. [0,2,1]wird [0,1,2]und umgekehrt [2,1,0].

Beispiel 1

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

Beispiel 2

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

Beispiel 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

Beispiel 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

Ihre Aufgabe ist es, eine Funktion (oder ein Programm) zu definieren, die eine Permutation von ganzen Zahlen verwendet 0..Nund die Anzahl der Schritte zurückgibt (oder ausgibt), bis eine bereits aufgetretene Permutation auftritt. Wenn zu Xtransformiert wird, sollte Xdie Ausgabe Null sein. Wenn Xzu Yund Yzu X(oder Y) transformiert wird, sollte die Ausgabe 1 sein.

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

Testfälle:

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

Wenn Ihre Sprache keine "Funktionen" unterstützt, können Sie davon ausgehen, dass die Sequenz als durch Leerzeichen getrennte Liste von Ganzzahlen wie 0 1 2oder 3 1 0 2in einer einzelnen Zeile angegeben wird.

Wissenswertes:

• Die Folge 0,1,2,3, .., N wird immer in N, ..., 3,2,1,0 transformiert
• Die Folge N, .., 3,2,1,0 wird immer in N, .., 3,2,1,0 transformiert
• Die Folge 0,1,3,2, ..., N + 1, N wird immer zu N, ..., 3,2,1,0 transformiert

Bonusaufgabe : Finde eine mathematische Formel heraus.

Optionale Regeln :

• Wenn der erste Index Ihrer Sprache 1 anstelle von 0 ist, können Sie Permutationen verwenden 1..N(Sie können jeder Ganzzahl im Beispiel und in den Testfällen einfach eine hinzufügen).

JavaScript (ES6), 54 Byte

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

Probieren Sie es online!

Python 2 , 67 Bytes

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

Probieren Sie es online!

Pyth, 10 9 8 Bytes

tl.u@LN_

Erläuterung:

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.

Testsuite .

Haskell, 52 Bytes

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

Probieren Sie es online!

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 Bytes

-9 bytes dank nwellnhof

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

Probieren Sie es online!

Erläuterung:

{                              }  # 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 Bytes

-7 dank bubbler

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

Probieren Sie es online!

Wie

ursprüngliche Erklärung. Meine letzte Verbesserung ändert nur das Stück, das "den Index des ersten Elements findet, das wir bereits gesehen haben". es verwendet jetzt das "Nubsieb", um dies in weniger Bytes zu tun.

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

Beachten Sie, dass der gesamte letzte Satz 1<:@i.~[:({:e.}:)\dem Auffinden "des Index des ersten Elements, das bereits gesehen wurde" gewidmet ist. Das scheint furchtbar lange zu dauern, aber ich konnte nicht mehr Golf spielen. Vorschläge sind willkommen.

Gelee , 6 Bytes

Ṛị$ƬL’

Probieren Sie es online!

1-indiziert.

Dyalog APL, 29 28 27 Bytes

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

Nimmt geschachtelte Arrays auf. Wird später trainieren und erklären.

Probieren Sie es hier als Testsuite aus .

Sauber , 90 Bytes

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

Probieren Sie es online!