Language: C++

#include <bits/stdc++.h>

using namespace std;

#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define endl "\n"

string mul(string a)
{
  int n = (int)a.size();
  string res = "";
  bool up = false;
  for (int i = n - 1; i >= 0; i--)
  {
    int tmp = (int)(a[i] - '0');
    tmp *= 2;
    if (up)
      tmp++;
    up = false;
    string tmp2 = to_string(tmp);
    res += tmp2[tmp2.size() - 1];
    if (tmp2.size() > 1)
      up = true;
  }
  if (up)
    res += '1';
  reverse(all(res));
  return res;
}

string add(string a) {
  int n = (int)a.size();
  string res = "";
  bool up = true;
  for (int i = n - 1; i >= 0; i--) {
    if (!up) {
      res += a[i];
      continue;
    }
    int tmp = (int)(a[i] - '0');
    tmp++;
    string tmp2 = to_string(tmp);
    res += tmp2[tmp2.size() - 1];
    if (tmp2.size() > 1) up = true;
    else up = false;
  }
  if (up) res += '1';
  reverse(all(res));
  return res;
}

map<string, int> NumA, NumB;

void parseA(string idx, string s)
{
  int n = (int)s.size();
  stack<char> st;
  int res = 0;
  int left = -1, right = -1;
  for (int i = 0; i < n; i++)
  {
    if (s[i] == '(')
      st.push('(');
    else if (s[i] == ')')
      st.pop();
    else if (isdigit(s[i]) && st.empty())
    {
      res *= 10;
      res += (int)(s[i] - '0');
    }
    else if (s[i] == '[' && st.empty() && i - 2 > 0)
    {
      parseA(idx * 2, s.substr(1, i - 2));
    }
    else if (s[i] == ']' && st.empty() && i + 2 < n - 1)
    {
      parseA(idx * 2 + 1, s.substr(i + 2, n - i - 3));
      break;
    }
  }
  NumA[idx] = res;
}

void parseB(string idx, string s)
{
  int n = (int)s.size();
  stack<char> st;
  int res = 0;
  for (int i = 0; i < n; i++)
  {
    if (s[i] == '(')
      st.push('(');
    else if (s[i] == ')')
      st.pop();
    else if (isdigit(s[i]) && st.empty())
    {
      res *= 10;
      res += (int)(s[i] - '0');
    }
    else if (s[i] == '[' && st.empty() && i - 2 > 0)
    {
      parseB(mul(idx), s.substr(1, i - 2));
    }
    else if (s[i] == ']' && st.empty() && i + 2 < n - 1)
    {
      parseB(add(mul(idx)), s.substr(i + 2, n - i - 3));
      break;
    }
  }
  NumB[idx] = res;
}

string a, b;
map<string, int> NumS;

string construct(string idx)
{
  if (NumS.count(idx) == 0)
    return "";
  return "(" + construct(mul(idx)) + ")[" + to_string(NumS[idx]) + "](" + construct(add(mul(idx))) + ")";
}

int main()
{
  cin >> a >> b;
  parseA("1", a);
  parseB("1", b);
  for (auto ite = NumA.begin(); ite != NumA.end(); ite++) {
    for (auto ite2 = NumB.begin(); ite2 != NumB.end(); ite2++) {
      if (ite->fi == ite2->fi) {
        NumS[ite->fi] = ite->se + ite2->se;
      }
    }
  }
  string ans = construct("1");
  cout << ans << endl;
  return 0;
}


Compiler output:
a.cc: In function 'void parseA(std::string, std::string)':
a.cc:78:18: error: no match for 'operator*' (operand types are 'std::string' {aka 'std::__cxx11::basic_string<char>'} and 'int')
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |              ~~~ ^ ~
      |              |     |
      |              |     int
      |              std::string {aka std::__cxx11::basic_string<char>}
In file included from /usr/include/c++/14/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:127,
                 from a.cc:1:
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::complex<_Tp>'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::complex<_Tp>'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   mismatched types 'const std::complex<_Tp>' and 'int'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
In file included from /usr/include/c++/14/valarray:605,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:166:
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom1, class _Dom2> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_Expr, _Dom1, _Dom2>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const _Expr<_Dom2, typename _Dom2::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_Constant, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const typename _Dom::value_type&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Constant, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const typename _Dom::value_type&, const _Expr<_Dom1, typename _Dom1::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_ValArray, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const valarray<typename _Dom::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const valarray<typename _Dom::value_type>&, const _Expr<_Dom1, typename _Dom1::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const valarray<_Tp>&, const valarray<_Tp>&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::valarray<_Tp>'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_Constant, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const valarray<_Tp>&, const typename valarray<_Tp>::value_type&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::valarray<_Tp>'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Constant, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const typename valarray<_Tp>::value_type&, const valarray<_Tp>&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:78:20: note:   mismatched types 'const std::valarray<_Tp>' and 'int'
   78 |       parseA(idx * 2, s.substr(1, i - 2));
      |                    ^
a.cc:82:18: error: no match for 'operator*' (operand types are 'std::string' {aka 'std::__cxx11::basic_string<char>'} and 'int')
   82 |       parseA(idx * 2 + 1, s.substr(i + 2, n - i - 3));
      |              ~~~ ^ ~
      |              |     |
      |              |     int
      |              std::string {aka std::__cxx11::basic_string<char>}
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:82:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::complex<_Tp>'
   82 |       parseA(idx * 2 + 1, s.substr(i + 2, n - i - 3));
      |                    ^
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:82:20: note:   'std::string' {aka 'std::__cxx11::basic_string<char>'} is not derived from 'const std::complex<_Tp>'
   82 |       parseA(idx * 2 + 1, s.substr(i + 2, n - i - 3));
      |                    ^
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:82:20: note:   mismatched types 'const std::complex<_Tp>' and 'int'
   82 |       parseA(idx * 2 + 1, s.substr(i + 2, n - i - 3));
      |                    ^
/usr/include/c++/14/bits/valarray_afte