Сложить числа записанные в указанном формате

#include <iostream>
#include <vector>
 
using namespace std;
 
struct vv{
    int c, num;
};
 
void printBigNumber(const std::vector<int>& number) {
    int cnt = 0;
    std::vector<vv> kk;
    for (int k = 0; k < number.size(); ++k) {
        if (k + 1 < number.size()) {
            if (number[k] == number[k + 1]) {
                cnt++;
            } else {
                kk.push_back({cnt + 1, number[k]});
                cnt = 0;
            }
        } else {
            kk.push_back({cnt + 1, number[k]});
        }
    }
    std::cout << kk.size() << std::endl;
    for (auto j: kk) {
        std::cout << j.c << ' ' << j.num << '\n';
    }
//    for(auto k : number){
//        std::cout << k << ' ';
//    }
}
 
int main() {
    vector<int> a;
    vector<int> b;
    const int base = 1000 * 1000 * 1000;
    int n;
    string stra;
    string strb;
    cin >> n;
    while (n--) {
        int c;
        char num;
        cin >> c >> num;
        while (c--) {
            stra.push_back(num);
        }
    }
    cin >> n;
    while (n--) {
        int c;
        char num;
        cin >> c >> num;
        while (c--) {
            strb.push_back(num);
        }
    }
    for (int i = (int) stra.length(); i > 0; i -= 9) {
        if (i < 9)
            a.push_back(atoi(stra.substr(0, i).c_str()));
        else
            a.push_back(atoi(stra.substr(i - 9, 9).c_str()));
    }
    for (int i = (int) strb.length(); i > 0; i -= 9){
        if (i < 9)
            b.push_back(atoi(strb.substr(0, i).c_str()));
        else
            b.push_back(atoi(strb.substr(i - 9, 9).c_str()));
    }
    for(auto k : a){
        std::cout << k;
    }
    cout << '+';
    for(auto k : b){
        std::cout << k;
    }
    cout << endl;
    int carry = 0;
    for (size_t i=0; i<max(a.size(),b.size()) || carry; ++i) {
        if (i == a.size())
            a.push_back (0);
        a[i] += carry + (i < b.size() ? b[i] : 0);
        carry = a[i] >= base;
        if (carry)  a[i] -= base;
    }
    b.clear();
    stra.erase();
    strb.erase();
    vector<int> res;
    //вывод
    cout << a.empty() ? 0 : a.back();
    for (int i=(int)a.size()-2; i>=0; --i)
        cout << a[i];
 
    res.push_back(a.empty() ? 0 : a.back());
    for (int i=(int)a.size()-2; i>=0; --i) {
        res.push_back(a[i]);
    }
    printBigNumber(res);
}

    unsigned long long a[2] = { 0,0 };
    int N, n, d;
    for (int i = 0; i < 2; i++)
    {
        cin >> N;
        for (int j = 0; j < N; j++)
        {
            cin >> n >> d;
            for (int k = 0; k < n; k++)
            {
                a[i] *= 10;
                a[i] += d;
            }
        }
    }
    unsigned long long b = *a + a[1];
    vector<pair<int, int>> v;
    pair<int, int> p = { 0,-1 };
    do
    {
        d = b % 10;
        if (d != p.second)
        {
            if (p.first)
                v.push_back(p);
            p.first = 1;
            p.second = d;
        }
        else
            p.first++;
        b /= 10;
        if (!b)
            v.push_back(p);
    } while (b);
 
    cout << v.size() << endl;
    for (int i = v.size() - 1; i >= 0; i--)
        cout << v[i].first << " " << v[i].second << endl;

#include <iostream>
#include <string>
using ll = long long;
 
// складывает две группы одинаковой длины len
std::string sum(ll len, int d1, int d2)
{
    int res = d1 + d2;
    auto str = std::to_string(res);
    if (d1 + d2 >= 10)
    {
        auto substr = std::to_string(len - 1) + std::string(1, char(str.back() + 1));
        str.insert(1, substr);
        bool eq = str[0] == *(str.end() - 2);
        if (eq)
        {
            substr = std::to_string(len) + std::string(1, char(str.back() + 1));
            str.replace(0, str.size() - 1, substr);
        }
        else
        {
            str = "1" + str;
        }
        str.insert(str.end() - 1, '1');
    }
    else
    {
        str = std::to_string(len) + str;
    }
    return str;
}
 
int main()
{
    ll len = 3; // длина группы (одинакова для обеих групп)
    int d1 = 5; // цифра первой группы
    int d2 = 6; // цифра второй группы
    std::cout << sum(len, d1, d2) << "\n";
}

