PYTHON.2 COURS D'ALGORITHMIQUE

 

                                Bases d’algorithmique             2nde  →   BTS1          janvier  2012
                                
                                       Polycopié                              
                                        PLAN 
1 .Vocabulaire.
           1.1 Définition d'un algorithme.
           1.2 Variable, affectation.
2. Structures importantes.
           2.1 Instruction conditionnelle .
           2.2 Boucle itérative.
           2.3 Boucle conditionnelle.
                                   Liste d'exemples  d'algorithmes
                        1 Image par une fonction .
                        2 Triangle rectangle en C
                        3 Image par une fonction en tenant compte

                           de l’ensemble de définition .
                        4 Jeu de Pile ou Face.
                        5 Table de multiplication .
                        6 Calcul d’une somme d’entiers .
                        7 Algorithme d’Euclide de calcul du PGCD.

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

                             Prévoir une activité simple en introduction.

               
 1 Vocabulaire
     1.1 Définition :

      Un algorithme est une suite finie d’opérations élémentaires,

      à appliquer dans un ordre déterminé,à des données.

      Sa réalisation permet de résoudre un problème donné.


     Exemples :

           Suivre un plan pour se rendre à un endroit, faire une division euclidienne

           à la main sont des exemples d’algorithme.


      Remarques : ( Quelques banalités..... )

 
         Un algorithme doit être lisible de tous.

         Son intérêt, c’est d’être codé dans un langage informatique
         afin qu’une machine (ordinateur, calculatrice, etc.)

         puisse l’exécuter rapidement et efficacement.
        Un algorithme comporte tois phases ordonnées:
             L’entrée des données.
          Le traitement des données.
          • La sortie des résultats.


                        Traiter quelques exercices à ce stade.


    1.2 Variable, affectation.
                        
       Définition :

           Lors de l’exécution d’un algorithme, on va avoir besoin

           de stocker des données, voire des résultats.
           Pour cela, on utilise des variables.
           On attribue un nom à chaque variable.
          Remarques :
           Une variable est comme une boîte, repérée par un nom,

              qui va contenir une information.

               Pour utiliser  le contenu de cette boîte, il suffit

               de l’appeler par son nom.


            Dans l’écriture d’un algorithme, ( avec ALGOBOX )on prendra l’habitude

               de préciser des le départ le nom des variables
               utilisées en indiquant leur type (nombre, chaîne de caractère, liste, etc.).

                 Cette étape est appelée déclaration des variables.

                 Mais Python par exemple ne demande pas de déclaration de variable d'abord.

                ( En Python le simple fait de dire a =2 fait que la variable a existe

                  puisque à un instant donné elle a une valeur.

                  En algobox , par contre, on devra indique avant le début de l'algorithme :

                  a VARIABLE_DE_TYPE  ...... NOMBRE ou CHAINE  ou LISTE   )


           Définition :

                       Les instructions de base sur des variables sont les suivantes :
         – La saisie : on demande à l’utilisateur de l’algorithme de donner une valeur à la variable ;
         – l’affectation : le concepteur de l’algorithme donne une valeur à la variable.

                                  Cette valeur peut-être le résultat d’un calcul ;
         – l’affichage : on affiche la valeur de la variable.
                              

                 Algorithme 1    Image par une fonction    y = 3x2 − 2x + 1

                      Variables :
                       x, y : nombres réels
                       Entrée :
                        Saisir x
                       Traitement :
                        y reçoit 3x2 − 2x + 1       Affectation
                        Sortie :
                        Afficher y
     2 Des structures importantes
            2.1 L’instruction conditionnelle.

               Définition :

                La résolution des certains problèmes nécessite la mise

                en place d’un test pour savoir si l’on doit effectuer une tâche.


                Si la condition est remplie alors on effectue la tâche,

                sinon on effectue (éventuellement) une autre tâche.
                Dans un algorithme, on code la structure du « Si... Alors.. Sinon » sous

                 la forme suivante :
                  Si      condition
                  Alors
                               Tâche 1
                               Tâche 2
                                  ...
                 Sinon
                             Tâche 1bis
                             Tâche 2bis
                              ...
                  Fin Si
                

      Remarques :
            •   Il est important de respecter les espaces laissés au début de

                 chaque ligne, car ils permettent une meilleure lisibilité

                 de l’algorithme.
            •  Le « Sinon » n’est pas obligatoire.

               S’il n’est pas présent, aucune tâche ne sera effectué si la condition
               n’est pas remplie.
                Exemples :
                    
               Algorithme: Triangle rectangle en C
                   Variables :
                       AB, AC, AB, x, y : nombres réels
                   Entrée :
                   Afficher « Entrer la valeur de AB »
                   Saisir AB
                   Afficher « Entrer la valeur de AC »
                   Saisir AC
                   Afficher « Entrer la valeur de BC »
                   Saisir BC
                   Traitement :
                   x reçoit AB²
                   y reçoit AC²+BC²
                   Si x = y
                   Alors
                   Afficher « Le triangle ABC est rectangle en C »
                   Sinon
                   Afficher « Le triangle ABC n’est pas rectangle en C »
                   Fin Si
                 Algorithme: Image par une fonction en tenant

                  compte de l’ensemble de définition.

                 Soit la fonction rationnelle f : x (x + 1) / (x − 1)
                   Variables :
                    x, y : nombres réels
                     Entrée :
                      Saisir x
                      Traitement :
                      Si x != 1       (   !=    mis pour   ≠  )
                       Alors
                       y reçoit (x + 1) / (x − 1)
                       Afficher y
                       Sinon
                        Afficher « La valeur choisie n’est pas dans

                       l’ensemble de définition »
                      Fin Si

                      Algorithme: Jeu de Pile ou Face
                     Variables :
                      choix, tirage : nombres réels
                      Entrée :
                       Saisir choix
                       tirage reçoit un nombre au hasard choisit

                       dans l’ensemble {0 ; 1}
                       Traitement :
                       Si choix =tirage
                        Alors
                       Afficher « Gagné ! »
                        Sinon
                        Afficher « Perdu ! »
                        Fin Si
       2.2 La boucle itérative

             Définition :

              Lorsque l’on doit répéter un nombre de fois connu à l’avance

              la même tâche, on utilise une boucle
              itérative de la forme

             « Pour.. allant de... à ».
              Dans un algorithme, cette structure est codée

               de la façon suivante :
                  Pour variable allant de valeur_départ à valeur_fin faire
                                     tâche 1
                                    tâche 2
                                        ...
                   Fin pour


                    La variable utilisée dans la boucle est

                    appelée compteur.

                    À chaque passage dans la boucle, sa valeur est
                    automatiquement augmentée de 1.


       Algorithme: Affiche la table de multiplication (de 0 à 10)

                          d’un nombre entier donné. ( Table de multiplication)


                        Variables :
                         n, m, i : nombres entiers
                        Entrée :
                        Saisir n
                       Traitement :
                        Pour i allant de 0 à 10 faire
                        m reçoit n × i
                        Afficher n ,« x », i, « = », m
                        Fin Pour


                Algorithme :   Affiche la somme de tous les entiers jusqu’à un entier donné.

                   Variables :
                   S , i, n : nombres entiers
                   Entrée :
                   Saisir n
                   S reçoit 0
                   Traitement :
                   Pour i allant de 1 à n faire
                   S reçoit S + i
                   Fin Pour
                  Sortie :
                  Afficher S

       2.3 La boucle conditionnelle
 
              Définition :

               Lorsque l’on doit répéter une tâche un nombre de fois

               non connu à l’avance, mais tant qu’une condition est remplie,

               on utilise une boucle conditionnelle de la forme

                « Tant que.. ».
                    Dans un algorithme, cette structure

                    est codée de la façon suivante :


                    Tant que condition faire
                                               tâche 1
                                               tâche 2
                                                ...
                      Fin Tant que


            Algorithme :  Algorithme d’Euclide du calcul du PGCD de deux nombres entiers.

             Le reste de la division euclidienne d’un nombre a par un nombre b

             est codé par l’instruction « a mod b ».
              Variables :
              a, b, r : nombres entiers
              Entrée :
               Afficher « Entrer le plus grand nombre »
               Saisir a
               Afficher « Entrer le plus petit nombre »
               Saisir b
               Traitement :
                r reçoit b
                Tant que r != 0 faire
                r reçoit (a mod b)
                a reçoit b
                b reçoit r
                Fin Tant que
                Sortie :
                Afficher « Le PGCD est », a

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