README.md

 # INF-TC1
 
+## Installation
+
+* La distribution Anaconda offre cet avantage en étant multi-plateformes (Windows, Mac, Linux) et disposant de tous les outils dont vous aurez besoin en Informatique au cours du semestre (interpréteur Python, éditeur Spyder, divers modules). Vous obtiendrez la dernière version sur ce site : https://www.anaconda.com/download/
+
+* Nous vous demandons donc de l’installer sur vos ordinateurs et de vérifier son fonctionnement (l’exécution d’un code simple devrait suffire) avant votre première séance de TD.
+
+* Concerant l'éditeur de code Python, vous pouvez utiliser Spyder inclu dans Anaconda, mais vous pouvez aussi télécharger et installer Microsoft Code qui est une excellente alternative : https://code.visualstudio.com/download
+
+
+## Aides en informatique
+
+* Des [transparents d'aide](aide-informatique.pdf)
+* Une vidéo de présentation de ces transparents https://replay.ec-lyon.fr/video/0920-aides-en-informatique/ 
+
+## Livres
+
+Les livres suivants sont disponibles sous forme de pdf et couvrent les points abordés en cours et en TD :
+
+- [Think Python](books/thinkpython2.pdf), 2nd edition, par Allen B. Downey
+- [Python for Everybody](books/pythonlearn.pdf), par Charles Severance
+- [Problem Solving with Algorithms and Data Structures using Python](books/problemsolving.pdf), par Brad Miller et David Ranum
+- [ODS Pyhon](books/ods-python.pdf), par Pat Morin ([url](https://opendatastructures.org/ods-python/))
+
+Autres ressources :
+
+- https://en.wikibooks.org/wiki/Algorithms/
+- [computer science books](https://freecomputerbooks.com/compscAlgorithmBooks.html)
\ No newline at end of file

TD01/code/08-conversion_exercices.py

-# 8 Conversion de types
-
-# Exercice
-
-# Écrire la fonction convertir(S) qui convertit son paramètre (un string) 
-# en un entier. Pour que la conversion soit possible, le paramètre S doit 
-# être être composé de chiffres éventuellement précédé d'un signe.
-
-def convertir(S) : # S est une liste de caractères
-
-    # Il y a un signe au début ou pas ?
-    signe= +1                                         # Initialisation du signe
-    if S[0:1] in '+-':
-        if S[0:1]=='-' : signe=-1
-        S = S[1:]                                        # On enlève le signe
-
-    if S.isdigit(): return int(S) * signe             # On peut aussi écrire : str.isdigit(xs) !
-    else: return (S + " n'est pas un nombre")
-
-S=input('Donner  une chaine de chiffres: ')
-print(convertir(S))
-
-# Donner  une chaine de chiffres: -124
-# -124
-# Donner  une chaine de chiffres: 12a
-
-#  Une version qui n'utilise ni int() ni isdigit()
-def convertir02(S1) :       # S est une liste de caractères
-    assert(S1 != '' and S1 != None)
-    signe= +1                                       # Initialisation du signe
-    val = 0; S=S1
-    if S[0] in '+-':
-        if S[0:1]=='-' : signe=-1
-        S = S[1:]
-    for car in S :
-        if car in "0123456789": val = 10*val+ord(car)-ord('0')
-        else : return (S1 + " n'est pas un nombre")
-    return val * signe             # On peut aussi écrire : str.isdigit(xs) !
-
-S=input('Donner  une chaine de chiffres : ')
-print(convertir02(S))
-
-# Exercice
-# Écrire la fonction {\tt convertir2r(S)} qui convertit son paramètre (un 
-# string) en un réel (loat). Pour que la conversion soit possible, le
-# paramètre {\it S} doit être être éventuellement précédé d'un signe, puis 
-# composé de chiffres suivis d'un '.' puis une série de chiffres. La
-# présence d'un '.' est obligatoire, et qui est forcément suivi d'au moins
-# un chiffre.
-
-def convertir2r(S) :                       # S est une liste de caractères
-    assert('.' in S)                        # '.' obligatoire
-    lst_2_parties=S.split('.')              # une liste des 2 parties
-    val_int=0
-    if lst_2_parties[0] != '' : val_int=convertir02(lst_2_parties[0])
-        
-    # vérifier que la partie décimale ne comporte  pas un second signe !
-    assert(lst_2_parties[1][0] not in '+-')
-
-    val_reel=0
-    if lst_2_parties[1] != '' : val_reel=convertir02(lst_2_parties[1])
-
-    # La partie décimale s'ajoute ou se retrache suivant le signe de val_int'
-    if val_int >= 0 :
-        return val_int + val_reel/(10**len(lst_2_parties[1]))
-    else : return val_int - val_reel/(10**len(lst_2_parties[1]))
-
-
-S=input('Donner  une chaine de chiffres (un réel) : ')
-print(convertir2r(S))
-convertir2r('12.34')
-convertir2r('0.12')
-convertir2r('13.0')
-convertir2r('-3.001')
\ No newline at end of file

TD01/code/addition.py

-def addition(a, b):
-    return a + b
-
-def addition_inf(*argv):
-    res = 0
-    for arg in argv:  
-        res += arg
-    return res
-
-if __name__=="__main__": 
-    assert addition(1, 2) == 3
-    assert not addition(1, 2) == 2
-
-    assert addition_inf(1, 1, 1) == 3
-    assert not addition_inf(1, 1, 1) == 2
-
-    assert addition_inf(1, 1, 1) == addition(1, 2)
\ No newline at end of file

TD01/code/chaines-valide.py

-def valide(seq):
-    """Retourne True si séquence ADN."""
-    ret = len(seq) != 0
-    for c in seq:
-        ret = (ret and True) if (c in "atgc") else False
-    return ret
-
-if __name__=="__main__": 
-    assert valide("atgc")
-    assert not valide("atgcz")

TD01/code/commentaires.py

-# Un commentaire court commence par un # et se limite à la fin de la ligne
-
-"""
-On peut aussi créer un commentaire long = une zone de 
-commentaires  sur plusieurs lignes placées
-entre une paire de triple-guillements dont le second suit :
-"""
-
-# Remarques : 
-# Un ';' à la fin d'une ligne rend la ligne muette (pas d'affichage des résultats). 
-# Il permet également de placer plusieurs expressions sur la même ligne.
-
-# Si vous placez un commentaire immédiatement après la signature d'une fonction} 
-# (ou une méthode, une classe, etc.) entre un couple de  """, 
-# votre commentaire (appelé docstring) devient accessible avec help
\ No newline at end of file

TD01/code/fibo-comp.py

-def fibo1(f2, f1, i):
-    if i > 0:
-        return fibo1(f1, f2+f1, i-1)
-    else:
-        return f2
-
-
-def fibo2(f2, f1, i):
-    while i > 0:
-        f2, f1, i = f1, f2+f1, i-1
-    return f2
-
-print(fibo1(6))
-print(fibo2(6))
\ No newline at end of file

TD01/code/fibo-mem.py

-def fib(n, lookup): 
-  
-    # Cas d'arrêt
-    if n == 0 or n == 1 : 
-        lookup[n] = n 
-  
-    # On calcule la valeur si pas déjà calculée
-    if lookup[n] is None: 
-        lookup[n] = fib(n-1 , lookup)  + fib(n-2 , lookup)  
-  
-    # On renvoie la n-eme valeur
-    return lookup[n] 
-  
-def main(): 
-    n = 6 
-    max = 100
-    # Initialise la table de cache
-    lookup = [None]*(max)
-    print("Le nombre de fibonacci est ", fib(n, lookup))
-    # Le nombre de fibonacci est  8
-
-if __name__=="__main__": 
-    main() 
\ No newline at end of file

TD01/code/file.py

-class File():
-    def __init__(self, values = []):
-        self.__values = []
-        for v in values:
-            self.ajoute(v)
-
-    def ajoute(self, v):
-        self.__values.append(v)
-        return v
-
-    def supprime(self):
-        v = self.__values.pop(0)
-        return v
-
-    def renvoie(self, critere = lambda x : True):
-        for v in self.__values:
-            if critere(v):
-                return v
-        return False
-
-    def affiche(self):
-        for v in self.__values:
-            print(v)
-
-    def taille(self): 
-        return len(self.__values)
-
-if __name__ == "__main__":
-    f = File()
-    for d in [1, 2, 3]:
-        f.ajoute(d)

TD01/code/graphe-sim.py

-# Par exemple pour Fool et Sage vous devez renvoyez le résultat suivant :
-# 
-# FOOL
-# POOL
-# POLL
-# POLE
-# PALE
-# SALE
-# SAGE
-# 
-# SOLUTION:
-
-graph = {'A': ['B', 'C'],
-  'B': ['C', 'D'],
-  'C': ['D'],
-  'D': ['C'],
-  'E': ['F'],
-  'F': ['C']
-}
-
-class Graphe(dict):
-    def __init__(self, liens, noeuds):
-        for v in liens:
-            self[v] = set()
-        for e in noeuds:
-            self.ajout_noeud(e)
-
-    def ajout_lien(self, lien):
-        self[lien[0]].add(lien[1])
-        self[lien[1]].add(lien[0])
-
-    def ajout_noeud(self, noeud):
-        self[noeud] = set()
-
-def simGraphe(mots):
-    d = {}
-    g = Graphe(mots, [])
-
-    for mot in mots:
-        for i in range(len(mot)):
-            groupe = mot[:i] + '_' + mot[i+1:]
-            if groupe in d:
-                d[groupe].append(mot)
-            else:
-                d[groupe] = [mot]
-
-    for groupe in d.keys():
-        for mot1 in d[groupe]:
-            for mot2 in d[groupe]:
-                if mot1 != mot2:
-                    g.ajout_lien([mot1, mot2])
-    return g
-
-def chemin(graphe, source, destination, visite=None):
-
-    if source == destination:
-        return [destination]
-    else:
-        visite = visite or set()
-        for s in graphe[source]:
-                if s not in visite:
-                    visite.add(s)
-                    print("trace:", source + " > " + s)
-                    sous_chemin = chemin(graphe, s, destination, visite)
-                    if sous_chemin is not None:
-                        return [source] + sous_chemin
-
-print(chemin(simGraphe(["AA", "AB", "BC", "AC", "DD"]), "AA", "BC"))
-
-# ['AA', 'AB', 'AC', 'BC']
\ No newline at end of file

TD01/code/graphe_dico.py

-G = {
-    'A' : ['B','C', 'F'],
-    'B' : ['D', 'E'],
-    'C' : ['F'],
-    'D' : ['G'],
-    'E' : ['F'],
-    'F' : ['G', 'H'],
-    'G' : ['H'],
-    'H' : []
-}
-
-v = set()
-
-def traitement(v, G, n):
-    if n not in v:
-        v.add(n)
-        print(n)
-        for m in G[n]:
-            traitement(v, G, m)
-
-if __name__ == '__main__':
-    traitement(v, G, 'A')
-
-    if len(v) > 0:
-        print("Que se passe-t-il ?")

TD01/code/liste-liee.py

-class Node:
-    def __init__(self, data = None, next = None):
-        self.data = data
-        self.next = next
-
-class LinkedList:
-    def __init__(self):
-        self.head = None
-
-    def listprint(self):
-        printval = self.head
-        while printval is not None:
-            print(printval.dataval)
-            printval = printval.nextval
-    
-    def push(self, n):
-        if self.head is None:
-            self.head = Node(n)
-        else:
-            node = self.head
-            while node.next is not None:
-                node = node.next
-            node.next = Node(n)
-
-    def detectLoop(self):
-        s = set() 
-        temp = self.head 
-        while (temp):
-            if (temp in s): 
-                return True
-            s.add(temp) 
-            temp = temp.next
-        return False
\ No newline at end of file

TD01/code/listes-liee-boucle.py

-from liste_liee import *
-
-ll = liste_liee() # Ajout de données
-ll.push(20) 
-ll.push(4) 
-ll.push(15) 
-ll.push(10)
-   
-# Création d'une boucle
-ll.head.next.next.next.next = ll.head; 
-  
-if( ll.detectLoop()): 
-    print ("Il y a une boucle !") 
-else : 
-    print ("Pas de boucle ! ") 
\ No newline at end of file

TD01/code/moyenne.py

-# Calcul de la moyenne de deux entiers  
-
-a=input('Donner la valeur de a : ')
-b=input('Donner la valeur de b : ')
-print('la moyenne = ', (int(a) + int(b))/2)  # int(a) : conversion de 'a' en entier
-
-# Une seconde méthode : on convertit en lisant les valeurs en int
-a=int(input('Donner la valeur de a : '))
-b=int(input('Donner la valeur de b : '))
-print('la moyenne = ', (a+b)/2) 

TD01/code/parite.py

-def parite(a):
-    """ Lire un entier au clavier et décider (et afficher) s'il est pair ou impair. """
-    if (a%2 == 1):
-        print(a, " est impair")
-    else :
-        print(a, " est pair")
-
-if __name__=="__main__": 
-
-    while True:
-        try:
-            a = int(input('Donner un entier  positif : '))
-            parite(a)
-            break
-        except ValueError:
-            print("Ce n'est pas un nombre valide.. ré-essayer !")
-   
-    
\ No newline at end of file

TD01/code/pile.py

-class Pile():
-    def __init__(self, values = []):
-        self.__values = []
-        for v in values:
-            self.ajoute(v)
-
-    def ajoute(self, v):
-        self.__values.append(v)
-        return v
-
-    def supprime(self):
-        v = self.__values.pop()
-        return v
-
-    def affiche(self):
-        for v in self.__values:
-            print(v)
-
-    def taille(self): 
-        return len(self.__values)
-
-if __name__ == "__main__":
-    p = Pile()
-    for d in [1, 2, 3]:
-        p.ajoute(d)

TD01/code/racines.py

-from math import sqrt;
-
-def trinome(a, b, c):
-    """ Résolution équation quadratique """
-    delta = b**2 - 4*a*c
-    if delta > 0.0:
-        assert(a != 0)      
-        racine_delta = sqrt(delta)
-        return (2, (-b-racine_delta)/(2*a), (-b+racine_delta)/(2*a))
-    elif delta < 0.0: return (0,)
-    else: 
-        assert(a != 0)     
-        return (1, (-b/(2*a)))
-    
-if __name__ == "__main__":
-    print(trinome(1.0, -3.0, 2.0))
-    print(trinome(1.0, -2.0, 1.0))
-    print(trinome(1.0, 1.0, 1.0))  
\ No newline at end of file

TD01/code/recherche-dico.py

-def recherche(element, liste):
-    a = 0
-    b = len(liste)-1
-
-    while a < b :
-        m = (a+b) //2
-        if liste[m] == element :
-            return m
-        elif liste[m] > element :
-            b = m-1
-        else :
-            a = m+1
-
-    return a
-
-print (recherche(3, [3, 1, 4, 2, 3]))

TD01/code/tas.py

-class Tas():
-    def __init__(self):
-        self.__values = []
-
-    def push(self, value):
-        self.__values.append(value)
-
-    def peek(self, i): # pop sans suppression
-        return self.__values[i], i
-        
-    def fg(self, i):
-        left_i = 2 * i + 1
-        if left_i > len(self.__values):
-            return None, left_i
-        else:
-            return self.__values[left_i], left_i
-
-    def fd(self, i):
-        droite_i = 2 * i + 2
-        if droite_i > len(self.__values):
-            return None, droite_i
-        else:
-            return self.__values[droite_i], droite_i
-
-    def parent(self, i):
-        return self.__values[(i - 1) // 2]
-
-    def afficher(self):
-        return ' '.join(str(v) for v in self.__values)
-
-    def inserer(self, value):
-        self.push(value)
-        i = len(self.__values) - 1
-        while (i + 1) // 2 > 0:
-            if self.__values[i] < self.parent(i):
-                tmp = self.__values[i // 2]
-                self.__values[i // 2] = self.__values[i]
-                self.__values[i] = tmp
-            i = i // 2
-        
-    def supprimer(self, i):
-
-        v = self.__values.pop(i)
-        max_i = i
-        n = len(self.__values) - 1
-
-        while self.__values[i] > self.fg(i)[0] or self.__values[i] > self.fd(i)[0]:
-
-            max = self.__values[i]
-            
-            if i < n and max > self.fg(i)[0]:
-                max_i = 2 * i + 1
-
-            if i < n and max > self.fd(i)[0]:
-                max_i = 2 * i + 2
-
-            if max_i != i: 
-                self.__values[i], self.__values[max_i] = self.__values[max_i], self.__values[i]
-
-            i = max_i
-
-        return v
\ No newline at end of file