Print all possible expressions that evaluate to a target

25 May, 2022
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 to 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++
Java
Python3
C#
Javascript
// C++ program to find all possible expression which// evaluate to target#include <bits/stdc++.h>using namespace std; // Utility recursive method to generate all possible// expressionsvoid getExprUtil(vector<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.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 targetvector<string> getExprs(string input, int target){    vector<string> res;    getExprUtil(res, "", input, target, 0, 0, 0);    return res;} // method to print resultvoid printResult(vector<string> res){    for (int i = 0; i < res.size(); i++)        cout << res[i] << " ";    cout << endl;} // Driver code to test above methodsint main(){    string input = "123";    int target = 6;    vector<string> res = getExprs(input, target);    printResult(res);     input = "125";    target = 7;    res = getExprs(input, target);    printResult(res);    return 0;}
// 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<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.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<String> getExprs(String input,                                      int target)    {        ArrayList<String> res = new ArrayList<String>();        getExprUtil(res, "", input, target, 0, 0, 0);        return res;    }     // method to print result    static void printResult(ArrayList<String> 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<String> res = getExprs(input, target);        printResult(res);         input = "125";        target = 7;        res = getExprs(input, target);        printResult(res);    }} // This code is contributed by jainlovely450.o
# Python3 program to find all possible expression which# evaluate to target # Utility recursive method to generate all possible# expressionsdef 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 targetdef getExprs(_input, target):    res=[]    getExprUtil(res, "", _input, target, 0, 0, 0)    return res  # method to print resultdef printResult(res):    for i in range(len(res)):        print(res[i],end=" ")    print()  # Driver code to test above methodsif __name__ == '__main__':    _input = "123"    target = 6    res = getExprs(_input, target)    printResult(res)     _input = "125"    target = 7    res = getExprs(_input, target)    printResult(res)
// C# program to find all possible expression which// evaluate to targetusing 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.
<script>    // Javascript program to find all possible expression which    // evaluate to target         // Utility recursive method to generate all possible    // expressions    function getExprUtil(res, curExp, input, target, pos, curVal, 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(curExp);            return;        }         // loop to put operator at all positions        for (let 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            let part = input.substr(pos, i + 1 - pos);             // take numeric value of part            let cur = parseInt(part, 10);             // 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    function getExprs(input, target)    {        let res = [];        getExprUtil(res, "", input, target, 0, 0, 0);        return res;    }     // method to print result    function printResult(res)    {        for (let i = 0; i < res.length; i++)            document.write(res[i] + " ");        document.write("</br>");    }         let input = "123";    let target = 6;    let res = getExprs(input, target);    printResult(res);      input = "125";    target = 7;    res = getExprs(input, target);    printResult(res);         // This code is contributed by decode2207.</script>
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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
surinderdawra388
pankajsharmagfg
amartyaghoshgfg
decode2207
divyesh072019
jainlovely450
Algorithms
Recursion
Recursion
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.