Aller au contenu principal

Sous-sections de Quelques projets à coder

Physique, Chimie et Informatique > Terminales Spé. NSI > Quelques projets à coder

Etiquetage en composante connexe

Introduction

L’étiquetage en composante connexe est une technique utilisée en traitement d’image pour regrouper ensemble des pixels ou des régions qui sont connectés et partagent des propriétés similaires. En d’autres termes, il s’agit de trouver et d’étiqueter des zones d’une image qui sont liées de manière directe ou indirecte.

Pour simplifier :

  • Pixels Connexes : On regarde les pixels qui se touchent ou sont directement voisins (horizontalement, verticalement, ou en diagonale).

  • Propriétés Similaires : On examine les valeurs des pixels ou d’autres caractéristiques, comme la couleur ou la luminosité, et on groupe les pixels ayant des valeurs similaires.

  • Étiquetage : On attribue une étiquette (un numéro ou une autre identification) à chaque groupe de pixels connexes partageant des propriétés similaires.

Cette technique est utilisée dans divers domaines, tels que la vision par ordinateur, la détection d’objets, la segmentation d’image, etc. Elle permet de distinguer et d’identifier des régions distinctes dans une image en se basant sur la connectivité et la similarité des pixels.

14 nov. 2023
Physique, Chimie et Informatique > Terminales Spé. NSI > Quelques projets à coder

Lé Démineur

Info

Le Démineur est un jeu vidéo de réflexion dont le but est de localiser des mines cachées dans une grille représentant un champ de mines virtuel, avec pour seule indication le nombre de mines dans les zones adjacentes.

L’objectif de cette séance est la construction de la grille représentant le champ de mines.

  1. Les fonctions développées ci-dessous devront appartenir à un module demineur.
    Créer ce module.

Le plateau à deux dimensions (m lignes et n colonnes) du jeu sera défini à la question 3. par une liste de listes contenant des valeurs booléennes. La présence d’une bombe correspondra à la valeur True tandis que l’absence d’une bombe à la valeur False. Les bombes seront placées aléatoirement avec une probabilité de 1/p.

  1. Dans le module demineur, définir la fonction contient_bombe dont la spécification est :
def contient_bombe(p: int) -> bool:
    """
    Fonction qui détermine si une case contient une bombe ou pas.
    Cette détermination est aléatoire, de probabilité 1/p.
    """

Remarque. Utiliser la fonction randint du module random pour effectuer le tirage aléatoire et décider que la présence d’une bombe correspond à la valeur 1 (c’est arbitraire).

  1. Dans le module demineur, définir la fonction initialisation_jeu dont la spécification est :
def initialisation_jeu(m: int, n: int, p: int) -> List[List[bool]]:
    """
    Initialise le Jeu en construisant un plateau de dimensions m x n cases,
    contenant des bombes dont la probabilité d'apparition est de 1/p.

    La présence d'une bombe correspond à la valeur True, l'absence d'une
    bombe correspond à la valeur False.
    """

Remarque. En fait, il est plus pratique (la raison sera développée plus tard) de créer un plateau de m + 2 lignes et de n + 2 colonnes. Les première et dernière lignes, ainsi que les première et dernière colonnes ne devront contenir aucune bombe.

  1. Dans le module demineur, définir la fonction affichage dont la spécification est :
def affichage(p: List[List[bool]]) -> None:
    """
    Affiche le plateau du jeu dans la console.
    Une astérisque représente une bombe, un point représente une cellule
    « sure ».
    """
  1. Dans le fichier principal, importer le module demineur,

    • définir les variables M, N et p en demandant à l’utilisateur leurs valeurs,
    • initialiser le jeu,
    • afficher le plateau.
  2. Dans le module demineur, définir la fonction nombre_bombes dont la spécification est :

def nombre_bombes(p: List[List[bool]], i: int, j: int) -> int:
    """
    Retourne le nombre de bombes au voisinage de la
    cellule (i, j) du plateau p.
    """

Remarque. Le fait d’avoir choisi une liste de listes de dimensions (m + 2) x (n + 2) facilite l’écriture de cette fonction.

  1. Dans le module demineur, définir la fonction dont la spécification est :
def affichage_nbre_bombes(p: List[List[bool]]) -> None:
    """
    Affiche le plateau du jeu dans la console.
    Une astérisque représente une bombe, les cellules « sures » contiennent
    le nombre de bombes adjacentes.
    """
  1. Appeler la fonction affichage_nbre_bombes depuis le fichier principal.
28 févr. 2022
Physique, Chimie et Informatique > Terminales Spé. NSI > Quelques projets à coder

Analyse des résultats du Loto

Le LOTO de la Française des Jeux est un jeu de hasard et d’argent apparu en 1976 en France. Dans sa première version (jusqu’en 2008), les joueurs devaient choisir 6 numéros dans une grille contenant tous les nombres entiers de 1 à 49 (inclus).

Sur le site de la Française des Jeux https://www.fdj.fr/jeux/jeux-de-tirage/loto/statistiques il est possible de télécharger un fichier contenant les résultats de tous les tirages1, noyés parmi un grand nombre d’informations, depuis le tout début de ce jeu. La quantité d’informations contenues dans le fichier est tellement importante que l’utilisation d’un programme pour les analyser prend tout son sens.

L’objectif du programme est, au minimum, de compter le nombre d’apparitions de chacun des numéros entre 1976 et 2008.
Le résultat, dans la console, doit au minimum fournir les informations suivantes2 :

Lors des 4858 tirages : 
    le 1 est apparu 710 fois 
    le 2 est apparu 681 fois 
    le 3 est apparu 674 fois 
    le 4 est apparu 720 fois 
    le 5 est apparu 702 fois
    ...

Le programme devra être découpé en fonctions. Chaque fonction devra être accompagnée de sa spécification.

Le site n’est pas accessible depuis les Émirats


  1. En réalité il existe deux fichiers car la formule du jeu a été modifiée en 2008. Nous ne traiterons que les résultats des tirages entre 1976 et 2008 ! ↩︎

  2. Vous pourrez en fournir d’autres qui vous paraitraient pertinentes. ↩︎