Алтарь цветного Бога

/*
Вот уже год назад Вася записался в секту. И сегодня они решили построить алтари
своему цветному (RGB) Господу.
Алтарь строится из кирпичей 3 цветов (R, G, B). Он строится на фундаменте
(фундамент не считается алтарем).
 
Правила постройки:
1. Если цвета двух соседних треугольников (кирпичи имеют треугольную форму) внизу
какого-то треугольника разные, то этот треугольник должен быть третьего цвета;
 
2. Если цвет двух соседних треугольников внизу совпадает, то этот же цвет должен иметь
и текущий треугольник.
 
3. Алтарь - правильный треугольник со стороной n = 3^k (k <= 10)
(фундамент соответственно n+1).
 
4. Верхушка алтаря должна быть зеленого цвета.
 
Пример алтаря со стороной n=3:
 
g }
r b } Алтарь
b g r }
r g g b <--- (фундамент)
 
Тех. Условия: Считываем целое число F [1;10]. Из этой же строки считываем (через пробел)
F фундаментов (последовательностей символов из множества {r,g,b}).
Надо вывести F кусочков фундамента, которых не хватает для того, чтоб вершина была
зеленой (п.4). Если нельзя получить зеленую вершину ни одним способом вывести -1.
 
Пример работы:
 
Ввод: 2 rgg ggrggrggr
 
Вывод: b g
*/
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <deque>
#include <cmath>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::vector     < T_str     >   T_strings;
///////////////////////////////////////////////////////////////////////////////
char    color_sum
    (
        char    L,
        char    R
    )
{
    if( L == R )
    {
        return  L;
    }
 
    if( L > R )
    {
        std::swap( L, R );
    }
 
    auto    LR  =   T_str{L} + R;
 
    if( LR == "bg" )
    {
        return  'r';
    }
 
    if( LR == "br" )
    {
        return  'g';
    }
 
    if( LR == "gr" )
    {
        return  'b';
    }
 
    return  0;
}
///////////////////////////////////////////////////////////////////////////////
T_str   get_right_side_of_altar_with_bottom( T_str  &   altar_bottom )
{
    T_str   result;
 
    while   (
                altar_bottom.size()     >   1
            )
    {
        result.insert
            (
                result.begin        (),
                altar_bottom.back   ()
            );
 
        T_str   new_altar_bottom;
 
        std::transform
            (
                altar_bottom.begin  ()  +   1,
                altar_bottom.end    (),
                altar_bottom.begin  (),
                std::back_inserter  ( new_altar_bottom ),
                color_sum
            );
 
        std::swap
            (
                new_altar_bottom,
                altar_bottom
            );
    }//while
 
    result.insert
        (
            result.begin        (),
            altar_bottom.back   ()
        );
 
    return   result;
}
///////////////////////////////////////////////////////////////////////////////
void    inc_right_altar_side_and_save_result_back
    (
        T_str   &   side,
        T_str   &   back_colors
    )
{
    T_str   new_side{'g'};
 
    std::transform
        (
            side.front()    ==  'g'
                ?   side.begin  ()  +   1
                :   side.begin  (),
 
            side.end            (),
            std::back_inserter  ( new_side ),
 
            [&]                 ( auto  side_color )
            {
                return  color_sum
                            (
                                side_color,
                                new_side.back()
                            );
            }
        );
 
    std::swap
        (
            new_side,
            side
        );
 
    back_colors.push_back
        (
            side.back()
        );
}
///////////////////////////////////////////////////////////////////////////////
T_str   get_altar_bottom_tail
    (
        T_str   const   &   altar_bottom_head,
        int                 k_max
    )
{
    auto    altar_bottom_head_size  =   altar_bottom_head.size();
 
    if  (
            altar_bottom_head_size  ==  std::pow( 3.0, k_max ) + 1
        )
    {
        return  T_str("-1");
    }
 
    double  k_real  =   log( altar_bottom_head_size - 1 ) / log(3);
 
    int     k       =   k_real  ==  ceil( k_real )
                            ?   ++k_real
                            :   ceil( k_real );
 
    auto    target_altar_size       =   pow( 3.0, k ) + 1;
 
    auto    target_altar_tail_size  =       target_altar_size
                                        -   altar_bottom_head_size;
 
    T_str   altar_bottom        =   altar_bottom_head;
    T_str   right_altar_side    =   get_right_side_of_altar_with_bottom( altar_bottom );
    T_str   altar_bottom_tail;
 
    do
    {
        inc_right_altar_side_and_save_result_back
                (
                    right_altar_side,
                    altar_bottom_tail
                );
    }
    while   (
                    altar_bottom_tail.size()
                <   target_altar_tail_size
            );
 
    return  altar_bottom_tail;
}
///////////////////////////////////////////////////////////////////////////////
T_strings   get_altar_bottom_tails
    (
        T_strings   const   &   altar_bottom_heads,
        int                     k_max
    )
{
    T_strings   altar_bottom_tails;
 
    std::transform
        (
            altar_bottom_heads.begin    (),
            altar_bottom_heads.end      (),
            std::back_inserter          ( altar_bottom_tails ),
 
            std::bind                   (
                                            get_altar_bottom_tail,
                                            std::placeholders::_1,
                                            k_max
                                        )
        );
 
    return  altar_bottom_tails;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    const   int     K_MAX   =   10;
    int     F{};
 
    std::cout   <<  "Input data:"
                <<  std::endl;
 
    T_strings   altar_bottom_heads;
 
    std::cin    >>  F;
 
    std::generate_n
        (
            std::back_inserter( altar_bottom_heads ),
            F,
            [&]
            {
                T_str   altar_bottom_head;
                std::cin    >>  altar_bottom_head;
                return  altar_bottom_head;
            }
        );
 
    auto    altar_bottom_tails  =   get_altar_bottom_tails
                                        (
                                            altar_bottom_heads,
                                            K_MAX
                                        );
 
    std::copy
        (
            altar_bottom_tails.begin        (),
            altar_bottom_tails.end          (),
            std::ostream_iterator<T_str>    ( std::cout, "\n" )
        );
 
    std::cout   <<  std::endl;
    system("pause");
}