Вывести 3 случайных массива в которых сумма строк = сумме столбцов

[Riven7]

Помогите пожалуйста!

В общем задание такое: "Создать динамическую матрицу nxn, заполнить случайными числами в интервале [n;n], вывести на экран, три случайных матрицы, в которых сумма строк и столбцов равны"

Создал массив который может посчитать строки и столбцы. Как сделать так, чтобы он вывел не 1 массив , а 3 в которых сумма строк = сумме столбцов?

#include <stdio.h>
#define M 7
#define N 7
#include <iostream>
#include <stdlib.h>
 
int main()
{
    int Mass[M][N];
    int V[N];
    int s, i, j;
    for (i=0; i<M; i++) V[i] = 0;
    for (i=0; i<N; i++) {
        s = 0;
        for (j=0; j<M; j++)
            {
            Mass[i][j] = rand()%15-7;
            printf("%5d", Mass[i][j]);
            s += Mass[i][j];
            V[j] += Mass[i][j];
        }
        printf("   |%d\n", s);
    }
    for (i=0; i<M; i++)
        printf("%5s", "--");
    printf("\n");
    for (i=0; i<M; i++)
        printf("%5d", V[i]);
    printf("\n");
}

[_Bers]

http://rextester.com/POFXH21573

#include <algorithm>
#include <iostream>
#include <chrono>
#include <random>
using namespace std;
//------------------------------------------------------------

//запчасти от стандартного генератора псевдослучайных чисел
namespace _private{

::std::default_random_engine& _RND()
{
    static ::std::default_random_engine r(
        static_cast<uint32_t>(
            ::std::chrono::system_clock::now().time_since_epoch().count()
        )
    );
    return r;
}
uint32_t RND() { return _RND()(); }
    
} //namespace _private

//------------------------------------------------------------
//генератор псевдослучайных чисел
//используется для автоматического заполнения матриц случайным содержимым
uint32_t Random(uint32_t minvalue, uint32_t maxvalue)
{
    if(minvalue>maxvalue) 
    {
        const auto tmp = minvalue;
        minvalue = maxvalue;
        maxvalue = tmp;
    }
    return _private::RND() % (maxvalue - minvalue + 1) + minvalue;
}

//------------------------------------------------------------

// для удобства чтения кода объявляем псевдоним
// для типа данных "двухмерный массив"
typedef int array[7][7];

//------------------------------------------------------------

// шаблон служит для автоматического определения 
// размерности матрицы времени компиляции
template< class T> struct property;
template< class T, int L, int R> struct property<T[L][R]>
{
    typedef T type;
    enum { size  = L*R }; 
    enum { lines = L   }; 
    enum { rows  = R   }; 
};
//------------------------------------------------------------

// заполняет матрицу случайными данными
void MakeRandomMatrix(array& arr)
{
    enum { size = property<array>::size }; 
    typedef property<array>::type
        type;
    
    type* const p = (type*)arr;
    const auto lambda = [](){ return Random(0,9); };
    ::std::generate(p, p+size, lambda);
}
//------------------------------------------------------------

// печатает содержимое матрицы в консоль
void ViewMatrix(array& arr)
{
    for(const auto& l: arr)
    {
        for(const auto& r: l)
            cout<< r<<" ";
        cout<<'\n';
    }
}
//------------------------------------------------------------

// определение суммы по линиям
int SummLines(array& arr)
{
    int result = 0;
    for(const auto& l: arr)
        for(const auto& r: l)
            result +=r;
    return result;
}
//------------------------------------------------------------

// определение суммы по столбцам
int SummRows(array& arr)
{
    enum { lines = property<array>::lines }; 
    enum { rows  = property<array>::rows  }; 
    
    int result = 0;
    for(size_t r = 0;r<rows;++r)
        for(size_t l = 0;l<lines;++l)
            result +=arr[l][r];
    return result;
}
//------------------------------------------------------------


int main()
{
    std::cout << "Hello, world!\n";
    

    array arr; 
    
    //--- количество матриц, которое нужно обнаружить, 
    //    для которых сумма по линиям и столбикам будет одинаковой
    size_t n=3;
    
    //--- заполняем матрицу числами
    //    и проверяем суммы. Если не сошлись - повторяем все заново
    //    если сошлись - показываем на экране, и уменьшаем счетчик 
    while( MakeRandomMatrix(arr), n!=0)
        if( SummLines(arr)==SummRows(arr) )
            ViewMatrix(arr), 
            cout<<"-----\n", 
            --n;
}