숫자로 낙서하는 동안 숫자 목록에서 생성 할 수있는 흥미로운 순열을 발견했습니다. 이 같은 순열을 여러 번 반복하면 항상 원래 배열로 돌아갑니다. 다음 목록을 사용하십시오.

[1, 2, 3, 4, 5]

예로서

1. 배열을 뒤집 습니다. 이제 우리 배열은

   [5, 4, 3, 2, 1]
   

2. 각 쌍을 재정렬 (스왑)하십시오. 우리의 목록에는 2 쌍이 있습니다 : [5, 4], [3, 2]. 불행히도, 우리는 1쌍으로 그룹화 할 수 없으므로 우리는 그것을 스스로 남겨 둘 것입니다. 각 쌍을 교체 한 후 새 배열은 다음과 같습니다.

   [4, 5, 2, 3, 1]
   

3. 원래 배열로 돌아갈 때까지 1 단계와 2 단계를 반복 하십시오. 다음 4 단계는 다음과 같습니다.

   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 이 홀수 인 경우 원래 배열로 돌아가려면 항상 정확히 n 단계를 수행합니다. 경우 n이 짝수, 항상, 원래의 배열로 반환이 개 조치를 취할 것입니다 하지 않는 n이 2 인 (반전과 교환하는 것은 같은 일 때문에)가 1 단계를 취할되는 경우.

오늘의 과제 (수락하기로 선택해야 함)는 임의의 길이 목록에 대해이 단계 세트를 시각화하는 것입니다. 단일 양의 정수 n 을 입력으로 사용하고 list에 대해이 단계 세트를 수행 하는 프로그램 또는 함수를 작성해야 합니다 [1, n]. 각 단계를 인쇄하거나 단계 목록으로 모두 리턴하는지 여부에 관계없이 중간 단계를 출력해야합니다. 모든 단계를 생성하고 있음이 분명하다면 출력 형식에 대해 까다 롭지 않습니다. 이것은 (예를 들어) 다음 중 하나를 의미합니다.

• 모든 단계를 STDOUT에 목록으로 출력

• 리스트리스트 리턴

• 각 단계의 문자열 표현 목록 반환

• 행렬 반환 / 출력

받아 들일 것입니다.

또한 원래 배열이 시작 부분에 있는지 또는 시작 부분에 있는지에 관계없이 원본 배열을 출력해야합니다. (기술적으로는 둘 다 맞습니다)

2 대신 1 단계를 복용하는 2의 경우를 처리 해야하므로 솔루션이 2의 입력으로 작동하는지 확인하십시오 (1은 또 다른 잠재적 인 경우입니다).

평소와 같이, 이것은 코드 골프입니다 . 따라서 표준 허점이 적용되며 원하는 언어로 솔루션을 더 짧게 만들거나 기분이 좋을 때 일반적으로 더 짧은 다른 언어를 이길 수 있습니다 도전).

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]

그리고 좋은 측정을 위해 여기에 하나의 거대한 테스트 사례가 있습니다.

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]

즐거운 골프 되세요!

TI 기본 (83 시리즈), 58 57 54 바이트 (104 자)

: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

설명

입력을 받습니다 Ans(예 : 5:prgmNAME크기가 5 인 목록을 사용하도록 작성).

(재현에서 주어진 크기의 세 개의 보조리스트 작성 ᶫB각각의 단계를) ᶫB = ᶫC = {1,2,3,4,5,...}과 ᶫD = {-1,-1,-2,-2,-3,...}. 각 단계 에서에 동일한 순열을 적용하여 정렬 ᶫC하고 ᶫD내림차순으로 정렬 합니다 ᶫA. 의 경우 ᶫC, 반대로,이 ᶫA경우 ᶫDTI-Basic은 가능한 한 많은 동일한 요소를 재정렬 하는 정말 어리석은 선택 정렬 구현 을 사용하기 때문에 인접한 쌍 SortD(을 교체합니다. 다시 ᶫA같을 때 ᶫB우리는 멈춘다.

진심으로, 내장 정렬 알고리즘은 TI-Basic 인터프리터에 대한 두 번째로 큰 불만입니다. (내 가장 큰 불만은 루프 데이터가 스택에 저장되기 때문에 많은 중첩 루프가 인터프리터를 느리게하는 것입니다. 그러나 스택이 잘못된 끝에서 자라므로 요소를 누를 때마다 계산기가 전체 스택 을 이동해야합니다 그러나 터지는.) 그러나 이번에는 편리하다.

-1 바이트 : Pause인쇄하고있는 값을 저장합니다 . Ans보다 참조보다 짧습니다 ᶫA.

-3 바이트 : 입력을받습니다 Ans

젤리 , 10 바이트

RµUs2UFµÐĿ

온라인으로 사용해보십시오!

설명

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

노트

원래 범위 가 끝에 있어야 하는 경우 ṙ112 바이트 코드에 추가하십시오 .

05AB1E , 13 11 바이트

LIGÂ2ôí˜})Ù

온라인으로 사용해보십시오!

설명

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

자바 스크립트 (ES6), 89 85

