Thử thách:

Đầu vào: Danh sách các số nguyên dương khác biệt trong phạm vi .$[1, \text{list-size}]$

Đầu ra: Một số nguyên: số lần danh sách được xáo trộn . Đối với một danh sách, điều này có nghĩa là danh sách được chia thành hai nửa và các nửa này được xen kẽ (nghĩa là xáo trộn danh sách [1,2,3,4,5,6,7,8,9,10]một lần sẽ dẫn đến [1,6,2,7,3,8,4,9,5,10], vì vậy đối với thử thách [1,6,2,7,3,8,4,9,5,10]này, kết quả đầu vào sẽ dẫn đến 1).

Quy tắc thử thách:

• Bạn có thể giả sử danh sách sẽ chỉ chứa các số nguyên dương trong phạm vi (hoặc nếu bạn chọn có danh sách đầu vào được lập chỉ mục 0 ).$[1, \text{list-size}]$$[0, \text{list-size}-1]$
• Bạn có thể giả sử tất cả các danh sách đầu vào sẽ là một danh sách xáo trộn hợp lệ hoặc một danh sách được sắp xếp không bị xáo trộn (trong trường hợp đó là đầu ra 0).
• Bạn có thể giả sử danh sách đầu vào sẽ chứa ít nhất ba giá trị.

Ví dụ từng bước:

Đầu vào: [1,3,5,7,9,2,4,6,8]

Xáo trộn nó một lần trở thành : [1,5,9,4,8,3,7,2,6], bởi vì mọi mục chẵn 0 chỉ mục đều đến trước [1, ,5, ,9, ,4, ,8], và sau đó tất cả các mục 0 chỉ mục lẻ sau đó [ ,3, ,7, ,2, ,6, ].
Danh sách chưa được đặt hàng, vì vậy chúng tôi tiếp tục:

Xáo trộn danh sách một lần nữa trở thành: [1,9,8,7,6,5,4,3,2]
Một lần nữa trở thành: [1,8,6,4,2,9,7,5,3]
Sau đó: [1,6,2,7,3,8,4,9,5]
Và cuối cùng : [1,2,3,4,5,6,7,8,9], đó là một danh sách được sắp xếp, vì vậy chúng tôi đã hoàn thành việc xáo trộn.

Chúng tôi đã xáo trộn [1,3,5,7,9,2,4,6,8]năm lần ban đầu để có được [1,2,3,4,5,6,7,8,9], vì vậy đầu ra là 5trong trường hợp này.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

Input                                                   Output

[1,2,3]                                                 0
[1,2,3,4,5]                                             0
[1,3,2]                                                 1
[1,6,2,7,3,8,4,9,5,10]                                  1
[1,3,5,7,2,4,6]                                         2
[1,8,6,4,2,9,7,5,3,10]                                  2
[1,9,8,7,6,5,4,3,2,10]                                  3
[1,5,9,4,8,3,7,2,6,10]                                  4
[1,3,5,7,9,2,4,6,8]                                     5
[1,6,11,5,10,4,9,3,8,2,7]                               6
[1,10,19,9,18,8,17,7,16,6,15,5,14,4,13,3,12,2,11,20]    10
[1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20]    17
[1,141,32,172,63,203,94,234,125,16,156,47,187,78,218,109,249,140,31,171,62,202,93,233,124,15,155,46,186,77,217,108,248,139,30,170,61,201,92,232,123,14,154,45,185,76,216,107,247,138,29,169,60,200,91,231,122,13,153,44,184,75,215,106,246,137,28,168,59,199,90,230,121,12,152,43,183,74,214,105,245,136,27,167,58,198,89,229,120,11,151,42,182,73,213,104,244,135,26,166,57,197,88,228,119,10,150,41,181,72,212,103,243,134,25,165,56,196,87,227,118,9,149,40,180,71,211,102,242,133,24,164,55,195,86,226,117,8,148,39,179,70,210,101,241,132,23,163,54,194,85,225,116,7,147,38,178,69,209,100,240,131,22,162,53,193,84,224,115,6,146,37,177,68,208,99,239,130,21,161,52,192,83,223,114,5,145,36,176,67,207,98,238,129,20,160,51,191,82,222,113,4,144,35,175,66,206,97,237,128,19,159,50,190,81,221,112,3,143,34,174,65,205,96,236,127,18,158,49,189,80,220,111,2,142,33,173,64,204,95,235,126,17,157,48,188,79,219,110,250]
                                                        45

Thạch , 8 byte

ŒœẎ$ƬiṢ’

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

Làm sao?

ŒœẎ$ƬiṢ’ - Link: list of integers A
    Ƭ    - collect up until results are no longer unique...
   $     -   last two links as a monad:
