Проверка идентичности матриц в C++, Python, JS и C

Два массива (матрицы) считаются идентичными, если у них одинаковые размеры и все соответствующие элементы равны. Ниже — простые и надёжные реализации на C++, Python, JavaScript и C с объяснением подхода, сложностью и тестовыми случаями.

Матрицы и логотипы языков: Python, C++, JavaScript и C на фоне матрицы

Две матрицы считаются идентичными, если у них одинаковое число строк и столбцов и все соответствующие элементы совпадают. В этой статье показано, как это проверить на четырёх популярных языках, плюс рекомендации, когда подход простого посэмпельного сравнения не подходит.

Условие идентичности

Чтобы матрицы считались идентичными, должны выполняться два условия:

Размеры совпадают: одинаковое число строк и столбцов.
Все соответствующие элементы равны друг другу.

Важно: при работе с числами с плавающей точкой сравнение надо делать с допуском (EPS), а не прямым равенством.

Пример: две матрицы и указание совпадающих/различающихся элементов

Подход (простая версия)

Сравнить размеры матриц — если не совпадают, вернуть false и завершить.
Пройти по всем элементам двойным вложенным циклом (по строкам и столбцам).
Если найдено любое несоответствие — вернуть false сразу (ранний выход).
Если цикл закончился без различий — вернуть true.

Краткая сложность: O(n*m) по времени и O(1) по дополнительной памяти, где n×m — размер матрицы.

Important: для разреженных матриц или очень больших объёмов данных разумно использовать другие подходы (хеширование строк, сравнение только ненулевых элементов, проверка контрольных сумм).

Алгоритмическая сложность и особенности

Время: O(rows * cols) — нужно посмотреть каждый элемент в худшем случае.
Память: O(1) дополнительной памяти (если матрицы уже загружены). Для потоковой проверки можно сравнивать элементы на лету.
Погрешности с float/double: сравнивайте |a-b| < eps.
Большие матрицы: ранний выход и проверка размеров экономят работу; при частых проверках имеет смысл использовать быстрые хеши (например, хешы строк/строк-CRC).

Критерии приёмки

Функция возвращает true только если размеры совпадают и каждый элемент равен соответствующему.
Для чисел с плавающей точкой должно быть настроено сравнение с допуском.
Работает для произвольных целочисленных и вещественных матриц одинаковой размерности.

Примеры реализации

Ниже — чистые примеры кода. Строки вывода в примерах оставлены в исходном виде (английские сообщения) для точного соответствия демонстрации.

C++

// C++ program to check if two matrices are identical
#include 
using namespace std;

// The order of the matrix is 3 x 4
#define size1 3
#define size2 4

// Function to check if two matrices are identical
bool isIdentical(int mat1[][size2], int mat2[][size2])
{
    for (int i = 0; i < size1; i++)
    {
        for (int j = 0; j < size2; j++)
        {
            if (mat1[i][j] != mat2[i][j])
            {
                return false;
            }
        }
    }
    return true;
}

// Function to print a matrix
void printMatrix(int mat[][size2])
{
    for (int i = 0; i < size1; i++)
    {
        for (int j = 0; j < size2; j++)
        {
            cout << mat[i][j] << " ";
        }
        cout << endl;
    }
}

int main()
{
    int mat1[size1][size2] = { {2, 2, 2, 2},
                               {2, 2, 2, 2},
                               {2, 2, 2, 2} };
    cout << "Matrix 1:" << endl;
    printMatrix(mat1);

    int mat2[size1][size2] = { {2, 2, 2, 2},
                               {2, 2, 2, 2},
                               {2, 2, 2, 2} };
    cout << "Matrix 2:" << endl;
    printMatrix(mat2);

    if(isIdentical(mat1, mat2))
    {
        cout << "Yes, the matrices are identical" << endl;
    }
    else
    {
        cout << "No, the matrices are not identical" << endl;
    }

    int mat3[size1][size2] = { {3, 3, 3, 3},
                               {3, 3, 3, 3},
                               {3, 3, 3, 3} };
    cout << "Matrix 3:" << endl;
    printMatrix(mat3);

    int mat4[size1][size2] = { {4, 4, 4, 4},
                               {4, 4, 4, 4},
                               {4, 4, 4, 4} };
    cout << "Matrix 4:" << endl;
    printMatrix(mat4);

    if(isIdentical(mat3, mat4))
    {
        cout << "Yes, the matrices are identical" << endl;
    }
    else
    {
        cout << "No, the matrices are not identical" << endl;
    }
    return 0;
}

