#include <chrono>

#if 1
using Type = int;
#else
using Type = double;
#endif

int const Size = 1024+1/*5*/;
int const Half = Size / 2;

Type arr[Size][Size] =
{
     1,  2,  3,  4,  5,
     6,  7,  8,  9, 11,
    12, 14, 15, 16, 17,
    18, 19, 20, 21, 22,
    23, 24, 25, 26, 27
};

Type summ_diamond_1()
{
    Type res = 0;

    for (size_t i=0; i<Half; ++i)
    {
        for (size_t j=Half-i; j<=Half+i; ++j)
        {
            res += arr[i][j];
            res += arr[Size-i-1][j];
        }
    }

    for (size_t i=0; i<Size; ++i)
    {
        res += arr[Half][i];
    }

    return res;
}

Type summ_diamond_2()
{
  constexpr size_t dim = Size;
  constexpr size_t m = dim / 2;

  Type sum = 0;
  Type
      *head = ((Type*)arr) + m,
      *tail = ((Type*)arr) + dim*dim - m - 1;
  size_t
      n = 1,
      c = n,
      d;

  while (head != tail)
  {
    if (c--)
    {
      sum += *head++;
      sum += *tail--;
    }
    else
    {
      d = dim - 1 - n;
      head += d;
      tail -= d;
      n += 2;
      c = n;
    }
  }
  sum += *head;

  return sum;
}

double test(Type (&summ_func)())
{
    double res = 0.0;
    for (size_t i=0; i<1000; ++i)
    {
        for (size_t i=0; i<Size; ++i)
        {
            for (size_t j=0; j<Size; ++j)
            {
                arr[i][j] = std::rand();
            }
        }

        auto start = std::chrono::high_resolution_clock::now();
        summ_func();
        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> elapsed_seconds = end - start;
        res += elapsed_seconds.count();
    }
    std::cout << "Elapsed time: " << res << "s\n";
    return res;
}

void testComplex(Type (&summ_func_1)(), Type (&summ_func_2)())
{
    double const d1 = test(summ_func_1);
    double const d2 = test(summ_func_2);
    std::cout << "Relation: " << (d2 / d1) << "\n";
}

void calc_times()
{
    testComplex(summ_diamond_1, summ_diamond_2);
    testComplex(summ_diamond_2, summ_diamond_1);
    testComplex(summ_diamond_1, summ_diamond_2);
}