GeeksforGeeks App
Open App
Browser
Continue

# Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts

Given an array arr[] consisting of N positive integers, the task is to find the minimum possible length of a rod that can be cut into N equal parts such that every ith part can be cut into arr[i] equal parts.

Examples:

Input: arr[] = {1, 2}
Output: 4
Explanation:
Consider the length of the rod as 4. Then it can be divided in 2 equal parts, each having length 2.
Now, part 1 can be divided in arr[0](= 1) equal parts of length 2.
Part 2 can be divided in arr[1](= 2) equal parts of length 1.
Therefore, the minimum length of the rod must be 4.

Input: arr[] = {1, 1}
Output: 2

Naive Approach: The given problem can be solved based on the following observations:

• Consider the minimum length of the rod is X, then this rod is cut into N equal parts and the length of each part will be X/N.
• Now each N parts will again be cut down as follows:
• Part 1 will be cut into arr[0] equal where each part has a length say a1.
• Part 2 will be cut into arr[1] equal where each part has a length say a2.
• Part 3 will be cut into arr[2] equal where each part has a length say a3.
• .
• .
• .
• and so on.
• Now, the above relation can also be written as:

X/N = arr[0]*a1 = arr[1]*a2 =  …  = arr[N – 1]*aN.

• Therefore, the minimum length of the rod is given by:

N*lcm (arr[0]*a1, arr[1]*a2, …, arr[N – 1]*aN)

From the above observations, print the value of the product of N and the LCM of the given array arr[] as the resultant minimum length of the rod.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find GCD``// of two numbers a and b``int` `gcd(``int` `a, ``int` `b)``{``    ``// Base Case``    ``if` `(b == 0)``        ``return` `a;` `    ``// Find GCD recursively``    ``return` `gcd(b, a % b);``}` `// Function to find the LCM``// of the resultant array``int` `findlcm(``int` `arr[], ``int` `n)``{``    ``// Initialize a variable ans``    ``// as the first element``    ``int` `ans = arr[0];` `    ``// Traverse the array``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Update LCM``        ``ans = (((arr[i] * ans))``               ``/ (gcd(arr[i], ans)));``    ``}` `    ``// Return the minimum``    ``// length of the rod``    ``return` `ans;``}` `// Function to find the minimum length``// of the rod that can be divided into``// N equals parts and each part can be``// further divided into arr[i] equal parts``void` `minimumRod(``int` `A[], ``int` `N)``{``    ``// Print the result``    ``cout << N * findlcm(A, N);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``minimumRod(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `public` `class` `GFG {` `    ``// Function to find GCD``    ``// of two numbers a and b``    ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``        ``// Base Case``        ``if` `(b == ``0``)``            ``return` `a;` `        ``// Find GCD recursively``        ``return` `gcd(b, a % b);``    ``}` `    ``// Function to find the LCM``    ``// of the resultant array``    ``static` `int` `findlcm(``int` `arr[], ``int` `n)``    ``{``        ``// Initialize a variable ans``        ``// as the first element``        ``int` `ans = arr[``0``];` `        ``// Traverse the array``        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``// Update LCM``            ``ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));``        ``}` `        ``// Return the minimum``        ``// length of the rod``        ``return` `ans;``    ``}` `    ``// Function to find the minimum length``    ``// of the rod that can be divided into``    ``// N equals parts and each part can be``    ``// further divided into arr[i] equal parts``    ``static` `void` `minimumRod(``int` `A[], ``int` `N)``    ``{``        ``// Print the result``        ``System.out.println(N * findlcm(A, N));``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``2` `};``        ``int` `N = arr.length;``        ``minimumRod(arr, N);``    ``}``}` `// This code is contributed by Kingash.`

## Python3

 `# Python3 program for the above approach` `# Function to find GCD``# of two numbers a and b``def` `gcd(a, b):``    ` `    ``# Base Case``    ``if` `(b ``=``=` `0``):``        ``return` `a``        ` `    ``# Find GCD recursively``    ``return` `gcd(b, a ``%` `b)` `# Function to find the LCM``# of the resultant array``def` `findlcm(arr, n):``    ` `    ``# Initialize a variable ans``    ``# as the first element``    ``ans ``=` `arr[``0``]``    ` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):``        ` `        ``# Update LCM``        ``ans ``=` `(((arr[i] ``*` `ans)) ``/``            ``(gcd(arr[i], ans)))``    ` `    ``# Return the minimum``    ``# length of the rod``    ``return` `ans` `# Function to find the minimum length``# of the rod that can be divided into``# N equals parts and each part can be``# further divided into arr[i] equal parts``def` `minimumRod(A, N):``    ` `    ``# Print the result``    ``print``(``int``(N ``*` `findlcm(A, N)))` `# Driver Code``arr ``=` `[ ``1``, ``2` `]``N ``=` `len``(arr)` `minimumRod(arr, N)` `# This code is contributed by sanjoy_62`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``  ` `    ``// Function to find GCD``    ``// of two numbers a and b``    ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``      ` `        ``// Base Case``        ``if` `(b == 0)``            ``return` `a;` `        ``// Find GCD recursively``        ``return` `gcd(b, a % b);``    ``}` `    ``// Function to find the LCM``    ``// of the resultant array``    ``static` `int` `findlcm(``int``[] arr, ``int` `n)``    ``{``      ` `        ``// Initialize a variable ans``        ``// as the first element``        ``int` `ans = arr[0];` `        ``// Traverse the array``        ``for` `(``int` `i = 1; i < n; i++) {` `            ``// Update LCM``            ``ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));``        ``}` `        ``// Return the minimum``        ``// length of the rod``        ``return` `ans;``    ``}` `    ``// Function to find the minimum length``    ``// of the rod that can be divided into``    ``// N equals parts and each part can be``    ``// further divided into arr[i] equal parts``    ``static` `void` `minimumRod(``int``[] A, ``int` `N)``    ``{``      ` `        ``// Print the result``        ``Console.WriteLine(N * findlcm(A, N));``    ``}``  ` `  ``// Driver code``    ``static` `void` `Main()``    ``{``        ``int``[] arr = { 1, 2 };``        ``int` `N = arr.Length;``        ``minimumRod(arr, N);``    ``}``}` `// This code is contributed by sk944795.`

## Javascript

 ``

Output:

`4`

Time Complexity: O(N*log M) where M is the maximum element of the array.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up