ขณะที่ดูตัวเลขกับตัวเลขฉันพบการเปลี่ยนแปลงที่น่าสนใจที่คุณสามารถสร้างจากรายการตัวเลข ถ้าคุณทำซ้ำการเรียงสับเปลี่ยนแบบนี้บ่อยครั้งคุณจะกลับมาที่อาร์เรย์เดิมเสมอ ลองใช้รายการต่อไปนี้:

[1, 2, 3, 4, 5]

ตัวอย่างเช่น

1. ย้อนกลับอาร์เรย์ ตอนนี้อาร์เรย์ของเราคือ

   [5, 4, 3, 2, 1]
   

2. จัดลำดับใหม่ (สลับ) แต่ละคู่ รายการของเรามี 2 คู่และ[5, 4] [3, 2]น่าเสียดายที่เราไม่สามารถจัดกลุ่ม1เป็นคู่ได้ดังนั้นเราจะทิ้งมันไว้เป็นของตัวเอง หลังจากสลับแต่ละคู่อาร์เรย์ใหม่จะเป็น:

   [4, 5, 2, 3, 1]
   

3. ทำซ้ำขั้นตอนที่ 1 และ 2 จนกระทั่งเรากลับสู่อาร์เรย์เดิม นี่คือ 4 ขั้นตอนถัดไป:

   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
   

   หากความยาวของรายการnเป็นเลขคี่จะใช้เวลาnขั้นตอนในการกลับไปยังอาร์เรย์ดั้งเดิมเสมอ หากnเป็นเลขคู่จะใช้เวลา 2 ขั้นตอนในการกลับไปยังอาร์เรย์เดิมเสมอเว้นแต่ว่า n คือ 2 ซึ่งในกรณีนี้จะใช้เวลา 1 ขั้นตอน (เนื่องจากการย้อนกลับและการสลับเป็นเรื่องเดียวกัน)

งานของคุณสำหรับวันนี้ (คุณควรเลือกที่จะยอมรับ) คือการมองเห็นชุดของขั้นตอนนี้สำหรับรายการความยาวโดยพลการ คุณต้องเขียนโปรแกรมหรือฟังก์ชั่นที่ใช้เวลาเดียวจำนวนเต็มบวกnเป็น input [1, n]และไม่ชุดของขั้นตอนนี้สำหรับรายการ คุณต้องแสดงผลแต่ละขั้นตอนระดับกลางไปพร้อมกันไม่ว่าจะหมายถึงการพิมพ์แต่ละขั้นตอนหรือส่งคืนทั้งหมดในรายการขั้นตอน ฉันไม่ได้พิถีพิถันมากนักเกี่ยวกับรูปแบบผลลัพธ์ตราบใดที่มันชัดเจนว่าคุณกำลังสร้างทุกขั้นตอน นี่หมายถึง (ตัวอย่าง) สิ่งเหล่านี้:

• แสดงผลทุกขั้นตอนเป็นรายการไปยัง STDOUT

• ส่งคืนรายการ

• ส่งคืนรายการการแทนค่าสตริงของแต่ละขั้นตอน

• การส่งคืน / ส่งออกเมทริกซ์

จะเป็นที่ยอมรับ

คุณต้องส่งออกอาเรย์ดั้งเดิมไม่ว่าจะมาที่ท้ายหรือตอนเริ่มต้นขึ้นอยู่กับคุณ (ทางเทคนิคทั้งคู่ถูกต้อง)

คุณจะต้องจัดการกับเคสขอบของ 2 โดยทำ 1 ขั้นตอนแทน 2ดังนั้นโปรดตรวจสอบให้แน่ใจว่าโซลูชันของคุณทำงานกับอินพุต 2 (และ 1 เป็นเคสขอบที่มีศักยภาพอีกอัน)

ตามปกตินี่คือcode-golfดังนั้นจึงใช้ช่องโหว่มาตรฐานและพยายามทำให้โซลูชันของคุณสั้นกว่าภาษาอื่น ๆ ในภาษาที่คุณเลือก (หรือแม้แต่พยายามเอาชนะภาษาอื่นที่สั้นกว่าของคุณโดยทั่วไปถ้าคุณรู้สึก สำหรับความท้าทาย)

ทดสอบ 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]

และสำหรับการวัดที่ดีนี่เป็นกรณีทดสอบขนาดยักษ์หนึ่งกรณี:

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]

ขอให้สนุกกับการเล่นกอล์ฟ!

