Open In App

# Print all possible expressions that evaluate to a target

Given a string that contains only digits from 0 to 9, and an integer value, target. Find out how many expressions are possible which evaluate to target using binary operator +, – and * in given string of digits.

```Input : "123",  Target : 6
Output : {“1+2+3”, “1*2*3”}

Input : “125”, Target : 7
Output : {“1*2+5”, “12-5”}```

This problem can be solved by putting all possible binary operator in mid between two digits and evaluating them and then check they evaluate to target or not.

• While writing the recursive code, we need to keep these variable as argument of recursive method – result vector, input string, current expression string, target value, position till which input is processed, current evaluated value and last value in evaluation.
• Last value is kept in recursion because of multiplication operation, while doing multiplication we need last value for correct evaluation.

See below example for better understanding –

```Input is 125, suppose we have reached till 1+2 now,
Input = “125”, current expression = “1+2”,
position = 2, current val = 3, last = 2

Now when we go for multiplication, we need last
value for evaluation as follows:

current val = current val - last + last * current val

First we subtract last and then add last * current
val for evaluation, new last is last * current val.
current val = 3 – 2 + 2*5 = 11
last = 2*5 = 10 ```

Another thing to note in below code is, we have ignored all numbers which start from 0 by imposing a condition as first condition inside the loop so that we will not process number like 03, 05 etc.
See the use of c_str() function, this function converts the C++ string into C char array, this function is used in below code because atoi() function expects a character array as an argument not the string. It converts character array to number.

## C++

 `// C++ program to find all possible expression which``// evaluate to target``#include ``using` `namespace` `std;` `// Utility recursive method to generate all possible``// expressions``void` `getExprUtil(vector& res, string curExp,``                 ``string input, ``int` `target, ``int` `pos,``                 ``int` `curVal, ``int` `last)``{``    ``// true if whole input is processed with some``    ``// operators``    ``if` `(pos == input.length())``    ``{``        ``// if current value is equal to target``        ``//then only add to final solution``        ``// if question is : all possible o/p then just``        ``//push_back without condition``        ``if` `(curVal == target)``            ``res.push_back(curExp);``        ``return``;``    ``}` `    ``// loop to put operator at all positions``    ``for` `(``int` `i = pos; i < input.length(); i++)``    ``{``        ``// ignoring case which start with 0 as they``        ``// are useless for evaluation``        ``if` `(i != pos && input[pos] == ``'0'``)``            ``break``;` `        ``// take part of input from pos to i``        ``string part = input.substr(pos, i + 1 - pos);` `        ``// take numeric value of part``        ``int` `cur = ``atoi``(part.c_str());` `        ``// if pos is 0 then just send numeric value``        ``// for next recursion``        ``if` `(pos == 0)``            ``getExprUtil(res, curExp + part, input,``                     ``target, i + 1, cur, cur);`  `        ``// try all given binary operator for evaluation``        ``else``        ``{``            ``getExprUtil(res, curExp + ``"+"` `+ part, input,``                     ``target, i + 1, curVal + cur, cur);``            ``getExprUtil(res, curExp + ``"-"` `+ part, input,``                     ``target, i + 1, curVal - cur, -cur);``            ``getExprUtil(res, curExp + ``"*"` `+ part, input,``                     ``target, i + 1, curVal - last + last * cur,``                     ``last * cur);``        ``}``    ``}``}` `// Below method returns all possible expression``// evaluating to target``vector getExprs(string input, ``int` `target)``{``    ``vector res;``    ``getExprUtil(res, ``""``, input, target, 0, 0, 0);``    ``return` `res;``}` `// method to print result``void` `printResult(vector res)``{``    ``for` `(``int` `i = 0; i < res.size(); i++)``        ``cout << res[i] << ``" "``;``    ``cout << endl;``}` `// Driver code to test above methods``int` `main()``{``    ``string input = ``"123"``;``    ``int` `target = 6;``    ``vector res = getExprs(input, target);``    ``printResult(res);` `    ``input = ``"125"``;``    ``target = 7;``    ``res = getExprs(input, target);``    ``printResult(res);``    ``return` `0;``}`