Œœ       -     odds & evens i.e. [a,b,c,d,...] -> [[a,c,...],[b,d,...]]
  Ẏ      -     tighten                         -> [a,c,...,b,d,...]
     Ṣ   - sort A
    i    - first (1-indexed) index of sorted A in collected shuffles
      ’  - decrement

JavaScript (ES6), 44 byte

Phiên bản ngắn hơn được đề xuất bởi @nwellnhof

Yêu cầu một cỗ bài với các thẻ 1 chỉ mục làm đầu vào.

f=(a,x=1)=>a[x]-2&&1+f(a,x*2%(a.length-1|1))

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

Cho một boong $[c_0,\ldots,c_{L-1}]$ chiều dài $L$ , chúng ta định nghĩa:

Và chúng tôi tìm sao cho .$n$$c_{x_n}=2$

JavaScript (ES6),  57 52  50 byte

Yêu cầu một cỗ bài với các thẻ 0 chỉ mục làm đầu vào.

f=(a,x=1,k=a.length-1|1)=>a[1]-x%k&&1+f(a,x*-~k/2)

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

Làm sao?

Vì JS thiếu hỗ trợ riêng để trích xuất các lát mảng với một bước tùy chỉnh, mô phỏng toàn bộ riffle-shuffle có thể sẽ khá tốn kém (nhưng thành thật mà nói, tôi thậm chí không thử). Tuy nhiên, giải pháp cũng có thể được tìm thấy bằng cách chỉ nhìn vào thẻ thứ 2 và tổng số thẻ trong bộ bài.

Cho một cỗ bài có chiều dài , mã này tìm kiếm sao cho:$L$$n$

Trong đó là thẻ thứ hai và được định nghĩa là:$c_2$$k$

Python 2 , 39 byte

f=lambda x:x[1]-2and-~f(x[::2]+x[1::2])

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

-4 cảm ơn Jonathan Allan .

R , 58 55 45 byte

a=scan();while(a[2]>2)a=matrix(a,,2,F<-F+1);F

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

Mô phỏng quá trình phân loại. Đầu vào là 1 chỉ mục, trả về FALSE0.

Perl 6 , 34 32 byte

-2 byte nhờ Jo King

{(.[(2 X**^$_)X%$_-1+|1]...2)-1}

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

Tương tự như cách tiếp cận của Arnauld . Chỉ số của thẻ thứ hai sau n shuffles là 2**n % kvới k được định nghĩa như trong câu trả lời của Arnauld.

APL (Dyalog Unicode) , 35 26 23 22 byte ^SBCS

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}

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

Cảm ơn Adám vì sự giúp đỡ, Erik Outgolfer cho -3 và ngn cho -1.

Liên kết TIO chứa hai trường hợp thử nghiệm.

Giải trình:

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}
{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]} ⍝ function takes one argument: ⍵, the array
 ⍵≡⍳≢⍵                 ⍝ if the array is sorted:
 ⍵≡⍳≢⍵                 ⍝ array = 1..length(array)
      :0               ⍝ then return 0
        ⋄              ⍝ otherwise
         1+            ⍝ increment
           ∇           ⍝ the value of the recursive call with this argument:
            ⍵[      ]  ⍝ index into the argument with these indexes:
                 ⍳⍴⍵   ⍝ - generate a range from 1 up to the size of ⍵
               2|      ⍝ - %2: generate a binary mask like [1 0 1 0 1 0]
              ⍒        ⍝ - grade (sorts but returns indexes instead of values), so we have the indexes of all the 1s first, then the 0s.

¹

Perl 6 , 36 34 32 byte

-2 byte nhờ nwellnhof

$!={.[1]-2&&$!(.sort:{$++%2})+1}

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

Đảo ngược xáo trộn xáo trộn bằng cách sắp xếp theo chỉ số modulo 2 cho đến khi danh sách được sắp xếp, sau đó trả về độ dài của chuỗi.

Thật buồn cười, tôi thường không thử cách tiếp cận đệ quy cho Perl 6, nhưng lần này nó kết thúc ngắn hơn so với ban đầu.

Giải trình:

$!={.[1]-2&&$!(.sort:{$++%2})+1}
$!={                           }   # Assign the anonymous code block to $!
    .[1]-2&&                       # While the list is not sorted
            $!(             )      # Recursively call the function on
               .sort:{$++%2}       # It sorted by the parity of each index
                             +1    # And return the number of shuffles

05AB1E (di sản) , 9 byte

