कम से कम 3 या अधिक संख्या के लिए सामान्य एकाधिक

Question

आप कम से कम सामान्य संख्या के कई संख्याओं की गणना कैसे करते हैं?

अब तक मैं केवल दो नंबरों के बीच इसकी गणना कर पाया हूं। लेकिन यह पता नहीं है कि 3 या अधिक संख्याओं की गणना करने के लिए इसका विस्तार कैसे किया जाए।

अब तक यही मैंने किया है

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

Gcd के साथ संख्याओं के लिए सबसे बड़ी सामान्य भाजक की गणना करने का कार्य है। यूक्लिडियन एल्गोरिथ्म का उपयोग करना

लेकिन मैं यह पता नहीं लगा सकता कि 3 या अधिक संख्याओं के लिए इसकी गणना कैसे की जाए।

Comments

कृपया इसे होमवर्क के रूप में टैग न करें। मैं एक प्लेट पर धातु की शीट के कई टुकड़ों को फिट करने का एक तरीका खोजने की कोशिश कर रहा हूं और एक ही प्लेट पर अलग-अलग लंबाई की धातु को फिट करने का तरीका खोजने की आवश्यकता है। एलसीएम और जीसीडी ऐसा करने का सबसे अच्छा तरीका है। Ia प्रोग्रामर एक गणित आदमी नहीं है। इसीलिए मैंने पूछा।

— पान

एक बड़ी शीट में छोटी चादरें भरना - 2 डी बिन पैकिंग?

— उच्च प्रदर्शन मार्क

@HighPerformanceMark टेट्रिस?

— mbomb007

Answer 1

आप दो संख्याओं के LCM की गणना करके दो से अधिक संख्या के LCM की गणना कर सकते हैं, अर्थात

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

Comments

Ooooh पाठ्यपुस्तक पुनरावृत्ति :)

— पीटर

एक पुनरावर्ती एल्गोरिथ्म की परिभाषा का मतलब जरूरी नहीं है कि एक पुनरावर्ती उपरांत। आप इसे एक लूप में बहुत सरलता से लागू कर सकते हैं। सही उत्तर के लिए धन्यवाद।

— मारियस

Answer 2

पायथन में (संशोधित 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)

Comments

मैं अजगर से परिचित नहीं हूं, क्या कम करता है ()?

— पान

एक फ़ंक्शन f और एक सूची l = [a, b, c, d], कम करें (f, l) रिटर्न f (f (f (a, b), c)), d)। यह कार्यात्मक कार्यान्वयन है "एलसीएम की गणना वर्तमान मूल्य के लिम्के और सूची के अगले एलिमेंट द्वारा गणना की जा सकती है।"

— ए। रेक्स

एक समाधान है कि तीन से अधिक मापदंडों के अनुकूलित कर सकते हैं दिखाने के लिए +1

— OnesimusUnbound

क्या आप lcm फ़ंक्शन को स्वयं कम करके lcmm फ़ंक्शन की तरह व्यवहार कर सकते हैं? मेरा पहला विचार यह है कि 2 तर्क होने पर इसे Lcm () करें, और अधिक होने पर घटाएँ () करें।

— एंडोलिथ

@ हाईटियन कॉमा पाइथन में टपल बनाता है। : इस मामले में, यह बराबर हैt = a; a = b; b = t % b

— JFS

Answer 3

यहां 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));
    }
}

Comments

यह बुरा लगता है कि मुझे समझ में नहीं आ रहा है कि "ईसीएमए-शैली" = /

— फ्रीटास

Answer 4

मैं इसके साथ जाऊंगा (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);
}

सिर्फ कुछ स्पष्टीकरण, क्योंकि पहली नज़र में यह इतना स्पष्ट नहीं है कि यह कोड क्या कर रहा है:

एग्रीगेट एक लाइनक एक्सटेंशन विधि है, इसलिए आप अपने संदर्भों में System.Linq का उपयोग करना नहीं भूल सकते।

एग्रीगेट एक संचित कार्य करता है इसलिए हम एक IEnumerable पर संपत्ति lcm (a, b, c) = lcm (a, lcm (b, c)) का उपयोग कर सकते हैं। एग्रीगेट पर अधिक

जीसीडी गणना यूक्लिडियन एल्गोरिथ्म का उपयोग करती है ।

lcm गणना Abs (a * b) / gcd (a, b) का उपयोग करता है, सबसे बड़ी सामान्य भाजक द्वारा कटौती को संदर्भित करता है ।

उम्मीद है की यह मदद करेगा,

Answer 5

मैं बस हास्केल में यह पता लगा:

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, केवल इसे प्रील्यूड में खोजने के लिए! आज मेरे लिए बहुत कुछ सीखने लायक है: डी

Comments

आप अंतिम पंक्ति के लिए foldr1 का उपयोग कर सकते हैं: lcm ns = foldr1 lcm' nsयाlcm = foldr1 lcm'

— नील

तुम भी वास्तव में कम से कम परिणाम के लिए हस्ताक्षर के साथ टाइप कर सकते हैं, जैसा Integralकि निहित हैdiv

— नील मैथ्यू

Answer 6

कुछ पायथन कोड जिन्हें 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)

यह टर्मिनल में कैसा दिखता है:

$ python lcm.py 10 15 17
510

Answer 7

1 से 20 समावेशी पूर्णांक के LCM को वापस करने के लिए एक पायथन वन-लाइनर (आयातों की गिनती नहीं) है:

