Sayılarla dolanırken, sayılar listesinden oluşturabileceğiniz ilginç bir permütasyon buldum. Bu aynı izinleri yeterince tekrarlarsanız, daima orijinal diziye geri dönersiniz. Aşağıdaki listeyi kullanalım:

[1, 2, 3, 4, 5]

Örnek olarak

1. Diziyi ters çevir. Şimdi dizimiz

   [5, 4, 3, 2, 1]
   

2. Her çifti yeniden sıralayın (değiştirin). Listemizde 2 çift var:, [5, 4]ve [3, 2]. Maalesef, 1çifti bir çift halinde gruplayamıyoruz , bu yüzden sadece kendi başına bırakacağız. Her çifti değiştirdikten sonra, yeni dizi şöyledir:

   [4, 5, 2, 3, 1]
   

3. Orijinal diziye geri dönene kadar 1. ve 2. adımları tekrarlayın . İşte sonraki 4 adım:

   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
   

   Listenin uzunluğu n'nin tuhaf olması durumunda , orijinal diziye geri dönmek her zaman tam olarak n adım atar. Eğer n bile, bu her zaman için orijinal diziye dönmek için 2 adımları atacaktır sürece n 2'dir (ters ve takas aynı şeydir çünkü) 1 adım atacak durumda.

Bugünkü göreviniz (kabul etmeyi seçmelisiniz) isteğe bağlı uzunluk listeleri için bu adım kümesini görselleştirmektir. Girdi olarak tek bir pozitif tamsayı n alan bir program veya işlev yazmalısınız ve liste için bu adımları uygulayın [1, n]. Her bir ara adımı yol boyunca çıkarmanız gerekir, bunun her adımı yazdırmak veya hepsini bir adım listesi olarak döndürmek anlamına gelir. Her adımı oluşturduğunuz belli olduğu sürece çıktı biçimi konusunda çok seçici değilim. Bunun anlamı (örneğin) bunlardan herhangi biri:

• Her adımı bir liste olarak STDOUT'a aktarma

• Bir liste listesi döndürmek

• Her adımın dizgi gösterimlerinin bir listesini döndürme

• Matris döndürme / basma

kabul edilebilir olurdu.

Orijinal diziyi de, sonunda veya başında gelirse size bağlı olsun çıkarmalısınız. (teknik olarak, ikisi de doğru)

2 yerine 1 adım atan 2 numaralı kenar kasasını kullanmanız gerekecek , bu nedenle lütfen çözümünüzün 2 girişiyle çalıştığından emin olun (ve 1, başka bir potansiyel kenar kasasıdır).

Her zamanki gibi, bu kod golfüdür , bu nedenle standart boşluklar uygulanır ve çözümünüzü tercih ettiğiniz dilden diğerlerinden daha kısa tutmaya çalışın (ya da kendinizi hissettiğinizde genellikle sizinkinden daha kısa olan başka bir dili geçmeyi deneyin) bir meydan okuma için).

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

Ve iyi bir ölçüm için, burada dev bir test durumu:

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]

Golf eğlenin!

TI-Basic (83 serisi), 58 57 54 bayt (104 karakter)

: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

açıklama

Girdiyi alır Ans(örneğin, 5:prgmNAMEbeş boyutlu listeleri kullanmak için yazın ).

Verilen ebatta üç yardımcı liste oluşturur ( ᶫBher adımda yeniden oluşturulur ): ᶫB = ᶫC = {1,2,3,4,5,...}ve ᶫD = {-1,-1,-2,-2,-3,...}. Her adımda, aynı permütasyonu uygulayarak sıralar ᶫCve ᶫDazalan sırada ᶫA. Durumunda ᶫCbu işlem tersine çevrilir, ᶫAve söz konusu olduğunda ᶫD, bu takas bitişik çiftleri TI-Basic kullandığı için gerçekten aptal seçim sıralama uygulama için SortD(gibi muhtemelen çok sayıda özdeş elemanları gibi olan yeniden sıralar. Ne zaman ᶫAeşittir ᶫByine biz durdurun.

Hayır, cidden, yerleşik sıralama algoritmaları, TI-Basic yorumlayıcısına ikinci en büyük şikayetim. (En büyük şikayetim, iç içe geçmiş döngülerin birçoğunun, döngü verileri bir yığında depolandığından tercümanı ne kadar yavaşlattığı, ancak yığının yanlış uçtan büyüdüğüdür, bu nedenle hesap makinesi, bir öğeye her basıldığında tüm yığını taşımak zorundadır. veya attı.) Ama bu sefer uygun.

-1 bayt: başvurduğudan daha kısa olan Pauseyazdırdığı değeri saklar .AnsᶫA

-3 bayt: girdi almak Ans

Jöle , 10 bayt

RµUs2UFµÐĿ

Çevrimiçi deneyin!

açıklama

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

Not

Orijinal aralığın sonunda olması gerekiyorsa , ṙ112 baytlık koda ekleyin .

05AB1E , 13 11 bayt

LIGÂ2ôí˜})Ù

