ตัวคูณร่วมน้อยสำหรับ 3 ตัวหรือมากกว่า

คุณจะคำนวณจำนวนตัวคูณร่วมที่น้อยที่สุดในหลายวิธีได้อย่างไร

จนถึงตอนนี้ฉันสามารถคำนวณได้ระหว่างตัวเลขสองตัวเท่านั้น แต่ไม่รู้จะขยายอย่างไรเพื่อคำนวณตัวเลข 3 ตัวขึ้นไป

จนถึงตอนนี้เป็นวิธีที่ฉันทำ

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

ด้วย gcd เป็นฟังก์ชันในการคำนวณตัวหารร่วมที่ยิ่งใหญ่ที่สุดสำหรับตัวเลข ใช้อัลกอริทึมแบบยุคลิด

แต่ฉันไม่สามารถหาวิธีการคำนวณเป็น 3 หรือมากกว่าได้

คุณสามารถคำนวณ LCM มากกว่าสองตัวเลขได้โดยคำนวณ LCM เป็นตัวเลขสองหลักเช่นกัน

lcm(a,b,c) = lcm(a,lcm(b,c))

ใน Python (แก้ไข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)

การใช้งาน:

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

reduce()ทำงานบางอย่างเช่นนั้น :

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

นี่คือการใช้สไตล์ ECMA:

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

ฉันจะไปกับอันนี้ (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);
}

เพียงแค่คำอธิบายบางอย่างเพราะในตอนแรกมันไม่ได้ตะเข็บเพื่อให้ชัดเจนว่าโค้ดนี้ทำอะไร:

การรวมเป็นวิธีการขยาย Linq ดังนั้นคุณไม่สามารถเพิ่มโดยใช้ System.Linq ในการอ้างอิงของคุณ

การรวมได้รับฟังก์ชั่นการสะสมเพื่อให้เราสามารถใช้คุณสมบัติ lcm (a, b, c) = lcm (a, lcm (b, c)) ผ่าน IEnumerable เพิ่มเติมเกี่ยวกับการรวม

คำนวณ GCD ทำให้การใช้อัลกอริทึมแบบยุคลิด

คำนวณ LCM ใช้ Abs (a * b) / GCD (A, B) หมายถึงการลดลงโดยตัวหารร่วมมาก

หวังว่าจะช่วยได้

ฉันเพิ่งพบสิ่งนี้ใน 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

ฉันยังใช้เวลาในการเขียนgcdฟังก์ชั่นของตัวเองเพียงเพื่อจะพบมันในโหมโรง! วันนี้มีการเรียนรู้มากมายสำหรับฉัน: D

รหัส Python บางตัวที่ไม่ต้องการฟังก์ชันสำหรับ 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)

นี่คือสิ่งที่ดูเหมือนใน terminal:

$ python lcm.py 10 15 17
510

นี่คือ Python หนึ่งบรรทัด (ไม่นับการนำเข้า) เพื่อส่งคืน LCM ของจำนวนเต็มตั้งแต่ 1 ถึง 20:

Python 3.5+ การนำเข้า:

from functools import reduce
from math import gcd

Python 2.7 การนำเข้า:

from fractions import gcd

ตรรกะทั่วไป:

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

โปรดทราบว่าในทั้งPython 2และPython 3กฎสำคัญของโอเปอเรเตอร์จะเป็นตัวกำหนดว่า*และ//โอเปอเรเตอร์จะมีลำดับความสำคัญเท่ากันดังนั้นจึงใช้จากซ้ายไปขวา เช่นx*y // zวิธีการและไม่ได้(x*y) // z x * (y//z)โดยทั่วไปแล้วทั้งสองจะให้ผลลัพธ์ที่แตกต่างกัน นี้จะไม่ได้มีความสำคัญเป็นอย่างมากสำหรับการแบ่งลอย แต่มันไม่สำหรับการแบ่งชั้น

นี่คือพอร์ต C # ของการปฏิบัติของ 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;
    }
}'

ฟังก์ชั่นเพื่อค้นหา lcm ของรายการตัวเลขใด ๆ :

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

ใช้ LINQ คุณสามารถเขียน:

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

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

ควรเพิ่มusing System.Linq;และอย่าลืมจัดการข้อยกเว้น ...

และเวอร์ชั่น 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)

นี่มันอยู่ในสวิฟท์

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

