Plus petit commun multiple de 3 ou plus nombre

Comment calculer le plus petit commun multiple de plusieurs numéros?

Jusqu'à présent, j'ai seulement été en mesure de calculer entre deux nombres. Mais n'ai aucune idée de comment la développer pour calculer les 3 chiffres ou plus.

Jusqu'à présent c'est la façon dont je l'ai fait

LCM = num1 * num2 / gcd ( num1 , num2 )

Avec pgcd est la fonction pour calculer le plus grand diviseur commun des nombres. Utilisant l'algorithme d'euclide

Mais je ne peux pas comprendre comment le calculer pour 3 numéros ou plus.

s'il vous plaît ne pas appeler cela comme devoirs. J'essaie de trouver un moyen d'ajustement de multiples morceaux de feuilles de métal sur une plaque et ont besoin de trouver un moyen d'ajustement de longueur différente en métal sur la même plaque. PPCM et PGCD est le meilleur moyen pour ce faire. Je suis un programmeur ne sont pas des mathématiques gars. C'est pourquoi j'ai demandé.
Installer des petites feuilles dans une grande feuille -- 2D bin packing ?
Tetris?

InformationsquelleAutor paan | 2008-09-29

171

Vous pouvez calculer le PPCM de plus de deux numéros par itérative de calcul du PPCM de deux nombres, c'est à dire
```
lcm(a,b,c) = lcm(a,lcm(b,c))
```
- Ooooh manuel de récursivité 🙂
- un algorithme récursif définition ne signifie pas nécessairement un sous-programme récursif. Vous pouvez implémenter cela dans une boucle assez simplement. Merci pour la réponse parfaite.
InformationsquelleAutor A. Rex
143

En Python (modifié primes.py):
```
def gcd(a, b):
    """Return greatest common divisor using Euclid's Algorithm."""
    while b:      
        a, b = b, a % b
    return a

def lcm(a, b):
    """Return lowest common multiple."""
    return a * b //gcd(a, b)

def lcmm(*args):
    """Return lcm of args."""   
    return reduce(lcm, args)
```
Utilisation:
```
>>> lcmm(100, 23, 98)
112700
>>> lcmm(*range(1, 20))
232792560
```
reduce() fonctionne quelque chose comme que:
```
>>> f = lambda a,b: "f(%s,%s)" % (a,b)
>>> print reduce(f, "abcd")
f(f(f(a,b),c),d)
```
- Je ne suis pas familier avec python, ce n'réduire() faire?
- Étant donné une fonction f et une liste l = [a,b,c,d], de réduire(f,l) renvoie f(f(f(a,b),c),d). C'est la fonctionnelle de la mise en œuvre de "lcm peut être calculée par la manière itérative le calcul du ppcm de la valeur actuelle et l'élément suivant de la liste."
- +1 pour une solution qui peut s'adapter à plus de trois paramètres
- pouvez-vous faire de la lcm, la fonction se comporte comme le gcvm fonction par la réduction de lui-même? Ma première pensée est pour lui faire faire le lcm() quand il y a 2 arguments, et ne la réduire() quand il y a plus.
- En voici un: enrico-franchi.org/2010/09/nice-functional-lcm-in-python.html
- est déjà cette fonction. Il fonctionne pour tous les len(args) > 0 y compris len(arg) == 2.
- gcvm ne fonctionne pas sans lcm
- Un petit détail: vous pouvez faire lcmm de travail pour un nombre quelconque d'arguments, juste l'ajout de l'identité de l'élément à gauche pli: reduce(lcm, args, 1).
- Vous pouvez également utiliser la intégré dans la mise en œuvre de gcd au lieu de votre propre mise en œuvre.
- n'est disponible que depuis la version 2.6 de Python (la réponse a été écrit avant la sortie), mais il n'a pas d'importance parce que la question n'a pas de python de la balise; par conséquent, la réponse doit être rédigée de manière à être utile pour les personnes qui ne sont pas familiers avec Python c'est à dire, le Python est utilisé comme un exécutable pseudo-code ici (je comprends que l'utilisation de reduce() quelque peu contredit-il. J'espère que l'exemple à la fin clarifie ce qu'il fait).
- J'ai réalisé que la réponse était vieux, mais je ne savais pas que c'précédé la libération de 2,6 en deux jours. J'ai toujours l'impression que le commentaire est pertinent pour les personnes qui trébuchent sur cette réponse maintenant. Cela apparaît fortement dans Google. Notez que je n'ai upvote votre réponse afin de ne pas prendre le commentaire comme trop critique.
- J'ai eu ce travail en ajoutant *args au lieu d'arguments pour gcvm fonction.
- vous devriez vraiment lire la réponse et les commentaires par exemple, ce commentaire. C'est la deuxième fois aujourd'hui. Évidemment, le code fonctionne en Python. Il fonctionne en Python 2—la seule version disponible à l'époque.
- Ce qui ne les virgules ne sur la ligne 4? Je ne suis pas familier avec eux comme des opérateurs et, après une brève recherche sur google, je ne pouvais pas trouver quoi que ce soit.
- virgule crée un tuple en Python. Dans ce cas, c'est équivalent à: t = a; a = b; b = t % b
- Ahhh, ok, je pensais à un n-uplet a dû être à l'intérieur de la parenthèse. Merci
- +1 pour l'utilisation de reduce, je n'avais jamais vu avant aujourd'hui! Mais je me demande si elle n'est pas obsolète maintenant? Il a été un long moment...
- hehe vous êtes à la résolution de la droite d'euler prblem projecteuler.net/problem=5, gentil 😀
- primes.py comprend déjà def LCM(terms): "Return lcm of a list of numbers." Ajouté à primes.py le Mar 30, 2000.
InformationsquelleAutor jfs

