Mentre scarabocchiavo con i numeri, ho trovato un'interessante permutazione che puoi generare da un elenco di numeri. Se ripeti questa stessa permutazione abbastanza volte, tornerai sempre alla matrice originale. Usiamo il seguente elenco:

[1, 2, 3, 4, 5]

come esempio

1. Invertire l'array. Ora il nostro array è

   [5, 4, 3, 2, 1]
   

2. Riordina (scambia) ogni coppia. La nostra lista ha 2 coppie:, [5, 4]e [3, 2]. Sfortunatamente, non possiamo raggrupparli 1in una coppia, quindi lo lasceremo da solo. Dopo aver scambiato ciascuna coppia, il nuovo array è:

   [4, 5, 2, 3, 1]
   

3. Ripetere i passaggi 1 e 2 fino a quando non si ritorna alla matrice originale. Ecco i prossimi 4 passaggi:

   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
   

   Se la lunghezza dell'elenco, n è dispari, saranno sempre necessari esattamente n passaggi per tornare all'array originale. Se n è pari, saranno sempre necessari 2 passaggi per tornare all'array originale, a meno che n sia 2, nel qual caso occorrerà 1 passaggio (poiché l'inversione e lo scambio sono la stessa cosa).

Il tuo compito per oggi (se scegli di accettarlo) è di visualizzare questo insieme di passaggi per elenchi di lunghezze arbitrarie. È necessario scrivere un programma o una funzione che accetta un singolo numero intero positivo n come input ed esegue questa serie di passaggi per l'elenco [1, n]. È necessario generare ogni passaggio intermedio lungo il percorso, indipendentemente dal fatto che ciò significhi stampare ogni passaggio o restituirli tutti come un elenco di passaggi. Non sono molto esigente riguardo al formato di output, purché sia ​​chiaro che stai generando ogni passaggio. Ciò significa (ad esempio) uno di questi:

• Inoltra ogni passaggio come elenco a STDOUT

• Restituzione di un elenco di elenchi

• Restituisce un elenco di rappresentazioni di stringhe di ogni passaggio

• Restituzione / emissione di una matrice

sarebbe accettabile.

È inoltre necessario produrre l'array originale, indipendentemente dal fatto che arrivi alla fine o all'inizio. (tecnicamente, entrambi sono corretti)

Dovrai gestire il caso limite di 2 eseguendo 1 passaggio invece di 2 , quindi assicurati che la tua soluzione funzioni con un input di 2 (e 1 è un altro caso limite potenziale).

Come al solito, si tratta di code-golf , quindi si applicano scappatoie standard e cerca di rendere la tua soluzione più breve di qualsiasi altra nella lingua che preferisci (o anche di provare a battere un'altra lingua che è in genere più corta della tua se ti senti bene per una sfida).

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

E per buona misura, ecco un caso di test gigante:

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]

Divertiti a giocare a golf!

TI-Basic (serie 83), 58 57 54 byte (104 caratteri)

: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

Spiegazione

Riceve input Ans(ad esempio, scrivere 5:prgmNAMEper utilizzare elenchi di dimensioni cinque).

Crea tre elenchi ausiliari delle dimensioni indicate (che vengono ricreati da ᶫBogni passaggio): ᶫB = ᶫC = {1,2,3,4,5,...}e ᶫD = {-1,-1,-2,-2,-3,...}. Ad ogni passo, ordina ᶫCe ᶫDin ordine decrescente, applicando la stessa permutazione a ᶫA. Nel caso ᶫC, questo inverte ᶫAe nel caso ᶫDscambia coppie adiacenti perché TI-Basic utilizza un'implementazione di ordinamento di selezione davvero stupida per SortD(cui riordina quanti più elementi identici possibile. Quando ᶫAè uguale di ᶫBnuovo, ci fermiamo.

No, sul serio, il loro algoritmo di ordinamento integrato è la mia seconda lamentela più grande con l'interprete TI-Basic. (La mia più grande lamentela è che molti loop nidificati rallentano l'interprete, poiché i dati del loop sono memorizzati in uno stack, ma lo stack viene cresciuto dalla parte sbagliata, quindi la calcolatrice deve spostare l'intero stack ogni volta che viene premuto un elemento o spuntato.) Ma questa volta, è conveniente.

