Definition
Entrywise
Each output cell is the sum of matching input cells.
Perform Matrix Addition in Python
Overview
What You’ll Learn
Matrix addition combines matching cells: C[i][j] = A[i][j] + B[i][j], only when shapes match. This tutorial covers the rule, nested loops over list-of-lists, a live preview, worked Python examples, edge cases, and complexity.
Same Shape
m × n both
Addition is defined only when dimensions match.
Nested Loops
Rows × cols
Outer loop rows, inner loop columns, visit each cell once.
3×3 Sample
All 10s
Classic demo: complementary matrices sum to 10.
Live Preview
Show sum
Run the 3×3 sample matrices in the browser.
O(m·n)
Per add
Visit each of the m·n cells exactly once.
Introduction
Matrix addition is entrywise: if A and B are both m × n, then C = A + B is also m × n with C[i][j] = A[i][j] + B[i][j].
In Python interviews, matrices are usually list-of-lists. Nested loops walk every position once; if shapes differ, addition is not defined.
Why it matters?
It is the cleanest 2D indexing warm-up — and the foundation before subtraction, multiplication, and transpose problems.
Key Highlights
Same Positions
Top-left adds to top-left — never mix cells.
Shape First
Validate rows and columns before looping.
List of Lists
Access cells with matrix[i][j].
Commutative
A + B = B + A for equal-sized matrices.
In short: if shapes match, walk every cell with nested loops and set C[i][j] = A[i][j] + B[i][j].
Foundation
📝 Problem & Approach
Given two equal-sized matrices A and B, build C where each cell is the sum of corresponding cells.
python
# [[1, 2], [3, 4]] + [[4, 3], [2, 1]] = [[5, 5], [5, 5]]
# Same shape required; different shape → not definedInputs & Outputs
| Item | Type | Description |
|---|---|---|
A, B | list[list[int]] | Two matrices with the same shape. |
| Return / print | matrix / text | Result matrix C with entrywise sums. |
Minimal workflow
Pseudocode
function add_matrices(A, B, rows, cols):
create matrix C of shape rows x 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 CMethod comparison
| Method | Idea | Notes |
|---|---|---|
| Nested loops | C[i][j] = A[i][j] + B[i][j] | Interview default — clear indexing |
| List comprehension | Build rows with nested comps | Compact Python; same O(m·n) |
| NumPy | A + B | Production speed; show loops in interviews |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Rows | rows = len(mat) |
| Columns | cols = len(mat[0]) |
| Add cell | result[i][j] = a[i][j] + b[i][j] |
| Traverse | for i in range(rows): for j in range(cols) |
| Print row | print(" ".join(str(x) for x in row)) |
| Shape check | Same len for rows and each row length |
Compare
📋 Loops vs Comprehension vs NumPy
Same entrywise rule — pick the form that fits the interview.
Nested loops
i, j indexingClearest story for whiteboards
Comprehension
[[a+b...]]Idiomatic Python once loops are solid
NumPy
A + BFast for large data in apps
Interview tip
shape firstState the dimension rule before coding
Context
When This Problem Shows Up
Reach for matrix addition when 2D indexing and entrywise work matter.
Interview warm-ups
Nested loops plus list-of-lists indexing.
Linear algebra basics
First matrix operation before multiply / transpose.
Image / grid tasks
Same pattern as combining equal-sized grids.
After magic numbers
Shift from digit loops to 2D structures.
Not for multiply
Different shape rules — do not confuse the two.
Key benefit: one short 2D problem that locks in indexing, shape validation, and O(m·n) thinking.
Interactive
🔮 Live Preview
Uses the same 3×3 sample matrices as Example 1. Click to display Matrix 1, Matrix 2, and the result.
Hands-On
Examples Gallery
Three complete Python programs — 3×3 helpers, compact 2×2, and a dimension-safe adder. Click View Output to reveal sample console results.
📚 Getting Started
Reusable add and display helpers for a 3×3 pair.
Example 1 — Add Two 3×3 Matrices
Helper functions for addition and display — beginner-friendly and interview-friendly.
python
def add_matrices(mat1: list[list[int]], mat2: list[list[int]]) -> list[list[int]]:
rows = len(mat1)
cols = len(mat1[0])
result = []
for i in range(rows):
row = []
for j in range(cols):
row.append(mat1[i][j] + mat2[i][j])
result.append(row)
return result
def display_matrix(title: str, matrix: list[list[int]]) -> None:
print(title)
for row in matrix:
print(" ".join(str(x) for x in row))
def main() -> None:
matrix1 = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
matrix2 = [
[9, 8, 7],
[6, 5, 4],
[3, 2, 1],
]
result_matrix = add_matrices(matrix1, matrix2)
display_matrix("Matrix 1:", matrix1)
print()
display_matrix("Matrix 2:", matrix2)
print()
display_matrix("Resultant Matrix:", result_matrix)
if __name__ == "__main__":
main()How It Works
The key line is mat1[i][j] + mat2[i][j]. Nested loops visit every matching position once; the print helper formats each row for the console.
⚡ Compact Size
Same logic on a smaller 2×2 dry-run.
Example 2 — Add Two 2×2 Matrices
Fixed-size loops — great for quick whiteboard checks.
python
def add_matrices_2x2(a: list[list[int]], b: list[list[int]]) -> list[list[int]]:
result = [[0, 0], [0, 0]]
for i in range(2):
for j in range(2):
result[i][j] = a[i][j] + b[i][j]
return result
def print_matrix(title: str, m: list[list[int]]) -> None:
print(title)
for row in m:
print(*row)
def main() -> None:
a = [
[1, 2],
[3, 4],
]
b = [
[4, 3],
[2, 1],
]
c = add_matrices_2x2(a, b)
print_matrix("A", a)
print()
print_matrix("B", b)
print()
print_matrix("A + B", c)
if __name__ == "__main__":
main()How It Works
Even with fixed size 2×2, the pattern is identical: loop over rows and columns and add matching entries.
⚙️ Shape Validation
Reject mismatched or ragged matrices before adding.
Example 3 — Dimension-Safe Adder
Checks empty input, row counts, and uniform column lengths, then adds.
python
def same_shape(a: list[list[int]], b: list[list[int]]) -> bool:
if not a or not b:
return False
if len(a) != len(b):
return False
cols = len(a[0])
if cols == 0:
return False
for row in a + b:
if len(row) != cols:
return False
return True
def add_matrices_safe(a: list[list[int]], b: list[list[int]]) -> list[list[int]] | None:
if not same_shape(a, b):
return None
rows, cols = len(a), len(a[0])
return [[a[i][j] + b[i][j] for j in range(cols)] for i in range(rows)]
ok = add_matrices_safe([[1, 2], [3, 4]], [[4, 3], [2, 1]])
bad = add_matrices_safe([[1, 2]], [[1, 2], [3, 4]])
print(ok)
print(bad)How It Works
Shape checks catch mismatched dimensions and ragged rows before any addition. Returning None (or raising) is clearer than silent index errors.
🧠 How the Algorithm Builds C
1
Check dimensions
If row or column counts differ, stop.
Shape
2
Nested traverse
For each i, j set C[i][j] = A[i][j] + B[i][j].
Loops
3
Display result
Print each row on its own line.
Output
=
Sum matrix ready
C has the same shape as A and B.
Trace
🔎 Worked Walkthrough — 2×2
Trace each cell for [[1, 2], [3, 4]] + [[4, 3], [2, 1]].
| (i, j) | A | B | C |
|---|---|---|---|
(0, 0) | 1 | 4 | 5 |
(0, 1) | 2 | 3 | 5 |
(1, 0) | 3 | 2 | 5 |
(1, 1) | 4 | 1 | 5 |
Result: [[5, 5], [5, 5]].
Use Cases
Where matrix addition shows up beyond the interview prompt.
1. Interview Warm-Ups
2D indexing with a one-line cell formula.
Example: write add_matrices(A, B).
2. Teaching Nested Loops
Outer row / inner column with a visual result.
Example: 3×3 all-10s demo.
3. Grid / Image Layers
Combine equal-sized 2D arrays entrywise.
Example: add two intensity maps.
4. Precursor to Multiply
Master shape rules before harder matrix ops.
Example: next up: division / multiply.
5. Validation Habits
Practice rejecting ragged or mismatched shapes.
Example: Example 3 above.
6. Complexity Stories
State O(m·n) when asked about cost.
Example: one add per cell.
Pro Tip: say “same shape, entrywise sum” before writing a single loop.
Advantages
Why this pattern works well in interviews and classwork.
1. Simple Formula
One cell rule: C[i][j] = A[i][j] + B[i][j].
2. Predictable Cost
Exactly m·n additions for an m×n pair.
3. Easy to Dry-Run
2×2 examples fit on a whiteboard in seconds.
4. Builds Later Topics
Same traversal pattern for subtraction and more.
Pro Tip: lead with nested loops; mention list comprehensions or NumPy only as follow-ups.
Usage Tips
Small habits that keep matrix-addition solutions interview-ready.
1. State Shape First
Say “same m×n required” before coding loops.
2. Build Rows Fresh
Append a new row list each outer iteration — avoid shared references.
3. Dry-Run a 2×2
Four cells catch off-by-one bugs fast.
4. Print Row by Row
Keep matrix layout readable in console demos.
5. Mention O(m·n)
Interviewers often ask complexity right after the code.
Pro Tip: never write result = [[0] * cols] * rows — that shares row references and corrupts updates.
Common Pitfalls
Mistakes that commonly break matrix-addition solutions.
1. Ignoring Shape Mismatch
Adding matrices with different sizes.
→ Validate rows and columns first.
2. Shared Row References
[[0]*cols]*rowsmakes every row the same list.→ Build each row separately (or use a comprehension carefully).
3. Ragged Rows
One row shorter than others raises index errors.
→ Check every row length equals
cols.4. Swapping i and j
Wrong index order corrupts rectangular matrices.
→ Keep i = row, j = column consistently.
5. Confusing With Multiplication
Using row·column products for addition.
→ Addition is entrywise only.
Edge Cases
Most matrix-addition bugs come from shape assumptions and indexing mistakes.
Shape
Mismatched dimensions
Never add matrices with different row or column counts.
Input
Ragged rows
Validate each row length before indexing.
Index
Wrong loop bounds
Bad ranges skip cells or raise IndexError.
Empty
Empty matrices
Decide whether [] + [] is allowed; guard empty rows.
1×1
Single cell
Still uses the same formula — one addition.
Negatives
Signed entries
Addition works the same for negative integers.
Math
⚖️ Facts Worth Knowing
Handy follow-ups interviewers sometimes ask.
- Entrywise. (A+B)ij = Aij + Bij.
- Commutative. A + B = B + A for equal-sized matrices.
- Associative. (A + B) + C = A + (B + C) when shapes match.
- Not multiply. Multiplication has different dimensions and a different formula.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Dry-run 2×2
- Reproduce Example 2 by hand
- Expect all 5s
2. Shape rejection
- 2×2 + 2×3 → error / None
- Assert your guard works
3. List comprehension
- Rewrite add without explicit appends
- Keep the same O(m·n) behavior
4. Subtract next
- Change + to - with the same loops
- Warm-up for matrix division page
Important
Notes
- Definition:
C[i][j] = A[i][j] + B[i][j]only when dimensions match. - Code pattern: nested loops over rows and columns, plus optional print helper.
- Complexity: linear in number of cells,
m*n. - Watch ragged rows and shared-list initialization bugs.
Quick Takeaway: same shape required; add matching cells with nested loops in O(m·n).
Analysis
⏱️ Time and Space Complexity
| Operation | Time | Extra space |
|---|---|---|
Add two m × n matrices | O(m*n) | O(1) besides the output matrix |
Print an m × n matrix | O(m*n) | O(1) |
| Shape validation | O(m) row checks | O(1) |
🎉 Conclusion
Matrix addition is entrywise: matching cells add when shapes match. Use nested loops over list-of-lists, validate dimensions, and state O(m·n) complexity.
Practice the three examples above, then continue to matrix division for the next 2D operation.
Same shape first, then C[i][j] = A[i][j] + B[i][j] — never confuse this with multiplication.
Pro Tips
💡 Best Practices
✅ Do
- State the shape rule before coding
- Use nested loops with clear i, j meaning
- Build each result row as a fresh list
- Dry-run a 2×2 example
- Quote O(m*n) complexity
❌ Don’t
- Add mismatched shapes
- Initialize with
[[0]*cols]*rows - Ignore ragged rows
- Swap row/column indices
- Confuse addition with multiplication
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about matrix addition
Add matrices the interview-friendly way.
5
Core concepts 01
Rule
Entrywise sum
Definition 02
Shape
Same m × n
Constraint 03
Loops
Rows then cols
Code 04
Store
list[list]
Python 05
Cost
O(m·n)
Analysis❓ Frequently Asked Questions
They must have exactly the same dimensions: same row count and same column count. Then each output cell is the sum of matching cells.
For interview-level problems, a matrix is usually a list of lists, such as [[1, 2], [3, 4]]. Each inner list is one row.
Yes. For equal-sized matrices, A + B = B + A because each pair of matching entries is added.
For an m x n matrix, we visit each entry once, so time complexity is O(m*n). Extra space is O(1) besides the output matrix.
Python integers are arbitrary precision, so normal integer overflow does not happen. But very large numbers can still make operations slower.
Because matrices are 2D. The outer loop walks rows and the inner loop walks columns, so every position (i, j) is processed exactly once.
No. Addition is entrywise. Multiplication mixes rows and columns with a different formula and shape rules.
NumPy can add arrays with a + b. Interviews usually want nested loops first so you show indexing clearly.
Did you Know? 🔊
Matrix addition is entrywise: (A+B)ij = Aij + Bij. It is valid only when both matrices have the same number of rows and columns.
Continue to Matrix Division
Learn how to divide two matrices entrywise with the same nested-loop pattern.
About the author
8 people found this page helpful