Обмінюючись цифрами, я знайшов цікаву перестановку, яку можна створити зі списку чисел. Якщо ви повторите цю саму перестановку достатньо разів, ви завжди опинитеся в початковому масиві. Давайте скористаємося таким списком:

[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 як вхід, і виконує цей набір кроків для списку [1, n]. Ви повинні виводити кожен проміжний крок по дорозі, чи означає це друк кожного кроку, або повертайте їх усі як список кроків. Я не дуже прискіпливий до вихідного формату, доки зрозуміло, що ви генеруєте кожен крок. Це означає (наприклад) будь-яке з них:

• Виведення кожного кроку як список для STDOUT

• Повернення списку списків

• Повернення списку рядкових представлень кожного кроку

• Повернення / виведення матриці

було б прийнятним.

Ви також повинні вивести оригінальний масив, незалежно від того, залежно від того, чи буде він в кінці чи на початку. (технічно обидва є правильними)

Вам доведеться обробити крайовий випадок 2, зробивши 1 крок замість 2 , тому переконайтесь, що ваше рішення працює з введенням 2 (а 1 - ще один потенційний край).

Як завжди, це код-гольф , тому застосовуються стандартні лазівки, і спробуйте зробити своє рішення коротшим, ніж будь-який інший на обраній вами мові (або навіть намагайтеся перемогти іншу мову, яка зазвичай коротша за вашу, якщо ви відчуваєте для виклику).

Тест 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 серія), 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(якої впорядковується стільки ідентичних елементів, скільки можливо. Коли знову ᶫ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 байти, збережені thx @JustinMariner

Використовуючи той факт, що коли будь-який елемент знаходиться в потрібному місці, всі елементи є.

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

Менше гольфу

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

Математика, 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 байт

Якщо той факт, що код кидає попередження поверх фактичного рішення (відсутні попередження, якщо n1, 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}

Спробуйте в Інтернеті!

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

Лушпиння , 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]

Рубі , 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лише для того, щоб зробити його оператором infix. Основна функція 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

Стакс , 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)

Спробуйте в Інтернеті!

Пояснення / Недозволений

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

Спробуйте в Інтернеті!

Виконує задане перетворення за допомогою periodstepsвбудованого. Однак цей вбудований файл повертає всі елементи, що включає діапазон введення як його перший та останній елементи. Тому ми очолюємо цей список, повертаючи все, крім першого елемента.

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.

JavaScript, 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)}}