Podczas rysowania liczbami znalazłem interesującą permutację, którą można wygenerować z listy liczb. Jeśli powtórzysz tę samą permutację wystarczająco dużo razy, zawsze znajdziesz się w oryginalnej tablicy. Skorzystajmy z poniższej listy:

[1, 2, 3, 4, 5]

jako przykład

1. Odwróć tablicę. Teraz nasza tablica jest

   [5, 4, 3, 2, 1]
   

2. Zmień kolejność (zamień) każdej pary. Nasza lista zawiera 2 pary: [5, 4]i [3, 2]. Niestety nie możemy pogrupować 1pary w parę, więc zostawimy ją samą. Po zamianie każdej pary nowa tablica jest:

   [4, 5, 2, 3, 1]
   

3. Powtarzaj kroki 1 i 2, aż wrócimy do oryginalnej tablicy. Oto kolejne 4 kroki:

   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
   

   Jeśli długość listy, n jest nieparzysta, zawsze zajmie dokładnie n kroków, aby powrócić do oryginalnej tablicy. Jeśli n jest parzyste, zawsze zajmie 2 kroki, aby powrócić do pierwotnej tablicy, chyba że n wynosi 2, w takim przypadku zajmie 1 krok (ponieważ odwracanie i zamiana to to samo).

Twoim zadaniem na dziś (jeśli zdecydujesz się go zaakceptować) jest wizualizacja tego zestawu kroków dla list o dowolnej długości. Musisz napisać program lub funkcję, która przyjmuje jedną dodatnią liczbę całkowitą n jako dane wejściowe i wykonuje ten zestaw kroków dla listy [1, n]. Musisz wydrukować każdy pośredni krok po drodze, niezależnie od tego, czy oznacza to wydrukowanie każdego kroku, czy zwrócenie ich wszystkich jako listy kroków. Nie jestem zbyt wybredna, jeśli chodzi o format wyjściowy, o ile jasne jest, że generujesz każdy krok. Oznacza to (na przykład) dowolny z tych:

• Wyprowadzanie każdego kroku jako listy do STDOUT

• Zwracanie listy list

• Zwracanie listy reprezentacji ciągów każdego kroku

• Zwracanie / wysyłanie macierzy

byłby do przyjęcia.

Musisz także wypisać oryginalną tablicę, niezależnie od tego, czy będzie to na końcu, czy na początku, tylko od Ciebie. (technicznie oba są poprawne)

Będziesz musiał poradzić sobie z przypadkiem krawędzi 2, biorąc 1 krok zamiast 2 , więc upewnij się, że twoje rozwiązanie działa z wejściem 2 (a 1 to kolejny potencjalny przypadek krawędzi).

Jak zwykle jest to gra w golfa , więc obowiązują standardowe luki i staraj się, aby twoje rozwiązanie było krótsze niż inne w wybranym języku (lub nawet spróbuj pokonać inny język, który jest zwykle krótszy niż twój, jeśli czujesz się lepiej na wyzwanie).

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

Na wszelki wypadek oto jeden gigantyczny przypadek testowy:

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]

Miłej zabawy w golfa!

TI-Basic (seria 83), 58 57 54 bajtów (104 znaki)

: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

Wyjaśnienie

Pobiera dane wejściowe Ans(np. Napisz, 5:prgmNAMEaby użyć list o rozmiarze pięciu).

Tworzy trzy listy pomocnicze o danym rozmiarze (które są odtwarzane ᶫBna każdym etapie): ᶫB = ᶫC = {1,2,3,4,5,...}i ᶫD = {-1,-1,-2,-2,-3,...}. Na każdym kroku sortuje ᶫCi ᶫDmalejąco, stosując tę ​​samą permutację do ᶫA. W przypadku ᶫCodwraca to ᶫA, aw przypadku ᶫDzamiany sąsiednich par, ponieważ TI-Basic używa naprawdę głupiej implementacji sortowania selekcji, dla SortD(której zmienia kolejność tylu identycznych elementów, jak to możliwe. Kiedy znów ᶫAjest równy ᶫB, zatrzymujemy się.

Nie, poważnie, ich wbudowany algorytm sortowania jest moją drugą co do wielkości skargą na interpreter TI-Basic. (Moją największą skargą jest to, jak wiele zagnieżdżonych pętli spowalnia interpreter, ponieważ dane pętli są przechowywane w stosie, ale stos jest wyrastany z niewłaściwego końca, więc kalkulator musi przesuwać cały stos za każdym razem, gdy element jest popychany lub wyskoczył.) Ale tym razem jest to wygodne.

-1 bajt: Pauseprzechowuje wartość, do Ansktórej drukuje , która jest krótsza do odniesienia niż ᶫA.

-3 bajty: weź dane wejściowe Ans

Galaretka , 10 bajtów

RµUs2UFµÐĿ

Wypróbuj online!

Wyjaśnienie

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

Uwaga

Jeśli pierwotny zakres musi znajdować się na końcu, dołącz ṙ1do kodu 12 bajtów.

05AB1E , 13 11 bajtów

LIGÂ2ôí˜})Ù

