Sfida:

Input: un elenco di interi positivi distinti all'interno dell'intervallo $[1, \text{list-size}]$ .

Output: un numero intero: la quantità di volte in cui l'elenco viene mischiato a riffle . Per un elenco, ciò significa che l'elenco è diviso in due metà e queste metà sono interlacciate (vale a dire che una volta si sfogliare l'elenco [1,2,3,4,5,6,7,8,9,10]una volta [1,6,2,7,3,8,4,9,5,10], quindi per questa sfida si [1,6,2,7,3,8,4,9,5,10]otterrebbe l'input 1).

Regole della sfida:

• Puoi presumere che l'elenco conterrà numeri interi positivi solo nell'intervallo $[1, \text{list-size}]$ (o se scegli di avere elenchi di input indicizzati 0).$[0, \text{list-size}-1]$
• Puoi presumere che tutti gli elenchi di input siano o un elenco mischiato a riffle valido o un elenco ordinato che non è mischiato (nel qual caso l'output è 0).
• Si può presumere che l'elenco di input conterrà almeno tre valori.

Esempio dettagliato:

Ingresso: [1,3,5,7,9,2,4,6,8]

La riordina una volta diventa:, [1,5,9,4,8,3,7,2,6]perché ogni elemento [1, ,5, ,9, ,4, ,8]pari a 0 viene prima , quindi dopo tutti gli oggetti dispari con indice 0 [ ,3, ,7, ,2, ,6, ].
L'elenco non è ancora stato ordinato, quindi continuiamo:

La rielaborazione dell'elenco diventa di nuovo: [1,9,8,7,6,5,4,3,2]
Ancora diventa: [1,8,6,4,2,9,7,5,3]
Quindi: [1,6,2,7,3,8,4,9,5]
E infine [1,2,3,4,5,6,7,8,9]:, che è un elenco ordinato, quindi abbiamo finito di rimescolare.

Abbiamo rimescolato l'originale [1,3,5,7,9,2,4,6,8]cinque volte per arrivare a [1,2,3,4,5,6,7,8,9], quindi l'output è 5in questo caso.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Input                                                   Output

[1,2,3]                                                 0
[1,2,3,4,5]                                             0
[1,3,2]                                                 1
[1,6,2,7,3,8,4,9,5,10]                                  1
[1,3,5,7,2,4,6]                                         2
[1,8,6,4,2,9,7,5,3,10]                                  2
[1,9,8,7,6,5,4,3,2,10]                                  3
[1,5,9,4,8,3,7,2,6,10]                                  4
[1,3,5,7,9,2,4,6,8]                                     5
[1,6,11,5,10,4,9,3,8,2,7]                               6
[1,10,19,9,18,8,17,7,16,6,15,5,14,4,13,3,12,2,11,20]    10
[1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20]    17
[1,141,32,172,63,203,94,234,125,16,156,47,187,78,218,109,249,140,31,171,62,202,93,233,124,15,155,46,186,77,217,108,248,139,30,170,61,201,92,232,123,14,154,45,185,76,216,107,247,138,29,169,60,200,91,231,122,13,153,44,184,75,215,106,246,137,28,168,59,199,90,230,121,12,152,43,183,74,214,105,245,136,27,167,58,198,89,229,120,11,151,42,182,73,213,104,244,135,26,166,57,197,88,228,119,10,150,41,181,72,212,103,243,134,25,165,56,196,87,227,118,9,149,40,180,71,211,102,242,133,24,164,55,195,86,226,117,8,148,39,179,70,210,101,241,132,23,163,54,194,85,225,116,7,147,38,178,69,209,100,240,131,22,162,53,193,84,224,115,6,146,37,177,68,208,99,239,130,21,161,52,192,83,223,114,5,145,36,176,67,207,98,238,129,20,160,51,191,82,222,113,4,144,35,175,66,206,97,237,128,19,159,50,190,81,221,112,3,143,34,174,65,205,96,236,127,18,158,49,189,80,220,111,2,142,33,173,64,204,95,235,126,17,157,48,188,79,219,110,250]
                                                        45

Gelatina , 8 byte

ŒœẎ$ƬiṢ’

Provalo online!

Come?

ŒœẎ$ƬiṢ’ - Link: list of integers A
    Ƭ    - collect up until results are no longer unique...
   $     -   last two links as a monad:
Œœ       -     odds & evens i.e. [a,b,c,d,...] -> [[a,c,...],[b,d,...]]
  Ẏ      -     tighten                         -> [a,c,...,b,d,...]
     Ṣ   - sort A
    i    - first (1-indexed) index of sorted A in collected shuffles
      ’  - decrement

JavaScript (ES6), 44 byte

Versione più breve suggerita da @nwellnhof

Si aspetta un mazzo con carte 1 indicizzate come input.

f=(a,x=1)=>a[x]-2&&1+f(a,x*2%(a.length-1|1))

Provalo online!

Dato un mazzo $[c_0,\ldots,c_{L-1}]$ di lunghezza $L$ , definiamo:

E cerchiamo $n$ tale che .$c_{x_n}=2$

JavaScript (ES6),  57 52  50 byte

Si aspetta un mazzo con carte indicizzate 0 come input.

f=(a,x=1,k=a.length-1|1)=>a[1]-x%k&&1+f(a,x*-~k/2)

Provalo online!

Come?

Poiché a JS manca il supporto nativo per l'estrazione di sezioni di array con un passo personalizzato, la simulazione dell'intero riffle-shuffle sarebbe probabilmente piuttosto costosa (ma a dire il vero, non ci ho nemmeno provato). Tuttavia, la soluzione può essere trovata anche solo guardando la seconda carta e il numero totale di carte nel mazzo.

Dato un mazzo di lunghezza , questo codice cerca tale che:$L$$n$

dove è la seconda carta e è definito come:$c_2$$k$

Python 2 , 39 byte

f=lambda x:x[1]-2and-~f(x[::2]+x[1::2])

Provalo online!

-4 grazie a Jonathan Allan .

R , 58 55 45 byte

a=scan();while(a[2]>2)a=matrix(a,,2,F<-F+1);F

Provalo online!

Simula il processo di ordinamento. L'input è 1 indicizzato, restituisce FALSE0.

Perl 6 , 34 32 byte

-2 byte grazie a Jo King

{(.[(2 X**^$_)X%$_-1+|1]...2)-1}

Provalo online!

Simile all'approccio di Arnauld . L'indice della seconda carta dopo n shuffle è 2**n % kcon k definito come nella risposta di Arnauld.

APL (Dyalog Unicode) , 35 26 23 22 byte ^SBCS

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}