## Java

 `// Java program to find all possible expression which``// evaluate to target` `import` `java.util.ArrayList;` `class` `GFG {` `    ``// Utility recursive method to generate all possible``    ``// expressions``    ``static` `void` `getExprUtil(ArrayList res,``                            ``String curExp, String input,``                            ``int` `target, ``int` `pos, ``int` `curVal,``                            ``int` `last)``    ``{``        ``// true if whole input is processed with some``        ``// operators``        ``if` `(pos == input.length()) {``            ``// if current value is equal to target``            ``// then only add to final solution``            ``// if question is : all possible o/p then just``            ``// push_back without condition``            ``if` `(curVal == target)``                ``res.add(curExp);``            ``return``;``        ``}` `        ``// loop to put operator at all positions``        ``for` `(``int` `i = pos; i < input.length(); i++) {``            ``// ignoring case which start with 0 as they``            ``// are useless for evaluation``            ``if` `(i != pos && input.charAt(pos) == ``'0'``)``                ``break``;` `            ``// take part of input from pos to i``            ``String part = input.substring(pos, i + ``1``);` `            ``// take numeric value of part``            ``int` `cur = Integer.parseInt(part);` `            ``// if pos is 0 then just send numeric value``            ``// for next recursion``            ``if` `(pos == ``0``)``                ``getExprUtil(res, curExp + part, input,``                            ``target, i + ``1``, cur, cur);` `            ``// try all given binary operator for evaluation``            ``else` `{``                ``getExprUtil(res, curExp + ``"+"` `+ part, input,``                            ``target, i + ``1``, curVal + cur,``                            ``cur);``                ``getExprUtil(res, curExp + ``"-"` `+ part, input,``                            ``target, i + ``1``, curVal - cur,``                            ``-cur);``                ``getExprUtil(res, curExp + ``"*"` `+ part, input,``                            ``target, i + ``1``,``                            ``curVal - last + last * cur,``                            ``last * cur);``            ``}``        ``}``    ``}` `    ``// Below method returns all possible expression``    ``// evaluating to target``    ``static` `ArrayList getExprs(String input,``                                      ``int` `target)``    ``{``        ``ArrayList res = ``new` `ArrayList();``        ``getExprUtil(res, ``""``, input, target, ``0``, ``0``, ``0``);``        ``return` `res;``    ``}` `    ``// method to print result``    ``static` `void` `printResult(ArrayList res)``    ``{``        ``for` `(``int` `i = ``0``; i < res.size(); i++)``            ``System.out.print(res.get(i) + ``" "``);``        ``System.out.println();``    ``}` `    ``// Driver code to test above methods``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String input = ``"123"``;``        ``int` `target = ``6``;``        ``ArrayList res = getExprs(input, target);``        ``printResult(res);` `        ``input = ``"125"``;``        ``target = ``7``;``        ``res = getExprs(input, target);``        ``printResult(res);``    ``}``}` `// This code is contributed by jainlovely450.o`

## Python3

 `# Python3 program to find all possible expression which``# evaluate to target` `# Utility recursive method to generate all possible``# expressions``def` `getExprUtil(res, curExp, _input, target, pos, curVal, last):``    ``# true if whole input is processed with some``    ``# operators``    ``if` `(pos ``=``=` `len``(_input)):``        ``# if current value is equal to target``        ``#then only add to final solution``        ``# if question is : all possible o/p then just``        ``#push_back without condition``        ``if` `(curVal ``=``=` `target):``            ``res.append(curExp)``        ``return``    `  `    ``# loop to put operator at all positions``    ``for` `i ``in` `range``(pos,``len``(_input)):``        ``# ignoring case which start with 0 as they``        ``# are useless for evaluation``        ``if` `(i !``=` `pos ``and` `_input[pos] ``=``=` `'0'``):``            ``break` `        ``# take part of input from pos to i``        ``part ``=` `_input[pos: i ``+` `1``].strip()` `        ``# take numeric value of part``        ``cur ``=` `int``(part)` `        ``# if pos is 0 then just send numeric value``        ``# for next recursion``        ``if` `(pos ``=``=` `0``):``            ``getExprUtil(res, curExp ``+` `part, _input,``                     ``target, i ``+` `1``, cur, cur)`  `        ``# try all given binary operator for evaluation``        ``else``:``            ``getExprUtil(res, curExp ``+` `"+"` `+` `part, _input,``                     ``target, i ``+` `1``, curVal ``+` `cur, cur)``            ``getExprUtil(res, curExp ``+` `"-"` `+` `part, _input,``                     ``target, i ``+` `1``, curVal ``-` `cur, ``-``cur)``            ``getExprUtil(res, curExp ``+` `"*"` `+` `part, _input,``                     ``target, i ``+` `1``, curVal ``-` `last ``+` `last ``*` `cur,``                     ``last ``*` `cur)``        ` `    `   `# Below method returns all possible expression``# evaluating to target``def` `getExprs(_input, target):``    ``res``=``[]``    ``getExprUtil(res, "", _input, target, ``0``, ``0``, ``0``)``    ``return` `res`  `# method to print result``def` `printResult(res):``    ``for` `i ``in` `range``(``len``(res)):``        ``print``(res[i],end``=``" "``)``    ``print``()`  `# Driver code to test above methods``if` `__name__ ``=``=` `'__main__'``:``    ``_input ``=` `"123"``    ``target ``=` `6``    ``res ``=` `getExprs(_input, target)``    ``printResult(res)` `    ``_input ``=` `"125"``    ``target ``=` `7``    ``res ``=` `getExprs(_input, target)``    ``printResult(res)`

