Aller au contenu

Exercices - Suites de caractères☘

Ces exercices doivent être utilisés pour vous entraîner à programmer. Ils sont généralement accompagnés de pistes 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ées 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 [F02-Chaines] avec le nom donné à l'exercice : ProgF02.71.py, ProgF02.72.py, etc...
  • Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].

ProgF02.71 : Suite de Robinson☘

Téléchargez le fichier « à trous » ProgF02.71.py (clic droit -> [Enregistrer sous]) et enregistrez-le dans le dossier [F02-Chaines] présent dans le répertoire [NSI].

Partie A - Compter des caractères identiques☘

Complétez le corps de la fonction compte_carac() en respectant ses spécifications. 

1
2
3
4
5
6
def compte_carac(chaine, car):
    """
    chaine – str (chaîne de caractères)
    car – str (un seul caractère)
    Sortie: int – le nombre d'occurences de car dans chaine
    """

Exemples de test

>>> compte_carac('abracadabra', 'a')
5
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def compte_carac(chaine, car):
    """
    chaine – str (chaîne de caractères)
    car – str (un seul caractère)
    Sortie: int – le nombre d'occurences de car dans chaine
    """
    compte = 0
    for carac in chaine:
        if carac == car:
            compte += 1
    return compte

Partie B - Sur le cahier☘

On considère les lignes suivantes, début de la suite de Robinson : 

0
10
1110
3110
132110
13123110
23124110
1413223110
1423224110

  1. Quelle logique permet le passage d'une ligne à l'autre ?
  2. Déterminez sur votre cahier les deux lignes qui suivront.
  3. Appelez l'enseignant pour vérifier.

Partie C - Programmation☘

  1. En utilisant à bon escient la fonction compte_carac() programmée en partie A, complétez le corps de la fonction ligne_suivante() qui permet de générer la ligne suivante dans la suite de Robinson. 

    1
2
3
4
5
    def ligne_suivante(chaine):
    """
    chaine – str, chaîne de caractères non vide constituée de chiffres
    Sortie: str – la chaîne de caractère suivante dans la suite de Robinson
    """

    Exemples de test

    >>> ligne_suivante('3110')
'132110'
    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    def ligne_suivante(chaine):
    """
    chaine – str, chaîne de caractères non vide constituée de chiffres
    Sortie: str – la chaîne de caractère suivante dans la suite de Robinson
    """
    resultat = ""
    for i in range(10):
        nb_carac = compte_carac(chaine, str(i))
        if nb_carac != 0:
            resultat = str(nb_carac) + str(i) + resultat
    return resultat

  2. Complétez le corps de triangle_robinson() en utilisant les fonctions définies précédemment. 

    1
2
3
4
5
6
7
    def triangle_robinson(chaine, nb_lignes):
    """
    chaine – str, chaîne de caractères non vide constituée de chiffres
    nb_lignes – int, entier strictement positif
    Sortie: None – Affiche nb_lignes du triangle de Robinson.
            chaine représente la première ligne de ce triangle.
    """

    Exemples de test

    >>> triangle_robinson('0', 9)
0
10
1110
3110
132110
13123110
23124110
1413223110
1423224110
    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def triangle_robinson(chaine, nb_lignes):
    """
    chaine – str, chaîne de caractères non vide constituée de chiffres
    nb_lignes – int, entier strictement positif
    Sortie: None – Affiche nb_lignes du triangle de Robinson.
            chaine représente la première ligne de ce triangle.
    """
    for i in range(nb_lignes):
        print(chaine)
        chaine = ligne_suivante(chaine)

ProgF02.72 : Suite de Conway☘

Téléchargez le fichier « à trous » ProgF02.72.py (clic droit -> [Enregistrer sous]) et enregistrez-le dans le dossier [F02-Chaines] présent dans le répertoire [NSI].

Partie A - Compter des caractères identiques☘

Complétez le corps de la fonction nb_carac_egaux() en respectant ses spécifications. 

1
2
3
4
5
6
7
def nb_carac_egaux(chaine, indice):
    """
    chaine – str, chaîne de caractères non vide
    indice – int, indice d'un caractère de la chaîne : 0 <= indice < len(chaine)
    Sortie: int – le nombre de caractères successifs égaux à chaine[indice]
            en partant de chaine[indice]
    """

Exemples de test

>>> nb_carac_egaux('aaa55bbb', 0)
3

>>> nb_carac_egaux('aaa55bbb', 2)
1

>>> nb_carac_egaux('aaa55bbb', 3)
2
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def nb_carac_egaux(chaine, indice):
    """
    chaine – str, chaîne de caractères non vide
    indice – int, indice d'un caractère de la chaîne : 0 <= indice < len(chaine)
    Sortie: int – le nombre de caractères successifs égaux à chaine[indice]
            en partant de chaine[indice]
    """
    carac_depart = chaine[indice]
    compteur = 1
    i = indice + 1
    while i < len(chaine) and chaine[i] == carac_depart:
        compteur += 1
        i += 1
    return compteur

Partie B - Sur le cahier☘

On considère les lignes suivantes, début de la suite de Conway : 

1
11
21
1211
111221
312211
13112221

  1. Quelle logique permet le passage d'une ligne à l'autre ?
  2. Déterminez sur votre cahier les deux lignes qui suivront.
  3. Appelez l'enseignant pour vérifier.

Partie C - Programmation☘

  1. En utilisant à bon escient la fonction nb_carac_egaux() programmée en Partie A, complétez le corps de la fonction conway_suivant() qui permet de générer la ligne suivante dans la suite de Conway. 

    1
2
3
4
5
    def conway_suivant(chaine):
    """
    chaine – str, chaîne de caractères non vide
    Sortie: str – la chaîne de caractère suivante dans la suite de Conway
    """

    Exemples de test

    >>> conway_suivant('1211')
'111221'
    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    def conway_suivant(chaine):
    """
    chaine – str, chaîne de caractères non vide
    Sortie: str – la chaîne de caractère suivante dans la suite de Conway
    """
    suivant = ''
    caractere = chaine[0]
    indice = 0
    nb_carac = nb_carac_egaux(chaine, indice)

    while indice < len(chaine):
        suivant = f"{suivant}{nb_carac}{caractere}"
        indice = indice + nb_carac
        if indice < len(chaine):
            caractere = chaine[indice]
            nb_carac = nb_carac_egaux(chaine, indice)

    return suivant

  2. Complétez le corps de triangle_conway() en utilisant les fonctions définies précédemment. 

    1
2
3
4
5
6
    def triangle_conway(nb_lignes):
    """
    nb_lignes – int, entier strictement positif
    Sortie: None – Affiche nb_lignes du triangle de Conway.
            chaine représente la première ligne de ce triangle.
    """

    Exemples de test

    >>> triangle_conway(7)
11
21
1211
111221
312211
13112221
    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def triangle_conway(nb_lignes):
    """
    nb_lignes – int, entier strictement positif
    Sortie: None – Affiche nb_lignes du triangle de Conway.
            chaine représente la première ligne de ce triangle.
    """
    chaine = '1'
    for i in range(nb_lignes):
        print(chaine)
        chaine = conway_suivant(chaine)