Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Generate a sequence such that float division of array elements is maximized

  • Last Updated : 13 Jan, 2022

Given an array arr[] consisting of N integers, the task is to find the expression by using parenthesis ‘(‘ and ‘)’ and division operator ‘/’ to maximize the value of the expression of subsequent float division of array elements.

Examples:

Input: arr[] = {1000, 100, 10, 2}
Output: “1000/(100/10/2)”
Explanation:
The value of the expression 1000/(100/10/2) can be calculated as 1000/((100/10)/2) = 200.

Input: arr[] = {2, 3, 4}
Output: “2/(3/4)”

Approach: The idea is based on the observation that for every division, the result is maximum only when the denominator is minimum. Therefore, the task reduces to place the parentheses and operators in such a way that the denominator is minimum. Consider the following example to solve the problem:



Consider an expression 1000 / 100 / 10 / 2.
To make its value maximum, denominator needs to be minimized. Therefore, the denominators need to be in the sequence 100, 10, 2.
Now, consider the following cases:

  • 100 / (10 / 2) = (100 × 2) / 10 = 20
  • (100 / 10) / 2 = 10 / 2 = 5

Therefore, the minimized value for the expression is obtained for the second case. Therefore, 1000 / (100 / 10 / 2) is the required sequence.

Therefore, from the above example, it can be concluded that the parenthesis needs to be placed to the sequence after the first integer that makes the whole sequence from the second integer reduced to the minimum value possible. 
Follow the steps below to solve the problem:

  • Initialize a string S as “”, to store the final expression.
  • If N is equal to 1, print the integer in string form.
  • Otherwise, append arr[0] and “/(“ in S, and then append all the remaining integers of arr[] separated by “/”.
  • At last, append “)” in the string S and print the string S as the result.

Below is the implementation of the above approach:

C++14




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to place the parenthesis
// such that the result is maximized
void generateSequence(int arr[], int n)
{
    // Store the required string
    string ans;
 
    // Add the first integer to string
    ans = to_string(arr[0]);
 
    // If the size of array is 1
    if (n == 1)
        cout << ans;
 
    // If the size of array is 2, print
    // the 1st integer followed by / operator
    // followed by the next integer
    else if (n == 2) {
        cout << ans + "/"
             << to_string(arr[1]);
    }
 
    // If size of array is exceeds two,
    // print 1st integer concatenated
    // with operators '/', '(' and next
    // integers with the operator '/'
    else {
        ans += "/(" + to_string(arr[1]);
 
        for (int i = 2; i < n; i++) {
            ans += "/" + to_string(arr[i]);
        }
 
        // Add parenthesis at the end
        ans += ")";
 
        // Print the final expression
        cout << ans;
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 1000, 100, 10, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
    generateSequence(arr, N);
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
class GFG
{
 
// Function to place the parenthesis
// such that the result is maximized
static void generateSequence(int arr[], int n)
{
   
    // Store the required string
    String ans;
 
    // Add the first integer to string
    ans = Integer.toString(arr[0]);
 
    // If the size of array is 1
    if (n == 1)
        System.out.println(ans);
 
    // If the size of array is 2, print
    // the 1st integer followed by / operator
    // followed by the next integer
    else if (n == 2) {
        System.out.println(ans + "/"
            + Integer.toString(arr[1]));
    }
 
    // If size of array is exceeds two,
    // print 1st integer concatenated
    // with operators '/', '(' and next
    // integers with the operator '/'
    else {
        ans += "/(" + Integer.toString(arr[1]);
 
        for (int i = 2; i < n; i++) {
            ans += "/" + Integer.toString(arr[i]);
        }
 
        // Add parenthesis at the end
        ans += ")";
 
        // Print the final expression
        System.out.println(ans);
    }
}
 
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1000, 100, 10, 2 };
    int N = arr.length;
    generateSequence(arr, N);
}
}
 
// This code is contributed by code_hunt.
Python3



# Python3 program for the above approach
 
# Function to place the parenthesis
# such that the result is maximized
def generateSequence(arr, n):
     
    # Store the required string
    ans = ""
 
    # Add the first integer to string
    ans = str(arr[0])
 
    # If the size of array is 1
    if (n == 1):
        print(ans)
 
    # If the size of array is 2, print
    # the 1st integer followed by / operator
    # followed by the next integer
    elif (n == 2):
        print(ans + "/"+str(arr[1]))
     
    # If size of array is exceeds two,
    # pr1st integer concatenated
    # with operators '/', '(' and next
    # integers with the operator '/'
    else:
        ans += "/(" + str(arr[1])
 
        for i in range(2, n):
            ans += "/" + str(arr[i])
 
        # Add parenthesis at the end
        ans += ")"
 
        # Print final expression
        print(ans)
 
