Sum of LCM in Java

In the input, a number n is given. Our task is to find the sum of LCM of numbers from 1 to n with the number N, respectively. In other words, we have to find the value of lcm(1, n) + lcm(2, n) + lcm(3, n) + … + lcm(n, n).

Example 1:

Input

int n = 6

Output: 66

Explanation: The value of lcm(1, 6) + lcm(2, 6) + lcm(3, 6) + lcm(4, 6) + lcm(5, 6) + lcm(6, 6) = 6 + 6 + 6 + 12 + 30 + 6 = 66

Example 2:

Input

int n = 3

Output: 12

Explanation: The value of lcm(1, 3) + lcm(2, 3) + lcm(3, 3) = 3 + 6 + 3 = 12

Simple Approach

The simple approach is to run a loop and compute the LCM for each pair. The LCM of two numbers p and q (say) can be found by using a loop that runs from the maximum of p and q to p x q. In each iteration, we have to check whether the value pointed by the loop variable is completely divisible by p and q or not. If yes, we can terminate the loop using a break statement, and the value is our LCM of the numbers p and q. If not, then the loop continues. Observe the following program.

FileName: LCMSum.java

public class LCMSum 
{
// a method that finds the lcm of numbers a and b
public int findLCM(int a, int b)
{
int maxLimit = a * b;
int lcmVal = 1;
while((maxLimit >= a) && (maxLimit >= b))
{
if((maxLimit % a) == 0 && (maxLimit % b) == 0)
{
lcmVal = maxLimit;
}
maxLimit = maxLimit - 1;
}

return lcmVal;
}

// a method that computes the sum of LCM of (a, n)
// where 1 <= a <= n
public int lcmSum(int n)
{
int sum = 0;
for(int i = 1; i <= n; i++)
{
sum = sum + findLCM(i, n);
}

return sum;
}

// main method
public static void main(String argvs[]) 
{
// creating an object of the class LCMSum
LCMSum obj = new LCMSum();

// input 1
int n = 6;

// invoking the method lcmSum()
int ans = obj.lcmSum(n);
System.out.println("The sum of LCM of numbers for the input number: " + n + " is " + ans);

System.out.println(" \n ");

// input 2
n = 3;

// invoking the method lcmSum()
ans = obj.lcmSum(n);
System.out.println("The sum of LCM of numbers for the input number: " + n + " is " + ans);

}
}

Output:

The sum of LCM of numbers for the input number: 6 is 66
 
 
The sum of LCM of numbers for the input number: 3 is 12

Complexity Analysis: There is a loop running from 1 to n, which takes O(n) time. In each iteration, we are invoking the method findLCM() that takes O(a * n), where a runs from 1 to n. Thus, the overall time complexity of the program is O(a * n²), where n is the input number. The space complexity of the program is O(1).

Now, let us reduce the time complexity of the program by doing some optimization.

Approach: Using Mathematical Formula

The basic mathematical formula of the product of two natural numbers, p and q, are:

p x q = HCF(p, q) x LCM(p, q). Hence, LCM(p, q) = (p x q) / HCF(p, q). The numbers p and q are already known. The only thing to find is the HCF (Highest Common Factor). HCF can be found using a loop, which runs from min(p, q) to 1. If the value pointed by the loop variable divides both the number completely, then that value is our HCF, and we can terminate the loop. After that, finding the LCM(p, q) is easy.

Another way to find the HCF is the Euclidean algorithm. We will be implementing both these ways to find HCF and, eventually, LCM. See the following program.

FileName: LCMSum1.java

public class LCMSum1 
{
// finding minimum using p and q
public int findMin(int p, int q)
{
    return (p > q) ? q : p;
}

// a method that finds the LCM of numbers a and b
public int findLCMUsingLoop(int a, int b)
{
int minVal = findMin(a, b);
int ans = 0;
for(int i = minVal; i >= 1; i--)
{
if((a % i) == 0 && (b % i) == 0)
{
    ans = i;
    break;
}
}

int lcmVal = (a * b) / ans;

return lcmVal;

}

// a method that finds the HCF of numbers a and b using the Euclidean Algorithm
public int findHCFUsingEuclideanAlgo(int a, int b)
{
// handling the base case
if(a == 0)
{
    return b;
}

// recursively find the HCF
return findHCFUsingEuclideanAlgo(b % a, a);

}

// a method the finds the LCM of numbers a and b
public int findLCMUsingEuclidean(int a, int b)
{

int lcmVal = (a * b) / findHCFUsingEuclideanAlgo(a, b);

// finding the LCM
return lcmVal;

}

// a method that computes the sum of LCM of (a, n)
// where 1 <= a <= n
public int lcmSum(int n)
{
int sum = 0;
for(int i = 1; i <= n; i++)
{
sum = sum + findLCMUsingEuclidean(i, n); // line 60
}

return sum;
}

// main method
public static void main(String argvs[]) 
{
// creating an object of the class LCMSum1
LCMSum1 obj = new LCMSum1();

// input 1
int n = 6;

// invoking the method lcmSum()
int ans = obj.lcmSum(n);
System.out.println("The sum of LCM of numbers for the input number: " + n + " is " + ans);

System.out.println(" \n ");

// input 2
n = 3;

// invoking the method lcmSum()
ans = obj.lcmSum(n);
System.out.println("The sum of LCM of numbers for the input number: " + n + " is " + ans);

}
}

