Des algorithmes

Comment Gérer vous présente différents algorithmes à découvrir, pour démarrer et s’en rappeler.

Après avoir vu l’article sur Mémo – Algorithmique, voici quelques algorithmes simples.

Vous trouverez des algorithmes avec affectation de variables.

Nous commencerons avec des algorithmes demandant à l’utilisateur d’entrer des données et d’afficher des résultats.

publicités

Et puis nous continuerons avec quelques algorithmes avec des conditions.

Nous verrons des algorithmes présentant l’utilisation du modulo et d’autres avec des boucles, des conditions et l’ensemble de ce que nous avons vu auparavant.

Certains de ces algorithmes seront présentés avec une ou plusieurs versions.

Voici le programme :

Echanges de deux variables
Lecture, calcul et affichage
Valeur absolue
Nombre divisible
Nombre divisible par trois
Calculer des photocopies
Premier entier supérieur à 100
Calcul puissance
Boucles imbriquées

1. Echanges de deux variables

Algorithme permettant d’échanger les variables de A et de B.

// Avec 3 variables
ALGORITHME EchangeDeuxVariables_1
VARIABLES A, B, C : entier
DEBUT
  A <- 1
  B <- 2

  C <- A
  A <- B
  B <- C
FIN

// Avec 2 variables
ALGORITHME EchangeDeuxVariables_2
VARIABLES A, B : entier
DEBUT
  A <- 1
  B <- 2

  A <- A + B
  B <- A - B
  A <- A - B
FIN

2. Lecture, calcul et affichage

Algorithme demandant un nombre entier à l’utilisateur, puis calcule et affiche le double de ce nombre.

// Version à deux variables
ALGORITHME CalculDouble_1
VARIABLES nombre, resultat : entier
DEBUT
  AFFICHER("Entrez un nombre :")
  LIRE(nombre)
  resultat <- nombre * 2
  // Rappel : & représente la concaténation.
  AFFICHER("Le double de "& nombre &" est : "& resultat)
FIN

// Version à une variable
ALGORITHME CalculDouble_2
VARIABLES nombre : entier
DEBUT
  AFFICHER("Entrez un nombre :")
  LIRE(nombre)
  AFFICHER(nombre * 2)
FIN

3. Valeur absolue

Algorithme qui affiche la valeur absolue d’un nombre.

La valeur absolue renvoie toujours un positif.

// Version avec SI
ALGORITHME ValeurAbsolue_1
VARIABLES nombre : reel
DEBUT
  AFFICHER("Entrez un nombre :")
  LIRE(nombre)
  SI nombre < 0 ALORS
    nombre <- |nombre|
  FINSI
  AFFICHER("La valeur absolue du nombre est "& nombre)
FIN

// Version avec SI... SINON
ALGORITHME ValeurAbsolue_2
VARIABLES nombre : reel
DEBUT
  AFFICHER("Entrez un nombre :")
  LIRE(nombre)
  SI nombre < 0 ALORS
    AFFICHER("La valeur absolue du nombre est "& -nombre)
  SINON
    AFFICHER("La valeur absolue du nombre est "& nombre)
  FINSI
FIN

4. Nombre divisible

Algorithme qui vérifie si deux nombres sont divisibles (le reste de la division = 0).

ALGORITHME NombreDivisible
VARIABLES x, y : entier
DEBUT
  AFFICHER("Entrez un premier nombre :")
  LIRE(x)
  AFFICHER("Entrez un second nombre :")
  LIRE(y)
  // Rappel : % représente le modulo.
  SI (x % y == 0)
    AFFICHER(x &" est divisible par "& y)
  SINON
    AFFICHER(x &" n'est pas divisible par "& y)
  FINSI
FIN

5. Nombre divisible par trois

Algorithme qui vérifie si un nombre est divisible par trois.

ALGORITHME NombreDivisiblePar3
VARIABLES x : entier
DEBUT
  AFFICHER("Entrez un premier nombre :")
  LIRE(x)
  AFFICHER(x)
  SI (x % 3 == 0)
    AFFICHER(x &" est divisible par 3.")
  SINON
    AFFICHER(x &" n'est pas divisible par 3.")
  FINSI
FIN

6. Calculer des photocopies

Algorithme qui calcule le coût selon le nombre effectué de photocopies, selon ces conditions :

0,5 € la copie pour un nombre inférieur à 10.
0,4 € pour un nombre de copies entre 10 et 20.
0,3 € au-delà.

ALGORITHME Photocopie
VARIABLES prixMoins10, prix10Et20, prix20Plus, resultat : reel
  nombrePhotocopies : entier
DEBUT
  prixMoins10 <- 0.5
  prix10Et20 <- 0.4
  prix20Plus <- 0.3
  AFFICHER("Nombre de photocopies :")
  LIRE(nombrePhotocopies)
  AFFICHER(nombrePhotocopies)
  SI ( (nombrePhotocopies >= 10) ET (nombrePhotocopies <= 20) )
    resultat <- nombrePhotocopies * prix10Et20
  SINON
    SI (nombrePhotocopies < 10) 
      resultat <- nombrePhotocopies * prixMoins10
    SINON
      resultat <- nombrePhotocopies * prix20Plus
    FINSI
  FINSI
  AFFICHER("Le total pour "& nombrePhotocopies &" photocopies est de "& resultat &" €.")
FIN

7. Premier entier supérieur à 100

Algorithme qui détermine le premier entier n tel que la somme de 1 à n dépasse strictement 100.

ALGORITHME PremierEntierSuperieurA100
VARIABLES n, somme : entier
DEBUT
  n <- 0
  somme <- 0
  TANTQUE (somme < 100)
    n <- n + 1
    somme <- n + somme
  FINTANTQUE
  AFFICHER("Le premier entier qui dépasse strictement 100 est "& n)
FIN

8. Calcul puissance

Algorithme qui calcule la puissance d’un nombre.

ALGORITHME CalculPuissance
VARIABLES n : entier, i : entier, x : reel, résultat : reel
DEBUT
  AFFICHER("Entrez un nombre")
  LIRE(x)
  TANTQUE (x == 0)
    AFFICHER("Entrez un réel non nul")
    LIRE(x)
  FINTANTQUE

  AFFICHER("Entrez la puissance")
  LIRE(n)
  TANTQUE (n <= 0)
    AFFICHER("Entrez un entier positif ou nul")
    LIRE(n)
  FINTANTQUE

  // Soit exemple avec une boucle pour
  POUR i allant de 1 à n PAR PAS DE 1
    SI (i == 1) ALORS
      resultat <- x
    SINON
      resultat <- x * resultat
    FINSI
  FINPOUR

  // Soit exemple avec une boucle tant que
  TANTQUE (i <= n)
    SI (i == 1) ALORS
      resultat <- x
    SINON
      resultat <- x * resultat
    FINSI
    i < i + 1
  FINTANQUE

  AFFICHER("Le résultat est "& resultat)
FIN

9. Boucles imbriquées

Un algorithme qui affiche ceci :

OX
OOX
OOOX
OOOOX
OOOOOX

ALGORITHME BouclesImbriquees
VARIABLES i, j : entier
DEBUT
  POUR i ALLANT DE 1 A 5
    POUR j ALLANT DE 1 A j
      AFFICHER("O")
    FINPOUR
    AFFICHER("X")
  FINPOUR
FIN

Crédit photo : By Crusher95 (Own work) [Coucou BY-SA 4.0], via Wikimedia Commons