add pair instruction and examples

gcziprusz · gcziprusz · commit 1a410ea9dbb5 · 2025-09-04T11:45:26.000-05:00
diff --git a/src/chapters/combining-patterns/9b8a8427.js b/src/chapters/combining-patterns/9b8a8427.js
@@ -10,6 +10,12 @@ export const codeExcerciseOneChapter = {
 
 **Navigate:** 1 | [2](a4b7c9d2) | [3](e8f1a5b3) | [4](c6d9e2f4) | [5](b3a8d7c1) | [6](f9e4b2a7) | [7](d1c5f8e3) | [8](a7b2e9f6) | [9](c4f7a1d8)
 
+## 👥 Pair Programming Instructions
+
+**Work in pairs for this challenge!** One person should be the **Driver** (writing code) and the other the **Navigator** (reviewing and guiding). **Switch roles for each function** you implement.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/jqGmL6Hf23k?si=qXmQcnQigfo1adTb" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
 **Why it matters:** Arrays are the workhorse. Mastering iteration and index-based edits builds intuition for time complexity.
 
 **Objectives:**
@@ -22,8 +28,16 @@ export const codeExcerciseOneChapter = {
 ## Problems to Solve:
 
 1. **sumOfSquares(nums)** - Return the sum of x² for each x in nums (no Array.prototype.map)
+   - Example: \`sumOfSquares([1, 2, 3])\` → \`14\` (1² + 2² + 3² = 1 + 4 + 9 = 14)
+   - Example: \`sumOfSquares([2, 4])\` → \`20\` (2² + 4² = 4 + 16 = 20)
+
 2. **insertAt(arr, index, value)** - Return NEW array with value inserted at index
+   - Example: \`insertAt([10, 20, 30], 1, 99)\` → \`[10, 99, 20, 30]\`
+   - Example: \`insertAt([], 0, 'a')\` → \`['a']\`
+
 3. **removeAt(arr, index)** - Return NEW array without the element at index
+   - Example: \`removeAt([10, 20, 30], 1)\` → \`[10, 30]\`
+   - Example: \`removeAt([5], 0)\` → \`[]\`
 
 ## Big-O Analysis:
 - **insertAt/removeAt are O(n)**: They require shifting elements to maintain array structure
@@ -80,6 +94,9 @@ function insertAt(arr, index, value) {
 
 function removeAt(arr, index) {
   // returns NEW array without the element at index
+  if (index < 0 || index >= arr.length) {
+    return [...arr]; // Return a new array that is a copy of the original
+  }
   return [...arr.slice(0, index), ...arr.slice(index + 1)];
 }
 
@@ -93,8 +110,8 @@ function removeAt(arr, index) {
         name: "sumOfSquares calculates correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { sumOfSquares, insertAt, removeAt };`)();
-            const result = func.sumOfSquares([1, 2, 3]);
+            const sumOfSquares = new Function(`${code}; \n return sumOfSquares;`)();
+            const result = sumOfSquares([1, 2, 3]);
             if (result === 14) {
               return new TestResult({ passed: true });
             } else {
@@ -116,9 +133,9 @@ function removeAt(arr, index) {
         name: "insertAt works correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { sumOfSquares, insertAt, removeAt };`)();
-            const result1 = func.insertAt([10, 20, 30], 1, 99);
-            const result2 = func.insertAt([], 0, 'a');
+            const insertAt = new Function(`${code};  \n return insertAt;`)();
+            const result1 = insertAt([10, 20, 30], 1, 99);
+            const result2 = insertAt([], 0, 'a');
             
             const test1 = JSON.stringify(result1) === JSON.stringify([10, 99, 20, 30]);
             const test2 = JSON.stringify(result2) === JSON.stringify(['a']);
@@ -144,8 +161,8 @@ function removeAt(arr, index) {
         name: "removeAt works correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { sumOfSquares, insertAt, removeAt };`)();
-            const result = func.removeAt([10, 20, 30], 1);
+            const removeAt = new Function(`${code}; \n return removeAt;`)();
+            const result = removeAt([10, 20, 30], 1);
             
             if (JSON.stringify(result) === JSON.stringify([10, 30])) {
               return new TestResult({ passed: true });
diff --git a/src/chapters/combining-patterns/a4b7c9d2.js b/src/chapters/combining-patterns/a4b7c9d2.js
@@ -10,6 +10,12 @@ export const codeExcerciseTwoChapter = {
 
 **Navigate:** [1](9b8a8427) | 2 | [3](e8f1a5b3) | [4](c6d9e2f4) | [5](b3a8d7c1) | [6](f9e4b2a7) | [7](d1c5f8e3) | [8](a7b2e9f6) | [9](c4f7a1d8)
 
+## 👥 Pair Programming Instructions
+
+**Work in pairs for this challenge!** One person should be the **Driver** (writing code) and the other the **Navigator** (reviewing and guiding). **Switch roles for each function** you implement.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/jqGmL6Hf23k?si=qXmQcnQigfo1adTb" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
 **Why it matters:** Grid problems are everywhere (games, pathfinding, image processing). Neighbor logic is foundational.
 
 **Objectives:**
@@ -21,7 +27,12 @@ export const codeExcerciseTwoChapter = {
 ## Problems to Solve:
 
 1. **countNeighbors(grid, r, c, target)** - Count 8-direction neighbors that match a target value
+   - Example: \`countNeighbors([[1,1,0],[0,1,0],[0,0,1]], 0, 0, 1)\` → \`2\` (neighbors at (0,1) and (1,1))
+   - Example: \`countNeighbors([[1,0],[0,1]], 1, 1, 0)\` → \`2\` (neighbors at (0,1) and (1,0))
+
 2. **neighborCountGrid(grid, target)** - For each cell, set it to the number of matching neighbors (new grid)
+   - Example: \`neighborCountGrid([[1,0],[0,1]], 1)\` → \`[[1,2],[2,1]]\`
+   - Example: \`neighborCountGrid([[0,0],[0,0]], 1)\` → \`[[0,0],[0,0]]\`
 
 ## Big-O Analysis:
 - **Runtime: O(R*C)** since each cell looks at constant 8 neighbors
@@ -99,7 +110,7 @@ function neighborCountGrid(grid, target) {
         name: "countNeighbors works correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { countNeighbors, neighborCountGrid };`)();
+            const func = new Function(`${code}; \n return { countNeighbors, neighborCountGrid };`)();
             const g = [
               [1,1,0],
               [0,1,0],
@@ -128,7 +139,7 @@ function neighborCountGrid(grid, target) {
         name: "neighborCountGrid works correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { countNeighbors, neighborCountGrid };`)();
+            const func = new Function(`${code}; \n return { countNeighbors, neighborCountGrid };`)();
             const result = func.neighborCountGrid([[1,0],[0,1]], 1);
             const expected = [[1,2],[2,1]];
             
@@ -153,7 +164,7 @@ function neighborCountGrid(grid, target) {
         name: "Handles edge cases",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { countNeighbors, neighborCountGrid };`)();
+            const func = new Function(`${code}; \n return { countNeighbors, neighborCountGrid };`)();
             
             // Single cell grid
             const result1 = func.countNeighbors([[1]], 0, 0, 1);
diff --git a/src/chapters/combining-patterns/a7b2e9f6.js b/src/chapters/combining-patterns/a7b2e9f6.js
@@ -10,6 +10,12 @@ export const codeExcerciseEightChapter = {
 
 **Navigate:** [1](9b8a8427) | [2](a4b7c9d2) | [3](e8f1a5b3) | [4](c6d9e2f4) | [5](b3a8d7c1) | [6](f9e4b2a7) | [7](d1c5f8e3) | 8 | [9](c4f7a1d8)
 
+## 👥 Pair Programming Instructions
+
+**Work in pairs for this challenge!** One person should be the **Driver** (writing code) and the other the **Navigator** (reviewing and guiding). **Switch roles for each function** you implement.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/jqGmL6Hf23k?si=qXmQcnQigfo1adTb" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
 **Why it matters:** Real work is often sorting records by one or more fields.
 
 **Objectives:**
@@ -26,6 +32,13 @@ export const codeExcerciseEightChapter = {
 
 Task object format: \`{id: number, title: string, priority: number, due: string}\`
 
+**Examples:**
+   - Input: \`[{id:1, priority:2, due:'2025-09-10'}, {id:2, priority:1, due:'2025-09-15'}]\`
+   - Output: \`[{id:2, priority:1, due:'2025-09-15'}, {id:1, priority:2, due:'2025-09-10'}]\` (priority 1 first)
+   
+   - Input: \`[{id:3, priority:1, due:'2025-09-01'}, {id:4, priority:1, due:'2025-08-31'}]\`
+   - Output: \`[{id:4, priority:1, due:'2025-08-31'}, {id:3, priority:1, due:'2025-09-01'}]\` (earlier date first)
+
 ## Algorithm:
 1. Use Array.sort() with custom comparator
 2. First compare by priority
@@ -89,7 +102,7 @@ function sortTasks(tasks){
         name: "sortTasks works correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return sortTasks;`)();
+            const func = new Function(`${code}; \n return sortTasks;`)();
             
             const tasks = [
               {id:1, title:'a', priority:2, due:'2025-09-10'},
@@ -122,7 +135,7 @@ function sortTasks(tasks){
         name: "Does not mutate original array",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return sortTasks;`)();
+            const func = new Function(`${code}; \n return sortTasks;`)();
             
             const tasks = [
               {id:1, title:'a', priority:2, due:'2025-09-10'},
@@ -157,7 +170,7 @@ function sortTasks(tasks){
         name: "Handles edge cases",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return sortTasks;`)();
+            const func = new Function(`${code}; \n return sortTasks;`)();
             
             // Empty array
             const result1 = func([]);
diff --git a/src/chapters/combining-patterns/b3a8d7c1.js b/src/chapters/combining-patterns/b3a8d7c1.js
@@ -10,6 +10,12 @@ export const codeExcerciseFiveChapter = {
 
 **Navigate:** [1](9b8a8427) | [2](a4b7c9d2) | [3](e8f1a5b3) | [4](c6d9e2f4) | 5 | [6](f9e4b2a7) | [7](d1c5f8e3) | [8](a7b2e9f6) | [9](c4f7a1d8)
 
+## 👥 Pair Programming Instructions
+
+**Work in pairs for this challenge!** One person should be the **Driver** (writing code) and the other the **Navigator** (reviewing and guiding). **Switch roles for each function** you implement.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/jqGmL6Hf23k?si=qXmQcnQigfo1adTb" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
 **Why it matters:** Hash-based structures unlock O(1) average lookups and fast membership tests.
 
 **Objectives:**
@@ -21,7 +27,14 @@ export const codeExcerciseFiveChapter = {
 ## Problems to Solve:
 
 1. **wordCount(text)** - Return a Map of word → count (case-insensitive, letters only)
+   - Example: \`wordCount('One fish two fish')\` → Map{'one' => 1, 'fish' => 2, 'two' => 1}
+   - Example: \`wordCount('Hello, World!')\` → Map{'hello' => 1, 'world' => 1}
+   - Example: \`wordCount('123 !@#')\` → Map{} (no letters)
+
 2. **hasDuplicate(arr)** - Return true if array has any duplicate value (use Set)
+   - Example: \`hasDuplicate([1, 2, 3, 2])\` → \`true\` (2 appears twice)
+   - Example: \`hasDuplicate([1, 2, 3])\` → \`false\` (all unique)
+   - Example: \`hasDuplicate([])\` → \`false\` (empty array)
 
 ## Big-O Analysis:
 - **Average O(1)** for Map/Set operations (.get/.set/.has)
@@ -90,7 +103,7 @@ function hasDuplicate(arr) {
         name: "wordCount works correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { wordCount, hasDuplicate };`)();
+            const func = new Function(`${code}; \n return { wordCount, hasDuplicate };`)();
             const wc = func.wordCount('One fish two fish, red fish blue fish.');
             
             const fishCount = wc.get('fish');
@@ -117,7 +130,7 @@ function hasDuplicate(arr) {
         name: "hasDuplicate detects duplicates",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { wordCount, hasDuplicate };`)();
+            const func = new Function(`${code}; \n return { wordCount, hasDuplicate };`)();
             
             const result1 = func.hasDuplicate([1, 2, 3, 2]);
             const result2 = func.hasDuplicate([1, 2, 3]);
@@ -143,7 +156,7 @@ function hasDuplicate(arr) {
         name: "Handles edge cases",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return { wordCount, hasDuplicate };`)();
+            const func = new Function(`${code}; \n return { wordCount, hasDuplicate };`)();
             
             // Empty text
             const wc1 = func.wordCount('');
diff --git a/src/chapters/combining-patterns/c4f7a1d8.js b/src/chapters/combining-patterns/c4f7a1d8.js
@@ -10,6 +10,12 @@ export const codeExcerciseNineChapter = {
 
 **Navigate:** [1](9b8a8427) | [2](a4b7c9d2) | [3](e8f1a5b3) | [4](c6d9e2f4) | [5](b3a8d7c1) | [6](f9e4b2a7) | [7](d1c5f8e3) | [8](a7b2e9f6) | 9
 
+## 👥 Pair Programming Instructions
+
+**Work in pairs for this challenge!** One person should be the **Driver** (writing code) and the other the **Navigator** (reviewing and guiding). **Switch roles for each function** you implement.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/jqGmL6Hf23k?si=qXmQcnQigfo1adTb" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
 **Why it matters:** Sliding window replaces nested loops when aggregating over contiguous spans.
 
 **Objectives:**
@@ -22,6 +28,13 @@ export const codeExcerciseNineChapter = {
 
 **maxSumOfSizeK(nums, k)** - Return the maximum sum of any contiguous subarray of length k
 
+**Examples:**
+   - \`maxSumOfSizeK([2,1,5,1,3,2], 3)\` → \`9\` (subarray [5,1,3] = 5+1+3 = 9)
+   - \`maxSumOfSizeK([2,3,4,1,5], 2)\` → \`7\` (subarray [3,4] = 3+4 = 7)
+   - \`maxSumOfSizeK([1], 1)\` → \`1\` (single element)
+   - \`maxSumOfSizeK([1,2], 3)\` → \`null\` (k > array length)
+   - \`maxSumOfSizeK([-1,-2,-3,-4], 2)\` → \`-3\` (subarray [-1,-2] = -1+(-2) = -3)
+
 ## Algorithm:
 1. Calculate sum of first k elements (initial window)
 2. Slide the window: add next element, remove first element
@@ -94,7 +107,7 @@ function maxSumOfSizeK(nums, k){
         name: "maxSumOfSizeK works correctly",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return maxSumOfSizeK;`)();
+            const func = new Function(`${code}; \n return maxSumOfSizeK;`)();
             
             const result1 = func([2,1,5,1,3,2], 3); // 5+1+3 = 9
             const result2 = func([2,3,4,1,5], 2);   // 3+4 = 7
@@ -121,7 +134,7 @@ function maxSumOfSizeK(nums, k){
         name: "Handles edge cases",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return maxSumOfSizeK;`)();
+            const func = new Function(`${code}; \n return maxSumOfSizeK;`)();
             
             const result1 = func([1,2], 3);    // k > length
             const result2 = func([], 1);       // empty array
@@ -148,7 +161,7 @@ function maxSumOfSizeK(nums, k){
         name: "Works with negative numbers",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return maxSumOfSizeK;`)();
+            const func = new Function(`${code}; \n return maxSumOfSizeK;`)();
             
             const result1 = func([-1, -2, -3, -4], 2); // max of [-1,-2], [-2,-3], [-3,-4] = -3
             const result2 = func([1, -1, 0, 2], 2);    // max of [1,-1], [-1,0], [0,2] = 2
diff --git a/src/chapters/combining-patterns/c6d9e2f4.js b/src/chapters/combining-patterns/c6d9e2f4.js
@@ -10,6 +10,12 @@ export const codeExcerciseFourChapter = {
 
 **Navigate:** [1](9b8a8427) | [2](a4b7c9d2) | [3](e8f1a5b3) | 4 | [5](b3a8d7c1) | [6](f9e4b2a7) | [7](d1c5f8e3) | [8](a7b2e9f6) | [9](c4f7a1d8)
 
+## 👥 Pair Programming Instructions
+
+**Work in pairs for this challenge!** One person should be the **Driver** (writing code) and the other the **Navigator** (reviewing and guiding). **Switch roles for each function** you implement.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/jqGmL6Hf23k?si=qXmQcnQigfo1adTb" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
 **Why it matters:** Two pointers converts nested loops to linear time when data is ordered.
 
 **Objectives:**
@@ -21,6 +27,10 @@ export const codeExcerciseFourChapter = {
 ## Problem to Solve:
 
 **hasPairWithSum(sortedNums, target)** - Given a sorted array and target, return true if any pair sums to target
+   - Example: \`hasPairWithSum([1, 2, 4, 4], 8)\` → \`true\` (4 + 4 = 8)
+   - Example: \`hasPairWithSum([1, 2, 3, 9], 8)\` → \`false\` (no pair sums to 8)
+   - Example: \`hasPairWithSum([1, 2], 3)\` → \`true\` (1 + 2 = 3)
+   - Example: \`hasPairWithSum([5], 5)\` → \`false\` (single element, no pair)
 
 ## Algorithm:
 1. Use two pointers: left at start, right at end
@@ -85,7 +95,7 @@ function hasPairWithSum(sortedNums, target) {
         name: "Finds pair that sums to target",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return hasPairWithSum;`)();
+            const func = new Function(`${code}; \n return hasPairWithSum;`)();
             const result = func([1, 2, 4, 4], 8);
             
             if (result === true) {
@@ -109,7 +119,7 @@ function hasPairWithSum(sortedNums, target) {
         name: "Returns false when no pair exists",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return hasPairWithSum;`)();
+            const func = new Function(`${code}; \n return hasPairWithSum;`)();
             const result = func([1, 2, 3, 9], 8);
             
             if (result === false) {
@@ -133,7 +143,7 @@ function hasPairWithSum(sortedNums, target) {
         name: "Handles edge cases",
         test: (code) => {
           try {
-            const func = new Function(`${code}; return hasPairWithSum;`)();
+            const func = new Function(`${code}; \n return hasPairWithSum;`)();
             
             const result1 = func([], 5); // Empty array
             const result2 = func([5], 5); // Single element
diff --git a/src/chapters/combining-patterns/d1c5f8e3.js b/src/chapters/combining-patterns/d1c5f8e3.js
diff --git a/src/chapters/combining-patterns/e8f1a5b3.js b/src/chapters/combining-patterns/e8f1a5b3.js
diff --git a/src/chapters/combining-patterns/f9e4b2a7.js b/src/chapters/combining-patterns/f9e4b2a7.js
