J’ai croisé cette question sur un groupe de discussion et je trouve que c’est un bon algorithme à travailler ensemble. Commencez par chercher à y répondre par vous-même. Arrêtez là votre lecture, prenez une feuille et un stylo, et tentez de calculer la somme des entiers pairs et le produit des entiers impairs d’un tableau que l’on vous a donné en entrée.

Vous avez un algo ?

Si c’est trop dur du premier coup, n’hésitez pas à découper le problème en 2, calculer la somme des entiers paires, et ensuite, modifiez l’algo pour calculer aussi le produit des entiers impairs.

D’ailleurs, c’est ce que nous allons faire. 😊

 

Si vous souhaitez apprendre, je vous recommande de lire cet article pas à pas, en tentant à chaque fois de faire l’algorithme par vous-même. Autant vous ne pouvez pas deviner comment faire tant que vous ne l’avez pas déjà vu 1 ou 2 fois. Autant vous ne serez jamais autonome si vous ne cherchez pas au maximum à faire par vous-même dès que c’est possible ! Pratiquez, pratiquez, pratiquez !

N’oubliez pas ce vieil adage : « c’est en forgeant que l’on devient forgeron ! ».

Tous les codes indiqués dans cet article sont en pseudo-code. Je mettrais plus tard un exemple en Java et/ou dans le langage de votre choix.

 

Calcul de la somme des entiers pairs

 

Imaginons que nous ayons un tableau nommé « nombresEntiers » dont nous connaissons la taille « tailleNombresEntiers ».

Comment calculer cette somme ?

De manière logique, sans entrer dans le verbiage informatique, nous devons :

• Consulter chaque nombre un par un
• Reconnaitre s’il s’agit d’un nombre pair ou d’un nombre impair
• S’il s’agit d’un nombre pair, je l’ajoute à la somme des nombres pairs que je calcule petit à petit (imaginez une feuille où je somme petit à petit tous les nombres pairs que je rencontre).
• Une fois tous les nombres analysés, nous avons la somme, il suffit de l’afficher.

Pour convertir cela sous forme informatique, voici ce que je dois faire :

1)     Consulter tous les nombres un par un.

Il nous faut itérer sur le tableau avec une boucle Pour.
Notez bien que toutes les boucles peuvent faire l’affaire ! Les boucles Pour, Repeter, Faire… Repeter sont toutes équivalentes à quelques différences près. En tout cas il est toujours possible de passer de l’une à l’autre. Nous utilisons Pour dans ce cas, car c’est la boucle la plus adaptée au parcours de tableau. Toutes les informations sont réunies sur la première ligne, c’est plus lisible, tout le monde utilise Pour pour un parcours de tableau.

Pour(int i = 0 ; i< tailleNombresEntiers ; i++) faire
    // Votre code ici
FinPour

Pour information, voici les correspondances entre les boucles en pseudo-code français et les boucles en informatique :

• Pour : for
• Repeter : while
• Faire … repeter : do … while

 

2)     Comment reconnaître un nombre pair ?

Pour cela nous allons utiliser l’opération modulo.
Le modulo nous donne le reste de la division entière entre deux nombres (lien wikipedia). C’est une très bonne technique pour identifier des cycles. Ici nous cherchons les nombres pairs, donc tous ceux qui sont divisibles par 2. Ces nombres auront donc un reste de 0.

Quelques exemples pour vous en convaincre :

• 6 modulo 2 = 0 : quand on divise 6 par 2 en division entière, il reste rien à diviser, car 6 est directement divisible par 2 (cela donne un quotient de 3) : attention, module est le reste de la division entière, pas le résultat ! C’est uniquement ce qu’il reste, qui n’a pas pu être divisé.
• 7 modulo 2 = 1 : quand je divise 7 par 2 en division entière il me reste 1, car 7 n’est pas directement divisible par 2 en division entière. C’est 6 qui l’est. Il reste donc 1 qui correspond à l’écart entre 7 et 6.
• 12 modulo 2 = 0
• 17 modulo 2 = 1

Vous pouvez explorer la fonction modulo par vous-même en utilisant la calculatrice intégrée de Google : https://www.google.com/search?q=7+modulo+2

Pour mieux comprendre l’immense intérêt des modulos pour identifier des cycles en informatique, testez des modulos par 5, par 7, par 8 … :

• 7 modulo 5 = 2
• 8 modulo 5 = 3
• 9 modulo 5 = 4
• 10 modulo 5 = 0