template <typename INPUT_IT, typename OUTPUT_IT>
OUTPUT_IT long_sum_10(INPUT_IT it_a, INPUT_IT it_a_end,
                      INPUT_IT it_b, INPUT_IT it_b_end,
                      OUTPUT_IT it_c)
{
  int carry = 0;
 
  for (; it_a != it_a_end && it_b != it_b_end; ++it_a, ++it_b)
  {
    int s = *it_a + *it_b + carry;
    *it_c++ = s % 10;
    carry = s / 10;
  }
 
  for (; it_a != it_a_end; ++it_a)
  {
    int s = *it_a + carry;
    *it_c++ = s % 10;
    carry = s / 10;
  }
 
  for (; it_b != it_b_end; ++it_b)
  {
    int s = *it_b + carry;
    *it_c++ = s % 10;
    carry = s / 10;
  }
 
  if (carry > 0)
    *it_c++ = carry;
 
  return it_c;
}

template <typename IT>
class RleInputIt
{ // Читает пары (value, count) именно в таком порядке
public:
  using iterator_category = std::input_iterator_tag;
  using difference_type = typename std::iterator_traits<IT>::difference_type;
  using value_type = int;
  using pointer = const value_type *;
  using reference = const value_type &;
 
  RleInputIt(IT it) : it(it), count(0)
    {}
 
  RleInputIt &operator ++()
  {
    if (count == 0)
      fill();
 
    assert(count > 0);
    --count;
 
    return *this;
  }
 
  RleInputIt operator ++(int)
    { RleInputIt old = *this; ++*this; return old; }
 
  reference operator *()
  { 
    if (count == 0)
      fill();
 
    assert(count > 0);
    return value; 
  }
 
  friend bool operator ==(const RleInputIt &lhs, const RleInputIt &rhs)
    { return lhs.it == rhs.it && lhs.count == rhs.count; }
  friend bool operator !=(const RleInputIt &lhs, const RleInputIt &rhs)
    { return !(lhs == rhs); }
 
private:
  IT it;
  unsigned count;
  value_type value;
 
  void fill()
  {
    assert(count == 0);
    value = *it++;
    count = *it++;
    assert(count > 0);
  }
};
 
template <typename IT>
class RleOutputIt
{ // Записывает пары (value, count) именно в таком порядке
public:
  using iterator_category = std::output_iterator_tag;
  using difference_type = typename std::iterator_traits<IT>::difference_type;
  using value_type = int;
  using pointer = const value_type *;
  using reference = const value_type &;
 
  RleOutputIt(IT it) : it(it), count(0)
    {}
 
  RleOutputIt &operator *() const
    { return const_cast<RleOutputIt &>(*this); }
 
  RleOutputIt &operator ++()
    { return *this; }
 
  RleOutputIt &operator ++(int)
    { return *this; }
 
  void operator =(value_type v)
  {
    if (count > 0 && v == value)
      ++count;
    else
    {
      if (count > 0)
        flush();
 
      assert(count == 0);
      value = v;
      count = 1;
    }
  }
 
private:
  IT it;
  unsigned count;
  value_type value;
 
  void flush()
  {
    assert(count > 0);
    *it++ = value;
    *it++ = count;
    count = 0;
  }
};

  using InIt = RleInputIt<std::vector<int>::const_reverse_iterator>;
  using OutIt = RleOutputIt<std::back_insert_iterator<std::vector<int>>>;
 
  std::vector<int> a { 2, 2, 3, 3, 9, 9 }, b = { 1, 1 }, c;
  OutIt it = long_sum_10(
    InIt(a.crbegin()), InIt(a.crend()), 
    InIt(b.crbegin()), InIt(b.crend()), 
    OutIt(std::back_inserter(c)));
  *it++ = 0;
  // Выводим дополнительный 0 для сброса последней накопленной последовательности
  std::reverse(c.begin(), c.end());
 
  std::copy(a.cbegin(), a.cend(), std::ostream_iterator<int>(std::cout, ""));
  std::cout << " + ";
  std::copy(b.cbegin(), b.cend(), std::ostream_iterator<int>(std::cout, ""));
  std::cout << " = ";
  std::copy(c.cbegin(), c.cend(), std::ostream_iterator<int>(std::cout, ""));
  std::cout << std::endl;

#include <iostream>
#include <string>
#include <utility>
#include <vector>
#include <algorithm>
using ll = long long;
using group = std::pair<ll, int>;
using longnumber = std::vector<group>;
 
