Aller au contenu

Mélanges parfaits d'un jeu de 32 cartes

Cette page présente les mélanges parfaits de type out-shuffle et in-shuffle d'un jeu de cartes et en explore quelques propriétés.

1. Mélange parfait

Question 1

Un jeu de 32 cartes peut être représenté par un tableau, où chaque carte est représentée par un entier.
Créer le tableau jeu32, contenant les 32 entiers entre 1 et 32.

jeu32 = [ … ] # à compléter

Pour réaliser un mélange parfait d'un jeu de cartes, on le sépare en 2 paquets de même taille avant de mélanger ensemble les 2 paquets créés.

Les fonctions ci-dessous permettent de récupérer la moitié du "dessus" et la moitié du "dessous" d'un jeu de cartes.

def dessus(tab):
    return(tab[: len(tab) // 2])

def dessous(tab):
    return(tab[len(tab) // 2 :])

À réaliser

Exécuter les appels dessus(jeu32) et dessous(jeu32) et observer le résultat produit.

Lors du mélange parfait d'un jeu de cartes, on le sépare en 2 paquets de même taille : le paquet A désigne la moitié du dessus et le paquet B désigne la moitié du dessous. Puis on alterne les cartes d'un paquet et de l'autre.
Le mélange peut se réaliser de 2 façons :
- soit c'est la carte du dessus du paquet A qui sera au-dessus du paquet mélangé : ce mélange est appelé out-shuffle ;
- soit c'est la carte du dessus du paquet B qui sera au-dessus du paquet mélangé : ce mélange est appelé in-shuffle.

Voici un exemple avec un jeu initial de 8 cartes : observer la position des cartes extrêmes (1 et 8) dans les manipulations suivantes.

On sépare le jeu en 2 paquets de même taille : le paquet A est constitué des cartes 1 à 4, le paquet B des cartes 5 à 8.

Voici le paquet obtenu après un mélange out-shuffle : les cartes du paquet A occupent les places 1, 3, 5 et 7.
Les cartes extrêmes (1 et 8) ont conservé leur position initiale (à l'extérieur : out).

Voici le paquet obtenu après un mélange in-shuffle : les cartes du paquet A occupent les places 2, 4, 6 et 8.
Les cartes extrêmes (1 et 8) sont désormais à l'intérieur du paquet mélangé (à l'intérieur : in).

2. Mélange Out-shuffle

2.1 Fonction outshuffle

Afin de pouvoir simuler des mélanges répétés, on programme une fonction qui agit sur un jeu de carte comme un mélange out-shuffle.

Question 2

Compléter la fonction outshuffle(tab) qui prend en paramètre un tableau représentant un jeu de cartes et qui renvoie le contenu de ce tableau après un mélange de type out-shuffle.

On suppose que tab contient un nombre pair d'éléments.

def outshuffle(tab):
    # on sépare le paquet de cartes en 2
    tas_haut = … # à compléter
    tas_bas = … # à compléter

    # on crée un tableau de même longueur que tab
    tab2 = [0] * len(tab)

    # on copie dans tab2 les cartes de tas_haut et tas_bas en les alternant
    # dans le tri out-shuffle, la carte du dessus du paquet initial reste
    # au-dessus du paquet mélangé
    for i in range(len(tas_haut)):
        # rangs pairs
        tab2[2 * i] = …
        # rangs impairs
        tab2[2 * i + 1] = …
    return tab2

À réaliser

Vérifier qu'un mélange de jeu32 avec la fonction outshuffle donne bien le résultat attendu.

assert(outshuffle(jeu32) == [1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31, 16, 32])

2.2 Après plusieurs mélanges

Question 3

  • Quelle est la position de la carte 2 du tableau jeu32 après un mélange de type out-shuffle ?
  • Et après 2 mélanges ? 3 mélanges ?

Question 4

En appliquant successivement plusieurs fois le mélange out-shuffle, peut-on revenir à l'ordre initial du jeu de 32 cartes ? Si oui, au bout de combien de mélanges au minimum ?

Question 5

  • Que réalise la fonction cycle_out(tab) ci-dessous ?
  • Quelle est la valeur de cycle_out(jeu32) ? Comment interpréter cette valeur ?
def cycle_out(tab):
    tab2 = tab[:] #copie des valeurs contenues dans tab
    compteur = 1
    tab = outshuffle(tab)
    while tab2 != tab :
        compteur += 1
        tab = outshuffle(tab)
    return compteur

2.3 Trajectoire d'une carte fixée

On s'intéresse dans cette partie à toutes les positions occupées par la carte 2 du jeu jeu32 au cours des mélanges successifs jusqu'à revenir à la configuration initiale du jeu.

Info

La méthode tab.index(valeur) permet de renvoyer l'indice de la première occurrence de valeur dans le tableau tab.

Exemple

Dans le tableau jeu32, la carte 2 apparaît en 2e position, c'est-à-dire avec l'indice 1.

jeu32.index(2)

1

Il peut être intéressant de constater que cette valeur est le nombre de cartes "au-dessus" de la carte 2 dans le paquet.

Question 6

Quels sont tous les indices de la carte 2 du tableau jeu32 lorsqu'on effectue des mélanges out-shuffle jusqu'à revenir à la configuration de départ ?

nombre de mélange(s) out-shuffle indice de la carte 2
0 1
1
2
3
...
à compléter

Question 7

On réalise des mélanges out-shuffle à partir du tableau jeu32.
Conjecturer une formule permettant d'obtenir l'indice de la carte 2 dans le tableau jeu32 à l'issue du prochain mélange out-shuffle, en fonction de son indice actuel.

À réaliser

Vérifier que la formule conjecturée permet de passer de chacun des indices du tableau de la question 6 à l'indice suivant, obtenu avec un nouveau mélange out-shuffle de jeu32.
En particulier, à partir de l'indice de la dernière ligne du tableau, la formule conjecturée doit donner 1, qui serait l'indice de la carte 2 après un nouveau mélange.

2.4 Trajectoire d'une carte quelconque

La fonction orbite_out(tab, valeur) ci-dessous permet d'obtenir le tableau de tous les indices de la carte valeur dans le tableau tab lorsqu'on effectue 5 mélanges out-shuffle successifs.

def orbite_out(tab, valeur):
    orbite =[0]*5
    for i in range(5):
        orbite[i] = tab.index(valeur)
        tab = outshuffle(tab)
    return orbite

Question 8

Utiliser la fonction précédente pour explorer les indices de quelques cartes du tableau jeu32 lorsqu'on effectue des mélanges out-shuffle jusqu'à revenir à la configuration de départ.
Conjecturer une formule permettant d'obtenir l'indice de la carte valeur dans le tableau jeu32 à l'issue du prochain mélange out-shuffle, en fonction de son indice actuel.

Question 9

Créer une fonction orbite_conjecture_out(valeur) permettant d'obtenir le tableau de tous les indices de la carte valeur dans le tableau jeu32, au fur et à mesure des mélanges, selon la conjecture formulée à la question précédente.

def orbite_conjecture_out(valeur):
   # à compléter

Question 10

Créer une fonction validation_conjecture_out() qui vérifie si, pour toutes les valeurs des cartes de jeu32, les tableaux orbite_out(jeu32, valeur) et orbite_conjecture_out(valeur) sont identiques.

def validation_conjecture_out(tab):
    # à compléter

2.5 Synthèse

Question 11

Rédiger une synthèse des résultats établis concernant le mélange out-shuffle.

3. Mélange in-shuffle

3.1 Fonction inshuffle

Question 12

Écrire une fonction inshuffle(tab) qui prend en paramètre un tableau représentant un jeu de cartes et qui renvoie le contenu de ce tableau après un mélange de type in-shuffle.

On suppose que tab contient un nombre pair d'éléments.

def inshuffle(tab):
   # à compléter

3.2 Après plusieurs mélanges

Question 13

En appliquant successivement plusieurs fois le mélange in-shuffle, peut-on revenir à l'ordre initial du jeu de 32 cartes ? Si oui, au bout de combien de mélanges au minimum ?

On utilisera une fonction pour déterminer cette valeur.

3.3 Trajectoire d'une carte fixée

Question 14

Quels sont tous les indices de la carte 2 du tableau jeu32 lorsqu'on effectue des mélanges in-shuffle jusqu'à revenir à la position de départ ?

nombre de mélange(s) in-shuffle indice de la carte 2
0 1
1
2
3
...
à compléter

Question 15

On réalise des mélanges in-shuffle à partir du tableau jeu32. Conjecturer une formule permettant d'obtenir l'indice de la carte 2 dans le tableau jeu32 à l'issue du prochain mélange in-shuffle, en fonction de son indice actuel.

3.4 Trajectoire d'une carte quelconque

La fonction orbite_in(tab, valeur) ci-dessous permet d'obtenir le tableau de tous les indices de la carte valeur dans le tableau tab lorsqu'on effectue 10 mélanges in-shuffle.

def orbite_in(tab, valeur):
    orbite =[0]*10
    for i in range(10):
        orbite[i] = tab.index(valeur)
        tab = inshuffle(tab)
    return orbite

Question 16

Utiliser la fonction précédente pour explorer les indices de quelques cartes du tableau jeu32 lorsqu'on effectue des mélanges in-shuffle jusqu'à revenir à la configuration de départ.
Conjecturer une formule permettant d'obtenir l'indice de la carte valeur dans le tableau jeu32 à l'issue du prochain mélange in-shuffle, en fonction de son indice actuel.

Question 17

Créer une fonction orbite_conjecture_in(valeur) permettant d'obtenir le tableau de tous les indices de la carte valeur dans le tableau jeu32, au fur et à mesure des mélanges, selon la conjecture formulée à la question précédente.

def orbite_conjecture_in(valeur):
   # à compléter

Question 18

Créer une fonction validation_conjecture_in() qui vérifie si pour toutes les valeurs des cartes de jeu32 les tableaux orbite_in(jeu32, valeur) et orbite_conjecture_in(valeur) sont identiques.

def validation_conjecture_in(tab):
    # à compléter

3.5 Synthèse

Question 19

Rédiger une synthèse des résultats établis concernant le mélange in-shuffle.