mathematics - math video



दो पूर्णांक के कम से कम सामान्य एकाधिक की गणना करने का सबसे प्रभावी तरीका क्या है? (6)

दो पूर्णांक के कम से कम सामान्य एकाधिक की गणना करने का सबसे प्रभावी तरीका क्या है?

मैं बस इसके साथ आया, लेकिन यह निश्चित रूप से वांछित होने के लिए कुछ छोड़ देता है।

int n=7, m=4, n1=n, m1=m;

while( m1 != n1 ){
    if( m1 > n1 )
        n1 += n;
    else 
        m1 += m;
}

System.out.println( "lcm is " + m1 );

2 संख्याओं का उत्पाद एलसीएम * जीसीडी या एचसीएफ के बराबर है। एलसीएम खोजने का सबसे अच्छा तरीका जीसीडी ढूंढना और उत्पाद को जीडीसी के साथ विभाजित करना है


परिणाम दो संख्याओं के बड़े होने के लगातार गुणांक लें जब तक कि परिणाम छोटे से एक न हो।

यह काम कर सकता है ..

   public int LCM(int x, int y)
   {
       int larger  = x>y? x: y,
           smaller = x>y? y: x,
           candidate = larger ;
       while (candidate % smaller  != 0) candidate += larger ;
       return candidate;
   }

मुझे नहीं पता कि यह अनुकूलित है या नहीं, लेकिन शायद सबसे आसान:

public void lcm(int a, int b)
{
    if (a > b)
    {
        min = b;
        max = a;
    }
    else
    {
        min = a;
        max = b;
    }
    for (i = 1; i < max; i++)
    {
        if ((min*i)%max == 0)
        {
            res = min*i;
            break;
        }
    }
    Console.Write("{0}", res);
}

मुझे लगता है कि " सबसे बड़ा आम विभाजक द्वारा कमी " का दृष्टिकोण तेजी से होना चाहिए। जीसीडी की गणना करके शुरू करें (उदाहरण के लिए यूक्लिड के एल्गोरिदम का उपयोग करके), फिर जीसीडी द्वारा दो संख्याओं के उत्पाद को विभाजित करें।


सी ++ टेम्पलेट। समय संकलित करें

#include <iostream>

const int lhs = 8, rhs = 12;

template<int n, int mod_lhs=n % lhs, int mod_rhs=n % rhs> struct calc {
  calc() { }
};

template<int n> struct calc<n, 0, 0> {
  calc() { std::cout << n << std::endl; }
};

template<int n, int mod_rhs> struct calc<n, 0, mod_rhs> {
  calc() { }
};

template<int n, int mod_lhs> struct calc <n, mod_lhs, 0> {
  calc() { }
};

template<int n> struct lcm {
  lcm() {
    lcm<n-1>();
    calc<n>();
  }
};

template<> struct lcm<0> {
  lcm() {}
};

int main() {
  lcm<lhs * rhs>();
}

a और b का कम से कम आम (एलसीएम) उनका उत्पाद उनके सबसे बड़े आम विभाजक (जीसीडी) (यानी lcm(a, b) = ab/gcd(a,b) द्वारा विभाजित है।

तो, सवाल बन जाता है, जीसीडी कैसे ढूंढें? यूक्लिडियन एल्गोरिदम आम तौर पर जीसीडी की गणना कैसे की जाती है। क्लासिक एल्गोरिदम का प्रत्यक्ष कार्यान्वयन कुशल है, लेकिन कुछ भिन्नताएं हैं जो थोड़ा बेहतर करने के लिए बाइनरी अंकगणित का लाभ उठाती हैं। Knuth की " कंप्यूटर प्रोग्रामिंग की कला " वॉल्यूम 2, "सेमिन्यूमेरिकल एल्गोरिदम" § 4.5.2 देखें





math