Dans cet algorithme, nous avons utilisé le mot « Écrire » pour afficher la chaîne de caractères Hello, world! sur notre écran. Voici l’organigramme de cet algorithme:

Cet algorithme invite l’utilisateur à saisir deux nombres, les additionne, puis affiche le résultat. Voici l’organigramme de cet algorithme:

Cet algorithme déclare d’abord trois variables n1, n2 et tmp, puis demande à l’utilisateur de saisir deux nombres entiers. Ensuite, il utilise une variable temporaire tmp pour échanger les valeurs de n1 et n2, et enfin affiche les valeurs échangées. Voici l’organigramme de cet algorithme:

Nous commençons par déclarer les variables que nous utiliserons dans l’algorithme. Nous avons besoin de trois variables : nbr, f et i. Nous les déclarons comme des entiers en utilisant le symbole deux points (:).

Ensuite, nous demandons à l’utilisateur d’entrer la valeur de nbr à l’aide des instructions Ecrire et Lire. Nous écrivons un message invitant l’utilisateur à saisir un entier nbr, puis nous lisons la valeur saisie par l’utilisateur et la stockons dans la variable nbr.

Ensuite, nous initialisons la variable f à 1. Cette variable stockera la factorielle de nbr au fur et à mesure que nous la calculerons dans la boucle. Nous utilisons le signe (←) pour attribuer une valeur à une variable.

Ensuite, nous utilisons une boucle pour itérer de 1 à nbr et multiplier f par i à chaque itération. La boucle a une valeur de départ, une valeur d’arrivée et une valeur d’incrémentation. Dans ce cas, nous commençons à 1, nous terminons à nbr et nous incrémentons de 1. Nous utilisons le mot-clé ‘POUR’ pour commencer la boucle et le mot-clé ‘FinPour’ pour la terminer. Nous utilisons également l’indentation pour montrer le corps de la boucle. À chaque itération, nous mettons à jour la valeur de f en la multipliant par i à l’aide du symbole de l’astérisque (*). De cette façon, nous calculons la factorielle de nbr comme le produit de tous les entiers de 1 à nbr.

Enfin, nous affichons la factorielle de nbr à l’aide de l’instruction Écrire. Nous écrivons un message qui indique la valeur de nbr et sa factorielle séparées par des virgules. Voici l’organigramme de cet algorithme:

Si un nombre est divisible par 2 sans reste, il est pair. Vous pouvez calculer le reste à l’aide de l’opérateur modulo « mod », comme ceci nbr mod 2 = 0. Si un nombre divisé par 2 laisse un reste de 1, le nombre est impair. Vous pouvez le vérifier en utilisant nbr mod 2 = 1. Voici l’organigramme de cet algorithme:

Voici l’organigramme de cet algorithme:

L’algorithme demande à l’utilisateur un nombre de 1 à 5 jusqu’à ce que la réponse est correct.

Voici l’organigramme de cet algorithme:

La formule pour trouver la moyenne de nombres ou de valeurs donnés est très simple. Il suffit d’additionner tous les nombres et de diviser le résultat par le nombre de valeurs données. La formule pour calculer la moyenne est donc la suivante:

Moyenne = Total/Nombre

Ici, nous utilisons 3 nombres, donc pour calculer la moyenne, nous devons additionner les 3 nombres et les diviser par 3.

Dans cet algorithme, la boucle TantQue continuera à s'exécuter tant que la variable n est inférieure ou égale à 10. À l'intérieur de la boucle, le texte est affiché, puis la variable n est incrémentée de 1 jusqu'à ce que la condition ne soit plus remplie. Voici l'organigramme de cet algorithme:

Dans la boucle TantQue ci-dessus, la variable i est initialisée à 1 et la boucle se poursuit tant que i est inférieur ou égal à 10. À chaque itération de la boucle, la variable sum s'additionne à la valeur de i.

Enfin, la boucle incrémente la valeur de i de 1, et le processus se répète jusqu'à ce que la condition i <= 10 ne soit plus vraie. Dans ce cas on affiche le message "La somme de 1 à 10 est: sum".

La boucle TantQue est itérée n fois. À chaque itération, la valeur de i est ajoutée à la somme sum et i est incrémenté de 1.