## C#

 `// C# program to find all possible expression which``// evaluate to target``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `  ``// Utility recursive method to generate all possible expressions``  ``static` `void` `getExprUtil(List<``string``> res, ``string` `curExp,``                          ``string` `input, ``int` `target, ``int` `pos,``                          ``int` `curVal, ``int` `last)``  ``{` `    ``// true if whole input is processed with some``    ``// operators``    ``if` `(pos == input.Length)``    ``{``      ``// if current value is equal to target``      ``//then only add to final solution``      ``// if question is : all possible o/p then just``      ``//push_back without condition``      ``if` `(curVal == target)``        ``res.Add(curExp);``      ``return``;``    ``}` `    ``// loop to put operator at all positions``    ``for` `(``int` `i = pos; i < input.Length; i++)``    ``{``      ``// ignoring case which start with 0 as they``      ``// are useless for evaluation``      ``if` `(i != pos && input[pos] == ``'0'``)``        ``break``;` `      ``// take part of input from pos to i``      ``string` `part = input.Substring(pos, i + 1 - pos);` `      ``// take numeric value of part``      ``int` `cur = Int32.Parse(part);` `      ``// if pos is 0 then just send numeric value``      ``// for next recursion``      ``if` `(pos == 0)``        ``getExprUtil(res, curExp + part, input,``                    ``target, i + 1, cur, cur);`  `      ``// try all given binary operator for evaluation``      ``else``      ``{``        ``getExprUtil(res, curExp + ``"+"` `+ part, input,``                    ``target, i + 1, curVal + cur, cur);``        ``getExprUtil(res, curExp + ``"-"` `+ part, input,``                    ``target, i + 1, curVal - cur, -cur);``        ``getExprUtil(res, curExp + ``"*"` `+ part, input,``                    ``target, i + 1, curVal - last + last * cur,``                    ``last * cur);``      ``}``    ``}``  ``}` `  ``// Below method returns all possible expression``  ``// evaluating to target``  ``static` `List<``string``> getExprs(``string` `input, ``int` `target)``  ``{``    ``List<``string``> res = ``new` `List<``string``>();``    ``getExprUtil(res, ``""``, input, target, 0, 0, 0);``    ``return` `res;``  ``}` `  ``// method to print result``  ``static` `void` `printResult(List<``string``> res)``  ``{``    ``for` `(``int` `i = 0; i < res.Count; i++)``      ``Console.Write(res[i] + ``" "``);``    ``Console.WriteLine();``  ``}` `  ``static` `void` `Main()``  ``{``    ``string` `input = ``"123"``;``    ``int` `target = 6;``    ``List<``string``> res = getExprs(input, target);``    ``printResult(res);` `    ``input = ``"125"``;``    ``target = 7;``    ``res = getExprs(input, target);``    ``printResult(res);``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``

Output:

```1+2+3 1*2*3
1*2+5 12-5```

Time Complexity: O()
Auxiliary Space: O(N)
This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.