Найти все варианты размещения знаков операций +,-,* на месте вопросов в выражении 1?2?3?4?5?6?7?8?9=100

#include <iostream>
 
 
int mass[9]={1,2,3,4,5,6,7,8,9}, Sf, Ss;
 
 
int Do(int znak, int a, int b, int &S){
    if(znak == 0){
        S=a-b;
    }
    if(znak == 1){
        S=a+b;
    }
    if(znak == 2){
        S=a*b;
    }
    return 0;
}
char Znak(int i){
    char Znak;
    if(i == 0){
        Znak='-';
    }
    if(i == 1){
        Znak='+';
    }
    if(i == 2){
        Znak='*';
    }
    return Znak;
}
void main(){
    int count(0);
    std::cout<<"Varianti podstanovki znakov pri kotorom virazhenie ravno 100:"<<"\n";
    for(int a(0); a<3; a++){
        for(int b(0); b<3; b++){
            for(int c(0); c<3; c++){
                for(int d(0); d<3; d++){
                    for(int e(0); e<3; e++){
                        for(int f(0); f<3; f++){
                            for(int g(0); g<3; g++){
                                for(int h(0); h<3; h++){
                                    Do(e, mass[0], mass[1], Sf);
                                    Ss=0;
                                    Do(b, Sf, mass[2], Ss);
                                    Sf=0;
                                    Do(c, Ss, mass[3], Sf);
                                    Ss=0;
                                    Do(d, Sf, mass[4], Ss);
                                    Sf=0;
                                    Do(e, Ss, mass[5], Sf);
                                    Ss=0;
                                    Do(f, Sf, mass[6], Ss);
                                    Sf=0;
                                    Do(g, Ss, mass[7], Sf);
                                    Ss=0;
                                    Do(h, Sf, mass[8], Ss);
                                    Sf=0;
                                    if(Ss == 100){
 
                                        std::cout<<"1"<<Znak(a)<<"2"<<Znak(b)<<"3"<<Znak(c)<<"4"<<Znak(d)<<"5"<<Znak(e)<<"6"<<Znak(f)<<"7"<<Znak(g)<<"8"<<Znak(h)<<"9"<<" = 100"<<"\n";
                                        count++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
std::cout<<"Kol-vo variantov podstanovki znakov pri kotorom virazhenie ravno 100"<<"\t"<<count<<"\n";
system("pause");
 
}

      Do(e, mass[0], mass[1], Sf);
                                    Ss=0;
                                    Do(b, Sf, mass[2], Ss);
                                    Sf=0;
                                    Do(c, Ss, mass[3], Sf);
                                    Ss=0;
                                    Do(d, Sf, mass[4], Ss);
                                    Sf=0;
                                    Do(e, Ss, mass[5], Sf);
                                    Ss=0;
                                    Do(f, Sf, mass[6], Ss);
                                    Sf=0;
                                    Do(g, Ss, mass[7], Sf);
                                    Ss=0;
                                    Do(h, Sf, mass[8], Ss);
                                    Sf=0;
                                    if(Ss == 100)

#include <iostream>
#include <vector>
 
using namespace std;
 
int eval(vector<int> arr){
    int total = 0;
    vector<int> p = arr, m = arr, mp = arr;
    if (arr.size() > 2){
        p[1] = p[0] + p[1]; p.erase(p.begin()); total += eval(p);
        m[1] = m[0] - m[1]; m.erase(m.begin()); total += eval(m);
        mp[1]=mp[0] *mp[1];mp.erase(mp.begin()); total+=eval(mp);
    } else {
        if ((arr[0] - arr[1]) == 100) total++;
        if ((arr[0] + arr[1]) == 100) total++;
        if ((arr[0] * arr[1]) == 100) total++;
    }
    return total;
}
 
int main(){
    vector<int> arr; for (int i = 1; i < 10; i++) arr.push_back(i);
    cout<<eval(arr);
}

#include <iostream>
#include <vector>
#include <string>
 
using namespace std;
string str(int n);
 
int eval(vector<int> arr, string expr){
    int total = 0;
    vector<int> p = arr, m = arr, mp = arr;
    int sp = p[1], sm = m[1], smp = mp[1];
    if (arr.size() > 2){
        p[1] = p[0] + p[1]; p.erase(p.begin()); total += eval(p, expr + string("+") + str('0' + sp));
        m[1] = m[0] - m[1]; m.erase(m.begin()); total += eval(m, expr + string("-") + str('0' + sm));
        mp[1]=mp[0] *mp[1];mp.erase(mp.begin()); total+=eval(mp, expr + string("*") + str('0' + smp));
    } else {
        if ((arr[0] - arr[1]) == 100) {total++; cout<<expr<<"-"<<arr[1]<<endl;}
        if ((arr[0] + arr[1]) == 100) {total++; cout<<expr<<"+"<<arr[1]<<endl;}
        if ((arr[0] * arr[1]) == 100) {total++; cout<<expr<<"*"<<arr[1]<<endl;}
    }
    return total;
}
 
string str(int n){
    string a = "0";
    a[0] = (char) n;
    return a;
}
 
int main(){
    string expr = "1";
    vector<int> arr; for (int i = 1; i < 10; i++) arr.push_back(i);
    eval(arr, expr);
}

Do(a, mass[0], mass[1], Sf);//тут опечатка была 1 аргумент "a" а не "e"
Ss=0;
Do(b, Sf, mass[2], Ss);
Sf=0;
Do(c, Ss, mass[3], Sf);
Ss=0;
Do(d, Sf, mass[4], Ss);
Sf=0;
Do(e, Ss, mass[5], Sf);
Ss=0;
Do(f, Sf, mass[6], Ss);
Sf=0;
Do(g, Ss, mass[7], Sf);
Ss=0;
Do(h, Sf, mass[8], Ss);
Sf=0;
if(Ss == 100)

/////////////////////////////////////////////////////////////////////////////////////////
//Составить программу, которая бы нашла все варианты размещения знаков арифметических операций 
//+,-,* на месте вопросительных знаков в выражении 1?2?3?4?5?6?7?8?9, что значение этого выражения 
//равнялось бы 100. Арифметические действия выполняются слева направо, а не по обычному приоритету.
/////////////////////////////////////////////////////////////////////////////////////////
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string         T_str;
typedef std::deque<int>     T_operands;
/////////////////////////////////////////////////////////////////////////////////////////
T_str   num_to_str( int  num )
{
    std::ostringstream  sout;
    sout    <<  num;
    return  sout.str();
}
/////////////////////////////////////////////////////////////////////////////////////////
void    print_variants_for_add_subtr_mult
    (
        T_operands      operands,
        int             result_target,
        int             result_cur      =   0,
        T_str           str_result      =   T_str()
    )
{
    if  (
            operands.empty()
        )
    {
        if( result_cur == result_target )
        {
            str_result  +=  " = ";
            str_result  +=  num_to_str( result_target );
 
            std::cout   <<  str_result
                        <<  std::endl;
        }
        return;
    }//if
 
    int     operand     =   operands.front();
    operands.pop_front();
 
    if  (
            str_result.empty()
        )
    {
        print_variants_for_add_subtr_mult
            (
                operands,
                result_target,
                operand,
                num_to_str( operand )
            );
    }
    else
    {
        print_variants_for_add_subtr_mult
            (
                operands,
                result_target,
                result_cur + operand,
                str_result + " + " + num_to_str( operand )
            );
 
        print_variants_for_add_subtr_mult
            (
                operands,
                result_target,
                result_cur - operand,
                str_result + " - " + num_to_str( operand )
            );
 
        print_variants_for_add_subtr_mult
            (
                operands,
                result_target,
                result_cur * operand,
                str_result + " * " + num_to_str( operand )
            );
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    int         operands_arr[]  =   {1, 2, 3, 4, 5, 6, 7, 8, 9};
 
    T_operands  operands
        (
            operands_arr,
            operands_arr + sizeof( operands_arr ) / sizeof( operands_arr[0] )
        );
 
    int     result_target   =   100;
 
    print_variants_for_add_subtr_mult
        (
            operands,
            result_target
        );
 
    system( "pause" );
}

/////////////////////////////////////////////////////////////////////////////////////////
//Составить программу, которая бы нашла все варианты размещения знаков арифметических операций 
//+,-,* на месте вопросительных знаков в выражении 1?2?3?4?5?6?7?8?9, что значение этого выражения 
//равнялось бы 100. Арифметические действия выполняются слева направо, а не по обычному приоритету.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <deque>
#include <iostream>
#include <iterator>
#include <set>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef std::set    < T_str >   T_strings;
typedef std::deque  < int   >   T_operands;
/////////////////////////////////////////////////////////////////////////////////////////
T_str   num_to_str( int  num )
{
    std::ostringstream  sout;
    sout    <<  num;
    return  sout.str();
}
/////////////////////////////////////////////////////////////////////////////////////////
void    set_variants_strings_for_add_subtr_mult
    (
        T_operands      operands,
        int             result_target,
        T_strings   &   variants_strings,
        int             result_cur      =   0,
        T_str           str_result      =   T_str()
    )
{
    if  (
            operands.empty()
        )
    {
        if( result_cur == result_target )
        {
            str_result  +=  " = ";
            str_result  +=  num_to_str( result_target );
 
            variants_strings.insert( str_result );
        }
    }
    else
    {
        int     operand     =   operands.front();
        operands.pop_front();
 
        if  (
                str_result.empty()
            )
        {
            set_variants_strings_for_add_subtr_mult
                (
                    operands,
                    result_target,
                    variants_strings,
                    operand,
                    num_to_str( operand )
                );
        }
        else
        {
            set_variants_strings_for_add_subtr_mult
                (
                    operands,
                    result_target,
                    variants_strings,
                    result_cur + operand,
                    str_result + " + " + num_to_str( operand )
                );
 
            set_variants_strings_for_add_subtr_mult
                (
                    operands,
                    result_target,
                    variants_strings,
                    result_cur - operand,
                    str_result + " - " + num_to_str( operand )
                );
 
            set_variants_strings_for_add_subtr_mult
                (
                    operands,
                    result_target,
                    variants_strings,
                    result_cur * operand,
                    str_result + " * " + num_to_str( operand )
                );
        }//else
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_prompt_and_input_val
    (
        T_str   const   &   prompt,
        int             &   val
    )
{
    std::cout   <<  prompt;
    std::cin    >>  val;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_prompt_and_input_val_not_less_than
    (
        T_str   const   &   prompt,
        int             &   val,
        int                 left_bound
    )
{
    do
    {
        print_prompt_and_input_val
            (
                prompt,
                val
            );
    }
    while( val < left_bound );
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        int     operands_count  =   0;
 
        print_prompt_and_input_val_not_less_than
            (
                "Введите количество операндов: ",
                operands_count,
                1
            );
 
        std::cout   <<  "Введите "
                    <<  operands_count
                    <<  " операндов:"
                    <<  std::endl;
 
        T_operands  operands;
 
        for( int  i = 0; i < operands_count; ++i )
 
        {
            int     operand_cur     =   0;
 
            print_prompt_and_input_val
                (
                    "#" + num_to_str( i + 1 ) + "\t: ",
                    operand_cur
                );
 
            operands.push_back( operand_cur );
        }
 
        int     result_target   =   0;
 
        print_prompt_and_input_val
            (
                "\nВведите желаемый результат: ",
                result_target
            );
 
        std::cout   <<  std::endl;
        T_strings   variants_strings;
 
        set_variants_strings_for_add_subtr_mult
            (
                operands,
                result_target,
                variants_strings
            );
 
        std::copy
            (
                variants_strings.begin          (),
                variants_strings.end            (),
                std::ostream_iterator<T_str>    ( std::cout, "\n" )
            );
 
        int     variants_total  =   variants_strings.size();
 
        std::cout   <<  (
                            variants_total == 0
                                ?   "Нет решений."
                                :   "Всего " + num_to_str( variants_total ) + " решений."
                        )
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}