Оптимизация [сокращение времени выполнения]

#include <iostream>
using namespace std;
int lucky(int a, int b)
{
    int r1 = 0,r2 = 0,i,timer = 0;
    for(int mi=a;mi<=b;mi++)
    {
        int var1 = mi;
        for (i = 0;i < 4;i++)
        {
            int temp = var1 % 10;
            var1 /= 10;
            r1 += temp;
            int temp2 = var1 % 10;
            var1 /= 10;
            r2 += temp2;
        }
        if (r1 == r2)
        {
            timer++;
        }
        r1 = 0;
        r2 = 0;
    }
    return timer;
}
int main()
{
    int a, b;
    cin >> a >> b;
    cout << lucky(a, b) << endl;
    return 0;
}

        if (r1 == r2)
        {
            timer++;
        }

#include <iostream>
 
int lucky(int a, int b) {
    /*максимальное количество сочетаний из 4 цифр, для каждой суммы (можно сразу их в массив забить)*/
    int m[37] = {0};
    for(int i = 0; i <= 9999; ++i) {
        int val = i, sum = 0;
        while(val) {
            sum += val % 10;
            val /= 10;
        }
        m[sum] += 1;
    }
    /*исключаем из суммы те, что меньше порога*/
    for(int i = 0, l = a % 10000; i < l; ++i) {
        int val = i, sum = 0;
        while(val) {
            sum += val % 10;
            val /= 10;
        }
        m[sum] -= 1;
    }
    /*исключаем из суммы те, что больше порога*/
    for(int i = 1 + (b % 10000); i <= 9999; ++i) {
        int val = i, sum = 0;
        while(val) {
            sum += val % 10;
            val /= 10;
        }
        m[sum] -= 1;
    }
    /*считаем сумму левой части и добавляем количество возможных чисел с той же суммой из правой*/
    int cnt = 0;
    for(int i = a / 10000, l = b / 10000; i <= l; ++i) {
        int val = i, sum=0;
        while(val) {
            sum += val % 10;
            val /= 10;
        }
        cnt+=m[sum];
    }       
            
    return cnt;
}
 
int main() {
    int a, b;
    std::cin >> a >> b;
    
    std::cout << "нессыпрорвёмся" << lucky(a, b) << std::endl;
 
    return 0;
}

int lucky(int a, int b) {
    
    int m[37] = {0};        
    for(int i = a % 10000, l = b % 10000; i <= l; ++i) {
        int val = i, sum = 0;
        while(val) {
            sum += val % 10;
            val /= 10;
        }
        m[sum] += 1;
    }
    
    /*считаем сумму левой части и добавляем количество возможных чисел с той же суммой из правой*/
    int cnt = 0;
    for(int i = a / 10000, l = b / 10000; i <= l; ++i) {
        int val = i, sum=0;
        while(val) {
            sum += val % 10;
            val /= 10;
        }
        cnt+=m[sum];
    }       
            
    return cnt;
}

///////////////////////////////////////////////////////////////////////////////
//1.
///////////////////////////////////////////////////////////////////////////////
//У вас имеются два билета. Номер первого билета равен M, второго – N.
//Лимиты M и N: 10000000 ? M < N ? 99999999.
//Ваша задача определить количество "счастливых билетов" в данном диапазоне.
//Билет "счастливый", если сумма первых 4 цифр равна сумме последних 4 цифр.
//Ввод:
//Вводятся номера двух билетов.
 
//Вывод
//Количество "счастливых билетов" в данном диапазоне.
 
//Пример:
//a: 11111110
//b: 11111112
//ans: 1
 
//a: 10000000
//b: 99999999
//ans: 4379055
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef long long                           T_int;
typedef std::map    < T_int,    T_int   >   T_count_of_sum;
///////////////////////////////////////////////////////////////////////////////
T_int   sum_digits( T_int   n )
{
    T_int   res{};
 
    do
    {
        res     +=  n % 10;
        n       /=  10;
    }
    while(n);
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
void    fill_count_of_tail_dig_sum
    (
        T_int               min,
        T_int               max,
        T_int               mod,
        T_count_of_sum  &   count_of_sum
    )
{
    for( T_int  n{min}; n <= max; ++n )
    {
        ++count_of_sum  [
                            sum_digits( n % mod )
                        ];
    }
}
///////////////////////////////////////////////////////////////////////////////
T_int   winning_tickets_count_in_segment
    (
        T_int   min,
        T_int   max
    )
{
    T_count_of_sum  count_of_sum_L;
    T_count_of_sum  count_of_sum_R;
    T_int           num_len     =   std::to_string( max ).size();
    T_int           mod         =   std::pow( 10,   num_len / 2 );
 
    fill_count_of_tail_dig_sum
        (
            min /   mod,
            max /   mod,
            mod,
            count_of_sum_L
        );
 
    fill_count_of_tail_dig_sum
        (
            min,
            std::min    (
                            min + mod - 1,
                            max
                        ),
            mod,
            count_of_sum_R
        );
 
    T_int   res{};
 
    for( T_int  sum{}; sum <= 9 * num_len / 2; ++sum )
    {
        res +=      count_of_sum_L[ sum ]
                *   count_of_sum_R[ sum ];
    }//for
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_int     a{};
    T_int     b{};
 
    std::cin    >>  a   >>  b;
 
    std::cout   <<  winning_tickets_count_in_segment( a, b )
                <<  std::endl;
}

#include <iostream>
using namespace std;
int lucky(int *a,int *b,char *sum)
{
  int count3 = 0;
  for (int i = 0;i <= 99;i++) sum[i] = i / 10 + i % 10;
  int h = 0, h_sum;
  for (int i = *a;i <= *b;i++)
  {
    int l = i % 10000;
    if (l == 0 || h == 0) {
      h = i / 10000;
      h_sum = *(sum + h / 100) + *(sum + h % 100);
    }
    count3 += (sum[l / 100] + sum[l % 100] == h_sum);
  }
  return count3;
}
int main()
{
  int a, b;
  char sum[100];
  cin >> a >> b;
  cout << lucky(&a,&b,sum) << endl;
  return 0;
}