Ребус Криптарифм

#include <iostream>
#include <vector>
 
/*
*     Z G Z C B
*   +   U Z C H
*    ----------
*     Z U B M M
*/
 
inline int ZGZCB(int B, int C, int G, int Z)
{
    return Z*1e4 + G*1e3 + Z*1e2 + C*1e1 + B;
}
 
inline int UZCH(int C, int H, int U, int Z)
{
    return U*1e3 + Z*1e2 + C*1e1 + H;
}
 
inline int ZUBMM(int B, int M, int U, int Z)
{
    return Z*1e4 + U*1e3 + B*1e2 + M*1e1 + M;
}
 
bool hasDuplicate(const std::vector<int>& v)
{
    for (size_t i = 0; i < v.size(); ++i)
        for (size_t j = i+1; j < v.size(); ++j)
            if (v[i] == v[j])
                return true;
    return false;
}
 
int main()
{
    for(int B = 0; B < 10; ++B)
        for(int C = 0; C < 10; ++C)
            for(int G = 0; G < 10; ++G)
                for(int H = 0; H < 10; ++H)
                    for(int M = 0; M < 10; ++M)
                        for(int U = 0; U < 10; ++U)
                            for(int Z = 0; Z < 10; ++Z)
                            {
                                //  проверка на уникальность
                                std::vector<int> v{B, C, G, H, M, U, Z};
                                if(hasDuplicate(v))
                                    break;
 
                                if(ZGZCB(B, C, G, Z) + UZCH(C, H, U, Z) == ZUBMM(B, M, U, Z))
                                    std::cout << Z << G << Z << C << B << " + " <<
                                        U << Z << C << H << " = " << Z << U << B << M << M << std::endl;
                            }
    return 0;
}

/*
*     Z G Z C B
*   +   U Z C H
*    ----------
*     Z U B M M
*/

std::vector<int> v{B, C, G, H, M, U, Z};

std::vector<int> v(7);
v[0] = B;
v[1] = C;
v[2] = G;
v[3] = H;
v[4] = M;
v[5] = U;
v[6] = Z;

    unsigned count = 0;
    for(int B = 0; B < 10; ++B)
        for(int C = 0; C < 10; ++C)
            for(int G = 0; G < 10; ++G)
                for(int H = 0; H < 10; ++H)
                    for(int M = 0; M < 10; ++M)
                        for(int U = 0; U < 10; ++U)
                            for(int Z = 0; Z < 10; ++Z)
                            {
                                //  проверка на уникальность
                                std::vector<int> v(7);
                                v[0] = B;
                                v[1] = C;
                                v[2] = G;
                                v[3] = H;
                                v[4] = M;
                                v[5] = U;
                                v[6] = Z;
 
                                if(hasDuplicate(v))
                                    continue;
 
                                if(ZGZCB(B, C, G, Z) + UZCH(C, H, U, Z) == ZUBMM(B, M, U, Z))
                                {
                                    std::cout << Z << G << Z << C << B << " + " <<
                                        U << Z << C << H << " = " << Z << U << B << M << M << std::endl;
                                    ++count;
                                }
                            }
 
    std::cout << "There are " << count << " different combinations." << std::endl;

#include <algorithm>
#include <iostream>
#include <iterator>
#include <set>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::set        < T_str     >   T_solutions;
typedef std::set        < char      >   T_symb_set;
///////////////////////////////////////////////////////////////////////////////
int     get_num
    (
        T_symb_set  const   &   letters,
        T_str       const   &   digits,
        T_str       const   &   word
    )
{
    T_str   dig_word;
 
    std::transform
        (
            word.begin          (),
            word.end            (),
            std::back_inserter  ( dig_word ),
 
            [=]                 ( char  letter )
            {
                auto    it  =   std::find
                                    (
                                        letters.begin   (),
                                        letters.end     (),
                                        letter
                                    );
 
                return  digits  [
                                    std::distance
                                        (
                                            letters.begin   (),
                                            it
                                        )
                                ];
            }
        );
 
    return  stoi( dig_word );
}
///////////////////////////////////////////////////////////////////////////////
void    print_all_solutions_of_rebus
    (
        T_str   const   &   L_str,
        T_str   const   &   R_str,
        T_str   const   &   sum_str
    )
{
    T_symb_set      letters;
    T_solutions     solutions;
 
    letters.insert
        (
            L_str.begin     (),
            L_str.end       ()
        );
 
    letters.insert
        (
            R_str.begin     (),
            R_str.end       ()
        );
 
    letters.insert
        (
            sum_str.begin   (),
            sum_str.end     ()
        );
 
    T_str   digits      ("0123456789");
    int     num_L       {};
    int     num_R       {};
    int     num_sum     {};
 
    do
    {
        num_L       =   get_num     (
                                        letters,
                                        digits,
                                        L_str
                                    );
 
        num_R       =   get_num     (
                                        letters,
                                        digits,
                                        R_str
                                    );
 
        num_sum     =   get_num     (
                                        letters,
                                        digits,
                                        sum_str
                                    );
 
        if  (
                        num_L
                    +   num_R
 
                ==      num_sum
            )
        {
            std::ostringstream  sout;
 
            sout    <<  num_L
                    <<  " + "
                    <<  num_R
                    <<  " = "
                    <<  num_sum;
 
            if  (
                    solutions.insert    (
                                            sout.str()
                                        )
                                        .second
                )
            {
                std::cout   <<  "found "
                            <<  solutions.size()
                            <<  " solutions"
                            <<  std::endl;
            }//if
        }//if
    }
    while   (
                 std::next_permutation
                     (
                         digits.begin    (),
                         digits.end      ()
                     )
            );
 
    std::copy
        (
            solutions.begin                 (),
            solutions.end                   (),
            std::ostream_iterator< T_str >  ( std::cout,    "\n" )
        );
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    print_all_solutions_of_rebus
        (
            "ZGZCB",
            "UZCH",
            "ZUBMM"
        );
 
    std::cout   <<  "end"
                <<  std::endl;
}