Tiga R's: Mundur, Menyusun Ulang, Ulangi


31

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


6
Apakah saya tetap bisa menghasilkan kisaran asli di depan?
HyperNeutrino

1
Saya pikir ada kesalahan pada baris terakhir dalam contoh ini. Seharusnya 1 2 3 4 5tidak 1 2 4 3 5.
Stewie Griffin

2
Adakah yang bisa mengkonfirmasi bahwa elemen 0 hanya akan menjadi 1 pada awal dan akhir proses?
Roberto Graham

1
@RobertoGraham Saya memiliki skrip python yang memverifikasi bahwa array[0]hanya akan ada 1 pada awal dan akhir proses hingga n = 999. Dari melihat polanya, sepertinya untuk setiap n aneh , elemen pertama 1, n-1, 3, n - 3, 5, n - 5, 7...naik hingga n - 2, 3, n, 1, yang akan selalu mengambil n langkah. Saya tidak melihat alasan bahwa pola ini akan berubah dengan n yang lebih besar .
DJMcMayhem

3
Jika kita ingin membuktikan bahwa periode adalah n ketika n adalah ganjil, mungkin lebih mudah untuk melacak ke mana elemen 1 berjalan: ia mengikuti jalan 1, n, 2, n-2, 4, n-4, 6, n-6, 8, n-8, ...dan mudah untuk menunjukkan dengan induksi bahwa suatu elemen pada posisi genap x bergerak ke nx setelah satu langkah , dan elemen pada posisi ganjil x pindah ke n-x + 2 . Jadi jika n = 2k + 1 , maka setelah langkah 2k -th 1 akan berada pada 2k , dan pada langkah berikutnya di n-2k = 1 .
Misha Lavrov

Jawaban:


16

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


Trik yang luar biasa dengan pemilihan semacam!
Riking

7

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.



@DJMcMayhem Keren, bagus!
HyperNeutrino

5

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

4

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


Saya pikir Anda dapat memperpendek loop pembuatan rentang for(l=[];n;l[n-1]=n--);, Coba secara online! .
Justin Mariner

@JustinMariner wow mundur, bagus! Terima kasih
edc65

3

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

3

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:


3

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!


1
88 byte - printmengembalikan argumennya sehingga kita dapat memanfaatkannya di sini. Saya tidak berpikir saya pernah melihat encodesebelumnya; itu cara pengindeksan yang rapi!
Giuseppe

Terima kasih! Meskipun saya perlu membuatnya sedikit lebih lama karena tidak berfungsi jika n = 1 sejauh ini.
plannapus

Oh, saya tidak melihat bahwa ... ganti 2di embeddengan min(n,2)?
Giuseppe

1
Anda hanya bisa meletakkan nalih-alih {}untuk loop sementara karena ntidak melakukan apa-apa. :)
Giuseppe

1
Peningkatan yang mengesankan !!! 0:n+2*1:0sama dengan 1+0:n+c(1,-1)-4 byte. any(print(...) != s)setara dengan any(print(...)-s)-1 byte. Aaand jika kita dapat membuktikan bahwa m[1]==1hanya pada akhir algoritme, maka kita dapat menjatuhkannya any, sehingga kita dapatkan while(print(...)-1)dan kita dapat menghapus s, sehingga kita mendapatkan 62 byte,n=scan();m=1:n;w=0:n+2*1:0;while(print(m<-rev(m)[w[w<=n]])-1)n
Giuseppe

3

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

Sampai sekarang, saya percaya w ò mwbisaò2n)w
ETHproduksi

Oo, bagus, terima kasih, @ETHproductions. Akan berjalan ke pub jadi aku akan melihat yang tepat di pagi hari.
Shaggy

2

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]

2

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)


2

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.


2
0!xalih-alih f xmenyimpan byte - Cobalah secara online!
Angs

1

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

1

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!


1
n->{java.util.Arrays x=null;int i=0,k,f,a[]=new int[n],t[]=new int[n];for(;i<n;a[i]=t[i]=++i);do{for(f=0;f<n/2;k=t[f],t[f]=t[n+~f],t[n+~f++]=k);for(k=1;k<n;t[k]=t[--k],t[k]=f,k+=3)f=t[k];System.out.println(x.toString(t));}while(!x.equals(a,t));}( 245 byte ) Ringkasan perubahan java.util.Arrays x=null;:; n-f-1untuk n+~f; menghapus kurung loop; Berubah 2x k-1untuk --k(dan juga berubah k+=2untuk k+=3menetralkan ini.
Kevin Cruijssen

Dan Anda dapat menyimpan dua byte lagi dengan menghapus ,fdan menggunakan kembali i.
Kevin Cruijssen

Bagus, Anda banyak meningkatkannya! Anda sekarang bahkan lebih rendah dari jawaban Java saya. :) Anda dapat bermain golf satu byte lagi dengan mengubah for(i=0;i<n/2;k=t[i],t[i]=t[n+~i],t[n+~i++]=k);kefor(i=0;i<n/2;t[i]=t[n+~i],t[n+~i++]=k)k=t[i];
Kevin Cruijssen

1

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

1

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.


0

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.


0

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)

0

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.


0

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!


0

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.


Alih-alih list(reversed(a))mencoba a[::-1].
Chas Brown

' '*[2-(x<3),x][x%2]
tsh



1
@tsh [b,0][b==a]-> b*(a!=b).
Jonathan Frech

0

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)}}
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.