it-swarm.com.de

Wenig gemeinsames Vielfaches für 3 oder mehr Zahlen

Wie berechnen Sie das kleinste gemeinsame Vielfache mehrerer Zahlen?

Bisher konnte ich es nur zwischen zwei Zahlen berechnen. Aber haben Sie keine Ahnung, wie Sie es erweitern, um 3 oder mehr Zahlen zu berechnen.

So habe ich es bisher gemacht 

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

Mit gcd ist die Funktion zur Berechnung des größten gemeinsamen Divisors für die Zahlen. Verwendung des euklidischen Algorithmus

Aber ich kann nicht herausfinden, wie ich es für drei oder mehr Zahlen berechnen kann.

136
paan

Sie können das LCM aus mehr als zwei Zahlen berechnen, indem Sie das LCM aus zwei Zahlen iterativ berechnen, d. H.

lcm(a,b,c) = lcm(a,lcm(b,c))
170
A. Rex

In Python (modifiziert 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)

Verwendungszweck:

>>> lcmm(100, 23, 98)
112700
>>> lcmm(*range(1, 20))
232792560

reduce() arbeitet so etwas wie das :

>>> f = lambda a,b: "f(%s,%s)" % (a,b)
>>> print reduce(f, "abcd")
f(f(f(a,b),c),d)
143
jfs

Hier ist eine Implementierung im ECMA-Stil:

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

Ich würde mit dieser (C #) gehen: 

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

Nur ein paar Klarstellungen, weil auf den ersten Blick nicht klar ist, was dieser Code macht:

Aggregat ist eine Linq-Erweiterungsmethode. Sie können also nicht vergessen, System.Linq zu Ihren Referenzen hinzuzufügen.

Aggregat erhält eine Akkumulationsfunktion, sodass wir die Eigenschaft lcm (a, b, c) = lcm (a, lcm (b, c)) über eine IEnumerable verwenden können. Mehr zum Aggregat

Bei der GCD-Berechnung wird der Euklidische Algorithmus verwendet.

bei der Berechnung von lcm werden Abs (a * b)/gcd (a, b) verwendet, siehe Reduzierung um den größten gemeinsamen Teiler .

Hoffe das hilft,

10
Rodrigo López

Einige Python-Codes, die keine Funktion für gcd benötigen:

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)

So sieht es im Terminal aus:

$ python lcm.py 10 15 17
510
6
Eratosthenes

Ich habe das gerade in Haskell herausgefunden:

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

Ich habe mir sogar die Zeit genommen, meine eigene gcd-Funktion zu schreiben, nur um sie in Prelude zu finden! Heute viel lernen für mich: D

6
Matt Ellen

Hier ist ein Python-Einzeiler (Importe nicht mitgezählt), um das LCM der ganzen Zahlen von 1 bis einschließlich 20 zurückzugeben:

Python 3.5+ -Importe:

from functools import reduce
from math import gcd

Python 2.7-Importe:

from fractions import gcd

Gemeinsame Logik:

lcm = reduce(lambda x,y: x*y//gcd(x, y), range(1, 21))

In den Python 2 - und Python 3 - Regeln legen die Operatorvorrangregeln fest, dass die *- und //-Operatoren die gleiche Priorität haben, und gelten daher von links nach rechts. Als solches bedeutet x*y//z(x*y)//z und nicht x*(y//z). Die beiden erzeugen normalerweise unterschiedliche Ergebnisse. Für die Float-Division hätte dies nicht so viel ausgemacht, für die Floor-Division .

5
A-B-B

Hier ist ein C # Port der Implementierung von 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;
    }
}'
3
t9mike

Funktion zum Finden von lcm einer beliebigen Liste von Zahlen:

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

Mit LINQ könnten Sie schreiben:

static int LCM(int[] numbers)
{
    return numbers.Aggregate(LCM);
}

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

Sollte using System.Linq; hinzufügen und nicht vergessen, die Ausnahmen zu behandeln ...