Dans cet algorithme, la boucle POUR continuera à s'exécuter tant que la variable n est inférieure ou égale à 10. À l'intérieur de la boucle, le texte est affiché, puis la variable n est incrémentée de 1 jusqu'à ce que la condition ne soit plus remplie. Voici l'organigramme de cet algorithme:

Dans la boucle POUR ci-dessus, la variable i est initialisée à 1 et la boucle se poursuit tant que i est inférieur ou égal à 10. À chaque itération de la boucle, la variable sum s'additionne à la valeur de i.

La boucle POUR est itérée n fois. À chaque itération, la valeur de i est ajoutée à la somme sum et i est incrémenté de 1.

Nous utilisons la boucle POUR pour afficher la table de multiplication de 3. La boucle s'exécute de i = 1 à i = 10. À chaque itération de la boucle, i * 3 est affiché.

Nous utilisons la boucle POUR pour afficher la table de multiplication de n. La boucle s'exécute de i = 1 à i = 10. À chaque itération de la boucle, i * n est affiché.

La principale différence entre la boucle "TantQue" et "Répéter Jusqu’à" est que dans la boucle Répéter Jusqu’à", la boucle s'exécute une fois avant même de vérifier la condition, alors que dans une boucle "TantQue", la boucle s'exécute si la condition est vraie.

L'algorithme ci-dessus invite l'utilisateur à saisir 10 entiers dans un tableau nommé myTab, puis affiche les éléments du tableau.

La première boucle POUR demande à l'utilisateur de saisir 10 éléments dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 10, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau myTab[i].

La deuxième boucle POUR affiche ensuite le contenu du tableau, qui parcourt les éléments de myTab et affiche chaque élément à l'aide de Ecrire().

L'algorithme demande à l'utilisateur de saisir 10 notes dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 10, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau Notes[i].

Ensuite, à chaque itération de la boucle, la somme de chaque élément saisi est calculée. Une fois la boucle POUR terminée, la moyenne est calculée et affichée à l'écran à l'aide de Ecrire().

Dans cet algorithme nous avons créer une variable max et l'initier à myTab[0] pour stocker le maximum dans le tableau.

Itérer sur le tableau

• Comparer myTab[i] avec max.
• Si myTab[i] > max, mettre à jour max ← myTab[i].

Une fois l'itération terminée, renvoyer max comme réponse.

Pour compter le nombre d'occurrences d'une valeur spécifique dans un tableau, nous pouvons utiliser une simple boucle POUR tout en recherchant notre valeur cible. Si la valeur cible est trouvée, nous incrémentons la variable nbrOcc. Nous procédons de cette façon jusqu'à ce que l'ensemble du tableau soit parcouru.

Approche:

• Initialiser la variable nbrOcc à zéro.
• On parcourt le tableau et on vérifie si l'élément courant(myTab[i]) correspond à la valeur cible(nbrRech).
• Si c'est le cas, nbrOcc est incrémenté de 1.
• Dans le cas contraire, passer à l'itération suivante.
• Répétez le processus jusqu'à ce que tous les éléments du tableau aient été vérifiés.
• Enfin, retourner nbrOcc.

L'algorithme ci-dessus invite l'utilisateur à saisir 10 nombres dans un tableau nommé myTab, puis affiche les éléments triés du tableau.

La première boucle POUR demande à l'utilisateur de saisir 10 éléments dans le tableau, et la boucle POUR s'exécute de 1 jusqu'à 10, invitant l'utilisateur à saisir chaque élément à l'aide de lire(), et stockant chaque entrée dans l'index correspondant du tableau myTab[i].

La deuxième boucle POUR parcourt le tableau myTab et permute les éléments du tableau(permute deux éléments aux positions i et j) en utilisant une variable temporaire pour contenir l'une des valeurs pendant la permutation. L'algorithme parcourt le tableau répétitivement, compare chaque paire d'éléments adjacents et les échange si nécessaire. Après le premier passage, l'élément le plus grand est placé à la fin du tableau.

