Числовое кольцо

#include <iostream>
#include <algorithm>
#include <string>
#include <regex>
#include <string>
#include <ctime>
 
// сложение двух длинных чисел
std::string sum(std::string const& s1, std::string const& s2)
{
    std::string sres, a = s1, b = s2;
    sres.reserve(99);
    std::reverse(a.begin(), a.end());
    std::reverse(b.begin(), b.end());
    auto [min, max] = std::minmax(a, b, [](std::string const& a, std::string const& b) {return a.size() < b.size(); });
    int rem{}, i{};
    for (i = 0; i < min.size(); ++i)
    {
        int d = min[i] - '0' + max[i] - '0' + rem;
        sres.push_back(d % 10 + '0');
        rem = d / 10;
    }
    if (rem == 1)
    {
        std::string str{ "1" };
        str.append(i, '0');
        const_cast<std::string&>(max).replace(max.begin(), max.begin() + i, sres);
        std::reverse(const_cast<std::string&>(max).begin(), const_cast<std::string&>(max).end());
        sres = sum(str, max);
    }
    else
    {
        const_cast<std::string&>(max).replace(max.begin(), max.begin() + i, sres);
        sres = max;
    }
 
    return sres;
}
 
int main() 
{
    std::string str{"000002440000977710021"};
    std::string a, b, c, ssum;
    int rc = str.size();
    auto t1 = clock();
    while (rc--)
    {
        for (int i = 0; i < str.size() - 2; ++i)
        {
            a = std::string(str, 0, i + 1);
            for (int j = i + 1; j < str.size() - 1; ++j)
            {
                b = std::string(str, i + 1, j - i);
                //int bb = std::stoull(b);
                ssum = sum(a, b);
                std::reverse(ssum.begin(), ssum.end());
                c = std::string(str, j + 1, str.size() - j - 1);
                c = std::regex_replace(c, std::regex{ "^0+" }, "");
                ssum = std::regex_replace(ssum, std::regex{ "^0+" }, "");
                if (ssum == c)
                {
                    std::cout << str << ": " << a << " + " << b << " = " << c << "\n";
                }
            }
        }
        std::rotate(str.begin(), str.begin() + 1, str.end());
    } 
    auto t2 = clock();
    std::cout << "time: " << (1. * t2 - t1) / CLOCKS_PER_SEC << "\n";
}
 
// 0099999999999999999999999999999999999999999999999910010000000000000000000000000000000000000000000000

#include<iostream>
#include<random>
#include<time.h>
 
using namespace std;
 
mt19937 gen( time(0) );
 
 
int generat( int X )
 {
uniform_int_distribution<> u( 1, X );
return u( gen );
 }
 
 
int main()
 {
//const string numer_str = "15897471";
string numer_str = "123456789";
int place = 4;
 
cout << "Enter many dijit number: ";
cin >> numer_str;
cin.ignore( 80, '\n' );
 
int N = numer_str.length();
 
cout << "Enter start at place: [ 0 .. " << N << " ]: ";
cin >> place;
 
if( place > N || place < 0 )
 {
 cout << "!!!BIGGEST ERROR!!!\n";
 return 0xFF;
 }
 
int X = N;
 
for( int i=0, j=place, Xx=0, flag=0; i<N && X; i++ )
 {
 Xx = generat( ((!flag) ? N : place) - j );
 X = X - Xx;
 
 for( int c=0; c<N && c<Xx; j++, c++ )
  {
  cout << numer_str[ j ] << "";
  if( j==N-1 )
   {
   flag = 1;
   j=0;
   break;
   }
  }
 if( X ) cout << "+";
 }
 
return 0;
 }

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
 
using namespace std;
 
char *c_substr( const char *str, char *buffer, int a, int b )
 {
strncpy( buffer, str+a, b-a );
buffer[ b-a ] = '\0';
return buffer;
 }
 
char *circuit( char *sample )
 {
int N = strlen( sample );
 
char tmp = sample[ N-1 ];
 
for( int i=N-1; i>0; i-- )
 {
 sample[ i ] = sample[ i-1 ];
 }
sample[ 0 ] = tmp;
 
return sample;
 }
 
int find_summand( char *summand, char *sum, char complex[][20] )
 {
int flag = 0;
 
int N = strlen( summand );
char *buffer = new char[ N ];
 
long long first_summand, second_summand;
long long digit_sum = atol( sum );
 
for( int i=1; i<N; i++ )
 {
 first_summand = atol( (c_substr(summand, buffer, 0, i)) );
 second_summand = atol( (c_substr(summand, buffer, i, N)) );
 
 if(  first_summand + second_summand == digit_sum )
  {
  flag = 1;
  strcpy( complex[ 0 ], c_substr(summand, buffer, 0, i) );
  strcpy( complex[ 1 ], c_substr(summand, buffer, i, N) );
  break;
  }
 }
delete [] buffer;
return flag;
 }
 
int reaearch_number_str( const char *sample )
 {
int N = strlen(sample), flag = 0;
char *sum = new char[ N ]();
char *summand = new char[ N ]();
 
if( N < 3 )
 {
 printf( "Incorrect many_digit_str(its long less 3)\n" );
 return 0;
 }
char complex[ 2 ][ 20 ] = {0};
 
for( int i=N-1, j=1; i>=2; i--, j++ )
 {
 c_substr( sample, sum, i, N );
 c_substr( sample, summand, 0, i );
 
 if( find_summand(summand, sum, complex) )
  {
  flag = 1;
  cout << sample << ": " << complex[ 0 ] << " + " << complex[ 1 ] << " = " << sum << "\n";
  }
 }
delete [] sum;
delete [] summand;
return flag;
 }
 
 
int main()
 {
char many_digit_str[] = "00099919991";
char *work_str = &many_digit_str[ 0 ];
int flag = 0;
int N = strlen( many_digit_str );
 
for( int i=0; i<N; i++ )
 {
 if( reaearch_number_str(work_str) )
  {
  flag = 1;
  }
 work_str = circuit( work_str );
 }
if( !flag ) cout << "Not found.\n";
return 0;
 }