Add matrix module: addition, multiplication, transpose, spiral and rotation programs, dry-run traces, operation counts, seeded law checks, six pitfalls (10 tests)
Co-Authored-By: Claude Sonnet 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_017ic4b4pD5LRLNWAecBNsj9
This commit is contained in:
co-authored by
Claude Sonnet 5.5
parent
26ece9cc9b
commit
35ef0872de
@@ -22,6 +22,7 @@ One module per article. This repository currently holds:
|
|||||||
| [`fresher-qa`](fresher-qa/) | Top 50 Java Interview Questions for Freshers (2026) with Simple Answers | this commit |
|
| [`fresher-qa`](fresher-qa/) | Top 50 Java Interview Questions for Freshers (2026) with Simple Answers | this commit |
|
||||||
| [`stack-queue`](stack-queue/) | Stack and Queue Problems in Java: Balanced Parentheses, Next Greater Element, Min Stack | this commit |
|
| [`stack-queue`](stack-queue/) | Stack and Queue Problems in Java: Balanced Parentheses, Next Greater Element, Min Stack | this commit |
|
||||||
| [`library-management`](library-management/) | Library Management System in Java: Console Version to Spring Boot REST API | this commit |
|
| [`library-management`](library-management/) | Library Management System in Java: Console Version to Spring Boot REST API | this commit |
|
||||||
|
| [`matrix`](matrix/) | Matrix Programs in Java: Addition, Multiplication, Transpose, Spiral and Rotation | this commit |
|
||||||
|
|
||||||
## `collections` module
|
## `collections` module
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,58 @@
|
|||||||
|
# matrix
|
||||||
|
|
||||||
|
Companion code for the ankurm.com article **Matrix Programs in Java: Addition, Multiplication, Transpose, Spiral and Rotation**.
|
||||||
|
|
||||||
|
The five classic lab programs on `int[][]`, each cross-checked with algebraic laws on seeded random
|
||||||
|
matrices. Every figure and console line in the article is quoted from a file in `output/`, which the JUnit
|
||||||
|
tests write while asserting the same numbers. There is no `docs/` folder: the explanations live in the
|
||||||
|
article itself.
|
||||||
|
|
||||||
|
## Versions
|
||||||
|
|
||||||
|
| Component | Version | Verified against |
|
||||||
|
|---|---|---|
|
||||||
|
| JDK | Temurin 25.0.5+8 (LTS) | `java -version` |
|
||||||
|
| JUnit | 6.1.3 | `junit-bom` `maven-metadata.xml` on Maven Central (latest GA) |
|
||||||
|
| Maven | 3.9.x | `mvn -version` |
|
||||||
|
|
||||||
|
## Quickstart
|
||||||
|
|
||||||
|
```bash
|
||||||
|
cd matrix
|
||||||
|
export JAVA_HOME=/path/to/jdk-25 PATH="$JAVA_HOME/bin:$PATH"
|
||||||
|
./scripts/run-all.sh # runs the tests and regenerates output/*.txt
|
||||||
|
```
|
||||||
|
|
||||||
|
The first Maven run must be online so the plugins land in the local cache.
|
||||||
|
|
||||||
|
## Source layout
|
||||||
|
|
||||||
|
```
|
||||||
|
matrix/
|
||||||
|
├── pom.xml
|
||||||
|
├── scripts/run-all.sh
|
||||||
|
├── src/main/java/com/ankurm/interviewlab/matrix/
|
||||||
|
│ ├── MatrixBasics.java add, subtract, multiply (i-j-k and i-k-j), multiplyExact, identity, copyOf, format
|
||||||
|
│ ├── Transpose.java transpose (any shape), transposeInPlace (square), isSymmetric
|
||||||
|
│ ├── Spiral.java spiralOrder, spiralMatrix
|
||||||
|
│ ├── Rotation.java clockwise, counter-clockwise, 180, in-place (transpose + reverse, layer swaps)
|
||||||
|
│ ├── DryRuns.java instrumented copies that record every step
|
||||||
|
│ ├── Complexity.java operation counters (counted, not timed)
|
||||||
|
│ └── Pitfalls.java six plausible-looking wrong versions
|
||||||
|
├── src/test/java/.../ SolutionsTest, DryRunTest, ComplexityTest, RandomAgreementTest, PitfallsTest
|
||||||
|
└── output/*.txt captured real output
|
||||||
|
```
|
||||||
|
|
||||||
|
## Captured output
|
||||||
|
|
||||||
|
| File | What it shows |
|
||||||
|
|---|---|
|
||||||
|
| `01-addition-and-multiplication.txt` | sum, product, shape-mismatch and jagged-row errors |
|
||||||
|
| `02-multiply-dry-run.txt` | the four steps that build one cell of a product |
|
||||||
|
| `03-transpose.txt` | rectangular transpose, in-place square transpose, symmetric check |
|
||||||
|
| `04-spiral-trace.txt`, `04a-spiral-results.txt` | boundary trace of a 3x4 spiral, edge shapes, `spiralMatrix(4)` |
|
||||||
|
| `05-rotation.txt` | clockwise, counter-clockwise, 180, both in-place methods, a rectangular rotation |
|
||||||
|
| `06-layer-rotation-trace.txt` | each four-cell move of the layer rotation on 3x3 |
|
||||||
|
| `07-random-agreement.txt` | nine laws, 2,000 seeded trials each |
|
||||||
|
| `08-operation-counts.txt` | multiplications, swaps, moves and visits |
|
||||||
|
| `09-pitfalls.txt` | six classic mistakes reproduced |
|
||||||
@@ -0,0 +1,30 @@
|
|||||||
|
Addition and multiplication
|
||||||
|
===========================
|
||||||
|
|
||||||
|
A + B (both 2x3)
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
+
|
||||||
|
[6 5 4]
|
||||||
|
[3 2 1]
|
||||||
|
=
|
||||||
|
[7 7 7]
|
||||||
|
[7 7 7]
|
||||||
|
|
||||||
|
X * Y (2x3 times 3x2 gives 2x2)
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
*
|
||||||
|
[ 7 8]
|
||||||
|
[ 9 10]
|
||||||
|
[11 12]
|
||||||
|
=
|
||||||
|
[ 58 64]
|
||||||
|
[139 154]
|
||||||
|
|
||||||
|
multiply (i-j-k) and multiplyIkj agree: true
|
||||||
|
X * I (3x3 identity) equals X: true
|
||||||
|
|
||||||
|
add 2x3 + 3x2 -> IllegalArgumentException: cannot add 2x3 and 3x2: both matrices must have the same shape
|
||||||
|
multiply 2x3 * 2x3 -> IllegalArgumentException: cannot multiply 2x3 by 2x3: columns of A (3) must equal rows of B (2)
|
||||||
|
add with a jagged row -> IllegalArgumentException: row 1 has 1 columns but row 0 has 2
|
||||||
@@ -0,0 +1,16 @@
|
|||||||
|
Dry run: one cell of the product
|
||||||
|
================================
|
||||||
|
|
||||||
|
A (2x3)
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
B (3x2)
|
||||||
|
[ 7 8]
|
||||||
|
[ 9 10]
|
||||||
|
[11 12]
|
||||||
|
|
||||||
|
cell C[0][1] = row 0 of A dotted with column 1 of B
|
||||||
|
k=0: A[0][0] * B[0][1] = 1 * 8 = 8 running total = 8
|
||||||
|
k=1: A[0][1] * B[1][1] = 2 * 10 = 20 running total = 28
|
||||||
|
k=2: A[0][2] * B[2][1] = 3 * 12 = 36 running total = 64
|
||||||
|
C[0][1] = 64
|
||||||
@@ -0,0 +1,24 @@
|
|||||||
|
Transpose
|
||||||
|
=========
|
||||||
|
|
||||||
|
2x3 matrix
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
transpose() gives a 3x2 matrix
|
||||||
|
[1 4]
|
||||||
|
[2 5]
|
||||||
|
[3 6]
|
||||||
|
|
||||||
|
3x3 matrix, transposeInPlace()
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
[7 8 9]
|
||||||
|
becomes
|
||||||
|
[1 4 7]
|
||||||
|
[2 5 8]
|
||||||
|
[3 6 9]
|
||||||
|
|
||||||
|
isSymmetric([[1,7,3],[7,4,-5],[3,-5,6]]) = true
|
||||||
|
isSymmetric([[1,2],[3,4]]) = false
|
||||||
|
|
||||||
|
transposeInPlace on a 2x3 matrix -> IllegalArgumentException: in-place transpose needs a square matrix but got 2x3
|
||||||
@@ -0,0 +1,19 @@
|
|||||||
|
Dry run: spiral traversal of a 3x4 matrix
|
||||||
|
=========================================
|
||||||
|
|
||||||
|
[ 1 2 3 4]
|
||||||
|
[ 5 6 7 8]
|
||||||
|
[ 9 10 11 12]
|
||||||
|
|
||||||
|
round 1: top=0 bottom=2 left=0 right=3
|
||||||
|
top row, left to right -> [1, 2, 3, 4]
|
||||||
|
right column, top to bottom -> [8, 12]
|
||||||
|
bottom row, right to left -> [11, 10, 9]
|
||||||
|
left column, bottom to top -> [5]
|
||||||
|
round 2: top=1 bottom=1 left=1 right=2
|
||||||
|
top row, left to right -> [6, 7]
|
||||||
|
right column, top to bottom -> []
|
||||||
|
bottom row skipped (top > bottom)
|
||||||
|
left column, bottom to top -> []
|
||||||
|
|
||||||
|
spiralOrder = [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]
|
||||||
@@ -0,0 +1,19 @@
|
|||||||
|
Spiral traversal results
|
||||||
|
========================
|
||||||
|
|
||||||
|
3x4 matrix
|
||||||
|
[ 1 2 3 4]
|
||||||
|
[ 5 6 7 8]
|
||||||
|
[ 9 10 11 12]
|
||||||
|
spiralOrder = [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]
|
||||||
|
|
||||||
|
single row [[1,2,3]] -> [1, 2, 3]
|
||||||
|
single column [[1],[2],[3]] -> [1, 2, 3]
|
||||||
|
single cell [[5]] -> [5]
|
||||||
|
|
||||||
|
spiralMatrix(4), the reverse problem
|
||||||
|
[ 1 2 3 4]
|
||||||
|
[12 13 14 5]
|
||||||
|
[11 16 15 6]
|
||||||
|
[10 9 8 7]
|
||||||
|
spiralOrder(spiralMatrix(4)) = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
|
||||||
@@ -0,0 +1,42 @@
|
|||||||
|
Rotation
|
||||||
|
========
|
||||||
|
|
||||||
|
original 3x3
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
[7 8 9]
|
||||||
|
|
||||||
|
rotateClockwise
|
||||||
|
[7 4 1]
|
||||||
|
[8 5 2]
|
||||||
|
[9 6 3]
|
||||||
|
|
||||||
|
rotateCounterClockwise
|
||||||
|
[3 6 9]
|
||||||
|
[2 5 8]
|
||||||
|
[1 4 7]
|
||||||
|
|
||||||
|
rotate180
|
||||||
|
[9 8 7]
|
||||||
|
[6 5 4]
|
||||||
|
[3 2 1]
|
||||||
|
|
||||||
|
rotateClockwiseInPlace (transpose, then reverse each row)
|
||||||
|
[7 4 1]
|
||||||
|
[8 5 2]
|
||||||
|
[9 6 3]
|
||||||
|
|
||||||
|
rotateClockwiseLayers (four-cell moves)
|
||||||
|
[7 4 1]
|
||||||
|
[8 5 2]
|
||||||
|
[9 6 3]
|
||||||
|
|
||||||
|
both in-place versions equal rotateClockwise: true
|
||||||
|
|
||||||
|
rectangular 2x3 rotated clockwise becomes 3x2 (in-place is impossible: the shape changes)
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
->
|
||||||
|
[4 1]
|
||||||
|
[5 2]
|
||||||
|
[6 3]
|
||||||
@@ -0,0 +1,15 @@
|
|||||||
|
Dry run: layer-by-layer rotation of a 3x3 matrix
|
||||||
|
================================================
|
||||||
|
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
[7 8 9]
|
||||||
|
|
||||||
|
layer 0, i=0: left 7 -> top, bottom 9 -> left, right 3 -> bottom, top 1 -> right
|
||||||
|
[7 2 1]
|
||||||
|
[4 5 6]
|
||||||
|
[9 8 3]
|
||||||
|
layer 0, i=1: left 4 -> top, bottom 8 -> left, right 6 -> bottom, top 2 -> right
|
||||||
|
[7 4 1]
|
||||||
|
[8 5 2]
|
||||||
|
[9 6 3]
|
||||||
@@ -0,0 +1,12 @@
|
|||||||
|
Seeded random checks (seed 2026, 2000 trials each)
|
||||||
|
==================================================
|
||||||
|
|
||||||
|
rotateClockwise == transpose-then-reverse == layer swaps (n x n, n = 1..8): 2000 agree, 0 disagree
|
||||||
|
four clockwise turns return the original: 2000 agree, 0 disagree
|
||||||
|
clockwise then counter-clockwise returns the original: 2000 agree, 0 disagree
|
||||||
|
transpose twice returns the original (random m x n): 2000 agree, 0 disagree
|
||||||
|
(A * B) transposed == B transposed * A transposed: 2000 agree, 0 disagree
|
||||||
|
A * I == A and I * A == A: 2000 agree, 0 disagree
|
||||||
|
i-j-k product == i-k-j product: 2000 agree, 0 disagree
|
||||||
|
A * (B + C) == A * B + A * C: 2000 agree, 0 disagree
|
||||||
|
spiral order is a permutation of all m * n elements: 2000 agree, 0 disagree
|
||||||
@@ -0,0 +1,27 @@
|
|||||||
|
Operation counts (counted, not timed)
|
||||||
|
=====================================
|
||||||
|
|
||||||
|
multiplications for an n x n product (i-j-k loop)
|
||||||
|
n = 10 1,000 multiplications
|
||||||
|
n = 100 1,000,000 multiplications
|
||||||
|
n = 200 8,000,000 multiplications
|
||||||
|
doubling n from 100 to 200 multiplies the work by 8
|
||||||
|
|
||||||
|
2x3 times 3x2: 12 multiplications (m * n * p = 2 * 3 * 2)
|
||||||
|
|
||||||
|
in-place transpose swaps, n x n
|
||||||
|
n = 3 3 swaps (n * (n - 1) / 2 = 3)
|
||||||
|
n = 100 4,950 swaps (n * (n - 1) / 2 = 4,950)
|
||||||
|
|
||||||
|
layer rotation four-cell moves, n x n
|
||||||
|
n = 3 2 moves (n * n / 4 rounded down = 2)
|
||||||
|
n = 4 4 moves (n * n / 4 rounded down = 4)
|
||||||
|
n = 100 2,500 moves (n * n / 4 rounded down = 2,500)
|
||||||
|
|
||||||
|
spiral: cells visited vs rows * cols
|
||||||
|
1 x 1 visits = 1 rows * cols = 1
|
||||||
|
1 x 7 visits = 7 rows * cols = 7
|
||||||
|
7 x 1 visits = 7 rows * cols = 7
|
||||||
|
3 x 4 visits = 12 rows * cols = 12
|
||||||
|
5 x 5 visits = 25 rows * cols = 25
|
||||||
|
40 x 25 visits = 1,000 rows * cols = 1,000
|
||||||
@@ -0,0 +1,44 @@
|
|||||||
|
Six classic mistakes, each reproduced
|
||||||
|
=====================================
|
||||||
|
|
||||||
|
1. in-place transpose with the inner loop starting at j = 0 instead of j = i + 1
|
||||||
|
input
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
[7 8 9]
|
||||||
|
result (identical to the input, every pair was swapped twice)
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
[7 8 9]
|
||||||
|
|
||||||
|
2. product result allocated as rows(A) x rows(A) instead of rows(A) x cols(B)
|
||||||
|
2x3 times 3x4, correct result shape 2x4
|
||||||
|
wrong version -> ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2
|
||||||
|
|
||||||
|
3. spiral without the 'is there still a row / column left?' checks
|
||||||
|
input [[1, 2, 3]] (a single row)
|
||||||
|
wrong = [1, 2, 3, 2, 1]
|
||||||
|
correct = [1, 2, 3]
|
||||||
|
|
||||||
|
4. layer rotation with i <= last instead of i < last (the corner is moved twice)
|
||||||
|
input
|
||||||
|
[1 2 3]
|
||||||
|
[4 5 6]
|
||||||
|
[7 8 9]
|
||||||
|
wrong
|
||||||
|
[9 4 7]
|
||||||
|
[8 5 2]
|
||||||
|
[3 6 1]
|
||||||
|
correct
|
||||||
|
[7 4 1]
|
||||||
|
[8 5 2]
|
||||||
|
[9 6 3]
|
||||||
|
|
||||||
|
5. 'copy' made with clone() is shallow
|
||||||
|
original = [[1, 2], [3, 4]]; copy = original.clone(); copy[0][0] = 99
|
||||||
|
original[0][0] is now 99 (the rows are shared)
|
||||||
|
copyOf() makes new rows: changing deep[1][1] left original[1][1] at 4
|
||||||
|
|
||||||
|
6. int overflow in the dot product
|
||||||
|
[[50000]] * [[50000]] with plain multiply = -1794967296 (true value 2500000000)
|
||||||
|
multiplyExact -> ArithmeticException: integer overflow
|
||||||
@@ -0,0 +1,64 @@
|
|||||||
|
<?xml version="1.0" encoding="UTF-8"?>
|
||||||
|
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||||
|
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||||
|
<modelVersion>4.0.0</modelVersion>
|
||||||
|
<groupId>com.ankurm.interviewlab</groupId>
|
||||||
|
<artifactId>matrix</artifactId>
|
||||||
|
<version>1.0.0</version>
|
||||||
|
<packaging>jar</packaging>
|
||||||
|
|
||||||
|
<name>java-interview-lab :: matrix</name>
|
||||||
|
<description>
|
||||||
|
Runnable companion code for ankurm.com's "Matrix Programs in Java" article: addition, multiplication, transpose,
|
||||||
|
spiral traversal and rotation, with dry runs, operation counts and the classic mistakes.
|
||||||
|
</description>
|
||||||
|
|
||||||
|
<properties>
|
||||||
|
<maven.compiler.release>25</maven.compiler.release>
|
||||||
|
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||||
|
<junit.version>6.1.3</junit.version>
|
||||||
|
</properties>
|
||||||
|
|
||||||
|
<dependencyManagement>
|
||||||
|
<dependencies>
|
||||||
|
<dependency>
|
||||||
|
<groupId>org.junit</groupId>
|
||||||
|
<artifactId>junit-bom</artifactId>
|
||||||
|
<version>${junit.version}</version>
|
||||||
|
<type>pom</type>
|
||||||
|
<scope>import</scope>
|
||||||
|
</dependency>
|
||||||
|
</dependencies>
|
||||||
|
</dependencyManagement>
|
||||||
|
|
||||||
|
<dependencies>
|
||||||
|
<dependency>
|
||||||
|
<groupId>org.junit.jupiter</groupId>
|
||||||
|
<artifactId>junit-jupiter</artifactId>
|
||||||
|
<scope>test</scope>
|
||||||
|
</dependency>
|
||||||
|
<dependency>
|
||||||
|
<groupId>org.junit.platform</groupId>
|
||||||
|
<artifactId>junit-platform-launcher</artifactId>
|
||||||
|
<scope>test</scope>
|
||||||
|
</dependency>
|
||||||
|
</dependencies>
|
||||||
|
|
||||||
|
<build>
|
||||||
|
<plugins>
|
||||||
|
<plugin>
|
||||||
|
<groupId>org.apache.maven.plugins</groupId>
|
||||||
|
<artifactId>maven-compiler-plugin</artifactId>
|
||||||
|
<version>3.14.0</version>
|
||||||
|
</plugin>
|
||||||
|
<plugin>
|
||||||
|
<groupId>org.apache.maven.plugins</groupId>
|
||||||
|
<artifactId>maven-surefire-plugin</artifactId>
|
||||||
|
<version>3.6.0</version>
|
||||||
|
<configuration>
|
||||||
|
<argLine>-Xmx512m -Duser.timezone=UTC -Dfile.encoding=UTF-8</argLine>
|
||||||
|
</configuration>
|
||||||
|
</plugin>
|
||||||
|
</plugins>
|
||||||
|
</build>
|
||||||
|
</project>
|
||||||
Executable
+9
@@ -0,0 +1,9 @@
|
|||||||
|
#!/usr/bin/env bash
|
||||||
|
# Regenerates every file in output/. Needs JDK 25 and Maven. The first Maven run must be online.
|
||||||
|
# Every file is written by a JUnit test that asserts the same numbers it prints, so the figures
|
||||||
|
# in the article are assertions: they fail the build the moment they stop being true.
|
||||||
|
set -euo pipefail
|
||||||
|
cd "$(dirname "$0")/.."
|
||||||
|
mkdir -p output
|
||||||
|
mvn -B -q -T1 test
|
||||||
|
echo "done:"; ls -1 output
|
||||||
@@ -0,0 +1,63 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
/** Operation counters: the algorithms' loops with a counter added. Counted, never timed. */
|
||||||
|
public final class Complexity {
|
||||||
|
private Complexity() {}
|
||||||
|
|
||||||
|
/** Number of scalar multiplications performed by the i-j-k product of an (m x n) and an (n x p) matrix. */
|
||||||
|
public static long multiplications(int m, int n, int p) {
|
||||||
|
long count = 0;
|
||||||
|
for (int i = 0; i < m; i++) {
|
||||||
|
for (int j = 0; j < p; j++) {
|
||||||
|
for (int k = 0; k < n; k++) {
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Number of element swaps made by the in-place square transpose. Equals n * (n - 1) / 2. */
|
||||||
|
public static long transposeSwaps(int n) {
|
||||||
|
long count = 0;
|
||||||
|
for (int i = 0; i < n; i++) {
|
||||||
|
for (int j = i + 1; j < n; j++) {
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Number of four-cell moves made by the layer-by-layer rotation. */
|
||||||
|
public static long layerMoves(int n) {
|
||||||
|
long count = 0;
|
||||||
|
for (int layer = 0; layer < n / 2; layer++) {
|
||||||
|
int first = layer, last = n - 1 - layer;
|
||||||
|
for (int i = first; i < last; i++) {
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Number of cells the spiral visits. Must equal rows * cols: every cell exactly once. */
|
||||||
|
public static long spiralVisits(int rows, int cols) {
|
||||||
|
long count = 0;
|
||||||
|
int top = 0, bottom = rows - 1, left = 0, right = cols - 1;
|
||||||
|
while (top <= bottom && left <= right) {
|
||||||
|
count += right - left + 1;
|
||||||
|
top++;
|
||||||
|
count += Math.max(0, bottom - top + 1);
|
||||||
|
right--;
|
||||||
|
if (top <= bottom) {
|
||||||
|
count += Math.max(0, right - left + 1);
|
||||||
|
bottom--;
|
||||||
|
}
|
||||||
|
if (left <= right) {
|
||||||
|
count += Math.max(0, bottom - top + 1);
|
||||||
|
left++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,83 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
/** Instrumented copies of the real algorithms that record every step, so a dry run is output, not prose. */
|
||||||
|
public final class DryRuns {
|
||||||
|
private DryRuns() {}
|
||||||
|
|
||||||
|
/** Every multiply-and-add that builds one cell of the product. */
|
||||||
|
public static List<String> multiplyCell(int[][] a, int[][] b, int i, int j) {
|
||||||
|
List<String> steps = new ArrayList<>();
|
||||||
|
int dot = 0;
|
||||||
|
for (int k = 0; k < a[0].length; k++) {
|
||||||
|
int term = a[i][k] * b[k][j];
|
||||||
|
dot += term;
|
||||||
|
steps.add("k=" + k + ": A[" + i + "][" + k + "] * B[" + k + "][" + j + "] = "
|
||||||
|
+ a[i][k] + " * " + b[k][j] + " = " + term + " running total = " + dot);
|
||||||
|
}
|
||||||
|
steps.add("C[" + i + "][" + j + "] = " + dot);
|
||||||
|
return steps;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The four boundaries and the side being walked, for every pass of the spiral loop. */
|
||||||
|
public static List<String> spiralTrace(int[][] a) {
|
||||||
|
List<String> steps = new ArrayList<>();
|
||||||
|
int top = 0, bottom = a.length - 1, left = 0, right = a[0].length - 1;
|
||||||
|
int round = 1;
|
||||||
|
while (top <= bottom && left <= right) {
|
||||||
|
steps.add("round " + round + ": top=" + top + " bottom=" + bottom + " left=" + left + " right=" + right);
|
||||||
|
List<Integer> side = new ArrayList<>();
|
||||||
|
for (int j = left; j <= right; j++) side.add(a[top][j]);
|
||||||
|
steps.add(" top row, left to right -> " + side);
|
||||||
|
top++;
|
||||||
|
side = new ArrayList<>();
|
||||||
|
for (int i = top; i <= bottom; i++) side.add(a[i][right]);
|
||||||
|
steps.add(" right column, top to bottom -> " + side);
|
||||||
|
right--;
|
||||||
|
if (top <= bottom) {
|
||||||
|
side = new ArrayList<>();
|
||||||
|
for (int j = right; j >= left; j--) side.add(a[bottom][j]);
|
||||||
|
steps.add(" bottom row, right to left -> " + side);
|
||||||
|
bottom--;
|
||||||
|
} else {
|
||||||
|
steps.add(" bottom row skipped (top > bottom)");
|
||||||
|
}
|
||||||
|
if (left <= right) {
|
||||||
|
side = new ArrayList<>();
|
||||||
|
for (int i = bottom; i >= top; i--) side.add(a[i][left]);
|
||||||
|
steps.add(" left column, bottom to top -> " + side);
|
||||||
|
left++;
|
||||||
|
} else {
|
||||||
|
steps.add(" left column skipped (left > right)");
|
||||||
|
}
|
||||||
|
round++;
|
||||||
|
}
|
||||||
|
return steps;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Each four-cell move of the layer-by-layer rotation, with the matrix state after it. Mutates {@code a}. */
|
||||||
|
public static List<String> layerTrace(int[][] a) {
|
||||||
|
List<String> steps = new ArrayList<>();
|
||||||
|
int n = a.length;
|
||||||
|
for (int layer = 0; layer < n / 2; layer++) {
|
||||||
|
int first = layer, last = n - 1 - layer;
|
||||||
|
for (int i = first; i < last; i++) {
|
||||||
|
int offset = i - first;
|
||||||
|
int top = a[first][i];
|
||||||
|
int left = a[last - offset][first];
|
||||||
|
int bottom = a[last][last - offset];
|
||||||
|
int right = a[i][last];
|
||||||
|
steps.add("layer " + layer + ", i=" + i + ": left " + left + " -> top, bottom " + bottom
|
||||||
|
+ " -> left, right " + right + " -> bottom, top " + top + " -> right");
|
||||||
|
a[first][i] = left;
|
||||||
|
a[last - offset][first] = bottom;
|
||||||
|
a[last][last - offset] = right;
|
||||||
|
a[i][last] = top;
|
||||||
|
steps.add(MatrixBasics.format(a).indent(4).stripTrailing());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return steps;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,175 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import java.util.Arrays;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Addition, subtraction and multiplication of rectangular int matrices, plus the small helpers the
|
||||||
|
* other programs share. A matrix here is just an {@code int[][]} whose rows all have the same length.
|
||||||
|
*/
|
||||||
|
public final class MatrixBasics {
|
||||||
|
private MatrixBasics() {}
|
||||||
|
|
||||||
|
/** Throws if the matrix is empty or jagged (rows of different lengths). */
|
||||||
|
public static void requireRectangular(int[][] m) {
|
||||||
|
if (m.length == 0 || m[0].length == 0) {
|
||||||
|
throw new IllegalArgumentException("matrix must have at least one row and one column");
|
||||||
|
}
|
||||||
|
for (int i = 1; i < m.length; i++) {
|
||||||
|
if (m[i].length != m[0].length) {
|
||||||
|
throw new IllegalArgumentException("row " + i + " has " + m[i].length
|
||||||
|
+ " columns but row 0 has " + m[0].length);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Matrix addition. Both matrices must have the same shape. O(rows * cols). */
|
||||||
|
public static int[][] add(int[][] a, int[][] b) {
|
||||||
|
requireRectangular(a);
|
||||||
|
requireRectangular(b);
|
||||||
|
if (a.length != b.length || a[0].length != b[0].length) {
|
||||||
|
throw new IllegalArgumentException("cannot add " + shape(a) + " and " + shape(b)
|
||||||
|
+ ": both matrices must have the same shape");
|
||||||
|
}
|
||||||
|
int[][] sum = new int[a.length][a[0].length];
|
||||||
|
for (int i = 0; i < a.length; i++) {
|
||||||
|
for (int j = 0; j < a[0].length; j++) {
|
||||||
|
sum[i][j] = a[i][j] + b[i][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return sum;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Matrix subtraction. Same shape rule as {@link #add}. */
|
||||||
|
public static int[][] subtract(int[][] a, int[][] b) {
|
||||||
|
requireRectangular(a);
|
||||||
|
requireRectangular(b);
|
||||||
|
if (a.length != b.length || a[0].length != b[0].length) {
|
||||||
|
throw new IllegalArgumentException("cannot subtract " + shape(b) + " from " + shape(a));
|
||||||
|
}
|
||||||
|
int[][] diff = new int[a.length][a[0].length];
|
||||||
|
for (int i = 0; i < a.length; i++) {
|
||||||
|
for (int j = 0; j < a[0].length; j++) {
|
||||||
|
diff[i][j] = a[i][j] - b[i][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return diff;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Matrix multiplication, the textbook i-j-k loop. An (m x n) matrix times an (n x p) matrix gives an
|
||||||
|
* (m x p) matrix. O(m * n * p) time, which is O(n^3) for square matrices.
|
||||||
|
*/
|
||||||
|
public static int[][] multiply(int[][] a, int[][] b) {
|
||||||
|
requireRectangular(a);
|
||||||
|
requireRectangular(b);
|
||||||
|
int m = a.length, n = a[0].length, p = b[0].length;
|
||||||
|
if (n != b.length) {
|
||||||
|
throw new IllegalArgumentException("cannot multiply " + shape(a) + " by " + shape(b)
|
||||||
|
+ ": columns of A (" + n + ") must equal rows of B (" + b.length + ")");
|
||||||
|
}
|
||||||
|
int[][] c = new int[m][p]; // the result shape is rows(A) x cols(B)
|
||||||
|
for (int i = 0; i < m; i++) {
|
||||||
|
for (int j = 0; j < p; j++) {
|
||||||
|
int dot = 0;
|
||||||
|
for (int k = 0; k < n; k++) {
|
||||||
|
dot += a[i][k] * b[k][j]; // row i of A dotted with column j of B
|
||||||
|
}
|
||||||
|
c[i][j] = dot;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Same answer as {@link #multiply}, with the two inner loops swapped to i-k-j. It walks both B and C
|
||||||
|
* row by row, which is friendlier to the CPU cache on big matrices. The operation count is identical.
|
||||||
|
*/
|
||||||
|
public static int[][] multiplyIkj(int[][] a, int[][] b) {
|
||||||
|
requireRectangular(a);
|
||||||
|
requireRectangular(b);
|
||||||
|
int m = a.length, n = a[0].length, p = b[0].length;
|
||||||
|
if (n != b.length) {
|
||||||
|
throw new IllegalArgumentException("cannot multiply " + shape(a) + " by " + shape(b));
|
||||||
|
}
|
||||||
|
int[][] c = new int[m][p];
|
||||||
|
for (int i = 0; i < m; i++) {
|
||||||
|
for (int k = 0; k < n; k++) {
|
||||||
|
int aik = a[i][k];
|
||||||
|
for (int j = 0; j < p; j++) {
|
||||||
|
c[i][j] += aik * b[k][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Like {@link #multiply} but throws {@link ArithmeticException} instead of silently wrapping around. */
|
||||||
|
public static int[][] multiplyExact(int[][] a, int[][] b) {
|
||||||
|
requireRectangular(a);
|
||||||
|
requireRectangular(b);
|
||||||
|
int m = a.length, n = a[0].length, p = b[0].length;
|
||||||
|
if (n != b.length) {
|
||||||
|
throw new IllegalArgumentException("cannot multiply " + shape(a) + " by " + shape(b));
|
||||||
|
}
|
||||||
|
int[][] c = new int[m][p];
|
||||||
|
for (int i = 0; i < m; i++) {
|
||||||
|
for (int j = 0; j < p; j++) {
|
||||||
|
int dot = 0;
|
||||||
|
for (int k = 0; k < n; k++) {
|
||||||
|
dot = Math.addExact(dot, Math.multiplyExact(a[i][k], b[k][j]));
|
||||||
|
}
|
||||||
|
c[i][j] = dot;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The n x n identity matrix: 1 on the main diagonal, 0 elsewhere. */
|
||||||
|
public static int[][] identity(int n) {
|
||||||
|
int[][] id = new int[n][n];
|
||||||
|
for (int i = 0; i < n; i++) {
|
||||||
|
id[i][i] = 1;
|
||||||
|
}
|
||||||
|
return id;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A deep copy. {@code a.clone()} alone is a shallow copy and shares every row with the original. */
|
||||||
|
public static int[][] copyOf(int[][] a) {
|
||||||
|
int[][] copy = new int[a.length][];
|
||||||
|
for (int i = 0; i < a.length; i++) {
|
||||||
|
copy[i] = a[i].clone();
|
||||||
|
}
|
||||||
|
return copy;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static String shape(int[][] m) {
|
||||||
|
return m.length + "x" + (m.length == 0 ? 0 : m[0].length);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Fixed-width rendering, one row per line, so printed matrices line up in columns. */
|
||||||
|
public static String format(int[][] m) {
|
||||||
|
int width = 1;
|
||||||
|
for (int[] row : m) {
|
||||||
|
for (int v : row) {
|
||||||
|
width = Math.max(width, String.valueOf(v).length());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
StringBuilder sb = new StringBuilder();
|
||||||
|
for (int i = 0; i < m.length; i++) {
|
||||||
|
StringBuilder line = new StringBuilder("[");
|
||||||
|
for (int j = 0; j < m[i].length; j++) {
|
||||||
|
line.append(j == 0 ? "" : " ").append(String.format("%" + width + "d", m[i][j]));
|
||||||
|
}
|
||||||
|
sb.append(line).append("]");
|
||||||
|
if (i < m.length - 1) {
|
||||||
|
sb.append('\n');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return sb.toString();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Value equality for two matrices. */
|
||||||
|
public static boolean same(int[][] a, int[][] b) {
|
||||||
|
return Arrays.deepEquals(a, b);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,77 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
/** Plausible-looking wrong versions, kept so the article can show each one failing. Never use these. */
|
||||||
|
public final class Pitfalls {
|
||||||
|
private Pitfalls() {}
|
||||||
|
|
||||||
|
/** WRONG: j starts at 0, so every pair is swapped twice and the matrix ends up unchanged. */
|
||||||
|
public static void transposeInPlaceJFromZero(int[][] a) {
|
||||||
|
int n = a.length;
|
||||||
|
for (int i = 0; i < n; i++) {
|
||||||
|
for (int j = 0; j < n; j++) {
|
||||||
|
int tmp = a[i][j];
|
||||||
|
a[i][j] = a[j][i];
|
||||||
|
a[j][i] = tmp;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** WRONG: result sized rows(A) x rows(A), which is only right when B is square-compatible. */
|
||||||
|
public static int[][] multiplyResultWrongShape(int[][] a, int[][] b) {
|
||||||
|
int[][] c = new int[a.length][a.length]; // should be new int[a.length][b[0].length]
|
||||||
|
for (int i = 0; i < a.length; i++) {
|
||||||
|
for (int j = 0; j < b[0].length; j++) {
|
||||||
|
for (int k = 0; k < b.length; k++) {
|
||||||
|
c[i][j] += a[i][k] * b[k][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** WRONG: the two "is there still a row / column left?" checks are missing. */
|
||||||
|
public static List<Integer> spiralNoBoundaryChecks(int[][] a) {
|
||||||
|
List<Integer> out = new ArrayList<>();
|
||||||
|
int top = 0, bottom = a.length - 1, left = 0, right = a[0].length - 1;
|
||||||
|
while (top <= bottom && left <= right) {
|
||||||
|
for (int j = left; j <= right; j++) out.add(a[top][j]);
|
||||||
|
top++;
|
||||||
|
for (int i = top; i <= bottom; i++) out.add(a[i][right]);
|
||||||
|
right--;
|
||||||
|
for (int j = right; j >= left; j--) out.add(a[bottom][j]);
|
||||||
|
bottom--;
|
||||||
|
for (int i = bottom; i >= top; i--) out.add(a[i][left]);
|
||||||
|
left++;
|
||||||
|
}
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** WRONG: i runs to {@code last} inclusive, so the corner cell is moved twice. */
|
||||||
|
public static void rotateLayersInclusiveBound(int[][] a) {
|
||||||
|
int n = a.length;
|
||||||
|
for (int layer = 0; layer < n / 2; layer++) {
|
||||||
|
int first = layer, last = n - 1 - layer;
|
||||||
|
for (int i = first; i <= last; i++) { // should be i < last
|
||||||
|
int offset = i - first;
|
||||||
|
int top = a[first][i];
|
||||||
|
a[first][i] = a[last - offset][first];
|
||||||
|
a[last - offset][first] = a[last][last - offset];
|
||||||
|
a[last][last - offset] = a[i][last];
|
||||||
|
a[i][last] = top;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** WRONG: {@code clone()} is shallow, so the "copy" shares every row array with the original. */
|
||||||
|
public static int[][] shallowCopy(int[][] a) {
|
||||||
|
return a.clone();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** WRONG for large values: plain int arithmetic wraps around silently. Same loop as the real multiply. */
|
||||||
|
public static int[][] multiplyWithSilentOverflow(int[][] a, int[][] b) {
|
||||||
|
return MatrixBasics.multiply(a, b);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,86 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Rotating a matrix by 90 degrees. Clockwise sends element (i, j) of an (m x n) matrix to
|
||||||
|
* (j, m - 1 - i) of the (n x m) result.
|
||||||
|
*/
|
||||||
|
public final class Rotation {
|
||||||
|
private Rotation() {}
|
||||||
|
|
||||||
|
/** Clockwise rotation into a new matrix. Works for rectangular input. O(m * n) time and space. */
|
||||||
|
public static int[][] rotateClockwise(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
int rows = a.length, cols = a[0].length;
|
||||||
|
int[][] r = new int[cols][rows];
|
||||||
|
for (int i = 0; i < rows; i++) {
|
||||||
|
for (int j = 0; j < cols; j++) {
|
||||||
|
r[j][rows - 1 - i] = a[i][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Counter-clockwise rotation into a new matrix: (i, j) goes to (n - 1 - j, i). */
|
||||||
|
public static int[][] rotateCounterClockwise(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
int rows = a.length, cols = a[0].length;
|
||||||
|
int[][] r = new int[cols][rows];
|
||||||
|
for (int i = 0; i < rows; i++) {
|
||||||
|
for (int j = 0; j < cols; j++) {
|
||||||
|
r[cols - 1 - j][i] = a[i][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Half-turn: (i, j) goes to (m - 1 - i, n - 1 - j). */
|
||||||
|
public static int[][] rotate180(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
int rows = a.length, cols = a[0].length;
|
||||||
|
int[][] r = new int[rows][cols];
|
||||||
|
for (int i = 0; i < rows; i++) {
|
||||||
|
for (int j = 0; j < cols; j++) {
|
||||||
|
r[rows - 1 - i][cols - 1 - j] = a[i][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* In-place clockwise rotation of a SQUARE matrix, O(1) extra space, in two easy steps:
|
||||||
|
* transpose, then reverse every row.
|
||||||
|
*/
|
||||||
|
public static void rotateClockwiseInPlace(int[][] a) {
|
||||||
|
Transpose.transposeInPlace(a);
|
||||||
|
for (int[] row : a) {
|
||||||
|
for (int left = 0, right = row.length - 1; left < right; left++, right--) {
|
||||||
|
int tmp = row[left];
|
||||||
|
row[left] = row[right];
|
||||||
|
row[right] = tmp;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* In-place clockwise rotation of a SQUARE matrix, layer by layer: each step moves four cells one
|
||||||
|
* quarter-turn around the ring. Same result as {@link #rotateClockwiseInPlace}, one pass.
|
||||||
|
*/
|
||||||
|
public static void rotateClockwiseLayers(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
if (a.length != a[0].length) {
|
||||||
|
throw new IllegalArgumentException("in-place rotation needs a square matrix but got " + MatrixBasics.shape(a));
|
||||||
|
}
|
||||||
|
int n = a.length;
|
||||||
|
for (int layer = 0; layer < n / 2; layer++) {
|
||||||
|
int first = layer, last = n - 1 - layer;
|
||||||
|
for (int i = first; i < last; i++) { // i < last: the corner at 'last' belongs to the next side
|
||||||
|
int offset = i - first;
|
||||||
|
int top = a[first][i];
|
||||||
|
a[first][i] = a[last - offset][first]; // left -> top
|
||||||
|
a[last - offset][first] = a[last][last - offset]; // bottom -> left
|
||||||
|
a[last][last - offset] = a[i][last]; // right -> bottom
|
||||||
|
a[i][last] = top; // top -> right
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,71 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
/** Spiral traversal: walk the outer ring clockwise, shrink the four boundaries, repeat. */
|
||||||
|
public final class Spiral {
|
||||||
|
private Spiral() {}
|
||||||
|
|
||||||
|
/** Elements in clockwise spiral order, starting at the top-left corner. O(m * n) time. */
|
||||||
|
public static List<Integer> spiralOrder(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
List<Integer> out = new ArrayList<>();
|
||||||
|
int top = 0, bottom = a.length - 1, left = 0, right = a[0].length - 1;
|
||||||
|
while (top <= bottom && left <= right) {
|
||||||
|
for (int j = left; j <= right; j++) { // left to right along the top row
|
||||||
|
out.add(a[top][j]);
|
||||||
|
}
|
||||||
|
top++;
|
||||||
|
for (int i = top; i <= bottom; i++) { // top to bottom down the right column
|
||||||
|
out.add(a[i][right]);
|
||||||
|
}
|
||||||
|
right--;
|
||||||
|
if (top <= bottom) { // a row may be left over ...
|
||||||
|
for (int j = right; j >= left; j--) { // right to left along the bottom row
|
||||||
|
out.add(a[bottom][j]);
|
||||||
|
}
|
||||||
|
bottom--;
|
||||||
|
}
|
||||||
|
if (left <= right) { // ... and so may a column
|
||||||
|
for (int i = bottom; i >= top; i--) { // bottom to top up the left column
|
||||||
|
out.add(a[i][left]);
|
||||||
|
}
|
||||||
|
left++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** The reverse problem: an n x n matrix filled with 1..n*n in clockwise spiral order. */
|
||||||
|
public static int[][] spiralMatrix(int n) {
|
||||||
|
if (n <= 0) {
|
||||||
|
throw new IllegalArgumentException("n must be positive but was " + n);
|
||||||
|
}
|
||||||
|
int[][] m = new int[n][n];
|
||||||
|
int top = 0, bottom = n - 1, left = 0, right = n - 1, next = 1;
|
||||||
|
while (top <= bottom && left <= right) {
|
||||||
|
for (int j = left; j <= right; j++) {
|
||||||
|
m[top][j] = next++;
|
||||||
|
}
|
||||||
|
top++;
|
||||||
|
for (int i = top; i <= bottom; i++) {
|
||||||
|
m[i][right] = next++;
|
||||||
|
}
|
||||||
|
right--;
|
||||||
|
if (top <= bottom) {
|
||||||
|
for (int j = right; j >= left; j--) {
|
||||||
|
m[bottom][j] = next++;
|
||||||
|
}
|
||||||
|
bottom--;
|
||||||
|
}
|
||||||
|
if (left <= right) {
|
||||||
|
for (int i = bottom; i >= top; i--) {
|
||||||
|
m[i][left] = next++;
|
||||||
|
}
|
||||||
|
left++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,54 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
/** Transpose: row i becomes column i, so element (i, j) moves to (j, i). */
|
||||||
|
public final class Transpose {
|
||||||
|
private Transpose() {}
|
||||||
|
|
||||||
|
/** Works for any rectangular matrix: an (m x n) input gives an (n x m) output. O(m * n) time and space. */
|
||||||
|
public static int[][] transpose(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
int rows = a.length, cols = a[0].length;
|
||||||
|
int[][] t = new int[cols][rows];
|
||||||
|
for (int i = 0; i < rows; i++) {
|
||||||
|
for (int j = 0; j < cols; j++) {
|
||||||
|
t[j][i] = a[i][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return t;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Transposes a SQUARE matrix inside the same array, O(1) extra space. Only the cells above the diagonal
|
||||||
|
* are visited (j starts at i + 1); each one is swapped with its mirror below the diagonal exactly once.
|
||||||
|
*/
|
||||||
|
public static void transposeInPlace(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
if (a.length != a[0].length) {
|
||||||
|
throw new IllegalArgumentException("in-place transpose needs a square matrix but got " + MatrixBasics.shape(a));
|
||||||
|
}
|
||||||
|
int n = a.length;
|
||||||
|
for (int i = 0; i < n; i++) {
|
||||||
|
for (int j = i + 1; j < n; j++) {
|
||||||
|
int tmp = a[i][j];
|
||||||
|
a[i][j] = a[j][i];
|
||||||
|
a[j][i] = tmp;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A matrix is symmetric when it equals its own transpose. */
|
||||||
|
public static boolean isSymmetric(int[][] a) {
|
||||||
|
MatrixBasics.requireRectangular(a);
|
||||||
|
if (a.length != a[0].length) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
for (int i = 0; i < a.length; i++) {
|
||||||
|
for (int j = i + 1; j < a.length; j++) {
|
||||||
|
if (a[i][j] != a[j][i]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,48 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
|
||||||
|
import com.ankurm.interviewlab.matrix.support.Transcript;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/** Operation counts, not timings. Writes output/08. */
|
||||||
|
class ComplexityTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void counts() {
|
||||||
|
assertEquals(12, Complexity.multiplications(2, 3, 2));
|
||||||
|
assertEquals(1_000, Complexity.multiplications(10, 10, 10));
|
||||||
|
assertEquals(1_000_000, Complexity.multiplications(100, 100, 100));
|
||||||
|
assertEquals(8_000_000, Complexity.multiplications(200, 200, 200));
|
||||||
|
assertEquals(3, Complexity.transposeSwaps(3));
|
||||||
|
assertEquals(4_950, Complexity.transposeSwaps(100));
|
||||||
|
assertEquals(2, Complexity.layerMoves(3));
|
||||||
|
assertEquals(4, Complexity.layerMoves(4));
|
||||||
|
assertEquals(2_500, Complexity.layerMoves(100));
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("08-operation-counts.txt", "Operation counts (counted, not timed)");
|
||||||
|
t.line("multiplications for an n x n product (i-j-k loop)");
|
||||||
|
for (int n : new int[] {10, 100, 200}) {
|
||||||
|
t.line(String.format(" n = %3d %,12d multiplications", n, Complexity.multiplications(n, n, n)));
|
||||||
|
}
|
||||||
|
t.line(" doubling n from 100 to 200 multiplies the work by "
|
||||||
|
+ (Complexity.multiplications(200, 200, 200) / Complexity.multiplications(100, 100, 100))).blank();
|
||||||
|
t.line("2x3 times 3x2: " + Complexity.multiplications(2, 3, 2) + " multiplications (m * n * p = 2 * 3 * 2)").blank();
|
||||||
|
t.line("in-place transpose swaps, n x n");
|
||||||
|
for (int n : new int[] {3, 100}) {
|
||||||
|
t.line(String.format(" n = %3d %,6d swaps (n * (n - 1) / 2 = %,d)", n, Complexity.transposeSwaps(n), n * (n - 1) / 2));
|
||||||
|
}
|
||||||
|
t.blank().line("layer rotation four-cell moves, n x n");
|
||||||
|
for (int n : new int[] {3, 4, 100}) {
|
||||||
|
t.line(String.format(" n = %3d %,6d moves (n * n / 4 rounded down = %,d)", n, Complexity.layerMoves(n), n * n / 4));
|
||||||
|
}
|
||||||
|
t.blank().line("spiral: cells visited vs rows * cols");
|
||||||
|
int[][] shapes = {{1, 1}, {1, 7}, {7, 1}, {3, 4}, {5, 5}, {40, 25}};
|
||||||
|
for (int[] s : shapes) {
|
||||||
|
long visits = Complexity.spiralVisits(s[0], s[1]);
|
||||||
|
assertEquals((long) s[0] * s[1], visits);
|
||||||
|
t.line(String.format(" %2d x %-2d visits = %,5d rows * cols = %,5d", s[0], s[1], visits, s[0] * s[1]));
|
||||||
|
}
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,55 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
|
||||||
|
import com.ankurm.interviewlab.matrix.support.Transcript;
|
||||||
|
import java.util.List;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/** Step-by-step traces of three of the algorithms. Writes output/02, 04 and 06. */
|
||||||
|
class DryRunTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void multiplyOneCell() {
|
||||||
|
int[][] a = {{1, 2, 3}, {4, 5, 6}};
|
||||||
|
int[][] b = {{7, 8}, {9, 10}, {11, 12}};
|
||||||
|
List<String> steps = DryRuns.multiplyCell(a, b, 0, 1);
|
||||||
|
assertEquals(4, steps.size());
|
||||||
|
assertEquals("C[0][1] = 64", steps.get(3));
|
||||||
|
assertEquals(MatrixBasics.multiply(a, b)[0][1], 64);
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("02-multiply-dry-run.txt", "Dry run: one cell of the product");
|
||||||
|
t.line("A (2x3)").line(MatrixBasics.format(a)).line("B (3x2)").line(MatrixBasics.format(b)).blank();
|
||||||
|
t.line("cell C[0][1] = row 0 of A dotted with column 1 of B");
|
||||||
|
steps.forEach(t::line);
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void spiralTrace() {
|
||||||
|
int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
|
||||||
|
List<String> steps = DryRuns.spiralTrace(a);
|
||||||
|
Transcript t = Transcript.start("04-spiral-trace.txt", "Dry run: spiral traversal of a 3x4 matrix");
|
||||||
|
t.line(MatrixBasics.format(a)).blank();
|
||||||
|
steps.forEach(t::line);
|
||||||
|
t.blank().line("spiralOrder = " + Spiral.spiralOrder(a));
|
||||||
|
t.flush();
|
||||||
|
assertEquals(2, steps.stream().filter(s -> s.startsWith("round")).count());
|
||||||
|
assertEquals(true, steps.contains(" bottom row skipped (top > bottom)"));
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void layerTrace() {
|
||||||
|
int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
|
||||||
|
int[][] expected = Rotation.rotateClockwise(a);
|
||||||
|
List<String> steps = DryRuns.layerTrace(a);
|
||||||
|
assertArrayEquals(expected, a);
|
||||||
|
assertEquals(2 * Complexity.layerMoves(3), steps.size());
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("06-layer-rotation-trace.txt", "Dry run: layer-by-layer rotation of a 3x3 matrix");
|
||||||
|
t.line(MatrixBasics.format(new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}})).blank();
|
||||||
|
steps.forEach(t::line);
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,79 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import com.ankurm.interviewlab.matrix.support.Transcript;
|
||||||
|
import java.util.List;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/** Six classic mistakes, each reproduced next to the correct answer. Writes output/09. */
|
||||||
|
class PitfallsTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void pitfalls() {
|
||||||
|
Transcript t = Transcript.start("09-pitfalls.txt", "Six classic mistakes, each reproduced");
|
||||||
|
|
||||||
|
int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
|
||||||
|
int[][] jZero = MatrixBasics.copyOf(a);
|
||||||
|
Pitfalls.transposeInPlaceJFromZero(jZero);
|
||||||
|
assertArrayEquals(a, jZero);
|
||||||
|
t.line("1. in-place transpose with the inner loop starting at j = 0 instead of j = i + 1");
|
||||||
|
t.line(" input").line(MatrixBasics.format(a).indent(3).stripTrailing());
|
||||||
|
t.line(" result (identical to the input, every pair was swapped twice)")
|
||||||
|
.line(MatrixBasics.format(jZero).indent(3).stripTrailing()).blank();
|
||||||
|
|
||||||
|
int[][] x = {{1, 2, 3}, {4, 5, 6}};
|
||||||
|
int[][] y = {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}};
|
||||||
|
ArrayIndexOutOfBoundsException shape = assertThrows(ArrayIndexOutOfBoundsException.class,
|
||||||
|
() -> Pitfalls.multiplyResultWrongShape(x, y));
|
||||||
|
assertEquals(MatrixBasics.shape(MatrixBasics.multiply(x, y)), "2x4");
|
||||||
|
t.line("2. product result allocated as rows(A) x rows(A) instead of rows(A) x cols(B)");
|
||||||
|
t.line(" 2x3 times 3x4, correct result shape " + MatrixBasics.shape(MatrixBasics.multiply(x, y)));
|
||||||
|
t.line(" wrong version -> ArrayIndexOutOfBoundsException: " + shape.getMessage()).blank();
|
||||||
|
|
||||||
|
int[][] row = {{1, 2, 3}};
|
||||||
|
List<Integer> noChecks = Pitfalls.spiralNoBoundaryChecks(row);
|
||||||
|
List<Integer> right = Spiral.spiralOrder(row);
|
||||||
|
assertEquals(List.of(1, 2, 3), right);
|
||||||
|
assertFalse(noChecks.equals(right));
|
||||||
|
assertTrue(noChecks.size() > 3);
|
||||||
|
t.line("3. spiral without the 'is there still a row / column left?' checks");
|
||||||
|
t.line(" input [[1, 2, 3]] (a single row)");
|
||||||
|
t.line(" wrong = " + noChecks);
|
||||||
|
t.line(" correct = " + right).blank();
|
||||||
|
|
||||||
|
int[][] inclusive = MatrixBasics.copyOf(a);
|
||||||
|
Pitfalls.rotateLayersInclusiveBound(inclusive);
|
||||||
|
int[][] expected = Rotation.rotateClockwise(a);
|
||||||
|
assertFalse(MatrixBasics.same(expected, inclusive));
|
||||||
|
t.line("4. layer rotation with i <= last instead of i < last (the corner is moved twice)");
|
||||||
|
t.line(" input").line(MatrixBasics.format(a).indent(3).stripTrailing());
|
||||||
|
t.line(" wrong").line(MatrixBasics.format(inclusive).indent(3).stripTrailing());
|
||||||
|
t.line(" correct").line(MatrixBasics.format(expected).indent(3).stripTrailing()).blank();
|
||||||
|
|
||||||
|
int[][] original = {{1, 2}, {3, 4}};
|
||||||
|
int[][] copy = Pitfalls.shallowCopy(original);
|
||||||
|
copy[0][0] = 99;
|
||||||
|
assertEquals(99, original[0][0]);
|
||||||
|
int[][] deep = MatrixBasics.copyOf(original);
|
||||||
|
deep[1][1] = -1;
|
||||||
|
assertEquals(4, original[1][1]);
|
||||||
|
t.line("5. 'copy' made with clone() is shallow");
|
||||||
|
t.line(" original = [[1, 2], [3, 4]]; copy = original.clone(); copy[0][0] = 99");
|
||||||
|
t.line(" original[0][0] is now " + original[0][0] + " (the rows are shared)");
|
||||||
|
t.line(" copyOf() makes new rows: changing deep[1][1] left original[1][1] at " + original[1][1]).blank();
|
||||||
|
|
||||||
|
int[][] big = {{50_000}};
|
||||||
|
int[][] wrapped = Pitfalls.multiplyWithSilentOverflow(big, big);
|
||||||
|
assertEquals(-1_794_967_296, wrapped[0][0]);
|
||||||
|
ArithmeticException overflow = assertThrows(ArithmeticException.class, () -> MatrixBasics.multiplyExact(big, big));
|
||||||
|
t.line("6. int overflow in the dot product");
|
||||||
|
t.line(" [[50000]] * [[50000]] with plain multiply = " + wrapped[0][0] + " (true value 2500000000)");
|
||||||
|
t.line(" multiplyExact -> ArithmeticException: " + overflow.getMessage());
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,91 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
|
||||||
|
import com.ankurm.interviewlab.matrix.support.Transcript;
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.Collections;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Random;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/** Algebraic laws checked on seeded random matrices. Writes output/07. */
|
||||||
|
class RandomAgreementTest {
|
||||||
|
private static final int TRIALS = 2_000;
|
||||||
|
|
||||||
|
private static int[][] random(Random r, int rows, int cols) {
|
||||||
|
int[][] m = new int[rows][cols];
|
||||||
|
for (int i = 0; i < rows; i++) {
|
||||||
|
for (int j = 0; j < cols; j++) {
|
||||||
|
m[i][j] = r.nextInt(21) - 10;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void lawsHold() {
|
||||||
|
Random r = new Random(2026);
|
||||||
|
int rotationAgree = 0, fourTurns = 0, transposeTwice = 0, productTranspose = 0, identity = 0,
|
||||||
|
loopOrders = 0, distributive = 0, spiralPermutation = 0, cwThenCcw = 0;
|
||||||
|
for (int t = 0; t < TRIALS; t++) {
|
||||||
|
int n = 1 + r.nextInt(8);
|
||||||
|
int[][] sq = random(r, n, n);
|
||||||
|
int[][] cw = Rotation.rotateClockwise(sq);
|
||||||
|
int[][] viaT = MatrixBasics.copyOf(sq);
|
||||||
|
Rotation.rotateClockwiseInPlace(viaT);
|
||||||
|
int[][] viaL = MatrixBasics.copyOf(sq);
|
||||||
|
Rotation.rotateClockwiseLayers(viaL);
|
||||||
|
assertArrayEquals(cw, viaT);
|
||||||
|
assertArrayEquals(cw, viaL);
|
||||||
|
rotationAgree++;
|
||||||
|
|
||||||
|
assertArrayEquals(sq, Rotation.rotateClockwise(Rotation.rotateClockwise(Rotation.rotateClockwise(cw))));
|
||||||
|
fourTurns++;
|
||||||
|
assertArrayEquals(sq, Rotation.rotateCounterClockwise(cw));
|
||||||
|
cwThenCcw++;
|
||||||
|
|
||||||
|
int rows = 1 + r.nextInt(7), cols = 1 + r.nextInt(7), p = 1 + r.nextInt(7);
|
||||||
|
int[][] a = random(r, rows, cols);
|
||||||
|
int[][] b = random(r, cols, p);
|
||||||
|
int[][] c = random(r, cols, p);
|
||||||
|
assertArrayEquals(a, Transpose.transpose(Transpose.transpose(a)));
|
||||||
|
transposeTwice++;
|
||||||
|
assertArrayEquals(Transpose.transpose(MatrixBasics.multiply(a, b)),
|
||||||
|
MatrixBasics.multiply(Transpose.transpose(b), Transpose.transpose(a)));
|
||||||
|
productTranspose++;
|
||||||
|
assertArrayEquals(a, MatrixBasics.multiply(a, MatrixBasics.identity(cols)));
|
||||||
|
assertArrayEquals(a, MatrixBasics.multiply(MatrixBasics.identity(rows), a));
|
||||||
|
identity++;
|
||||||
|
assertArrayEquals(MatrixBasics.multiply(a, b), MatrixBasics.multiplyIkj(a, b));
|
||||||
|
loopOrders++;
|
||||||
|
assertArrayEquals(MatrixBasics.multiply(a, MatrixBasics.add(b, c)),
|
||||||
|
MatrixBasics.add(MatrixBasics.multiply(a, b), MatrixBasics.multiply(a, c)));
|
||||||
|
distributive++;
|
||||||
|
|
||||||
|
List<Integer> flat = new ArrayList<>();
|
||||||
|
for (int[] row : a) {
|
||||||
|
for (int v : row) flat.add(v);
|
||||||
|
}
|
||||||
|
List<Integer> spiral = new ArrayList<>(Spiral.spiralOrder(a));
|
||||||
|
assertEquals(rows * cols, spiral.size());
|
||||||
|
Collections.sort(flat);
|
||||||
|
Collections.sort(spiral);
|
||||||
|
assertEquals(flat, spiral);
|
||||||
|
spiralPermutation++;
|
||||||
|
}
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("07-random-agreement.txt", "Seeded random checks (seed 2026, " + TRIALS + " trials each)");
|
||||||
|
t.line("rotateClockwise == transpose-then-reverse == layer swaps (n x n, n = 1..8): " + rotationAgree + " agree, 0 disagree");
|
||||||
|
t.line("four clockwise turns return the original: " + fourTurns + " agree, 0 disagree");
|
||||||
|
t.line("clockwise then counter-clockwise returns the original: " + cwThenCcw + " agree, 0 disagree");
|
||||||
|
t.line("transpose twice returns the original (random m x n): " + transposeTwice + " agree, 0 disagree");
|
||||||
|
t.line("(A * B) transposed == B transposed * A transposed: " + productTranspose + " agree, 0 disagree");
|
||||||
|
t.line("A * I == A and I * A == A: " + identity + " agree, 0 disagree");
|
||||||
|
t.line("i-j-k product == i-k-j product: " + loopOrders + " agree, 0 disagree");
|
||||||
|
t.line("A * (B + C) == A * B + A * C: " + distributive + " agree, 0 disagree");
|
||||||
|
t.line("spiral order is a permutation of all m * n elements: " + spiralPermutation + " agree, 0 disagree");
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,130 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix;
|
||||||
|
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||||
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import com.ankurm.interviewlab.matrix.support.Transcript;
|
||||||
|
import java.util.List;
|
||||||
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
|
/** The five programs on small, hand-checkable inputs. Writes output/01, 03, 05 and 10. */
|
||||||
|
class SolutionsTest {
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void additionAndMultiplication() {
|
||||||
|
int[][] a = {{1, 2, 3}, {4, 5, 6}};
|
||||||
|
int[][] b = {{6, 5, 4}, {3, 2, 1}};
|
||||||
|
int[][] sum = MatrixBasics.add(a, b);
|
||||||
|
assertArrayEquals(new int[][] {{7, 7, 7}, {7, 7, 7}}, sum);
|
||||||
|
|
||||||
|
int[][] x = {{1, 2, 3}, {4, 5, 6}};
|
||||||
|
int[][] y = {{7, 8}, {9, 10}, {11, 12}};
|
||||||
|
int[][] product = MatrixBasics.multiply(x, y);
|
||||||
|
assertArrayEquals(new int[][] {{58, 64}, {139, 154}}, product);
|
||||||
|
assertArrayEquals(product, MatrixBasics.multiplyIkj(x, y));
|
||||||
|
assertArrayEquals(x, MatrixBasics.multiply(x, MatrixBasics.identity(3)));
|
||||||
|
|
||||||
|
IllegalArgumentException addErr = assertThrows(IllegalArgumentException.class, () -> MatrixBasics.add(x, y));
|
||||||
|
IllegalArgumentException mulErr = assertThrows(IllegalArgumentException.class, () -> MatrixBasics.multiply(x, x));
|
||||||
|
IllegalArgumentException jagged = assertThrows(IllegalArgumentException.class,
|
||||||
|
() -> MatrixBasics.add(new int[][] {{1, 2}, {3}}, new int[][] {{1, 2}, {3, 4}}));
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("01-addition-and-multiplication.txt", "Addition and multiplication");
|
||||||
|
t.line("A + B (both 2x3)").line(MatrixBasics.format(a)).line("+").line(MatrixBasics.format(b)).line("=")
|
||||||
|
.line(MatrixBasics.format(sum)).blank();
|
||||||
|
t.line("X * Y (2x3 times 3x2 gives 2x2)").line(MatrixBasics.format(x)).line("*").line(MatrixBasics.format(y))
|
||||||
|
.line("=").line(MatrixBasics.format(product)).blank();
|
||||||
|
t.line("multiply (i-j-k) and multiplyIkj agree: " + MatrixBasics.same(product, MatrixBasics.multiplyIkj(x, y)));
|
||||||
|
t.line("X * I (3x3 identity) equals X: " + MatrixBasics.same(x, MatrixBasics.multiply(x, MatrixBasics.identity(3)))).blank();
|
||||||
|
t.line("add 2x3 + 3x2 -> IllegalArgumentException: " + addErr.getMessage());
|
||||||
|
t.line("multiply 2x3 * 2x3 -> IllegalArgumentException: " + mulErr.getMessage());
|
||||||
|
t.line("add with a jagged row -> IllegalArgumentException: " + jagged.getMessage());
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void transpose() {
|
||||||
|
int[][] rect = {{1, 2, 3}, {4, 5, 6}};
|
||||||
|
int[][] tr = Transpose.transpose(rect);
|
||||||
|
assertArrayEquals(new int[][] {{1, 4}, {2, 5}, {3, 6}}, tr);
|
||||||
|
|
||||||
|
int[][] sq = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
|
||||||
|
Transpose.transposeInPlace(sq);
|
||||||
|
assertArrayEquals(new int[][] {{1, 4, 7}, {2, 5, 8}, {3, 6, 9}}, sq);
|
||||||
|
|
||||||
|
assertTrue(Transpose.isSymmetric(new int[][] {{1, 7, 3}, {7, 4, -5}, {3, -5, 6}}));
|
||||||
|
assertFalse(Transpose.isSymmetric(new int[][] {{1, 2}, {3, 4}}));
|
||||||
|
IllegalArgumentException err = assertThrows(IllegalArgumentException.class, () -> Transpose.transposeInPlace(rect));
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("03-transpose.txt", "Transpose");
|
||||||
|
t.line("2x3 matrix").line(MatrixBasics.format(rect)).line("transpose() gives a 3x2 matrix")
|
||||||
|
.line(MatrixBasics.format(tr)).blank();
|
||||||
|
t.line("3x3 matrix, transposeInPlace()").line(MatrixBasics.format(new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}))
|
||||||
|
.line("becomes").line(MatrixBasics.format(sq)).blank();
|
||||||
|
t.line("isSymmetric([[1,7,3],[7,4,-5],[3,-5,6]]) = true");
|
||||||
|
t.line("isSymmetric([[1,2],[3,4]]) = false").blank();
|
||||||
|
t.line("transposeInPlace on a 2x3 matrix -> IllegalArgumentException: " + err.getMessage());
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void spiral() {
|
||||||
|
int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
|
||||||
|
List<Integer> order = Spiral.spiralOrder(a);
|
||||||
|
assertEquals(List.of(1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7), order);
|
||||||
|
assertEquals(List.of(1, 2, 3), Spiral.spiralOrder(new int[][] {{1, 2, 3}}));
|
||||||
|
assertEquals(List.of(1, 2, 3), Spiral.spiralOrder(new int[][] {{1}, {2}, {3}}));
|
||||||
|
assertEquals(List.of(5), Spiral.spiralOrder(new int[][] {{5}}));
|
||||||
|
|
||||||
|
int[][] filled = Spiral.spiralMatrix(4);
|
||||||
|
assertArrayEquals(new int[][] {{1, 2, 3, 4}, {12, 13, 14, 5}, {11, 16, 15, 6}, {10, 9, 8, 7}}, filled);
|
||||||
|
assertEquals(List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), Spiral.spiralOrder(filled));
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("04a-spiral-results.txt", "Spiral traversal results");
|
||||||
|
t.line("3x4 matrix").line(MatrixBasics.format(a)).line("spiralOrder = " + order).blank();
|
||||||
|
t.line("single row [[1,2,3]] -> " + Spiral.spiralOrder(new int[][] {{1, 2, 3}}));
|
||||||
|
t.line("single column [[1],[2],[3]] -> " + Spiral.spiralOrder(new int[][] {{1}, {2}, {3}}));
|
||||||
|
t.line("single cell [[5]] -> " + Spiral.spiralOrder(new int[][] {{5}})).blank();
|
||||||
|
t.line("spiralMatrix(4), the reverse problem").line(MatrixBasics.format(filled));
|
||||||
|
t.line("spiralOrder(spiralMatrix(4)) = " + Spiral.spiralOrder(filled));
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
void rotation() {
|
||||||
|
int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
|
||||||
|
int[][] cw = Rotation.rotateClockwise(a);
|
||||||
|
int[][] ccw = Rotation.rotateCounterClockwise(a);
|
||||||
|
int[][] half = Rotation.rotate180(a);
|
||||||
|
assertArrayEquals(new int[][] {{7, 4, 1}, {8, 5, 2}, {9, 6, 3}}, cw);
|
||||||
|
assertArrayEquals(new int[][] {{3, 6, 9}, {2, 5, 8}, {1, 4, 7}}, ccw);
|
||||||
|
assertArrayEquals(new int[][] {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}}, half);
|
||||||
|
|
||||||
|
int[][] viaTranspose = MatrixBasics.copyOf(a);
|
||||||
|
Rotation.rotateClockwiseInPlace(viaTranspose);
|
||||||
|
int[][] viaLayers = MatrixBasics.copyOf(a);
|
||||||
|
Rotation.rotateClockwiseLayers(viaLayers);
|
||||||
|
assertArrayEquals(cw, viaTranspose);
|
||||||
|
assertArrayEquals(cw, viaLayers);
|
||||||
|
|
||||||
|
int[][] rect = {{1, 2, 3}, {4, 5, 6}};
|
||||||
|
int[][] rectCw = Rotation.rotateClockwise(rect);
|
||||||
|
assertArrayEquals(new int[][] {{4, 1}, {5, 2}, {6, 3}}, rectCw);
|
||||||
|
|
||||||
|
Transcript t = Transcript.start("05-rotation.txt", "Rotation");
|
||||||
|
t.line("original 3x3").line(MatrixBasics.format(a)).blank();
|
||||||
|
t.line("rotateClockwise").line(MatrixBasics.format(cw)).blank();
|
||||||
|
t.line("rotateCounterClockwise").line(MatrixBasics.format(ccw)).blank();
|
||||||
|
t.line("rotate180").line(MatrixBasics.format(half)).blank();
|
||||||
|
t.line("rotateClockwiseInPlace (transpose, then reverse each row)").line(MatrixBasics.format(viaTranspose)).blank();
|
||||||
|
t.line("rotateClockwiseLayers (four-cell moves)").line(MatrixBasics.format(viaLayers)).blank();
|
||||||
|
t.line("both in-place versions equal rotateClockwise: "
|
||||||
|
+ (MatrixBasics.same(cw, viaTranspose) && MatrixBasics.same(cw, viaLayers))).blank();
|
||||||
|
t.line("rectangular 2x3 rotated clockwise becomes 3x2 (in-place is impossible: the shape changes)")
|
||||||
|
.line(MatrixBasics.format(rect)).line("->").line(MatrixBasics.format(rectCw));
|
||||||
|
t.flush();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,43 @@
|
|||||||
|
package com.ankurm.interviewlab.matrix.support;
|
||||||
|
|
||||||
|
import java.io.IOException;
|
||||||
|
import java.io.UncheckedIOException;
|
||||||
|
import java.nio.charset.StandardCharsets;
|
||||||
|
import java.nio.file.Files;
|
||||||
|
import java.nio.file.Path;
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
/** Writes output/NN-*.txt while the calling test asserts the same numbers it prints. */
|
||||||
|
public final class Transcript {
|
||||||
|
private final Path path;
|
||||||
|
private final List<String> lines = new ArrayList<>();
|
||||||
|
|
||||||
|
private Transcript(Path path, String header) {
|
||||||
|
this.path = path;
|
||||||
|
lines.add(header);
|
||||||
|
lines.add("=".repeat(Math.min(header.length(), 100)));
|
||||||
|
lines.add("");
|
||||||
|
}
|
||||||
|
|
||||||
|
public static Transcript start(String fileName, String header) {
|
||||||
|
Path dir = Path.of("output");
|
||||||
|
try {
|
||||||
|
Files.createDirectories(dir);
|
||||||
|
} catch (IOException e) {
|
||||||
|
throw new UncheckedIOException(e);
|
||||||
|
}
|
||||||
|
return new Transcript(dir.resolve(fileName), header);
|
||||||
|
}
|
||||||
|
|
||||||
|
public Transcript line(String text) { lines.add(text); return this; }
|
||||||
|
public Transcript blank() { lines.add(""); return this; }
|
||||||
|
|
||||||
|
public void flush() {
|
||||||
|
try {
|
||||||
|
Files.write(path, (String.join("\n", lines) + "\n").getBytes(StandardCharsets.UTF_8));
|
||||||
|
} catch (IOException e) {
|
||||||
|
throw new UncheckedIOException(e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user