[DāQ#ι˜]N

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

Giải trình

[   #  ]     # loop until
  ā          # the 1-indexed enumeration of the current list
 D Q         # equals a copy of the current list
     ι˜      # while false, uninterleave the current list and flatten
        N    # push the iteration index N as output

Java (JDK) , 59 byte

a->{int c=0;for(;a[(1<<c)%(a.length-1|1)]>2;)c++;return c;}

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

Chỉ hoạt động đáng tin cậy cho các mảng có kích thước nhỏ hơn 31 hoặc các giải pháp có ít hơn 31 lần lặp. Để biết giải pháp tổng quát hơn, hãy xem giải pháp sau với 63 byte:

a->{int i=1,c=0;for(;a[i]>2;c++)i=i*2%(a.length-1|1);return c;}

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

Giải trình

Trong một đoạn ngắn, vị trí tiếp theo là một lần trước hai lần modulo nếu là số lẻ hoặc độ dài - 1 nếu là số chẵn.

Vì vậy, tôi đang lặp lại tất cả các chỉ số bằng cách sử dụng công thức này cho đến khi tôi tìm thấy giá trị 2 trong mảng.

Tín dụng

• -8 byte nhờ Kevin Cruijssen . (Thuật toán trước, sử dụng mảng)
• -5 byte nhờ Arnauld .

J , 28 26 byte

-2 byte nhờ Jonah!

 1#@}.(\:2|#\)^:(2<1{])^:a:

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

Lấy cảm hứng là giải pháp APL của Ven.

Giải trình:

               ^:       ^:a:   while 
                 (2<1{])       the 1-st (zero-indexed) element is greater than 2   
     (        )                do the following and keep the intermediate results
          i.@#                 make a list form 0 to len-1
        2|                     find modulo 2 of each element
      /:                       sort the argument according the list of 0's and 1's
1  }.                          drop the first row of the result
 #@                            and take the length (how many rows -> steps)     

K (ngn / k) , 25 byte

Cảm ơn ngn vì lời khuyên và cho phiên dịch K của mình!

{#1_{~2=x@1}{x@<2!!#x}\x}

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

APL (NARS), ký tự 49, byte 98

{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}

Tại sao sử dụng trong vòng lặp sâu nhất, một thuật toán nên là nlog (n), khi chúng ta có thể sử dụng một n tuyến tính? chỉ cho vài byte nữa? [⍵≡⍵ [⍋⍵] O (nlog n) và đối đầu với từng yếu tố để xem theo thứ tự sử dụng phép thử ∧ / ¯1 ↓ 1⌽⍵ O (n)]:

  f←{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}
  f ,1
0
  f 1 2 3
0
  f 1,9,8,7,6,5,4,3,2,10
3
  f 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20
17

Ruby , 42 byte

f=->d,r=1{d[r]<3?0:1+f[d,r*2%(1|~-d.max)]}

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

Làm sao:

Tìm kiếm số 2 bên trong mảng: nếu nó ở vị trí thứ hai, bộ bài không bị xáo trộn, nếu không hãy kiểm tra các vị trí mà các lần xáo trộn liên tiếp sẽ đặt nó.

R , 70 72 byte

x=scan();i=0;while(any(x>sort(x))){x=c(x[y<-seq(x)%%2>0],x[!y]);i=i+1};i

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

Bây giờ xử lý các trường hợp shuffle không.

C (GCC) 64 63 byte

-1 byte từ nwellnhof

i,r;f(c,v)int*v;{for(i=r=1;v[i]>2;++r)i=i*2%(c-1|1);return~-r;}

Đây là một câu trả lời ngắn gọn hơn dựa trên câu trả lời của Arnauld và Olivier Grégoire. Tôi sẽ để lại giải pháp cũ của mình bên dưới vì nó giải quyết được vấn đề chung hơn một chút về các cỗ bài với các thẻ không tiếp giáp nhau.

Dùng thử trực tuyến

C (GCC) 162 byte

a[999],b[999],i,r,o;f(c,v)int*v;{for(r=0;o=1;++r){for(i=c;i--;(i&1?b:a)[i/2]=v[i])o=(v[i]>v[i-1]|!i)&o;if(o)return r;for(i+=o=c+1;i--;)v[i]=i<o/2?a[i]:b[i-o/2];}}

Dùng thử trực tuyến

a[999],b[999],i,r,o; //pre-declare variables
f(c,v)int*v;{ //argument list
    for(r=0;o=1;++r){ //major loop, reset o (ordered) to true at beginning, increment number of shuffles at end
        for(i=c;i--;(i&1?b:a)[i/2]=v[i]) //loop through v, split into halves a/b as we go
            o=(v[i]>v[i-1]|!i)&o; //if out of order set o (ordered) to false
        if(o) //if ordered
            return r; //return number of shuffles
        //note that i==-1 at this point
        for(i+=o=c+1;i--;)//set i=c and o=c+1, loop through v
            v[i]=i<o/2?a[i]:b[i-o/2];//set first half of v to a, second half to b
    }
}

R, 85 byte

s=scan();u=sort(s);k=0;while(any(u[seq(s)]!=s)){k=k+1;u=as.vector(t(matrix(u,,2)))};k

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

Giải trình

Phương pháp ngu ngốc (vũ phu), kém thanh lịch hơn nhiều so với làm theo thẻ số 2.

Thay vì xáo trộn đầu vào, schúng ta bắt đầu với một vectơ được sắp xếp umà chúng ta xáo trộn dần dần cho đến khi nó giống hệt nhau s. Điều này đưa ra các cảnh báo (nhưng số lần xáo trộn vẫn chính xác) đối với độ dài đầu vào lẻ ​​do gấp một vectơ có độ dài lẻ thành ma trận 2 cột; trong trường hợp đó, trong R, điểm dữ liệu bị thiếu được lấp đầy bằng cách tái chế phần tử đầu tiên.

Vòng lặp sẽ không bao giờ chấm dứt nếu chúng ta cung cấp một vectơ không thể xáo trộn.

Phụ lục: bạn lưu một byte nếu không xáo trộn thay thế. Không giống như câu trả lời ở trên, không cần phải chuyển đổi với t(), tuy nhiên, thứ tự byrow=TRUElà lý do tại sao Txuất hiện trong matrix().

R , 84 byte

s=scan();u=sort(s);k=0;while(any(s[seq(u)]!=u)){k=k+1;s=as.vector(matrix(s,,2,T))};k

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

PowerShell , 116 114 108 84 78 byte

-24 byte nhờ vào giải pháp của Erik the Outgolfer .

-6 byte nhờ mazzy .

param($a)for(;$a[1]-2){$n++;$t=@{};$a|%{$t[$j++%2]+=,$_};$a=$t.0+$t.1;$j=0}+$n

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

Ngôn ngữ Wolfram (Mathicala) , 62 byte

c=0;While[Sort[a]!=a,a=a[[1;;-1;;2]]~Join~a[[2;;-1;;2]];c++];c

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

Giải trình

Danh sách đầu vào là a. Nó không được chỉnh sửa và so sánh với danh sách được sắp xếp cho đến khi chúng khớp.

Đỏ , 87 79 78 byte

func[b][c: 0 while[b/2 > 2][c: c + 1 b: append extract b 2 extract next b 2]c]

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

Perl 5 -pa , 77 byte

map{push@{$_%2},$_}0..$#F;$_=0;++$_,@s=sort{$a-$b}@F=@F[@0,@1]while"@F"ne"@s"

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

Bình thường , 18 byte

L?SIb0hys%L2>Bb1
y

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

-2 cảm ơn @Erik the Outgolfer.

Kịch bản có hai dòng: dòng đầu tiên xác định hàm y, dòng thứ hai gọi yvới đối số ẩn Q(đánh giá stdin).

L?SIb0hys%L2>Bb1
L                function y(b)
 ?               if...
  SIb            the Invariant b == sort(b) holds
     0           return 0
      h          otherwise increment...
       y         ...the return of a recursive call with:
             B   the current argument "bifurcated", an array of:
              b   - the original argument
            >  1  - same with the head popped off
          L      map...
         % 2     ...take only every 2nd value in each array
        s         and concat them back together

¹

PowerShell , 62 71 70 66 byte

+9 byte khi Các trường hợp kiểm tra có số phần tử chẵn được thêm vào.

-1 byte với tính năng ghép hình.

-4 byte: bọc biểu thức với $i, $jđến một phạm vi mới.

for($a=$args;$a[1]-2;$a=&{($a|?{++$j%2})+($a|?{$i++%2})}){$n++}+$n

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

Japt , 13 11 10 byte

Lấy trình thông dịch sáng bóng, mới , rất tiến bộ của tôi để lái thử.

ÅÎÍ©ÒßUñÏu

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

ÅÎÍ©ÒßUñÏu     :Implicit input of integer array U
Å              :Slice the first element off U
 Î             :Get the first element
  Í            :Subtract from 2
   ©           :Logical AND with
    Ò          :  Negation of bitwise NOT of
     ß         :  A recursive call to the programme with input
      Uñ       :    U sorted
        Ï      :    By 0-based indices
         u     :    Modulo 2

Python 3, 40 byte

f=lambda x:x[1]-2and 1+f(x[::2]+x[1::2])  # 1-based
f=lambda x:x[1]-1and 1+f(x[::2]+x[1::2])  # 0-based

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

Tôi cần làm mới trang thường xuyên hơn: bỏ lỡ chỉnh sửa của Erik the Outgolfer khi thực hiện một thủ thuật tương tự =)