Wypróbuj online!

Wyjaśnienie

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

Edytuj 4 bajty zapisane thx @JustinMariner

Wykorzystując fakt, że gdy dowolny element znajduje się we właściwym miejscu, wszystkie elementy są.

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

Mniej golfa

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

Test

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

Mathematica, 142 bajty

(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 bajtów

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

Wyświetla listę dla każdego kroku.

Pamiętaj, że nie musimy inicjować tablicy, aby piłka się toczyła. Jeśli niezainicjowany ( xjest niezdefiniowany), możemy użyć indeksów (parametru i) tablicy, aby wykonać pierwszy krok:

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

Przypadki testowe:

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 bajty

Jeśli fakt, że kod rzuca ostrzeżenia na rzeczywiste rozwiązanie (brak ostrzeżeń, jeśli nwynosi 1, 3 ostrzeżenia, jeśli nsą parzyste i nostrzeżenia, jeśli nsą nieparzyste), nie stanowi problemu, to następujące działanie działa podobnie do poprzedniego rozwiązania, dzięki wektorowi recykling:

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

Wypróbuj online!

Jeszcze raz dziękuję @Giuseppe za dodatkowe 12 bajtów!

Poprzednie rozwiązanie bez ostrzeżeń o rozmiarze 94 bajtów:

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

Wypróbuj online!

Oryginalne rozwiązanie o wielkości 109 bajtów :

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}

Wypróbuj online!

Japt , 20 18 15 12 bajtów

õ
£=ò2n)ÔcÃâ

Wypróbuj ( -Rflaga tylko do celów wizualizacji)

1 bajt zaoszczędzony dzięki produktom ETH.

               :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

Łuska , 9 bajtów

U¡ȯṁ↔C2↔ḣ

Wypróbuj online!

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

Rubin , 64 57 52 50 bajtów

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

Wypróbuj online!

Jak to działa:

Najpierw utwórz zakres, a następnie powtórz permutację x razy: użyj ujemnego indeksu, ale odwróć ostatni bit, więc otrzymamy sekwencję -2, -1, -4, -3 ... jeśli x jest parzysty, to się skończy cóż, jeśli nie, dodamy pozostały element na końcu. Ostatni krok: odfiltruj powtarzające się tablice (więc uwzględniamy wszystkie przypadki: x = 1, x = 2, liczby nieparzyste i parzyste)

Haskell, 75 74 bajtów

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]

Wypróbuj online!

gwykonuje zamiany parami, hjeden krok (wstecz + zmiana kolejności), !stosuje się wielokrotnie h(i zbiera wyniki pośrednie) aż do przywrócenia kolejności. Uwaga: !pobiera dodatkowy, ale nieużywany parametr dodatkowy, 0aby stał się operatorem infix. Główna funkcja puruchamia go.

Edycja: Dzięki @Angs za bajt.

Java 8, 215 214 bajtów

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

Próbowałem grać w golfa przy użyciu rzeczywistych tablic zamiast listy, ale zarówno odwracanie, jak i zamiana zajmują zbyt wiele bajtów. Może może być połączone w jedną pętlę (zamiast pierwszego cofania, a następnie zamiany), ale jeszcze nie rozgryź to.
Można to jednak zdecydowanie pograć w golfa.

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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

Wypróbuj online!

MATL , 17 bajtów

:`tP2ePXz!tG:-a]x

Wypróbuj online!

Wyjaśnienie

:       % 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 bajtów

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

Uruchom i debuguj

Wyjaśnienie

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

Zaskakujące, że działa tak szybko, jak działa, przetestowane do 399, zanim nie chciałem już temperować mojej przeglądarki.

JavaScript (ES6), 122 bajty

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)można użyć zamiast r.push(b)umieszczenia oryginalnej permutacji z przodu.

Haskell , 97 bajtów

To wydaje się trochę długie :(

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

Wypróbuj online!

Wyjaśnienie / Niegolfowany

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

Ułożone , 42 bajty

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

Wypróbuj online!

Wykonuje podaną transformację za pomocą periodstepswbudowanego. Jednak to wbudowane zwraca wszystkie elementy, które obejmują zakres danych wejściowych jako pierwszy i ostatni element. Dlatego ścinamy listę, zwracając wszystko oprócz pierwszego elementu.

AWK , 123 bajty

Niezbyt ciasno, ale to najlepsze, co mogłem wymyślić.

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

Wypróbuj online!

Python 2 , 165 159 138 81 bajtów

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

Wypróbuj online!

-20 bajtów dzięki @ChasBrown . (Westchnienie, podjąłem całe wyzwanie dotyczące rozszerzonej składni krojenia)

Zaraz! GolfStorm (-57 bajtów)! Dzięki Ian Gödel, tsh i Jonathan Frech.

JavaScript, 136 bajtów

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