Défi:

Entrée: liste d'entiers positifs distincts dans la plage $[1, \text{list-size}]$ .

Sortie: Un entier: le nombre de fois que la liste est réorganisée . Pour une liste, cela signifie que la liste est divisée en deux moitiés, et ces moitiés sont entrelacées (c'est-à-dire que le réarrangement rapide de la liste [1,2,3,4,5,6,7,8,9,10]entraînerait une fois [1,6,2,7,3,8,4,9,5,10], donc pour ce défi, l'entrée en [1,6,2,7,3,8,4,9,5,10]résulterait 1).

Règles du défi:

• Vous pouvez supposer que la liste ne contiendra que des entiers positifs dans la plage $[1, \text{list-size}]$ (ou $[0, \text{list-size}-1]$ si vous choisissez d'avoir des listes d'entrée indexées 0).
• Vous pouvez supposer que toutes les listes d'entrées seront soit une liste mélangée à un riffle valide, soit une liste triée qui n'est pas mélangée (dans ce cas, la sortie l'est 0).
• Vous pouvez supposer que la liste d'entrées contiendra au moins trois valeurs.

Exemple étape par étape:

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

Le décompresser devient une fois:, [1,5,9,4,8,3,7,2,6]car chaque élément pair indexé 0 vient en premier [1, ,5, ,9, ,4, ,8], puis tous les éléments indexés 0 impairs après cela [ ,3, ,7, ,2, ,6, ].
La liste n'est pas encore commandée, nous continuons donc:

Dégrouper à nouveau la liste devient: devient à [1,9,8,7,6,5,4,3,2]
nouveau: [1,8,6,4,2,9,7,5,3]
Alors: [1,6,2,7,3,8,4,9,5]
Et enfin [1,2,3,4,5,6,7,8,9]:, qui est une liste ordonnée, nous avons donc terminé de décompresser.

Nous avons décompressé l'original [1,3,5,7,9,2,4,6,8]cinq fois pour y accéder [1,2,3,4,5,6,7,8,9], donc la sortie est 5dans ce cas.

Règles générales:

• C'est du code-golf , donc la réponse la plus courte en octets est gagnante.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de 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

Gelée , 8 octets

ŒœẎ$ƬiṢ’

Essayez-le en ligne!

Comment?

ŒœẎ$Ƭ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 octets

Version plus courte suggérée par @nwellnhof

Attend un jeu avec des cartes 1 indexées en entrée.

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

Essayez-le en ligne!

Etant donné un tablier $[c_0,\ldots,c_{L-1}]$ de longueur $L$ , on définit:

Et on cherche $n$ tel que $c_{x_n}=2$ .

JavaScript (ES6),  57 52  50 octets

Attend un jeu avec des cartes indexées 0 en entrée.

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

Essayez-le en ligne!

Comment?

Étant donné que JS ne prend pas en charge nativement l'extraction des tranches de tableau avec un pas personnalisé, simuler l'intégralité du riffle-shuffle serait probablement assez coûteux (mais pour être honnête, je n'ai même pas essayé). Cependant, la solution peut également être trouvée en regardant simplement la 2ème carte et le nombre total de cartes dans le jeu.

Etant donné un paquet de longueur $L$ , ce code recherche $n$ tel que:

où $c_2$ est la deuxième carte et $k$ est défini comme:

Python 2 , 39 octets

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

Essayez-le en ligne!

-4 merci à Jonathan Allan .

R , 58 55 45 octets

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

Essayez-le en ligne!

Simule le processus de tri. L'entrée est indexée sur 1, renvoie FALSE0.

Perl 6 , 34 32 octets

-2 octets grâce à Jo King

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

Essayez-le en ligne!

Similaire à l'approche d' Arnauld . L'index de la deuxième carte après n shuffles est 2**n % kavec k défini comme dans la réponse d'Arnauld.

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

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

Essayez-le en ligne!

Merci à Adám pour l'aide, Erik l'Outgolfer pour -3 et ngn pour -1.

Le lien TIO contient deux cas de test.

Explication:

{⍵≡⍳≢⍵: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 octets

-2 octets grâce à nwellnhof

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

Essayez-le en ligne!

Inverser le shuffle shuffles en triant par l'index modulo 2 jusqu'à ce que la liste soit triée, puis retourne la longueur de la séquence.

C'est drôle, je n'essaie généralement pas l'approche récursive pour Perl 6, mais cette fois-ci, elle s'est avérée plus courte que l'original.

Explication:

$!={.[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 (hérité) , 9 octets

[DāQ#ι˜]N

Essayez-le en ligne!

Explication

[   #  ]     # 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 octets

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

Essayez-le en ligne!

Fonctionne de manière fiable uniquement pour les baies de taille inférieure à 31 ou les solutions avec moins de 31 itérations. Pour une solution plus générale, consultez la solution suivante avec 63 octets:

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

Essayez-le en ligne!

Explication

Dans un fusil, la position suivante est la précédente fois deux modules soit de longueur si elle est impaire ou de longueur - 1 si elle est paire.

Je suis donc en train d'itérer sur tous les indices en utilisant cette formule jusqu'à ce que je trouve la valeur 2 dans le tableau.

Crédits

• -8 octets grâce à Kevin Cruijssen . (Algorithme précédent, utilisant un tableau)
• -5 octets grâce à Arnauld .

J , 28 26 octets

-2 octets grâce à Jonah!

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

Essayez-le en ligne!

Inspiré de la solution APL de Ven.

Explication:

               ^:       ^: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 octets

Merci à ngn pour les conseils et pour son interprète K!

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

Essayez-le en ligne!

APL (NARS), caractères 49, octets 98

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

pourquoi utiliser dans la boucle la plus profonde, un algo qui devrait être nlog (n), quand on peut utiliser un n linéaire? juste pour quelques octets de plus? [⍵≡⍵ [⍋⍵] O (nlog n) et la confrontation de chaque élément pour voir sont en ordre en utilisant le 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

Ruby , 42 octets

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

Essayez-le en ligne!

Comment:

Recherchez le numéro 2 à l'intérieur du tableau: s'il est en deuxième position, le jeu n'a pas été mélangé, sinon vérifiez les positions où les mélanges successifs le placeraient.

R , 70 72 octets

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

Essayez-le en ligne!

Gère maintenant le cas de shuffle zéro.

C (GCC) 64 63 octets

-1 octet de nwellnhof

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

Il s'agit d'une réponse considérablement plus courte basée sur les réponses d'Arnauld et d'Olivier Grégoire. Je vais laisser mon ancienne solution ci-dessous car elle résout le problème un peu plus général des decks avec des cartes qui ne sont pas contiguës.

Essayez-le en ligne

C (GCC) 162 octets

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

Essayez-le en ligne

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 octets

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

Essayez-le en ligne.

Explication

Méthode stupide (force brute), beaucoup moins élégante que de suivre la carte # 2.

Au lieu de décompresser l'entrée, snous commençons par un vecteur trié uque nous mélangeons progressivement jusqu'à ce qu'il soit identique às . Cela donne des avertissements (mais les nombres aléatoires sont toujours corrects) pour les longueurs d'entrée impaires en raison du pliage d'un vecteur de longueur impaire dans une matrice à 2 colonnes; dans ce cas, en R, le point de données manquant est comblé par recyclage du premier élément d'entrée.

La boucle ne se terminera jamais si nous fournissons un vecteur qui ne peut pas être décompressé.

Addendum: vous économisez un octet si vous ne le mélangez pas à la place. Contrairement à la réponse ci-dessus, il n'est pas nécessaire de transposer avec t(), cependant, l'ordre byrow=TRUEest la raison pour laquelle Tapparaît dans matrix().

R , 84 octets

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

Essayez-le en ligne!

PowerShell , 116114108 84 78 octets

-24 octets grâce à Erik le Outgolfer de solution .

-6 octets grâce à mazzy .

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 62 octets

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

Essayez-le en ligne!

Explication

La liste d'entrée est a. Il est non trié et comparé à la liste triée jusqu'à ce qu'ils correspondent.

Rouge , 87 79 78 octets

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

Essayez-le en ligne!

Perl 5 -pa , 77 octets

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

Essayez-le en ligne!

Pyth , 18 octets

L?SIb0hys%L2>Bb1
y

Essayez-le en ligne!

-2 merci à @Erik l'Outgolfer.

Le script a deux lignes: la première définit une fonction y, la deuxième ligne appelle yavec l' Qargument implicite (évalué stdin).

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 octets

+9 octets lorsque des cas de test avec un nombre pair d'éléments ajoutés.

-1 octet avec éclaboussures.

-4 octets: encapsule l'expression avec $i, $jdans une nouvelle étendue.

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

Essayez-le en ligne!

Japt , 13 11 10 octets

En prenant mon brillant, nouveau , très -Travailler en cours interprète pour un essai routier.

ÅÎÍ©ÒßUñÏu

Essayez-le ou lancez tous les cas de 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 octets

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

Essayez-le en ligne!

J'ai besoin de rafraîchir la page plus fréquemment: j'ai raté la modification d'Erik l'Outgolfer en faisant une astuce similaire =)