Related Articles

# Minimum number that can be obtained by applying ‘+’ and ‘*’ operations on array elements

• Last Updated : 04 Aug, 2021

Given an array arr[] consisting of N positive integers and a string S of length (N – 1), containing characters ‘+’ and ‘*’, the task is to find the smallest number that can be obtained after applying the arithmetic operations mentioned in the string S on the array elements in any order.

Examples:

Input: A[] ={2, 2, 2, 2}, S = “**+”
Output: 8
Explanation:
Operation 1: Perform the multiplication operation on the first two elements operation i.e., arr*arr = 2*2 = 4. Now the array modifies to {4, 2, 2}.
Operation 2: Perform the multiplication operation on the remaining two elements i.e., arr*arr = 2*2 = 4. Now the array modifies to {4, 4}.
Operation 3: Perform the addition operation on the remaining elements arr + arr = 4 + 4 = 8. Now the array modifies to {8}.
Therefore, the result of the operation performed is 8, which is minimum.

Input: A[] = {1, 2, 3, 4}, S = “*++”
Output: 9

Approach: The given problem can be solved using bit-masking. Follow the steps below to solve the problem:

• Store the count of the multiplication and addition operation in the string S in variables, say mul and add respectively.
• Now, the operation applied on the elements of the array can be encoded in a mask(binary string) such that if the ith bit of mask is set then it is equal to ‘1’, and multiplication operation has to be performed. Otherwise, perform addition.
• Initialize a variable, say ans as INT_MAX that stores the minimum value of the result.
• So, create all masks in the range [0, 2(N – 1)] and find the number of set bits in the mask and perform the following steps:
• If the number of set bits in the mask is equal to mul, then apply this mask on the array A[] i.e., if the ith bit of mask is ‘1’ then perform multiplication operation on the ith element and (i + 1)th element.
• Update the value of ans to the minimum of the ans and the calculated value in the above step.
• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the smallest number``// that can  be obtained after applying``// the arithmetic operations mentioned``// in the string S``int` `minimumSum(``int` `A[], ``int` `N, string S)``{``    ``// Stores the count of multiplication``    ``// operator in the string``    ``int` `mul = 0;``    ``for` `(``int` `i = 0;``         ``i < (``int``)S.size(); i++) {``        ``if` `(S[i] == ``'*'``)``            ``mul += 1;``    ``}` `    ``// Store the required result``    ``int` `ans = 1000000;` `    ``// Iterate in the range to``    ``// create the mask``    ``for` `(``int` `i = 0;``         ``i < (1 << (N - 1)); i++) {``        ``int` `cnt = 0;``        ``vector<``char``> v;` `        ``// Checking the number of bits``        ``// that are set in the mask``        ``for` `(``int` `j = 0; j < N - 1; j++) {` `            ``if` `((1 << j) & (i)) {``                ``cnt += 1;``                ``v.push_back(``'*'``);``            ``}``            ``else` `{``                ``v.push_back(``'+'``);``            ``}``        ``}` `        ``// Check if the number of bits``        ``// that are set in the mask is``        ``// multiplication operation``        ``if` `(cnt == mul) {` `            ``// Storing the elements``            ``// that is to be added``            ``deque<``int``> d;``            ``d.push_back(A);` `            ``// Apply the multiplications``            ``// operation first``            ``for` `(``int` `j = 0; j < N - 1; j++) {` `                ``// If sign is '*', then``                ``// multiply last element``                ``// of deque with arr[i]``                ``if` `(v[j] == ``'*'``) {` `                    ``int` `x = d.back();``                    ``d.pop_back();``                    ``x = x * A[j + 1];` `                    ``// Push last multiplied``                    ``// element in the deque``                    ``d.push_back(x);``                ``}``                ``else` `{` `                    ``// If the element is to``                    ``// be added, then add``                    ``// it to the deque``                    ``d.push_back(A[j + 1]);``                ``}``            ``}` `            ``int` `sum = 0;` `            ``// Add all the element of``            ``// the deque``            ``while` `(d.size() > 0) {``                ``int` `x = d.front();``                ``sum += x;``                ``d.pop_front();``            ``}` `            ``// Minimize the answer with``            ``// the given sum``            ``ans = min(ans, sum);``        ``}``    ``}` `    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 2, 2, 2, 2 };``    ``string S = ``"**+"``;``    ``int` `N = ``sizeof``(A) / ``sizeof``(A);``    ``cout << minimumSum(A, N, S);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the smallest number``// that can  be obtained after applying``// the arithmetic operations mentioned``// in the String S``static` `int` `minimumSum(``int` `A[], ``int` `N, String S)``{``    ` `    ``// Stores the count of multiplication``    ``// operator in the String``    ``int` `mul = ``0``;``    ``for``(``int` `i = ``0``;``            ``i < (``int``)S.length(); i++)``    ``{``        ``if` `(S.charAt(i) == ``'*'``)``            ``mul += ``1``;``    ``}` `    ``// Store the required result``    ``int` `ans = ``1000000``;` `    ``// Iterate in the range to``    ``// create the mask``    ``for``(``int` `i = ``0``;``            ``i < (``1` `<< (N - ``1``)); i++)``    ``{``        ``int` `cnt = ``0``;``        ``Vector v = ``new` `Vector();` `        ``// Checking the number of bits``        ``// that are set in the mask``        ``for``(``int` `j = ``0``; j < N - ``1``; j++)``        ``{``            ``if` `(((``1` `<< j) & (i)) > ``0``)``            ``{``                ``cnt += ``1``;``                ``v.add(``'*'``);``            ``}``            ``else``            ``{``                ``v.add(``'+'``);``            ``}``        ``}` `        ``// Check if the number of bits``        ``// that are set in the mask is``        ``// multiplication operation``        ``if` `(cnt == mul)``        ``{``            ` `            ``// Storing the elements``            ``// that is to be added``            ``LinkedList d = ``new` `LinkedList();``            ``d.add(A[``0``]);` `            ``// Apply the multiplications``            ``// operation first``            ``for``(``int` `j = ``0``; j < N - ``1``; j++)``            ``{``                ` `                ``// If sign is '*', then``                ``// multiply last element``                ``// of deque with arr[i]``                ``if` `(v.get(j) == ``'*'``)``                ``{``                    ``int` `x = d.getLast();``                    ``d.removeLast();``                    ``x = x * A[j + ``1``];` `                    ``// Push last multiplied``                    ``// element in the deque``                    ``d.add(x);``                ``}``                ``else``                ``{``                    ` `                    ``// If the element is to``                    ``// be added, then add``                    ``// it to the deque``                    ``d.add(A[j + ``1``]);``                ``}``            ``}``            ``int` `sum = ``0``;` `            ``// Add all the element of``            ``// the deque``            ``while` `(d.size() > ``0``)``            ``{``                ``int` `x = d.peek();``                ``sum += x;``                ``d.removeFirst();``            ``}` `            ``// Minimize the answer with``            ``// the given sum``            ``ans = Math.min(ans, sum);``        ``}``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``2``, ``2``, ``2``, ``2` `};``    ``String S = ``"**+"``;``    ``int` `N = A.length;``    ` `    ``System.out.print(minimumSum(A, N, S));``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program for the above approach` `# Function to find the smallest number``# that can be obtained after applying``# the arithmetic operations mentioned``# in the string S``def` `minimumSum(A, N, S):``    ` `    ``# Stores the count of multiplication``    ``# operator in the string``    ``mul ``=` `0``    ``for` `i ``in` `range``(``len``(S)):``        ``if` `(S[i] ``=``=` `"*"``):``            ``mul ``+``=` `1``    ` `    ``# Store the required result``    ``ans ``=` `1000000``    ` `    ``# Iterate in the range to``    ``# create the mask``    ``for` `i ``in` `range``(``1` `<< (N ``-` `1``)):``        ``cnt ``=` `0``        ``v ``=` `[]``        ` `        ``# Checking the number of bits``        ``# that are set in the mask``        ``for` `j ``in` `range``(N ``-` `1``):``            ``if` `((``1` `<< j) & i):``                ``cnt ``+``=` `1``                ``v.append(``"*"``)``            ``else``:``                ``v.append(``"+"``)``            ` `        ``# Check if the number of bits``        ``# that are set in the mask is``        ``# multiplication operation``        ``if` `(cnt ``=``=` `mul):``            ` `            ``# Storing the elements``            ``# that is to be added``            ``d ``=` `[]``            ``d.append(A[``0``])``            ` `            ``# Apply the multiplications``            ``# operation first``            ``for` `j ``in` `range``(N ``-` `1``):``                ` `                ``# If sign is '*', then``                ``# multiply last element``                ``# of deque with arr[i]``                ``if` `(v[j] ``=``=` `"*"``):``                    ``x ``=` `d[``len``(d) ``-` `1``]``                    ``d.pop()``                    ``x ``=` `x ``*` `A[j ``+` `1``]``                    ` `                    ``# append last multiplied``                    ``# element in the deque``                    ``d.append(x)``                ``else``:``                    ` `                    ``# If the element is to``                    ``# be added, then add``                    ``# it to the deque``                    ``d.append(A[j ``+` `1``])``        ` `            ``sum` `=` `0``            ` `            ``# Add all the element of``            ``# the deque``            ``while` `(``len``(d) > ``0``):``                ``x ``=` `d[``0``]``                ``sum` `+``=` `x``                ``d.pop(``0``)``            ` `            ``# Minimize the answer with``            ``# the given sum``            ``ans ``=` `min``(ans, ``sum``)``        ` `    ``return` `ans` `# Driver Code``A ``=` `[ ``2``, ``2``, ``2``, ``2` `]``S ``=` `"**+"``N ``=` `len``(A)` `print``(minimumSum(A, N, S))` `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `// Function to find the smallest number``// that can  be obtained after applying``// the arithmetic operations mentioned``// in the String S``static` `int` `minimumSum(``int` `[]A, ``int` `N, String S)``{``    ` `    ``// Stores the count of multiplication``    ``// operator in the String``    ``int` `mul = 0;``    ``for``(``int` `i = 0;``            ``i < (``int``)S.Length; i++)``    ``{``        ``if` `(S[i] == ``'*'``)``            ``mul += 1;``    ``}` `    ``// Store the required result``    ``int` `ans = 1000000;` `    ``// Iterate in the range to``    ``// create the mask``    ``for``(``int` `i = 0;``            ``i < (1 << (N - 1)); i++)``    ``{``        ``int` `cnt = 0;``        ``List<``char``> v = ``new` `List<``char``>();` `        ``// Checking the number of bits``        ``// that are set in the mask``        ``for``(``int` `j = 0; j < N - 1; j++)``        ``{``            ``if` `(((1 << j) & (i)) > 0)``            ``{``                ``cnt += 1;``                ``v.Add(``'*'``);``            ``}``            ``else``            ``{``                ``v.Add(``'+'``);``            ``}``        ``}` `        ``// Check if the number of bits``        ``// that are set in the mask is``        ``// multiplication operation``        ``if` `(cnt == mul)``        ``{``            ` `            ``// Storing the elements``            ``// that is to be added``            ``List<``int``> d = ``new` `List<``int``>();``            ``d.Add(A);` `            ``// Apply the multiplications``            ``// operation first``            ``for``(``int` `j = 0; j < N - 1; j++)``            ``{``                ` `                ``// If sign is '*', then``                ``// multiply last element``                ``// of deque with arr[i]``                ``if` `(v[j] == ``'*'``)``                ``{``                    ``int` `x = d[d.Count-1];``                    ``d.RemoveAt(d.Count-1);``                    ``x = x * A[j + 1];` `                    ``// Push last multiplied``                    ``// element in the deque``                    ``d.Add(x);``                ``}``                ``else``                ``{``                    ` `                    ``// If the element is to``                    ``// be added, then add``                    ``// it to the deque``                    ``d.Add(A[j + 1]);``                ``}``            ``}``            ``int` `sum = 0;` `            ``// Add all the element of``            ``// the deque``            ``while` `(d.Count > 0)``            ``{``                ``int` `x = d;``                ``sum += x;``                ``d.RemoveAt(0);``            ``}` `            ``// Minimize the answer with``            ``// the given sum``            ``ans = Math.Min(ans, sum);``        ``}``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]A = { 2, 2, 2, 2 };``    ``String S = ``"**+"``;``    ``int` `N = A.Length;``    ` `    ``Console.Write(minimumSum(A, N, S));``}``}` `// This code contributed by shikhasingrajput`

## Javascript

 ``
Output:
`8`

Time Complexity: O(2(N – 1)*N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up