Voici un ECMA-mise en œuvre de style:

function gcd(a, b){
    //Euclidean algorithm
    var t;
    while (b != 0){
        t = b;
        b = a % b;
        a = t;
    }
    return a;
}

function lcm(a, b){
    return (a * b /gcd(a, b));
}

function lcmm(args){
    //Recursively iterate through pairs of arguments
    //i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

    if(args.length == 2){
        return lcm(args[0], args[1]);
    } else {
        var arg0 = args[0];
        args.shift();
        return lcm(arg0, lcmm(args));
    }
}

Il se sent mal que je ne comprends pas ce que tu veux dire par "ECMA-" style =/
en.wikipedia.org/wiki/ECMAScript

InformationsquelleAutor T3db0t

13

Je voudrais aller avec celui-ci (C#):
```
static long LCM(long[] numbers)
{
    return numbers.Aggregate(lcm);
}
static long lcm(long a, long b)
{
    return Math.Abs(a * b) /GCD(a, b);
}
static long GCD(long a, long b)
{
    return b == 0 ? a : GCD(b, a % b);
}
```
Juste quelques précisions, parce que, à première vue, il n'a pas de coutures de manière claire ce que ce code est en train de faire:

Globale est une Extension Linq méthode, de sorte que vous ne pouvez pas oublier d'ajouter à l'aide du Système.Linq to vos références.

Globale obtient une accumulation de fonction de sorte que nous pouvons faire usage de la propriété ppcm(a,b,c) = ppcm(a,ppcm(b,c)) sur un IEnumerable. De plus sur le total des

PGCD de calcul rend l'utilisation de la Algorithme d'euclide.

lcm calcul utilise Abs(a*b)/pgcd(a,b) , reportez-vous à Réduction par le plus grand diviseur commun.

Espère que cette aide,

InformationsquelleAutor Rodrigo López
6

J'ai juste pensé que c'en Haskell:
```
lcm' :: Integral a => a -> a -> a
lcm' a b = a`div`(gcd a b) * b
lcm :: Integral a => [a] -> a
lcm (n:ns) = foldr lcm' n ns
```
J'ai même pris le temps d'écrire mon propre gcd fonction, seulement pour trouver qu'il en Prélude! Beaucoup d'apprentissage pour moi aujourd'hui 😀
- Vous pouvez utiliser foldr1 pour la dernière ligne: lcm ns = foldr1 lcm' ns ou lcm = foldr1 lcm'
- Vous pouvez également renoncer à la signature type, pour un vraiment minime résultat, comme Integral est implicite par div
InformationsquelleAutor Matt Ellen

Du code Python qui n'exige pas une fonction gcd:

from sys import argv 

def lcm(x,y):
    tmp=x
    while (tmp%y)!=0:
        tmp+=x
    return tmp

def lcmm(*args):
    return reduce(lcm,args)

args=map(int,argv[1:])
print lcmm(*args)

Voici à quoi il ressemble dans le terminal:

$ python lcm.py 10 15 17
510

InformationsquelleAutor Eratosthenes

5

Ici est un Python one-liner (non compris les importations) pour retourner le PPCM des entiers de 1 à 20 inclusivement:

Python 3.5+ importations:
```
from functools import reduce
from math import gcd
```
Python 2.7 importations:
```
from fractions import gcd
```
Logique commune:
```
lcm = reduce(lambda x,y: x*y//gcd(x, y), range(1, 21))
```
Noter que dans les deux Python 2 et Python 3, la priorité de l'opérateur règles exigent que la * et // les opérateurs ont la même priorité, et si elles s'appliquent à partir de la gauche vers la droite. En tant que tel, x*y//z signifie (x*y)//z et pas x*(y//z). Les deux produisent généralement des résultats différents. Ce ne serait pas compté autant de flotteur de la division, mais il le fait pour étage de la division.

InformationsquelleAutor Acumenus

Ici est un C# port de Virgile Disgr4ce de la mise en oeuvre:

public class MathUtils
{
    ///<summary>
    ///Calculates the least common multiple of 2+ numbers.
    ///</summary>
    ///<remarks>
    ///Uses recursion based on lcm(a,b,c) = lcm(a,lcm(b,c)).
    ///Ported from http://stackoverflow.com/a/2641293/420175.
    ///</remarks>
    public static Int64 LCM(IList<Int64> numbers)
    {
        if (numbers.Count < 2)
            throw new ArgumentException("you must pass two or more numbers");
        return LCM(numbers, 0);
    }

    public static Int64 LCM(params Int64[] numbers)
    {
        return LCM((IList<Int64>)numbers);
    }

    private static Int64 LCM(IList<Int64> numbers, int i)
    {
        //Recursively iterate through pairs of arguments
        //i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

        if (i + 2 == numbers.Count)
        {
            return LCM(numbers[i], numbers[i+1]);
        }
        else
        {
            return LCM(numbers[i], LCM(numbers, i+1));
        }
    }

    public static Int64 LCM(Int64 a, Int64 b)
    {
        return (a * b /GCD(a, b));
    }

    ///<summary>
    ///Finds the greatest common denominator for 2 numbers.
    ///</summary>
    ///<remarks>
    ///Also from http://stackoverflow.com/a/2641293/420175.
    ///</remarks>
    public static Int64 GCD(Int64 a, Int64 b)
    {
        //Euclidean algorithm
        Int64 t;
        while (b != 0)
        {
            t = b;
            b = a % b;
            a = t;
        }
        return a;
    }
}'

InformationsquelleAutor t9mike

3

Fonction pour trouver lcm d'une liste de nombres:
```
 def function(l):
     s = 1
     for i in l:
        s = lcm(i, s)
     return s
```
InformationsquelleAutor Aaditya Mishra
2

À l'aide de LINQ, vous pourriez écrire:
```
static int LCM(int[] numbers)
{
    return numbers.Aggregate(LCM);
}

static int LCM(int a, int b)
{
    return a * b /GCD(a, b);
}
```
Devrait ajouter using System.Linq; et n'oubliez pas de gérer les exceptions ...

InformationsquelleAutor SepehrM

Ici, il est en Swift.

//Euclid's algorithm for finding the greatest common divisor
func gcd(_ a: Int, _ b: Int) -> Int {
  let r = a % b
  if r != 0 {
    return gcd(b, r)
  } else {
    return b
  }
}

//Returns the least common multiple of two numbers.
func lcm(_ m: Int, _ n: Int) -> Int {
  return m /gcd(m, n) * n
}

//Returns the least common multiple of multiple numbers.
func lcmm(_ numbers: [Int]) -> Int {
  return numbers.reduce(1) { lcm($0, $1) }
}

InformationsquelleAutor cmilr

1

vous pouvez le faire d'une autre façon
Qu'il y ait des n nombres.Prenez une paire de nombres consécutifs et d'enregistrer sa lcm dans un autre tableau. Le faire lors de la première itération du programme ne n/2 itérations.Puis ensuite, ramasser la paire à partir de 0 comme (0,1) , (2,3), et ainsi de suite.Calculer leur LCM et de les stocker dans un autre tableau. Faites cela jusqu'à ce que vous êtes de gauche avec un tableau.
(il n'est pas possible de trouver lcm si n est impair)

InformationsquelleAutor mohit
1

Dans R, on peut utiliser les fonctions mGCD(x) et mLCM(x) à partir du package numéros de, pour calculer le plus grand commun diviseur et plus petit commun multiple de tous les nombres dans l'entier vecteur x ensemble:
```
    library(numbers)
    mGCD(c(4, 8, 12, 16, 20))
[1] 4
    mLCM(c(8,9,21))
[1] 504
    # Sequences
    mLCM(1:20)
[1] 232792560
```
InformationsquelleAutor mpalanco
1

ES6 style
```
function gcd(...numbers) {
  return numbers.reduce((a, b) => b === 0 ? a : gcd(b, a % b));
}

function lcm(...numbers) {
  return numbers.reduce((a, b) => Math.abs(a * b) /gcd(a, b));
}
```
- Vous avez appelé gcd(a, b) mais la gdc fonction attend un tableau de sorte que vous vouliez appeler gcd([a, b])
- c'est le plus élégant de réponse, et de loin
InformationsquelleAutor Saebekassebil

Et de la Scala version:

def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
def gcd(nums: Iterable[Int]): Int = nums.reduce(gcd)
def lcm(a: Int, b: Int): Int = if (a == 0 || b == 0) 0 else a * b /gcd(a, b)
def lcm(nums: Iterable[Int]): Int = nums.reduce(lcm)

InformationsquelleAutor Zach-M

Juste pour le plaisir, un shell (presque n'importe quel shell) mise en œuvre:

#!/bin/sh
gcd() {   # Calculate $1 % $2 until $2 becomes zero.
      until [ "$2" -eq 0 ]; do set -- "$2" "$(($1%$2))"; done
      echo "$1"
      }

lcm() {   echo "$(( $1 /$(gcd "$1" "$2") * $2 ))";   }

while [ $# -gt 1 ]; do
    t="$(lcm "$1" "$2")"
    shift 2
    set -- "$t" "$@"
done
echo "$1"

essayer avec:

$ ./script 2 3 4 5 6

pour obtenir

Le plus grand d'entrée et le résultat doit être inférieur à (2^63)-1 ou la coquille de mathématiques se terminera.

InformationsquelleAutor sorontar

j'étais à la recherche de pgcd et de ppcm des éléments d'un tableau et a trouvé une bonne solution dans le lien suivant.

https://www.hackerrank.com/challenges/between-two-sets/forum

qui comprend le code suivant. L'algorithme de pgcd utilise L'Algorithme d'Euclide bien expliqué dans le lien ci-dessous.

https://www.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/the-euclidean-algorithm

private static int gcd(int a, int b) {
    while (b > 0) {
        int temp = b;
        b = a % b; //% is remainder
        a = temp;
    }
    return a;
}

private static int gcd(int[] input) {
    int result = input[0];
    for (int i = 1; i < input.length; i++) {
        result = gcd(result, input[i]);
    }
    return result;
}

private static int lcm(int a, int b) {
    return a * (b /gcd(a, b));
}

private static int lcm(int[] input) {
    int result = input[0];
    for (int i = 1; i < input.length; i++) {
        result = lcm(result, input[i]);
    }
    return result;
}

InformationsquelleAutor mehmet riza oz

Ici est la PHP mise en œuvre:

    //https://stackoverflow.com/q/12412782/1066234
    function math_gcd($a,$b) 
    {
        $a = abs($a); 
        $b = abs($b);
        if($a < $b) 
        {
            list($b,$a) = array($a,$b); 
        }
        if($b == 0) 
        {
            return $a;      
        }
        $r = $a % $b;
        while($r > 0) 
        {
            $a = $b;
            $b = $r;
            $r = $a % $b;
        }
        return $b;
    }

    function math_lcm($a, $b)
    {
        return ($a * $b /math_gcd($a, $b));
    }

    //https://stackoverflow.com/a/2641293/1066234
    function math_lcmm($args)
    {
        //Recursively iterate through pairs of arguments
        //i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

        if(count($args) == 2)
        {
            return math_lcm($args[0], $args[1]);
        }
        else 
        {
            $arg0 = $args[0];
            array_shift($args);
            return math_lcm($arg0, math_lcmm($args));
        }
    }

    //fraction bonus
    function math_fraction_simplify($num, $den) 
    {
        $g = math_gcd($num, $den);
        return array($num/$g, $den/$g);
    }


    var_dump( math_lcmm( array(4, 7) ) ); //28
    var_dump( math_lcmm( array(5, 25) ) ); //25
    var_dump( math_lcmm( array(3, 4, 12, 36) ) ); //36
    var_dump( math_lcmm( array(3, 4, 7, 12, 36) ) ); //252

Les crédits vont à @T3db0t avec son la réponse ci-dessus (ECMA-code de style).

InformationsquelleAutor Kai Noack

PGCD besoin d'un peu de correction pour les nombres négatifs:

def gcd(x,y):
  while y:
    if y<0:
      x,y=-x,-y
    x,y=y,x % y
    return x

def gcdl(*list):
  return reduce(gcd, *list)

def lcm(x,y):
  return x*y /gcd(x,y)

def lcml(*list):
  return reduce(lcm, *list)

InformationsquelleAutor Roger Garzon Nieto

Comment à ce sujet?

from operator import mul as MULTIPLY

def factors(n):
    f = {} # a dict is necessary to create 'factor : exponent' pairs 
    divisor = 2
    while n > 1:
        while (divisor <= n):
            if n % divisor == 0:
                n /= divisor
                f[divisor] = f.get(divisor, 0) + 1
            else:
                divisor += 1
    return f


def mcm(numbers):
    #numbers is a list of numbers so not restricted to two items
    high_factors = {}
    for n in numbers:
        fn = factors(n)
        for (key, value) in fn.iteritems():
            if high_factors.get(key, 0) < value: # if fact not in dict or < val
                high_factors[key] = value
    return reduce (MULTIPLY, ((k ** v) for k, v in high_factors.items()))

InformationsquelleAutor Alessandro Martin

Nous avons travail de mise en œuvre du plus petit Commun Multiple sur Calculla qui fonctionne pour n'importe quel nombre d'entrées affichant aussi les étapes.

Ce que nous faisons est:

0: Assume we got inputs[] array, filled with integers. So, for example:
   inputsArray = [6, 15, 25, ...]
   lcm = 1

1: Find minimal prime factor for each input.
   Minimal means for 6 it's 2, for 25 it's 5, for 34 it's 17
   minFactorsArray = []

2: Find lowest from minFactors:
   minFactor = MIN(minFactorsArray)

3: lcm *= minFactor

4: Iterate minFactorsArray and if the factor for given input equals minFactor, then divide the input by it:
  for (inIdx in minFactorsArray)
    if minFactorsArray[inIdx] == minFactor
      inputsArray[inIdx] \= minFactor

5: repeat steps 1-4 until there is nothing to factorize anymore. 
   So, until inputsArray contains only 1-s.

Et voilà - vous avez obtenu votre lcm.

InformationsquelleAutor yosh kemu

LCM est à la fois associatif et commutatif.

PPCM(a,b,c)=PPCM(PPCM(a,b),c)=PPCM(a,PPCM(b,c))

voici un exemple de code en C:

int main()
{
  int a[20],i,n,result=1;  //assumption: count can't exceed 20
  printf("Enter number of numbers to calculate LCM(less than 20):");
  scanf("%d",&n);
  printf("Enter %d  numbers to calculate their LCM :",n);
  for(i=0;i<n;i++)
    scanf("%d",&a[i]);
 for(i=0;i<n;i++)
   result=lcm(result,a[i]);
 printf("LCM of given numbers = %d\n",result);
 return 0;
}

int lcm(int a,int b)
{
  int gcd=gcd_two_numbers(a,b);
  return (a*b)/gcd;
}

int gcd_two_numbers(int a,int b)
{
   int temp;
   if(a>b)
   {
     temp=a;
     a=b;
     b=temp;
   }
  if(b%a==0)
    return a;
  else
    return gcd_two_numbers(b%a,a);
}

InformationsquelleAutor User

Méthode compLCM prend un vecteur et renvoie LCM. Tous les numéros sont dans l'vecteur in_numbers.

int mathOps::compLCM(std::vector<int> &in_numbers)
 {
    int tmpNumbers = in_numbers.size();
    int tmpMax = *max_element(in_numbers.begin(), in_numbers.end());
    bool tmpNotDividable = false;

    while (true)
    {
        for (int i = 0; i < tmpNumbers && tmpNotDividable == false; i++)
        {
            if (tmpMax % in_numbers[i] != 0 )
                tmpNotDividable = true;
        }

        if (tmpNotDividable == false)
            return tmpMax;
        else
            tmpMax++;
    }
}

InformationsquelleAutor Behnam Dezfouli

0
```
clc;

data = [1 2 3 4 5]

LCM=1;

for i=1:1:length(data)

    LCM = lcm(LCM,data(i))

end 
```
- Le Code est apprécié, mais si vous pouvez ajouter des commentaires détaillant la façon dont il fonctionne, il est apprécié encore plus.
- Alors que cet extrait de code, peut-être de résoudre la question, y compris une explication aide vraiment afin d'améliorer la qualité de votre post. Rappelez-vous que vous répondez à la question pour les lecteurs dans l'avenir, et pas seulement la personne qui vous demande maintenant! Veuillez modifier votre réponse pour ajouter des explications, et de donner une indication de ce que les limites et les hypothèses s'appliquent.
InformationsquelleAutor MD Nashid Anjum

Pour ceux qui recherchent rapide code du travail, essayez ceci:

J'ai écrit une fonction lcm_n(args, num) qui calcule et renvoie le ppcm de tous les nombres dans le tableau args. Le deuxième paramètrenum est le nombre de chiffres dans le tableau.

Mettre tous ces nombres dans un tableau args et ensuite appeler la fonction comme lcm_n(args,num);

Cette fonction retourne le ppcm de tous ces chiffres.

Ici est la mise en œuvre de la fonction lcm_n(args, num):

int lcm_n(int args[], int num) //lcm of more than 2 numbers
{
    int i, temp[num-1];

    if(num==2)
    {
        return lcm(args[0], args[1]);
    }
    else
    {
        for(i=0;i<num-1;i++)
        {
           temp[i] = args[i];   
        }

        temp[num-2] = lcm(args[num-2], args[num-1]);
        return lcm_n(temp,num-1);
    }
}

Cette fonction des besoins en dessous de deux fonctions de travail. Donc, il suffit de les ajouter avec elle.

int lcm(int a, int b) //lcm of 2 numbers
{
    return (a*b)/gcd(a,b);
}


int gcd(int a, int b) //gcd of 2 numbers
{
    int numerator, denominator, remainder;

    //Euclid's algorithm for computing GCD of two numbers
    if(a > b)
    {
        numerator = a;
        denominator = b;
    }
    else
    {
        numerator = b;
        denominator = a;
    }
    remainder = numerator % denominator;

    while(remainder != 0)
    {
        numerator   = denominator;
        denominator = remainder;
        remainder   = numerator % denominator;
    }

    return denominator;
}

InformationsquelleAutor Nikhil

0

int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a%b); } int lcm(int[] a, int n) { int res = 1, i; for (i = 0; i < n; i++) { res = res*a[i]/gcd(res, a[i]); } return res; }

InformationsquelleAutor vipul

En python:

def lcm(*args):
    """Calculates lcm of args"""
    biggest = max(args) #find the largest of numbers
    rest = [n for n in args if n != biggest] #the list of the numbers without the largest
    factor = 1 #to multiply with the biggest as long as the result is not divisble by all of the numbers in the rest
    while True:
        #check if biggest is divisble by all in the rest:
        ans = False in [(biggest * factor) % n == 0 for n in rest]
        #if so the clm is found break the loop and return it, otherwise increment factor by 1 and try again
        if not ans:
            break
        factor += 1
    biggest *= factor
    return "lcm of {0} is {1}".format(args, biggest)

>>> lcm(100,23,98)
'lcm of (100, 23, 98) is 112700'
>>> lcm(*range(1, 20))
'lcm of (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19) is 232792560'

InformationsquelleAutor amirt

C'est ce que j'ai utilisé --

def greater(n):

      a=num[0]

      for i in range(0,len(n),1):
       if(a<n[i]):
        a=n[i]
      return a

r=input('enter limit')

num=[]

for x in range (0,r,1):

    a=input('enter number ')
    num.append(a)
a= greater(num)

i=0

while True:

    while (a%num[i]==0):
        i=i+1
        if(i==len(num)):
               break
    if i==len(num):
        print 'L.C.M = ',a
        break
    else:
        a=a+1
        i=0

InformationsquelleAutor Vishwajeet Gaur

pour python 3:

from functools import reduce

gcd = lambda a,b: a if b==0 else gcd(b, a%b)
def lcm(lst):        
    return reduce(lambda x,y: x*y//gcd(x, y), lst)

InformationsquelleAutor Rodrigo López

-1

Si il n'y a pas de temps de contrainte, c'est assez simple et directe:
```
def lcm(a,b,c):
    for i in range(max(a,b,c), (a*b*c)+1, max(a,b,c)):
        if i%a == 0 and i%b == 0 and i%c == 0:
            return i
```
- Pouvez-vous expliquer comment un nombre plus petit que le maximum d'un ensemble de nombres peut être un multiple de chacun d'eux?
- vous avez raison, je l'ai changé pour le maximum d'un ensemble de nombres. Et il vérifie par incréments de le nombre maximum.
- C'est une amélioration. Si vous continuez sur cette ligne de pensée, vous découvrir de plus.
InformationsquelleAutor Sri

Vous devez vous connecter pour publier un commentaire.