-1 byte: Pausememorizza il valore su cui sta stampando Ans, che è più breve rispetto al riferimento ᶫA.

-3 byte: accetta input Ans

Gelatina , 10 byte

RµUs2UFµÐĿ

Provalo online!

Spiegazione

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

Nota

Se l'intervallo originale deve essere alla fine, aggiungere ṙ1al codice per 12 byte.

05AB1E , 13 11 byte

LIGÂ2ôí˜})Ù

Provalo online!

Spiegazione

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

Modifica 4 byte salvati grazie a @JustinMariner

Usando il fatto che quando ogni elemento è nel posto giusto, tutti gli elementi lo sono.

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

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

Test

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

Emette un elenco per ogni passaggio.

Nota che non è necessario inizializzare l'array per far rotolare la palla. Se non inizializzato (non xdefinito), possiamo usare gli indici dell'array (parametro i) per fare il primo passo:

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

Casi test:

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

Se il fatto che il codice genera avvisi sopra la soluzione effettiva (nessun avviso se nè 1, 3 avvisi se nè pari e navvisi se nè dispari) non è un problema, allora quanto segue funziona in modo simile alla soluzione precedente, grazie a vector raccolta differenziata:

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

Provalo online!

Grazie ancora a @Giuseppe per altri 12 byte di sconto!

Soluzione precedente, senza avvisi a 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

Provalo online!

Soluzione originale a 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}

Provalo online!

Japt , 20 18 15 12 byte

õ
£=ò2n)ÔcÃâ

Provalo ( -Rflag solo a scopo di visualizzazione)

1 byte salvato grazie a 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

Buccia , 9 byte

U¡ȯṁ↔C2↔ḣ

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

Rubino , 64 57 52 50 byte

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

Provalo online!

Come funziona:

Per prima cosa crea l'intervallo, quindi ripeti la permutazione x volte: usa un indice negativo, ma capovolgi l'ultimo bit, quindi otteniamo la sequenza -2, -1, -4, -3 ... se x è pari, questo finirà bene, in caso contrario aggiungeremo l'elemento rimanente alla fine. Ultimo passo: filtrare le matrici ripetute (quindi copriamo tutti i casi: x = 1, x = 2, numeri pari e dispari)

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]

Provalo online!

gesegue gli swap in coppia, hun singolo passaggio (indietro + riordina), !si applica ripetutamente h(e raccoglie i risultati intermedi) fino al ripristino dell'ordine. Nota: !accetta il parametro aggiuntivo aggiuntivo ma inutilizzato 0solo per renderlo un operatore infix. La funzione principale plo avvia.

Modifica: grazie a @Angs per un 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);}

Ho provato a giocare a golf usando array reali invece di un elenco, ma sia l'inversione che lo scambio occupano troppi byte .. Forse può essere combinato in un ciclo (anziché prima invertire, quindi scambiare), ma devo ancora capire questo.
Questo può sicuramente essere golfato ancora un po ', però.

Spiegazione:

Provalo qui.

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

Provalo online!

MATL , 17 byte

:`tP2ePXz!tG:-a]x

Provalo online!

Spiegazione

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

Esegui ed esegui il debug

Spiegazione

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

Sorpreso funziona tanto velocemente quanto, testato fino a 399 prima di non voler più provare il mio browser.

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)potrebbe essere usato invece di r.push(b)mettere la permutazione originale in primo piano.

Haskell , 97 byte

Questo sembra un po 'lungo :(

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

Provalo online!

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

Impilato , 42 byte

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

Provalo online!

Esegue la trasformazione specificata usando l' periodstepsintegrato. Tuttavia, questo builtin restituisce tutti gli elementi, che include l'intervallo dell'input come primo e ultimo elemento. Siamo quindi in testa alla lista, restituendo tutto tranne il primo elemento.

AWK , 123 byte

Non molto stretto, ma questo è il migliore che ho potuto inventare.

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

Provalo online!

Python 2 , 165 159 138 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

Provalo online!

-20 byte grazie a @ChasBrown . (Sospiro, ho fatto tutta una sfida sull'estesa sintassi dello slicing)

Whoa! GolfStorm (-57 byte)! Grazie a Ian Gödel, tsh e 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)}}