Propagation

L’exercice propagation portait sur des parcours récursifs dans une grille (un tableau à 2 dimensions).

Cet exercice a été réalisé en programmation impérative.

Code complet
import random

def construire_grille(w, h, defaut = 0):
    """ Renvoie une grille (liste de listes)
        de dimensions <w> x <h>
        ne contenant que la valeur <defaut>
    """
    g = []
    for _ in range(h):
        l = []
        for _ in range(w):
            l.append(defaut)
        g.append(l)
    return g

def peupler_grille(g, v, n):
    """ Peuple la grille <g> (construite avec construire_grille)
        avec <n> fois la valeur <v>
        répartis aléatoirement
    """
    w, h = len(g[0]), len(g)
    for pos in sample(range(w*h), n):
        g[pos//w][pos%w] = v


# Code d'affichage
sel = "█"  # case "sélectionnée"
vid = " "  # case "vide" (valeur 0)

def afficher_grille(g):
    """ Construit puis affiche
        une représentation textuelle d'une grille <g>
        (construite avec construire_grille)
    """
    w, h = len(g[0]), len(g)
    p = []
    for l in range(h):
        ligne = ""
        for c in range(w):
            v = g[l][c]
            if v == 0:
                car = vid
            elif v == -1:
                car = sel
            else: 
                car = str(v)
            ligne += car
        p.append(ligne)
    t = "\n".join(p)+"\n"
    print(t)


def propager(g, case, val = None):
    """ Lance une sélection des cases d'une grille <g>
        (construite avec construire_grille)
        par propagation à partir de la <case>
        (tuple (ligne, colonne))
        <val> est la valeur de référence utilisée pour la propagation
        (définie par celle de la première <case> de départ)
    """
    w, h = len(g[0]), len(g)
    l, c = case
    v = g[l][c]
    if val is None:
        val = v
    if v == val:
        g[l][c] = -1 # sélection de la case (l,c)
        afficher_grille(g) # uniquement pour afficher la progression de la propagation
        if l > 0:
            propager(g, (l-1, c), val)
        if l < h-1:
            propager(g, (l+1, c), val)
        if c > 0:
            propager(g, (l, c-1), val)
        if c < w-1:
            propager(g, (l, c+1), val)

 

L’objectif de l’activité est de réécrire ce programme en utilisant la programmation orientée objet, selon le diagramme de classe UML ci-dessous :

Commencer par implémenter la définition de la classe Case, et tester le bon fonctionnement de ses méthodes.

 

Implémenter progressivement la définition de la classe Grille, en testant le bon fonctionnement de chaque méthode à chaque étape.

Vous aimerez aussi...

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *