SlideShare une entreprise Scribd logo
DUT SRC – IUT de Marne-la-Vallée
                04/11/2011
          INF120 - Algorithmique




            Cours 3
Méthodologie pour l'algorithmique




                                         Philippe Gambette
Sources

 • Le livre de Java premier langage, d'A. Tasso
 • Cours INF120 de J.-G. Luque
 • Cours de J. Henriet : http://julienhenriet.olympe-network.com/Algo.html
 • http://xkcd.com, http://xkcd.free.fr
Plan du cours 3 – Méthodologie

 • Résumé des épisodes précédents
 • Compétences acquises en INF120
 • Méthodologie pour l'algorithmique
 • Exemples d'application de la méthodologie
Plan du cours 3 – Méthodologie

 • Résumé des épisodes précédents
 • Compétences acquises en INF120
 • Méthodologie pour l'algorithmique
 • Exemples d'application de la méthodologie
Résumé de l'épisode précédent

 Du problème au programme pour le résoudre :

  problème                                        algorithme                           code source
                     décomposition du                             traduction directe
                     problème +
                     connaissance des outils                                     compilation javac
                     disponibles + intuition       traduction directe

                                             organigramme                              programme
                                                                                   exécution java

 Codage des données :
 • Pour chaque type de variable (entiers, flottants, chaînes de caractères,
 couleurs, booléens), une méthode de codage en binaire est choisie
 (en Java : int, float, double, String, Color, boolean, ...)

 • Définition d'opérations de base pour chaque type de données
 (en Java : +, -, *, /, %, &&, ||, !, ...)
Plan du cours 3 – Méthodologie

 • Résumé des épisodes précédents
 • Compétences acquises en INF120
 • Méthodologie pour l'algorithmique
 • Exemples d'application de la méthodologie
Compétences acquises en INF120

 • Connaître les éléments de base d'un algorithme
 • Savoir lire et comprendre un algorithme
 • Savoir concevoir un algorithme pour résoudre un problème
 • Savoir programmer un algorithme
Compétences acquises en INF120

 Connaître les éléments de base d'un algorithme
 Un algorithme résout un problème, en fournissant un résultat en sortie à
 partir de données en entrée.
 Pour cela, il utilise plusieurs types d'instructions :
 - des affectations dans des variables (mémoires)
 - des boucles
 - des appels à d'autres algorithmes
 - des tests
 - des “lectures” d'entrées et “renvois” de sorties


 Chaque variable a un nom. On doit :
 - la déclarer en définissant son type (ensemble de valeurs possibles)
 - puis l'initialiser (lui donner une valeur)
 avant de l'utiliser.
Compétences acquises en INF120
                                                                              en pseudo-code
 Connaître les éléments de base d'un algorithme
 Un algorithme résout un problème, en fournissant un résultat en sortie à
                                                        Entrées : entiers i et j
 partir de données en entrée.                           Sortie : somme i+j (entier)
                                       une instruction par ligne !
 Pour cela, il utilise plusieurs types d'instructions :
 - des affectations dans des variables (mémoires) produit ← entier1+produit
 - des boucles Tant que … faire : … Fin TantQue         variable            valeur
 - des appels à d'autres algorithmes Addition(3,5) entrées de l'algorithme entre parenthèses,
                                                     respectant l'ordre de déclaration des entrées
 - des tests Si ... alors : ... sinon : … FinSi
 - des “lectures” d'entrées et “renvois” de sorties
                                        renvoyer i+j


 Chaque variable a un nom. On doit :
 - la déclarer en définissant son type (ensemble de valeurs possibles)
                                                                  Variables : entiers a et b
 - puis l'initialiser (lui donner une valeur par une affectation)              type
 avant de l'utiliser.                                a ←2
                                                             b ← a+2
Compétences acquises en INF120
                                                                                                en Java
 Connaître les éléments de base d'un algorithme
 Un algorithme résout un problème, en fournissant un int Addition(int i, int j){...}
                                         public static
                                                       résultat en sortie à
 partir de données en entrée.                     type de sortie entrées précédées de
                                     instructions finies par “;”                                leur type
 Pour cela, il utilise plusieurs types d'instructions :
 - des affectations dans des variables (mémoires) produit = entier1+produit;
 - des boucles while(…){...}                            variable           valeur
 - des appels à d'autres algorithmes Addition(3,5); entrées de l'algorithme entre parenthèses,
                                                     respectant l'ordre de déclaration des entrées
 - des tests   if(...){...}else{...}

 - des “lectures” d'entrées et “renvois” de sorties Indentation :              while (i<10){
                                        return i+j;                décalage du début if (x==5){
                                                                                                  i=i+1;
                                                                   de la ligne pour         }
                                                                   structurer le code   }
 Chaque variable a un nom. On doit :
 - la déclarer en définissant son type (ensemble de valeurs possibles) int a,b;
 - puis l'initialiser (lui donner une valeur par une affectation)      type
                                                     a = 2;
 avant de l'utiliser.                                b = a+2;
Plan du cours 3 – Méthodologie

 • Résumé des épisodes précédents
 • Compétences acquises en INF120
 • Méthodologie pour l'algorithmique
 • Exemples d'application de la méthodologie
Méthodologie pour l'algorithmique

 Savoir lire et comprendre un algorithme
 Premiers éléments à identifier :
 - qu'est-ce que l'algorithme prend en entrée ? Combien de variables, de
 quels types ?
 - qu'est-ce que l'algorithme renvoie en sortie ? Rien ? Ou bien une
 variable ? De quel type ?
 Ensuite :
 - quels sont les autres algorithmes appelés par l'algorithme ?
 Enfin :
 - faire la trace de l'algorithme, c'est-à-dire l'essayer sur un exemple
 (… ou plusieurs pour passer au moins une fois par toutes les instructions de l'algorithme)
 et voir ce que valent toutes les variables à chaque étape (et noter ces valeurs
 dans un tableau contenant une ligne par variable et une colonne par étape),
 - noter en particulier le résultat obtenu en sortie pour une entrée testée.
Méthodologie pour l'algorithmique

 Savoir concevoir un algorithme pour résoudre un problème

  La “minute xkcd”
  Problèmes informatiques
                                                            Mais aujourd'hui,             C'est comme ceci
          Sur une               Je passe la plupart de
   Tu connais ce échelle de 1 à 10,                         l'agencement des lumières     que j'explique mes
          quelle est la probabilité temps à appuyer
   rectangle métallique         mon                         est complètement anormal !    problèmes
   plein de petites question utilise boutons pour
          que cette             sur des
                                                                          Oh mon Dieu !   d'ordinateur à mon
   lumières ?
          du binaire ?          changer la configuration
                                                                       Essaye d'appuyer   chat. D'habitude, il a
                      Oui.      des lumières comme je
                                le veux.                     Ça n'améliore sur plus de
                                                                              4?          l'air plus content que
                                                    Cool.        rien !       boutons !   moi.
          C'est quoi un 4 ?




  http://xkcd.com/722
  http://xkcd.free.fr?id=722
Méthodologie pour l'algorithmique

 Savoir concevoir un algorithme pour résoudre un problème
 Premiers éléments à identifier :
 - quels sont les outils à disposition ? (pour ces outils : données en entrée, type de données
 en entrée, résultat en sortie, type de résultat en sortie, résultat attendu sur un exemple...)
 - quel est le comportement attendu pour mon algorithme ? (données en entrée, type
 de données en entrée, résultat en sortie, type de résultat en sortie, résultat attendu sur un
 exemple...)

 Ensuite, résoudre le problème en utilisant ces outils :
 - comment résoudre le problème étape par étape ? (essayer sur l'exemple testé)
 - est-ce que les outils à disposition sont utilisables pour réaliser chaque étape ?

 Enfin :
 - comment structurer l'utilisation des outils à disposition ? (combinaison des
 différents outils à l'intérieur de structure de boucles, de tests, utilisation d'un organigramme...)
 - comment décomposer le problème ? (et reformuler chaque sous-problème pour le
 résoudre avec les outils à disposition, écrire un algorithme par sous-problème)
Plan du cours 3 – Méthodologie

 • Résumé des épisodes précédents
 • Compétences acquises en INF120
 • Méthodologie pour l'algorithmique
 • Exemples d'application de la méthodologie
Le toit avec une pente à 26,565°




 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }
Le toit avec une pente à 26,565°




 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }


 Faire la trace de l'algorithme
Le toit avec une pente à 26,565°



                 (300,200)                                      (500,200)




 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }


 Faire la trace de l'algorithme
 “dessineLigne(Graphics g, int abscisse1, int ordonnee1, int abscisse2, int ordonnee2,
 Color couleur), qui dessine sur l'objet g une ligne commençant au point de coordonnées
 (abscisse1,ordonnee1) et se terminant au point de coordonnées (abscisse2,ordonnee2).”
Le toit avec une pente à 26,565°



                (300,200)                        (500,200)




 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }


 Faire la trace de l'algorithme, quand i=0 :
 dessineLigne(g,300,199,300,199,rouge)
 dessineLigne(g,301,199,301,199,rouge)
 ...
Le toit avec une pente à 26,565°



                (300,200)                        (500,200)




 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }


 Faire la trace de l'algorithme, quand i=1 :
 dessineLigne(g,302,198,302,199,rouge)
 dessineLigne(g,303,198,303,199,rouge)
 ...
Le toit avec une pente à 26,565°



                (300,200)                        (500,200)




 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }


 Faire la trace de l'algorithme, quand i=10 :
 dessineLigne(g,320,189,320,199,rouge)
 dessineLigne(g,321,189,321,199,rouge)
 ...
Le toit avec une pente à 26,565°




 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }


 On sort de la boucle après avoir affecté la valeur 51 à la variable i
Le toit avec une pente à 26,565°

 i=0;
 rouge=couleurRGB(200,0,0);
 while (i<51){
    dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge);
    dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge);
    dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge);
    dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge);
    i=i+1;
 }

 Traduction en pseudo-code :
 Algorithme DessineToit()
 Variables : entier i, couleur rouge
 Début
      i←0
      rouge ← couleurRGB(200,0,0)
      Tant que i<51 faire :
             dessineLigne(300+2i,199-i,300+2i,199,rouge)
             dessineLigne(301+2i,199-i,301+2i,199,rouge)
             dessineLigne(500-2i,199-i,500-2i,199,rouge)
             dessineLigne(501-2i,199-i,501-2i,199,rouge)
             i ← i+1
      Fin TantQue
 Fin
Exercice 1 du TD2

• 42 en binaire : 101010
• 84 en binaire : 1010100
• Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne
de caractères qui contient un nombre binaire n et s'il est pair, renvoie une
chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous
utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères
chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que
l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine
allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui
renvoie le nombre de caractères de la chaîne de caractères chaine.

Longueur :
Entrée : chaîne de caractères chaine
Exercice 1 du TD2

• 42 en binaire : 101010
• 84 en binaire : 1010100
• Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne
de caractères qui contient un nombre binaire n et s'il est pair, renvoie une
chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous
utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères
chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que
l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine
allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui
renvoie le nombre de caractères de la chaîne de caractères chaine.

Longueur :
Entrée : chaîne de caractères chaine
Sortie : entier (nombre de caractères de chaine)
Exercice 1 du TD2

• 42 en binaire : 101010
• 84 en binaire : 1010100
• Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne
de caractères qui contient un nombre binaire n et s'il est pair, renvoie une
chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous
utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères
chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que
l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine
allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui
renvoie le nombre de caractères de la chaîne de caractères chaine.

Longueur :
Entrée : chaîne de caractères chaine                  Longueur(“101010”)
Sortie : entier (nombre de caractères de chaine)                6
Exercice 1 du TD2

• 42 en binaire : 101010
• 84 en binaire : 1010100
• Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne
de caractères qui contient un nombre binaire n et s'il est pair, renvoie une
chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous
utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères
chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que
l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine
allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui
renvoie le nombre de caractères de la chaîne de caractères chaine.

Longueur :
Entrée : chaîne de caractères chaine                   Longueur(“101010”)
Sortie : entier (nombre de caractères de chaine)                6
DiviseParDeuxPair :
Entrée : chaîne de caractères chaine (qui code un entier n)
Sortie : chaîne de caractères (n/2 en binaire)
Exercice 1 du TD2

• 42 en binaire : 101010
• 84 en binaire : 1010100
• Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne
de caractères qui contient un nombre binaire n et s'il est pair, renvoie une
chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous
utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères
chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que
l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine
allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui
renvoie le nombre de caractères de la chaîne de caractères chaine.

Longueur :
Entrée : chaîne de caractères chaine                   Longueur(“101010”)
Sortie : entier (nombre de caractères de chaine)                6
DiviseParDeuxPair :
Entrée : chaîne de caractères chaine (qui code un entier n)
Sortie : chaîne de caractères (n/2 en binaire)
DiviseParDeuxPair(“1010100”)           SousChaine(“1010100”,2,3)
          “101010”                               “01”
Exercice 1 du TD2
                                    Principale instruction :
• 42 en binaire : 101010             renvoyer SousChaine(chaine,1,Longueur(chaine)-1)
• 84 en binaire : 1010100
• Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne
de caractères qui contient un nombre binaire n et s'il est pair, renvoie une
chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous
utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères
chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que
l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine
allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui
renvoie le nombre de caractères de la chaîne de caractères chaine.

Longueur :
Entrée : chaîne de caractères chaine                           Longueur(“101010”)
Sortie : entier (nombre de caractères de chaine)                       6
DiviseParDeuxPair :
Entrée : chaîne de caractères chaine (qui code un entier n)
Sortie : chaîne de caractères (n/2 en binaire)
DiviseParDeuxPair(“1010100”)              SousChaine(“1010100”,2,3)
          “101010”                                  “01”
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                           Outils à disposition : SousChaine,
                                                           Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”




                                                                                           South Park S15E09
                                                        http://www.spscriptorium.com/Season15/E1509script.htm
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                           Outils à disposition : SousChaine,
                                                           Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


TrouveMot
Entrées : chaîne de caractères mot, chaîne de
              caractères texte
Sortie : entier (nombre de fois que mot apparaît dans texte)

 TrouveMot(“fuck”, “Nobody's fuckin' screaming, Craig! Wake the fuck up!”)
 renvoie l'entier 2
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                           Outils à disposition : SousChaine,
                                                           Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte
• on teste si on trouve mot
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                               Outils à disposition : SousChaine,
                                                               Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte
