Haskell : Fonction PPCM

Exercices Corriges en Haskell : Fonction  PPCM

Exercice corriges Programmation Fonctionnelle (Haskell)

Écrire une fonction en Haskell permettant de déterminer le PPCM de 2 entiers positifs pris en paramètre.

Haskell pandacodeur

Correction :


ppcm :: Integral a => a -> a -> a
ppcm a b = (a * b) `div` (gcd a b)

 

Explications :

Cette méthode utilise la formule suivante : PPCM(a, b) = (a * b) / PGCD(a, b). Nous utilisons la fonction gcd pour calculer le PGCD de a et b, puis nous utilisons l'opérateur div pour diviser le produit a * b par le PGCD. Cette formule est dérivée du fait que tout nombre entier est un multiple du PPCM de deux nombres si et seulement si il est un multiple commun de ces deux nombres. De même, tout nombre entier qui est un multiple commun de deux nombres est un multiple de leur PGCD. Ainsi, si nous multiplions les deux nombres et les divisons par leur PGCD, le résultat est le PPCM.

Autre Solution :

Voici une autre façon d'implémenter la fonction ppcm en Haskell en utilisant une fonction récursive qui calcule toutes les diviseurs communs de a et b :


ppcm :: Integral a => a -> a -> a
ppcm a b = head [i | i <- [(max a b)..], i `mod` a == 0 && i `mod` b == 0]

 

Explications :

Cette méthode utilise une compréhension de liste pour générer une liste d'entiers à partir du plus grand des deux nombres jusqu'à l'infini. Nous utilisons ensuite la fonction mod pour vérifier si chaque élément de la liste est divisible par a et b. La première valeur qui satisfait ces conditions est le PPCM, que nous récupérons avec la fonction head.

La deuxième méthode utilise une méthode de recherche pour trouver le PPCM. Nous générons une liste infinie d'entiers à partir du plus grand des deux nombres et nous vérifions chaque nombre de la liste s'il est divisible par a et b. Cette méthode est moins efficace que la première méthode, car elle doit vérifier chaque nombre de la liste jusqu'à trouver le PPCM.

 

.

 

Autre Solution :

Voici une autre façon d'implémenter la fonction ppcm en Haskell en utilisant une fonction récursive qui calcule toutes les diviseurs communs de a et b :


ppcm :: Integral a => a -> a -> a
ppcm a b = foldr1 lcm [a, b]

 

Explications :

Cette méthode utilise la fonction foldr1 pour appliquer la fonction lcm (le PPCM de deux nombres) à chaque élément d'une liste de deux éléments (a et b dans notre cas). La fonction foldr1 prend le dernier élément de la liste comme premier argument de la fonction lcm, puis applique cette fonction à chaque élément de la liste en partant de la droite. Le résultat final est le PPCM. La troisième méthode utilise la fonction foldr1 pour appliquer la fonction lcm (le PPCM de deux nombres) à chaque élément d'une liste de deux éléments (a et b dans notre cas). La fonction foldr1 prend le dernier élément de la liste comme premier argument de la fonction lcm, puis applique cette fonction à chaque élément de la liste en partant de la droite. Le résultat final est le PPCM. Cette méthode est plus concise que les deux précédentes, mais peut être moins claire.

Les fonctions lcm et gcd sont des fonctions mathématiques courantes qui permettent de calculer respectivement le plus petit commun multiple et le plus grand commun diviseur de deux nombres entiers. Ces fonctions sont présentes dans de nombreux langages de programmation, y compris Haskell.

La fonction lcm (pour least common multiple) retourne le plus petit nombre entier qui est un multiple commun de deux nombres donnés. La fonction gcd (pour greatest common divisor) retourne le plus grand diviseur commun à deux nombres donnés.

En Haskell, ces fonctions sont implémentées dans le module Data.List. Voici un exemple d'utilisation de ces fonctions :

import Data.List (lcm, gcd)

-- Calcul du ppcm de deux nombres

ppcm x y = lcm x y

-- Calcul du pgcd de deux nombres

pgcd x y = gcd x y

Dans cet exemple, la fonction ppcm utilise la fonction lcm pour calculer le ppcm de deux nombres, et la fonction pgcd utilise la fonction gcd pour calculer le pgcd de deux nombres.

Il est également possible d'implémenter ces fonctions de manière récursive. Voici un exemple d'implémentation récursive de la fonction gcd :

gcd' :: Int -> Int -> Int

gcd' a b

          | b == 0 = abs a

         | otherwise = gcd' b (a `mod` b)

Dans cette implémentation, la fonction est récursive et utilise l'algorithme d'Euclide pour calculer le pgcd de deux nombres entiers. L'algorithme d'Euclide consiste à répéter la division euclidienne du plus grand nombre par le plus petit nombre, jusqu'à ce que le reste soit égal à zéro. Le dernier diviseur non nul est alors le pgcd des deux nombres.

Il est important de noter que la fonction gcd implémentée de cette manière peut également être utilisée pour calculer le pgcd de plusieurs nombres, en appelant récursivement la fonction avec les nombres successifs.

Si vous avez trouvé les exercices corrigés en Haskell de JoëlYk intéressants et utiles, pourquoi ne pas les partager avec d'autres personnes qui pourraient également en bénéficier ? Partagez ce lien sur les réseaux sociaux ou envoyez-le à vos amis et collègues. Vous pourriez aider quelqu'un à améliorer ses compétences en programmation ou à trouver des solutions à des problèmes complexes. N'oubliez pas que la connaissance doit être partagée pour grandir. Merci pour votre soutien et votre partage !

Contact WhatsApp : +237 658395978 | Réaliser Par Joël_Yk

  • Aucune note. Soyez le premier à attribuer une note !

Ajouter un commentaire

Anti-spam