Trong khi vẽ nguệch ngoạc với các con số, tôi đã tìm thấy một hoán vị thú vị mà bạn có thể tạo ra từ một danh sách các số. Nếu bạn lặp lại cùng một hoán vị đủ thời gian, bạn sẽ luôn trở lại mảng ban đầu. Hãy sử dụng danh sách sau đây:

[1, 2, 3, 4, 5]

làm ví dụ

1. Đảo ngược mảng. Bây giờ mảng của chúng tôi là

   [5, 4, 3, 2, 1]
   

2. Sắp xếp lại (trao đổi) từng cặp. Danh sách của chúng tôi có 2 cặp: [5, 4]và [3, 2]. Thật không may, chúng tôi không thể nhóm 1thành một cặp, vì vậy chúng tôi sẽ để riêng nó. Sau khi hoán đổi từng cặp, mảng mới là:

   [4, 5, 2, 3, 1]
   

3. Lặp lại bước 1 và 2 cho đến khi chúng tôi trở lại mảng ban đầu. Dưới đây là 4 bước tiếp theo:

   Step 2:
   Start:          [4, 5, 2, 3, 1]
   Reversed:       [1, 3, 2, 5, 4]
   Pairs Swapped:  [3, 1, 5, 2, 4]
   
   Step 3:
   Start:          [3, 1, 5, 2, 4]
   Reversed:       [4, 2, 5, 1, 3]
   Pairs Swapped:  [2, 4, 1, 5, 3]
   
   Step 4:
   Start:          [2, 4, 1, 5, 3]
   Reversed:       [3, 5, 1, 4, 2]
   Pairs Swapped:  [5, 3, 4, 1, 2]
   
   Step 5:
   Start:          [5, 3, 4, 1, 2]
   Reversed:       [2, 1, 4, 3, 5]
   Pairs Swapped:  [1, 2, 3, 4, 5]
   
   # No more steps needed because we are back to the original array
   

   Nếu độ dài của danh sách, n là số lẻ, nó sẽ luôn thực hiện chính xác n bước để trở về mảng ban đầu. Nếu n chẵn, sẽ luôn mất 2 bước để trở về mảng ban đầu, trừ khi n là 2, trong trường hợp đó sẽ mất 1 bước (vì đảo ngược và hoán đổi là điều tương tự).

Nhiệm vụ của bạn cho ngày hôm nay (nếu bạn chọn chấp nhận nó) là trực quan hóa tập hợp các bước này cho danh sách các độ dài tùy ý. Bạn phải viết một chương trình hoặc hàm lấy một số nguyên dương n làm đầu vào và thực hiện tập hợp các bước này cho danh sách [1, n]. Bạn phải xuất từng bước trung gian trên đường đi, cho dù điều đó có nghĩa là in từng bước hoặc trả lại tất cả chúng dưới dạng danh sách các bước. Tôi không kén chọn định dạng đầu ra, miễn là rõ ràng rằng bạn đang tạo ra mọi bước. Điều này có nghĩa (ví dụ) bất kỳ trong số này:

• Xuất ra mỗi bước dưới dạng một danh sách cho STDOUT

• Trả về một danh sách các danh sách

• Trả về một danh sách các biểu diễn chuỗi của mỗi bước

• Trả về / xuất ra một ma trận

sẽ được chấp nhận

Bạn cũng phải xuất ra mảng ban đầu, cho dù điều đó đến ở cuối hay ở đầu là tùy thuộc vào bạn. (về mặt kỹ thuật, cả hai đều đúng)

Bạn sẽ phải xử lý trường hợp cạnh 2 bằng 1 bước thay vì 2 , vì vậy hãy đảm bảo giải pháp của bạn hoạt động với đầu vào là 2 (và 1 là trường hợp cạnh tiềm năng khác).

Như thường lệ, đây là môn đánh gôn , vì vậy các sơ hở tiêu chuẩn được áp dụng và cố gắng làm cho giải pháp của bạn ngắn hơn bất kỳ ngôn ngữ nào bạn chọn (hoặc thậm chí cố gắng đánh bại một ngôn ngữ khác thường ngắn hơn ngôn ngữ của bạn nếu bạn cảm thấy khó chịu cho một thử thách).

Kiểm tra IO

1: 
[1]


2: 
[1, 2]