Çevrimiçi deneyin!

açıklama

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

Düzenle 4 byte kaydedildi thx @JustinMariner

Herhangi bir eleman doğru yerde olduğunda, tüm elemanların olduğu gerçeğini kullanarak.

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

Daha az golf oynadı

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

Ölçek

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 bayt

(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 bayt

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

Her adım için bir liste çıkar.

Topu yuvarlamak için diziyi başlatmamız gerekmediğine dikkat edin. Başlatılmamışsa ( xtanımsızsa), iilk adımı yapmak için dizinin endekslerini (parametre ) kullanabiliriz:

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

Test Durumları:

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 bayt

Kodun, gerçek çözümün üzerine uyarılar atması (eğer n1, 3 ise uyarılar yok nve neğer ntek ise uyarılar olmaz) bir sorun değilse, aşağıdaki gibi, vektör sayesinde önceki çözüme benzer şekilde çalışır. geri dönüşüm:

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

Çevrimiçi deneyin!

Ekstra 12 bayt için @Giuseppe'ye tekrar teşekkürler !

94 baytta önceki, uyarı gerektirmeyen çözüm:

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

Çevrimiçi deneyin!

109 byte'ta orijinal çözüm :

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}

Çevrimiçi deneyin!

Japt , 20 18 15 12 bayt

õ
£=ò2n)ÔcÃâ

Deneyin ( -Ryalnızca görselleştirme amaçlı bayrak)

ETHproductions sayesinde 1 bayt kurtarıldı.

               :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

Kabuğu , 9 bayt

U¡ȯṁ↔C2↔ḣ

Çevrimiçi deneyin!

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

Yakut , 64 57 52 50 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır:

İlk önce aralığı yaratın, sonra permütasyonu x kez tekrarlayın: negatif bir indeks kullanın, ancak son biti çevirin, böylece x, eşitse -2, -1, -4, -3 ... dizisini alırız. peki, değilse kalan elemanı sonuna ekleyeceğiz. Son adım: tekrarlanan dizileri filtreleyin (bu nedenle tüm vakaları kapsarız: x = 1, x = 2, tek ve çift sayılar)

Haskell, 75 74 bayt

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]

Çevrimiçi deneyin!

gçift ​​yönlü swapları, sipariş geri yüklenene kadar htek bir adım (ters + sipariş), !tekrar tekrar uygular h(ve ara sonuçları toplar). Not: !Ek fakat kullanılmayan ilave parametreyi alır0 Sadece bir infix operatörü yapmak . Ana fonksiyon pbaşlatır.

Düzenleme: Bir bayt için @Angs teşekkürler.

Java 8, 215 214 bayt

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

Liste yerine gerçek dizileri kullanarak golf oynamaya çalıştım, ancak hem ters hem de takas işlemi çok fazla bayt alabiliyor. buna çözüm bul.
Bu olsa da, kesinlikle biraz daha golf olabilir.

Açıklama:

Burada dene.

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 bayt

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

Çevrimiçi deneyin!

MATL , 17 bayt

:`tP2ePXz!tG:-a]x

Çevrimiçi deneyin!

açıklama

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

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

Koş ve hata ayıkla

açıklama

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

Şaşırdım, olabildiğince hızlı çalıştı, artık tarayıcımı tempolu hale getirmek istemedim önce 399 kadar test edildi.

JavaScript (ES6), 122 bayt

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)Orijinal müsaadeyi öne koymak yerine, kullanılabilir .

Haskell , 97 bayt

Bu biraz uzun geliyor :(

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

Çevrimiçi deneyin!

Açıklama / 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)

Yığılmış , 42 bayt

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

Çevrimiçi deneyin!

Yerleşik kullanarak verilen dönüşümü gerçekleştirir periodsteps. Bununla birlikte, bu yerleşik, girişin aralığını ilk ve son öğe olarak içeren tüm öğeleri döndürür. Bu nedenle, listenin başındayız, ilk eleman hariç hepsini geri getiriyoruz.

AWK , 123 bayt

Çok sıkı değil, ama bulabildiğim en iyisi bu.

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

Çevrimiçi deneyin!

Python 2 , 165 159 138 81 bayt

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

Çevrimiçi deneyin!

@ChasBrown sayesinde -20 bayt . (Sigh, genişletilmiş dilimleme sözdizimi konusunda büyük bir mücadele verdim)

Oha! GolfStorm (-57 bayt)! Ian Gödel, tsh ve Jonathan Frech'e teşekkürler.

JavaScript, 136 bayt

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