Xáo trộn riffle là một loại xáo trộn trong đó bộ bài được chia thành hai phân vùng và các phân vùng sau đó được ghép lại với nhau để tạo ra một bộ bài xáo trộn mới.

Các thẻ được ghép với nhau theo cách các thẻ duy trì trật tự tương đối của chúng trong phân vùng mà chúng là thành viên . Ví dụ: nếu thẻ A nằm trước thẻ B trong cỗ bài và thẻ A và B nằm trong cùng một phân vùng, thẻ A phải ở trước thẻ B trong kết quả cuối cùng, ngay cả khi số lượng thẻ giữa chúng tăng lên. Nếu A và B ở các phân vùng khác nhau, chúng có thể theo bất kỳ thứ tự nào, bất kể thứ tự bắt đầu của chúng, trong kết quả cuối cùng.

Mỗi shuffle riffle sau đó có thể được xem như là một hoán vị của bộ bài gốc. Ví dụ hoán vị

1,2,3 -> 1,3,2

là một shuffle riffle. Nếu bạn chia boong như vậy

1, 2 | 3

chúng tôi thấy rằng mọi thẻ trong 1,3,2đều có cùng thứ tự tương tự với mọi thẻ khác trong phân vùng của nó. 2vẫn là sau 1.

Mặt khác, hoán vị sau đây không phải là một shuffle riffle.

1,2,3 -> 3,2,1

Chúng ta có thể thấy điều này bởi vì tất cả hai phân vùng (không tầm thường)

1, 2 | 3
1 | 2, 3 

có một cặp thẻ không duy trì thứ tự tương đối của chúng. Trong phân vùng đầu tiên 1và 2thay đổi thứ tự của họ, trong khi trong phân vùng thứ hai 2và 3thay đổi thứ tự của họ.

Tuy nhiên, chúng tôi thấy rằng 3, 2, 1có thể được thực hiện bằng cách kết hợp hai xáo trộn riffle,

1, 3, 2 + 2, 3, 1 = 3, 2, 1

Trong thực tế, một thực tế khá đơn giản được chứng minh là bất kỳ hoán vị nào cũng có thể được thực hiện khi tôi kết hợp một số số hoán vị xáo trộn riffle.

Bài tập

Nhiệm vụ của bạn là tạo một chương trình hoặc hàm lấy hoán vị (có kích thước N ) làm đầu vào và xuất ra số lượng hoán vị xáo trộn nhỏ nhất (có kích thước N ) có thể được kết hợp để tạo thành hoán vị đầu vào. Bạn không cần phải xuất ra các riffle xáo trộn chính mình có bao nhiêu.

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

Bạn có thể xuất 1 hoặc 0 cho hoán vị danh tính.

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

1,3,2 -> 1
3,2,1 -> 2
3,1,2,4 -> 1
2,3,4,1 -> 1
4,3,2,1 -> 2

Python 3 , 255 byte

Kiểm tra tất cả các riffles có thể lên đến độ dài của danh sách (yêu cầu số lượng tối đa), vì vậy rất chậm cho đầu vào lớn hơn. Có lẽ cũng có thể được chơi golf một chút.

lambda x:f(range(1,len(x)+1),x)
f=lambda x,y,i=0:x==y and i or i<len(x)and min(f(q,y,i+1)for a in range(1,len(x))for q in g(x[:a],x[a:]))or i
g=lambda x,y:(x or y)and[[v]+q for v in x[:1]for q in g(x[1:],y)]+[[v]+q for v in y[:1]for q in g(x,y[1:])]or[[]]

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

Sạch , 206 ... 185 byte

import StdEnv
f=flatten
$a b#[c:d]=b
|a>[]#[u:v]=a
=[a++b,b++a:f[[[u,c:e],[c,u:e]]\\e<- $v d]]=[b]
@l#i=length l
=hd[n\\n<-[0..],e<-iter n(f o map(uncurry$o splitAt(i/2)))[[1..i]]|l==e]

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

Tạo mọi kết quả có thể có của nthời gian xáo trộn và kiểm tra xem danh sách có phải là thành viên không.
Mặc dù đây là một cách không hiệu quả khủng khiếp để giải quyết vấn đề, nhưng mã này đặc biệt chậm do sử dụng khả năng hiểu danh sách thay vì thành phần, điều này hạn chế rất nhiều bất kỳ việc giảm đồ thị cơ bản nào, và dẫn đến một màn trình diễn ngoạn mục của công cụ thu gom rác của Clean.

Ung dung:

import StdEnv
shuffle [] l
    = [l]
shuffle [a: b] [c: d]
    = [[a: b]++[c: d], [c: d]++[a: b]: flatten [
        [[a, c: e], [c, a: e]]
        \\ e <- shuffle b d
        ]]
numReq l
    = until cond ((+)1) 0
where
    cond n 
        = let
            mapper
                = map (uncurry shuffle o splitAt (length l/2))
            options
                = iter n (removeDup o flatten o mapper) [[1..length l]]
        in isMember l options

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