Vous êtes maintenant capable d’identifier des cycles de 5, ou des cycles de toute autre nature 😊.

Nous savons identifier les nombres pairs, il nous reste à le faire dans un test pour conditionner le code permettant de les sommer :

    Si (nombresEntiers[i] modulo 2 == 0) Alors
        // votre code ici
    FinSi

Testez ce code avec un affichage, vous verrez qu’il n’affiche que les nombres pairs. 😊

 

3)     Sommer les nombres pairs

Nous savons parcourir le tableau et identifier tous les cas de nombres pairs pour exécuter du code spécifique seulement dans ces cas-là.

Quel code pouvons-nous mettre pour calculer la somme ?

En informatique nous procédons comme dans la vraie vie. Nous commençons par faire la somme entre les deux premiers, puis entre le résultat et le nombre suivant, et ainsi de suite jusqu’au dernier nombre à ajouter. Ensuite, nous faisons cela petit à petit en même temps que la boucle parcourt le tableau et identifie des nombres pairs.

Ajoutez une variable « sommeDesNombresPairs » juste avant la boucle, et l’initialiser à 0 . Oui, au début, je n’ai sommé aucun nombre pair, donc la somme vaut 0.

Ensuite, à chaque tour de boucle, quand j’ai identifié un nombre pair, je peux simplement faire la somme entre ce nombre et ma variable sommeDesNombresPairs et je stocke le résultat dans cette même variable. Le code pour faire cela est tout simple :

    sommeDesNombresPairs = nombresEntiers[i]  + sommeDesNombresPairs ;

Cela donne le code complet suivant :

Pour(int i = 0 ; i< tailleNombresEntiers ; i++) faire
    Si (nombresEntiers[i] modulo 2 == 0) Alors
        sommeDesNombresPairs = nombresEntiers[i]  + sommeDesNombresPairs;
    FinSi
FinPour

 

4)     À la fin, afficher.

Il s’agit de la partie la plus simple, tout le travail a déjà été fait en cumulant petit à petit la somme des entiers pairs dans sommeDesNombresPairs ! 😊

Il suffit maintenant de l’afficher juste après la fermeture de la boucle :

Afficher(sommeDesNombresPairs) ;

 

Calcul du produit des entiers impairs

 

Stoppez là votre lecture ! Tentez de le faire par vous-même, nous avons déjà vu tout ce qui vous permettait de répondre à cette question. Car au final, qu’est-ce qui différencie cette question de la précédente ?

• Il faut identifier les nombres impairs.
• Il faut en faire le produit.

Vous avez déjà les briques vous permettant de répondre à ces questions. Allez-y, lancez-vous !

Toujours des questions ?

Voici un peu d’aide :

1)     Identifier les nombres impairs

Pour cela, il suffit d’ajouter un test portant toujours sur le modulo. Au lieu de tester si le reste de la division entière par 2 est de 0, vous allez tester s’il est de 1. En effet, tous les nombres impairs auront un reste de division entière de 1.

Voici le code :

    Si (nombresEntiers[i] modulo 2 == 1) Alors
        // le code ici
    FinSi

Notez que vu que les entiers sont soit pairs soit impairs, nous pourrions très bien ajouter une clause sinon sur le test des cas pairs.

 

 

2)     Calculer le produit des nombres impairs

Surtout ne pas toucher à la variable que nous avions créée. Il faut en faire une autre dans laquelle nous allons progressivement calculer le produit.

Appelons la produitDesNombresImpairs.

Le calcul, de manière similaire, va être de faire la multiplication entre le nombre impair trouvé et produitDesNombresImpairs. Ensuite, stocker le résultat de cette multiplication dans produitDesNombresImpairs lui-même pour en tenir compte par la suite.

Voici le pseudo-code :

produitDesNombresImpairs =  nombresEntiers[i] * produitDesNombresImpairs;

 

En conclusion

Nous avons vu quelques points récurrents des algorithmes. La fonction modulo pour identifier les cycles et le calcul progressif d’une somme ou d’un produit en utilisant une variable créée pour l’occasion.

J’espère que cet article vous aide à découvrir la programmation et à comprendre comment créer un algorithme. N’hésitez pas à le partager s’il peut être utile à d’autres personnes.

Si vous voulez que je mette ce code dans un langage particulier, indiquez-le-moi dans les commentaires.