Output:

The sum of LCM of numbers for the input number: 6 is 66
 
 
The sum of LCM of numbers for the input number: 3 is 12

Complexity Analysis: The method invoked at line 60 decides the time complexity of the program. In the program, the method findLCMUsingEuclidean() is invoked (at line 60). The time complexity of the method findLCMUsingEuclidean() is O(log(min(a, n))), where a ranges from 1 to n. Also, that method is invoked n times. Thus, the overall time complexity of the program is O(n x log(min(a, n))). If we use the method findLCMUsingMethod() (at line 60), then the time consumed by the method is O(min(a, n)). The overall time complexity of the program is O(n x log(min(a, n), where n is the input number.

Approach: Using Euler Totient Function

We will use the Euler Totient method for solving the problem.

The function Euler's Totient Φ(p) for an input 'p' is the number count in the list {1, 2, 3, …, p} that are relatively prime to p. In other words, the numbers whose HCF (Highest Common Factor) with p is equal to 1. Some examples are given below.

Example 1:

Φ(1) = 1

gcd(1, 1) is 1

Example 2:

Φ(4) = 2

gcd(1, 4) is 1 and gcd(3, 4) is 1

Example 3:

Φ(7) = 6

gcd(1, 7) is 1, gcd(2, 7) is 1,

gcd(3, 7) is 1 and gcd(4, 7) is 1

gcd(5, 7) is 1 and gcd(6, 7) is 1

Example 4:

Φ(8) = 4

gcd(1, 8) is 1 and gcd(3, 8) is 1

gcd(5, 8) is 1 and gcd(7, 8) is 1

For calculating Φ (p), one can use two approaches:

1) Using HCF

Run a loop from 1 to p, and check the HCF for each number with p. Whenever the HCF is 1, one can increment the value. The other approach is to use the Euler Formula

2) Using The Euler Product Formula

The formula tells that the value of Φ(p) is equal to p multiplied by the product of (1 - 1/t) for all prime factors t of N. For example, the value of:

Φ(12) = 12 * (1 - 1 / 2) * (1 - 1 / 3) = 4. Note that 2 and 3 are the prime factors of 12.

After computing the ETF (Euler Totient Function) for each number, we can use the following Euler's formula of LCM sum :

∑LCM(a, p) = ((∑(div * ETF(div)) + 1) * p) / 2

where ETF(div) is the Euler totient function of div and div is the set of divisors of p.

Let's verify with the help of an example.

Example

∑LCM(a, p) = LCM(1, 6) + LCM(2, 6) + LCM(3, 6) + LCM(4, 6) + LCM(5, 6) + LCM(6, 6) = 6 + 6 + 6 + 12 + 30 + 6 = 66, where a = 1, p = 6

Now, let's use Euler Totient Function:

All divisors of 6 are: {1, 2, 3, 6}

Hence, ((1 x ETF(1) + 2 x ETF(2) + 3 x ETF(3) + 6 x ETF(6) + 1) * 6) / 2 = ((1 + 2 + 6 + 12 + 1) x 6) / 2 = 132 / 2 = 66

We get the same result. Now comes the implementation part.

FileName: LCMSum2.java

public class LCMSum2 
{

// class variables
private static int[] reslt;
private static int[] phie;
private static int flag = 0;

public void preCalculate(int n) 
{
    reslt = new int[100001];
    phie = new int[100001];

    for (int p = 1; p <= n; ++p)  
    {
        phie[p] = p;
    }

    // the nested for-loop is computing the value of ETF(d)
    for (int i = 2; i <= n; ++i) 
    {
        if (phie[i] == i) 
        {
            for (int j = i; j <= n; j += i) 
            {
                phie[j] /= i;
                phie[j] *= i - 1;
            }
        }
    }

    // the value of (d x ETF(d))
    for (int p = 1; p <= n; ++p) 
    {
        for (int j = p; j <= n; j += p) 
        {
            reslt[j] += (p * phie[p]);
        }
    }
    return;
}
    
// a method that computes the sum of LCM of (a, n)
// where 1 <= a <= n
public int lcmSum(int n)
{
if (flag == 0) 
{
preCalculate(100000);
flag = 1;
}

int ans = reslt[n] + 1;
ans = ans * n;
ans = ans / 2;
return ans;
}

    
// main method
public static void main(String argvs[]) 
{
// creating an object of the class LCMSum2
LCMSum2 obj = new LCMSum2();

// input 1
int n = 6;

// invoking the method lcmSum()
int ans = obj.lcmSum(n);
System.out.println("The sum of LCM of numbers for the input number: " + n + " is " + ans);

System.out.println(" \n ");

// input 2
n = 3;

// invoking the method lcmSum()
ans = obj.lcmSum(n);
System.out.println("The sum of LCM of numbers for the input number: " + n + " is " + ans);

}
}

Output:

The sum of LCM of numbers for the input number: 6 is 66
 
 
The sum of LCM of numbers for the input number: 3 is 12

Complexity Analysis: Finding the factor of a number n takes log(log(n)) time, and we are finding the factor of n numbers. Therefore, the overall time complexity of the program is O(n x log(log(n))), where n is the input number.

Next TopicTilde Operator in Java

← prev next →