TP1/Tp1.py

+#TANOH M'BAH ANGE PASCAL
+#17/01/2024
+#GROUPE 15
+
+
+s="la méthode split est parfois bien utile"
+
+#s.split(' ')=['la', 'méthode','split','est','parfois','bien','utile']
+#s.split('e')=['laméthod',' split ','st ',' parfois bi'n util', '']
+
+#s.split('é')=['la m','thode split est parfois bien utile']
+
+#s.split()=['la', 'méthode', 'split', 'est', 'parfois', 'bien', 'utile']
+#s.split('')=Valueerror,chaine vide ne doit pas être vide
+
+#s.split('split')=['la méthode ', ' est parfois bien utile']
+
+#2.La méthode split sépare la chaine de caractère en supprimant ce qui est dans les parenthèses
+#3. Non , s n'est pas modifié , elle renvoie seulement une liste de la chaine séparé par la chaine de caractère dans les parenthèses.
+l = s.split()
+#Méthode sort
+#"".join(l)='laméthodesplitestparfoisbienutile'
+
+#" ".join(l)='la méthode split est parfois bien utile'
+#";".join(l)='la;méthode;split;est;parfois;bien;utile'
+
+#" tralala ".join(l)='la tralala méthode tralala split tralala est tralala parfois tralala bien tralala utile'
+
+#print ("\n".join(l))
+
+#la
+#méthode
+#split
+#est
+#parfois
+#bien
+#utile
+
+#"".join(s)='la méthode split est parfois bien utile'
+
+#"!".join(s)='l!a! !m!é!t!h!o!d!e! !s!p!l!i!t! !e!s!t! !p!a!r!f!o!i!s! !b!i!e!n! !u!t!i!l!e'
+#"".join()=Typeerror
+#dans la parenthèse il doit y avoir une variable
+
+
+#"".join([])=''
+#"".join([1,2])=Typeerror
+#Join accepte seulement les chaines de caractères
+#2. La méthode join rassemble les chaines de caractères en fonction du caractère dans les parenthèses.
+#3. Cette méthode ne modifie pas la chaine de caractère s. 
+
+l = list('timoleon')
+
+#l.sort()
+#l=['e', 'i', 'l', 'm', 'n', 'o', 'o', 't']
+s1="Je n'ai jamais joué de flûte."
+l1=list(s1)
+#l1=['J', 'e', ' ', 'n', "'", 'a', 'i', ' ', 'j', 'a', 'm', 'a', 'i', 's', ' ', 'j', 'o', 'u', 'é', ' ', 'd', 'e', ' ', 'f', 'l', 'û', 't', 'e', '.']
+#1. La méthode sort renvoie la liste de la chaine séparté caractères par caractère en les classant avec l'ordre léxicographique
+l=['a',1]
+#2.l.sort()=Typeerror, ne supporte pas les listes des entiers et chaines de caractères. La méthode sort() accepte les listes de str tout seul ou listes de int tout seul.
+def sort(s: str) -> str:
+    """
+    Renvoie une chaîne de caractères contenant les caractères de `s` triés dans l'ordre croissant.
+
+    Précondition: aucune
+
+    Exemples:
+
+    $$$ sort('timoleon')
+    'eilmnoot'
+    """
+    res=''
+    l=list(s)
+    l.sort()
+    for elt in range(len(l)):
+        res+=l[elt]
+        
+    return res
+
+def sont_anagrammes1(s1: str, s2: str) -> bool:
+    """
+    Renvoie True si s1 et s2 sont anagrammatiques, False sinon.
+
+    Précondition: aucune
+
+    Exemples:
+
+    $$$ sont_anagrammes1('orange', 'organe')
+    True
+    $$$ sont_anagrammes1('orange','Organe')
+    True
+    """
+    i=0
+    while i<len(s1) and i<len(s2) and s1[i]!=s2[i]:
+        if len(s1)==len(s2):
+            i+=1
+    return s1[i]==s2[i]
+
+
+def sont_anagrammes(s1: str, s2: str) -> bool:
+    """
+    Renvoie True si s1 et s2 sont anagrammatiques, False sinon.
+
+    Précondition: aucune
+
+    Exemples:
+
+    $$$ sont_anagrammes('orange', 'organe')
+    True
+    $$$ sont_anagrammes('orange','Organe')
+    False
+    """
+
+    
+    l1=list(s1)
+    l1.sort()
+    l2=list(s2)
+    l2.sort()
+    return l1==l2 
+
+def sont_anagrammes2(s1: str, s2: str) -> bool:
+    """
+    Renvoie True si s1 et s2 sont anagrammatiques, False sinon.
+
+    Précondition: aucune
+
+    Exemples:
+
+    $$$ sont_anagrammes2('orange', 'organe')
+    True
+    $$$ sont_anagrammes2('orange','Organe')
+    False
+    """
+    
+    occurrence_s1={}
+    occurrence_s2={}
+    for c in s1:
+        #occurrence_s1[c]=occurrence_s1.get(c)+1
+        occurrence_s1[c]={c}
+    for c in s2: 
+        #occurrence_s2[c]=occurrence_s2.get(c)+1
+        occurrence_s2[c]={c}
+    return occurrence_s1==occurrence_s2
+
+def sont_anagrammes3(s1: str, s2: str) -> bool:
+    """
+    Renvoie True si s1 et s2 sont anagrammatiques, False sinon.
+
+    Précondition: aucune
+
+    Exemples:
+
+    $$$ sont_anagrammes3('orange', 'organe')
+    True
+    $$$ sont_anagrammes3('orange','Organe')
+    True
+    """
+    
+    
+    
+    for c in s1:
+        if s1.count(c)!=s2.count(c):
+            res=False
+        else:
+            res=True
+    
+    return res
+                
+
+    
+EQUIV_NON_ACCENTUE={'e':['è','é','ê'],'a':['à','â'],'i':['î'],'u':['ù']}
+
+def bas_casse_sans_accent(chaine:str)->str:
+    """ renvoie une chaîne de caractères identiques à celle passée en paramètre sauf pour les lettres majuscules et les lettres accentuées qui sont converties en leur équivalent minuscule non accentué
+
+    Précondition : aucune
+    Exemple(s) :
+    $$$ bas_casse_sans_accent('Orangé')
+    'orange'
+ 
+
+    """
+    res=''
+    for car in chaine:
+        identique=False
+        for cle,val in EQUIV_NON_ACCENTUE.items():
+            if car in val:
+                res+=cle.lower()
+                identique=True
+        if not identique:
+            res+=car.lower()
+    return res
+            
+                 
+            
+def sont_anagrammes4(s1: str, s2: str) -> bool:
+    """
+    Renvoie True si s1 et s2 sont anagrammatiques, False sinon.
+
+    Précondition: aucune
+
+    Exemples:
+
+    $$$ sont_anagrammes4('orange', 'organe')
+    True
+    $$$ sont_anagrammes4('orange','Organe')
+    True
+    """
+    
+    occurrence_s1={}
+    occurrence_s2={}
+    for c in s1:
+        mini=c.lower()
+        
+        occurrence_s1[mini]=occurrence_s1.get(mini)
+    for c in s2:
+        mini=c.lower()
+        occurrence_s2[mini]=occurrence_s2.get(mini)
+        
+    return occurrence_s1==occurrence_s2
+            
+from lexique import LEXIQUE
+#1.len(LEXIQUE)= 139719
+#2. set(LEXIQUE)=5001
+
+def anagrammes_v1(mot: str) -> list[str]:
+    """
+    Renvoie la liste des mots figurant dans le LEXIQUE qui sont des anagrammes de mot.
+
+    Précondition: aucune
+
+    Exemples:
+
+    $$$ anagrammes_v1('orange')
+    ['onagre', 'orange', 'orangé', 'organe', 'rongea']
+    $$$ anagrammes_v1('info')
+    ['foin']
+    $$$ anagrammes_v1('Calbuth')
+    []
+    """
+    liste=[]
+    for elt in LEXIQUE:
+        if sont_anagrammes(mot,elt):
+            liste.append(elt)
+    return liste
+            
+#Anagrammes d'un mot:seconde méthode
+#Il y a beaucoup de clés à créer, et la recherche d'un mot spécifique pour trouver la liste de ses anagrammes implique de connaître toutes les clées. 
+
+def cle(mot:str)->str:
+    """ Fonction qui calcule la clé que doit avoir un mot donné dans le dictionnaire
+
+    Précondition : 
+    Exemple(s) :
+    $$$ cle('Orangé')
+    'aegnor'
+
+
+    """
+    correspond={'é': 'e', 'è': 'e', 'ê': 'e', 'à': 'a', 'â': 'a', 'î': 'i', 'ô': 'o', 'û': 'u'}
+    mot_accent = ''.join(correspond.get(car,car) for car in mot.lower())
+    mot_trie = ''.join(sorted(list(mot_accent)))
+    return mot_trie
+    
+    
+def ANAGRAMMES(lexique:list[str])->dict:
+    """Construisez le dictionnaire des anagrammes, dont chaque association a pour clé la clé d'un mot du lexique, et pour valeur la liste des anagrammes
+
+    Précondition : 
+    Exemple(s) :
+    
+
+    """
+    dictionnaire={}
+    for mot_lexique in lexique:
+        anagramme=cle(mot_lexique)
+        if anagramme not in dictionnaire:
+            dictionnaire[anagramme]=[]
+        dictionnaire[anagramme].append(mot_lexique)
+    print(dictionnaire)
+    
+    
+

