Aller au contenu

Exercices pour approfondir☘

Ces exercices doivent être utilisés pour approfondir votre maîtrise de la programmation. Ils sont parfois accompagnés d'aide et de leur solution pour vous permettre de progresser.

Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :

  • Avez-vous bien fait un schéma au brouillon pour visualiser le problème posé ?
  • Avez-vous essayé de rédiger un algorithme en français, avec vos propres mots, avant de vous lancer dans la programmation sur machine ?
  • Avez-vous utilisé des affichages intermédiaires, des print(), pour visualiser au fur et à mesure le contenu des variables ?
  • Avez-vous testé le programme avec les propositions de tests donnés dans l'exercice ?
  • Avez-vous testé le programme avec de nouveaux tests, différents de ceux proposés ?

Rappels

  • Chaque programme Python doit être sauvegardé sous forme de fichier texte avec l'extension .py.
    Enregistrez ce fichier dans le dossier [A02-Booléens] avec le nom donné à l'exercice : ProgA02.61.py, ProgA02.62.py, etc...
  • Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].

ProgA02.61 - Fonction « xor »☘

  1. Copiez, collez puis complétez le corps de la fonction xor() en respectant ses spécifications.
    Vérifiez votre travail en effectuant un appel à cette fonction dans la console.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def xor(a, b):
    """
    a, b – booléens
    Sortie: booléen – Résultat de « l'opération » a xor b
    >>> xor(True, True)
    False
    >>> xor(True, False)
    True
    >>> xor(False, True)
    True
    >>> xor(False, False)
    False
    """
    pass

##----- Mise en oeuvre des tests -----##
if __name__ == "__main__":
    import doctest
    doctest.testmod()
    Remarque importante

    Lister les quatre cas possibles en utilisant des instructions conditionnelles « if » marche, mais à ce stade de l'année, votre enseignant attend davantage de reflexion de votre part.

    Une solution

    On utilise les propriétés du « ou exclusif » découvertes dans le cours : 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
    def xor(a, b):
    """
    a, b – booléens
    Sortie: booléen – Résultat de « l'opération » a xor b
    >>> xor(True, True)
    False
    >>> xor(True, False)
    True
    >>> xor(False, True)
    True
    >>> xor(False, False)
    False
    """
    if a == b:
        return False
    else:
        return True

##----- Mise en oeuvre des tests -----##
if __name__ == "__main__":
    import doctest
    doctest.testmod()

  2. En vous inspirant de l'exercice ProgA02.51, définissez dans le même programme la fonction tableXor() qui affiche la table de l'opérateur xor.

    Affichage après exécution

    On doit obtenir l'affichage suivant : 

    >>> tableXor()
False xor False = False
False xor True = True
True xor False = True
True xor True = False

    Une réponse
    1
2
3
4
5
6
7
    def tableXor():
    """
    Sortie: None - Affichage de la table du « ou »
    """
    for a in (False, True):
        for b in (False, True):
            print(f"{a} xor {b} = {xor(a, b)}")

ProgA02.62 - Fonction « nand »☘

  1. Copiez, collez puis complétez le corps de la fonction nand() en respectant ses spécifications.
    Vérifiez votre travail en effectuant un appel à cette fonction dans la console.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def nand(a, b):
    """
    a, b – booléens
    Sortie: booléen – Résultat de « l'opération » a nand b
    >>> nand(True, True)
    False
    >>> nand(True, False)
    True
    >>> nand(False, True)
    True
    >>> nand(False, False)
    True
    """
    pass

##----- Mise en oeuvre des tests -----##
if __name__ == "__main__":
    import doctest
    doctest.testmod()
    Remarque importante

    Lister les quatre cas possibles en utilisant des instructions conditionnelles « if » marche, mais à ce stade de l'année, votre enseignant attend davantage de reflexion de votre part.

    Une solution

    On utilise la définition du « nand » découverte en TD, à savoir a nand b = non(a et b) : 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def nand(a, b):
    """
    a, b – booléens
    Sortie: booléen – Résultat de « l'opération » a nand b
    >>> nand(True, True)
    False
    >>> nand(True, False)
    True
    >>> nand(False, True)
    True
    >>> nand(False, False)
    True
    """
    return not(a and b)

##----- Mise en oeuvre des tests -----##
if __name__ == "__main__":
    import doctest
    doctest.testmod()

  2. En vous inspirant de l'exercice ProgA02.21, définissez dans le même programme la fonction tableNand() qui affiche la table de l'opérateur nand.

    Affichage après exécution

    On doit obtenir l'affichage suivant : 

    >>> tableNand()
False nand False = True
False nand True = True
True nand False = True
True nand True = False

    Une réponse
    1