คุณสามารถทำได้อีกวิธีหนึ่ง - ปล่อยให้มีตัวเลข n ใช้หมายเลขติดต่อกันสองคู่และบันทึก lcm ในอาร์เรย์อื่น การทำเช่นนี้ในโปรแกรมการวนซ้ำครั้งแรกจะทำการวนซ้ำ n / 2 จากนั้นรับคู่ต่อไปเริ่มต้นจาก 0 เช่น (0,1), (2,3) และอื่น ๆ คำนวณ LCM ของพวกเขาและเก็บไว้ในอาร์เรย์อื่น ทำเช่นนี้จนกว่าคุณจะเหลือหนึ่งอาร์เรย์ (เป็นไปไม่ได้ที่จะหา lcm ถ้า n เป็นเลขคี่)

ใน R เราสามารถใช้ฟังก์ชั่นmGCD (x) และmLCM (x) จากหมายเลขแพ็คเกจเพื่อคำนวณตัวหารร่วมมากที่สุดและตัวคูณร่วมน้อยสำหรับตัวเลขทั้งหมดในเวกเตอร์จำนวนเต็ม x ด้วยกัน:

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

สไตล์ ES6

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

เพื่อความสนุกการใช้งานเชลล์ (เกือบทุกเชลล์):

#!/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"

ลองกับ:

$ ./script 2 3 4 5 6

เพื่อรับ

60

อินพุตและผลลัพธ์ที่ใหญ่ที่สุดควรน้อยกว่า(2^63)-1หรือเชลล์คณิตศาสตร์จะสรุป

ฉันกำลังมองหา gcd และ lcm ขององค์ประกอบอาเรย์และพบทางออกที่ดีในลิงค์ต่อไปนี้

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

ซึ่งรวมถึงรหัสต่อไปนี้ อัลกอริทึมสำหรับ gcd ใช้อัลกอริทึมแบบยุคลิดอธิบายได้ดีในลิงค์ด้านล่าง

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

นี่คือการใช้งานPHP :

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

เครดิตไปที่ @ T3db0t กับเขาคำตอบข้างต้น (รหัส ECMA สไตล์)

GCD ต้องการการแก้ไขเล็กน้อยสำหรับตัวเลขลบ:

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)

แล้วเรื่องนี้ล่ะ

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

เรามีการใช้งานLeast Common Multiple บน Calcullaซึ่งทำงานกับอินพุตจำนวนเท่าใดก็ได้และยังแสดงขั้นตอนต่างๆ

สิ่งที่เราทำคือ:

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.

และนั่นคือ - คุณได้ lcm ของคุณ

LCM เป็นทั้งแบบเชื่อมโยงและสลับกัน

LCM (A, B, C) = LCM (LCM (A, B) ค) = LCM (มี LCM (B, C))

นี่คือตัวอย่างรหัสใน 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);
}

วิธี compLCM ใช้เวกเตอร์และส่งกลับ LCM ตัวเลขทั้งหมดอยู่ภายใน 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++;
    }
}

clc;

data = [1 2 3 4 5]

LCM=1;

for i=1:1:length(data)

    LCM = lcm(LCM,data(i))

end 

สำหรับใครที่กำลังมองหารหัสที่ทำงานได้อย่างรวดเร็วลองสิ่งนี้:

ผมเขียนฟังก์ชั่นlcm_n(args, num) ซึ่งคำนวณและส่งกลับ LCM argsของตัวเลขทั้งหมดในอาร์เรย์ พารามิเตอร์ที่สองnumคือการนับจำนวนในอาร์เรย์

ใส่ตัวเลขเหล่านั้นทั้งหมดในอาร์เรย์argsแล้วเรียกใช้ฟังก์ชันเช่นlcm_n(args,num);

ฟังก์ชันนี้ส่งคืน lcm ของตัวเลขเหล่านั้นทั้งหมด

นี่คือการใช้ฟังก์ชั่น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);
    }
}

ฟังก์ชันนี้ต้องการฟังก์ชันสองฟังก์ชันที่ต่ำกว่า ดังนั้นเพียงแค่เพิ่มพวกเขาไปพร้อมกับมัน

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

ในหลาม:

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'

นี่คือสิ่งที่ฉันใช้ -

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

สำหรับหลาม 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)  

ใน Ruby มันง่ายเหมือน:

> [2, 3, 4, 6].reduce(:lcm)
=> 12

> [16, 32, 96].reduce(:gcd)
=> 16

(ทดสอบกับ Ruby 2.2.10 และ 2.6.3.)