diff --git a/README.md b/README.md
index 87f68ea..b128eed 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,7 @@ One module per article. This repository currently holds:
| [`elevator`](elevator/) | Low-Level Design: Elevator System in Java (State Pattern and Scheduling) | this commit |
| [`experienced-2-3y`](experienced-2-3y/) | Java Interview Questions for 2 to 3 Years Experience (Scenario-Based, with Answers) | this commit |
| [`food-delivery`](food-delivery/) | Low-Level Design: Food Delivery App (Zomato/Swiggy-Style) in Java | this commit |
+| [`binary-search`](binary-search/) | Binary Search in Java: Iterative, Recursive, Lower/Upper Bound and 10 Interview Problems | this commit |
## `collections` module
diff --git a/binary-search/README.md b/binary-search/README.md
new file mode 100644
index 0000000..a6021ba
--- /dev/null
+++ b/binary-search/README.md
@@ -0,0 +1,67 @@
+# binary-search
+
+Companion code for the ankurm.com article **Binary Search in Java: Iterative, Recursive, Lower/Upper Bound and 10 Interview Problems**
+(a full rewrite of the 2015 post "Implementing Binary Search in Java", same URL).
+
+Iterative and recursive search, the overflow-safe midpoint, `lowerBound`/`upperBound`, rotated arrays, "search on the answer" and ten
+interview problems, each cross-checked against an obviously-correct brute-force version on seeded random inputs. 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.1+2 (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 binary-search
+export JAVA_HOME=/path/to/jdk-25 PATH="$JAVA_HOME/bin:$PATH"
+./scripts/run-all.sh # runs 14 tests and regenerates output/*.txt
+java src/main/java/com/ankurm/interviewlab/binarysearch/InteractiveDemo.java # the original console program
+```
+
+The first Maven run must be online so the plugins land in the local cache.
+
+## Source layout
+
+```
+binary-search/
+├── pom.xml
+├── scripts/run-all.sh
+├── src/main/java/com/ankurm/interviewlab/binarysearch/
+│ ├── BinarySearch.java iterative, recursive, lowerBound, upperBound, first/last/count
+│ ├── Overflow.java the (lo + hi) / 2 bug at 2,000,000,000 elements, and two fixes
+│ ├── RotatedArray.java search, minimum, and the minimum with duplicates
+│ ├── SearchOnAnswer.java firstTrue template, integer sqrt, Koko bananas, ship packages
+│ ├── InterviewProblems.java range, peak element, 2D matrix; index of all ten problems
+│ ├── BruteForce.java slow, obviously-correct references (no shared helpers)
+│ ├── DryRuns.java instrumented copies that record every step
+│ ├── Pitfalls.java two plausible-looking wrong versions
+│ └── InteractiveDemo.java the original 2015 console program
+├── src/test/java/.../ one test class per output file group
+└── output/*.txt captured real output
+```
+
+## Captured output (`output/`)
+
+| File | What it shows |
+|---|---|
+| `01-dry-run-iterative.txt` | the three searches from the original article, step by step |
+| `02-recursive-vs-iterative.txt` | identical answers on 2,003 keys; recursion depth 5 / 11 / 21 |
+| `03-overflow-mid.txt` | `(lo + hi) / 2` wrapping negative and throwing at n = 2,000,000,000 |
+| `04-lower-upper-bound.txt` | bounds, first/last/count and `Arrays.binarySearch` on duplicates |
+| `05-rotated-array.txt` | rotated search and minimum traces; the duplicates degradation |
+| `06-search-on-answer.txt` | how many yes/no questions sqrt, Koko and ship packages ask |
+| `07-ten-problems.txt` | one example per problem beside the brute-force answer |
+| `08-random-agreement.txt` | 34,000 seeded comparisons, 0 disagreements |
+| `09-operation-counts.txt` | elements looked at: linear vs binary, n = 10 to 1,000,000,000 |
+| `10-pitfalls.txt` | the classic mistakes, each reproduced |
+| `11-interactive-session.txt` | the original program, same sample session as the 2015 post |
+| `12-jdk-source.txt` | the JDK's own midpoint line, read from `lib/src.zip` |
+| `13-sixteen-elements.txt` | 26 among 16 values: four probes, against 13 for a linear scan |
+| `14-no-bound-methods.txt` | reflection check: no lowerBound/upperBound in Arrays, Collections or List |
diff --git a/binary-search/output/01-dry-run-iterative.txt b/binary-search/output/01-dry-run-iterative.txt
new file mode 100644
index 0000000..0065214
--- /dev/null
+++ b/binary-search/output/01-dry-run-iterative.txt
@@ -0,0 +1,20 @@
+Iterative binary search, traced step by step on [10, 20, 30, 40, 45]
+====================================================================
+
+search for 40
+ low=0 high=4 mid=2 a[mid]=30 -> 40 > 30, low=3
+ low=3 high=4 mid=3 a[mid]=40 -> equals 40, return 3
+ result: 3 (position 4 counting from 1), 2 elements compared
+
+search for 10
+ low=0 high=4 mid=2 a[mid]=30 -> 10 < 30, high=1
+ low=0 high=1 mid=0 a[mid]=10 -> equals 10, return 0
+ result: 0 (position 1 counting from 1), 2 elements compared
+
+search for 25
+ low=0 high=4 mid=2 a[mid]=30 -> 25 < 30, high=1
+ low=0 high=1 mid=0 a[mid]=10 -> 25 > 10, low=1
+ low=1 high=1 mid=1 a[mid]=20 -> 25 > 20, low=2
+ low=2 high=1 -> low > high, return -1
+ result: -1, 3 elements compared
+
diff --git a/binary-search/output/02-recursive-vs-iterative.txt b/binary-search/output/02-recursive-vs-iterative.txt
new file mode 100644
index 0000000..d61a85e
--- /dev/null
+++ b/binary-search/output/02-recursive-vs-iterative.txt
@@ -0,0 +1,9 @@
+Recursive vs iterative: same answers, and how deep the recursion goes
+=====================================================================
+
+n=1000, elements 0,2,4,...,1998: 2003 keys from -1 to 2001 (present and absent)
+give identical answers from the iterative and the recursive version.
+
+n= 10 absent key above the last element: result=-1, recursion frames=5 (iterative uses 0 extra frames)
+n= 1,000 absent key above the last element: result=-1, recursion frames=11 (iterative uses 0 extra frames)
+n=1,000,000 absent key above the last element: result=-1, recursion frames=21 (iterative uses 0 extra frames)
diff --git a/binary-search/output/03-overflow-mid.txt b/binary-search/output/03-overflow-mid.txt
new file mode 100644
index 0000000..73ca087
--- /dev/null
+++ b/binary-search/output/03-overflow-mid.txt
@@ -0,0 +1,21 @@
+The (lo + hi) / 2 bug on a sorted sequence of 2,000,000,000 elements (no array: see Overflow.Sequence)
+====================================================================================================
+
+Plain int arithmetic, lo=1000000000 hi=1999999999:
+ lo + hi = -1294967297
+ (lo + hi) / 2 = -647483648
+ lo + (hi - lo) / 2 = 1499999999
+ (lo + hi) >>> 1 = 1499999999
+
+Broken (lo + hi) / 2, searching for the last element, 1999999999:
+ lo=0 hi=1999999999 lo+hi=1999999999 mid=999999999
+ lo=1000000000 hi=1999999999 lo+hi=-1294967297 mid=-647483648
+ -> java.lang.ArrayIndexOutOfBoundsException: Index -647483648 out of bounds for length 2000000000
+
+Fixed with lo + (hi - lo) / 2: found index 1999999999 after 31 steps. First and last steps:
+ lo=0 hi=1999999999 hi-lo=1999999999 mid=999999999
+ lo=1000000000 hi=1999999999 hi-lo=999999999 mid=1499999999
+ ...
+ lo=1999999999 hi=1999999999 hi-lo=0 mid=1999999999
+
+Fixed with (lo + hi) >>> 1: found index 1999999999
diff --git a/binary-search/output/04-lower-upper-bound.txt b/binary-search/output/04-lower-upper-bound.txt
new file mode 100644
index 0000000..e8936e1
--- /dev/null
+++ b/binary-search/output/04-lower-upper-bound.txt
@@ -0,0 +1,27 @@
+lowerBound / upperBound on [1, 2, 2, 2, 2, 2, 3, 5, 5, 8] (indexes 0..9)
+========================================================================
+
+key | lowerBound | upperBound | first | last | count | iterative | Arrays.binarySearch
+ 0 | 0 | 0 | -1 | -1 | 0 | -1 | -1
+ 1 | 0 | 1 | 0 | 0 | 1 | 0 | 0
+ 2 | 1 | 6 | 1 | 5 | 5 | 4 | 4
+ 3 | 6 | 7 | 6 | 6 | 1 | 6 | 6
+ 4 | 7 | 7 | -1 | -1 | 0 | -1 | -8
+ 5 | 7 | 9 | 7 | 8 | 2 | 7 | 7
+ 8 | 9 | 10 | 9 | 9 | 1 | 9 | 9
+ 9 | 10 | 10 | -1 | -1 | 0 | -1 | -11
+
+lowerBound for 2:
+ low=0 high=10 mid=5 a[mid]=2 -> 2 >= 2, mid might be the answer, high=5
+ low=0 high=5 mid=2 a[mid]=2 -> 2 >= 2, mid might be the answer, high=2
+ low=0 high=2 mid=1 a[mid]=2 -> 2 >= 2, mid might be the answer, high=1
+ low=0 high=1 mid=0 a[mid]=1 -> 1 < 2, everything up to mid is too small, low=1
+ low=1 high=1 -> range is empty, answer 1
+
+lowerBound for 4:
+ low=0 high=10 mid=5 a[mid]=2 -> 2 < 4, everything up to mid is too small, low=6
+ low=6 high=10 mid=8 a[mid]=5 -> 5 >= 4, mid might be the answer, high=8
+ low=6 high=8 mid=7 a[mid]=5 -> 5 >= 4, mid might be the answer, high=7
+ low=6 high=7 mid=6 a[mid]=3 -> 3 < 4, everything up to mid is too small, low=7
+ low=7 high=7 -> range is empty, answer 7
+
diff --git a/binary-search/output/05-rotated-array.txt b/binary-search/output/05-rotated-array.txt
new file mode 100644
index 0000000..81c41c9
--- /dev/null
+++ b/binary-search/output/05-rotated-array.txt
@@ -0,0 +1,26 @@
+Rotated sorted array [4, 5, 6, 7, 0, 1, 2]
+==========================================
+
+search for 0
+ low=0 high=6 mid=3 a[mid]=7 | left half 4..7 is sorted and does not hold 0 -> low=4
+ low=4 high=6 mid=5 a[mid]=1 | left half 0..1 is sorted and holds 0 -> high=4
+ low=4 high=4 mid=4 a[mid]=0 -> found at 4
+
+search for 3
+ low=0 high=6 mid=3 a[mid]=7 | left half 4..7 is sorted and does not hold 3 -> low=4
+ low=4 high=6 mid=5 a[mid]=1 | left half 0..1 is sorted and does not hold 3 -> low=6
+ low=6 high=6 mid=6 a[mid]=2 | left half 2..2 is sorted and does not hold 3 -> low=7
+ low=7 high=6 -> low > high, return -1
+
+find the minimum (the rotation point)
+ low=0 high=6 mid=3 a[mid]=7 a[high]=2 -> 7 > 2, the drop is right of mid, low=4
+ low=4 high=6 mid=5 a[mid]=1 a[high]=2 -> 1 <= 2, the drop is at mid or left of it, high=5
+ low=4 high=5 mid=4 a[mid]=0 a[high]=1 -> 0 <= 1, the drop is at mid or left of it, high=4
+ low=4 high=4 -> minimum 0 at index 4
+
+exhaustive check, every rotation of every distinct array of length 1..12, every key: 2184 searches, 0 disagreements
+
+With duplicates the same idea can degrade to a linear scan (iterations of the find-minimum loop):
+ n= 16 minimum at index 1: distinct values 4 iterations many duplicates 14 iterations
+ n= 256 minimum at index 1: distinct values 8 iterations many duplicates 254 iterations
+ n= 4096 minimum at index 1: distinct values 12 iterations many duplicates 4094 iterations
diff --git a/binary-search/output/06-search-on-answer.txt b/binary-search/output/06-search-on-answer.txt
new file mode 100644
index 0000000..093dd7c
--- /dev/null
+++ b/binary-search/output/06-search-on-answer.txt
@@ -0,0 +1,20 @@
+Binary search on the answer: how many times the yes/no question was asked
+=========================================================================
+
+Integer square root = largest m with m*m <= x; the question is "is m*m > x?"
+ sqrt(8) = 2 asked 3 times, instead of trying up to 9 candidates
+ sqrt(16) = 4 asked 4 times, instead of trying up to 17 candidates
+ sqrt(1,000,000,007) = 31622 asked 30 times, instead of trying up to 1,000,000,008 candidates
+ sqrt(2,147,483,647) = 46340 asked 31 times, instead of trying up to 2,147,483,648 candidates
+
+Koko eating bananas: smallest speed k with sum(ceil(pile / k)) <= h
+ piles=[3, 6, 7, 11] h=8 -> speed 4 asked 4 times (candidates 1..11)
+ piles=[30, 11, 23, 4, 20] h=5 -> speed 30 asked 4 times (candidates 1..30)
+ piles=[30, 11, 23, 4, 20] h=6 -> speed 23 asked 5 times (candidates 1..30)
+ for [3, 6, 7, 11], hours needed at speed 1..11: 27, 15, 10, 8, 8, 6, 5, 5, 5, 5, 4
+ is that <= 8? F F F T T T T T T T T
+ piles=[1000000000, 999999999, 500000000] h=10 -> speed 250,000,000 asked 29 times (candidates 1..1,000,000,000); checked: speed-1 needs 13 hours
+
+Ship packages within D days: smallest capacity so that, loading in order, D days are enough
+ weights=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] days=5 -> capacity 15 asked 5 times (candidates 10..55)
+ days needed at capacity 15: 5; at capacity 14: 6
diff --git a/binary-search/output/07-ten-problems.txt b/binary-search/output/07-ten-problems.txt
new file mode 100644
index 0000000..e0e33d6
--- /dev/null
+++ b/binary-search/output/07-ten-problems.txt
@@ -0,0 +1,20 @@
+Ten interview problems: fast answer beside the brute-force answer
+=================================================================
+
+ 1. search insert position [1, 3, 5, 6] key=5 fast=2 brute-force=2
+ 1. search insert position [1, 3, 5, 6] key=2 fast=1 brute-force=1
+ 1. search insert position [1, 3, 5, 6] key=7 fast=4 brute-force=4
+ 1. search insert position [1, 3, 5, 6] key=0 fast=0 brute-force=0
+ 2. first and last position [5, 7, 7, 8, 8, 10] key=8 fast=[3, 4] brute-force=[3, 4]
+ 2. first and last position [5, 7, 7, 8, 8, 10] key=6 fast=[-1, -1] brute-force=[-1, -1]
+ 3. count occurrences [1, 2, 2, 2, 2, 2, 3] key=2 fast=5 brute-force=5
+ 4. search in rotated array [4, 5, 6, 7, 0, 1, 2] key=0 fast=4 brute-force=4
+ 4. search in rotated array [4, 5, 6, 7, 0, 1, 2] key=3 fast=-1 brute-force=-1
+ 5. minimum of rotated array [3, 4, 5, 1, 2] (index of min) fast=3 brute-force=3
+ 6. find a peak element [1, 2, 1, 3, 5, 6, 4] (any peak is valid) fast=5 brute-force=peaks at 1 and 5, 5 is a peak: true
+ 7. integer square root x=4 fast=2 brute-force=2
+ 7. integer square root x=8 fast=2 brute-force=2
+ 8. koko eating bananas [3, 6, 7, 11] h=8 fast=4 brute-force=4
+ 9. ship packages within D days weights 1..10 days=5 fast=15 brute-force=15
+10. search a 2D matrix 3x4 matrix target=3 fast=true brute-force=true
+10. search a 2D matrix 3x4 matrix target=13 fast=false brute-force=false
diff --git a/binary-search/output/08-random-agreement.txt b/binary-search/output/08-random-agreement.txt
new file mode 100644
index 0000000..3d9b09d
--- /dev/null
+++ b/binary-search/output/08-random-agreement.txt
@@ -0,0 +1,13 @@
+Seeded random cross-check (Random(2026)): fast solution vs brute force
+======================================================================
+
+plain search + insert position (1) 3,000 cases 0 disagreements
+first and last position (2) 3,000 cases 0 disagreements
+count occurrences (3) 3,000 cases 0 disagreements
+search in rotated array (4) 3,000 cases 0 disagreements
+minimum of rotated array, distinct + duplicates (5) 6,000 cases 0 disagreements
+find a peak element (6) 3,000 cases 0 disagreements
+integer square root, small + near Integer.MAX_VALUE (7) 4,000 cases 0 disagreements
+koko eating bananas (8) 3,000 cases 0 disagreements
+ship packages within D days (9) 3,000 cases 0 disagreements
+search a 2D matrix (10) 3,000 cases 0 disagreements
diff --git a/binary-search/output/09-operation-counts.txt b/binary-search/output/09-operation-counts.txt
new file mode 100644
index 0000000..4599978
--- /dev/null
+++ b/binary-search/output/09-operation-counts.txt
@@ -0,0 +1,11 @@
+Elements looked at: linear scan vs binary search (counted, not timed)
+=====================================================================
+
+ n | linear scan, absent key | binary, worst over every key | floor(log2 n) + 1
+ 10 | 10 | 4 | 4
+ 1,000 | 1,000 | 10 | 10
+ 100,000 | 100,000 | 17 | 17
+ 1,000,000 | 1,000,000 | 20 | 20
+
+n=1,000,000,000 (memory-free Sequence): the most probes seen over 10,002 sampled keys = 30; floor(log2 n) + 1 = 30
+a linear scan of the same data would look at up to 1,000,000,000 elements
diff --git a/binary-search/output/10-pitfalls.txt b/binary-search/output/10-pitfalls.txt
new file mode 100644
index 0000000..2759c32
--- /dev/null
+++ b/binary-search/output/10-pitfalls.txt
@@ -0,0 +1,28 @@
+Six classic binary-search mistakes, each reproduced
+===================================================
+
+1. hi = a.length with lo <= hi, searching [1, 3, 5] for 9
+ java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
+ correct version returns -1
+
+2. lo = mid instead of lo = mid + 1, searching [1, 2] for 2 (stopped after 6 iterations)
+ iteration 1: low=0 high=1 mid=0 a[mid]=1
+ iteration 2: low=0 high=1 mid=0 a[mid]=1
+ iteration 3: low=0 high=1 mid=0 a[mid]=1
+ iteration 4: low=0 high=1 mid=0 a[mid]=1
+ iteration 5: low=0 high=1 mid=0 a[mid]=1
+ iteration 6: low=0 high=1 mid=0 a[mid]=1
+ correct version returns 1
+
+3. unsorted input [5, 1, 2, 9, 3], key 3
+ binary search returns -1, a linear scan returns 4
+
+4. duplicates [1, 2, 2, 2, 2, 2, 3], key 2 occurs at indexes 1..5
+ iterative returns 3, Arrays.binarySearch returns 3, firstOccurrence returns 1, lastOccurrence returns 5
+
+5. Arrays.binarySearch does not return -1 for "not found": it returns -(insertion point) - 1
+ Arrays.binarySearch([10, 20, 30, 40, 45], 25) = -3 (== -1? false) insertion point = 2
+ Arrays.binarySearch([10, 20, 30, 40, 45], 5) = -1 (== -1? true) insertion point = 0
+ Arrays.binarySearch([10, 20, 30, 40, 45], 50) = -6 (== -1? false) insertion point = 5
+
+6. overflow of (lo + hi) / 2: see 03-overflow-mid.txt
diff --git a/binary-search/output/11-interactive-session.txt b/binary-search/output/11-interactive-session.txt
new file mode 100644
index 0000000..57f02a9
--- /dev/null
+++ b/binary-search/output/11-interactive-session.txt
@@ -0,0 +1,19 @@
+InteractiveDemo (the original console program) with scripted input; values echoed like a terminal
+=================================================================================================
+
+Enter how many numbers to be stored: 5
+Enter 5 numbers in INCREASING ORDER:
+Element [1]: 10
+Element [2]: 20
+Element [3]: 30
+Element [4]: 40
+Element [5]: 45
+Enter the number to search: 40
+Number 40 found at position 4
+Want to search another number? (y/n): y
+Enter the number to search: 10
+Number 10 found at position 1
+Want to search another number? (y/n): y
+Enter the number to search: 25
+Number NOT found in the array.
+Want to search another number? (y/n): n
diff --git a/binary-search/output/12-jdk-source.txt b/binary-search/output/12-jdk-source.txt
new file mode 100644
index 0000000..b25d118
--- /dev/null
+++ b/binary-search/output/12-jdk-source.txt
@@ -0,0 +1,27 @@
+How the JDK itself computes the midpoint (read from this JDK's lib/src.zip)
+===========================================================================
+
+JDK: 25.0.5.1+2-LTS
+
+java/util/Arrays.java, binarySearch0(int[] ...), lines 1698 onwards:
+ 1698 private static int binarySearch0(int[] a, int fromIndex, int toIndex,
+ 1699 int key) {
+ 1700 int low = fromIndex;
+ 1701 int high = toIndex - 1;
+ 1702
+ 1703 while (low <= high) {
+ 1704 int mid = (low + high) >>> 1;
+ 1705 int midVal = a[mid];
+ 1706
+ 1707 if (midVal < key)
+ 1708 low = mid + 1;
+ 1709 else if (midVal > key)
+ 1710 high = mid - 1;
+ 1711 else
+ 1712 return mid; // key found
+ 1713 }
+ 1714 return -(low + 1); // key not found.
+ 1715 }
+
+java/util/Collections.java, indexedBinarySearch(...):
+ 333 int mid = (low + high) >>> 1;
diff --git a/binary-search/output/13-sixteen-elements.txt b/binary-search/output/13-sixteen-elements.txt
new file mode 100644
index 0000000..ae68757
--- /dev/null
+++ b/binary-search/output/13-sixteen-elements.txt
@@ -0,0 +1,8 @@
+Searching for 26 among 2, 4, 6, ... 32 (sixteen values, indexes 0..15)
+======================================================================
+
+low=0 high=15 mid=7 a[mid]=16 -> 26 > 16, low=8
+low=8 high=15 mid=11 a[mid]=24 -> 26 > 24, low=12
+low=12 high=15 mid=13 a[mid]=28 -> 26 < 28, high=12
+low=12 high=12 mid=12 a[mid]=26 -> equals 26, return 12
+result: index 12 after 4 elements compared; a linear scan needs 13
diff --git a/binary-search/output/14-no-bound-methods.txt b/binary-search/output/14-no-bound-methods.txt
new file mode 100644
index 0000000..670531b
--- /dev/null
+++ b/binary-search/output/14-no-bound-methods.txt
@@ -0,0 +1,8 @@
+Public methods with "bound" or "binarySearch" in their name on java.util.Arrays, Collections and List
+====================================================================================================
+
+JDK: 25.0.5.1+2-LTS
+
+java.util.Arrays methods named *bound*: [] binarySearch overloads: 18
+java.util.Collections methods named *bound*: [] binarySearch overloads: 2
+java.util.List methods named *bound*: [] binarySearch overloads: 0
diff --git a/binary-search/pom.xml b/binary-search/pom.xml
new file mode 100644
index 0000000..42268d6
--- /dev/null
+++ b/binary-search/pom.xml
@@ -0,0 +1,63 @@
+
+
+ 4.0.0
+ com.ankurm.interviewlab
+ binary-search
+ 1.0.0
+ jar
+
+ java-interview-lab :: binary-search
+
+ Runnable companion code for ankurm.com's "Binary Search in Java" article: iterative, recursive, lower/upper bound, rotated arrays, search on the answer and 10 interview problems, each cross-checked against brute force.
+
+
+
+ 25
+ UTF-8
+ 6.1.3
+
+
+
+
+
+ org.junit
+ junit-bom
+ ${junit.version}
+ pom
+ import
+
+
+
+
+
+
+ org.junit.jupiter
+ junit-jupiter
+ test
+
+
+ org.junit.platform
+ junit-platform-launcher
+ test
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ 3.14.0
+
+
+ org.apache.maven.plugins
+ maven-surefire-plugin
+ 3.6.0
+
+ -Xmx512m -Duser.timezone=UTC -Dfile.encoding=UTF-8
+
+
+
+
+
diff --git a/binary-search/scripts/run-all.sh b/binary-search/scripts/run-all.sh
new file mode 100755
index 0000000..38df9a6
--- /dev/null
+++ b/binary-search/scripts/run-all.sh
@@ -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
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/BinarySearch.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/BinarySearch.java
new file mode 100644
index 0000000..8d2da74
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/BinarySearch.java
@@ -0,0 +1,101 @@
+package com.ankurm.interviewlab.binarysearch;
+
+/**
+ * The core of the article: plain search (iterative and recursive) and the two "boundary" searches
+ * that every harder problem is built from.
+ *
+ *
All methods expect an array sorted in ascending order. None of them checks that: with unsorted
+ * input they return garbage silently (see {@link Pitfalls}).
+ */
+public final class BinarySearch {
+ private BinarySearch() {}
+
+ /** Index of {@code key}, or -1. The loop invariant: if the key exists, it is inside [lo, hi]. */
+ public static int iterative(int[] a, int key) {
+ int lo = 0;
+ int hi = a.length - 1;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2; // never (lo + hi) / 2, see Overflow
+ if (a[mid] == key) {
+ return mid;
+ }
+ if (key > a[mid]) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return -1;
+ }
+
+ /** Same algorithm, with the loop replaced by a call: each call owns the range [lo, hi]. */
+ public static int recursive(int[] a, int key) {
+ return recursive(a, key, 0, a.length - 1);
+ }
+
+ static int recursive(int[] a, int key, int lo, int hi) {
+ if (lo > hi) {
+ return -1;
+ }
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] == key) {
+ return mid;
+ }
+ return key > a[mid] ? recursive(a, key, mid + 1, hi) : recursive(a, key, lo, mid - 1);
+ }
+
+ /**
+ * First index whose element is {@code >= key}; {@code a.length} if there is none. Works on the
+ * half-open range [lo, hi), so {@code hi = a.length} is a legal answer, not an out-of-bounds read.
+ */
+ public static int lowerBound(int[] a, int key) {
+ int lo = 0;
+ int hi = a.length;
+ while (lo < hi) {
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] < key) {
+ lo = mid + 1;
+ } else {
+ hi = mid;
+ }
+ }
+ return lo;
+ }
+
+ /** First index whose element is {@code > key}; {@code a.length} if there is none. */
+ public static int upperBound(int[] a, int key) {
+ int lo = 0;
+ int hi = a.length;
+ while (lo < hi) {
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] <= key) {
+ lo = mid + 1;
+ } else {
+ hi = mid;
+ }
+ }
+ return lo;
+ }
+
+ /** Leftmost index of {@code key}, or -1. */
+ public static int firstOccurrence(int[] a, int key) {
+ int i = lowerBound(a, key);
+ return i < a.length && a[i] == key ? i : -1;
+ }
+
+ /** Rightmost index of {@code key}, or -1. */
+ public static int lastOccurrence(int[] a, int key) {
+ int i = upperBound(a, key) - 1;
+ return i >= 0 && a[i] == key ? i : -1;
+ }
+
+ /** How many times {@code key} occurs: two searches, no loop over the matches. */
+ public static int count(int[] a, int key) {
+ return upperBound(a, key) - lowerBound(a, key);
+ }
+
+ /** Where {@code key} would have to be inserted to keep the array sorted (leftmost such slot). */
+ public static int insertPosition(int[] a, int key) {
+ return lowerBound(a, key);
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/BruteForce.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/BruteForce.java
new file mode 100644
index 0000000..f2635d9
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/BruteForce.java
@@ -0,0 +1,123 @@
+package com.ankurm.interviewlab.binarysearch;
+
+/** Slow, obviously-correct references. Written independently of the fast versions; no shared helpers. */
+public final class BruteForce {
+ private BruteForce() {}
+
+ public static int indexOf(int[] a, int key) {
+ for (int i = 0; i < a.length; i++) {
+ if (a[i] == key) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ public static int searchInsert(int[] a, int key) {
+ for (int i = 0; i < a.length; i++) {
+ if (a[i] >= key) {
+ return i;
+ }
+ }
+ return a.length;
+ }
+
+ public static int[] searchRange(int[] a, int key) {
+ int first = -1;
+ int last = -1;
+ for (int i = 0; i < a.length; i++) {
+ if (a[i] == key) {
+ if (first < 0) {
+ first = i;
+ }
+ last = i;
+ }
+ }
+ return new int[] {first, last};
+ }
+
+ public static int count(int[] a, int key) {
+ int c = 0;
+ for (int v : a) {
+ if (v == key) {
+ c++;
+ }
+ }
+ return c;
+ }
+
+ public static int minIndex(int[] a) {
+ int best = 0;
+ for (int i = 1; i < a.length; i++) {
+ if (a[i] < a[best]) {
+ best = i;
+ }
+ }
+ return best;
+ }
+
+ public static boolean isPeak(int[] a, int i) {
+ long left = i == 0 ? Long.MIN_VALUE : a[i - 1];
+ long right = i == a.length - 1 ? Long.MIN_VALUE : a[i + 1];
+ return a[i] > left && a[i] > right;
+ }
+
+ public static int sqrt(int x) {
+ long m = 0;
+ while ((m + 1) * (m + 1) <= x) {
+ m++;
+ }
+ return (int) m;
+ }
+
+ /** Try every speed from 1 upwards; count hours by literally eating each pile down. */
+ public static int minEatingSpeed(int[] piles, int h) {
+ for (int speed = 1; ; speed++) {
+ int hours = 0;
+ for (int p : piles) {
+ int left = p;
+ while (left > 0) {
+ left -= speed;
+ hours++;
+ }
+ }
+ if (hours <= h) {
+ return speed;
+ }
+ }
+ }
+
+ /** Try every capacity from the heaviest package upwards; load the ship day by day. */
+ public static int shipWithinDays(int[] weights, int days) {
+ int heaviest = 0;
+ for (int w : weights) {
+ heaviest = Math.max(heaviest, w);
+ }
+ for (int capacity = heaviest; ; capacity++) {
+ int day = 1;
+ int onShip = 0;
+ for (int w : weights) {
+ if (onShip + w <= capacity) {
+ onShip += w;
+ } else {
+ day++;
+ onShip = w;
+ }
+ }
+ if (day <= days) {
+ return capacity;
+ }
+ }
+ }
+
+ public static boolean searchMatrix(int[][] m, int target) {
+ for (int[] row : m) {
+ for (int v : row) {
+ if (v == target) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/DryRuns.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/DryRuns.java
new file mode 100644
index 0000000..aa5e97e
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/DryRuns.java
@@ -0,0 +1,183 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Instrumented copies of the real algorithms. Each one makes exactly the same moves as its original and
+ * writes down what it saw at every step; the tests assert that the result equals the original's result,
+ * so a trace can never drift from the code it explains.
+ */
+public final class DryRuns {
+ private DryRuns() {}
+
+ /** Result, the human-readable steps, and how many elements were compared ("probes"). */
+ public record Run(int result, List lines, int probes) {}
+
+ public static Run iterative(int[] a, int key) {
+ List lines = new ArrayList<>();
+ int lo = 0;
+ int hi = a.length - 1;
+ int probes = 0;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ probes++;
+ String head = "low=" + lo + " high=" + hi + " mid=" + mid + " a[mid]=" + a[mid];
+ if (a[mid] == key) {
+ lines.add(head + " -> equals " + key + ", return " + mid);
+ return new Run(mid, lines, probes);
+ }
+ if (key > a[mid]) {
+ lines.add(head + " -> " + key + " > " + a[mid] + ", low=" + (mid + 1));
+ lo = mid + 1;
+ } else {
+ lines.add(head + " -> " + key + " < " + a[mid] + ", high=" + (mid - 1));
+ hi = mid - 1;
+ }
+ }
+ lines.add("low=" + lo + " high=" + hi + " -> low > high, return -1");
+ return new Run(-1, lines, probes);
+ }
+
+ /** Trace of {@link BinarySearch#lowerBound}: note the half-open range, high starts at a.length. */
+ public static Run lowerBound(int[] a, int key) {
+ List lines = new ArrayList<>();
+ int lo = 0;
+ int hi = a.length;
+ int probes = 0;
+ while (lo < hi) {
+ int mid = lo + (hi - lo) / 2;
+ probes++;
+ String head = "low=" + lo + " high=" + hi + " mid=" + mid + " a[mid]=" + a[mid];
+ if (a[mid] < key) {
+ lines.add(head + " -> " + a[mid] + " < " + key + ", everything up to mid is too small, low=" + (mid + 1));
+ lo = mid + 1;
+ } else {
+ lines.add(head + " -> " + a[mid] + " >= " + key + ", mid might be the answer, high=" + mid);
+ hi = mid;
+ }
+ }
+ lines.add("low=" + lo + " high=" + hi + " -> range is empty, answer " + lo);
+ return new Run(lo, lines, probes);
+ }
+
+ public static Run rotatedSearch(int[] a, int key) {
+ List lines = new ArrayList<>();
+ int lo = 0;
+ int hi = a.length - 1;
+ int probes = 0;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ probes++;
+ String head = "low=" + lo + " high=" + hi + " mid=" + mid + " a[mid]=" + a[mid];
+ if (a[mid] == key) {
+ lines.add(head + " -> found at " + mid);
+ return new Run(mid, lines, probes);
+ }
+ if (a[lo] <= a[mid]) {
+ String half = "left half " + a[lo] + ".." + a[mid] + " is sorted";
+ if (a[lo] <= key && key < a[mid]) {
+ lines.add(head + " | " + half + " and holds " + key + " -> high=" + (mid - 1));
+ hi = mid - 1;
+ } else {
+ lines.add(head + " | " + half + " and does not hold " + key + " -> low=" + (mid + 1));
+ lo = mid + 1;
+ }
+ } else {
+ String half = "right half " + a[mid] + ".." + a[hi] + " is sorted";
+ if (a[mid] < key && key <= a[hi]) {
+ lines.add(head + " | " + half + " and holds " + key + " -> low=" + (mid + 1));
+ lo = mid + 1;
+ } else {
+ lines.add(head + " | " + half + " and does not hold " + key + " -> high=" + (mid - 1));
+ hi = mid - 1;
+ }
+ }
+ }
+ lines.add("low=" + lo + " high=" + hi + " -> low > high, return -1");
+ return new Run(-1, lines, probes);
+ }
+
+ public static Run rotatedMin(int[] a) {
+ List lines = new ArrayList<>();
+ int lo = 0;
+ int hi = a.length - 1;
+ int probes = 0;
+ while (lo < hi) {
+ int mid = lo + (hi - lo) / 2;
+ probes++;
+ String head = "low=" + lo + " high=" + hi + " mid=" + mid + " a[mid]=" + a[mid] + " a[high]=" + a[hi];
+ if (a[mid] > a[hi]) {
+ lines.add(head + " -> " + a[mid] + " > " + a[hi] + ", the drop is right of mid, low=" + (mid + 1));
+ lo = mid + 1;
+ } else {
+ lines.add(head + " -> " + a[mid] + " <= " + a[hi] + ", the drop is at mid or left of it, high=" + mid);
+ hi = mid;
+ }
+ }
+ lines.add("low=" + lo + " high=" + hi + " -> minimum " + a[lo] + " at index " + lo);
+ return new Run(lo, lines, probes);
+ }
+
+ /** {result, frames}: how deep the recursion went (the last frame is the empty-range base case). */
+ public static int[] recursiveDepth(int[] a, int key) {
+ int[] deepest = {0};
+ int result = recurse(a, key, 0, a.length - 1, 1, deepest);
+ return new int[] {result, deepest[0]};
+ }
+
+ private static int recurse(int[] a, int key, int lo, int hi, int depth, int[] deepest) {
+ deepest[0] = Math.max(deepest[0], depth);
+ if (lo > hi) {
+ return -1;
+ }
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] == key) {
+ return mid;
+ }
+ return key > a[mid]
+ ? recurse(a, key, mid + 1, hi, depth + 1, deepest)
+ : recurse(a, key, lo, mid - 1, depth + 1, deepest);
+ }
+
+ /** Number of elements the iterative search looks at for this key. */
+ public static int probes(int[] a, int key) {
+ int lo = 0;
+ int hi = a.length - 1;
+ int probes = 0;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ probes++;
+ if (a[mid] == key) {
+ return probes;
+ }
+ if (key > a[mid]) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return probes;
+ }
+
+ /** Same count over the memory-free {@link Overflow.Sequence}, for sizes no array could hold. */
+ public static int probes(Overflow.Sequence s, int key) {
+ int lo = 0;
+ int hi = s.length() - 1;
+ int probes = 0;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ probes++;
+ int v = s.get(mid);
+ if (v == key) {
+ return probes;
+ }
+ if (key > v) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return probes;
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/InteractiveDemo.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/InteractiveDemo.java
new file mode 100644
index 0000000..52e4dc4
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/InteractiveDemo.java
@@ -0,0 +1,77 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import java.io.PrintStream;
+import java.util.Scanner;
+
+/**
+ * The console program from the original 2015 version of the article, kept so nothing that article taught is
+ * lost. Two changes: the midpoint is now {@code low + (high - low) / 2}, and the loop is a method taking a
+ * Scanner and a PrintStream so a test can drive it. Run it for real with {@code java InteractiveDemo.java}.
+ */
+public final class InteractiveDemo {
+ private InteractiveDemo() {}
+
+ public static void main(String[] args) {
+ run(new Scanner(System.in), System.out, false);
+ }
+
+ /**
+ * @param echo when true, every value read is printed after its prompt, as a terminal would show what you
+ * typed. Needed only when input comes from a script instead of a keyboard.
+ */
+ public static void run(Scanner in, PrintStream out, boolean echo) {
+ out.print("Enter how many numbers to be stored: ");
+ int arraySize = readInt(in, out, echo);
+
+ int[] numberArray = new int[arraySize];
+ out.println("Enter " + arraySize + " numbers in INCREASING ORDER:");
+ for (int index = 0; index < arraySize; index++) {
+ out.print("Element [" + (index + 1) + "]: ");
+ numberArray[index] = readInt(in, out, echo);
+ }
+
+ String continueSearch;
+ do {
+ out.print("Enter the number to search: ");
+ int searchKey = readInt(in, out, echo);
+
+ int searchResult = performBinarySearch(numberArray, searchKey);
+ if (searchResult == -1) {
+ out.println("Number NOT found in the array.");
+ } else {
+ out.println("Number " + searchKey + " found at position " + (searchResult + 1));
+ }
+
+ out.print("Want to search another number? (y/n): ");
+ continueSearch = in.next();
+ if (echo) {
+ out.println(continueSearch);
+ }
+ } while (continueSearch.equalsIgnoreCase("y"));
+ }
+
+ private static int readInt(Scanner in, PrintStream out, boolean echo) {
+ int value = in.nextInt();
+ if (echo) {
+ out.println(value);
+ }
+ return value;
+ }
+
+ /** Returns the index of {@code key} in the sorted array, or -1 (the original method, same name). */
+ public static int performBinarySearch(int[] arr, int key) {
+ int low = 0;
+ int high = arr.length - 1;
+ while (low <= high) {
+ int mid = low + (high - low) / 2; // the original had (low + high) / 2
+ if (arr[mid] == key) {
+ return mid;
+ } else if (key > arr[mid]) {
+ low = mid + 1;
+ } else {
+ high = mid - 1;
+ }
+ }
+ return -1;
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/InterviewProblems.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/InterviewProblems.java
new file mode 100644
index 0000000..394d6f0
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/InterviewProblems.java
@@ -0,0 +1,71 @@
+package com.ankurm.interviewlab.binarysearch;
+
+/**
+ * The remaining interview problems that are not already one call into {@link BinarySearch},
+ * {@link RotatedArray} or {@link SearchOnAnswer}. The full list of ten:
+ *
+ *
+ * 1 Search insert position BinarySearch.insertPosition
+ * 2 First and last position InterviewProblems.searchRange
+ * 3 Count occurrences BinarySearch.count
+ * 4 Search in a rotated array RotatedArray.search
+ * 5 Minimum of a rotated array RotatedArray.minIndex
+ * 6 Find a peak element InterviewProblems.findPeak
+ * 7 Integer square root SearchOnAnswer.sqrt
+ * 8 Koko eating bananas SearchOnAnswer.minEatingSpeed
+ * 9 Ship packages within D days SearchOnAnswer.shipWithinDays
+ * 10 Search a 2D matrix InterviewProblems.searchMatrix
+ *
+ */
+public final class InterviewProblems {
+ private InterviewProblems() {}
+
+ /** {first, last} index of {@code key}, or {-1, -1}. Two boundary searches. */
+ public static int[] searchRange(int[] a, int key) {
+ return new int[] {BinarySearch.firstOccurrence(a, key), BinarySearch.lastOccurrence(a, key)};
+ }
+
+ /**
+ * Index of ANY peak: an element strictly greater than both neighbours (outside the array counts as
+ * minus infinity). Adjacent elements must differ. Follow the slope upward: a peak must exist that way.
+ */
+ public static int findPeak(int[] a) {
+ int lo = 0;
+ int hi = a.length - 1;
+ while (lo < hi) {
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] < a[mid + 1]) { // rising: a peak exists to the right of mid
+ lo = mid + 1;
+ } else { // falling (or at a peak): a peak exists at mid or to its left
+ hi = mid;
+ }
+ }
+ return lo;
+ }
+
+ /**
+ * Search a matrix where every row is sorted and each row starts above the end of the previous row.
+ * Pretend it is one flat sorted array of rows*cols elements: index i lives at [i / cols][i % cols].
+ */
+ public static boolean searchMatrix(int[][] m, int target) {
+ if (m.length == 0 || m[0].length == 0) {
+ return false;
+ }
+ int cols = m[0].length;
+ int lo = 0;
+ int hi = m.length * cols - 1;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ int v = m[mid / cols][mid % cols];
+ if (v == target) {
+ return true;
+ }
+ if (target > v) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return false;
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/Overflow.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/Overflow.java
new file mode 100644
index 0000000..8388ed4
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/Overflow.java
@@ -0,0 +1,87 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import java.util.List;
+
+/**
+ * The midpoint overflow bug, reproduced at the size where it bites.
+ *
+ * A real {@code int[]} of 2 billion elements needs about 8 GB, so the demo searches a
+ * {@link Sequence}: a sorted "array" whose element {@code i} is simply {@code i}, with no memory behind
+ * it. {@link Sequence#get(int)} throws the same exception type a real array would for a bad index.
+ */
+public final class Overflow {
+ private Overflow() {}
+
+ /** A sorted sequence 0, 1, 2, ... length-1 that costs no memory. */
+ public record Sequence(int length) {
+ public int get(int i) {
+ if (i < 0 || i >= length) {
+ throw new ArrayIndexOutOfBoundsException("Index " + i + " out of bounds for length " + length);
+ }
+ return i;
+ }
+ }
+
+ /** The textbook version, with {@code (lo + hi) / 2}. {@code log} (nullable) records every step. */
+ public static int broken(Sequence s, int key, List log) {
+ int lo = 0;
+ int hi = s.length() - 1;
+ while (lo <= hi) {
+ int mid = (lo + hi) / 2; // lo + hi can exceed Integer.MAX_VALUE and wrap to a negative number
+ if (log != null) {
+ log.add("lo=" + lo + " hi=" + hi + " lo+hi=" + (lo + hi) + " mid=" + mid);
+ }
+ int v = s.get(mid);
+ if (v == key) {
+ return mid;
+ }
+ if (key > v) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return -1;
+ }
+
+ /** Fix 1: {@code lo + (hi - lo) / 2}. {@code hi - lo} cannot overflow because 0 <= lo <= hi. */
+ public static int safeSubtract(Sequence s, int key, List log) {
+ int lo = 0;
+ int hi = s.length() - 1;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ if (log != null) {
+ log.add("lo=" + lo + " hi=" + hi + " hi-lo=" + (hi - lo) + " mid=" + mid);
+ }
+ int v = s.get(mid);
+ if (v == key) {
+ return mid;
+ }
+ if (key > v) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return -1;
+ }
+
+ /** Fix 2: {@code (lo + hi) >>> 1}. The sum wraps, but read as unsigned it is still correct before halving. */
+ public static int safeShift(Sequence s, int key) {
+ int lo = 0;
+ int hi = s.length() - 1;
+ while (lo <= hi) {
+ int mid = (lo + hi) >>> 1;
+ int v = s.get(mid);
+ if (v == key) {
+ return mid;
+ }
+ if (key > v) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return -1;
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/Pitfalls.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/Pitfalls.java
new file mode 100644
index 0000000..1e2c037
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/Pitfalls.java
@@ -0,0 +1,58 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import java.util.List;
+
+/**
+ * Plausible-looking wrong versions. Each is one small edit away from the correct loop in
+ * {@link BinarySearch}, which is exactly why these bugs survive code review. The other classic mistakes
+ * (unsorted input, duplicates, the negative return value of Arrays.binarySearch) need no wrong code at all
+ * and are demonstrated straight from PitfallsTest.
+ */
+public final class Pitfalls {
+ private Pitfalls() {}
+
+ /** Bug: {@code hi = a.length} with an inclusive {@code lo <= hi} loop. Reads a[a.length]. */
+ public static int hiIsLength(int[] a, int key) {
+ int lo = 0;
+ int hi = a.length; // should be a.length - 1
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] == key) {
+ return mid;
+ }
+ if (key > a[mid]) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Bug: {@code lo = mid} instead of {@code lo = mid + 1}. When the range shrinks to one or two elements
+ * and the middle one is too small, mid equals lo, the assignment changes nothing and the loop never ends.
+ * {@code cap} stops the demo.
+ * Returns -2 when the cap was hit.
+ */
+ public static int loEqualsMid(int[] a, int key, int cap, List log) {
+ int lo = 0;
+ int hi = a.length - 1;
+ for (int iteration = 1; lo <= hi; iteration++) {
+ if (iteration > cap) {
+ return -2;
+ }
+ int mid = lo + (hi - lo) / 2;
+ log.add("iteration " + iteration + ": low=" + lo + " high=" + hi + " mid=" + mid + " a[mid]=" + a[mid]);
+ if (a[mid] == key) {
+ return mid;
+ }
+ if (a[mid] < key) {
+ lo = mid; // should be mid + 1
+ } else {
+ hi = mid - 1;
+ }
+ }
+ return -1;
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/RotatedArray.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/RotatedArray.java
new file mode 100644
index 0000000..e71415f
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/RotatedArray.java
@@ -0,0 +1,72 @@
+package com.ankurm.interviewlab.binarysearch;
+
+/**
+ * Binary search on an array that was sorted and then rotated, such as [4, 5, 6, 7, 0, 1, 2].
+ * The array is no longer sorted, but at every step at least one half of it still is.
+ */
+public final class RotatedArray {
+ private RotatedArray() {}
+
+ /** Search a rotated array of DISTINCT values. Returns the index of {@code key} or -1. */
+ public static int search(int[] a, int key) {
+ int lo = 0;
+ int hi = a.length - 1;
+ while (lo <= hi) {
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] == key) {
+ return mid;
+ }
+ if (a[lo] <= a[mid]) { // left half [lo..mid] is sorted
+ if (a[lo] <= key && key < a[mid]) {
+ hi = mid - 1;
+ } else {
+ lo = mid + 1;
+ }
+ } else { // right half [mid..hi] is sorted
+ if (a[mid] < key && key <= a[hi]) {
+ lo = mid + 1;
+ } else {
+ hi = mid - 1;
+ }
+ }
+ }
+ return -1;
+ }
+
+ /** Index of the smallest element (the rotation point) of a rotated array of DISTINCT values. */
+ public static int minIndex(int[] a) {
+ int lo = 0;
+ int hi = a.length - 1;
+ while (lo < hi) {
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] > a[hi]) { // the minimum is strictly to the right of mid
+ lo = mid + 1;
+ } else { // a[mid] <= a[hi]: the minimum is at mid or to its left
+ hi = mid;
+ }
+ }
+ return lo;
+ }
+
+ /**
+ * Smallest value when duplicates are allowed. Returns {value, iterations}. When a[mid] == a[hi]
+ * the comparison proves nothing, so the only safe move is {@code hi--}: the worst case is O(n).
+ */
+ public static int[] minWithDuplicates(int[] a) {
+ int lo = 0;
+ int hi = a.length - 1;
+ int iterations = 0;
+ while (lo < hi) {
+ iterations++;
+ int mid = lo + (hi - lo) / 2;
+ if (a[mid] > a[hi]) {
+ lo = mid + 1;
+ } else if (a[mid] < a[hi]) {
+ hi = mid;
+ } else {
+ hi--;
+ }
+ }
+ return new int[] {a[lo], iterations};
+ }
+}
diff --git a/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/SearchOnAnswer.java b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/SearchOnAnswer.java
new file mode 100644
index 0000000..78e5204
--- /dev/null
+++ b/binary-search/src/main/java/com/ankurm/interviewlab/binarysearch/SearchOnAnswer.java
@@ -0,0 +1,87 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import java.util.function.LongPredicate;
+
+/**
+ * "Binary search on the answer": there is no array to search, but the answer lives in a range and a yes/no
+ * question about a candidate flips from false to true exactly once. Searching that flip point is the same
+ * loop as {@link BinarySearch#lowerBound(int[], int)}.
+ */
+public final class SearchOnAnswer {
+ private SearchOnAnswer() {}
+
+ /**
+ * Smallest x in [lo, hi] for which {@code ok} is true. Requires: ok is false...false true...true over
+ * the range, and ok(hi) is true.
+ */
+ public static long firstTrue(long lo, long hi, LongPredicate ok) {
+ while (lo < hi) {
+ long mid = lo + (hi - lo) / 2;
+ if (ok.test(mid)) {
+ hi = mid; // mid might be the answer: keep it
+ } else {
+ lo = mid + 1; // mid is too small: drop it
+ }
+ }
+ return lo;
+ }
+
+ /** Integer square root, rounded down, without Math.sqrt: the largest m with m*m <= x. */
+ public static int sqrt(int x, LongPredicate probe) {
+ long firstTooBig = firstTrue(0, (long) x + 1, probe);
+ return (int) (firstTooBig - 1);
+ }
+
+ public static int sqrt(int x) {
+ return sqrt(x, m -> m * m > x);
+ }
+
+ /** Smallest eating speed (bananas per hour) that finishes every pile within {@code h} hours. */
+ public static int minEatingSpeed(int[] piles, int h, LongPredicate probe) {
+ long max = 0;
+ for (int p : piles) {
+ max = Math.max(max, p);
+ }
+ return (int) firstTrue(1, max, probe);
+ }
+
+ public static int minEatingSpeed(int[] piles, int h) {
+ return minEatingSpeed(piles, h, k -> hoursNeeded(piles, k) <= h);
+ }
+
+ static long hoursNeeded(int[] piles, long speed) {
+ long hours = 0;
+ for (int p : piles) {
+ hours += (p + speed - 1) / speed; // ceil(p / speed)
+ }
+ return hours;
+ }
+
+ /** Smallest ship capacity that moves the packages, in order, within {@code days} days. */
+ public static int shipWithinDays(int[] weights, int days, LongPredicate probe) {
+ long max = 0;
+ long sum = 0;
+ for (int w : weights) {
+ max = Math.max(max, w);
+ sum += w;
+ }
+ return (int) firstTrue(max, sum, probe);
+ }
+
+ public static int shipWithinDays(int[] weights, int days) {
+ return shipWithinDays(weights, days, cap -> daysNeeded(weights, cap) <= days);
+ }
+
+ static int daysNeeded(int[] weights, long capacity) {
+ int days = 1;
+ long load = 0;
+ for (int w : weights) {
+ if (load + w > capacity) {
+ days++;
+ load = 0;
+ }
+ load += w;
+ }
+ return days;
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/BoundsTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/BoundsTest.java
new file mode 100644
index 0000000..e2d8b4f
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/BoundsTest.java
@@ -0,0 +1,42 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class BoundsTest {
+ static final int[] A = {1, 2, 2, 2, 2, 2, 3, 5, 5, 8};
+
+ @Test
+ void lowerAndUpperBoundOnDuplicates() {
+ Transcript t = Transcript.start("04-lower-upper-bound.txt",
+ "lowerBound / upperBound on " + Arrays.toString(A) + " (indexes 0..9)");
+ t.line(String.format("%3s | %10s | %10s | %5s | %4s | %5s | %9s | %19s",
+ "key", "lowerBound", "upperBound", "first", "last", "count", "iterative", "Arrays.binarySearch"));
+ for (int key : new int[] {0, 1, 2, 3, 4, 5, 8, 9}) {
+ int lb = BinarySearch.lowerBound(A, key);
+ int ub = BinarySearch.upperBound(A, key);
+ int first = BinarySearch.firstOccurrence(A, key);
+ int last = BinarySearch.lastOccurrence(A, key);
+ int count = BinarySearch.count(A, key);
+ assertEquals(BruteForce.searchInsert(A, key), lb);
+ assertEquals(BruteForce.searchRange(A, key)[0], first);
+ assertEquals(BruteForce.searchRange(A, key)[1], last);
+ assertEquals(BruteForce.count(A, key), count);
+ assertEquals(ub - lb, count);
+ t.line(String.format("%3d | %10d | %10d | %5d | %4d | %5d | %9d | %19d",
+ key, lb, ub, first, last, count, BinarySearch.iterative(A, key), Arrays.binarySearch(A, key)));
+ }
+ t.blank();
+ for (int key : new int[] {2, 4}) {
+ DryRuns.Run r = DryRuns.lowerBound(A, key);
+ assertEquals(BinarySearch.lowerBound(A, key), r.result());
+ t.line("lowerBound for " + key + ":");
+ r.lines().forEach(l -> t.line(" " + l));
+ t.blank();
+ }
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/ComplexityTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/ComplexityTest.java
new file mode 100644
index 0000000..afd4def
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/ComplexityTest.java
@@ -0,0 +1,42 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.Locale;
+import java.util.Random;
+import org.junit.jupiter.api.Test;
+
+/** Counted, not timed: how many elements each search looks at. */
+class ComplexityTest {
+ @Test
+ void probesGrowWithLogN() {
+ Transcript t = Transcript.start("09-operation-counts.txt",
+ "Elements looked at: linear scan vs binary search (counted, not timed)");
+ t.line(String.format("%13s | %24s | %30s | %s", "n", "linear scan, absent key", "binary, worst over every key", "floor(log2 n) + 1"));
+ for (int n : new int[] {10, 1_000, 100_000, 1_000_000}) {
+ int[] a = DryRunTest.evens(n);
+ int worst = 0;
+ for (int key = -1; key <= 2 * n; key++) { // every present key, every gap, both ends
+ worst = Math.max(worst, DryRuns.probes(a, key));
+ }
+ int bound = 32 - Integer.numberOfLeadingZeros(n);
+ assertEquals(bound, worst, "n=" + n);
+ t.line(String.format(Locale.ROOT, "%,13d | %,24d | %,30d | %d", n, n, worst, bound));
+ }
+ t.blank();
+
+ Overflow.Sequence big = new Overflow.Sequence(1_000_000_000);
+ Random rnd = new Random(2026);
+ int worst = Math.max(DryRuns.probes(big, -1), DryRuns.probes(big, 1_000_000_000));
+ for (int i = 0; i < 10_000; i++) {
+ worst = Math.max(worst, DryRuns.probes(big, rnd.nextInt(1_000_002) * 1000 - 1));
+ }
+ assertTrue(worst <= 30);
+ t.line(String.format(Locale.ROOT, "n=%,d (memory-free Sequence): the most probes seen over 10,002 sampled keys = %d; floor(log2 n) + 1 = %d",
+ 1_000_000_000, worst, 32 - Integer.numberOfLeadingZeros(1_000_000_000)));
+ t.line(String.format(Locale.ROOT, "a linear scan of the same data would look at up to %,d elements", 1_000_000_000));
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/DryRunTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/DryRunTest.java
new file mode 100644
index 0000000..41da9f1
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/DryRunTest.java
@@ -0,0 +1,76 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.Locale;
+import org.junit.jupiter.api.Test;
+
+/** Traces for the three searches the original article walked through, plus recursive vs iterative. */
+class DryRunTest {
+ static final int[] SAMPLE = {10, 20, 30, 40, 45};
+
+ static int[] evens(int n) {
+ int[] a = new int[n];
+ for (int i = 0; i < n; i++) {
+ a[i] = 2 * i;
+ }
+ return a;
+ }
+
+ @Test
+ void tracesTheThreeSearchesFromTheOriginalArticle() {
+ Transcript t = Transcript.start("01-dry-run-iterative.txt",
+ "Iterative binary search, traced step by step on [10, 20, 30, 40, 45]");
+ int[][] cases = {{40, 3}, {10, 0}, {25, -1}};
+ for (int[] c : cases) {
+ DryRuns.Run r = DryRuns.iterative(SAMPLE, c[0]);
+ assertEquals(c[1], r.result());
+ assertEquals(BinarySearch.iterative(SAMPLE, c[0]), r.result(), "trace must match the real code");
+ t.line("search for " + c[0]);
+ r.lines().forEach(l -> t.line(" " + l));
+ String where = r.result() >= 0 ? " (position " + (r.result() + 1) + " counting from 1)" : "";
+ t.line(" result: " + r.result() + where + ", " + r.probes() + " elements compared").blank();
+ }
+ t.flush();
+ }
+
+ @Test
+ void recursiveAndIterativeAgreeAndRecursionStaysShallow() {
+ Transcript t = Transcript.start("02-recursive-vs-iterative.txt",
+ "Recursive vs iterative: same answers, and how deep the recursion goes");
+ int[] a = evens(1000);
+ int checked = 0;
+ for (int key = -1; key <= 2001; key++) {
+ assertEquals(BinarySearch.iterative(a, key), BinarySearch.recursive(a, key), "key " + key);
+ checked++;
+ }
+ t.line("n=1000, elements 0,2,4,...,1998: " + checked + " keys from -1 to 2001 (present and absent)");
+ t.line("give identical answers from the iterative and the recursive version.").blank();
+ for (int n : new int[] {10, 1000, 1_000_000}) {
+ int[] arr = evens(n);
+ int key = arr[n - 1] + 1; // absent, larger than everything: the longest path
+ int[] r = DryRuns.recursiveDepth(arr, key);
+ assertEquals(-1, r[0]);
+ t.line(String.format(Locale.ROOT,
+ "n=%,9d absent key above the last element: result=%d, recursion frames=%d (iterative uses 0 extra frames)",
+ n, r[0], r[1]));
+ }
+ t.flush();
+ }
+
+ @Test
+ void sixteenValuesNeedFourProbes() {
+ int[] a = new int[16];
+ for (int i = 0; i < 16; i++) {
+ a[i] = 2 * (i + 1);
+ }
+ DryRuns.Run r = DryRuns.iterative(a, 26);
+ assertEquals(12, r.result());
+ assertEquals(4, r.probes());
+ Transcript t = Transcript.start("13-sixteen-elements.txt", "Searching for 26 among 2, 4, 6, ... 32 (sixteen values, indexes 0..15)");
+ r.lines().forEach(l -> t.line(l));
+ t.line("result: index " + r.result() + " after " + r.probes() + " elements compared; a linear scan needs 13").flush();
+ assertEquals(13, BruteForce.indexOf(a, 26) + 1);
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/InteractiveDemoTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/InteractiveDemoTest.java
new file mode 100644
index 0000000..63ec8a6
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/InteractiveDemoTest.java
@@ -0,0 +1,48 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Scanner;
+import org.junit.jupiter.api.Test;
+
+class InteractiveDemoTest {
+ /** The sample run printed in the original 2015 article, character for character. */
+ private static final String ORIGINAL_SAMPLE = String.join("\n",
+ "Enter how many numbers to be stored: 5",
+ "Enter 5 numbers in INCREASING ORDER:",
+ "Element [1]: 10",
+ "Element [2]: 20",
+ "Element [3]: 30",
+ "Element [4]: 40",
+ "Element [5]: 45",
+ "Enter the number to search: 40",
+ "Number 40 found at position 4",
+ "Want to search another number? (y/n): y",
+ "Enter the number to search: 10",
+ "Number 10 found at position 1",
+ "Want to search another number? (y/n): y",
+ "Enter the number to search: 25",
+ "Number NOT found in the array.",
+ "Want to search another number? (y/n): n",
+ "");
+
+ @Test
+ void reproducesTheOriginalSampleSession() {
+ ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+ PrintStream out = new PrintStream(buffer, true, StandardCharsets.UTF_8);
+ InteractiveDemo.run(new Scanner("5 10 20 30 40 45 40 y 10 y 25 n"), out, true);
+ String session = buffer.toString(StandardCharsets.UTF_8).replace("\r\n", "\n");
+ assertEquals(ORIGINAL_SAMPLE, session);
+
+ Transcript t = Transcript.start("11-interactive-session.txt",
+ "InteractiveDemo (the original console program) with scripted input; values echoed like a terminal");
+ for (String line : session.split("\n")) {
+ t.line(line);
+ }
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/JdkSourceTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/JdkSourceTest.java
new file mode 100644
index 0000000..f30e80a
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/JdkSourceTest.java
@@ -0,0 +1,93 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.TreeSet;
+import org.junit.jupiter.api.Test;
+
+/** Reads the JDK's own source instead of trusting memory about how java.util does it. */
+class JdkSourceTest {
+ @Test
+ void jdkUsesUnsignedShiftForTheMidpoint() throws IOException {
+ Path zip = Path.of(System.getProperty("java.home"), "lib", "src.zip");
+ assumeTrue(Files.exists(zip), "this JDK has no lib/src.zip");
+ Transcript t = Transcript.start("12-jdk-source.txt", "How the JDK itself computes the midpoint (read from this JDK's lib/src.zip)");
+ t.line("JDK: " + Runtime.version()).blank();
+ try (var fs = FileSystems.newFileSystem(zip)) {
+ List arrays = Files.readAllLines(fs.getPath("java.base/java/util/Arrays.java"));
+ int start = -1;
+ for (int i = 0; i < arrays.size(); i++) {
+ if (arrays.get(i).contains("private static int binarySearch0(int[] a, int fromIndex, int toIndex,")) {
+ start = i;
+ break;
+ }
+ }
+ assertTrue(start >= 0, "binarySearch0(int[]) not found");
+ t.line("java/util/Arrays.java, binarySearch0(int[] ...), lines " + (start + 1) + " onwards:");
+ boolean sawShift = false;
+ for (int i = start; i < arrays.size(); i++) {
+ String line = arrays.get(i);
+ t.line(String.format("%5d %s", i + 1, line));
+ sawShift |= line.contains("(low + high) >>> 1");
+ if (line.equals(" }")) {
+ break;
+ }
+ }
+ assertTrue(sawShift, "expected (low + high) >>> 1 in Arrays.binarySearch0");
+ t.blank();
+
+ List collections = Files.readAllLines(fs.getPath("java.base/java/util/Collections.java"));
+ int decl = -1;
+ for (int i = 0; i < collections.size(); i++) {
+ if (collections.get(i).contains("private static int indexedBinarySearch(")) {
+ decl = i;
+ break;
+ }
+ }
+ assertTrue(decl >= 0, "indexedBinarySearch not found");
+ t.line("java/util/Collections.java, indexedBinarySearch(...):");
+ for (int i = decl; i < collections.size(); i++) {
+ String line = collections.get(i);
+ if (line.contains("int mid")) {
+ t.line(String.format("%5d %s", i + 1, line));
+ assertTrue(line.contains(">>> 1"));
+ break;
+ }
+ }
+ }
+ t.flush();
+ }
+
+ @Test
+ void jdkHasNoLowerOrUpperBound() {
+ Transcript t = Transcript.start("14-no-bound-methods.txt",
+ "Public methods with \"bound\" or \"binarySearch\" in their name on java.util.Arrays, Collections and List");
+ t.line("JDK: " + Runtime.version()).blank();
+ for (Class> c : new Class>[] {java.util.Arrays.class, java.util.Collections.class, java.util.List.class}) {
+ TreeSet bound = new TreeSet<>();
+ TreeSet search = new TreeSet<>();
+ int overloads = 0;
+ for (Method m : c.getMethods()) {
+ String n = m.getName().toLowerCase(java.util.Locale.ROOT);
+ if (n.contains("bound")) {
+ bound.add(m.getName());
+ }
+ if (n.startsWith("binarysearch")) {
+ search.add(m.getName());
+ overloads++;
+ }
+ }
+ assertTrue(bound.isEmpty(), c.getName() + " unexpectedly has " + bound);
+ t.line(String.format("%-24s methods named *bound*: %s binarySearch overloads: %d", c.getName(), bound, overloads));
+ }
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/OverflowTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/OverflowTest.java
new file mode 100644
index 0000000..83fe0d8
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/OverflowTest.java
@@ -0,0 +1,53 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class OverflowTest {
+ @Test
+ void midpointOverflowAtTwoBillionElements() {
+ Transcript t = Transcript.start("03-overflow-mid.txt",
+ "The (lo + hi) / 2 bug on a sorted sequence of 2,000,000,000 elements (no array: see Overflow.Sequence)");
+
+ int lo = 1_000_000_000;
+ int hi = 1_999_999_999;
+ assertTrue(lo + hi < 0);
+ t.line("Plain int arithmetic, lo=" + lo + " hi=" + hi + ":");
+ t.line(" lo + hi = " + (lo + hi));
+ t.line(" (lo + hi) / 2 = " + ((lo + hi) / 2));
+ t.line(" lo + (hi - lo) / 2 = " + (lo + (hi - lo) / 2));
+ t.line(" (lo + hi) >>> 1 = " + ((lo + hi) >>> 1));
+ assertEquals(1_499_999_999, lo + (hi - lo) / 2);
+ assertEquals(1_499_999_999, (lo + hi) >>> 1);
+ t.blank();
+
+ Overflow.Sequence s = new Overflow.Sequence(2_000_000_000);
+ int key = 1_999_999_999; // the last element
+
+ List brokenLog = new ArrayList<>();
+ ArrayIndexOutOfBoundsException ex =
+ assertThrows(ArrayIndexOutOfBoundsException.class, () -> Overflow.broken(s, key, brokenLog));
+ t.line("Broken (lo + hi) / 2, searching for the last element, " + key + ":");
+ brokenLog.forEach(l -> t.line(" " + l));
+ t.line(" -> " + ex.getClass().getName() + ": " + ex.getMessage()).blank();
+
+ List fixedLog = new ArrayList<>();
+ int found = Overflow.safeSubtract(s, key, fixedLog);
+ assertEquals(key, found);
+ t.line("Fixed with lo + (hi - lo) / 2: found index " + found + " after " + fixedLog.size() + " steps. First and last steps:");
+ t.line(" " + fixedLog.get(0));
+ t.line(" " + fixedLog.get(1));
+ t.line(" ...");
+ t.line(" " + fixedLog.get(fixedLog.size() - 1)).blank();
+
+ assertEquals(key, Overflow.safeShift(s, key));
+ t.line("Fixed with (lo + hi) >>> 1: found index " + Overflow.safeShift(s, key));
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/PitfallsTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/PitfallsTest.java
new file mode 100644
index 0000000..76b50aa
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/PitfallsTest.java
@@ -0,0 +1,58 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class PitfallsTest {
+ @Test
+ void sixClassicMistakesEachReproduced() {
+ Transcript t = Transcript.start("10-pitfalls.txt", "Six classic binary-search mistakes, each reproduced");
+
+ int[] three = {1, 3, 5};
+ ArrayIndexOutOfBoundsException ex =
+ assertThrows(ArrayIndexOutOfBoundsException.class, () -> Pitfalls.hiIsLength(three, 9));
+ t.line("1. hi = a.length with lo <= hi, searching " + Arrays.toString(three) + " for 9");
+ t.line(" " + ex.getClass().getName() + ": " + ex.getMessage());
+ t.line(" correct version returns " + BinarySearch.iterative(three, 9)).blank();
+
+ int[] two = {1, 2};
+ List log = new ArrayList<>();
+ int stuck = Pitfalls.loEqualsMid(two, 2, 6, log);
+ assertEquals(-2, stuck);
+ t.line("2. lo = mid instead of lo = mid + 1, searching " + Arrays.toString(two) + " for 2 (stopped after 6 iterations)");
+ log.forEach(l -> t.line(" " + l));
+ t.line(" correct version returns " + BinarySearch.iterative(two, 2)).blank();
+
+ int[] unsorted = {5, 1, 2, 9, 3};
+ assertEquals(-1, BinarySearch.iterative(unsorted, 3));
+ assertEquals(4, BruteForce.indexOf(unsorted, 3));
+ t.line("3. unsorted input " + Arrays.toString(unsorted) + ", key 3");
+ t.line(" binary search returns " + BinarySearch.iterative(unsorted, 3) + ", a linear scan returns " + BruteForce.indexOf(unsorted, 3)).blank();
+
+ int[] dups = {1, 2, 2, 2, 2, 2, 3};
+ t.line("4. duplicates " + Arrays.toString(dups) + ", key 2 occurs at indexes 1..5");
+ t.line(" iterative returns " + BinarySearch.iterative(dups, 2)
+ + ", Arrays.binarySearch returns " + Arrays.binarySearch(dups, 2)
+ + ", firstOccurrence returns " + BinarySearch.firstOccurrence(dups, 2)
+ + ", lastOccurrence returns " + BinarySearch.lastOccurrence(dups, 2)).blank();
+
+ int[] a = {10, 20, 30, 40, 45};
+ t.line("5. Arrays.binarySearch does not return -1 for \"not found\": it returns -(insertion point) - 1");
+ for (int key : new int[] {25, 5, 50}) {
+ int r = Arrays.binarySearch(a, key);
+ assertEquals(-BinarySearch.insertPosition(a, key) - 1, r);
+ t.line(String.format(" Arrays.binarySearch(%s, %d) = %d (== -1? %b) insertion point = %d",
+ Arrays.toString(a), key, r, r == -1, -r - 1));
+ }
+ t.blank();
+
+ t.line("6. overflow of (lo + hi) / 2: see 03-overflow-mid.txt");
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/RandomAgreementTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/RandomAgreementTest.java
new file mode 100644
index 0000000..38d6395
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/RandomAgreementTest.java
@@ -0,0 +1,165 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Random;
+import org.junit.jupiter.api.Test;
+
+/** Seeded random inputs: every fast solution must agree with its brute-force reference. */
+class RandomAgreementTest {
+ private static final int CASES = 3000;
+ private final Random rnd = new Random(2026);
+ private final Transcript t = Transcript.start("08-random-agreement.txt",
+ "Seeded random cross-check (Random(2026)): fast solution vs brute force");
+
+ private int[] sortedWithDuplicates() {
+ int[] a = new int[rnd.nextInt(16)];
+ for (int i = 0; i < a.length; i++) {
+ a[i] = rnd.nextInt(13) - 2;
+ }
+ Arrays.sort(a);
+ return a;
+ }
+
+ private int[] distinctSorted(int maxLen) {
+ int[] a = new int[1 + rnd.nextInt(maxLen)];
+ int v = rnd.nextInt(5) - 3;
+ for (int i = 0; i < a.length; i++) {
+ v += 1 + rnd.nextInt(4);
+ a[i] = v;
+ }
+ return a;
+ }
+
+ private static int[] rotate(int[] a, int k) {
+ int[] r = new int[a.length];
+ for (int i = 0; i < a.length; i++) {
+ r[i] = a[(i + k) % a.length];
+ }
+ return r;
+ }
+
+ private void report(String name, int cases) {
+ t.line(String.format(Locale.ROOT, "%-58s %,6d cases 0 disagreements", name, cases));
+ }
+
+ @Test
+ void everyProblemAgreesWithBruteForce() {
+ for (int c = 0; c < CASES; c++) {
+ int[] a = sortedWithDuplicates();
+ int key = rnd.nextInt(18) - 3;
+ assertEquals(BruteForce.searchInsert(a, key), BinarySearch.insertPosition(a, key), Arrays.toString(a) + " " + key);
+ int idx = BinarySearch.iterative(a, key);
+ assertEquals(BruteForce.indexOf(a, key) >= 0, idx >= 0);
+ if (idx >= 0) {
+ assertEquals(key, a[idx]);
+ }
+ assertEquals(idx, BinarySearch.recursive(a, key));
+ }
+ report("plain search + insert position (1)", CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int[] a = sortedWithDuplicates();
+ int key = rnd.nextInt(18) - 3;
+ assertArrayEquals(BruteForce.searchRange(a, key), InterviewProblems.searchRange(a, key), Arrays.toString(a) + " " + key);
+ }
+ report("first and last position (2)", CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int[] a = sortedWithDuplicates();
+ int key = rnd.nextInt(18) - 3;
+ assertEquals(BruteForce.count(a, key), BinarySearch.count(a, key), Arrays.toString(a) + " " + key);
+ }
+ report("count occurrences (3)", CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int[] sorted = distinctSorted(14);
+ int[] a = rotate(sorted, rnd.nextInt(sorted.length));
+ int key = sorted[0] - 1 + rnd.nextInt(sorted[sorted.length - 1] - sorted[0] + 3);
+ assertEquals(BruteForce.indexOf(a, key), RotatedArray.search(a, key), Arrays.toString(a) + " " + key);
+ }
+ report("search in rotated array (4)", CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int[] sorted = distinctSorted(14);
+ int[] a = rotate(sorted, rnd.nextInt(sorted.length));
+ assertEquals(BruteForce.minIndex(a), RotatedArray.minIndex(a), Arrays.toString(a));
+ }
+ for (int c = 0; c < CASES; c++) {
+ int[] sorted = new int[1 + rnd.nextInt(14)];
+ for (int i = 0; i < sorted.length; i++) {
+ sorted[i] = rnd.nextInt(4);
+ }
+ Arrays.sort(sorted);
+ int[] a = rotate(sorted, rnd.nextInt(sorted.length));
+ assertEquals(a[BruteForce.minIndex(a)], RotatedArray.minWithDuplicates(a)[0], Arrays.toString(a));
+ }
+ report("minimum of rotated array, distinct + duplicates (5)", 2 * CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int[] a = new int[1 + rnd.nextInt(12)];
+ for (int i = 0; i < a.length; i++) {
+ do {
+ a[i] = rnd.nextInt(10);
+ } while (i > 0 && a[i] == a[i - 1]);
+ }
+ assertTrue(BruteForce.isPeak(a, InterviewProblems.findPeak(a)), Arrays.toString(a));
+ }
+ report("find a peak element (6)", CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int x = rnd.nextInt(100_001);
+ assertEquals(BruteForce.sqrt(x), SearchOnAnswer.sqrt(x), "x=" + x);
+ }
+ for (int c = 0; c < 1000; c++) {
+ int x = Integer.MAX_VALUE - rnd.nextInt(1_000_000);
+ int r = SearchOnAnswer.sqrt(x);
+ assertTrue((long) r * r <= x && (long) (r + 1) * (r + 1) > x, "x=" + x);
+ }
+ report("integer square root, small + near Integer.MAX_VALUE (7)", CASES + 1000);
+
+ for (int c = 0; c < CASES; c++) {
+ int[] piles = new int[1 + rnd.nextInt(5)];
+ int sum = 0;
+ for (int i = 0; i < piles.length; i++) {
+ piles[i] = 1 + rnd.nextInt(12);
+ sum += piles[i];
+ }
+ int h = piles.length + rnd.nextInt(sum - piles.length + 3);
+ assertEquals(BruteForce.minEatingSpeed(piles, h), SearchOnAnswer.minEatingSpeed(piles, h), Arrays.toString(piles) + " h=" + h);
+ }
+ report("koko eating bananas (8)", CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int[] w = new int[1 + rnd.nextInt(8)];
+ for (int i = 0; i < w.length; i++) {
+ w[i] = 1 + rnd.nextInt(10);
+ }
+ int days = 1 + rnd.nextInt(w.length);
+ assertEquals(BruteForce.shipWithinDays(w, days), SearchOnAnswer.shipWithinDays(w, days), Arrays.toString(w) + " days=" + days);
+ }
+ report("ship packages within D days (9)", CASES);
+
+ for (int c = 0; c < CASES; c++) {
+ int rows = 1 + rnd.nextInt(4);
+ int cols = 1 + rnd.nextInt(4);
+ int[][] m = new int[rows][cols];
+ int v = rnd.nextInt(3);
+ for (int r = 0; r < rows; r++) {
+ for (int k = 0; k < cols; k++) {
+ v += 1 + rnd.nextInt(3);
+ m[r][k] = v;
+ }
+ }
+ int target = rnd.nextInt(v + 3) - 1;
+ assertEquals(BruteForce.searchMatrix(m, target), InterviewProblems.searchMatrix(m, target), Arrays.deepToString(m) + " " + target);
+ }
+ report("search a 2D matrix (10)", CASES);
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/RotatedTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/RotatedTest.java
new file mode 100644
index 0000000..e1782e0
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/RotatedTest.java
@@ -0,0 +1,66 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.Locale;
+import org.junit.jupiter.api.Test;
+
+class RotatedTest {
+ static final int[] R = {4, 5, 6, 7, 0, 1, 2};
+
+ @Test
+ void tracesAndExhaustiveCheck() {
+ Transcript t = Transcript.start("05-rotated-array.txt", "Rotated sorted array [4, 5, 6, 7, 0, 1, 2]");
+ for (int key : new int[] {0, 3}) {
+ DryRuns.Run r = DryRuns.rotatedSearch(R, key);
+ assertEquals(RotatedArray.search(R, key), r.result());
+ assertEquals(BruteForce.indexOf(R, key), r.result());
+ t.line("search for " + key);
+ r.lines().forEach(l -> t.line(" " + l));
+ t.blank();
+ }
+ DryRuns.Run m = DryRuns.rotatedMin(R);
+ assertEquals(RotatedArray.minIndex(R), m.result());
+ assertEquals(4, m.result());
+ t.line("find the minimum (the rotation point)");
+ m.lines().forEach(l -> t.line(" " + l));
+ t.blank();
+
+ int checks = 0;
+ for (int n = 1; n <= 12; n++) {
+ for (int k = 0; k < n; k++) {
+ int[] a = new int[n];
+ for (int i = 0; i < n; i++) {
+ a[i] = ((i + k) % n) * 3 + 1; // distinct, rotated by k
+ }
+ assertEquals(BruteForce.minIndex(a), RotatedArray.minIndex(a));
+ for (int key = 0; key <= 3 * n + 2; key++) {
+ assertEquals(BruteForce.indexOf(a, key), RotatedArray.search(a, key));
+ checks++;
+ }
+ }
+ }
+ t.line("exhaustive check, every rotation of every distinct array of length 1..12, every key: " + checks + " searches, 0 disagreements").blank();
+
+ t.line("With duplicates the same idea can degrade to a linear scan (iterations of the find-minimum loop):");
+ for (int n : new int[] {16, 256, 4096}) {
+ int[] dup = new int[n];
+ java.util.Arrays.fill(dup, 1);
+ dup[1] = 0; // [1, 0, 1, 1, ..., 1]
+ int[] distinct = new int[n];
+ for (int i = 0; i < n; i++) {
+ distinct[i] = (i + n - 1) % n; // minimum also at index 1
+ }
+ int[] d = RotatedArray.minWithDuplicates(dup);
+ int distinctIterations = DryRuns.rotatedMin(distinct).probes();
+ assertEquals(0, d[0]);
+ assertTrue(d[1] >= n / 2, "duplicates should force a near-linear scan");
+ assertTrue(distinctIterations <= 13);
+ t.line(String.format(Locale.ROOT, " n=%5d minimum at index 1: distinct values %2d iterations many duplicates %5d iterations",
+ n, distinctIterations, d[1]));
+ }
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/SearchOnAnswerTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/SearchOnAnswerTest.java
new file mode 100644
index 0000000..eac67c2
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/SearchOnAnswerTest.java
@@ -0,0 +1,86 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.Locale;
+import org.junit.jupiter.api.Test;
+
+class SearchOnAnswerTest {
+ @Test
+ void sqrtKokoAndShipsWithPredicateCounts() {
+ Transcript t = Transcript.start("06-search-on-answer.txt",
+ "Binary search on the answer: how many times the yes/no question was asked");
+
+ t.line("Integer square root = largest m with m*m <= x; the question is \"is m*m > x?\"");
+ for (int x : new int[] {8, 16, 1_000_000_007, Integer.MAX_VALUE}) {
+ long[] calls = {0};
+ int r = SearchOnAnswer.sqrt(x, m -> {
+ calls[0]++;
+ return m * m > x;
+ });
+ assertEquals(SearchOnAnswer.sqrt(x), r);
+ assertEquals(BruteForce.sqrt(x), r);
+ assertEquals((int) Math.sqrt(x), r);
+ t.line(String.format(Locale.ROOT, " sqrt(%,d) = %d asked %d times, instead of trying up to %,d candidates",
+ x, r, calls[0], (long) x + 1));
+ }
+ t.blank();
+
+ t.line("Koko eating bananas: smallest speed k with sum(ceil(pile / k)) <= h");
+ int[][] pileSets = {{3, 6, 7, 11}, {30, 11, 23, 4, 20}, {30, 11, 23, 4, 20}};
+ int[] hs = {8, 5, 6};
+ for (int i = 0; i < pileSets.length; i++) {
+ int[] piles = pileSets[i];
+ int h = hs[i];
+ long[] calls = {0};
+ int r = SearchOnAnswer.minEatingSpeed(piles, h, k -> {
+ calls[0]++;
+ return SearchOnAnswer.hoursNeeded(piles, k) <= h;
+ });
+ assertEquals(BruteForce.minEatingSpeed(piles, h), r);
+ t.line(String.format(Locale.ROOT, " piles=%s h=%d -> speed %d asked %d times (candidates 1..%d)",
+ java.util.Arrays.toString(piles), h, r, calls[0], java.util.Arrays.stream(piles).max().getAsInt()));
+ }
+ int[] demo = {3, 6, 7, 11};
+ StringBuilder hoursRow = new StringBuilder();
+ StringBuilder okRow = new StringBuilder();
+ for (int k = 1; k <= 11; k++) {
+ long hrs = SearchOnAnswer.hoursNeeded(demo, k);
+ hoursRow.append(hrs).append(k < 11 ? ", " : "");
+ okRow.append(hrs <= 8 ? "T" : "F").append(k < 11 ? " " : "");
+ }
+ assertEquals("F F F T T T T T T T T", okRow.toString());
+ t.line(" for [3, 6, 7, 11], hours needed at speed 1..11: " + hoursRow);
+ t.line(" is that <= 8? " + okRow);
+ int[] big = {1_000_000_000, 999_999_999, 500_000_000};
+ long[] calls = {0};
+ int h = 10;
+ int speed = SearchOnAnswer.minEatingSpeed(big, h, k -> {
+ calls[0]++;
+ return SearchOnAnswer.hoursNeeded(big, k) <= h;
+ });
+ assertTrue(SearchOnAnswer.hoursNeeded(big, speed) <= h);
+ assertFalse(SearchOnAnswer.hoursNeeded(big, speed - 1) <= h);
+ t.line(String.format(Locale.ROOT,
+ " piles=%s h=%d -> speed %,d asked %d times (candidates 1..1,000,000,000); checked: speed-1 needs %d hours",
+ java.util.Arrays.toString(big), h, speed, calls[0], SearchOnAnswer.hoursNeeded(big, speed - 1)));
+ t.blank();
+
+ t.line("Ship packages within D days: smallest capacity so that, loading in order, D days are enough");
+ int[] weights = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ long[] shipCalls = {0};
+ int cap = SearchOnAnswer.shipWithinDays(weights, 5, c -> {
+ shipCalls[0]++;
+ return SearchOnAnswer.daysNeeded(weights, c) <= 5;
+ });
+ assertEquals(BruteForce.shipWithinDays(weights, 5), cap);
+ t.line(String.format(Locale.ROOT, " weights=%s days=5 -> capacity %d asked %d times (candidates 10..55)",
+ java.util.Arrays.toString(weights), cap, shipCalls[0]));
+ t.line(" days needed at capacity " + cap + ": " + SearchOnAnswer.daysNeeded(weights, cap)
+ + "; at capacity " + (cap - 1) + ": " + SearchOnAnswer.daysNeeded(weights, cap - 1));
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/TenProblemsTest.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/TenProblemsTest.java
new file mode 100644
index 0000000..0884082
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/TenProblemsTest.java
@@ -0,0 +1,82 @@
+package com.ankurm.interviewlab.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.ankurm.interviewlab.binarysearch.support.Transcript;
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class TenProblemsTest {
+ private static String row(int n, String name, String input, Object fast, Object brute) {
+ return String.format("%2d. %-30s %-44s fast=%-10s brute-force=%s", n, name, input, fast, brute);
+ }
+
+ @Test
+ void oneExampleEach() {
+ Transcript t = Transcript.start("07-ten-problems.txt", "Ten interview problems: fast answer beside the brute-force answer");
+
+ int[] ins = {1, 3, 5, 6};
+ for (int[] c : new int[][] {{5, 2}, {2, 1}, {7, 4}, {0, 0}}) {
+ assertEquals(c[1], BinarySearch.insertPosition(ins, c[0]));
+ assertEquals(c[1], BruteForce.searchInsert(ins, c[0]));
+ t.line(row(1, "search insert position", Arrays.toString(ins) + " key=" + c[0],
+ BinarySearch.insertPosition(ins, c[0]), BruteForce.searchInsert(ins, c[0])));
+ }
+
+ int[] rng = {5, 7, 7, 8, 8, 10};
+ for (int key : new int[] {8, 6}) {
+ assertArrayEquals(BruteForce.searchRange(rng, key), InterviewProblems.searchRange(rng, key));
+ t.line(row(2, "first and last position", Arrays.toString(rng) + " key=" + key,
+ Arrays.toString(InterviewProblems.searchRange(rng, key)),
+ Arrays.toString(BruteForce.searchRange(rng, key))));
+ }
+
+ int[] dups = {1, 2, 2, 2, 2, 2, 3};
+ assertEquals(5, BinarySearch.count(dups, 2));
+ t.line(row(3, "count occurrences", Arrays.toString(dups) + " key=2",
+ BinarySearch.count(dups, 2), BruteForce.count(dups, 2)));
+
+ int[] rot = {4, 5, 6, 7, 0, 1, 2};
+ for (int key : new int[] {0, 3}) {
+ assertEquals(BruteForce.indexOf(rot, key), RotatedArray.search(rot, key));
+ t.line(row(4, "search in rotated array", Arrays.toString(rot) + " key=" + key,
+ RotatedArray.search(rot, key), BruteForce.indexOf(rot, key)));
+ }
+
+ int[] rot2 = {3, 4, 5, 1, 2};
+ assertEquals(3, RotatedArray.minIndex(rot2));
+ t.line(row(5, "minimum of rotated array", Arrays.toString(rot2) + " (index of min)",
+ RotatedArray.minIndex(rot2), BruteForce.minIndex(rot2)));
+
+ int[] peaks = {1, 2, 1, 3, 5, 6, 4};
+ int p = InterviewProblems.findPeak(peaks);
+ assertTrue(BruteForce.isPeak(peaks, p));
+ t.line(row(6, "find a peak element", Arrays.toString(peaks) + " (any peak is valid)",
+ p, "peaks at 1 and 5, " + p + " is a peak: " + BruteForce.isPeak(peaks, p)));
+
+ for (int x : new int[] {4, 8}) {
+ assertEquals(BruteForce.sqrt(x), SearchOnAnswer.sqrt(x));
+ t.line(row(7, "integer square root", "x=" + x, SearchOnAnswer.sqrt(x), BruteForce.sqrt(x)));
+ }
+
+ int[] piles = {3, 6, 7, 11};
+ assertEquals(4, SearchOnAnswer.minEatingSpeed(piles, 8));
+ t.line(row(8, "koko eating bananas", Arrays.toString(piles) + " h=8",
+ SearchOnAnswer.minEatingSpeed(piles, 8), BruteForce.minEatingSpeed(piles, 8)));
+
+ int[] w = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ assertEquals(15, SearchOnAnswer.shipWithinDays(w, 5));
+ t.line(row(9, "ship packages within D days", "weights 1..10 days=5",
+ SearchOnAnswer.shipWithinDays(w, 5), BruteForce.shipWithinDays(w, 5)));
+
+ int[][] m = {{1, 3, 5, 7}, {10, 11, 16, 20}, {23, 30, 34, 60}};
+ for (int target : new int[] {3, 13}) {
+ assertEquals(BruteForce.searchMatrix(m, target), InterviewProblems.searchMatrix(m, target));
+ t.line(row(10, "search a 2D matrix", "3x4 matrix target=" + target,
+ InterviewProblems.searchMatrix(m, target), BruteForce.searchMatrix(m, target)));
+ }
+ t.flush();
+ }
+}
diff --git a/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/support/Transcript.java b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/support/Transcript.java
new file mode 100644
index 0000000..740a0db
--- /dev/null
+++ b/binary-search/src/test/java/com/ankurm/interviewlab/binarysearch/support/Transcript.java
@@ -0,0 +1,43 @@
+package com.ankurm.interviewlab.binarysearch.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 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);
+ }
+ }
+}