# Driver Code
if __name__ == '__main__':
    arr = [1000, 100, 10, 2]
    N = len(arr)
    generateSequence(arr, N)
 
    # This code is contributed by mohit kumar 29.
C#



// C# program for the above approach
using System;
class GFG
{
 
// Function to place the parenthesis
// such that the result is maximized
static void generateSequence(int []arr, int n)
{
   
    // Store the required string
    string ans="";
 
    // Add the first integer to string
    ans = arr[0].ToString();
 
    // If the size of array is 1
    if (n == 1)
        Console.WriteLine(ans);
 
    // If the size of array is 2, print
    // the 1st integer followed by / operator
    // followed by the next integer
    else if (n == 2) {
        Console.WriteLine(ans + "/"
            + arr[1].ToString());
    }
 
    // If size of array is exceeds two,
    // print 1st integer concatenated
    // with operators '/', '(' and next
    // integers with the operator '/'
    else {
        ans += "/(" + arr[1].ToString();
 
        for (int i = 2; i < n; i++) {
            ans += "/" + arr[i].ToString();
        }
 
        // Add parenthesis at the end
        ans += ")";
 
        // Print the final expression
        Console.WriteLine(ans);
    }
}
 
// Driver Code
public static void Main(string[] args)
{
    int []arr = { 1000, 100, 10, 2 };
    int N = arr.Length;
    generateSequence(arr, N);
}
}
 
// This code is contributed by chitranayal.
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to place the parenthesis
// such that the result is maximized
function generateSequence(arr, n)
{
    // Store the required string
    var ans;
 
    // Add the first integer to string
    ans = (arr[0].toString());
 
    // If the size of array is 1
    if (n == 1)
        document.write( ans);
 
    // If the size of array is 2, print
    // the 1st integer followed by / operator
    // followed by the next integer
    else if (n == 2) {
        document.write( ans + "/"
             + (arr[1].toString()));
    }
 
    // If size of array is exceeds two,
    // print 1st integer concatenated
    // with operators '/', '(' and next
    // integers with the operator '/'
    else {
        ans += "/(" + (arr[1].toString());
 
        for (var i = 2; i < n; i++) {
            ans += "/" + (arr[i].toString());
        }
 
        // Add parenthesis at the end
        ans += ")";
 
        // Print the final expression
        document.write( ans);
    }
}
 
// Driver Code
var arr = [1000, 100, 10, 2];
var N = arr.length;
generateSequence(arr, N);
 
// This code is contributed by noob2000.
</script>
Output: 
1000/(100/10/2)
 
Time Complexity: O(N)
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
How to Crop Image from Camera and Gallery in Android?
Next

Sum of Bitwise AND of the sum of all leaf and non-leaf nodes for each level of a Binary Tree
Recommended Articles
Page :
Generate an Array such with elements maximized through swapping bits
02, Jul 20
Generate an N-length array having length of non-decreasing subarrays maximized and minimum difference between first and last array elements
23, Jul 21
Generate a sequence X from given sequence Y such that Yi = gcd(X1, X2 , ... , Xi)
09, Dec 21
Split array into K non-empty subsets such that sum of their maximums and minimums is maximized
19, Apr 21
Split array into K subarrays such that sum of maximum of all subarrays is maximized
11, Jun 21
Count of pairs of (i, j) such that ((n % i) % j) % n is maximized
22, Jan 19
Largest number M having bit count of N such that difference between their OR and XOR value is maximized
15, Aug 20
Maximized partitions of a string such that each character of the string appears in one substring
15, Sep 20
Place N boys and M girls in different rows such that count of persons placed in each row is maximized
10, Mar 21
Lengths of maximized partitions of a string such that each character of the string appears in one substring
15, Sep 20
Count array elements that can be maximized by adding any permutation of first N natural numbers
12, Sep 20
Generate a sequence with product N such that for every pair of indices (i, j) and i < j, arr[j] is divisible by arr[i]
18, Jul 21
Smallest subsequence with sum of absolute difference of consecutive elements maximized
20, Jun 20
Generate an array of K elements such that sum of elements is N and the condition a[i] < a[i+1] <= 2*a[i] is met | Set 2
09, May 19
Generate minimum sum sequence of integers with even elements greater
25, Jan 19
Maximize count of 1s in an array by repeated division of array elements by 2 at most K times
10, Feb 21
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Find K numbers with sum equal to N and sum of their squares maximized
07, May 20
Breaking a number such that first part is integral division of second by a power of 10
11, Dec 17
Print indices in non-decreasing order of quotients of array elements on division by X
18, Jan 21
Generate an array of maximum sum such that each element exceeds all elements present either on its left or right
03, Aug 21
Generate an N-length sequence from two given arrays whose GCD is K
04, Mar 21
Generate a sequence with the given operations
26, Nov 18
Generate Bitonic Sequence of length N from integers in a given range
17, Nov 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
apoorvadaga
@apoorvadaga
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!