Étant donné une séquence d'entiers ou pour être plus spécifique une permutation de 0..N transformer cette séquence comme suit:

• sortie [x] = inverse (entrée [entrée [x]])
• répéter

Par exemple: [2,1,0]devient [0,1,2]et inversé est [2,1,0]. [0,2,1]devient [0,1,2]et inversé [2,1,0].

Exemple 1

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

Exemple 2

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

Exemple 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

Exemple 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

Votre tâche consiste à définir une fonction (ou un programme) qui accepte une permutation d'entiers 0..Net renvoie (ou génère) le nombre d'étapes jusqu'à ce qu'une permutation se produise déjà. Si se Xtransforme en Xalors la sortie doit être nulle, Si se Xtransforme en Yet Yvers X(ou Y) alors la sortie doit être 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

Si votre langue ne prend pas en charge les "fonctions", vous pouvez supposer que la séquence est donnée sous forme de liste séparée par des espaces d'espaces tels que 0 1 2ou 3 1 0 2sur une seule ligne.

Faits amusants:

• la séquence 0,1,2,3, .., N se transformera toujours en N, ..., 3,2,1,0
• la séquence N, .., 3,2,1,0 se transformera toujours en N, .., 3,2,1,0
• la séquence 0,1,3,2, ..., N + 1, N se transformera toujours en N, ..., 3,2,1,0

Tâche bonus : trouver une formule mathématique.

Règles optionnelles :

• Si le premier index de votre langue est 1 au lieu de 0, vous pouvez utiliser des permutations 1..N(vous pouvez simplement ajouter un à chaque entier dans l'exemple et les cas de test).

JavaScript (ES6), 54 octets

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

Essayez-le en ligne!

Python 2 , 67 octets

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

Essayez-le en ligne!

Pyth, 10 9 8 octets

tl.u@LN_

Explication:

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.

Suite de tests .

Haskell, 52 octets

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

Essayez-le en ligne!

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 octets

-9 octets grâce à nwellnhof

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

Essayez-le en ligne!

Explication:

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

-7 grâce au bubbler

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

Essayez-le en ligne!

Comment

explication originale. ma dernière amélioration ne change que la pièce qui trouve "l'index du premier élément que nous avons déjà vu". il utilise maintenant le "tamis nub" pour le faire en moins d'octets.

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

Notez que la phrase finale entière 1<:@i.~[:({:e.}:)\est consacrée à trouver "l'index du premier élément qui a déjà été vu". Cela semble terriblement long pour l'obtenir, mais je n'ai pas pu jouer au golf plus. Suggestions bienvenues.

Gelée , 6 octets

Ṛị$ƬL’

Essayez-le en ligne!

1 indexé.

Dyalog APL, 29 28 27 octets

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

Prend des tableaux en boîte. S'entraînera et expliquera plus tard.

Essayez-le ici comme suite de tests .

Nettoyer , 90 octets

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

Essayez-le en ligne!