Python

# Python program to check if two matrices are identical

# The order of the matrix is 3 x 4
size1 = 3
size2 = 4

# Function to check if two matrices are identical
def isIdentical(mat1, mat2):
    for i in range(size1):
        for j in range(size2):
            if (mat1[i][j] != mat2[i][j]):
                return False
    return True

# Function to print a matrix
def printMatrix(mat):
    for i in range(size1):
        for j in range(size2):
            print(mat[i][j], end=' ')
        print()

# Driver code
mat1 = [ [2, 2, 2, 2],
         [2, 2, 2, 2],
         [2, 2, 2, 2] ]

print("Matrix 1:")
printMatrix(mat1)

mat2 = [ [2, 2, 2, 2],
         [2, 2, 2, 2],
         [2, 2, 2, 2] ]

print("Matrix 2:")
printMatrix(mat2)

if (isIdentical(mat1, mat2)):
    print("Yes, the matrices are identical")
else:
    print("No, the matrices are not identical")

mat3 = [ [3, 3, 3, 3],
         [3, 3, 3, 3],
         [3, 3, 3, 3] ]

print("Matrix 3:")
printMatrix(mat3)

mat4 = [ [4, 4, 4, 4],
         [4, 4, 4, 4],
         [4, 4, 4, 4] ]

print("Matrix 4:")
printMatrix(mat4)

if (isIdentical(mat3, mat4)):
    print("Yes, the matrices are identical")
else:
    print("No, the matrices are not identical")

JavaScript

// JavaScript program to check if two matrices are identical

// The order of the matrix is 3 x 4
var size1 = 3;
var size2 = 4;

// Function to check if two matrices are identical
function isIdentical(mat1, mat2) {
    for (let i = 0; i < size1; i++)
    {
        for (let j = 0; j < size2; j++)
        {
            if (mat1[i][j] != mat2[i][j])
            {
                return false;
            }
        }
    }
    return true;
}