• on teste si on trouve mot     la sous-chaine de texte qui commence au i-ième caractère et a
                                   autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ?

                                        reformulation du problème avec
                                        Caractères, SousChaine, Longueur
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                               Outils à disposition : SousChaine,
                                                               Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte
• on teste si on trouve mot     la sous-chaine de texte qui commence au i-ième caractère et a
                                   autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ?

                                                  mot = SousChaine(texte,i,i+...) ?
                                        reformulation du problème avec
                                        Caractères, SousChaine, Longueur
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                               Outils à disposition : SousChaine,
                                                               Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte
• on teste si on trouve mot     la sous-chaine de texte qui commence au i-ième caractère et a
                                   autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ?

                                                   mot = SousChaine(texte,i,i+3) ?
                                        reformulation du problème avec
                                        Caractères, SousChaine, Longueur
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                               Outils à disposition : SousChaine,
                                                               Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte
• on teste si on trouve mot     la sous-chaine de texte qui commence au i-ième caractère et a
                                   autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ?

                                          mot = SousChaine(texte,i,i+Longueur(mot)-1) ?
                                        reformulation du problème avec
                                        Caractères, SousChaine, Longueur
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                               Outils à disposition : SousChaine,
                                                               Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte appeler cette position i
• on teste si on trouve mot       la faire varier de 1 à ...


                                         mot = SousChaine(texte,i,i+Longueur(mot)-1) ?
                                        reformulation du problème avec
                                        Caractères, SousChaine, Longueur
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                               Outils à disposition : SousChaine,
                                                               Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte appeler cette position i        i←1
• on teste si on trouve mot       la faire varier de 1 à ...      Tant que i<Longueur(texte)-
                                                                  Longueur(mot)+2 faire : ...

                                         mot = SousChaine(texte,i,i+Longueur(mot)-1) ?
                                        reformulation du problème avec
                                        Caractères, SousChaine, Longueur
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.
                                                           Outils à disposition : SousChaine,
                                                           Longueur, Caractère
Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”


Idée : regarder à toutes les positions de la chaîne de
caractères texte si on trouve le mot mot.

Décomposition du problème :
• à toutes les positions de texte                             i←1
• on teste si on trouve mot                                   Tant que i<Longueur(texte)-
                                                              Longueur(mot)+2 faire : ...

                                        mot = SousChaine(texte,i,i+Longueur(mot)-1) ?
                                       reformulation du problème avec
                                       Caractères, SousChaine, Longueur
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”




   i←1
   Tant que i<Longueur(texte)-Longueur(mot)+2 faire :

            mot = SousChaine(texte,i,i+Longueur(mot)-1) ?
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entier i
Début
      i←1
      ...
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
            ...

            i ← i+1
      Fin TantQue
      ...
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entier i
Début
      i←1
      ...
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
            ...

            i ← i+1
      Fin TantQue
      ...
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entiers i, NombreTrouvé
Début
      i←1
      NombreTrouvé ← 0
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
            ...

            i ← i+1
      Fin TantQue
      ...
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entiers i, NombreTrouvé
Début
      i←1
      NombreTrouvé ← 0
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
                  NombreTrouvé ← NombreTrouvé+1
            FinSi
            i ← i+1
      Fin TantQue
      ...
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entiers i, NombreTrouvé
Début
      i←1
      NombreTrouvé ← 0
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
                  NombreTrouvé ← NombreTrouvé+1
            FinSi
            i ← i+1
      Fin TantQue
      renvoyer NombreTrouvé
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entiers i, NombreTrouvé
Début
      i←1
      NombreTrouvé ← 0        Pourquoi cette condition d'arrêt ?
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
                  NombreTrouvé ← NombreTrouvé+1
            FinSi
            i ← i+1
      Fin TantQue
      renvoyer NombreTrouvé
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entiers i, NombreTrouvé
Début
      i←1
      NombreTrouvé ← 0        Pourquoi cette condition d'arrêt ?
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
                  NombreTrouvé ← NombreTrouvé+1
            FinSi                                                                123456
            i ← i+1                                          mot = “ab” texte = “ccabab”
      Fin TantQue
      renvoyer NombreTrouvé
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entiers i, NombreTrouvé
Début
      i←1
      NombreTrouvé ← 0        Pourquoi cette condition d'arrêt ?
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :
                  NombreTrouvé ← NombreTrouvé+1
            FinSi                                                                 123456
            i ← i+1                                          mot = “abc” texte = “ccabab”
      Fin TantQue
      renvoyer NombreTrouvé
Fin
Le nombre d'utilisations d'un mot dans un texte

• Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de
caractères mot et une chaîne de caractères texte, et compte le nombre
de fois que mot apparaît dans texte.

Exemple : mot = “fuck”
  texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ”

Algorithme TrouveMot :
Entrées : chaîne de caractères mot, chaîne de caractères texte
Sorties : nombre de fois (entier) que mot apparaît dans texte
Variables : entiers i, NombreTrouvé
Début
      i←1
      NombreTrouvé ← 0        Pourquoi cette condition d'arrêt ?
      Tant que i<Longueur(texte)-Longueur(mot)+2 faire :
            Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors :                   Longueur(texte)
                  NombreTrouvé ← NombreTrouvé+1
            FinSi                                                                 123456
            i ← i+1                                          mot = “abc” texte = “ccabab”
      Fin TantQue
      renvoyer NombreTrouvé
Fin                                                  Longueur(texte)-Longueur(mot)+1
                                                             6             4

Contenu connexe

Tendances

Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
Abdoulaye Dieng
 
Diviser Pour Régner
Diviser Pour RégnerDiviser Pour Régner
Diviser Pour Régner
Mestari-Mohammed
 
Chapitre v algorithmes gloutons
Chapitre v algorithmes gloutonsChapitre v algorithmes gloutons
Chapitre v algorithmes gloutonsSana Aroussi
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
ABID Mehdi
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
ABID Mehdi
 
récursivité algorithmique et complexité algorithmique et Les algorithmes de tri
récursivité algorithmique et complexité algorithmique et Les algorithmes de trirécursivité algorithmique et complexité algorithmique et Les algorithmes de tri
récursivité algorithmique et complexité algorithmique et Les algorithmes de tri
Yassine Anddam
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
Aziz Darouichi
 
Chapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régnerChapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régnerSana Aroussi
 
Algorithme & structures de données Chap II
Algorithme & structures de données Chap IIAlgorithme & structures de données Chap II
Algorithme & structures de données Chap II
Ines Ouaz
 
langage C++
langage C++langage C++
langage C++
mohamednacim
 
Chapitre vi np complétude
Chapitre vi np complétudeChapitre vi np complétude
Chapitre vi np complétudeSana Aroussi
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objets
Aziz Darouichi
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019
Aziz Darouichi
 
Cours langage c
Cours langage cCours langage c
Cours langage c
coursuniv
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite completChahrawoods Dmz
 
Chapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en JavaChapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en Java
Aziz Darouichi
 
Asd1
Asd1Asd1
Chap2fonctionscpp
Chap2fonctionscppChap2fonctionscpp
Chap2fonctionscpp
Aziz Darouichi
 
Chapitre 3 NP-complétude
Chapitre 3 NP-complétudeChapitre 3 NP-complétude
Chapitre 3 NP-complétude
Sana Aroussi
 
Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références
Aziz Darouichi
 

Tendances (20)

Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
 
