import pandas as pd
import ipywidgets as widgets
import matplotlib.pyplot as plt
from metakernel import register_ipython_magics as magics
from ipywidgets import interact
magics()
%matplotlib inline
Les exercices de cette sections devront être codés à l’aide d’une boucle pour.
Implémentez une fonction minimum
qui calcule la minimum des éléments d’une
liste d’entiers positifs.
def minimum(l) :
"""
Entrées : Liste d'entiers positifs l
Sortie : Le minimum de l
"""
if not l :
m = -1
else :
m = l[0]
for x in l[1:] :
if x < m :
m = x
return m
Implémentez une fonction deuxieme_minimum
qui calcule le second minimum des
éléments d’une liste d’entiers positifs.
def deuxieme_minimum(l) :
"""
Entrées : Liste d'entiers positifs l
Sortie : Le second minimum de l
"""
if len(L) > 1 :
if L[0] < L[1] :
m = L[0]
second_m = L[1]
else :
m = L[1]
second_m = L[0]
for x in l[2:] :
if x < m :
second_m = m
m = x
elif x < second_m :
second_m = x
else :
second_m = -1
return second_m
Implémentez une fonction recherche_lineaire
qui prend en entrée une liste de
chaînes de caractères et une chaîne de caractère et qui renvoie l’indice de la première
occurrence de la chaîne dans la liste, ou $-1$ si la chaîne n'est pas dans la liste.
def recherche_lineaire(l, s) :
"""
Entrées : Liste de chaînes de caractères l et une chaîne s
Sortie : L'indice de la première de s dans l, ou -1 si s n'est pas dans l
"""
for i, s_l in enumerate(l) :
if s_l == s :
return i
return -1
Implémentez une fonction recherche_lineaire_2
qui prend en entrée une liste de
chaînes de caractères et une chaîne de caractère et qui renvoie l’indice de la dernière
occurrence de la chaîne dans la liste, ou $-1$ si la chaîne n'est pas dans la liste.
def recherche_lineaire_2(l, s) :
"""
Entrées : Liste de chaînes de caractères l et une chaîne s
Sortie : L'indice de la dernière de s dans l, ou -1 si s n'est pas dans l
"""
for i in range(len(l)-1,-1,-1) :
if l[i] == s :
return i
return -1
Implémentez une fonction compter
qui prend en paramètre une liste d’entiers
L
et un entier x
et qui renvoie le nombre de fois que x
est dans L
.
def compter(l, x) :
"""
Entrées : Liste d'entiers l et un entier x
Sortie : Le nombre de fois que x apparaît dans l
"""
c = 0
for e in l :
if e == x :
c = c + 1
return c
Implémentez une fonction addition
qui prend deux n-uplet de flottants en
entrée de même taille $n$ et qui renvoie le n-uplet obtenu en sommant les
coordonnées des deux $n$-uplets.
def addition(u, v) :
"""
Entrées : u et v deux n-uplets de flottants de même taille
Sortie : l'addition de u et v dans R^n
"""
a = ()
for i in range(len(u)) :
a = a + (u[i]+v[i])
return a
t=addition((1,2),(2,4))
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Input In [7], in <cell line: 10>() 8 a = a + (u[i]+v[i]) 9 return a ---> 10 t=addition((1,2),(2,4)) Input In [7], in addition(u, v) 6 a = () 7 for i in range(len(u)) : ----> 8 a = a + (u[i]+v[i]) 9 return a TypeError: can only concatenate tuple (not "int") to tuple
Implémentez une fonction dedans
qui prend deux chaînes de caractère $s_1$ et
$s_2$ et qui renvoie une liste $L$ de booléens de même taille que $s_1$ telle
que $L[i]$ est vrai si et seulement si $s_1[i]$ est dans $s_2$.
def dedans(s1, s2) :
"""
Entrées : s1 et s2 deux chaînes de caractères
Sortie : une liste l de booléen de taille len(s1) telle que "l[i] ssi s[i] in s2"
"""
l = []
for c in s1 :
l = l + [c in s2]
return l
Implémentez une fonction souschaine
qui prend en entrée un chaîne de caractère
$s$ et un entier $n$ et qui renvoie la liste des sous chaînes de taille $n$ de
$s$.
Indication : Commencez par déterminer le nombre de sous chaînes de taille $n$ d’une chaîne de taille $m$.
def souschaine(s, n) :
"""
Entrées : s une chaîne de caractères et n un entier positif
Sortie : une liste l contenant toutes les sous chaînes de taille n de s
"""
l = []
for i in range(len(s)+1-n) :
l = l + [s[i:(i+n)]]
return l
Implémentez une fonction pyramide
qui prend en entrée un entier $n \geq 0$ et
qui renvoie une pyramide d’allumettes à $n$ étages en chaîne de caractères.
e.g. pour $n = 4$ :
|
|||
|||||
|||||||
Pour produire la pyramide, on va produire chaque étage qu'on va concatener les un avec les autres, séparés par un retour à la ligne.
Pour produire le $i^\text{ème}$ étage, on doit connaître :
Le nombre d'alumettes à l'étage $i$, $0 \leq i < n$, est $2\,i + 1$.
La base d'une pyramide de $n$ étage est donc $2\,n + 1$ alumette.
À chaque étage il reste $2\, n + 1 - 2\, i + 1 = 2\,(n - i + 1)$ espaces.
On les répartis, $(n - i + 1)$ espaces de chaque cotés pour équilibrer.
Le $i^\text{ème}$ étage sera donc produit au $i^\text{ème}$ tour de boucle du programme
def pyramide(n : int) -> str :
"""
Entrées : un entier n >= 0, le nombre d'étages de la pyramide.
Sortie : une chaîne de caractère, contenant le dessin de la pyramide d'alumettes.
"""
str_pyramide = ""
etage = 0
while etage < n :
str_etage = " " * (n - etage + 1) + "|" * (2 * etage + 1) + " " * ( n - etage + 1)
str_pyramide = str_pyramide + str_etage + "\n"
etage = etage + 1
return str_pyramide
interact(lambda n: print(pyramide(n)), n = widgets.IntSlider(value = 12, min = 0, max = 21))
None
Implémentez une fonction table_ascii
qui ne prend aucune entrée et renvoie la
table ascii dans une chaîne de caractère sous forme de tableau à double entrée.
Même principe que pour la pyramide, on va produire chaque ligne dans le corp d'une boucle.
On pense à produire la première ligne indépendemment.
Chaque ligne est produite à l'aide d'une boucle qui permettra de parcourir chaque valeur de la ligne et de la fonction chr
Pour mieux apréhender le code, essayons d'isoler différentes partie.
D'abord la création de la première ligne :
# Ligne initiale
colonne = 0
ligne_initiale = ""
ligne_initiale = ligne_initiale + " " # Première colonne
while colonne < 10 :
ligne_initiale = ligne_initiale + " " + str(colonne) + " " # Affichage du chiffre de la colonne
colonne = colonne + 1
ligne_initiale
' 0 1 2 3 4 5 6 7 8 9 '
Puis la création de la barre. Il faut calculer la longueur d'une ligne : $1$ pour le premier caractère et $3$ caractères pour chaque colonne.
barre = "-" * len(ligne_initiale)
print(ligne_initiale + '\n' + barre)
0 1 2 3 4 5 6 7 8 9 -------------------------------
Maintenant la création de chaque d'une ligne en particulier :
On considère une variable ligne
qui contient la dizaine de la ligne à afficher (10, 20, $\dots$)
colonne = 0
ligne_courante = ""
ligne_courante = ligne_courante + str(ligne) # Première colonne
# Ecriture de chaque colonne
while colonne < 10 :
ligne_courante = ligne_courante + " " + chr(ligne + colonne) + " "
colonne = colonne + 1
def tmp_ligne_table_ascii(ligne : int) -> str :
colonne = 0
ligne_courante = ""
ligne_courante = ligne_courante + str(ligne) # Première colonne
# Ecriture de chaque colonne
while colonne < 10 :
ligne_courante = ligne_courante + " " + chr(ligne + colonne) + " "
colonne = colonne + 1
return ligne_courante
interact(tmp_ligne_table_ascii, ligne = widgets.IntSlider(value = 50, min = 0, max = 120, step = 10, description = "ligne :" ))
None
interactive(children=(IntSlider(value=50, description='ligne :', max=120, step=10), Output()), _dom_classes=('…
On doit répéter le code ci-dessus pour chaque valeur de ligne
On imbrique donc ce code dans une boucle qui parcourera toutes les valeurs possibles de ligne
dans l'ordre.
def table_ascii() -> str :
"""
Entrées : aucune
Sortie : une chaîne de caractère, contenant la table ASCII
"""
table = ""
ligne_initiale = " " # Ligne initiale
for col in range(10) :
ligne_initiale = ligne_initiale + " " + str(col) + " "
# Barre
barre = "-" * len(ligne_initiale)
# Tableau
table = ligne_initiale + barre + "\n"
# Ecriture de chaque ligne
for ligne in range(0,130,10) :
ligne_courante = str(ligne) # Première colonne
# Ecriture de chaque colonne
for col in range(10) :
ligne_courante = ligne_courante + " " + chr(ligne + colonne) + " "
table = table + ligne_courante + "\n"
return table
print(table_ascii())
0 1 2 3 4 5 6 7 8 9 ------------------------------- 0 10 20 30 ! " # $ % & ' 40 ( ) * + , - . / 0 1 50 2 3 4 5 6 7 8 9 : ; 60 < = > ? @ A B C D E 70 F G H I J K L M N O 80 P Q R S T U V W X Y 90 Z [ \ ] ^ _ ` a b c 100 d e f g h i j k l m 110 n o p q r s t u v w 120 x y z { | } ~
Implémentez une fonction table_multiplication
qui prend un entier en entrée et
renvoie la table de multiplication de $0$ à $n$ dans une chaîne de caractère
sous forme de tableau à double entrée. e.g pour $n = 4$ :
| |0|1|2|3|4| |---|---|---|---|---|---| | 0|0|0|0|0|0| | 1|0|1|2|3|4| | 2|0|2|4|6|8| | 3|0|3|6|9|12| | 4|0|4|8|12|16|
Le concept est exactement le même que pour l'exercice précédent
def table_multiplication(n : int) -> str :
"""
Entrées : n un entier.
Sortie : une chaîne de caractère. La table de multiplication de 0 à n
"""
table = ""
colonne = 0
# Ligne initiale
ligne_initiale = ""
ligne_initiale = ligne_initiale + " " # Première colonne
while colonne <= n :
ligne_initiale = ligne_initiale + " " + str(colonne) + " " # Affichage du chiffre de la colonne
colonne = colonne + 1
table = ligne_initiale + "\n"
# Barre
barre = "-" * (1 + 3 * (n + 1))
table = table + barre + "\n"
# Tableau
ligne = 0
# Ecriture de chaque ligne
while ligne <= n :
colonne = 0
ligne_courante = ""
ligne_courante = ligne_courante + str(ligne) # Première colonne
# Ecriture de chaque colonne
while colonne <= n :
ligne_courante = ligne_courante + " " + str(ligne * colonne) + " "
colonne = colonne + 1
table = table + ligne_courante + "\n"
ligne = ligne + 1 # On passe à la dizaine suivante
return table
interact(lambda n: print(table_multiplication(n)), n = widgets.IntSlider(value = 12, min = 1, max = 30))
None
interactive(children=(IntSlider(value=12, description='n', max=30, min=1), Output()), _dom_classes=('widget-in…
Il y a un décalage, car le nombre de caractères pour écrire chaque nombre est différent.
On peut améliorer l'affichage en utilisant des tabulations ou en reservant un certain nombre d'espace pour chaque case en fonction du nombre le plus long à écrire.