Đưa ra một chuỗi các số nguyên hoặc cụ thể hơn là hoán vị 0..N biến đổi chuỗi này như sau:

• đầu ra [x] = đảo ngược (đầu vào [đầu vào [x]])
• nói lại

Ví dụ: [2,1,0]trở thành [0,1,2]và đảo ngược là [2,1,0]. [0,2,1]trở thành [0,1,2]và đảo ngược [2,1,0].

ví dụ 1

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

Ví dụ 2

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

Ví dụ 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

Ví dụ 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

Nhiệm vụ của bạn là xác định một hàm (hoặc chương trình) có hoán vị số nguyên 0..Nvà trả về (hoặc đầu ra) số bước cho đến khi xảy ra hoán vị đã xảy ra. Nếu Xbiến đổi thành Xthì đầu ra phải bằng 0, Nếu Xbiến đổi thành Yvà Ythành X(hoặc Y) thì đầu ra phải là 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

Testcase:

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

Nếu ngôn ngữ của bạn không hỗ trợ "các hàm", bạn có thể giả sử rằng chuỗi được đưa ra dưới dạng danh sách các số nguyên được phân tách bằng khoảng trắng như 0 1 2hoặc 3 1 0 2trên một dòng.

Những điều lý thú:

• dãy 0,1,2,3, .., N sẽ luôn biến đổi thành N, ..., 3,2,1,0
• dãy N, .., 3,2,1,0 sẽ luôn biến đổi thành N, .., 3,2,1,0
• chuỗi 0,1,3,2, ..., N + 1, N sẽ luôn biến đổi thành N, ..., 3,2,1,0

Nhiệm vụ tiền thưởng : Chỉ ra một công thức toán học.

Quy tắc tùy chọn :

• Nếu chỉ mục đầu tiên của ngôn ngữ của bạn là 1 thay vì 0, bạn có thể sử dụng hoán vị 1..N(bạn chỉ có thể thêm một cho mỗi số nguyên trong ví dụ và testcase).

JavaScript (ES6), 54 byte

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

Hãy thử trực tuyến!

Python 2 , 67 byte

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

Hãy thử trực tuyến!

Bình thường, 10 9 8 byte

tl.u@LN_

Giải trình:

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.

Bộ thử nghiệm .

Haskell, 52 byte

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

Hãy thử trực tuyến!

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 byte

-9 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Giải trình:

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

-7 nhờ bong bóng

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

Hãy thử trực tuyến!

làm sao

giải thích ban đầu. cải tiến cuối cùng của tôi chỉ thay đổi phần tìm thấy "chỉ mục của phần tử đầu tiên chúng ta đã thấy". bây giờ nó sử dụng "nub sàng" để làm điều đó với ít byte hơn.

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

Lưu ý toàn bộ cụm từ cuối cùng 1<:@i.~[:({:e.}:)\được dành cho việc tìm kiếm "chỉ mục của yếu tố đầu tiên đã được nhìn thấy." Điều này có vẻ rất dài để có được điều đó, nhưng tôi đã không thể chơi nó nhiều hơn. Gợi ý chào mừng.

Thạch , 6 byte

Ṛị$ƬL’

Hãy thử trực tuyến!

1 chỉ mục.

APL Dyalog, 29 28 27 byte

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

Đưa mảng đóng hộp. Sẽ đào tạo và giải thích sau.

Hãy thử nó ở đây như là một bộ thử nghiệm .

Sạch , 90 byte

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

Hãy thử trực tuyến!