Aller au contenu

TP Python – Boucles en Python

BTS SIO SISR 1re année – Mathématiques pour l'informatique – S04

Note

Comment ce TP fonctionne. Chaque exercice a un éditeur Python intégré à la page (il s'exécute dans ton navigateur, rien à installer). Avant de lancer, écris sur ta feuille ce que tu anticipes (« J'anticipe »). Puis lance et compare. Le bouton Valider exécute des tests : un test réussi ne dispense pas de comprendre pourquoi.

Exercice A – Somme des carrés

Écris somme_carres(n) qui renvoie \(1^2 + 2^2 + \dots + n^2\).

J'anticipe. Pour n = 4, écris la trace de s sur ta feuille avant de coder.

###
assert sommepy-undcarres(0) == 0bksl-nlassert sommepy-undcarres(1) == 1bksl-nlassert sommepy-undcarres(4) == 30bksl-nlassert sommepy-undcarres(5) == 55bksl-nlassert sommepy-undcarres(10) == 385bksl-nlbksl-nl ∞/∞

def sommepy-undcarres(n):bksl-nl """Renvoie 1² + 2² + ... + n²."""bksl-nl s = 0bksl-nl for i in range(1, n + 1):bksl-nl s = ... # à compléterbksl-nl return sbksl-nlbksl-nl



Exercice B – Factorielle

Écris factorielle(n) (\(n \ge 0\)) avec une boucle. Rappel : \(0! = 1\).

###
assert factorielle(0) == 1bksl-nlassert factorielle(1) == 1bksl-nlassert factorielle(5) == 120bksl-nlassert factorielle(10) == 3628800bksl-nlassert factorielle(20) == 2432902008176640000bksl-nlbksl-nl ∞/∞

def factorielle(n):bksl-nl """Renvoie n! (n entier >= 0)."""bksl-nl ...bksl-nlbksl-nl



Exercice C – Chiffres d'un nombre

Écris somme_chiffres(n) et nombre_chiffres(n) pour un entier \(n \ge 0\) (avec nombre_chiffres(0) égal à 1), sans utiliser str.

###
assert sommepy-undchiffres(2024) == 8bksl-nlassert sommepy-undchiffres(0) == 0bksl-nlassert sommepy-undchiffres(90210) == 12bksl-nlassert nombrepy-undchiffres(2024) == 4bksl-nlassert nombrepy-undchiffres(0) == 1bksl-nlassert nombrepy-undchiffres(9) == 1bksl-nlassert nombrepy-undchiffres(10) == 2bksl-nlassert nombrepy-undchiffres(90210) == 5bksl-nlassert all(nombrepy-undchiffres(k) == len(str(k)) for k in range(0, 5000))bksl-nlbksl-nl ∞/∞

def sommepy-undchiffres(n):bksl-nl """Somme des chiffres décimaux de n (n >= 0)."""bksl-nl ...bksl-nlbksl-nldef nombrepy-undchiffres(n):bksl-nl """Nombre de chiffres décimaux de n (n >= 0) ; 0 s'écrit avec 1 chiffre."""bksl-nl ...bksl-nlbksl-nl



Exercice D – Seuil de saturation

Un volume de sauvegardes double chaque mois à partir de 1 Go. Écris mois_avant_saturation(capacite) qui renvoie le plus petit nombre de mois \(k\) tel que le volume \(2^k\) Go atteint ou dépasse la capacité (en Go) du disque.

Je comprends. Quel est le variant de ta boucle ? Pourquoi s'arrête-t-elle ?

###
assert moispy-undavantpy-undsaturation(1) == 0bksl-nlassert moispy-undavantpy-undsaturation(2) == 1bksl-nlassert moispy-undavantpy-undsaturation(100) == 7bksl-nlassert moispy-undavantpy-undsaturation(128) == 7bksl-nlassert moispy-undavantpy-undsaturation(129) == 8bksl-nlassert moispy-undavantpy-undsaturation(1000) == 10bksl-nlassert moispy-undavantpy-undsaturation(4000) == 12bksl-nlbksl-nl ∞/∞

def moispy-undavantpy-undsaturation(capacite):bksl-nl """Plus petit k tel que 2py-strpy-strk >= capacite (capacite en Go, entier >= 1)."""bksl-nl volume = 1bksl-nl k = 0bksl-nl # À compléter : une boucle « tant que » qui double le volumebksl-nl # tant qu'il est inférieur à la capacité, en comptant les tours.bksl-nl return kbksl-nlbksl-nl



Exercice E – Adresses d'une plage

Écris plage(prefixe, debut, fin) qui renvoie la liste des adresses prefixe.k pour \(k\) de debut à fin inclus, par exemple plage("192.168.1", 10, 12) donne ["192.168.1.10", "192.168.1.11", "192.168.1.12"].

###
assert plage("192.168.1", 10, 12) == ["192.168.1.10", "192.168.1.11", "192.168.1.12"]bksl-nlassert plage("10.0.0", 5, 5) == ["10.0.0.5"]bksl-nlassert plage("10.0.0", 6, 5) == []bksl-nlassert len(plage("172.16.0", 1, 254)) == 254bksl-nlassert plage("172.16.0", 1, 254)[-1] == "172.16.0.254"bksl-nlbksl-nl ∞/∞

def plage(prefixe, debut, fin):bksl-nl """Liste des adresses prefixe.k pour k de debut à fin inclus."""bksl-nl adresses = []bksl-nl ...bksl-nl return adressesbksl-nlbksl-nl



Exercice F – Syracuse

Écris syracuse(n) qui renvoie le nombre d'étapes pour atteindre 1 à partir de \(n \ge 1\) (si \(n\) est pair on prend \(n/2\), sinon \(3n+1\)).

###
assert syracuse(1) == 0bksl-nlassert syracuse(2) == 1bksl-nlassert syracuse(7) == 16bksl-nlassert syracuse(27) == 111bksl-nlassert syracuse(16) == 4bksl-nlbksl-nl ∞/∞

def syracuse(n):bksl-nl """Nombre d'étapes pour atteindre 1 (n >= 1)."""bksl-nl etapes = 0bksl-nl # À compléter : tant que n est différent de 1,bksl-nl # - si n est pair, n devient n // 2, sinon n devient 3 py-str n + 1bksl-nl # - on compte une étapebksl-nl return etapesbksl-nlbksl-nl



Je comprends. Pourquoi ne peut-on pas affirmer, comme pour une boucle POUR, que cette boucle s'arrête ?