Diviser Pour Régner
Diviser Pour RégnerDiviser Pour Régner
Diviser Pour Régner
 
Chapitre v algorithmes gloutons
Chapitre v algorithmes gloutonsChapitre v algorithmes gloutons
Chapitre v algorithmes gloutons
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
 
récursivité algorithmique et complexité algorithmique et Les algorithmes de tri
récursivité algorithmique et complexité algorithmique et Les algorithmes de trirécursivité algorithmique et complexité algorithmique et Les algorithmes de tri
récursivité algorithmique et complexité algorithmique et Les algorithmes de tri
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
 
Chapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régnerChapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régner
 
Algorithme & structures de données Chap II
Algorithme & structures de données Chap IIAlgorithme & structures de données Chap II
Algorithme & structures de données Chap II
 
langage C++
langage C++langage C++
langage C++
 
Chapitre vi np complétude
Chapitre vi np complétudeChapitre vi np complétude
Chapitre vi np complétude
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objets
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019
 
Cours langage c
Cours langage cCours langage c
Cours langage c
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite complet
 
Chapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en JavaChapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en Java
 
Asd1
Asd1Asd1
Asd1
 
Chap2fonctionscpp
Chap2fonctionscppChap2fonctionscpp
Chap2fonctionscpp
 
Chapitre 3 NP-complétude
Chapitre 3 NP-complétudeChapitre 3 NP-complétude
Chapitre 3 NP-complétude
 
Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références
 

En vedette

INF220 - Algo DUT SRC1 - Cours 1 - 2013
INF220 - Algo DUT SRC1 - Cours 1 - 2013INF220 - Algo DUT SRC1 - Cours 1 - 2013
INF220 - Algo DUT SRC1 - Cours 1 - 2013PGambette
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
elharraj
 
Ch1 Algorthmique Avancée - Rappel & Notions de Base
Ch1 Algorthmique Avancée - Rappel & Notions de BaseCh1 Algorthmique Avancée - Rappel & Notions de Base
Ch1 Algorthmique Avancée - Rappel & Notions de Baselotfibenromdhane
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
Jalilos OSum
 
INF220 - Algo DUT SRC1 - Cours 1
INF220 - Algo DUT SRC1 - Cours 1INF220 - Algo DUT SRC1 - Cours 1
INF220 - Algo DUT SRC1 - Cours 1PGambette
 

En vedette (6)

INF220 - Algo DUT SRC1 - Cours 1 - 2013
INF220 - Algo DUT SRC1 - Cours 1 - 2013INF220 - Algo DUT SRC1 - Cours 1 - 2013
INF220 - Algo DUT SRC1 - Cours 1 - 2013
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
 
Ch1 Algorthmique Avancée - Rappel & Notions de Base
Ch1 Algorthmique Avancée - Rappel & Notions de BaseCh1 Algorthmique Avancée - Rappel & Notions de Base
Ch1 Algorthmique Avancée - Rappel & Notions de Base
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
 
Dc 1
Dc 1Dc 1
Dc 1
 
INF220 - Algo DUT SRC1 - Cours 1
INF220 - Algo DUT SRC1 - Cours 1INF220 - Algo DUT SRC1 - Cours 1
INF220 - Algo DUT SRC1 - Cours 1
 

Similaire à INF120 - Algo DUT SRC1 - Cours 3

Cours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkr
Cours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkrCours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkr
Cours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkr
JulienKhalil3
 
Eléments du langage Java.pdf
Eléments du langage  Java.pdfEléments du langage  Java.pdf
Eléments du langage Java.pdf
AabidiHafid
 
Algo inf102 2007
Algo inf102 2007Algo inf102 2007
Algo inf102 2007
SergeCowouvi1
 
Chapitre 2-Concepts de base de l'algorithme-2024.pdf
Chapitre 2-Concepts de base de l'algorithme-2024.pdfChapitre 2-Concepts de base de l'algorithme-2024.pdf
Chapitre 2-Concepts de base de l'algorithme-2024.pdf
AdjimbawNDIAYE
 
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
MSDEVMTL
 
Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
Sana Aroussi
 
Généralités sur la notion d’Algorithme
Généralités sur la notion d’AlgorithmeGénéralités sur la notion d’Algorithme
Généralités sur la notion d’Algorithme
InforMatica34
 
Les bases de la programmation en JAVA
Les bases de la programmation  en JAVA   Les bases de la programmation  en JAVA
Les bases de la programmation en JAVA
Asmaa BENGUEDDACH
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
Abdoulaye Dieng
 
cours fortran.pptx
cours fortran.pptxcours fortran.pptx
cours fortran.pptx
MED B
 
Conception de base_de_l_algorithme
Conception de base_de_l_algorithmeConception de base_de_l_algorithme
Conception de base_de_l_algorithmemustapha4
 
Formation en Python_Niveau1_2023.pptx
Formation en Python_Niveau1_2023.pptxFormation en Python_Niveau1_2023.pptx
Formation en Python_Niveau1_2023.pptx
betalab
 
Cours - TC - Histoire Algorithmique.pdf
Cours - TC - Histoire Algorithmique.pdfCours - TC - Histoire Algorithmique.pdf
Cours - TC - Histoire Algorithmique.pdf
adeljaouadi
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
Abdoulaye Dieng
 
Cours algorithmique02
Cours algorithmique02Cours algorithmique02
Cours algorithmique02
Eric Innocenti
 
cour de compilation
cour de compilation cour de compilation
cour de compilation Ens Kouba
 
COURS_ALGORITHME_SNINEH.pptx
COURS_ALGORITHME_SNINEH.pptxCOURS_ALGORITHME_SNINEH.pptx
COURS_ALGORITHME_SNINEH.pptx
SalmaAhraimida
 
Formation python
Formation pythonFormation python
Formation python
j_lipaz
 

Similaire à INF120 - Algo DUT SRC1 - Cours 3 (20)

Cours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkr
Cours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkrCours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkr
Cours_Java. Skzozibb nsif keizijfbjzozzml keiei tjeiz9rkr
 
Eléments du langage Java.pdf
Eléments du langage  Java.pdfEléments du langage  Java.pdf
Eléments du langage Java.pdf
 
Algo inf102 2007
Algo inf102 2007Algo inf102 2007
Algo inf102 2007
 
Chapitre 2-Concepts de base de l'algorithme-2024.pdf
Chapitre 2-Concepts de base de l'algorithme-2024.pdfChapitre 2-Concepts de base de l'algorithme-2024.pdf
Chapitre 2-Concepts de base de l'algorithme-2024.pdf
 
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
 
Part1
Part1Part1
Part1
 
Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
 
Généralités sur la notion d’Algorithme
Généralités sur la notion d’AlgorithmeGénéralités sur la notion d’Algorithme
Généralités sur la notion d’Algorithme
 
Les bases de la programmation en JAVA
Les bases de la programmation  en JAVA   Les bases de la programmation  en JAVA
Les bases de la programmation en JAVA
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
 
cours fortran.pptx
cours fortran.pptxcours fortran.pptx
cours fortran.pptx
 
Conception de base_de_l_algorithme
Conception de base_de_l_algorithmeConception de base_de_l_algorithme
Conception de base_de_l_algorithme
 
Formation en Python_Niveau1_2023.pptx
Formation en Python_Niveau1_2023.pptxFormation en Python_Niveau1_2023.pptx
Formation en Python_Niveau1_2023.pptx
 