TP1/lexique.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`lexique` module
+
+:author: FIL - IEEA - Univ. Lille1.fr <http://portail.fil.univ-lille1.fr>_
+
+:date: janvier 2015
+:last revision: février 2017
+
+"""
+
+with  open('lexique.txt', 'r', encoding='utf8') as f:
+    mots = f.readlines()
+
+
+# mise en minuscules et
+# suppression du marqueur de fin de ligne pour chacun des mots
+LEXIQUE = [m.lower().rstrip('\n') for m in mots]
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

TP2/ap_decorators.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:module: ap_decorators  
+:author: FIL - Faculté des Sciences et Technologies -  Univ. Lille <http://portail.fil.univ-lille1.fr>_
+:date: 2018, september
+
+"""
+
+from functools import wraps
+
+
+def trace(fct):
+    '''
+    Decorator for tracing every call to fct.
+    Recursive calls are indented.
+
+    :Example:
+
+    >>> @trace
+    ... def fact(n):
+    ...     if n == 0:
+    ...         return 1
+    ...     else:
+    ...         return n * fact(n - 1)
+    
+    >>> fact(5)
+     -> fact((5,), {})
+    ... -> fact((4,), {})
+    ...... -> fact((3,), {})
+    ......... -> fact((2,), {})
+    ............ -> fact((1,), {})
+    ............... -> fact((0,), {})
+    ............... <- 1
+    ............ <- 1
+    ......... <- 2
+    ...... <- 6
+    ... <- 24
+    <- 120
+    120
+    '''
+    @wraps(fct)
+    def wrapper(*args, **kwargs):
+        dots = '...' * wrapper.__depth
+        print('{:s} -> {:s}{:s}'.format(dots, wrapper.__name__, repr((args, kwargs))))
+        wrapper.__depth += 1
+        y = fct(*args, **kwargs)
+        wrapper.__depth -= 1
+        print('{:s} <- {:s}'.format(dots, repr(y)))
+        return y
+    wrapper.__depth = 0
+    return wrapper
+
+def count(fct):
+    '''
+    decorator for counting  calls to  function fct
+    
+    :Example:
+
+    >>> @count
+    ... def fact(n):
+    ...     if n == 0:
+    ...         return 1
+    ...     else:
+    ...         return n * fact(n - 1)
+    
+    >>> fact.counter
+    0
+    >>> fact(5)
+    120
+    >>> fact.counter
+    6
+    '''
+    @wraps(fct) 
+    def wrapper(*args, **kwargs):
+        y = fct(*args, **kwargs)
+        wrapper.counter += 1
+        return y
+    wrapper.counter = 0
+    return wrapper
+
+
+def memoize(fct):
+    '''
+    decorator for memoizing computed values of  function fct
+    
+    :Example:
+
+    >>> @count
+    ... @memoize
+    ... def fact(n):
+    ...     if n == 0:
+    ...         return 1
+    ...     else:
+    ...         return n * fact(n - 1)
+    
+    >>> fact.counter
+    0
+    >>> fact(5)
+    120
+    >>> fact.counter
+    6
+    >>> fact.counter = 0
+    >>> fact(5)
+    120
+    >>> fact.counter
+    1
+    '''
+    cache = dict()
+    @wraps(fct)
+    def wrapper(*args, **kwargs):
+        key = repr((args, kwargs))
+        if key in cache:
+            return cache[key]
+        else:
+            y = fct(*args, **kwargs)
+            cache[key] = y
+            return y
+    return wrapper
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS, verbose=False)
+    
+    
+
+
+
+
+
+
+