2
SepehrM

Hier ist es in 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) }
}
2
cmilr

In R können wir die Funktionen mGCD (x) und mLCM (x) aus dem Paket numbers verwenden, um den größten gemeinsamen Teiler und das kleinste gemeinsame Vielfache für alle Zahlen in der Ganzzahl zu berechnen Vektor x zusammen:

    library(numbers)
    mGCD(c(4, 8, 12, 16, 20))
[1] 4
    mLCM(c(8,9,21))
[1] 504
    # Sequences
    mLCM(1:20)
[1] 232792560
1
mpalanco

Und die 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)
1
Zach-M

ES6-Stil

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

Nur zum Spaß, eine Shell-Implementierung (fast jede Shell):

#!/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" "[email protected]"
done
echo "$1"

probiere es mit:

$ ./script 2 3 4 5 6

bekommen

60

Die größte Eingabe und das größte Ergebnis sollten weniger als (2^63)-1 sein, da sonst die Shell-Berechnungen umgebrochen werden.

1
sorontar

sie können es auch anders machen - Es gibt n Zahlen. Nehmen Sie ein Paar aufeinanderfolgender Zahlen und speichern Sie die lcm in einem anderen Array. Wenn Sie dieses Programm beim ersten Iterationsprogramm ausführen, werden n/2 Iterationen durchgeführt. Als Nächstes nehmen Sie ein Paar ab, das mit 0 (0,1), (2,3) usw. beginnt. Tun Sie dies, bis Sie nur noch ein Array haben. (Es ist nicht möglich, lcm zu finden, wenn n ungerade ist)

1
mohit

Hier ist die PHP Implementierung:

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

Credits gehen an @ T3db0t mit seiner Antwort oben (ECMA-Code) .

1
Kai Noack

ich suchte nach gcd und lcm von array-elementen und fand im folgenden link eine gute lösung. 

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

die folgenden Code enthält. Der Algorithmus für gcd verwendet den Euklidischen Algorithmus, der im folgenden Link gut erklärt wird.

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;
}
1
mehmet riza oz

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

0
vipul
clc;

data = [1 2 3 4 5]

LCM=1;

for i=1:1:length(data)

    LCM = lcm(LCM,data(i))

end 
0
MD Nashid Anjum

Für alle, die einen schnellen Code suchen, versuchen Sie Folgendes:

Ich habe eine Funktionlcm_n(args, num)geschrieben, die die lcm aller Zahlen im Array args berechnet und zurückgibt. Der zweite Parameternum ist die Anzahl der Zahlen im Array.

Setzen Sie alle diese Zahlen in ein Array args und rufen Sie dann die Funktion wie lcm_n(args,num); auf. 

Diese Funktion gibt die lcm aller Zahlen zurück. 

Hier ist die Implementierung der Funktion 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);
    }
}

Diese Funktion benötigt zwei Funktionen, um zu funktionieren. Fügen Sie sie einfach hinzu.

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

Wie wäre es damit?

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

Die Methode compLCM nimmt einen Vektor und gibt LCM zurück. Alle Zahlen liegen innerhalb des Vektors 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++;
    }
}
0
Behnam Dezfouli

Wir haben eine funktionierende Implementierung von Least Common Multiple auf Calculla , die für eine beliebige Anzahl von Eingaben funktioniert und auch die Schritte anzeigt.

Was wir machen, ist:

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.

Und das ist es - du hast deine Lcm.

0
yosh kemu

Das habe ich benutzt -

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
0
Vishwajeet Gaur

LCM ist sowohl assoziativ als auch kommutativ.

LCM (a, b, c) = LCM (LCM (a, b), c) = LCM (a, LCM (b, c))

hier ist Beispielcode in 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);
}
0
User

In 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'
0
amir-t

für 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)  
0
Rodrigo López

GCD benötigt eine kleine Korrektur für negative Zahlen:

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