1. Dans l'algorithme de tri à bulle, nous comparons les deux premiers éléments d'un tableau et les permutons si nécessaire.
2. Si nous voulons trier les éléments d'un tableau dans l'ordre croissant et si le premier élément est plus grand que le second, nous devons permuter les éléments.
3. Si le premier élément est plus petit que le second, il n'est pas nécessaire de permuter les éléments. Ce processus se poursuit jusqu'à ce que le dernier et l'avant-dernier élément soient comparés et permutés.

La troisième boucle POUR affiche ensuite le tableau trié, qui parcourt les éléments de myTab et affiche chaque élément à l'aide de Ecrire().

Description pas à pas de la logique permettant d'afficher tous les nombres pairs compris entre 1 et n à en utilisant l'instruction "Si":

• L'utilisateur doit saisir la limite supérieure des nombres pairs. Stockez-la dans la variable N.
• Exécutez la boucle "POUR" à partir de 1, jusqu'à N.
• À l'intérieur du corps de la boucle, vérifiez la condition pair/impair. Si le nombre actuel i est divisible par 2, alors i est pair. Autrement dit, Si(i mod 2 = 0), la valeur de i est affichée.

Dans cet algorithme:

• L'utilisateur doit saisir la limite supérieure des nombres impairs. Stockez-la dans la variable N.
• Exécutez la boucle "POUR" à partir de 1, jusqu'à N.
• À l'intérieur du corps de la boucle, vérifiez la condition pair/impair. Si le nombre actuel i n'est pas divisible par 2, alors i est impair. Autrement dit, Si(i mod 2 ≠ 0), nous ajoutons le nombre actuel i à la variable sum.
• Enfin nous affichons la somme des nombres impairs.

Dans ce programme, deux nombres entiers entrés par l'utilisateur sont stockés dans les variables n1 et n2. Ensuite, la boucle TantQue est itérée jusqu'à ce que i soit inférieur à n1 et n2.

A chaque itération, si n1 et n2 sont exactement divisibles par i, la valeur de i est affectée à la variable "pgcd".

Lorsque la boucle TantQue est terminée, le plus grand diviseur commun de deux nombres est stocké dans la variable "pgcd".

Le programme invite l'utilisateur à saisir un nombre à l'aide de la fonction Ecrire() et stocke la valeur dans la variable "N" à l'aide de la fonction Lire(). La boucle POUR est ensuite utilisée pour exécuter le code à l'intérieur de la boucle le nombre de fois spécifié par l'utilisateur. La boucle POUR commence avec "i" initialisé à 1, et la boucle continue jusqu'à ce que "i" soit inférieur ou égal à "N".

La deuxième boucle POUR est imbriquée dans la première boucle POUR et est utilisée pour exécuter de manière répétée le code à l'intérieur de la boucle pendant le nombre de fois spécifié par l'utilisateur. La boucle POUR commence avec "j" initialisé à 1, et la boucle continue jusqu'à ce que "j" soit inférieur ou égal à "i".

La fonction Ecrire() à l'intérieur de la boucle imbriquée est utilisée pour afficher le nombre actuelle (i) à l'écran à chaque fois que la boucle est exécutée. Les valeurs de "i" et "j" sont incrémentées de 1 à chaque itération des boucles, de sorte que les boucles se terminent finalement lorsque "i" et "j" atteignent la valeur de "N".

L'algorithme divise le nombre saisi par l'utilisateur par 10 dans la boucle TantQue jusqu'à ce que le résultat atteigne zéro. Le nombre d'itérations correspondra au nombre de chiffres.

L'entier saisi par l'utilisateur est stocké dans la variable Nbr. Ensuite, la boucle TantQue est itérée jusqu'à ce que la condition (Nbr div 10 ≠ 0) soit évaluée à 0 (False).

• Après la première itération, la valeur de Nbr est de 987 et le compteur est incrémenté à 1.
• Après la deuxième itération, la valeur de Nbr sera de 98 et le compteur sera incrémenté à 2.
• Après la troisième itération, la valeur de Nbr sera de 9 et le compteur sera incrémenté à 3.
• Après la quatrième itération, la valeur de Nbr sera 0 et le compteur sera incrémenté à 4.
• La condition de la boucle est alors évaluée à false et la boucle se termine.