TP2/recursivite.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# Noms : TANOH
+# Prenoms : M'BAH ANGE PASCAL
+# Groupe :MI 15
+# Date :24/01/2024
+
+
+
+"""
+
+:mod: module `recursivite`
+:author: FIL - Faculté des Sciences et Technologies - Univ. Lille
+:link: <http://portail.fil.univ-lille1.fr>_
+:date: Mars 2020
+:dernière révision: janvier 2024
+
+"""
+
+from ap_decorators import count, trace
+# l'instruction suivante permet d'annoter des paramètres qui sont des functions.
+from collections.abc import Callable
+
+
+def taille_binaire(naturel: int) -> int:
+    """
+    Renvoie le nombre de chiffres dans l'écriture binaire de l'entier naturel `naturel`
+
+    Précondition :
+       naturel >= 0
+
+    Exemples :
+    $$$ taille_binaire(0)
+    1
+    $$$ taille_binaire(1)
+    1
+    $$$ taille_binaire(2)
+    2
+    $$$ taille_binaire(1023)
+    10
+    $$$ taille_binaire(1024)
+    11
+    $$$ from random import randrange
+    $$$ l = [randrange(1,2**100)  for _ in range(100)]
+    $$$ all(taille_binaire(elt) == len(bin(elt))-2  for elt in l)
+    True
+    
+    """
+    res = 1
+    while naturel >= 2:
+        res += 1
+        naturel //= 2
+    return res
+
+def taille_binaire_recursive(naturel: int) -> int:
+    """
+    Renvoie le nombre de chiffres dans l'écriture binaire de l'entier naturel `naturel`
+
+    Précondition :
+       naturel >= 0
+
+    Exemples :
+    $$$ taille_binaire_recursive(0)
+    1
+    $$$ taille_binaire_recursive(1)
+    1
+    $$$ taille_binaire_recursive(2)
+    2
+    $$$ taille_binaire_recursive(1023)
+    10
+    $$$ taille_binaire_recursive(1024)
+    11
+    $$$ from random import randrange
+    $$$ l = [randrange(1,2**100)  for _ in range(100)]
+    $$$ all(taille_binaire_recursive(elt) == len(bin(elt))-2  for elt in l)
+    True
+    """
+    if naturel<2:
+        return 1
+    else:
+        return 1 + taille_binaire_recursive(naturel//2)
+
+def poids_binaire(naturel: int) -> int:
+    """
+    Renvoie le nombre de chiffre 1 dans l'écriture binaire de l'entier naturel `naturel`
+
+    Précondition :
+       naturel >= 0
+
+    Exxemples :
+
+    $$$ poids_binaire(0)
+    0
+    $$$ poids_binaire(1)
+    1
+    $$$ poids_binaire(2)
+    1
+    $$$ poids_binaire(255)
+    8
+    $$$ from random import randrange
+    $$$ l = [randrange(1,2**100)  for _ in range(100)]
+    $$$ all([poids_binaire(x)==bin(x).count('1') for x in l])
+    True
+    """
+    res = naturel % 2
+    while naturel > 0:
+        naturel //= 2
+        res += naturel % 2
+    return res
+
+#@trace
+def poids_binaire_recursif(naturel: int) -> int:
+    """
+    Renvoie le nombre de chiffre 1 dans l'écriture binaire de l'entier naturel `naturel`
+
+    Précondition :
+       naturel >= 0
+
+    Exxemples :
+
+    $$$ poids_binaire_recursif(0)
+    0
+    $$$ poids_binaire_recursif(1)
+    1
+    $$$ poids_binaire_recursif(2)
+    1
+    $$$ poids_binaire_recursif(255)
+    8
+    $$$ from random import randrange
+    $$$ l = [randrange(1, 2**100)  for _ in range(100)]
+    $$$ all([poids_binaire_recursif(x)==bin(x).count('1') for x in l])
+    True
+    """
+    if naturel == 0:
+        return 0
+    elif naturel < 3:
+        return 1
+    else:
+        return naturel % 2 + poids_binaire_recursif(naturel//2)
+
+def puissance(x: int|float, n: int) -> int|float:
+    """
+    Calcule x élevé à la puissance n
+
+    Précondition :
+        n>=0
+
+    Exemples :
+
+    $$$ puissance(10, 0)
+    1
+    $$$ puissance(10, 1)
+    10
+    $$$ puissance(2, 10)
+    1024
+    """
+    if n==0 :
+        return 1
+    else:
+        return x * puissance(x,n-1)
+
+def puissance_v2(x: int|float, n: int) -> int|float:
+    """
+    calcule  x élevé à la puissance n
+
+    Précondition :   n>=0
+
+    Exemples :
+    $$$ puissance_v2(10,0)
+    1
+    $$$ puissance_v2(10,1)
+    10
+    $$$ puissance_v2(2,10)
+    1024
+    """
+    if n==0 :
+        return 1
+    else:
+        return fois(x, puissance_v2(x,n-1))
+
+@count
+def fois(x: int|float, y: int|float) -> int|float:
+    """
+    renvoie le produit de x par y
+
+    Précondition : les mêmes que l'opérateur *
+
+    Exemples :
+    $$$ fois(8, 7)
+    56
+    """
+    return x * y
+
+def comptage(puissance: Callable[[int|float, int], int|float]) -> list[int]:
+    """
+    Renvoie une liste de longueur 100 contenant le nombre de multiplications
+    effectuées par la fonction ``puissance`` passée en paramètre
+
+    Précondition :
+       la fonction doit être implantée en utilisant la fonction ``fois``
+    """
+    res = []
+    for i in range(100):
+        fois.counter = 0
+        _ = puissance(2, i)
+        res.append(fois.counter)
+    return res
+
+#@trace
+def puissance_calbuth(x: int|float, n: int) -> int|float:
+    """
+    calcule  x élevé à la puissance n
+
+    Précondition :
+        n>=0
+
+    Exemples :
+
+    $$$ puissance_calbuth(10,0)
+    1
+    $$$ puissance_calbuth(10,1)
+    10
+    $$$ puissance_calbuth(2,10)
+    1024
+
+    """
+    if n == 0:
+        return 1
+    if n == 1:
+        return x
+    else:
+        k = n // 2
+        return puissance_calbuth(x, k) * puissance_calbuth(x, n - k)
+
+def puissance_calbuth_v2(x: int|float, n: int) -> int|float:
+    """
+    calcule  x élevé à la puissance n
+
+    Précondition :
+        n>=0
+
+    Exemples :
+
+    $$$ puissance_calbuth_v2(10,0)
+    1
+    $$$ puissance_calbuth_v2(10,1)
+    10
+    $$$ puissance_calbuth_v2(2,10)
+    1024
+
+    """
+    if n == 0:
+        return 1
+    if n == 1:
+        return x
+    else:
+        k = n // 2
+        return fois(puissance_calbuth(x, k), puissance_calbuth(x, n - k))
+
+
+
+
+def puissance_calbuth_v2_amelioree(x: int|float, n: int) -> int|float:
+    """
+    calcule  x élevé à la puissance n
+
+    Précondition :
+        n>=0
+
+    Exemples :
+
+    $$$ puissance_calbuth_v2_amelioree(10,0)
+    1
+    $$$ puissance_calbuth_v2_amelioree(10,1)
+    10
+    $$$ puissance_calbuth_v2_amelioree(2,10)
+    1024
+
+    """
+    ...
+
+def puissance_erronee(x: int|float, n: int) -> int|float:
+    """
+    aurait dû calculer  x élevé à la puissance n
+
+    Précondition :
+       n >= 0
+
+    Exemples :
+
+    $$$ puissance_erronee(10, 0)
+    1
+    $$$ puissance_erronee(10, 1)
+    10
+    $$$ #$$$ puissance_erronee(2, 10)
+    $$$ #1024
+    """
+    if n == 0:
+        return 1
+    elif n == 1:
+        return x
+    else:
+        r = n % 2
+        q = n // 2
+        return puissance_erronee(x, r) * puissance_erronee(puissance_erronee(x, q), 2)
+
+def puissance_reparee(x: int|float, n: int) -> int|float:
+    """
+    calcule  x élevé à la puissance n
+
+    Précondition :
+        n>=0
+
+    Exemples :
+
+    $$$ puissance_reparee(10,0)
+    1
+    $$$ puissance_reparee(10,1)
+    10
+    $$$ puissance_reparee(2,10)
+    1024
+    """
+    ...
+

tp1/Tp1.py

+#METHODE SPLIT
+
+#1) ['la', 'méthode', 'split', 'est', 'parfois', 'bien', 'utile']
+# ['la m', 'thode split est parfois bien utile']
+# ['la méthod', ' split ', 'st parfois bi', 'n util', '']
+# ['la', 'méthode', 'split', 'est', 'parfois', 'bien', 'utile']
+# ['la méthode ', ' est parfois bien utile']
+# pour s.split('') il y'a une erreur.
+# 
+# 2) la methode split permet de decouper un caractere ou plusieurs chaines de caracteres en plusieurs elements en utilisant les separateurs.
+# 3) oui cette methode modifie la chaine a laquelle elle s'applique'
+
+
+# METHODE JOIN
+
+#1)
+#'laméthodesplitestparfoisbienutile'
+#'la méthode split est parfois bien utile'
+#'la;méthode;split;est;parfois;bien;utile'
+#'la tralala méthode tralala split tralala est tralala parfois tralala bien tralala utile'
+#la
+#méthode
+#split
+#est
+#parfois
+# bien
+# utile
+# 'la méthode split est parfois bien utile'
+# 'l!a! !m!é!t!h!o!d!e! !s!p!l!i!t! !e!s!t! !p!a!r!f!o!i!s! !b!i!e!n! !u!t!i!l!e'
+# pour "".join() il y'a une erreur
+# ''
+# pour "".join([1,2]) il y'a une erreur
+# 
+# 2) la fonction split permet de creer et renvoyer une nouvelle chaine de caractere en concatenant tous les elements d'un tableau
+# 3)non elle modifie par la chaine a laqulele elle s'applique
+
+# METHODE SORT
+# 1)
+# l=['e', 'i', 'l', 'm', 'n', 'o', 'o', 't']
+# l  est rangé : ['J', 'e', ' ', 'n', "'", 'a', 'i', ' ', 'j', 'a', 'm', 'a', 'i', 's', ' ', 'j', 'o', 'u', 'é', ' ', 'd', 'e', ' ', 'f', 'l', 'û', 't', 'e', '.']
+# 2) pour l = ['a', 1] on n'a une erreur car la fonction sort modidie uniquement soit une chaine de caractere uniquement dalsn la liste ou soit une liste d'entier uniquement mais elle renvoie unerreur lorsqu'on a une chaine de caractere et un entiers dans la meme liste 
+
+# UNE FONCTION sort POUR LES CHAINES
+
+def sort(s:str)-> str:
+    """Renvoie une chaîne de caractères contenant les caractères de `s` triés dans l'ordre croissant.
+
+    Précondition : aucune
+    Exemple(s) :
+    $$$ sort('timoleon')
+    'eilmnoot'
+
+    """
+    chaine =''
+    l=list(s)
+    l.sort()
+    for elt in range(len(l)):
+        chaine += l[elt]
+    return chaine
+    
+        
+
+    
+
+
+