3: 
[2, 3, 1]
[3, 1, 2]
[1, 2, 3]


4: 
[3, 4, 1, 2]
[1, 2, 3, 4]


5: 
[4, 5, 2, 3, 1]
[3, 1, 5, 2, 4]
[2, 4, 1, 5, 3]
[5, 3, 4, 1, 2]
[1, 2, 3, 4, 5]


7: 
[6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 6]
[4, 6, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 7, 5]
[7, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7]


9: 
[8, 9, 6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 9, 6, 8]
[6, 8, 4, 9, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 9, 2, 8, 4, 6]
[4, 6, 2, 8, 1, 9, 3, 7, 5]
[7, 5, 9, 3, 8, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 8, 5, 9, 7]
[9, 7, 8, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Và để có biện pháp tốt, đây là một trường hợp thử nghiệm khổng lồ:

27: 
[26, 27, 24, 25, 22, 23, 20, 21, 18, 19, 16, 17, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 9, 6, 11, 8, 13, 10, 15, 12, 17, 14, 19, 16, 21, 18, 23, 20, 25, 22, 27, 24, 26]
[24, 26, 22, 27, 20, 25, 18, 23, 16, 21, 14, 19, 12, 17, 10, 15, 8, 13, 6, 11, 4, 9, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 9, 2, 11, 4, 13, 6, 15, 8, 17, 10, 19, 12, 21, 14, 23, 16, 25, 18, 27, 20, 26, 22, 24]
[22, 24, 20, 26, 18, 27, 16, 25, 14, 23, 12, 21, 10, 19, 8, 17, 6, 15, 4, 13, 2, 11, 1, 9, 3, 7, 5]
[7, 5, 9, 3, 11, 1, 13, 2, 15, 4, 17, 6, 19, 8, 21, 10, 23, 12, 25, 14, 27, 16, 26, 18, 24, 20, 22]
[20, 22, 18, 24, 16, 26, 14, 27, 12, 25, 10, 23, 8, 21, 6, 19, 4, 17, 2, 15, 1, 13, 3, 11, 5, 9, 7]
[9, 7, 11, 5, 13, 3, 15, 1, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 26, 14, 24, 16, 22, 18, 20]
[18, 20, 16, 22, 14, 24, 12, 26, 10, 27, 8, 25, 6, 23, 4, 21, 2, 19, 1, 17, 3, 15, 5, 13, 7, 11, 9]
[11, 9, 13, 7, 15, 5, 17, 3, 19, 1, 21, 2, 23, 4, 25, 6, 27, 8, 26, 10, 24, 12, 22, 14, 20, 16, 18]
[16, 18, 14, 20, 12, 22, 10, 24, 8, 26, 6, 27, 4, 25, 2, 23, 1, 21, 3, 19, 5, 17, 7, 15, 9, 13, 11]
[13, 11, 15, 9, 17, 7, 19, 5, 21, 3, 23, 1, 25, 2, 27, 4, 26, 6, 24, 8, 22, 10, 20, 12, 18, 14, 16]
[14, 16, 12, 18, 10, 20, 8, 22, 6, 24, 4, 26, 2, 27, 1, 25, 3, 23, 5, 21, 7, 19, 9, 17, 11, 15, 13]
[15, 13, 17, 11, 19, 9, 21, 7, 23, 5, 25, 3, 27, 1, 26, 2, 24, 4, 22, 6, 20, 8, 18, 10, 16, 12, 14]
[12, 14, 10, 16, 8, 18, 6, 20, 4, 22, 2, 24, 1, 26, 3, 27, 5, 25, 7, 23, 9, 21, 11, 19, 13, 17, 15]
[17, 15, 19, 13, 21, 11, 23, 9, 25, 7, 27, 5, 26, 3, 24, 1, 22, 2, 20, 4, 18, 6, 16, 8, 14, 10, 12]
[10, 12, 8, 14, 6, 16, 4, 18, 2, 20, 1, 22, 3, 24, 5, 26, 7, 27, 9, 25, 11, 23, 13, 21, 15, 19, 17]
[19, 17, 21, 15, 23, 13, 25, 11, 27, 9, 26, 7, 24, 5, 22, 3, 20, 1, 18, 2, 16, 4, 14, 6, 12, 8, 10]
[8, 10, 6, 12, 4, 14, 2, 16, 1, 18, 3, 20, 5, 22, 7, 24, 9, 26, 11, 27, 13, 25, 15, 23, 17, 21, 19]
[21, 19, 23, 17, 25, 15, 27, 13, 26, 11, 24, 9, 22, 7, 20, 5, 18, 3, 16, 1, 14, 2, 12, 4, 10, 6, 8]
[6, 8, 4, 10, 2, 12, 1, 14, 3, 16, 5, 18, 7, 20, 9, 22, 11, 24, 13, 26, 15, 27, 17, 25, 19, 23, 21]
[23, 21, 25, 19, 27, 17, 26, 15, 24, 13, 22, 11, 20, 9, 18, 7, 16, 5, 14, 3, 12, 1, 10, 2, 8, 4, 6]
[4, 6, 2, 8, 1, 10, 3, 12, 5, 14, 7, 16, 9, 18, 11, 20, 13, 22, 15, 24, 17, 26, 19, 27, 21, 25, 23]
[25, 23, 27, 21, 26, 19, 24, 17, 22, 15, 20, 13, 18, 11, 16, 9, 14, 7, 12, 5, 10, 3, 8, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 8, 5, 10, 7, 12, 9, 14, 11, 16, 13, 18, 15, 20, 17, 22, 19, 24, 21, 26, 23, 27, 25]
[27, 25, 26, 23, 24, 21, 22, 19, 20, 17, 18, 15, 16, 13, 14, 11, 12, 9, 10, 7, 8, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]

Chúc bạn chơi golf vui vẻ!

TI-Basic (sê-ri 83), 58 57 54 byte (104 ký tự)

:seq(I,I,1,Ans→A
:Ans→B
:Repeat prod(Ans=ᶫB
:ᶫB→C
:int(⁻Ans/2→D
:SortD(ᶫC,ᶫA
:SortD(ᶫD,ᶫA
:Pause ᶫA
:End

Giải trình

Đưa đầu vào vào Ans (ví dụ: ghi 5:prgmNAMEđể sử dụng danh sách kích thước năm).

Tạo ba danh sách phụ trợ của kích thước đã cho (được tạo lại từ ᶫBmỗi bước): ᶫB = ᶫC = {1,2,3,4,5,...}và ᶫD = {-1,-1,-2,-2,-3,...}. Ở mỗi bước, sắp xếp ᶫCvà ᶫDtheo thứ tự giảm dần, áp dụng cùng một hoán vị cho ᶫA. Trong trường hợp ᶫC, điều này đảo ngược ᶫAvà trong trường hợp ᶫD, điều này hoán đổi các cặp liền kề vì TI-Basic sử dụng triển khai sắp xếp lựa chọn thực sự ngu ngốc để SortD(sắp xếp lại càng nhiều phần tử giống nhau càng tốt. Khi nàoᶫA bằng với ᶫBmột lần nữa, chúng ta dừng lại.

Không, nghiêm túc, thuật toán sắp xếp tích hợp của họ là khiếu nại lớn thứ hai của tôi với trình thông dịch TI-Basic. (Khiếu nại lớn nhất của tôi là có bao nhiêu vòng lặp lồng nhau làm chậm trình thông dịch, vì dữ liệu vòng lặp được lưu trữ trong một ngăn xếp, nhưng ngăn xếp được phát triển từ đầu sai, do đó máy tính phải di chuyển toàn bộ ngăn xếp mỗi khi một phần tử được đẩy hoặc xuất hiện.) Nhưng lần này, thật tiện lợi.

-1 byte: Pauselưu trữ giá trị mà nó đang in Ans, ngắn hơn để tham chiếu ᶫA.

-3 byte: lấy đầu vào Ans

Thạch , 10 byte

RµUs2UFµÐĿ

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

Giải trình

RµUs2UFµÐĿ  Main link
R           Generate the range
        ÐĿ  While the results are unique (collecting results)
 µUs2UFµ    Reverse and reorder
  U         Reverse
   s        Slice non-overlapping into length
    2       2
     U      Reverse (automatically vectorizes to depth 1)
      F     Flatten

chú thích

Nếu phạm vi ban đầu cần ở cuối, hãy thêm ṙ1vào mã cho 12 byte.

05AB1E , 13 11 byte

LIGÂ2ôí˜})Ù

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

Giải trình

L             # range [1 ... input]
 IG           # input-1 times do:
   Â          # bifurcate
    2ô        # split into pieces of 2
      í       # reverse each
       ˜      # flatten
        }     # end loop
         )    # wrap stack in a list
          Ù   # remove duplicates

JavaScript (ES6), 89 85

Chỉnh sửa 4 byte đã lưu thx @JustinMariner

Sử dụng thực tế là khi bất kỳ yếu tố nào ở đúng nơi, tất cả các yếu tố là.

n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

Ít chơi gôn

n => {
  for(l=[], i=0; i<n; l[i] = ++i);
  while( alert(l=l.reverse().map( (x,i) => l[i^1] || x)),
         l[0]-1);
}

Kiểm tra

var F=
n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

alert=x=>console.log(x+'') // to avoid popup stress

function update() {
  F(+I.value);
} 

update()

<input type=number id=I value=1 min=1 oninput='update()'>

Toán học, 142 byte

(h=Range@#;W={};For[i=1,i<=#,i++,s=Reverse@h;AppendTo[W,h=Join[f=Flatten[Reverse/@Partition[s,{2}]],s~Complement~f]];s=h];DeleteDuplicates@W)&

JavaScript (ES6), 79 byte

f=(n,a=[...Array(n)],b=a.map((x,i)=>n-((x?x-1:i)^1)||1))=>b[0]>1?b+`
`+f(n,b):b

Xuất ra một danh sách cho mỗi bước.

Lưu ý rằng chúng ta không cần phải khởi tạo mảng để bắt bóng. Nếu chưa được khởi tạo ( xkhông xác định), chúng ta có thể sử dụng các chỉ số (tham số i) của mảng để thực hiện bước đầu tiên:

b=a.map((x,i)=>n-((x?x-1:i)^1)||1)

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

f=(n,a=[...Array(n)],b=a.map((x,i)=>n-((x?x-1:i)^1)||1))=>b[0]>1?b+`
`+f(n,b):b

console.log(f(1));
console.log(f(2));
console.log(f(3));
console.log(f(4));
console.log(f(5));
console.log(f(7));
console.log(f(27));

R, 109 95 94 79 74 62 byte

Nếu thực tế là mã ném cảnh báo lên trên giải pháp thực tế (không có cảnh báo nếu nlà 1, 3 cảnh báo nếu nlà chẵn và ncảnh báo nếu nlà số lẻ) không phải là vấn đề, thì cách sau hoạt động tương tự như giải pháp trước đó, nhờ vào vectơ tái chế:

n=scan();m=1:n;w=0:n+2*1:0;while(print(m<-rev(m)[w[w<=n]])-1)n

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

Một lần nữa xin cảm ơn @Giuseppe vì đã giảm thêm 12 byte!

Trước đây, giải pháp không cảnh báo ở 94 byte:

n=scan();m=s=1:n;while(any(print(m<-rev(m)[c(if(n>1)2:1+rep(seq(0,n-2,2),e=2),n[n%%2])])!=s))n

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

Giải pháp gốc ở 109 byte :

n=scan();m=s=1:n;repeat{cat(m<-rev(m)[c(t(embed(s,min(n,2))[!!s[-n]%%2,]),n[n%%2])],"\n");if(all(m==s))break}

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

Japt , 20 18 15 12 byte

õ
£=ò2n)ÔcÃâ

Hãy thử nó ( -Rcờ cho mục đích trực quan hóa)

Lưu 1 byte nhờ vào ETHproductions.

               :Implicit input of integer U
õ              :Range [1,U]
\n             :Reassign to U
£              :Map
  ò            :  Partitions
   2           :    Of length 2
    n          :    Starting from the end
     )         :  End partition
      Ô        :  Reverse
       c       :  Flatten
 =             :  Reassign to U
        Ã      :End map
         â     :Deduplicate

Husk , 9 byte

U¡ȯṁ↔C2↔ḣ

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

            -- implicit input N                 |  3
         ḣ  -- list [1..N]                      | [1,2,3]
 ¡(     )   -- iterate the following function,  | [[1,2,3],[2,3,1],[3,1,2],[1,2,3],...
U           -- until the first repetition:      | [[1,2,3],[2,3,1],[3,1,2]]
       ↔    --   reverse                        |   [3,2,1]
     C2     --   cut into two                   |   [[3,2],[1]]
   ṁ↔       --   reverse each pair & flatten    |   [2,3,1]

Ruby , 64 57 52 50 byte

->x{(s=*w=1..x).map{s=w.map{|y|s[-y^1]||s[0]}}|[]}

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

Làm thế nào nó hoạt động:

Đầu tiên tạo phạm vi, sau đó lặp lại hoán vị x lần: sử dụng chỉ số âm, nhưng lật bit cuối cùng, để chúng ta có được chuỗi -2, -1, -4, -3 ... nếu x chẵn, điều này sẽ kết thúc tốt, nếu không chúng ta sẽ thêm phần tử còn lại vào cuối. Bước cuối cùng: lọc ra các mảng lặp lại (vì vậy chúng tôi bao gồm tất cả các trường hợp: x = 1, x = 2, số lẻ và số chẵn)

Haskell, 75 74 byte

g(a:b:c)=b:a:g c
g x=x
h=g.reverse
0!x|x<[2]=[x]|1<2=x:0!h x
p n=0!h[1..n]

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

g các giao dịch hoán đổi cặp đôi, h một bước duy nhất (đảo ngược + sắp xếp lại), !áp dụng nhiều lần h(và thu thập các kết quả trung gian) cho đến khi đơn hàng được phục hồi. Lưu ý: !lấy tham số bổ sung nhưng không được sử dụng 0chỉ để biến nó thành toán tử infix. Các chức năng chính pbắt đầu nó lên.

Chỉnh sửa: Cảm ơn @Angs cho một byte.

Java 8, 215 214 byte

import java.util.*;n->{Stack a=new Stack(),t;int i=0;for(;i<n;a.add(++i));t=(Stack)a.clone();Collections x=null;for(i=0;i<1|!a.equals(t);System.out.println(t))for(x.reverse(t),i=0;i<n;i++)if(i<n-1)x.swap(t,i,++i);}

Tôi đã cố gắng đánh gôn bằng cách sử dụng các mảng thực tế thay vì Danh sách, nhưng cả đảo ngược và hoán đổi sẽ chiếm quá nhiều byte .. Có thể nó có thể được kết hợp trong một vòng lặp (thay vì đảo ngược đầu tiên, sau đó hoán đổi), nhưng tôi vẫn chưa hiểu ra điều này.
Điều này chắc chắn có thể được chơi golf nhiều hơn, mặc dù.

Giải trình:

Hãy thử nó ở đây.

import java.util.*;           // Required import for Stack and Collections

n->{                          // Method with integer parameter and no return-type
  Stack a=new Stack(),        //  Original List
        t;                    //  Copy-List
  int i=0;                    //  Index-integer, starting at 0
  for(;i<n;a.add(++i));       //  Fill the original list with the integers
  t=(Stack)a.clone();         //  Make a copy of the List
  Collections x=null;         //  Static `Collections` to reduce bytes
  for(i=0;                    //  Reset index `i` to 0
      i<1                     //  Loop (1) as long as `i` is 0 (the first iteration),
      |!a.equals(t);          //  or the input array is not equal to the copy
      System.out.println(t))  //    After every iteration: print the modified List
    for(x.reverse(t),         //   Reverse the copied List
        i=0;                  //   Reset `i` to 0
        i<n;                  //   Inner loop (2) over the List
        i++)                  //     After every iteration: increase `i` by 1 again
      if(i<n-1)               //    Unless it's the last item in the List:
        x.swap(t,i,++i);      //     Swap the items at indexes `i` and `i+1` 
                              //     (by increasing `i` by 1 first with `++i`)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
}                             // End of method

Java (OpenJDK 8) , 257 245 243 226 206 205 byte

n->{int i=0,k,t[]=new int[n];while(i<n)t[i]=++i;do{for(i=0;i<n/2;t[i]=t[n+~i],t[n+~i++]=k)k=t[i];for(k=1;k<n;t[k]=t[--k],t[k]=i,k+=3)i=t[k];System.out.println(java.util.Arrays.toString(t));}while(t[0]>1);}

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

MATL , 17 byte

:`tP2ePXz!tG:-a]x

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

Giải trình

:       % Implicit input: n. Push [1 2 ... n]
`       % Do...while
  t     %   Duplicate
  P     %   Reverse
  2e    %   Reshape into a 2-row matrix. A final 0 is added if needed
  P     %   Reverse each column
  Xz    %   Nonzero entries (i.e. remove final 0 if present). Gives a column vector
  !     %   Transpose into a row
  t     %   Duplicate
  G:    %   Push [1 2 ... n] again
  -     %   Subtract element-wise
  a     %   Any. Gives true if there is at least a nonzero value
]       % End. Go to next iteration if top of the stack is true.  So the loop ends
        % when [1 2 ... n] has been found again
x       % Delete top of the stack (which is [1 2  ... n]). Implicit display

Stax , 17 byte

âΩÄ─g╫B♥C╛♠ƒ?|πcD

Chạy và gỡ lỗi nó

Giải trình

RX~Wr2/{r+}Fc|uPcx=C      # Full program, unpacked, implicit input
RX~                       # Create range, save to X register, pop back to input stack
   W                      # Start while loop until truthy value
    r                     # reverse array
     2/                   # Split into groups of 2
      {r+}F               # Loop through each set and reverse each
           c              # Copy top value
            |u            # Convert to string representation of array
              P           # Pop top value off
               cx=        # Copy top value, get value of x register, compare to top value
                  C       # If top value is truthy, cancel block and end

Giả sử nó hoạt động nhanh như nó, đã thử nghiệm tới 399 trước khi tôi không muốn tạm thời trình duyệt của mình nữa.

JavaScript (ES6), 122 byte

f=(n,a=[...Array(n)].map((_,i)=>i+1),r=[],b=a.map((_,i)=>a[n+~(i^1)]||a[0]))=>b.some((e,i)=>e>b[i+1],r.push(b))?f(n,b,r):r

r.push(a)có thể được sử dụng thay vì r.push(b)đặt hoán vị ban đầu ở phía trước.

Haskell , 97 byte

Điều này cảm thấy một chút dài :(

f n|x<-[1..n]=x:takeWhile(/=x)(tail$iterate((r=<<).g.r)x)
r=reverse
g[]=[]
g x=take 2x:g(drop 2x)

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

Giải thích / Ungolfed

-- starting with x, accumulate the results of repeatedly
-- applying the function permute
f n = x : takeWhile (/=x) (tail $ iterate permute x)
  where x = [1..n]
        -- reverse, cut2, reverse each pair & flatten
        permute = concatMap reverse . cut2 . reverse

-- recursively transform a list into groups of 2
cut2 [] = []
cut2 xs = take 2 xs : g (drop 2 xs)

Xếp chồng lên nhau , 42 byte

[~>[rev 2#<$revflatmap]periodsteps behead]

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

Thực hiện chuyển đổi đã cho bằng cách sử dụng periodstepsnội dung. Tuy nhiên, nội dung này trả về tất cả các phần tử, bao gồm phạm vi của đầu vào là các phần tử đầu tiên và cuối cùng của nó. Do đó, chúng tôi chặt đầu danh sách, trả lại tất cả trừ phần tử đầu tiên.

AWK , 123 byte

Không chặt chẽ, nhưng đây là điều tốt nhất tôi có thể nghĩ ra.

{for(N=$1;N>$i=++i;);for(;n++<(i%2?i:i>2?2:1);){for(k=0;k++<i;)K[k]=(z=i-k+(k-1)%2*2)?$z:$1;for(k=0;k++<N;){$k=K[k]}print}}

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

Python 2 , 165 159 138 81 byte

x=input()+1
b=a=range(1,x)
while b:b=[b[x-min(x,i+1^1)]for i in a];print b;b*=a<b

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

-20 byte nhờ @ChasBrown . (Thở dài, tôi đã thực hiện một thử thách toàn bộ về cú pháp cắt lát mở rộng)

Whoa! GolfStorm (-57 byte)! Cảm ơn Ian Gödel, tsh và Jonathan Frech.

JavaScript, 136 byte

(n)=>{for(a=[],i=0;i<n;a[i]=++i);for(j=0;j<(n&1?n:2);j++){a.reverse();for(i=0;i<a.length-1;i += 2)m=a[i],a[i]=a[i+1],a[i+1]=m;alert(a)}}