Entrainement
Crédit
@crédit : Thomas Foirien et Stéphan Van Zuijlen
Téléchargement
Vous pouvez télécharger le notebook ici
Exercice 1
Ecrire un programme qui affiche la première lettre d'un mot saisi par l'utilisateur.
mot = input("Veuillez saisir un mot : ")
print(mot[0])
Exercice 2
Ecrire un programme qui affiche la dernière lettre d'un mot saisi par l'utilisateur.
mot = input("Veuillez saisir un mot : ")
print(mot[len(mot)-1])
mot = input("Veuillez saisir un mot : ")
print(mot[-1])
Exercice 3
Ecrire une fonction estPresent(lettre,message) qui renvoie True ou False selon que la lettre est présente ou non dans le message.
assert(estPresent('a','abracadabra') == True)
assert(estPresent('r','abracadabra') == True)
assert(estPréeent('R','abracadabra') == False)
def estPresent(lettre, message) :
return lettre in message
def estPresent(lettre, message) :
for c in message :
if lettre == c :
return True
return False
Exercice 4
Ecrire une fonction nbOccurences(lettre,message) qui renvoie le nombre d'occurences d'une lettre (ou d'un caractère) dans un message.
def nbOccurences(lettre,message):
pass
assert(nbOccurences('a','abracadabra') == 5)
assert(nbOccurences('A','abracadabra') == 0)
def nbOccurences(lettre,message):
compteur = 0
for i in range(len(message)) :
if lettre == message[i] :
compteur += 1
return compteur
def nbOccurences(lettre,message):
compteur = 0
for c in message :
if lettre == c :
compteur += 1
return compteur
Exercice 5
Mot inversé
Ecrire une fonction inverse(mot) qui prend en paramètre un mot, et qui retourne ce mot à l'envers (de la droite vers la gauche).
assert inverse("redon") == "noder"
assert inverse("NSI") == "ISN"
def inverse(mot) :
motinverse = ""
for i in range(len(mot)):
motinverse += (mot[len(mot)-i-1])
return motinverse
def inverse(mot) :
motinverse = ""
for i in range(len(mot)-1,-1,-1):
motinverse += mot[i]
return motinverse
assert inverse("redon") == "noder"
assert inverse("NSI") == "ISN"
Exercice 6
Suppression des voyelles
Ecrire un programme qui demande à l'utilisateur de saisir un mot ou un message en lettres majuscules, et qui affiche ce message en supprimant toutes les voyelles.
message = input("Veuillez saisir un texte en majuscules : ")
# ...
message = input("Veuillez saisir un texte en majuscules : ")
nouveauMessage = ""
for c in message: # on utilise ici la syntaxe raccourcie : c prend comme valeur les caractères successifs de la chaîne
if c!='A' and c!='E' and c!='I'and c!='O' and c!='U' and c!='Y':
nouveauMessage = nouveauMessage + c
print(nouveauMessage)
Exercice 7
Plus longue répétition
Ecrire une fonction plusLongueRepetition(message) qui renvoie le plus grand nombre de caractères consécutifs identiques dans le message.
def plusLongueRepetition(message):
pass
assert(plusLongueRepetition('lycanthropiques') == 1)
assert(plusLongueRepetition('arrosoir') == 2)
assert(plusLongueRepetition('AAaaaaAaaaA') == 4)
assert(plusLongueRepetition('aaa') == 3)
assert(plusLongueRepetition('a') == 1)
assert(plusLongueRepetition('') == 0)
```python
def plusLongueRepetition(message):
if len(message) == 0:
return 0
maximum = 0
compteur = 1
for i in range(len(message)-1):
if message[i] == message[i+1]:
compteur = compteur + 1
else:
if compteur > maximum:
maximum = compteur
compteur = 1
if compteur > maximum: # pour le cas où la plus longue suite se trouve à la fin du message
maximum = compteur
return maximum
```
```python
assert(plusLongueRepetition('lycanthropiques') == 1)
assert(plusLongueRepetition('arrosoir') == 2)
assert(plusLongueRepetition('AAaaaaAaaaA') == 4)
assert(plusLongueRepetition('aaa') == 3)
assert(plusLongueRepetition('a') == 1)
assert(plusLongueRepetition('') == 0)
```
Exercice 8
Distance entre deux mots
La distance de Hamming entre deux mots de même longueur est le nombre d'endroit où les lettres sont différentes.
Par exemple : JAPON - SAVON
La première lettre de JAPON est différente de la première lettre de SAVON, les troisièmes aussi sont différentes.
La distance de Hamming entre JAPON et SAVON vaut donc 2.
Ecrire une fonction distHamming(mot1, mot2) qui calcule la distance de Hamming entre deux mots passés en paramètre.
Aide :
- Pour connaître la longueur d’une chaîne de caractère: len(machaine)
- Pour tester la non égalité de deux éléments: if el1!=ele2
- On utilisera un compteur
- On testera l’égalité des longueurs des mots
- On mettra les mots en majuscule dans une autre variable: m = mot.upper()
- Pour boucler sur les lettres d’un mot: par exemple pour les afficher
for i in range(len(mot)):
print(mot[i])
assert distHamming("JAPON", "SAVON") == 2
assert distHamming("NON","OUI") == 3
def distHamming(mot1, mot2) :
compteur = 0
for i in range(len(mot1)) :
if mot1[i] != mot2[i] :
compteur += 1
return compteur
Exercice 9
Le latin cochon
On transforme un mot commençant par une consonne selon la recette suivante:
- On déplace la première lettre à la fin du mot
- On rajoute le suffixe UM
Par exemple: VITRE devient ITREVUM
Ecrire une fonction latin(message) qui transforme un mot en latin cochon.
assert latin("VITRE")=="ITREVUM"
assert latin("REDON")=="EDONRUM"
assert not latin("PARIS")=="PARISUM"
Aide :
- Une chaîne de caractère est non modifiable, il faut donc en créer une autre
- On mettra le mot en majuscule: m=mot.upper()
- L’addition de caractères se nomme concaténation "A"+"B"="AB"
- On définit une chaîne de caractère vide avec: chaine=""
def latin(mot) :
return mot[1:]+ mot[0]+"UM"
Exercice 10
Test de conformité d'une chaîne
Les codes postaux américains (ZIP codes) doivent impérativement suivre le format suivant : 99999-9999
(cinq chiffres suivis d'un tiret suivi de quatre chiffres).
Les services de l'US Postal ont un sens de l'humour assez limité, et quiconque ne respectera pas rigoureusement le format verra sa lettre redirigée vers le service de tri à la main, et en ressortir après une durée difficile à prédire.
Ecrire une fonction ZIPCodeOK qui prend en paramètre une chaîne de caractères, et qui renvoie la valeur booléenne True ou False selon que la chaîne est un code postal valide ou non.
Tester votre fonction avec trois cas de figure différents.
def estChiffre(c) :
chiffre = "0123456789"
return c in chiffre
def ZIPCodeOK(code) :
estZip = False
#Première condition : la longueur est de 10
#Si ce n'est pas le cas, inutile de continuer d'ou le return a ce moment la du programme
if len(code) == 10 :
estZip = True
else :
return False
#deuxième condition : on a des chiffres en position 0 à 4
for i in range(0, 5) :
if estChiffre(code[i]) :
estZip = True
else :
estZip = False
#troisième condition le 6ème caractère (à l'indice 5) est un tiret
# on recherche le tiret et on récupère son indice grace à la fonction find()
if code.find('-') == 5 :
estZip = True
else :
return False
#dernière condition : on a des chiffres en position 6 à 9
for i in range(6, 9) :
if estChiffre(code[i]) :
estZip = True
else :
estZip = False
return estZip
assert ZIPCodeOK("99999-9999")
assert not ZIPCodeOK("4444-55555")
assert not ZIPCodeOK("1111-22-333")
assert ZIPCodeOk("17581-1681")
Remarque : Ce genre de problème peut être traité de façon très concise et efficace à l'aide des "expressions régulières" (regular expressions en anglais, abrégées en regexpr ou regex ou re), comme le montre le code ci-dessous.
Dans cet exercice, vous ne pouvez utiliser que les notions vues en classe (boucles, conditions...).
```python
import re
def ZIPCodeOk(chaine):
return re.compile("\d{5}-\d{4}").fullmatch(chaine) is not None
print(ZIPCodeOk("17581-1681"))
```