3 বা ততোধিক সংখ্যার জন্য কমপক্ষে সাধারণ একাধিক

Question

আপনি একাধিক সংখ্যার সর্বনিম্ন সাধারণ এককটি কীভাবে গণনা করবেন?

এখন পর্যন্ত আমি কেবল এটি দুটি সংখ্যার মধ্যে গণনা করতে সক্ষম হয়েছি। তবে 3 বা ততোধিক সংখ্যার গণনা করার জন্য কীভাবে এটি প্রসারিত করবেন তার কোনও ধারণা নেই।

এখনও পর্যন্ত এটি আমি এটি করেছি

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

জিসিডি সহ সংখ্যার জন্য সর্বশ্রেষ্ঠ সাধারণ বিভাজক গণনা করার ফাংশন। ইউক্লিডিয়ান অ্যালগরিদম ব্যবহার করে

তবে কীভাবে 3 বা ততোধিক সংখ্যার জন্য এটি গণনা করব তা আমি বুঝতে পারি না।

Comments

দয়া করে এটি হোমওয়ার্ক হিসাবে ট্যাগ করবেন না। আমি এক প্লেটে ধাতব পাতাগুলির একাধিক টুকরো ফিট করার জন্য একটি উপায় অনুসন্ধান করার চেষ্টা করছি এবং একই প্লেটে বিভিন্ন দৈর্ঘ্যের ধাতব ফিট করার জন্য কোনও উপায় খুঁজে বের করতে হবে। এটি করার সবচেয়ে ভাল উপায় এলসিএম এবং জিসিডি। আমি প্রোগ্রামার কোনও গণিতের লোক নয়। ঐ জন্যই আমি জিজ্ঞাসা করেছিলাম.

— প্যান

একটি বড় শীটে ছোট শীট লাগানো - 2 ডি বিন প্যাকিং?

— উচ্চ পারফরম্যান্স মার্ক

নিবন্ধন করুন

— mbomb007

Answer 1

আপনি দুটি সংখ্যার, অর্থাৎ, এলসিএমকে পুনরাবৃত্তি করে দুটি সংখ্যার বেশি সংখ্যার এলসিএম গুণতে পারেন

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

Comments

— ওহো

পুনরাবৃত্তির অ্যালগরিদম সংজ্ঞাটির অর্থ অগত্যা একটি পুনরাবৃত্তির subroutine হয় না। আপনি এটি খুব সহজভাবে একটি লুপে প্রয়োগ করতে পারেন। নিখুঁত উত্তরের জন্য ধন্যবাদ।

— মারিয়াস

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

আমি অজগরটির সাথে পরিচিত নই, () কী হ্রাস পাবে?

— পান

একটি ফাংশন এফ এবং একটি তালিকা দেওয়া হয়েছে l = [a, b, c, d], হ্রাস (f, l) f (f (f (a, b), c), d) প্রদান করবে। এটি "এলসিএমের কার্যকরী বাস্তবায়নটি বর্তমান মানের এলসিএমিকে এবং পুনরায় তালিকার পরবর্তী উপাদানকে গণনা করে গণনা করা যেতে পারে।"

— এ রেক্স

এমন সমাধান দেখানোর জন্য +1 যা তিনটি বেশি প্যারামিটারের সাথে খাপ

— খাইয়ে

আপনি কি এলসিএম ফাংশনটিকে নিজেরাই হ্রাস করে এলসিএমএম ফাংশনের মতো আচরণ করতে পারেন? আমার প্রথম চিন্তাটি 2 টি আর্গুমেন্ট থাকা অবস্থায় এটি এলসিএম () করা এবং যখন বেশি থাকে তখন হ্রাস () করা।

— এন্ডোলিথ

@ হিরি কমা পাইথনে একটি টিপল তৈরি করে। এই ক্ষেত্রে এটি সমান:t = a; a = b; b = t % b

— jfs

Answer 3

এখানে একটি ইসিএমএ-শৈলীর প্রয়োগ রয়েছে:

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

