Sementara mencoret-coret angka, saya menemukan permutasi menarik yang dapat Anda hasilkan dari daftar angka. Jika Anda mengulangi permutasi yang sama ini cukup sering, Anda akan selalu berakhir kembali di array asli. Mari kita gunakan daftar berikut ini:

[1, 2, 3, 4, 5]

sebagai contoh

1. Membalikkan array. Sekarang array kita adalah

   [5, 4, 3, 2, 1]
   

2. Susun ulang (swap) setiap pasangan. Daftar kami memiliki 2 pasang:, [5, 4]dan [3, 2]. Sayangnya, kami tidak dapat mengelompokkannya 1menjadi pasangan, jadi kami akan membiarkannya sendiri. Setelah bertukar setiap pasangan, array baru adalah:

   [4, 5, 2, 3, 1]
   

3. Ulangi langkah 1 dan 2 sampai kita kembali ke array asli. Berikut adalah 4 langkah selanjutnya:

   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
   

   Jika panjang daftar, n ganjil, ia akan selalu mengambil langkah n persis untuk kembali ke array asli. Jika n adalah genap, ia akan selalu mengambil 2 langkah untuk kembali ke array asli, kecuali n adalah 2, dalam hal ini akan mengambil 1 langkah (karena membalik dan bertukar adalah hal yang sama).

Tugas Anda untuk hari ini (jika Anda memilih untuk menerimanya) adalah memvisualisasikan serangkaian langkah ini untuk daftar panjang yang sewenang-wenang. Anda harus menulis sebuah program atau fungsi yang menggunakan satu bilangan bulat positif n sebagai input, dan melakukan serangkaian langkah untuk daftar ini [1, n]. Anda harus menampilkan setiap langkah perantara di sepanjang jalan, apakah itu berarti mencetak setiap langkah, atau mengembalikan semuanya sebagai daftar langkah. Saya tidak terlalu pilih-pilih tentang format output, asalkan jelas bahwa Anda menghasilkan setiap langkah. Ini berarti (misalnya) salah satu dari ini:

• Mengeluarkan setiap langkah sebagai daftar ke STDOUT

• Mengembalikan daftar daftar

• Mengembalikan daftar representasi string dari setiap langkah

• Mengembalikan / mengeluarkan matriks

akan diterima.

Anda juga harus menampilkan array asli, apakah yang datang di akhir atau di awal terserah Anda. (secara teknis, keduanya benar)

Anda harus menangani kasing tepi 2 mengambil 1 langkah bukan 2 , jadi pastikan solusi Anda bekerja dengan input 2 (dan 1 adalah kasing tepi potensial lainnya).

Seperti biasa, ini adalah kode-golf , sehingga celah standar berlaku, dan mencoba membuat solusi Anda lebih pendek daripada yang lain dalam bahasa pilihan Anda (atau bahkan mencoba untuk mengalahkan bahasa lain yang biasanya lebih pendek dari bahasa Anda jika Anda merasa kesal untuk tantangan).

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

Dan untuk ukuran yang baik, inilah satu test case raksasa:

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]

Bersenang-senang bermain golf!

TI-Basic (83 series), 58 57 54 bytes (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

Penjelasan

Mengambil input Ans(mis., Menulis 5:prgmNAMEuntuk menggunakan daftar ukuran lima).

Membuat tiga daftar tambahan dari ukuran yang diberikan (yang dibuat ulang dari ᶫBpada setiap langkah): ᶫB = ᶫC = {1,2,3,4,5,...}dan ᶫD = {-1,-1,-2,-2,-3,...}. Pada setiap langkah, mengurutkan ᶫCdan ᶫDdalam urutan menurun, menerapkan permutasi yang sama ᶫA. Dalam kasus ᶫC, membalikkan ini ᶫA, dan dalam kasus ᶫD, swap ini pasangan yang berdekatan karena TI-Basic menggunakan implementasi seleksi semacam benar-benar bodoh untuk SortD(yang menata ulang sebagai banyak unsur yang identik seperti itu mungkin bisa. Ketika ᶫAsama dengan ᶫBlagi, kita berhenti.

Tidak, serius, algoritma penyortiran bawaan mereka adalah keluhan terbesar kedua saya dengan penerjemah TI-Basic. (Keluhan terbesar saya adalah seberapa banyak loop bersarang memperlambat penerjemah, karena data loop disimpan dalam tumpukan, tetapi tumpukan tumbuh dari ujung yang salah, sehingga kalkulator harus memindahkan seluruh tumpukan setiap kali elemen didorong) atau muncul.) Tapi kali ini, lebih mudah.

-1 byte: Pausemenyimpan nilai pencetakannya Ans, yang lebih pendek daripada referensi ᶫA.

-3 byte: ambil input Ans

Jelly , 10 byte

RµUs2UFµÐĿ

Cobalah online!

Penjelasan

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

Catatan

Jika rentang asli perlu di akhir, tambahkan ṙ1kode untuk 12 byte.

05AB1E , 13 11 byte

LIGÂ2ôí˜})Ù

