DS. 1 : I.P.T solutions

Dimension: px

Commencer à balayer dès la page:

Download "DS. 1 : I.P.T solutions"

Clarisse Leduc
il y a 6 ans
Total affichages :

1 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

2 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

3 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.

4 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 de droite 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 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]

5 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

Documents pareils

Initiation à la programmation en Python

I-Conventions Initiation à la programmation en Python Nom : Prénom : Une commande Python sera écrite en caractère gras. Exemples : print 'Bonjour' max=input("nombre maximum autorisé :") Le résultat de