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++ program for the above approach #include <bits/stdc++.h> 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 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 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# 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. |
<script> // javascript program for the above approach // Function to find GCD
// of two numbers a and b
function 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
function findlcm(arr, n)
{
// Initialize a variable ans
// as the first element
let ans = arr[0];
// Traverse the array
for (let 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
function minimumRod(A, N)
{
// Print the result
document.write(N * findlcm(A, N));
}
// Driver Code let arr = [ 1, 2 ];
let N = arr.length;
minimumRod(arr, N);
</script> |
4
Time Complexity: O(N*log M) where M is the maximum element of the array.
Auxiliary Space: O(1)