Cours - TC - Histoire Algorithmique.pdf
Cours - TC - Histoire Algorithmique.pdfCours - TC - Histoire Algorithmique.pdf
Cours - TC - Histoire Algorithmique.pdf
 
Initiation à l'algorithmique
Initiation à l'algorithmiqueInitiation à l'algorithmique
Initiation à l'algorithmique
 
Cours algorithmique02
Cours algorithmique02Cours algorithmique02
Cours algorithmique02
 
Apprentissage du java
Apprentissage du javaApprentissage du java
Apprentissage du java
 
cour de compilation
cour de compilation cour de compilation
cour de compilation
 
COURS_ALGORITHME_SNINEH.pptx
COURS_ALGORITHME_SNINEH.pptxCOURS_ALGORITHME_SNINEH.pptx
COURS_ALGORITHME_SNINEH.pptx
 
Formation python
Formation pythonFormation python
Formation python
 

Plus de PGambette

Correction de la question 5 de l'exercice 2 du TD3 (M1202)
Correction de la question 5 de l'exercice 2 du TD3 (M1202)Correction de la question 5 de l'exercice 2 du TD3 (M1202)
Correction de la question 5 de l'exercice 2 du TD3 (M1202)PGambette
 
M1202 Algorithmique & programmation Java - Cours 1 2013
M1202 Algorithmique & programmation Java - Cours 1 2013M1202 Algorithmique & programmation Java - Cours 1 2013
M1202 Algorithmique & programmation Java - Cours 1 2013PGambette
 
INF120 - Algo DUT SRC1 - Cours 3 (2012)
INF120 - Algo DUT SRC1 - Cours 3 (2012)INF120 - Algo DUT SRC1 - Cours 3 (2012)
INF120 - Algo DUT SRC1 - Cours 3 (2012)PGambette
 
INF120 - Algo DUT SRC1 - Cours 1 (2012)
INF120 - Algo DUT SRC1 - Cours 1 (2012)INF120 - Algo DUT SRC1 - Cours 1 (2012)
INF120 - Algo DUT SRC1 - Cours 1 (2012)PGambette
 
INF240 - Bases de données DUT SRC1 - Cours 3
INF240 - Bases de données DUT SRC1 - Cours 3INF240 - Bases de données DUT SRC1 - Cours 3
INF240 - Bases de données DUT SRC1 - Cours 3PGambette
 
INF240 - Bases de données DUT SRC1 - Cours 2
INF240 - Bases de données DUT SRC1 - Cours 2INF240 - Bases de données DUT SRC1 - Cours 2
INF240 - Bases de données DUT SRC1 - Cours 2PGambette
 
INF240 - Bases de données DUT SRC1 - Cours 1
INF240 - Bases de données DUT SRC1 - Cours 1INF240 - Bases de données DUT SRC1 - Cours 1
INF240 - Bases de données DUT SRC1 - Cours 1PGambette
 
INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2
PGambette
 
INF120 - Algo DUT SRC1 - Cours 4
INF120 - Algo DUT SRC1 - Cours 4INF120 - Algo DUT SRC1 - Cours 4
INF120 - Algo DUT SRC1 - Cours 4PGambette
 
INF120 - Algo DUT SRC1 - Cours 1
INF120 - Algo DUT SRC1 - Cours 1INF120 - Algo DUT SRC1 - Cours 1
INF120 - Algo DUT SRC1 - Cours 1
PGambette
 

Plus de PGambette (10)

Correction de la question 5 de l'exercice 2 du TD3 (M1202)
Correction de la question 5 de l'exercice 2 du TD3 (M1202)Correction de la question 5 de l'exercice 2 du TD3 (M1202)
Correction de la question 5 de l'exercice 2 du TD3 (M1202)
 
M1202 Algorithmique & programmation Java - Cours 1 2013
M1202 Algorithmique & programmation Java - Cours 1 2013M1202 Algorithmique & programmation Java - Cours 1 2013
M1202 Algorithmique & programmation Java - Cours 1 2013
 
INF120 - Algo DUT SRC1 - Cours 3 (2012)
INF120 - Algo DUT SRC1 - Cours 3 (2012)INF120 - Algo DUT SRC1 - Cours 3 (2012)
INF120 - Algo DUT SRC1 - Cours 3 (2012)
 
INF120 - Algo DUT SRC1 - Cours 1 (2012)
INF120 - Algo DUT SRC1 - Cours 1 (2012)INF120 - Algo DUT SRC1 - Cours 1 (2012)
INF120 - Algo DUT SRC1 - Cours 1 (2012)
 
INF240 - Bases de données DUT SRC1 - Cours 3
INF240 - Bases de données DUT SRC1 - Cours 3INF240 - Bases de données DUT SRC1 - Cours 3
INF240 - Bases de données DUT SRC1 - Cours 3
 
INF240 - Bases de données DUT SRC1 - Cours 2
INF240 - Bases de données DUT SRC1 - Cours 2INF240 - Bases de données DUT SRC1 - Cours 2
INF240 - Bases de données DUT SRC1 - Cours 2
 
INF240 - Bases de données DUT SRC1 - Cours 1
INF240 - Bases de données DUT SRC1 - Cours 1INF240 - Bases de données DUT SRC1 - Cours 1
INF240 - Bases de données DUT SRC1 - Cours 1
 
INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2
 
INF120 - Algo DUT SRC1 - Cours 4
INF120 - Algo DUT SRC1 - Cours 4INF120 - Algo DUT SRC1 - Cours 4
INF120 - Algo DUT SRC1 - Cours 4
 
INF120 - Algo DUT SRC1 - Cours 1
INF120 - Algo DUT SRC1 - Cours 1INF120 - Algo DUT SRC1 - Cours 1
INF120 - Algo DUT SRC1 - Cours 1
 

Dernier

Edito-B1-francais Manuel to learning.pdf
Edito-B1-francais Manuel to learning.pdfEdito-B1-francais Manuel to learning.pdf
Edito-B1-francais Manuel to learning.pdf
WarlockeTamagafk
 
Mémoire de licence en finance comptabilité et audit
Mémoire de licence en finance comptabilité et auditMémoire de licence en finance comptabilité et audit
Mémoire de licence en finance comptabilité et audit
MelDjobo
 
Système de gestion des fichiers de amine
Système de gestion des fichiers de amineSystème de gestion des fichiers de amine
Système de gestion des fichiers de amine
sewawillis
 
SYLLABUS DU COURS MARKETING DTS 1-2.pdf
SYLLABUS DU COURS  MARKETING DTS 1-2.pdfSYLLABUS DU COURS  MARKETING DTS 1-2.pdf
SYLLABUS DU COURS MARKETING DTS 1-2.pdf
Moukagni Evrard
 
Conseils pour Les Jeunes | Conseils de La Vie| Conseil de La Jeunesse
Conseils pour Les Jeunes | Conseils de La Vie| Conseil de La JeunesseConseils pour Les Jeunes | Conseils de La Vie| Conseil de La Jeunesse
Conseils pour Les Jeunes | Conseils de La Vie| Conseil de La Jeunesse
Oscar Smith
 
Burkina Faso library newsletter May 2024
Burkina Faso library newsletter May 2024Burkina Faso library newsletter May 2024
Burkina Faso library newsletter May 2024
Friends of African Village Libraries
 
