DS. 1 : I.P.T solutions 1) Faire un programme qui calcule la somme des entiers multiples de entre 1 et 140. # Méthode 1 for i in range(1,141): if i%==0: S=S+i # Méthode 2 for i in range(1,141//): S=S+*i # Méthode for i in range(,141,): # on indique le pas dans le troisième argument S=S+i 2) Ecrire une boucle qui répète l instruction a=input( Dis moi bonjour ) tant que l utilisateur ne répond pas bonjour. a=0 while a!="bonjour": a=input("dis moi bonjour ") ) Soit T=(1,2,,4). a) Que donne print(t[1:])? Réponse : (2,, 4) b) Que donne type(t)? Réponse : <class tuple > c) Que donne T[1]=0? Réponse : TypeError: tuple object does not support item assignment La modification d une entrée (item assignment) n est pas possible pour les tuples. d) Que fait L=list(T)? Réponse : Cette commande crée une liste L avec la valeur [1, 2,, 4]. e) Que donne L[1:]=[0] suivi de print(l)? Réponse : [1, 0, 4]. En effet, la commande L[1:]=[0] remplace la tranche [L[1],L[2]] de L par [0] 4) Ecrire une fonction EE (pour enlève-espaces ) qui prend en argument une chaîne de caractères S et qui retourne une chaîne de caractères,qu on notera T dans le code, indique à S sauf qu on enlève tous les caractères espace c est-à-dire. def EE(S): T=""#ini for caractere in S: if caractere!=" ": T=T+caractere return T 5) Fabriquer, avec la méthode de votre choix, une liste L formée des cos(i) pour i 1, 100. Indication : on n oubliera pas d écrire la ligne de commande nécessaire pour pouvoir utiliser la fonction cosinus. Deux méthodes : (M1) 1
from math import cos L=[0]*100 # préformatage for i in range(0,100): L[i]=cos(i+1) # attention au décalage car # on veut cos(1),..., cos(100). # L est fabriquée (M2) plus simple ici : L=[] for i in range(1,101): L.append(cos(i)) 6) Que renvoie le code suivant? def fonction(n): for i in range(n): print(fonction(17)) Réponse :La fonction retourne la valeur 0. Car au premier tour de boucle pour i égal à 0, le return fait sortir de la fonction et donc de la boucle. Donc le print(fonction(17)) affichera 0. 7) a) Ecrire une fonction PremierNeg(L) qui prend en argument une liste L dont les entrées sont supposées être des nombres, et renvoie l indice de la première entrée négative strictement. Par exemple si L=[2,2,45,-4,12,-5], PremierNeg(L) renverra car L[] vaut -4 et est la première entrée négative de L. Si toute les entrées sont positives, la fonction renverra None. def PremierNeg(L): i=0 while i<len(l) and L[i]>=0: # l ordre des deux conditions compte # nous y reviendrons i=i+1 if i<len(l): else: return None Ou bien avec une boucle for plus simple, grâce au fait que le return fait sortir de la fonction : def PNeg(L): if L[i]<0: return None # en fait cette ligne est inutile # une fonction sans return retourne en fait un None b) Ecrire une fonction MaxNeg(L) qui prend en argument une liste L dont les entrées sont supposées être des nombres et renvoie la valeur maximum des entrées négatives de L. Si L n a pas d entrée négative, la fonction ne renverra rien. Par exemple si L=[-2,4,-12,5,-5], MaxNeg(L) renverra -2. def MaxNeg(L): depart=premierneg(l) if depart==none: return None# sortie de la fct 2
max=l[depart] for j in range(depart,len(l)): if L[j]<0 and L[j]>max: max=l[j] return max 8) Expliquer ce que fait le code suivant : l argument n de la fonction est supposé être un entier naturel def NB2(n): N=0 acc=1# accumulateur while acc<n: acc=acc*2 N=N+1 return N Au départ N et acc sont initialisés comme indiqué. Ensuite en numérotant les tours de boucle while, en appelant zéro le premier tour de boucle, au début de ce tour 0, acc a la valeur 1 et à la fin de ce tour 0, N=1 et acc=2. Par récurrence, on montre qu au tour numéro i, au début de ce tour acc vaut 2 i et en fin de boucle N prend la valeur i + 1 et acc vaut 2 i+1. Ainsi le dernier tour de boucle disons numéroté f, correspond au plus grand entier f tel que 2 f < n. Ainsi à la fin de ce tour N prend la valeur f + 1. Donc la fonction renvoie N qui est le plus petit entier tel que 2 N n. 9) Soit L=[2,21,45] a) Que donne le code suivant (justifier votre réponse) : M=L L[0]=12 print(m) Réponse :[12,21,45] Autrement dit M est modifié comme L. La raison est que la commande L[0]=12 est une modification de L pas une réaffectation du nom L. La liste L reste à la même adresse, qui est celle vers laquelle pointe le nom M. b) Soit L=[2,21,45] que donne le code suivant (justifier votre réponse) : M=L[:] L[2]=66 print(m) Réponse :[2,21,45]. La commande M=L[:] crée une liste M dans laquelle on met le contenu de L mais à une adresse mémoire différente. Ainsi la modification L[2]=66 n affecte pas M. 10) On considère la fonction ci-dessous, qui prend comme argument une liste L de nombres def mystere(l): n=len(l) L[i]=L[i]+1 On considère le code suivant : L=[1,2,] M=mystere(L) Après exécution de ce code, que vaut M et que vaut L? Réponse :La fonction mystère modifie la liste L qui lui est passée en argument car les commandes L[i]= sont des commandes de modification. En revanche, la fonction n a pas de return donc elle ne renvoie pas de valeur (elle renvoie un None). Donc après M=mystere(L), on aura : L=[2,,4] et M=None.
11) Ecrire une fonction ListeDecalee(L) qui prend en argument une liste L, qui ne modifie pas cette liste L mais qui retourne une liste dont les valeurs sont celles des entrées de L avec un décalage d indice de 1 et cela de manière cyclique, ce qui veut dire la chose suivante : si par exemple L=[a,b,c,d] alors on veut que la liste renvoyée soit [b,c,d,a]. def ListeDecalee(L): M=[] n=len(l) for i in range(1,n): M.append(L[i]) M.append(L[0]) return M Une version plus élégante (Baptiste) : def ListeDecalee(L): M=[] indice=(i+1)%len(l) M.append(L[indice]) return M Grâce aux spécificités pythonesques L[-1] étant la dernière entrée, encore une autre possibilité (Mathieu P.) : def LD(L): T=L[:] T[i-1]=L[i] # pour i=0 on aura T[-1]=L[0] return T 12) Question plus difficile et un peu vague : une première idée (qui ne marche pas telle quelle) serait de choisir à chaque étape l entrée la plus grosse parmi les deux choix possibles. Cela ne donne pas forcément une somme maximum comme on peut le voir dans l exemple suivant donné par Odile où le parcours en gras est celui qui suit le meilleur choix à chaque étape : 2 1 Ce parcours ne donne pas la somme maximum qui est obtenue en suivant la ligne 1 2 9 1 2 1 9 de droite + 1 + 9 + 9. une amélioration de cette idée, qui est un exemple du concept de programmation dynamique. Au triangle T donné, on va associer un nouveau triangle S de même format mais avec dans chaque case S[i][j] la valeur de la plus grande somme de tous les chemins partant de T[0][0] arrivant à la case T[i][j] dans le premier triangle T. Pour le triangle de l énoncé T qui était 7 4 2 4 6 8 5 9 ce nouveau triangle S sera : Ce triangle S se construit bien sûr ligne par ligne à partir du triangle T donné : def sommemax(t): S=[[T[0][0]]]# initialisation for ligne in T[1:]:# on commence à la deuxieme ligne largeur=len(ligne) S.append([0]*largeur) for i in range(largeur): if i==0: S[-1][i]=ligne[i]+S[-2][i] 10 7 12 14 1 20 19 2 16 4
elif i==largeur-1: S[-1][i]=ligne[i]+S[-2][i-1] else: # sinon on prend le max des deux parents S[-1][i]=ligne[i]+max(S[-2][i-1],S[-2][i]) # on renvoie le max de la derniere ligne return max(s[-1]) # exemple L=[[],[7,4],[2,4,6],[8,5,9,]] print(sommemax(l)) 5