Provalo online!

Grazie ad Adám per l'aiuto, Erik Outgolfer per -3 e ngn per -1.

Il collegamento TIO contiene due casi di test.

Spiegazione:

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}
{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]} ⍝ function takes one argument: ⍵, the array
 ⍵≡⍳≢⍵                 ⍝ if the array is sorted:
 ⍵≡⍳≢⍵                 ⍝ array = 1..length(array)
      :0               ⍝ then return 0
        ⋄              ⍝ otherwise
         1+            ⍝ increment
           ∇           ⍝ the value of the recursive call with this argument:
            ⍵[      ]  ⍝ index into the argument with these indexes:
                 ⍳⍴⍵   ⍝ - generate a range from 1 up to the size of ⍵
               2|      ⍝ - %2: generate a binary mask like [1 0 1 0 1 0]
              ⍒        ⍝ - grade (sorts but returns indexes instead of values), so we have the indexes of all the 1s first, then the 0s.

¹

Perl 6 , 36 34 32 byte

-2 byte grazie a nwellnhof

$!={.[1]-2&&$!(.sort:{$++%2})+1}

Provalo online!

Mescola i riffle inverse ordinandoli in base all'indice modulo 2 fino a quando l'elenco non viene ordinato, quindi restituisce la lunghezza della sequenza.

È divertente, di solito non provo l'approccio ricorsivo per Perl 6, ma questa volta è risultato più corto dell'originale.

Spiegazione:

$!={.[1]-2&&$!(.sort:{$++%2})+1}
$!={                           }   # Assign the anonymous code block to $!
    .[1]-2&&                       # While the list is not sorted
            $!(             )      # Recursively call the function on
               .sort:{$++%2}       # It sorted by the parity of each index
                             +1    # And return the number of shuffles

05AB1E (legacy) , 9 byte

