Multiple le moins commun pour 3 nombres ou plus

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)

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));
    }
}

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 clarifications, parce qu'à première vue, il ne se confond pas si clairement ce que ce code fait:

Aggregate est une méthode D'Extension Linq, donc vous ne pouvez pas oublier d'ajouter en utilisant le système.Linq à 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. plus sur Total

PGCD de calcul rend l'utilisation de la algorithme d'Euclide .

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

Espère que cette aide,

je viens de le découvrir à 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 ma propre fonction gcd , pour la trouver en prélude! Beaucoup d'apprentissage pour moi aujourd'hui :D

un code Python qui ne nécessite pas de fonction pour 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

voici un Python one-liner (sans compter les importations) pour retourner le CML des entiers de 1 à 20 inclus:

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))

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 ils s'appliquent donc de gauche à droite. À ce titre, x*y//z signifie (x*y)//z et non x*(y//z) . Les deux donnent généralement des résultats différents. Cela n'aurait pas eu autant d'importance pour la division float, mais c'est le cas pour la floor division .

voici un C # port de la mise en œuvre de Virgil Disgr4ce:

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;
    }
}'

fonction pour trouver lcm de n'importe quelle liste de numéros:

 def function(l):
     s = 1
     for i in l:
        s = lcm(i, s)
     return s

en utilisant LINQ vous pouvez é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 ...

vous pouvez le faire d'une autre manière - Qu'il y ait des n nombres.Prenez une paire de nombres consécutifs et sauvegardez son lcm dans un autre tableau. Faire cela à la première itération programme fait n/2 itérations.Puis ramassez la paire suivante à partir de 0 comme (0,1) , (2,3) et ainsi de suite.Calculer leur CML et stocker dans un autre tableau. Faites ceci jusqu'à ce qu'il vous reste un tableau. (il n'est pas possible de trouver la MCP si n est impair)

dans R, Nous pouvons utiliser les fonctions mgmd (x) et mLCM (x) du paquet nombres , pour calculer le plus grand diviseur commun et le moins commun multiple pour tous les nombres dans le vecteur entier 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

et la version Scala:

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)

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

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

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

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

essayer avec:

$ ./script 2 3 4 5 6

pour obtenir

60

la plus grande entrée et le résultat devrait être moins que (2^63)-1 ou le calcul shell enveloppera.

je cherchais gcd et lcm d'éléments de réseau et j'ai 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;
}

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("151900920", ) }
}

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)

et ça?

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()))

nous avons l'implémentation de travail du Multiple Le moins commun sur le calcul qui fonctionne pour un nombre quelconque d'entrées affichant également les étapes.

Ce que nous faisons est la suivante:

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 c'est tout - vous avez votre lcm.

LCM est à la fois associatif et commutatif.

CML (a,b,c)=CML(CML (a,b),c)=CML(a, CML (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);
}

méthode compLCM prend un vecteur et renvoie LCM. Tous les nombres se trouvent dans vector 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++;
    }
}

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));
}

clc;

data = [1 2 3 4 5]

LCM=1;

for i=1:1:length(data)

    LCM = lcm(LCM,data(i))

end 

pour tous ceux qui cherchent un code de travail rapide, essayez ceci:

j'ai écrit une fonction lcm_n(args, num) qui calcule et renvoie le CML de tous les nombres dans le tableau args . Le second paramètre num est le nombre de nombres dans le tableau.

mettez tous ces numéros dans un tableau args et appelez la fonction comme lcm_n(args,num);

cette fonction retourne le lcm de tous ces numéros.

Voici 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 nécessite moins de deux fonctions pour fonctionner. 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;
}

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; }

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'

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

voici le PHP implémentation:

     // /q/simplifier une fraction-45205/"https://stackoverflow.com/a/2641293/1066234">la réponse ci-dessus (ECMA-code de style)    .