数字をいじくり回しながら、数字のリストから生成できる面白い順列を見つけました。この同じ順列を十分な回数繰り返すと、常に元の配列に戻ります。次のリストを使用してみましょう。

[1, 2, 3, 4, 5]

例として

1. 配列を逆にします。今、私たちの配列は

   [5, 4, 3, 2, 1]
   

2. 各ペアを並べ替える（スワップする）。リストには[5, 4]、との2つのペアがあり[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が偶数の場合、nが2でない限り、元の配列に戻るには常に2ステップかかります。nが2の場合、1ステップかかります（反転とスワップは同じことなので）。

今日のあなたの仕事は（あなたがそれを受け入れることを選択した場合）、任意の長さのリストに対するこの一連のステップを視覚化することです。入力として正の整数nを1つ受け取り、リストに対してこの一連のステップを実行するプログラムまたは関数を作成する必要があります[1, n]。途中で各中間ステップを出力する必要があります。それは、各ステップを印刷することを意味するか、すべてをステップのリストとして返すことを意味します。すべてのステップを生成していることが明確である限り、出力形式についてあまり気にしません。これは、たとえば次のいずれかを意味します。

• すべてのステップをリストとしてSTDOUTに出力する

• リストのリストを返す

• 各ステップの文字列表現のリストを返す

• 行列を返す/出力する

許容されます。

また、元の配列を出力する必要があります。それが最後に来るか最初に来るかはあなた次第です。（技術的には、両方とも正しいです）

2のエッジケースを2ではなく1ステップで処理する必要があるため、ソリューションが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]

適切な測定のために、ここに1つの巨大なテストケースを示します。

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サイズ5のリストを使用するように書き込みます）。

（から再作成された所定の大きさの3つの補助リストを作成しᶫB、各ステップでの）ᶫB = ᶫC = {1,2,3,4,5,...}とᶫD = {-1,-1,-2,-2,-3,...}。各ステップ、ソート時ᶫCとᶫD、降順に同じ順列を適用する際にᶫA。の場合ᶫC、これは逆転ᶫAし、の場合、ᶫDTI-Basicは可能な限り多くの同一の要素を並べ替える本当に愚かな選択ソート実装を使用するため、隣接するペアをスワップしSortD(ます。再びᶫA等しいときはᶫB停止します。

いいえ、真剣に、組み込みの並べ替えアルゴリズムは、TI-Basicインタープリターで2番目に大きな苦情です。（私の最大の不満は、ループデータがスタックに格納されているが、スタックが間違った端から成長するため、電卓は要素がプッシュされるたびにスタック全体を移動する必要があるため、インタープリターの速度が遅くなることですまたはポップ）。しかし、今回は便利です。

-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

@JustinMarinerに保存された4バイトを編集

要素が適切な場所にあるとき、すべての要素が正しいという事実を使用します。

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

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バイト

コードが実際のソリューションの上に警告をスローするという事実（n1の場合は警告なし、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}

オンラインでお試しください！

Japt、20 18 15 12バイト

õ
£=ò2n)ÔcÃâ

試してみてください（-R視覚化のみを目的としたフラグ）

ETHproductionsのおかげで1バイト節約されました。

               :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回繰り返します。負のインデックスを使用しますが、最後のビットを反転します。したがって、xが偶数の場合、シーケンス-2、-1、-4、-3 ...が得られます。そうでない場合は、最後に残りの要素を追加します。最後のステップ：繰り返される配列をフィルターで除外します（したがって、すべてのケースをカバーします：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

スタックス、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}}

オンラインでお試しください！

パイソン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

オンラインでお試しください！

@ChasBrownのおかげで-20バイト。（ため息、私は拡張スライシング構文について全面的に挑戦しました）

おっ！GolfStorm（-57バイト）！IanGö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)}}