// суммирует две группы одинаковой длины
longnumber sum(group const& g1, group const& g2)
{
    if (g1.first != g2.first)
        throw;
    auto len = g1.first;
    longnumber vres;
    int sum = g1.second + g2.second;
    if (sum >= 10)
    {
        vres.insert(vres.end(), { { 1, sum % 10 }, {1, (sum / 10) % 10} });
        if (len > 1)
        {
            vres.insert(vres.end() - 1, {len - 1, sum % 10 + 1});
        }
        if (vres[0].second == vres[1].second)
        {
            ++vres[1].first;
            vres.erase(vres.begin());
        }
    }
    else
    {
        vres.emplace_back(len, sum);
    }
    return vres;
}
 
// суммирует группу g с группой {1, 1}
longnumber addOne(group const& g)
{
    longnumber res;
    if (g.second < 9)
    {
        res.push_back({1, g.second + 1});
        res.push_back({g.first - 1, g.second});
    }
    else
    {
        res.push_back({ g.first, 0 });
        res.push_back({ 1, 1 });
    }
    return res;
}
 
int main()
{
    longnumber a = { { 1e18, 9 }, { 1e18, 3 } };                    // первое длинное число (старшие разряды в  конце вектора)
    longnumber b = { { 1, 1 },   };                 // второе длинное число
 
    // разбиваем оба числа на группы равной длины
    for (int i = 0, j = 0; i < a.size() && j < b.size(); ++i, ++j)
    {
        if (a[i].first < b[j].first)
        {
            b.insert(b.begin() + j + 1, { b[j].first - a[i].first, b[j].second });
            b[j].first = a[i].first;
        }
        else if (a[i].first > b[j].first)
        {
            a.insert(a.begin() + i + 1, { a[i].first - b[j].first, a[i].second });
            a[i].first = b[j].first;
        }
    }
    for (int i = 0; i < a.size(); ++i)
    {
        //std::cout << a[i].first << " ";
    }
    std::cout << "\n";
    for (int i = 0; i < b.size(); ++i)
    {
        //std::cout << b[i].first << " ";
    }
    std::cout << "\n\n";
 
    // суммируем группы равной длины
    longnumber res;
    int ind = 0;
    bool addCurByOne = false, addNextByOne = false;
    for (; ind < a.size() && ind < b.size(); ++ind)
    {
        longnumber c = sum(a[ind], b[ind]);
        if (c.size() > 1)
        {
            addNextByOne = true;
        }
        if (addCurByOne)
        {
            addCurByOne = false;
            longnumber added = addOne(c[0]);
            if(c[0].second == 9)
                addNextByOne = true;
            c.erase(c.begin());
            c.insert(c.begin(), added.begin(), added.end());
        }
        if (c.size() == 1)
        {
            res.push_back(c[0]);
        }
        else
        {
            res.insert(res.end(), c.begin(), c.end() - 1);
        }
        addCurByOne = addNextByOne;
        addNextByOne = false;
    }
 
    // добавляем голову более длинного числа
    auto [vmin, vmax] = std::minmax(a, b, [](auto const& a, auto const& b) {return a.size() < b.size(); });
    while (addCurByOne)
    {
        addCurByOne = false;
        if (ind < vmax.size())
        {
            longnumber added = addOne(vmax[ind]);
            if (vmax[ind].second == 9)
            {
                addNextByOne = true;
                res.insert(res.end(), added.begin(), added.end() - 1);
            }
            else
            {
                res.insert(res.end(), added.begin(), added.end());
            }
            ++ind;
        }
        else
        {
            res.push_back({1, 1});
        }
        addCurByOne = addNextByOne;
        addNextByOne = false;
    }
 
    // результат res готов. Причёсываем его.
    // удаление групп вида {0, N}
    auto it = std::remove_if(res.begin(), res.end(), [](auto const& g) {return g.first == 0; });
    res.erase(it, res.end());
 
    // мёржим соседние группы
    for (int i = 0; i < res.size() - 1; )
    {
        if (res[i].second == res[i + 1].second)
        {
            res[i].first += res[i + 1].first;
            res.erase(res.begin() + i + 1);
        }
        else
        {
            ++i;
        }
    }
 
    // вывод результата
    for (int i = 0; i < res.size(); ++i)
    {
        std::cout << res[i].first << " " << res[i].second << "\n";
    }
    
    for (; ind < vmax.size(); ++ind)
    {
        std::cout << vmax[ind].first << " " << vmax[ind].second << "\n";
    }
}

std::vector<int> a = { 2, 2, 3, 3, 9, 9 };
unsigned sum = std::accumulate(InIt(a.crbegin()), InIt(a.crend()), 0u);
std::cout << sum << std::endl;