আমি এটির সাথে যেতে চাই (সি #):

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

কেবল কিছু স্পষ্টতা, কারণ প্রথম নজরে এটি এতটা পরিষ্কার করে না যে এই কোডটি কী করছে:

সমষ্টি একটি লিনক এক্সটেনশন পদ্ধতি, সুতরাং আপনি আপনার রেফারেন্সগুলিতে সিস্টেম.লিঙ্ক ব্যবহার করে যুক্ত করতে ভুলতে পারবেন না।

সমষ্টিটি একটি সংশ্লেষিত ফাংশন পায় যাতে আমরা একটি সংখ্যার চেয়ে আরও বেশি পরিমাণে এলসিএম (ক, বি, সি) = এলসিএম (এ, এলসিএম (বি, সি)) ব্যবহার করতে পারি। সমষ্টি সম্পর্কে আরও

জিসিডি গণনা ইউক্যালিডিয়ান অ্যালগরিদম ব্যবহার করে ।

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

আপনি শেষ লাইনের জন্য ফোল্ডার 1 ব্যবহার করতে পারেন: lcm ns = foldr1 lcm' nsবাlcm = foldr1 lcm'

— নীল

সত্যিকারের ন্যূনতম ফলাফলের জন্য, স্বাক্ষর প্রকারের সাথে আপনি প্রেরণও করতে পারেন, যেমনটি Integralইঙ্গিত করা হয়েছেdiv

— নীল মেহেহু

Answer 6

কিছু পাইথন কোড যার জন্য গিসিডির জন্য কোনও ফাংশন প্রয়োজন হয় না:

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

পাইথন ২.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

ভার্জিল 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;
    }
}'

Answer 9

যে কোনও সংখ্যার তালিকার এলসিএম সন্ধানের কাজ:

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

Answer 10

লিনকিউ ব্যবহার করে আপনি লিখতে পারেন:

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 সংখ্যা থাকুক। একটানা সংখ্যার একজোড়া নিন এবং এর এলসিএমটিকে অন্য অ্যারে সংরক্ষণ করুন। প্রথম পুনরাবৃত্তির প্রোগ্রামে এটি করার ফলে এন / 2 পুনরাবৃত্তি ঘটে next এরপরে পরবর্তীটি 0 টি (0,1), (2,3) থেকে শুরু করে পিক আপ করুন their তাদের এলসিএম তৈরি করুন এবং অন্য অ্যারেতে সঞ্চয় করুন। আপনার একটি অ্যারে না ফেলে আসা পর্যন্ত এটি করুন। (n বিজোড় হলে lcm পাওয়া সম্ভব নয়)

Answer 14

আর-তে, আমরা পূর্ণসংখ্যার ভেক্টরের এক্স এর সাথে সংখ্যার জন্য সবচেয়ে বড় সাধারণ বিভাজক এবং সর্বনিম্ন সাধারণ একাধিক গণনা করতে প্যাকেজ নম্বরগুলি থেকে এমজিসিডি (এক্স) এবং এমএলসিএম (এক্স) ব্যবহার করতে পারি:

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

— জোও পিন্টো জের্নিমো

এটি এখন পর্যন্ত সবচেয়ে মার্জিত উত্তর

— লোকুয়া

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

আমি অ্যারের উপাদানগুলির জন্য জিসিডি এবং এলসিএম খুঁজছিলাম এবং নীচের লিঙ্কটিতে একটি ভাল সমাধান পেয়েছি।

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

এখানে পিএইচপি বাস্তবায়ন:

    // 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 এ যান ।

Answer 19

নেতিবাচক সংখ্যার জন্য জিসিডির সামান্য সংশোধন দরকার:

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

এলসিএম উভয়ই সাহসী এবং পরিবর্তনশীল।

LCM (ক, খ, গ) = LCM (LCM (ক, খ), গ) = LCM (ক, LCM (খ, গ))

এখানে সি তে নমুনা কোডটি রয়েছে:

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

পদ্ধতি কমপিএলসিএম একটি ভেক্টর নেয় এবং এলসিএম প্রদান করে। সমস্ত সংখ্যা ভেক্টর ইন_ নাম্বারের মধ্যে রয়েছে।

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) যা অ্যারের সমস্ত সংখ্যার এলসিএম গণনা করে এবং প্রদান করে args। দ্বিতীয় প্যারামিটারটি numঅ্যারের সংখ্যা গণনা।

সমস্ত নম্বর একটি অ্যারেতে রাখুন argsএবং তারপরে ফাংশনটিকে কল করুনlcm_n(args,num);

এই ফাংশনটি all সমস্ত সংখ্যার এলসিএম ফেরত দেয়।

এখানে ফাংশনটি বাস্তবায়ন করা হচ্ছে 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

(রুবি ২.২.১০ এবং ২.6.৩ এ পরীক্ষা করা হয়েছে)