TI-Basic (83 series), 58 57 54 ไบต์ (104 ตัวอักษร)

: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

คำอธิบาย

รับอินพุตAns(เช่นเขียน5:prgmNAMEเพื่อใช้รายการขนาดห้า)

สร้างเสริมสามรายการของขนาดที่กำหนด (ซึ่งถูกสร้างจากᶫBในแต่ละขั้นตอน) และᶫB = ᶫC = {1,2,3,4,5,...} ᶫD = {-1,-1,-2,-2,-3,...}ในแต่ละขั้นตอนทุกประเภทᶫCและในลำดับถัดลงมาใช้การเปลี่ยนแปลงเดียวกันกับᶫD ᶫAในกรณีของᶫC, หลีนี้ᶫAและในกรณีของᶫDคู่แลกเปลี่ยนนี้อยู่ติดกันเพราะ TI-Basic ใช้การดำเนินการเลือกการจัดเรียงโง่จริงๆสำหรับSortD(ที่ reorders เป็นองค์ประกอบที่เหมือนกันมากที่สุดเท่าที่มันอาจจะสามารถ เมื่อᶫAเท่ากับᶫBอีกครั้งเราหยุด

ไม่จริงจังอัลกอริทึมการเรียงลำดับในตัวของพวกเขาคือการร้องเรียนครั้งที่สองที่ใหญ่ที่สุดของฉันกับล่าม TI-Basic (ข้อร้องเรียนที่ใหญ่ที่สุดของฉันคือจำนวนลูปซ้อนกันจะทำให้ล่ามช้าลงเนื่องจากข้อมูลลูปถูกเก็บไว้ในสแต็ก แต่สแต็กโตขึ้นจากปลายที่ไม่ถูกต้องดังนั้นเครื่องคิดเลขต้องย้ายสแต็กทั้งหมดทุกครั้งที่ผลักองค์ประกอบ หรือแตกแล้ว) แต่คราวนี้สะดวก

-1 ไบต์: Pauseร้านค้ามูลค่าก็พิมพ์ไปซึ่งเป็นที่สั้นลงกว่าการอ้างอิงAnsᶫA

-3 ไบต์: รับอินพุต Ans

เยลลี่ 10 ไบต์

RµUs2UFµÐĿ

ลองออนไลน์!

คำอธิบาย

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

บันทึก

หากช่วงดั้งเดิมจำเป็นต้องสิ้นสุดที่จุดสิ้นสุดให้ผนวกṙ1รหัส 12 ไบต์

05AB1E , 13 11 ไบต์

LIGÂ2ôí˜})Ù

ลองออนไลน์!

คำอธิบาย

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

แก้ไข 4 ไบต์ที่บันทึกไว้ขอบคุณ @JustinMariner

ใช้ความจริงที่ว่าเมื่อองค์ประกอบใด ๆ อยู่ในตำแหน่งที่ถูกต้ององค์ประกอบทั้งหมดจะถูก

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

น้อย golfed

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

ทดสอบ

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 ไบต์

(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 ไบต์

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

แสดงรายการของแต่ละขั้นตอน

โปรดทราบว่าเราไม่จำเป็นต้องเริ่มต้นอาร์เรย์เพื่อให้ลูกบอลกลิ้ง หากไม่xกำหนดค่าเริ่มต้น( ไม่ได้กำหนด) เราสามารถใช้ดัชนี (พารามิเตอร์i) ของอาร์เรย์เพื่อทำขั้นตอนแรก:

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

กรณีทดสอบ:

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 ไบต์

หากความจริงที่ว่ารหัสโยนคำเตือนที่ด้านบนของการแก้ปัญหาที่เกิดขึ้นจริง (ไม่มีคำเตือนถ้าnเป็น 1, 3 คำเตือนถ้าnเป็นคู่และnคำเตือนถ้าnเป็นคี่) ไม่ใช่ปัญหาแล้วต่อไปนี้ทำงานคล้ายกับโซลูชั่นก่อนหน้านี้ขอบคุณเวกเตอร์ รีไซเคิล:

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

ลองออนไลน์!

ขอขอบคุณ@Giuseppeอีกครั้งสำหรับการเพิ่ม 12 ไบต์!

ก่อนหน้าวิธีแก้ปัญหาคำเตือนน้อยกว่าที่ 94 ไบต์:

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

ลองออนไลน์!

โซลูชันดั้งเดิมที่ 109 ไบต์ :

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}

