C Matrix Subtraction Program

Beginner
5 min read
Updated: Oct 2026
2 programs
Live preview
Definition

What Is Matrix Subtraction?

Matrix subtraction subtracts matching cells: C[i][j] = A[i][j] - B[i][j]. Both matrices must have the same number of rows and columns.

Remember
A − B is defined only when A and B have the same shape

  [ 9  8 ]   [ 1  5 ]   [ 8  3 ]
  [ 7  6 ] − [ 4  2 ] = [ 3  4 ]

Rule: (A − B)[i][j] = A[i][j] − B[i][j]

Negatives are allowed (e.g. 2 − 5 = −3).
PositionABA − B
[0][0]918
[0][1]853
[1][0]743
[1][1]624
Approach

How to Subtract Matrices in C

Four clear steps — same nested loops as addition, with minus.

  1. Confirm both matrices have the same rows and columns.
  2. Create a result matrix of that same size.
  3. Outer loop walks rows; inner loop walks columns.
  4. Set result[i][j] = A[i][j] - B[i][j] for every cell.
MethodIdeaTimeBest for
Nested loopsSubtract matching cells into a new 2D arrayO(m × n)Interviews, teaching
Shape-safe subtractValidate rows/cols first, then subtractO(m × n)Safer production-style code

Pseudocode

Pseudocode
function SubtractMatrices(A, B):
    rows = rows of A
    cols = cols of A

    if rows != rows of B or cols != cols of B:
        error "shapes must match"

    C = new matrix[rows][cols]
    for i from 0 to rows - 1:
        for j from 0 to cols - 1:
            C[i][j] = A[i][j] - B[i][j]

    return C
Reference

Cheat Sheet

Keep these facts handy while writing the program.

TopicDetail
RuleC[i][j] = A[i][j] - B[i][j]
RequirementSame rows and same columns
SizePass rows/cols or use macros
NegativesAllowed and expected when B > A
Vs multiplySubtraction is entrywise only
Classic check{{9,8},{7,6}} − {{1,5},{4,2}} = {{8,3},{3,4}}
Try it

Live Preview

Pick a sample pair to see matrices A, B, and A − B.

Tap a chip to run. Results may include negative numbers.

Result
A =
9  8
7  6

B =
1  5
4  2

A − B =
8  3
3  4
Trace

Worked Walkthrough — 2×2

Visit every index once and subtract the matching cells.

Calculation
A = [9 8]    B = [1 5]
    [7 6]        [4 2]

i=0, j=0 → 9 − 1 = 8
i=0, j=1 → 8 − 5 = 3
i=1, j=0 → 7 − 4 = 3
i=1, j=1 → 6 − 2 = 4

Result = [8 3]
         [3 4]
Code

C Programs

Start with a clear nested-loop subtractor. Then add a shape check so mismatched sizes fail safely.

Example 1 — Nested Loops

Subtract two same-sized 2D arrays cell by cell and print the result.

C
#include <stdio.h>

#define ROWS 2
#define COLS 2

void subtract_matrices(int a[ROWS][COLS], int b[ROWS][COLS],
                       int result[ROWS][COLS])
{
    int i, j;

    for (i = 0; i < ROWS; i++)
    {
        for (j = 0; j < COLS; j++)
        {
            result[i][j] = a[i][j] - b[i][j];
        }
    }
}

void print_matrix(int m[ROWS][COLS])
{
    int i, j;

    for (i = 0; i < ROWS; i++)
    {
        for (j = 0; j < COLS; j++)
        {
            printf("%d ", m[i][j]);
        }
        printf("\\n");
    }
}

int main(void)
{
    int a[ROWS][COLS] = { { 9, 8 }, { 7, 6 } };
    int b[ROWS][COLS] = { { 1, 5 }, { 4, 2 } };
    int result[ROWS][COLS];

    subtract_matrices(a, b, result);
    print_matrix(result);
    return 0;
}

How It Works

  1. ROWS and COLS fix the shared matrix size.
  2. Allocate a result array of the same shape.
  3. Outer loop chooses row i; inner loop chooses column j.
  4. Store a[i][j] - b[i][j] into result[i][j].
  5. Print walks the result the same way — one row per line.

Example 2 — Shape-Safe Subtract

Validate dimensions before subtracting so mismatched matrices fail with a clear message.

C
#include <stdio.h>

#define MAX_COLS 8

int subtract_matrices(int a[][MAX_COLS], int rows_a, int cols_a,
                      int b[][MAX_COLS], int rows_b, int cols_b,
                      int result[][MAX_COLS])
{
    int i, j;

    if (rows_a != rows_b || cols_a != cols_b)
    {
        printf("Matrices must have the same dimensions.\\n");
        return 0;
    }

    for (i = 0; i < rows_a; i++)
    {
        for (j = 0; j < cols_a; j++)
        {
            result[i][j] = a[i][j] - b[i][j];
        }
    }
    return 1;
}

int main(void)
{
    int a[2][MAX_COLS] = { { 10, 9, 8 }, { 7, 6, 5 } };
    int b[2][MAX_COLS] = { { 1, 2, 3 }, { 4, 5, 6 } };
    int diff[2][MAX_COLS];
    int i, j;

    if (!subtract_matrices(a, 2, 3, b, 2, 3, diff))
    {
        return 1;
    }

    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++)
        {
            printf("%d ", diff[i][j]);
        }
        printf("\\n");
    }
    return 0;
}

How It Works

  1. Pass row and column counts for both matrices.
  2. Return early if shapes differ — subtraction would be undefined.
  3. Otherwise run the same nested-loop subtraction as Example 1.
  4. For the 2×3 sample: 5 - 6 = -1 shows negatives are fine.
  5. Mention the shape check in interviews even when samples already match.

Edge Cases & Pitfalls

Check these before calling the solution done.

Shape

Must match

Different sizes cannot be subtracted — validate first.

Negatives

Expected

When B[i][j] > A[i][j], the cell is negative.

Order

A − B ≠ B − A

Subtraction is not commutative — keep the operand order clear.

Multiply

Different problem

Do not confuse entrywise subtract with row-column multiply.

Analysis

Time and Space Complexity

ProgramTimeExtra space
Nested loopsO(m × n)O(1) besides result
Shape-safe subtractO(m × n)O(1) besides result

Every cell is touched exactly once. The result matrix needs O(m × n) space to store the answer.

Remember

Key Takeaways

  • Rule: subtract matching cells; shapes must match.
  • Loops: outer rows, inner columns.
  • Negatives: valid when B’s cell is larger.
  • Test: {{9,8},{7,6}} − {{1,5},{4,2}} → {{8,3},{3,4}}.

One line: same shape required — then C[i][j] = A[i][j] − B[i][j].

Frequently Asked Questions

Only when they have the same dimensions — same row count and same column count. Then each result cell is A[i][j] − B[i][j].
Yes. If B’s cell is larger than A’s, the difference is negative. That is normal.
No. Subtraction is entrywise for same-sized matrices. Multiplication uses row-column dot products and different shape rules.
A − B is the same idea as A + (−B). Both need matching shapes and nested loops over every cell.
For an m × n matrix, each entry is visited once, so time is O(m × n).

Next: Matrix Transpose

Swap rows and columns of a matrix in C.

Matrix transpose tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

8 people found this page helpful

C Matrix Multiplication Program C Matrix Transpose Program