पायथन 3.5+ आयात:

from functools import reduce
from math import gcd

पायथन 2.7 आयात:

from fractions import gcd

सामान्य तर्क:

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

ध्यान दें कि पायथन 2 और पायथन 3 दोनों में , ऑपरेटर पूर्वता नियम निर्धारित करते हैं कि ऑपरेटरों *और //ऑपरेटरों में एक ही पूर्वता है, और इसलिए वे बाएं से दाएं लागू होते हैं। जैसे, x*y // zसाधन (x*y) // zऔर नहीं x * (y//z)। आम तौर पर दोनों अलग परिणाम देते हैं। यह फ्लोट डिवीजन के लिए ज्यादा मायने नहीं रखता था, लेकिन यह फ्लोर डिवीजन के लिए होता है ।

Answer 8

यहाँ विर्गिल डिसिप्रेस 4 के लागू होने का सी # पोर्ट है:

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

Answer 9

संख्याओं की किसी भी सूची का lcm खोजने का कार्य:

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

Answer 10

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;और अपवादों को संभालना नहीं भूलना चाहिए ...

Answer 11

और स्काला संस्करण:

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)

Answer 12

यहां यह स्विफ्ट में है ।

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

Answer 13

आप इसे दूसरे तरीके से कर सकते हैं - चलिए n नंबर होते हैं। लगातार संख्याओं की एक जोड़ी लें और इसके lcm को दूसरे सरणी में सहेजें। प्रथम पुनरावृति कार्यक्रम में ऐसा करने से n / 2 पुनरावृत्तियाँ हो जाती हैं। फिर अगली पिक अप जोड़ी 0 से शुरू होती है (0,1), (2,3) और इसी तरह। अपने LCM को प्राप्त करें और दूसरे सरणी में स्टोर करें। ऐसा तब तक करें जब तक आप एक सरणी के साथ नहीं रह जाते। (यदि n विषम है तो lcm खोजना संभव नहीं है)

Answer 14

आर में, हम फंक्शन 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

Answer 15

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

Comments

आपने फोन किया, gcd(a, b)लेकिन gdcसमारोह में एक सरणी की उम्मीद है ताकि आपको कॉल करने का मतलब होgcd([a, b])

— João Pinto Jerónimo

यह अब तक का सबसे सुरुचिपूर्ण जवाब है

— लोकुआ

Answer 16

बस मज़े के लिए, एक शेल (लगभग कोई शेल) कार्यान्वयन:

#!/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या शेल गणित लपेट देगा।

Answer 17

मैं सरणी तत्वों के gcd और lcm की तलाश कर रहा था और निम्नलिखित लिंक में एक अच्छा समाधान पाया।

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

जिसमें निम्नलिखित कोड शामिल हैं। एलसीडी के लिए एल्गोरिथ्म यूक्लिडियन एल्गोरिथ्म का उपयोग करता है नीचे दिए गए लिंक में अच्छी तरह से समझाया गया है।

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

Answer 18

यहाँ 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

क्रेडिट्स अपने उत्तर के ऊपर @ (ECMA- स्टाइल कोड) के साथ @ T3db0t पर जाते हैं ।

Answer 19

नकारात्मक संख्या के लिए 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)

Answer 20

इस बारे में कैसा है?

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

Answer 21

हमारे पास कलकुल्ला पर कम से कम एक से अधिक कार्य कार्यान्वयन है जो किसी भी संख्या में इनपुट के लिए काम करता है जो चरणों को भी प्रदर्शित करता है।

हम क्या करते हैं:

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.

और वह यह है - आपको अपना एलसीएम मिला।

Answer 22

एलसीएम सहयोगी और कम्यूटेटिव दोनों है।

एलसीएम (क, ख, ग) = एलसीएम (एलसीएम (ए, बी), सी) = एलसीएम (क, एलसीएम (ख, ग))

यहाँ 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);
}

Answer 23

विधि compLCM एक वेक्टर लेता है और LCM लौटाता है। सभी संख्याएं वेक्टर 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++;
    }
}

Answer 24

clc;

data = [1 2 3 4 5]

LCM=1;

for i=1:1:length(data)

    LCM = lcm(LCM,data(i))

end 

Comments

कोड की सराहना की जाती है, लेकिन यदि आप टिप्पणी को जोड़ सकते हैं कि यह कैसे काम करता है तो इसकी सराहना की जाती है।

— एलेक्स रिले

हालांकि यह कोड स्निपेट प्रश्न को हल कर सकता है, जिसमें स्पष्टीकरण सहित वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए सवाल का जवाब दे रहे हैं, न कि केवल उस व्यक्ति से जो अब पूछ रहा है! कृपया स्पष्टीकरण जोड़ने के लिए अपने उत्तर को संपादित करें, और इस बात का संकेत दें कि क्या सीमाएँ और मान्यताएँ लागू होती हैं।

— टोबे स्पीट

Answer 25

त्वरित कार्य कोड की तलाश में किसी के लिए, यह प्रयास करें:

मैंने एक फ़ंक्शन लिखा, 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;
}

Answer 26

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

Answer 27

अजगर में:

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'

Answer 28

यह वही है जो मैंने प्रयोग किया है -

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

Answer 29

अजगर 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)  

Answer 30

रूबी में, यह उतना ही सरल है:

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

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

(रूबी 2.2.10 और 2.6.3 पर परीक्षण किया गया।)