2
3
4
5
6
7
    def tableNand():
    """
    Sortie: None - Affichage de la table du « nand »
    """
    for a in (False, True):
        for b in (False, True):
            print(f"{a} nand {b} = {nand(a, b)}")

ProgA02.63 - Fonction « nor »☘

  1. Copiez, collez puis complétez le corps de la fonction nor() en respectant ses spécifications.
    Vérifiez votre travail en effectuant un appel à cette fonction dans la console.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def nor(a, b):
    """
    a, b – booléens
    Sortie: booléen – Résultat de « l'opération » a nor b
    >>> nor(True, True)
    False
    >>> nor(True, False)
    False
    >>> nor(False, True)
    False
    >>> nor(False, False)
    True
    """
    pass

##----- Mise en oeuvre des tests -----##
if __name__ == "__main__":
    import doctest
    doctest.testmod()
    Remarque importante

    Lister les quatre cas possibles en utilisant des instructions conditionnelles « if » marche, mais à ce stade de l'année, votre enseignant attend davantage de reflexion de votre part.

    Une solution

    On utilise la définition du « nor » découverte en TD, à savoir a nor b = non(a ou b) : 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def nor(a, b):
    """
    a, b – booléens
    Sortie: booléen – Résultat de « l'opération » a nor b
    >>> nor(True, True)
    False
    >>> nor(True, False)
    False
    >>> nor(False, True)
    False
    >>> nor(False, False)
    True
    """
    return not(a or b)

##----- Mise en oeuvre des tests -----##
if __name__ == "__main__":
    import doctest
    doctest.testmod()

  2. En vous inspirant de l'exercice ProgA02.21, définissez dans le même programme la fonction tableNor() qui affiche la table de l'opérateur nor.

    Affichage après exécution

    On doit obtenir l'affichage suivant : 

    >>> tableNor()
False nor False = True
False nor True = False
True nor False = False
True nor True = False

    Une réponse
    1
2
3
4
5
6
7
    def tableNor():
    """
    Sortie: None - Affichage de la table du « nor »
    """
    for a in (False, True):
        for b in (False, True):
            print(f"{a} nor {b} = {nor(a, b)}")

ProgA02.64 - Les gouverner toutes☘

Dans les exercices pour lesquels il a fallu afficher les tables de vérité, on peut constater que l'on écrit quasiment le même code, à l'opérateur près (et, ou, xor, nand, nor).

En programmation, il faut toujours éviter ce genre de répétition afin d'améliorer la maintenance du code sur le long terme. En effet, toute modification du rendu final de la table (par exemple) devra être corrigée dans chacune des versions...

On cherche donc maintenant à écrire une fonction générique nommée table(), qui prend pour paramètre le nom d'une fonction correspondant à un opérateur binaire boolén puis qui affiche la table de vérité de cet opérateur.

Copiez, collez puis complétez les pointillés dans le code ci-dessous.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def et(a, b):
    return a and b

def ou(a, b):
    return a or b

def xor(a, b):
    if a == b:
        return False
    else:
        return True

def nand(a, b):
    return not(a and b)

def nor(a, b):
    return not(a or b)

def table(f):
    """
    f – fonction de deux variables booléennes
    Sortie: None – Affiche la table de vérité de la fonction f()
    """
    for a in (False, True):
        for b in (False, True):
            print( f"..." )

Exemple d'appel

>>> table(xor)
xor(False, False) = False
xor(False, True) = True
xor(True, False) = True
xor(True, True) = False
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def et(a, b):
    return a and b

def ou(a, b):
    return a or b

def xor(a, b):
    if a == b:
        return False
    else:
        return True

def nand(a, b):
    return not(a and b)

def nor(a, b):
    return not(a or b)

def table(f):
    """
    f – fonction de deux variables booléennes
    Sortie: None – Affiche la table de vérité de la fonction f()
    """
    for a in (False, True):
        for b in (False, True):
            print( f"f({a}, {b}) = {f(a,b)}" )
Une meilleure solution

Un inconvénient dans la solution précédente est qu'on perd le nom de la fonction dont on affiche la table. En Python, il est possible de récupérer le nom de la fonction f() à l'aide de la méthode f.__name__ :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def et(a, b):
    return a and b

def ou(a, b):
    return a or b

def xor(a, b):
    if a == b:
        return False
    else:
        return True

def nand(a, b):
    return not(a and b)

def nor(a, b):
    return not(a or b)

def table(f):
    """
    f – fonction de deux variables booléennes
    Sortie: None – Affiche la table de vérité de la fonction f()
    """
    for a in (False, True):
        for b in (False, True):
            print( f"{f.__name__}({a}, {b}) = {f(a,b)}" )