Während ich mit Zahlen herumkritzelte, fand ich eine interessante Permutation, die Sie aus einer Liste von Zahlen generieren können. Wenn Sie dieselbe Permutation genügend oft wiederholen, gelangen Sie immer zum ursprünglichen Array zurück. Verwenden wir die folgende Liste:

[1, 2, 3, 4, 5]

als Beispiel

1. Kehren Sie das Array um. Jetzt ist unser Array

   [5, 4, 3, 2, 1]
   

2. Jedes Paar neu ordnen (tauschen). Unsere Liste enthält 2 Paare:, [5, 4]und [3, 2]. Leider können wir das nicht 1zu einem Paar zusammenfassen, also lassen wir es einfach für sich. Nach dem Tauschen jedes Paares lautet das neue Array:

   [4, 5, 2, 3, 1]
   

3. Wiederholen Sie die Schritte 1 und 2, bis Sie zum ursprünglichen Array zurückkehren. Hier sind die nächsten 4 Schritte:

   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
   

   Wenn die Länge der Liste n ungerade ist, dauert es immer genau n Schritte, um zum ursprünglichen Array zurückzukehren. Wenn n gerade ist, dauert es immer 2 Schritte, um zum ursprünglichen Array zurückzukehren, es sei denn, n ist 2. In diesem Fall dauert es 1 Schritt (da Umkehren und Vertauschen dasselbe ist).

Ihre Aufgabe für heute (falls Sie sie akzeptieren möchten) ist es, diesen Satz von Schritten für Listen beliebiger Länge zu visualisieren. Sie müssen ein Programm oder eine Funktion schreiben, die eine einzelne positive Ganzzahl n als Eingabe verwendet, und diese Schritte für die Liste ausführen [1, n]. Sie müssen jeden Zwischenschritt auf dem Weg ausgeben, dh jeden Schritt drucken oder alle als Liste von Schritten zurückgeben. Ich bin nicht sehr wählerisch in Bezug auf das Ausgabeformat, solange klar ist, dass Sie jeden Schritt generieren. Dies bedeutet (zum Beispiel) Folgendes:

• Ausgabe jedes Schritts als Liste an STDOUT

• Zurückgeben einer Liste von Listen

• Zurückgeben einer Liste mit Zeichenfolgendarstellungen für jeden Schritt

• Matrix zurückgeben / ausgeben

wäre akzeptabel.

Sie müssen auch das ursprüngliche Array ausgeben, ob dies am Ende oder am Anfang erfolgt, liegt bei Ihnen. (technisch sind beide richtig)

Sie müssen den Kantenfall von 2 in einem Schritt anstelle von 2 behandeln . Stellen Sie daher sicher, dass Ihre Lösung mit einer Eingabe von 2 funktioniert (und 1 ein weiterer potenzieller Kantenfall ist).

Wie üblich ist dies Codegolf , daher gelten Standardlücken, und versuchen Sie, Ihre Lösung in der Sprache Ihrer Wahl kürzer als jede andere zu machen (oder versuchen Sie sogar, eine andere Sprache zu schlagen, die in der Regel kürzer als Ihre ist, wenn Sie sich müde fühlen für eine Herausforderung).

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

Und zum guten Teil ist hier ein riesiger Testfall:

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]

Viel Spaß beim Golfen!

TI-Basic (Serie 83), 58 57 54 Byte (104 Zeichen)

: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

Erläuterung

Nimmt Eingaben auf Ans(z. B. Schreiben 5:prgmNAME, um Listen der Größe fünf zu verwenden).

Erstellt drei Hilfslisten der angegebenen Größe (die ᶫBbei jedem Schritt neu erstellt werden): ᶫB = ᶫC = {1,2,3,4,5,...}und ᶫD = {-1,-1,-2,-2,-3,...}. Bei jedem Schritt wird sortiert ᶫCund ᶫDin absteigender Reihenfolge die gleiche Permutation auf angewendet ᶫA. In diesem Fall ᶫCkehrt sich dies um ᶫA, und in diesem Fall werden ᶫDbenachbarte Paare vertauscht , da TI-Basic eine wirklich blöde Implementierung für SortD(die Auswahlsortierung verwendet, bei der so viele identische Elemente wie möglich neu angeordnet werden. Wann ᶫAist gleich ᶫBwieder aufhören wir.

Nein, im Ernst, der integrierte Sortieralgorithmus ist meine zweitgrößte Beschwerde beim TI-Basic-Interpreter. (Meine größte Beschwerde ist, dass viele verschachtelte Schleifen den Interpreter verlangsamen, da die Schleifendaten in einem Stapel gespeichert sind, der Stapel jedoch vom falschen Ende gewachsen ist, sodass der Taschenrechner den gesamten Stapel jedes Mal verschieben muss, wenn ein Element verschoben wird oder geknallt.) Aber diesmal ist es praktisch.

-1 Byte: PauseSpeichert den Wert, auf den gedruckt wird. Dieser Wert Ansist kürzer als der Referenzwert ᶫA.

-3 Bytes: Eingabe übernehmen in Ans

Gelee , 10 Bytes

RµUs2UFµÐĿ

Probieren Sie es online!

Erläuterung

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

Hinweis

Wenn die ursprüngliche Bereich Bedürfnisse am Ende sein, append , ṙ1um den Code für 12 Bytes.

05AB1E , 13 11 Bytes

LIGÂ2ôí˜})Ù

Probieren Sie es online!

Erläuterung

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

Bearbeite 4 Bytes gespeichert dank @JustinMariner

Ausgehend von der Tatsache, dass sich alle Elemente an der richtigen Stelle befinden.

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

Weniger golfen

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

Prüfung

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 Bytes

(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

Gibt für jeden Schritt eine Liste aus.

Beachten Sie, dass wir das Array nicht initialisieren müssen, um den Ball ins Rollen zu bringen. Wenn nicht initialisiert ( xundefiniert), können wir die Indizes (Parameter i) des Arrays verwenden , um den ersten Schritt auszuführen:

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

Testfälle:

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 Bytes

Wenn die Tatsache, dass der Code Warnungen über die eigentliche Lösung wirft (keine Warnungen bei n1, 3 Warnungen bei ngerade und nWarnungen bei nungerade), kein Problem darstellt, funktioniert das Folgende dank vector ähnlich wie bei der vorherigen Lösung Recycling:

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

Probieren Sie es online!

Nochmals vielen Dank an @ Giuseppe für zusätzliche 12 Bytes!

Bisherige Lösung ohne Warnung bei 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

Probieren Sie es online!

Ursprüngliche Lösung bei 109 Bytes :

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}

Probieren Sie es online!

Japt , 20 18 15 12 Bytes

õ
£=ò2n)ÔcÃâ

Probieren Sie es aus ( -RFlagge nur zu Visualisierungszwecken)

Dank ETHproductions 1 Byte gespart.

               :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

Schale , 9 Bytes

U¡ȯṁ↔C2↔ḣ

Probieren Sie es 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]

Ruby , 64 57 52 50 Bytes

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

Probieren Sie es online!

Wie es funktioniert:

Erstellen Sie zuerst den Bereich und wiederholen Sie dann die Permutation x-mal: Verwenden Sie einen negativen Index, kippen Sie jedoch das letzte Bit, sodass wir die Sequenz -2, -1, -4, -3 erhalten. Wenn x gerade ist, endet dies Wenn nicht, fügen wir das verbleibende Element am Ende hinzu. Letzter Schritt: Wiederholte Arrays herausfiltern (also decken wir alle Fälle ab: x = 1, x = 2, ungerade und gerade Zahlen)

Haskell, 75 74 Bytes

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]

Probieren Sie es online!

gBei den paarweisen Swaps handelt es sich um heinen einzelnen Schritt (Umkehren + Neuanordnen), der !wiederholt hangewendet wird (und die Zwischenergebnisse sammelt), bis die Reihenfolge wiederhergestellt ist. Hinweis: !Nimmt den zusätzlichen, aber nicht verwendeten zusätzlichen Parameter 0, um ihn zu einem Infix-Operator zu machen. Die Hauptfunktion pstartet es.

Edit: Danke an @Angs für ein Byte.

Java 8, 215 214 Bytes

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

Ich habe versucht, es mit tatsächlichen Arrays anstelle einer Liste zu spielen, aber sowohl das Umkehren als auch das Vertauschen nehmen zu viele Bytes ein finde es heraus.
Dies kann auf jeden Fall etwas mehr Golf gespielt werden.

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

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

Probieren Sie es online!

MATL , 17 Bytes

:`tP2ePXz!tG:-a]x

Probieren Sie es online!

Erläuterung

:       % 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 Bytes

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

Führen Sie es aus und debuggen Sie es

Erläuterung

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

Erstaunt funktioniert es so schnell wie es funktioniert, getestet bis zu 399, bevor ich meinen Browser nicht mehr tempen wollte.

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)könnte verwendet werden, anstatt r.push(b)die ursprüngliche Permutation in den Vordergrund zu stellen.

Haskell , 97 Bytes

Das fühlt sich ein bisschen lang an :(

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

Probieren Sie es online!

Erklärung / 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)

Gestapelt , 42 Bytes

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

Probieren Sie es online!

Führt die angegebene Transformation mit dem periodstepseingebauten Befehl aus. Diese integrierte Funktion gibt jedoch alle Elemente zurück, einschließlich des Eingabebereichs als erstes und letztes Element. Wir köpfen daher die Liste und geben alle Elemente außer dem ersten zurück.

AWK , 123 Bytes

Nicht sehr eng, aber das ist das Beste, was ich mir einfallen lassen konnte.

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

Probieren Sie es online!

Python 2 , 165 159 138 81 Bytes

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

Probieren Sie es online!

-20 Bytes dank @ChasBrown . (Seufz, ich habe eine ganze Herausforderung in Bezug auf die erweiterte Slicing-Syntax gestellt.)

Whoa! GolfStorm (-57 Bytes)! Vielen Dank an Ian Gödel, tsh und Jonathan Frech.

JavaScript, 136 Bytes

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