Ajout TP 7 et avancement sur Echecs avant POO

S1/TP 7/chaines.py

@@ -0,0 +1,396 @@
+# VAN DEN BERGE Manon          - PeiP 12 - 2014/2015
+# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
+# TP n°7 donné le 7/11/2014 - Exercices sur les chaînes de caractère
+# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/seq4_chaines_caracteres.html#exercices
+
+import doctest
+
+
+# Exercice 30 lignes vides
+
+# Comment en utilisant print une seule fois peut-on imprimer 30 lignes
+# vides ? (boucles pour et tant que interdites)
+
+# En utilisant l'opérateur de répétition
+
+# print("\n"*30, end='')
+
+
+# Exercice Impression verticale
+
+# Réalisez une fonction imprimer_vertical qui imprime un à un les
+# caractères de la chaîne qu’on lui donne en paramètre les uns au dessus
+# des autres.
+
+def imprimer_vertical(chaine):
+    """
+    Imprime un à un les caractères de la chaîne donnée en paramètre les uns au
+    dessus des autres.
+    str → ∅
+    CU : chaine du type str
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    for i in chaine:
+        print(i)
+
+# >>> imprimer_vertical('Timoleon')
+# T
+# i
+# m
+# o
+# l
+# e
+# o
+# n
+
+
+# Exercice Impression à l’envers
+
+# Réalisez d’au moins deux façons différentes une fonction imprimer_envers
+# qui imprime la chaîne qu’on lui donne en paramètre en inversant l’ordre
+# des caractères.
+
+# Avertissement Utilisez le paramètre optionnel end de la fonction print pour
+# éviter les passages à la ligne non désirés.
+
+def imprimer_envers1(chaine):
+    """
+    Imprime la chaîne donnée en paramètre en inversant l’ordre des caractères.
+    str → ∅
+    CU : chaine du type str
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    affichage = ''
+    for i in chaine:
+        affichage = i + affichage
+    print(affichage)
+
+# >>> imprimer_envers1('Timoleon')
+# noelomiT
+# >>> imprimer_envers1('')
+#
+
+def imprimer_envers2(chaine):
+    """
+    Imprime la chaîne donnée en paramètre en inversant l’ordre des caractères.
+    str → ∅
+    CU : chaine du type str
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    affichage = ''
+    if len(chaine) > 0:
+        for i in range(-1, -len(chaine)-1, -1):
+            print(i, chaine[i])
+            affichage += chaine[i]
+    print(affichage)
+
+# >>> imprimer_envers2('Timoleon')
+# noelomiT
+# >>> imprimer_envers2('')
+#
+
+
+# Exercice Miroir
+
+# Réalisez une fonction miroir qui renvoie une chaîne contenant les
+# caractères de la chaîne qu’on lui donne en paramètre dans l’ordre
+# inverse.
+
+def miroir(chaine):
+    """
+    Renvoie une chaîne contenant les caractères de la chaîne donnés en paramètre
+    dans l’ordre inverse.
+    str → str
+    CU : chaine du type str
+
+    >>> miroir ('Timoleon')
+    'noelomiT'
+    >>> miroir ('')
+    ''
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    retour = ''
+    if len(chaine) > 0:
+        for i in range(-1, -len(chaine)-1, -1):
+            retour += chaine[i]
+    return retour
+
+# Exercice Palindrome
+
+# Un palindrome est un mot qui se lit de la même façon de gauche à droite
+# et de droite à gauche. Par exemple, ICI, ELLE et RADAR sont des
+# palindromes.
+
+# Par extension, une chaîne de caractères est dite palindromique si la
+# liste de ses caractères parcourus de gauche à droite est la même que
+# celle de ses caractères parcourus de droite à gauche. Par exemple, la
+# chaîne 'A, 1 b+b 1 ,A' est palindromique
+
+# Le but est de réaliser un prédicat est_palindromique qui renvoie
+
+# True si la chaîne passée en paramètre est palindromique
+# False dans le cas contraire.
+# >>> est_palindromique ('Timoleon')
+# False
+# >>> est_palindromique ('RADAR')
+# True
+# >>> est_palindromique ('A, 1 b+b 1 ,A')
+# True
+
+# Réalisez ce prédicat en utilisant la fonction miroir de l’exercice précédent.
+
+def est_palindromique1(chaine):
+    """
+    Indique si la chaîne passée en paramètre est palindromique
+    str → bool
+    CU : mot est du type str
+
+    >>> est_palindromique1('Timoleon')
+    False
+    >>> est_palindromique1('A, 1 b+b 1 ,A')
+    True
+    >>> est_palindromique1('')
+    True
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    return chaine == miroir(chaine)
+
+# Réalisez une autre version sans utiliser la fonction miroir.
+
+def est_palindromique2(chaine):
+    """
+    Indique si la chaîne passée en paramètre est palindromique
+    str → bool
+    CU : mot est du type str
+
+    >>> est_palindromique1('Timoleon')
+    False
+    >>> est_palindromique1('A, 1 b+b 1 ,A')
+    True
+    >>> est_palindromique1('')
+    True
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    longueur = len(chaine) # On crée une variable pour éviter
+                           # de trop appeler len()
+    if longueur > 0:
+        for i in range(longueur):
+            if chaine[longueur-i-1] != chaine[i]:
+                return False
+    return True
+
+
+# Exercice Longueur d’une chaîne
+
+# La fonction len renvoie la longueur de la chaîne de caractères qu’on lui
+# passe en paramètre.
+
+# Sans utiliser cette fonction, réalisez une fonction qui fait exactement
+# la même chose.
+
+def my_len(chaine):
+    """
+    Renvoie la longueur de la chaîne de caractères passée en paramètre.
+    str → int
+    CU : chaine est du type str
+
+    >>> my_len ('')
+    0
+    >>> my_len ('abcd')
+    4
+    >>> my_len ('esope reste ici et se repose')
+    28
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    a = 0
+    for i in chaine[:]:
+        a += 1
+    return a
+
+
+# Exercice Suppression d’un caractère
+
+# Réalisez une fonction qui renvoie une chaîne obtenue en supprimant le
+# caractère d’indice i d’une chaîne s, l’indice et la chaîne s étant
+# passés en paramètres.
+
+def sauf(s, i):
+    """
+    Renvoie une chaîne obtenue en supprimant le caractère d’indice
+    i d’une chaîne s, l’indice et la chaîne s étant passés en paramètres.
+    (str, int) → str
+    CU : s du type str et 0 ≤ i < len(s)
+
+    >>> sauf('Timoleon', 3)
+    'Timleon'
+    """
+    assert(type(s) is str), "s doit être du type str"
+    assert(i >= 0 and i < len(s)), "i doit être dans l'intervalle [0, len(s)["
+
+    return s[:i] + s[i + 1:]
+
+# Vous pourrez supposer que l’indice est un entier positif ou nul.
+
+# >>> s = 'Timoleon'
+# >>> for i in range(len(s)):
+# ...     print(sauf(s, i))
+# ...
+# imoleon
+# Tmoleon
+# Tioleon
+# Timleon
+# Timoeon
+# Timolon
+# Timolen
+# Timoleo
+
+
+# Que renvoie votre fonction si l’indice passé en paramètre est négatif ?
+
+# En premier test, la fonction déclenche une erreur d'assertion.
+# En enlevant les assertions, l'instruction sauf(s, -i) (pour i positif)
+
+
+# Exercice Nombre d’occurrences
+
+# Réalisez une fonction qui renvoie le nombre d’occurrences d’un caractère
+# dans une chaîne, le caractère et la chaîne étant passés en paramètre.
+
+def nbre_occurrences(caractere, chaine):
+    """
+    Renvoie le nombre d’occurrences d’un caractère dans une chaîne, le caractère
+    et la chaîne étant passés en paramètre.
+    (str, str) → int
+    CU : caractere de type str de taille 1 et chaine de type str
+
+    >>> nbre_occurrences ('o', 'Timoleon')
+    2
+    >>> nbre_occurrences ('y', 'Timoleon')
+    0
+    >>> nbre_occurrences (' ', 'esope reste ici et se repose')
+    5
+    """
+    assert(type(caractere) is str and len(caractere) == 1), \
+        "caractere doit être du type str et de taille 1"
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    nombre = 0
+    for i in chaine:
+        if i == caractere:
+            nombre += 1
+    return nombre
+
+
+# Exercice Suppression des occurences d’un caractère
+
+# Réalisez une fonction qui renvoie une chaîne obtenue en supprimant
+# toutes les occurrences d’un caractère dans une chaîne, ce caractère et
+# cette chaîne étant passés en paramètres.
+
+def supprime_car(caractere, chaine):
+    """
+    Renvoie une chaîne obtenue en supprimant toutes les occurrences d’un
+    caractère dans une chaîne, ce caractère et cette chaîne étant passés en
+    paramètres.
+    (str, str) → str
+    CU : caractere de type str de taille 1 et chaine de type str
+
+    >>> supprime_car ('o', 'Timoleon')
+    'Timlen'
+    >>> supprime_car ('y', 'Timoleon')
+    'Timoleon'
+    """
+    assert(type(caractere) is str and len(caractere) == 1), \
+        "caractere doit être du type str et de taille 1"
+    assert(type(chaine) is str), "chaine doit être du type str"
+
+    retour = ''
+    for i in chaine:
+        if i != caractere:
+            retour += i
+    return retour
+
+
+# La phrase esope reste ici et se repose n’est pas un palindrome au sens
+# donné dans l’exercice ci-dessus. Mais si on ne regarde que les lettres,
+# c’est un palindrome.
+
+# Comment vérifier ce point avec les fonctions supprime_car et
+# est_palindromique ?
+
+# On peut utiliser la composée des deux fonctions de la façon suivante
+# (chaine étant la chaine dont on souhaite vérifier si elle est palindromique)
+
+# est_palindromique(supprime_car(' ', chaine))
+
+# On peut même enlever les points, les virgules et toute autre ponctuation
+# génante
+
+# est_palindromique(supprime_car(' ', supprime_car(',', supprime_car('.', \
+#   supprime_car('!', supprime_car('?', chaine))))))
+
+# Cependant, créer une nouvelle fonction qui supprime tous les caractères d'une
+# contenus dans une liste serait plus approprié dans ce cas.
+
+
+# Exercice Remplacement d’un caractère
+
+# Réalisez une fonction qui remplace le caractère d’un indice donné d’une
+# chaîne de caractères par une autre chaîne de caractères.
+
+def remplace_indice(chaine, indice, remplacement):
+    """
+    Remplace le caractère d’un indice donné d’une chaîne de caractères par une
+    autre chaîne de caractères.
+    (str, int, str) → str
+    CU : chaine de type str et indice de type int et remplacement de type str
+
+    >>> remplace_indice ('Timileon',3,'o')
+    'Timoleon'
+    >>> remplace_indice ('Tixleon',2,'mo')
+    'Timoleon'
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+    assert(type(indice) is int), "indice doit être du type int"
+    assert(type(remplacement) is str), "remplacement doit être du type str"
+
+    return chaine[:indice] + remplacement + chaine[indice + 1:]
+
+# Réalisez une fonction qui remplace dans une chaîne donnée toutes les
+# occurences d’un caracère donné par une autre chaîne de caractères.
+
+def remplace_occurrences(chaine, caractere, remplacement):
+    """
+    Remplace dans une chaîne donnée toutes les occurences d’un caracère donné
+    par une autre chaîne de caractères.
+    (str, str, str) → str
+    CU : chaine de type str et caractere du type str et de taille 1 et
+    remplacement de type str
+
+    >>> remplace_occurrences ('@ 3 est le neveu de @ 1er.','@','Napoléon')
+    'Napoléon 3 est le neveu de Napoléon 1er.'
+    """
+    assert(type(chaine) is str), "chaine doit être du type str"
+    assert(type(caractere) is str and len(caractere) == 1), \
+        "caractere doit être du type str et de taille 1"
+    assert(type(remplacement) is str), "remplacement doit être du type str"
+
+    retour = ''
+    for i in chaine:
+        if i == caractere:
+            retour += remplacement
+        else:
+            retour += i
+    return retour
+
+
+
+def tester():
+    doctest.testmod(verbose=True)