Получить заданное число m сложением/вычитанием цифр

/////////////////////////////////////////////////////////////////////////////////////////
//Счастливый билет, но не совсем
//Дано n (n>=2) количество цифр от 1 до 9 и любое число m. Написать программу расстановки 
//между каждой парой чисел, записанных именно в таком порядке, знаков "+" и "-" так, чтобы 
//значение полученного выражения равнялось m.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <bitset>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
const   int     MIN_DIGITS_COUNT    =   2;
const   int     MAX_DIGITS_COUNT    =   10;
const   char    ZERO_SYMB           =   '0';
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                             T_str;
typedef std::vector     < int               >   T_digits;
typedef std::bitset     < MAX_DIGITS_COUNT  >   T_operations;
/////////////////////////////////////////////////////////////////////////////////////////
int     get_rand_int_in_segment
    (
        int     min_val,
        int     max_val
    )
{
    return  rand() % ( max_val - min_val + 1 ) + min_val;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_digits    get_rand_digits()
{
    static  const   int     MIN_DIGIT   =   1;
    static  const   int     MAX_DIGIT   =   9;
 
    int     rand_digits_count   =   get_rand_int_in_segment
                                        (
                                            MIN_DIGITS_COUNT,
                                            MAX_DIGITS_COUNT
                                        );
 
    T_digits    digits( rand_digits_count );
 
    std::generate
        (
            digits.begin    (),
            digits.end      (),
 
            std::bind
                (
                    get_rand_int_in_segment,
                    MIN_DIGIT,
                    MAX_DIGIT
                )
        );
 
    return  digits;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    print_digits( T_digits  const   &   digits )
{
    std::copy
        (
            digits.begin                (),
            digits.end                  (),
            std::ostream_iterator<int>  ( std::cout )
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
int     get_result_for_digits_and_operatioins_string
    (
        T_digits    const   &   digits,
        T_str       const   &   operations_string
    )
{
    return  std::inner_product
                (
                    digits.begin                () + 1,
                    digits.end                  (),
                    operations_string.begin     (),
                    digits.front                (),
                    std::plus<int>              (),
 
                    []                          (
                                                    int     digit,
                                                    char    op_flag
                                                )
                    {
                        return  op_flag     ==  ZERO_SYMB
                                    ?   -digit
                                    :   digit;
                    }
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool   successfully_for_digits_and_result_set_operations_string
    (
        T_digits    const   &   digits,
        int                     result,
        T_str               &   operations_string
    )
{
    bool                bool_res        =   false;
    unsigned long long  variants_count  =   1 << ( digits.size() - 1 );
 
    for( unsigned long long  i = 0; i < variants_count; ++i )
    {
        operations_string   =   T_operations(i).to_string();
 
        operations_string.assign
            (
                operations_string.rbegin(),
                operations_string.rbegin() + digits.size() - 1
            );
 
        bool_res    =       result
 
                        ==  get_result_for_digits_and_operatioins_string
                                (
                                    digits,
                                    operations_string
                                );
 
        if( bool_res )
        {
            break;
        }
    }//for
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    print_arithmetic_expression_for_digits_and_result
    (
        T_digits    const   &   digits,
        int                     result
    )
{
    static  const   char    SPACE_SYMB  =   ' ';
    static  const   char    PLUS_SYMB   =   '+';
    static  const   char    MINUS_SYMB  =   '-';
 
    T_str   operations_string;
 
    if  (
            !successfully_for_digits_and_result_set_operations_string
                (
                    digits,
                    result,
                    operations_string
                )
        )
    {
        std::cout   <<  "Решения не существует."
                    <<  std::endl;
    }
    else
    {
        std::transform
            (
                operations_string.begin         (),
                operations_string.end           (),
                digits.begin                    (),
                std::ostream_iterator<T_str>    ( std::cout ),
 
                []                              (
                                                    char    op_flag,
                                                    int     digit
                                                )
                                                ->T_str
                {
                    std::ostringstream  sout;
 
                    sout    <<  digit
                            <<  SPACE_SYMB
 
                            <<  (
                                    op_flag     ==  ZERO_SYMB
                                        ?   MINUS_SYMB
                                        :   PLUS_SYMB
                                )
 
                            <<  SPACE_SYMB;
 
                    return  sout.str();
                }
            );
 
            std::cout   <<  digits.back()
                        <<  " = "
                        <<  result
                        <<  std::endl;
    }//else
 
    std::cout   <<  std::endl
                <<  std::endl
                <<  std::endl
                <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
    T_digits    digits  =   get_rand_digits();
 
    for(;;)
    {
        print_digits( digits );
 
        std::cout   <<  std::endl
                    <<  "result = ";
 
        int     result  =   0;
        std::cin    >>  result;
 
        print_arithmetic_expression_for_digits_and_result
            (
                digits,
                result
            );
    }//for
}