thx @JustinMariner로 저장된 4 바이트 편집

어떤 요소가 올바른 위치에있을 때 모든 요소가 있다는 사실을 사용합니다.

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

덜 골프

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);
}

테스트

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()'>

수학, 142 바이트

(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)&

자바 스크립트 (ES6), 79 바이트

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

각 단계에 대한 목록을 출력합니다.

볼 롤링을 얻기 위해 배열을 초기화하지 않아도됩니다. 초기화되지 않은 경우 ( x정의 되지 않은 경우 ) 배열의 인덱스 (parameter i)를 사용하여 첫 번째 단계를 수행 할 수 있습니다 .

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

테스트 사례 :

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 바이트

코드가 실제 솔루션 위에 경고를 던진다는 사실 ( n1 이면 경고 없음 , n짝수 이면 3 경고, 홀수이면 n경고 n)이 문제가 아닌 경우 벡터 덕분에 이전 솔루션과 유사하게 작동합니다. 재활용 :

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

온라인으로 사용해보십시오!

추가 12 바이트 를 줄인 @Giuseppe 에게 다시 한 번 감사드립니다 !

94 바이트의 이전 경고없는 솔루션 :

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

온라인으로 사용해보십시오!

109 바이트의 원래 솔루션 :

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}

온라인으로 사용해보십시오!

Japt , 20 18 15 12 바이트

õ
£=ò2n)ÔcÃâ

사용해보십시오 ( -R시각화 목적으로 만 플래그 지정)

ETH 프로덕션 덕분에 1 바이트가 절약되었습니다.

               :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

껍질 , 9 바이트

U¡ȯṁ↔C2↔ḣ

온라인으로 사용해보십시오!

            -- 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]

루비 , 64 57 52 50 바이트

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

온라인으로 사용해보십시오!

작동 방식 :

먼저 범위를 만든 다음 순열을 x 번 반복하십시오. 음수 색인을 사용하지만 마지막 비트를 뒤집으십시오. 따라서 시퀀스 -2, -1, -4, -3을 얻습니다. x가 짝수이면 끝납니다. 그렇지 않은 경우 나머지 요소를 끝에 추가합니다. 마지막 단계 : 반복 배열을 필터링하십시오 (그래서 우리는 모든 경우를 다룹니다 : x = 1, x = 2, 홀수 및 짝수)

하스켈, 75 74 바이트

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]

온라인으로 사용해보십시오!

gh단일 단계 (reverse + reorder) 인 페어 단위 스왑 은 순서가 복원 될 때까지 !반복적으로 적용 h하고 중간 결과를 수집합니다. 참고 : !추가 0연산자는 사용하지만 추가 연산자는 사용하지 않기 위해 추가 매개 변수 를 사용합니다. 주요 기능이 p시작됩니다.

편집 : 바이트에 대한 @Angs 덕분에.

자바 8, 214214 바이트

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);}

List 대신 실제 배열을 사용하여 골프를 쳤지 만 리버스와 스왑은 모두 너무 많은 바이트를 차지합니다. 아마도 하나의 루프 (먼저 리버스, 스왑 대신)로 결합 할 수는 있지만 아직은하지 않았습니다. 이것을 알아 내십시오.
그러나 이것은 확실히 더 골프를 칠 수 있습니다.

설명:

여기에서 시도하십시오.

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

자바 (오픈 JDK 8) , 257 (245) 243 226 206 205 바이트

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);}

온라인으로 사용해보십시오!

MATL , 17 바이트

:`tP2ePXz!tG:-a]x

온라인으로 사용해보십시오!

설명

:       % 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 바이트

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

실행 및 디버깅

설명

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

놀랍게도 더 빨리 작동하고 더 이상 브라우저를 시험하고 싶지 않기 전에 최대 399까지 테스트했습니다.

자바 스크립트 (ES6), 122 바이트

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)r.push(b)원래 순열을 앞에 두는 대신 사용할 수 있습니다 .

하스켈 , 97 바이트

이것은 조금 오래 느낀다 :(

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

온라인으로 사용해보십시오!

설명 / 비 골프

-- 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)

스택 , 42 바이트

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

온라인으로 사용해보십시오!

periodsteps내장을 사용하여 지정된 변환을 수행합니다 . 그러나이 기본 제공은 입력 범위를 첫 번째 및 마지막 요소로 포함하는 모든 요소를 ​​반환합니다. 따라서 첫 번째 요소를 제외한 모든 요소를 ​​반환하여 목록을 참았습니다.

AWK , 123 바이트

매우 빡빡하지는 않지만 이것이 내가 할 수있는 최선입니다.

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

온라인으로 사용해보십시오!

파이썬 (2) , 165 (159) 138 81 바이트

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

온라인으로 사용해보십시오!

@ChasBrown 덕분에 -20 바이트 . (한동안 확장 슬라이싱 구문에 대해 완전히 도전했습니다)

우와! GolfStorm (-57 바이트)! Ian Gödel, tsh 및 Jonathan Frech에게 감사합니다.

자바 스크립트, 136 바이트

(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)}}