Iris van Herpen. pptx
Iris            van        Herpen.     pptxIris            van        Herpen.     pptx
Iris van Herpen. pptx
Txaruka
 
Iris van Herpen. pptx
Iris         van         Herpen.      pptxIris         van         Herpen.      pptx
Iris van Herpen. pptx
Txaruka
 
Cours de conjugaison des verbes du premier, deuxième et troisième groupe
Cours de conjugaison des verbes du premier, deuxième et troisième groupeCours de conjugaison des verbes du premier, deuxième et troisième groupe
Cours de conjugaison des verbes du premier, deuxième et troisième groupe
Yuma91
 
Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...
Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...
Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...
mrelmejri
 
Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...
Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...
Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...
cristionobedi
 
Iris et les hommes.pptx
Iris      et         les      hommes.pptxIris      et         les      hommes.pptx
Iris et les hommes.pptx
Txaruka
 

Dernier (12)

Edito-B1-francais Manuel to learning.pdf
Edito-B1-francais Manuel to learning.pdfEdito-B1-francais Manuel to learning.pdf
Edito-B1-francais Manuel to learning.pdf
 
Mémoire de licence en finance comptabilité et audit
Mémoire de licence en finance comptabilité et auditMémoire de licence en finance comptabilité et audit
Mémoire de licence en finance comptabilité et audit
 
Système de gestion des fichiers de amine
Système de gestion des fichiers de amineSystème de gestion des fichiers de amine
Système de gestion des fichiers de amine
 
SYLLABUS DU COURS MARKETING DTS 1-2.pdf
SYLLABUS DU COURS  MARKETING DTS 1-2.pdfSYLLABUS DU COURS  MARKETING DTS 1-2.pdf
SYLLABUS DU COURS MARKETING DTS 1-2.pdf
 
Conseils pour Les Jeunes | Conseils de La Vie| Conseil de La Jeunesse
Conseils pour Les Jeunes | Conseils de La Vie| Conseil de La JeunesseConseils pour Les Jeunes | Conseils de La Vie| Conseil de La Jeunesse
Conseils pour Les Jeunes | Conseils de La Vie| Conseil de La Jeunesse
 
Burkina Faso library newsletter May 2024
Burkina Faso library newsletter May 2024Burkina Faso library newsletter May 2024
Burkina Faso library newsletter May 2024
 
Iris van Herpen. pptx
Iris            van        Herpen.     pptxIris            van        Herpen.     pptx
Iris van Herpen. pptx
 
Iris van Herpen. pptx
Iris         van         Herpen.      pptxIris         van         Herpen.      pptx
Iris van Herpen. pptx
 
Cours de conjugaison des verbes du premier, deuxième et troisième groupe
Cours de conjugaison des verbes du premier, deuxième et troisième groupeCours de conjugaison des verbes du premier, deuxième et troisième groupe
Cours de conjugaison des verbes du premier, deuxième et troisième groupe
 
Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...
Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...
Impact des Critères Environnementaux, Sociaux et de Gouvernance (ESG) sur les...
 
Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...
Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...
Formation Intelligence Artificielle pour dirigeants- IT6-DIGITALIX 24_opt OK_...
 
Iris et les hommes.pptx
Iris      et         les      hommes.pptxIris      et         les      hommes.pptx
Iris et les hommes.pptx
 