[DāQ#ι˜]N

Provalo online!

Spiegazione

[   #  ]     # loop until
  ā          # the 1-indexed enumeration of the current list
 D Q         # equals a copy of the current list
     ι˜      # while false, uninterleave the current list and flatten
        N    # push the iteration index N as output

Java (JDK) , 59 byte

a->{int c=0;for(;a[(1<<c)%(a.length-1|1)]>2;)c++;return c;}

Provalo online!

Funziona in modo affidabile solo per array con dimensioni inferiori a 31 o soluzioni con meno di 31 iterazioni. Per una soluzione più generale, vedere la seguente soluzione con 63 byte:

a->{int i=1,c=0;for(;a[i]>2;c++)i=i*2%(a.length-1|1);return c;}

Provalo online!

Spiegazione

In un riffle, la posizione successiva è la precedente due volte due moduli o lunghezza se è dispari o lunghezza - 1 se è pari.

Quindi sto ripetendo tutti gli indici usando questa formula fino a quando non trovo il valore 2 nella matrice.

Crediti

• -8 byte grazie a Kevin Cruijssen . (Algoritmo precedente, usando l'array)
• -5 byte grazie ad Arnauld .

J , 28 26 byte

-2 byte grazie a Giona!

 1#@}.(\:2|#\)^:(2<1{])^:a:

Provalo online!

Ispirato essere la soluzione APL di Ven.

Spiegazione:

               ^:       ^:a:   while 
                 (2<1{])       the 1-st (zero-indexed) element is greater than 2   
     (        )                do the following and keep the intermediate results
          i.@#                 make a list form 0 to len-1
        2|                     find modulo 2 of each element
      /:                       sort the argument according the list of 0's and 1's
1  }.                          drop the first row of the result
 #@                            and take the length (how many rows -> steps)     

K (ngn / k) , 25 byte

Grazie a ngn per il consiglio e per il suo interprete K!

{#1_{~2=x@1}{x@<2!!#x}\x}

Provalo online!

APL (NARS), caratteri 49, byte 98

{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}

perché usare nel ciclo più profondo, un algo che dovrebbe essere nlog (n), quando possiamo usare un n lineare? solo per qualche byte in più? [⍵≡⍵ [⍋⍵] O (nlog n) e il confronto di ciascun elemento per vedere sono in ordine usando il test ∧ / ¯1 ↓ ⍵≤1⌽⍵ O (n)]:

  f←{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}
  f ,1
0
  f 1 2 3
0
  f 1,9,8,7,6,5,4,3,2,10
3
  f 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20
17

Rubino , 42 byte

f=->d,r=1{d[r]<3?0:1+f[d,r*2%(1|~-d.max)]}

Provalo online!

Come:

Cerca il numero 2 all'interno dell'array: se è in seconda posizione, il mazzo non è stato mischiato, altrimenti controlla le posizioni in cui lo metterebbero i riordini successivi.

R , 70 72 byte

x=scan();i=0;while(any(x>sort(x))){x=c(x[y<-seq(x)%%2>0],x[!y]);i=i+1};i

Provalo online!

Ora gestisce il caso shuffle zero.

C (GCC) 64 63 byte

-1 byte da nwellnhof

i,r;f(c,v)int*v;{for(i=r=1;v[i]>2;++r)i=i*2%(c-1|1);return~-r;}

Questa è una risposta drasticamente più breve basata sulle risposte di Arnauld e Olivier Grégoire. Lascerò la mia vecchia soluzione in basso poiché risolve il problema leggermente più generale dei mazzi con carte non contigue.

Provalo online

C (GCC) 162 byte

a[999],b[999],i,r,o;f(c,v)int*v;{for(r=0;o=1;++r){for(i=c;i--;(i&1?b:a)[i/2]=v[i])o=(v[i]>v[i-1]|!i)&o;if(o)return r;for(i+=o=c+1;i--;)v[i]=i<o/2?a[i]:b[i-o/2];}}

Provalo online

a[999],b[999],i,r,o; //pre-declare variables
f(c,v)int*v;{ //argument list
    for(r=0;o=1;++r){ //major loop, reset o (ordered) to true at beginning, increment number of shuffles at end
        for(i=c;i--;(i&1?b:a)[i/2]=v[i]) //loop through v, split into halves a/b as we go
            o=(v[i]>v[i-1]|!i)&o; //if out of order set o (ordered) to false
        if(o) //if ordered
            return r; //return number of shuffles
        //note that i==-1 at this point
        for(i+=o=c+1;i--;)//set i=c and o=c+1, loop through v
            v[i]=i<o/2?a[i]:b[i-o/2];//set first half of v to a, second half to b
    }
}

R, 85 byte

s=scan();u=sort(s);k=0;while(any(u[seq(s)]!=s)){k=k+1;u=as.vector(t(matrix(u,,2)))};k

Provalo online.

Spiegazione

Metodo stupido (forza bruta), molto meno elegante che seguire la carta # 2.

Invece di mescolare l'input s, iniziamo con un vettore ordinato uche mescoliamo progressivamente fino a quando non è identicos . Ciò fornisce avvisi (ma i conteggi shuffle sono ancora corretti) per lunghezze dispari di input dovute alla piegatura di un vettore di lunghezza dispari in una matrice a 2 colonne; in tal caso, in R, il punto dati mancante viene riempito riciclando il primo elemento di input.

Il ciclo non terminerà mai se forniamo un vettore che non può essere mischiato.

Addendum: si salva un byte se si rimescola invece. A differenza della risposta sopra, non è necessario trasporre con t(), tuttavia, l'ordine byrow=TRUEè il motivo per cui Tapparematrix() .

R , 84 byte

s=scan();u=sort(s);k=0;while(any(s[seq(u)]!=u)){k=k+1;s=as.vector(matrix(s,,2,T))};k

Provalo online!

PowerShell , 116 114 108 84 78 byte

-24 byte grazie Erik l'Outgolfer s' soluzione .

-6 byte grazie a mazzy .

param($a)for(;$a[1]-2){$n++;$t=@{};$a|%{$t[$j++%2]+=,$_};$a=$t.0+$t.1;$j=0}+$n

Provalo online!

Wolfram Language (Mathematica) , 62 byte

c=0;While[Sort[a]!=a,a=a[[1;;-1;;2]]~Join~a[[2;;-1;;2]];c++];c

Provalo online!

Spiegazione

L'elenco di input è a. È privo di errori e confrontato con l'elenco ordinato fino a quando non corrispondono.

Rosso , 87 79 78 byte

func[b][c: 0 while[b/2 > 2][c: c + 1 b: append extract b 2 extract next b 2]c]

Provalo online!

Perl 5 -pa , 77 byte

map{push@{$_%2},$_}0..$#F;$_=0;++$_,@s=sort{$a-$b}@F=@F[@0,@1]while"@F"ne"@s"

Provalo online!

Pyth , 18 byte

L?SIb0hys%L2>Bb1
y

Provalo online!

-2 grazie a @Erik the Outgolfer.

Lo script ha due righe: la prima definisce una funzione y, la seconda chiama ycon l' Qargomento implicito (stdin valutato).

L?SIb0hys%L2>Bb1
L                function y(b)
 ?               if...
  SIb            the Invariant b == sort(b) holds
     0           return 0
      h          otherwise increment...
       y         ...the return of a recursive call with:
             B   the current argument "bifurcated", an array of:
              b   - the original argument
            >  1  - same with the head popped off
          L      map...
         % 2     ...take only every 2nd value in each array
        s         and concat them back together

¹

PowerShell , 62 71 70 66 byte

+9 byte quando si verificano casi di test con un numero pari di elementi.

-1 byte con splatting.

-4 byte: avvolge l'espressione con $i, $jin un nuovo ambito.

for($a=$args;$a[1]-2;$a=&{($a|?{++$j%2})+($a|?{$i++%2})}){$n++}+$n

Provalo online!

Japt , 13 11 10 byte

Prendendo il mio lucido, nuovo , molto -Lavori in corso interprete per un test drive.

ÅÎÍ©ÒßUñÏu

Provalo o esegui tutti i casi di test

ÅÎÍ©ÒßUñÏu     :Implicit input of integer array U
Å              :Slice the first element off U
 Î             :Get the first element
  Í            :Subtract from 2
   ©           :Logical AND with
    Ò          :  Negation of bitwise NOT of
     ß         :  A recursive call to the programme with input
      Uñ       :    U sorted
        Ï      :    By 0-based indices
         u     :    Modulo 2

Python 3, 40 byte

f=lambda x:x[1]-2and 1+f(x[::2]+x[1::2])  # 1-based
f=lambda x:x[1]-1and 1+f(x[::2]+x[1::2])  # 0-based

Provalo online!

Devo aggiornare la pagina più frequentemente: mancava la modifica di Erik the Outgolfer facendo un trucco simile =)