INFO Entraînement d'algo. mercredi 9 avril 2014

                   Entraînement  d'algo.  BTS1      9 avril 2014  et  le 1 avril 2015 

   • Travail sur papier. ( 30 minutes )

        Lire le programme suivant en Python 2.7.

        Puis répondre aux questions.

from random import*

from decimal import*

def Test(L):

      Q=[]
      for i in range(0,N-1):
           Q.append(round((L[i+1]/L[i]),2))
      return Q

####### PROGRAMME PRINCIPAL###
            ########################
L=input("Entrer une liste: L= ")
N=len(L)
print "La liste Q est :" , Test(L)

             QUESTIONS:

   1. Le fait de mettre 

        L=input("Entrer une liste: L= ")

        au même alignement que def

        présente quel intérêt ?

         Cela permet de lancer le programme tout suite dans la fenêtre Python shell

         en demandant la saisie de la liste L.

   2. A quoi sert le round( .... , 2  )  ?

       round((L[i+1]/L[i]),2))  

       permet d'avoir avec deux décimales si nécessaire 

       pour la valeur du quotient L[i+1] / L[i])  .

    3. Que signifie N=len(L) ?

        N est la longueur de la liste L   c-à-d  le nombre d'éléments de L

    4. Que signifie Q=[] ?

       Cela veut dire que Q est une liste vide.

    5. Que peut-on dire de l'entier i quand on a:

           for i in range (N − 1):  ?

       Cela signifie que i prend les valeurs entières de 0 comprise à N− 1 non comprise.

     6. Que donne 6./7. ?

         0.0857143

          Le point fait que l'on obtient un nombre sous forme décimale.

          On obtiendrait la même chose avec 6 /7.  ou  6./7

     7. Qu'obtient-on avec ce programme ?

          Tester le programme pour L=[2,4,8,16].

        Il donne:

>>>
Entrer une liste: L= [2,4,8,16]
La liste Q est : [2.0, 2.0, 2.0]
>>>

       On a les quotients des termes consécutifs décimaux de la liste L 

           c'est-à-dire de   4/ 2  ,  8/ 4  ,  16 / 8

   8. Modifier le programme de façon à obtenir également la liste 

      des différences successives de deux termes consécutifs de L.

             On peut considérer par exemple considérer:

from decimal import*
def Test(L):
      Q=[]
      R=[]
      for i in range(0,N-1):
           Q.append(round((L[i+1]/L[i]),2))
           R.append(round((L[i+1]− L[i]),2))
     print "La liste Q est : " ,Q
     print "La liste R est :" , R
####### PROGRAMME PRINCIPAL###
########################
L=input("Entrer une liste: L= ")
N=len(L)
print Test(L)

    On obtient par exemple:

>>>
Entrer une liste: L= [2,4,8,16]
La liste Q est : [2.0, 2.0, 2.0]
La liste R est : [2.0, 4.0, 8.0]
None
>>>

       9.Soit L  la liste des premiers termes d'une suite.

         Quel serait l'intérêt d'un tel programme?

          Cela permettrait de conjecturer que la suite est géométrique ou arithmétique.

          Ce permettrait de nier le fait qu'elle soit géométrique ou  arithmétique.

-------------------------------------------------------------------------------------------------

     • Travail sur ordinateur. ( 30 minutes )

      1. Ecrire un programme en Python 2.7 , qui , quand l'utilisateur entre

         l'entier naturel n, donne le terme d'indice n de la suite ( un ) telle que :

                     u0 = 1

                     u1 = 1

                     un + 2 =   un + un + 1     pour tout n dans IN

                  On peut proposer:

from random import*
def fib(n):
      if n==0 or n==1:
           return 1
     else:
           return fib(n−1)+fib(n−2)
####### PROGRAMME PRINCIPAL ###
          ########################
n=input("Entrer un entier naturel")
print "Le terme d'indice" , n,"est égal à",fib(n)

 

                     On obtient par exemple:

>>>
Entrer un entier naturel  6
Le terme d'indice 6 est égal à 13
>>>

      2. Modifier le programme pour avoir la liste L des cinq premiers termes

          de la suite ( un ).

                  On peut proposer:

from random import*
def fib(n):
      if n==0 or n==1:
           return 1
      else:
            return fib(n−1)+fib(n−2)
def termes():
      L=[]
      for n in range(5):
            L.append(fib(n))
      print "La liste des 5 premiers termes est",L

              On obtient :

>>> termes()
La liste des 5 premiers termes est [1, 1, 2, 3, 5]
>>>

       3. Modifier cet algorithme à l'aide du premier travail, pour pouvoir dire si la suite 

          semble particulière.

                      On peut proposer:

from random import*
def fib(n):
      if n==0 or n==1:
           return 1
      else:
            return fib(n−1)+fib(n−2)
def termes():
      L=[]
      for n in range(5):
           L.append(fib(n))
      print "La liste des 5 premiers termes est",L
      Q=[]
      R=[]
      for i in range(0,len(L) − 1):
           Q.append(round((L[i+1] / L[i]),2))
           R.append(round((L[i+1] − L[i]),2))
      print Q
      print R

                On obtient:

>>> termes()
La liste des 5 premiers termes est [1, 1, 2, 3, 5]
[1.0, 2.0, 1.0, 1.0]
[0.0, 1.0, 1.0, 2.0]
>>>

----------------------------------------------------------