INF120 - Algo DUT SRC1 - Cours 3

  • 1. DUT SRC – IUT de Marne-la-Vallée 04/11/2011 INF120 - Algorithmique Cours 3 Méthodologie pour l'algorithmique Philippe Gambette
  • 2. Sources • Le livre de Java premier langage, d'A. Tasso • Cours INF120 de J.-G. Luque • Cours de J. Henriet : http://julienhenriet.olympe-network.com/Algo.html • http://xkcd.com, http://xkcd.free.fr
  • 3. Plan du cours 3 – Méthodologie • Résumé des épisodes précédents • Compétences acquises en INF120 • Méthodologie pour l'algorithmique • Exemples d'application de la méthodologie
  • 4. Plan du cours 3 – Méthodologie • Résumé des épisodes précédents • Compétences acquises en INF120 • Méthodologie pour l'algorithmique • Exemples d'application de la méthodologie
  • 5. Résumé de l'épisode précédent Du problème au programme pour le résoudre : problème algorithme code source décomposition du traduction directe problème + connaissance des outils compilation javac disponibles + intuition traduction directe organigramme programme exécution java Codage des données : • Pour chaque type de variable (entiers, flottants, chaînes de caractères, couleurs, booléens), une méthode de codage en binaire est choisie (en Java : int, float, double, String, Color, boolean, ...) • Définition d'opérations de base pour chaque type de données (en Java : +, -, *, /, %, &&, ||, !, ...)
  • 6. Plan du cours 3 – Méthodologie • Résumé des épisodes précédents • Compétences acquises en INF120 • Méthodologie pour l'algorithmique • Exemples d'application de la méthodologie
  • 7. Compétences acquises en INF120 • Connaître les éléments de base d'un algorithme • Savoir lire et comprendre un algorithme • Savoir concevoir un algorithme pour résoudre un problème • Savoir programmer un algorithme
  • 8. Compétences acquises en INF120 Connaître les éléments de base d'un algorithme Un algorithme résout un problème, en fournissant un résultat en sortie à partir de données en entrée. Pour cela, il utilise plusieurs types d'instructions : - des affectations dans des variables (mémoires) - des boucles - des appels à d'autres algorithmes - des tests - des “lectures” d'entrées et “renvois” de sorties Chaque variable a un nom. On doit : - la déclarer en définissant son type (ensemble de valeurs possibles) - puis l'initialiser (lui donner une valeur) avant de l'utiliser.
  • 9. Compétences acquises en INF120 en pseudo-code Connaître les éléments de base d'un algorithme Un algorithme résout un problème, en fournissant un résultat en sortie à Entrées : entiers i et j partir de données en entrée. Sortie : somme i+j (entier) une instruction par ligne ! Pour cela, il utilise plusieurs types d'instructions : - des affectations dans des variables (mémoires) produit ← entier1+produit - des boucles Tant que … faire : … Fin TantQue variable valeur - des appels à d'autres algorithmes Addition(3,5) entrées de l'algorithme entre parenthèses, respectant l'ordre de déclaration des entrées - des tests Si ... alors : ... sinon : … FinSi - des “lectures” d'entrées et “renvois” de sorties renvoyer i+j Chaque variable a un nom. On doit : - la déclarer en définissant son type (ensemble de valeurs possibles) Variables : entiers a et b - puis l'initialiser (lui donner une valeur par une affectation) type avant de l'utiliser. a ←2 b ← a+2
  • 10. Compétences acquises en INF120 en Java Connaître les éléments de base d'un algorithme Un algorithme résout un problème, en fournissant un int Addition(int i, int j){...} public static résultat en sortie à partir de données en entrée. type de sortie entrées précédées de instructions finies par “;” leur type Pour cela, il utilise plusieurs types d'instructions : - des affectations dans des variables (mémoires) produit = entier1+produit; - des boucles while(…){...} variable valeur - des appels à d'autres algorithmes Addition(3,5); entrées de l'algorithme entre parenthèses, respectant l'ordre de déclaration des entrées - des tests if(...){...}else{...} - des “lectures” d'entrées et “renvois” de sorties Indentation : while (i<10){ return i+j; décalage du début if (x==5){ i=i+1; de la ligne pour } structurer le code } Chaque variable a un nom. On doit : - la déclarer en définissant son type (ensemble de valeurs possibles) int a,b; - puis l'initialiser (lui donner une valeur par une affectation) type a = 2; avant de l'utiliser. b = a+2;
  • 11. Plan du cours 3 – Méthodologie • Résumé des épisodes précédents • Compétences acquises en INF120 • Méthodologie pour l'algorithmique • Exemples d'application de la méthodologie
  • 12. Méthodologie pour l'algorithmique Savoir lire et comprendre un algorithme Premiers éléments à identifier : - qu'est-ce que l'algorithme prend en entrée ? Combien de variables, de quels types ? - qu'est-ce que l'algorithme renvoie en sortie ? Rien ? Ou bien une variable ? De quel type ? Ensuite : - quels sont les autres algorithmes appelés par l'algorithme ? Enfin : - faire la trace de l'algorithme, c'est-à-dire l'essayer sur un exemple (… ou plusieurs pour passer au moins une fois par toutes les instructions de l'algorithme) et voir ce que valent toutes les variables à chaque étape (et noter ces valeurs dans un tableau contenant une ligne par variable et une colonne par étape), - noter en particulier le résultat obtenu en sortie pour une entrée testée.
  • 13. Méthodologie pour l'algorithmique Savoir concevoir un algorithme pour résoudre un problème La “minute xkcd” Problèmes informatiques Mais aujourd'hui, C'est comme ceci Sur une Je passe la plupart de Tu connais ce échelle de 1 à 10, l'agencement des lumières que j'explique mes quelle est la probabilité temps à appuyer rectangle métallique mon est complètement anormal ! problèmes plein de petites question utilise boutons pour que cette sur des Oh mon Dieu ! d'ordinateur à mon lumières ? du binaire ? changer la configuration Essaye d'appuyer chat. D'habitude, il a Oui. des lumières comme je le veux. Ça n'améliore sur plus de 4? l'air plus content que Cool. rien ! boutons ! moi. C'est quoi un 4 ? http://xkcd.com/722 http://xkcd.free.fr?id=722
  • 14. Méthodologie pour l'algorithmique Savoir concevoir un algorithme pour résoudre un problème Premiers éléments à identifier : - quels sont les outils à disposition ? (pour ces outils : données en entrée, type de données en entrée, résultat en sortie, type de résultat en sortie, résultat attendu sur un exemple...) - quel est le comportement attendu pour mon algorithme ? (données en entrée, type de données en entrée, résultat en sortie, type de résultat en sortie, résultat attendu sur un exemple...) Ensuite, résoudre le problème en utilisant ces outils : - comment résoudre le problème étape par étape ? (essayer sur l'exemple testé) - est-ce que les outils à disposition sont utilisables pour réaliser chaque étape ? Enfin : - comment structurer l'utilisation des outils à disposition ? (combinaison des différents outils à l'intérieur de structure de boucles, de tests, utilisation d'un organigramme...) - comment décomposer le problème ? (et reformuler chaque sous-problème pour le résoudre avec les outils à disposition, écrire un algorithme par sous-problème)
  • 15. Plan du cours 3 – Méthodologie • Résumé des épisodes précédents • Compétences acquises en INF120 • Méthodologie pour l'algorithmique • Exemples d'application de la méthodologie
  • 16. Le toit avec une pente à 26,565° i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; }
  • 17. Le toit avec une pente à 26,565° i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; } Faire la trace de l'algorithme
  • 18. Le toit avec une pente à 26,565° (300,200) (500,200) i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; } Faire la trace de l'algorithme “dessineLigne(Graphics g, int abscisse1, int ordonnee1, int abscisse2, int ordonnee2, Color couleur), qui dessine sur l'objet g une ligne commençant au point de coordonnées (abscisse1,ordonnee1) et se terminant au point de coordonnées (abscisse2,ordonnee2).”
  • 19. Le toit avec une pente à 26,565° (300,200) (500,200) i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; } Faire la trace de l'algorithme, quand i=0 : dessineLigne(g,300,199,300,199,rouge) dessineLigne(g,301,199,301,199,rouge) ...
  • 20. Le toit avec une pente à 26,565° (300,200) (500,200) i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; } Faire la trace de l'algorithme, quand i=1 : dessineLigne(g,302,198,302,199,rouge) dessineLigne(g,303,198,303,199,rouge) ...
  • 21. Le toit avec une pente à 26,565° (300,200) (500,200) i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; } Faire la trace de l'algorithme, quand i=10 : dessineLigne(g,320,189,320,199,rouge) dessineLigne(g,321,189,321,199,rouge) ...
  • 22. Le toit avec une pente à 26,565° i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; } On sort de la boucle après avoir affecté la valeur 51 à la variable i
  • 23. Le toit avec une pente à 26,565° i=0; rouge=couleurRGB(200,0,0); while (i<51){ dessineLigne(g,300+2*i,199-i,300+2*i,199,rouge); dessineLigne(g,300+2*i+1,199-i,300+2*i+1,199,rouge); dessineLigne(g,500-2*i,199-i,500-2*i,199,rouge); dessineLigne(g,500-2*i+1,199-i,500-2*i+1,199,rouge); i=i+1; } Traduction en pseudo-code : Algorithme DessineToit() Variables : entier i, couleur rouge Début i←0 rouge ← couleurRGB(200,0,0) Tant que i<51 faire : dessineLigne(300+2i,199-i,300+2i,199,rouge) dessineLigne(301+2i,199-i,301+2i,199,rouge) dessineLigne(500-2i,199-i,500-2i,199,rouge) dessineLigne(501-2i,199-i,501-2i,199,rouge) i ← i+1 Fin TantQue Fin
  • 24. Exercice 1 du TD2 • 42 en binaire : 101010 • 84 en binaire : 1010100 • Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne de caractères qui contient un nombre binaire n et s'il est pair, renvoie une chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui renvoie le nombre de caractères de la chaîne de caractères chaine. Longueur : Entrée : chaîne de caractères chaine
  • 25. Exercice 1 du TD2 • 42 en binaire : 101010 • 84 en binaire : 1010100 • Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne de caractères qui contient un nombre binaire n et s'il est pair, renvoie une chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui renvoie le nombre de caractères de la chaîne de caractères chaine. Longueur : Entrée : chaîne de caractères chaine Sortie : entier (nombre de caractères de chaine)
  • 26. Exercice 1 du TD2 • 42 en binaire : 101010 • 84 en binaire : 1010100 • Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne de caractères qui contient un nombre binaire n et s'il est pair, renvoie une chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui renvoie le nombre de caractères de la chaîne de caractères chaine. Longueur : Entrée : chaîne de caractères chaine Longueur(“101010”) Sortie : entier (nombre de caractères de chaine) 6
  • 27. Exercice 1 du TD2 • 42 en binaire : 101010 • 84 en binaire : 1010100 • Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne de caractères qui contient un nombre binaire n et s'il est pair, renvoie une chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui renvoie le nombre de caractères de la chaîne de caractères chaine. Longueur : Entrée : chaîne de caractères chaine Longueur(“101010”) Sortie : entier (nombre de caractères de chaine) 6 DiviseParDeuxPair : Entrée : chaîne de caractères chaine (qui code un entier n) Sortie : chaîne de caractères (n/2 en binaire)
  • 28. Exercice 1 du TD2 • 42 en binaire : 101010 • 84 en binaire : 1010100 • Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne de caractères qui contient un nombre binaire n et s'il est pair, renvoie une chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui renvoie le nombre de caractères de la chaîne de caractères chaine. Longueur : Entrée : chaîne de caractères chaine Longueur(“101010”) Sortie : entier (nombre de caractères de chaine) 6 DiviseParDeuxPair : Entrée : chaîne de caractères chaine (qui code un entier n) Sortie : chaîne de caractères (n/2 en binaire) DiviseParDeuxPair(“1010100”) SousChaine(“1010100”,2,3) “101010” “01”
  • 29. Exercice 1 du TD2 Principale instruction : • 42 en binaire : 101010 renvoyer SousChaine(chaine,1,Longueur(chaine)-1) • 84 en binaire : 1010100 • Déduisez-en un algorithme DiviseParDeuxPair qui prend en entrée une chaîne de caractères qui contient un nombre binaire n et s'il est pair, renvoie une chaîne de caractères qui contient la valeur de n/2 écrite en binaire. Vous utiliserez l'algorithme Caractère qui prend en entrée une chaîne de caractères chaine et un entier i et renvoie le i-ième caractère de chaine, ainsi que l'algorithme SousChaine qui renvoie la partie de la chaîne de caractères chaine allant du i-ième au j-ième caractère (inclus), et l'algorithme Longueur qui renvoie le nombre de caractères de la chaîne de caractères chaine. Longueur : Entrée : chaîne de caractères chaine Longueur(“101010”) Sortie : entier (nombre de caractères de chaine) 6 DiviseParDeuxPair : Entrée : chaîne de caractères chaine (qui code un entier n) Sortie : chaîne de caractères (n/2 en binaire) DiviseParDeuxPair(“1010100”) SousChaine(“1010100”,2,3) “101010” “01”
  • 30. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte.
  • 31. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” South Park S15E09 http://www.spscriptorium.com/Season15/E1509script.htm
  • 32. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” TrouveMot Entrées : chaîne de caractères mot, chaîne de caractères texte Sortie : entier (nombre de fois que mot apparaît dans texte) TrouveMot(“fuck”, “Nobody's fuckin' screaming, Craig! Wake the fuck up!”) renvoie l'entier 2
  • 33. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte • on teste si on trouve mot
  • 34. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte • on teste si on trouve mot la sous-chaine de texte qui commence au i-ième caractère et a autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ? reformulation du problème avec Caractères, SousChaine, Longueur
  • 35. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte • on teste si on trouve mot la sous-chaine de texte qui commence au i-ième caractère et a autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ? mot = SousChaine(texte,i,i+...) ? reformulation du problème avec Caractères, SousChaine, Longueur
  • 36. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte • on teste si on trouve mot la sous-chaine de texte qui commence au i-ième caractère et a autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ? mot = SousChaine(texte,i,i+3) ? reformulation du problème avec Caractères, SousChaine, Longueur
  • 37. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte • on teste si on trouve mot la sous-chaine de texte qui commence au i-ième caractère et a autant de lettres que mot, c'est-à-dire 4, est-elle égale à mot ? mot = SousChaine(texte,i,i+Longueur(mot)-1) ? reformulation du problème avec Caractères, SousChaine, Longueur
  • 38. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte appeler cette position i • on teste si on trouve mot la faire varier de 1 à ... mot = SousChaine(texte,i,i+Longueur(mot)-1) ? reformulation du problème avec Caractères, SousChaine, Longueur
  • 39. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte appeler cette position i i←1 • on teste si on trouve mot la faire varier de 1 à ... Tant que i<Longueur(texte)- Longueur(mot)+2 faire : ... mot = SousChaine(texte,i,i+Longueur(mot)-1) ? reformulation du problème avec Caractères, SousChaine, Longueur
  • 40. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Outils à disposition : SousChaine, Longueur, Caractère Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Idée : regarder à toutes les positions de la chaîne de caractères texte si on trouve le mot mot. Décomposition du problème : • à toutes les positions de texte i←1 • on teste si on trouve mot Tant que i<Longueur(texte)- Longueur(mot)+2 faire : ... mot = SousChaine(texte,i,i+Longueur(mot)-1) ? reformulation du problème avec Caractères, SousChaine, Longueur
  • 41. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” i←1 Tant que i<Longueur(texte)-Longueur(mot)+2 faire : mot = SousChaine(texte,i,i+Longueur(mot)-1) ?
  • 42. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entier i Début i←1 ... Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : ... i ← i+1 Fin TantQue ... Fin
  • 43. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entier i Début i←1 ... Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : ... i ← i+1 Fin TantQue ... Fin
  • 44. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entiers i, NombreTrouvé Début i←1 NombreTrouvé ← 0 Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : ... i ← i+1 Fin TantQue ... Fin
  • 45. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entiers i, NombreTrouvé Début i←1 NombreTrouvé ← 0 Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : NombreTrouvé ← NombreTrouvé+1 FinSi i ← i+1 Fin TantQue ... Fin
  • 46. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entiers i, NombreTrouvé Début i←1 NombreTrouvé ← 0 Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : NombreTrouvé ← NombreTrouvé+1 FinSi i ← i+1 Fin TantQue renvoyer NombreTrouvé Fin
  • 47. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entiers i, NombreTrouvé Début i←1 NombreTrouvé ← 0 Pourquoi cette condition d'arrêt ? Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : NombreTrouvé ← NombreTrouvé+1 FinSi i ← i+1 Fin TantQue renvoyer NombreTrouvé Fin
  • 48. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entiers i, NombreTrouvé Début i←1 NombreTrouvé ← 0 Pourquoi cette condition d'arrêt ? Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : NombreTrouvé ← NombreTrouvé+1 FinSi 123456 i ← i+1 mot = “ab” texte = “ccabab” Fin TantQue renvoyer NombreTrouvé Fin
  • 49. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entiers i, NombreTrouvé Début i←1 NombreTrouvé ← 0 Pourquoi cette condition d'arrêt ? Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : NombreTrouvé ← NombreTrouvé+1 FinSi 123456 i ← i+1 mot = “abc” texte = “ccabab” Fin TantQue renvoyer NombreTrouvé Fin
  • 50. Le nombre d'utilisations d'un mot dans un texte • Écrivez un algorithme TrouveMot qui prend en entrée une chaîne de caractères mot et une chaîne de caractères texte, et compte le nombre de fois que mot apparaît dans texte. Exemple : mot = “fuck” texte=“ Nobody's fuckin' screaming, Craig! Wake the fuck up! ” Algorithme TrouveMot : Entrées : chaîne de caractères mot, chaîne de caractères texte Sorties : nombre de fois (entier) que mot apparaît dans texte Variables : entiers i, NombreTrouvé Début i←1 NombreTrouvé ← 0 Pourquoi cette condition d'arrêt ? Tant que i<Longueur(texte)-Longueur(mot)+2 faire : Si mot = SousChaine(texte,i,i+Longueur(mot)-1) alors : Longueur(texte) NombreTrouvé ← NombreTrouvé+1 FinSi 123456 i ← i+1 mot = “abc” texte = “ccabab” Fin TantQue renvoyer NombreTrouvé Fin Longueur(texte)-Longueur(mot)+1 6 4