ลองออนไลน์!

Japtap , 20 18 15 12 ไบต์

õ
£=ò2n)ÔcÃâ

ลองใช้ ( -Rตั้งค่าสถานะเพื่อการสร้างภาพข้อมูลเท่านั้น)

บันทึก 1 ไบต์ด้วย ETHproductions

               :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

Husk , 9 ไบต์

U¡ȯṁ↔C2↔ḣ

ลองออนไลน์!

            -- 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 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร:

ก่อนอื่นสร้างช่วงจากนั้นทำการเรียงสับเปลี่ยน x ครั้ง: ใช้ดัชนีลบ แต่กลับบิตสุดท้ายดังนั้นเราจึงได้ลำดับ -2, -1, -4, -3 ... ถ้า x เป็นเท่านี้จะสิ้นสุด ดีถ้าไม่เราจะเพิ่มองค์ประกอบที่เหลือในตอนท้าย ขั้นตอนสุดท้าย: กรองอาร์เรย์ที่ทำซ้ำออกไป (เพื่อให้ครอบคลุมทุกกรณี: x = 1, x = 2, เลขคี่และคู่)

Haskell, 75 74 ไบต์

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]

ลองออนไลน์!

gการสลับคู่ที่ชาญฉลาดhมีขั้นตอนเดียว (ย้อนกลับ + เรียงลำดับใหม่) !ใช้ซ้ำ ๆh(และรวบรวมผลลัพธ์ระดับกลาง) จนกว่าคำสั่งซื้อจะได้รับการคืนค่า หมายเหตุ: !รับพารามิเตอร์เพิ่มเติมเพิ่มเติม แต่ไม่ได้ใช้0เพื่อให้เป็นตัวดำเนินการมัด ฟังก์ชั่นหลักpเริ่มขึ้น

แก้ไข: ขอบคุณ @Angs สำหรับไบต์

Java 8, 215 214 ไบต์

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

ฉันพยายามเล่นกอล์ฟโดยใช้อาร์เรย์จริงแทนที่จะเป็นรายการ แต่ทั้งการย้อนกลับและการสลับจะใช้จำนวนไบต์มากเกินไป .. บางทีมันอาจรวมกันเป็นวงเดียว (แทนที่จะกลับก่อนแล้วสลับ) แต่ฉันยังไม่ได้ คิดออกนี้
แม้ว่าจะสามารถเล่นกอล์ฟได้มากกว่านี้

คำอธิบาย:

ลองที่นี่

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 ไบต์

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

ลองออนไลน์!

MATL , 17 ไบต์

:`tP2ePXz!tG:-a]x

ลองออนไลน์!

คำอธิบาย

:       % 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 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

คำอธิบาย

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

แปลกใจว่ามันทำงานได้อย่างรวดเร็วเหมือนทดสอบกับ 399 ก่อนที่ฉันจะไม่ต้องการให้เบราว์เซอร์ของฉันหยุดทำงานอีกต่อไป

JavaScript (ES6), 122 ไบต์

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)การเปลี่ยนรูปแบบเดิมที่ด้านหน้า

Haskell , 97 ไบต์

ความรู้สึกนี้ค่อนข้างยาว :(

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

ลองออนไลน์!

คำอธิบาย / 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)

ซ้อนกัน 42 ไบต์

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

ลองออนไลน์!

ดำเนินการแปลงที่กำหนดโดยใช้periodstepsbuiltin อย่างไรก็ตามบิวด์อินนี้ส่งคืนองค์ประกอบทั้งหมดซึ่งรวมช่วงของอินพุตเป็นองค์ประกอบแรกและสุดท้าย เราจึงตัดหัวรายการคืนทั้งหมดยกเว้นองค์ประกอบแรก

AWK , 123 ไบต์

ไม่แน่นมาก แต่นี่เป็นสิ่งที่ดีที่สุดที่ฉันสามารถทำได้

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

ลองออนไลน์!

Python 2 , 165 159 138 81 ไบต์

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

ลองออนไลน์!

-20 ไบต์ขอบคุณที่ @ChasBrown (เฮ้อฉันทำเรื่องท้าทายอย่างมากเกี่ยวกับการแบ่งส่วนข้อมูลเพิ่มเติม)

โว้ว! GolfStorm (-57 ไบต์)! ขอบคุณ Ian Gödel, tsh และ Jonathan Frech

จาวาสคริปต์, 136 ไบต์

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