Cobalah online!

Penjelasan

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

Edit 4 byte disimpan thx @JustinMariner

Menggunakan fakta bahwa ketika ada elemen di tempat yang tepat, semua elemen berada.

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

Kurang golf

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

Uji

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

Keluarkan daftar untuk setiap langkah.

Perhatikan bahwa kita tidak perlu menginisialisasi array untuk mendapatkan bola bergulir. Jika tidak diinisialisasi ( xtidak ditentukan), kita dapat menggunakan indeks array (parameter i) untuk melakukan langkah pertama:

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

Kasus uji:

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

Jika fakta bahwa kode melempar peringatan di atas solusi aktual (tidak ada peringatan jika nadalah 1, 3 peringatan jika ngenap dan nperingatan jika nganjil) bukan merupakan masalah, maka berikut ini berfungsi sama dengan solusi sebelumnya, berkat vektor mendaur ulang:

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

Cobalah online!

Sekali lagi terima kasih kepada @Giuseppe untuk tambahan 12 byte!

Sebelumnya, solusi peringatan-kurang pada 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

Cobalah online!

Solusi asli pada 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}

Cobalah online!

Japt , 20 18 15 12 byte

õ
£=ò2n)ÔcÃâ

Cobalah ( -Rtandai hanya untuk tujuan visualisasi)

1 byte disimpan berkat produk 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

Sekam , 9 byte

U¡ȯṁ↔C2↔ḣ

Cobalah 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 byte

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

Cobalah online!

Bagaimana itu bekerja:

Pertama buat rentang, lalu ulangi permutasi x kali: gunakan indeks negatif, tapi balikkan bit terakhir, jadi kita mendapatkan urutan -2, -1, -4, -3 ... jika x genap, ini akan berakhir yah, kalau tidak kita akan menambahkan elemen yang tersisa di akhir. Langkah terakhir: filter keluar array berulang (jadi kami membahas semua kasus: x = 1, x = 2, angka ganjil dan genap)

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]

Cobalah online!

gapakah pasangan bertukar, hsatu langkah (mundur + menyusun ulang), !berulang kali berlaku h(dan mengumpulkan hasil antara) sampai pesanan dikembalikan. Catatan: !ambil parameter tambahan tambahan yang tidak digunakan 0hanya untuk menjadikannya operator infiks. Fungsi utama pmemulai itu.

Sunting: Terima kasih kepada @Angs untuk satu 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);}

Saya mencoba bermain golf menggunakan array yang sebenarnya, bukan List, tetapi keduanya membalik dan bertukar akan memakan terlalu banyak byte .. Mungkin itu dapat digabungkan dalam satu loop (bukan pertama membalikkan, lalu bertukar), tapi saya belum cari tahu ini.
Ini pasti bisa bermain golf lagi.

Penjelasan:

Coba di sini.

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

Cobalah online!

MATL , 17 byte

:`tP2ePXz!tG:-a]x

Cobalah online!

Penjelasan

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

Jalankan dan debug itu

Penjelasan

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

Terkejut ia bekerja secepat itu, diuji hingga 399 sebelum saya tidak ingin temp browser saya lagi.

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)dapat digunakan alih-alih r.push(b)menempatkan permutasi asli di depan.

Haskell , 97 byte

Ini terasa agak lama :(

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

Cobalah online!

Penjelasan / Tidak Diundang

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

Ditumpuk , 42 byte

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

Cobalah online!

Melakukan transformasi yang diberikan menggunakan periodstepsbuiltin. Namun, bawaan ini mengembalikan semua elemen, yang mencakup rentang input sebagai elemen pertama dan terakhir. Karena itu kami memenggal daftar, mengembalikan semua kecuali elemen pertama.

AWK , 123 byte

Tidak terlalu ketat, tapi ini yang terbaik yang bisa saya lakukan.

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

Cobalah online!

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

Cobalah online!

-20 byte terima kasih kepada @ChasBrown . (Sigh, saya membuat seluruh tantangan tentang sintaksis slicing yang diperluas)

Wah! GolfStorm (-57 byte)! Terima kasih kepada Ian Gödel, tsh, dan 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)}}