// Function to print a matrix
function printMatrix(mat) {
    for (let i = 0; i < size1; i++) {
        for (let j = 0; j < size2; j++) {
            document.write(mat[i][j] + " ");
        }
        document.write("
");
    }
}

// Driver code
var mat1 = [ [2, 2, 2, 2],
             [2, 2, 2, 2],
             [2, 2, 2, 2] ];
document.write("Matrix 1:
");
printMatrix(mat1);

var mat2 = [ [2, 2, 2, 2],
             [2, 2, 2, 2],
             [2, 2, 2, 2] ];
document.write("Matrix 2:
");
printMatrix(mat2);

if (isIdentical(mat1, mat2)) {
    document.write("Yes, the matrices are identical
");
} else{
    document.write("No, the matrices are not identical
");
}

var mat3 = [ [3, 3, 3, 3],
             [3, 3, 3, 3],
             [3, 3, 3, 3] ];
document.write("Matrix 3:
");
printMatrix(mat3);

var mat4 = [ [4, 4, 4, 4],
             [4, 4, 4, 4],
             [4, 4, 4, 4] ];
document.write("Matrix 4:
");
printMatrix(mat4);

if (isIdentical(mat3, mat4)) {
    document.write("Yes, the matrices are identical
");
} else{
    document.write("No, the matrices are not identical
");
}

C

// C program to check if two matrices are identical
#include 
#include 

// The order of the matrix is 3 x 4
#define size1 3
#define size2 4

// Function to check if two matrices are identical
bool isIdentical(int mat1[][size2], int mat2[][size2])
{
    for (int i = 0; i < size1; i++)
    {
        for (int j = 0; j < size2; j++)
        {
            if (mat1[i][j] != mat2[i][j])
            {
                return false;
            }
        }
    }
    return true;
}

// Function to print a matrix
void printMatrix(int mat[][size2])
{
    for (int i = 0; i < size1; i++)
    {
        for (int j = 0; j < size2; j++)
        {
            printf("%d ", mat[i][j]);
        }
        printf("\n");
    }
}

int main()
{
    int mat1[size1][size2] = { {2, 2, 2, 2},
                                {2, 2, 2, 2},
                                {2, 2, 2, 2} };
    printf("Matrix 1:\n");
    printMatrix(mat1);

    int mat2[size1][size2] = { {2, 2, 2, 2},
                                {2, 2, 2, 2},
                                {2, 2, 2, 2} };
    printf("Matrix 2:\n");
    printMatrix(mat2);

    if(isIdentical(mat1, mat2))
    {
        printf("Yes, the matrices are identical \n");
    }
    else
    {
        printf("No, the matrices are not identical \n");
    }

    int mat3[size1][size2] = { {3, 3, 3, 3},
                                {3, 3, 3, 3},
                                {3, 3, 3, 3} };
    printf("Matrix 3:\n");
    printMatrix(mat3);

    int mat4[size1][size2] = { {4, 4, 4, 4},
                                {4, 4, 4, 4},
                                {4, 4, 4, 4} };
    printf("Matrix 4:\n");
    printMatrix(mat4);

    if(isIdentical(mat3, mat4))
    {
        printf("Yes, the matrices are identical \n");
    }
    else
    {
        printf("No, the matrices are not identical \n");
    }

    return 0;
}

Когда простой подход не годится (контрпримеры)

Плавающая точка: сравнение double == double ломается из‑за округлений.
Очень большие матрицы: полное посэмпельное сравнение дорого по времени; лучше использовать контрольные суммы или хешы.
Разреженные матрицы: хранение в CSR/COO требует сравнения только ненулевых элементов по индексам.

Альтернативные подходы

В NumPy: numpy.array_equal(A, B) — работает эффективно и учитывает размеры.
Хеширование строк: считать хеш каждой строки и сравнивать последовательности хешей (экономия при ранних различиях).
memcmp (C/C++): если представление памяти одинаковое и типы соответствуют, можно сравнить подлежащие блоки памяти, но это ненадёжно для выравнивания/маркировки типов.
Сравнение потока: если матрицы приходят по сети, сравнивать элементы по мере получения.

Руководство для разработчика (короткий playbook)

Проверить размеры матриц.
Если элементы — float/double, решить EPS и использовать сравнение с допуском.
Для больших данных предусмотреть ранний выход и хеширование по строкам/блокам.
Написать тесты с краевыми случаями (пустые матрицы, разные размеры, разные типы данных).

Тест-кейсы и приёмка

Пустые матрицы того же размера — true.
Матрицы одинакового размера, все элементы совпадают — true.
Матрицы разного размера — false.
Матрицы равного размера, одно несоответствие — false (тест раннего выхода).
Вещественные числа с малой погрешностью — сравнение с EPS.

Чек-лист для тестирования

Проверить совпадение размеров.
Проверить случай полного совпадения.
Проверить один отличающийся элемент.
Проверить разный порядок строк/столбцов (должно быть false).
Проверить поведение с отрицательными числами, нулями и большими значениями.

Краткое резюме

Простое поэлементное сравнение — самый прямой и понятный способ для небольших и плотных матриц.
Для вещественных чисел используйте допуск; для больших объёмов рассмотреть хеши или контрольные суммы.
Всегда сначала сравнивайте размеры — это быстро и часто предотвращает лишнюю работу.

Notes: учитесь применять подходящие структруры данных — разреженные форматы и потоковая обработка меняют оптимальную стратегию сравнения.