Devoir de synthèse n°1 — Chaînes et tableaux

id: 33-1368-devoir-synthese-1-chaines-tableaux slug: 33-1368-devoir-synthese-1-chaines-tableaux titre: Devoir de synthèse n°1 — Chaînes et tableaux chapitre: 0 chapitre_titre: Évaluations lecon: 1 niveau: 4eme-sci ordre: 1 prerequis: [] duree_estimee_min: 90 mots_cles:

chaines
tableaux
sous_chaine
modulo
python
devoir langages:
analyse
python objectifs:
Manipuler les fonctions prédéfinies sur les chaînes de caractères
Tracer l'exécution d'une fonction itérative et en déduire le rôle
Décomposer un problème en modules et l'implémenter en Python status: published source_pdf: 33_1368.pdf source_pages:
1
2
3
4 kind: devoir

Présentation du devoir

Niveau : 4ème SC 1 & 2 — Nouveau Régime Matière : Informatique Durée : 1h30

Ce devoir de synthèse comporte trois exercices portant sur la manipulation des chaînes de caractères, la trace d'exécution d'un module et la programmation modulaire en Python autour des tableaux de chaînes.

Exercice 1 — Manipulation de chaînes (4 points)

Soit la partie déclarative d'un programme :

mot1 ← 'informatique'
mot2 ← '3D'

En utilisant des fonctions et des procédures prédéfinies en algorithme, donner les instructions permettant de réaliser les traitements suivants.

Exercice 1

Traitements sur mot1 et mot2

a. À partir de mot1, mettre dans la variable mot3 le terme 'format'.

b. À partir de mot3 et mot2, mettre dans la variable mot4 le terme 'format 3D'.

c. Mettre dans n la longueur de la chaîne mot4.

d. À partir de mot2, mettre dans m la valeur 3.

Voir le corrigé

mot3 ← sous_chaine(mot1, 2, 8)

mot4 ← mot3 + ' ' + mot2

n ← long(mot4)

m ← valeur(sous_chaine(mot2, 0, 1))

Exercice 2 — Trace et rôle d'un module (4 points)

Soit le module suivant :

Fonction inconnue (n : entier) : entier
Debut
    s ← 0
    Repeter
        r ← n mod 10
        n ← n div 10
        s ← s + r
    jusqu'à n = 0
    retourner s
Fin

A. Tester le module avec n = 135

Exercice 2A

Trace d'exécution pour n = 135

Compléter le tableau de trace puis indiquer la valeur retournée.

Voir le corrigé

Trace d'exécution

0 / 4

N°	Instruction	r	n	s
01	···	?	?	?
02	···	?	?	?
03	···	?	?	?
04	···	?	?	?

B. Déduire le rôle du module

Exercice 2B

Rôle du module

À partir de la trace, déduire le rôle du module inconnue.

Voir le corrigé

Le module retourne la somme des chiffres d'un entier n.

Exercice 3 — Tableaux de chaînes (12 points)

Énoncé

On souhaite :

Saisir un tableau T1 de n chaînes de caractères (avec n > 2), chaque chaîne ne devant pas dépasser 8 caractères.
Remplir un tableau T2 où chaque case contient le nombre de caractères majuscules suivi du caractère '*' suivi du nombre de caractères chiffres de l'élément correspondant de T1.
Afficher le tableau T2.

Exemple

T1 :

Ahmed2	AB152	2test4

Affichage de T2 :

1*1	2*3	0*2

En effet la chaîne Ahmed2 contient un seul caractère majuscule 'A' et un seul caractère chiffre '2', donc T2[0] contient 1*1.

Question 1 — Analyse modulaire (2 points)

Exercice 3.1

Schéma de décomposition modulaire

Compléter le schéma de décomposition modulaire du problème.

Voir le corrigé

Décomposition :

Programme principal
- SaisirN — saisie de la taille n
- RemplirT1 — remplissage du tableau T1
- remplirT2 — construction du tableau T2
  - intervalle — compte les caractères d'une chaîne situés dans un intervalle donné

Question 2 — Programme principal en Python (4 points)

Exercice 3.2

Programme principal Python

Donner en Python le programme principal qui appelle les modules définis.

Voir le corrigé

from numpy import array

n = saisirN()
T1 = remplirT1(n)
T2 = remplirT2(T1, n)
afficher(T2, n)

Question 3 — Définition des modules en Python (6 points)

Exercice 3.3

Implémentation des modules

Définir en Python les modules identifiés à la question 1 : saisirN, remplirT1, intervalle, remplirT2 et afficher.

Voir le corrigé

Module saisirN — saisit n tel que 2 < n ≤ 10 :

def saisirN():
    valide = False
    while valide == False:
        n = int(input('Taille tableau '))
        valide = 2 < n <= 10
    return n

Module remplirT1 — saisit un tableau de n chaînes de moins de 8 caractères :

def remplirT1(n):
    T1 = array([str] * n)
    for i in range(n):
        valide = False
        while valide == False:
            T1[i] = str(input('Donner element du tableau '))
            valide = len(T1[i]) < 8
    return T1

Module intervalle — compte les caractères de ch situés entre debut et fin :

def intervalle(ch, debut, fin):
    s = 0
    for i in range(len(ch)):
        if debut <= ch[i] <= fin:
            s = s + 1
    return s

Module remplirT2 — construit le tableau résultat :

def remplirT2(T1, n):
    T2 = array([str] * n)
    for i in range(n):
        T2[i] = str(intervalle(T1[i], 'A', 'Z')) + '*' + str(intervalle(T1[i], '0', '9'))
    return T2

Module afficher — affiche les éléments d'un tableau :

def afficher(T, n):
    for i in range(n):
        print(T[i], end=" ")