Write-up for problem 2677. Chunk Array (#401)

Author: miorel

workspaces/javascript-leetcode-month/README.md

@@ -6,7 +6,7 @@ This directory contains the resources for the month of JavaScript on LeetCode, a
 
 1. [2703. Return Length of Arguments Passed](problems/2703-return-length-of-arguments-passed/)
 2. [2727. Is Object Empty](problems/2727-is-object-empty/)
-3. [2677. Chunk Array](https://leetcode.com/problems/chunk-array/)
+3. [2677. Chunk Array](problems/2677-chunk-array/)
 4. [2635. Apply Transform Over Each Element in Array](https://leetcode.com/problems/apply-transform-over-each-element-in-array/)
 5. [2634. Filter Elements from Array](https://leetcode.com/problems/filter-elements-from-array/)
 6. [2724. Sort By](https://leetcode.com/problems/sort-by/)

workspaces/javascript-leetcode-month/problems/2677-chunk-array/README.md

@@ -0,0 +1,9 @@
+# 2677. Chunk Array
+
+[View Problem on LeetCode](https://leetcode.com/problems/chunk-array/)
+
+Although the problem asks us not to use [`_.chunk`](https://lodash.com/docs/#chunk), I think there's no harm in using it to get a quick accept, as long as we then follow up with another strategy.
+
+As far as manual implementations, the choice is likely between traversing the input one element at a time, or grabbing a larger _slice_ of input at once. Both approaches are viable and can result in an efficient solution.
+
+Once you've worked on the problem, check out [the full write-up and solution](solution.md)!

workspaces/javascript-leetcode-month/problems/2677-chunk-array/solution.md

@@ -0,0 +1,9 @@
+function chunk<T>(arr: readonly T[], size: number): T[][] {
+  const res: T[][] = [];
+
+  for (let i = 0; i < arr.length; i += size) {
+    res.push(arr.slice(i, i + size));
+  }
+
+  return res;
+}

workspaces/javascript-leetcode-month/problems/2677-chunk-array/solutions/grabbing-slices/using-built-in-slice.ts

@@ -0,0 +1,22 @@
+function* generateSlice<T>(
+  arr: readonly T[],
+  start: number,
+  size: number,
+): Generator<T, void, void> {
+  for (let i = start; size > 0 && i < arr.length; ++i, --size) {
+    yield arr[i];
+  }
+}
+
+function* generateChunks<T>(
+  arr: readonly T[],
+  size: number,
+): Generator<T[], void, void> {
+  for (let i = 0; i < arr.length; i += size) {
+    yield Array.from(generateSlice(arr, i, size));
+  }
+}
+
+function chunk<T>(arr: readonly T[], size: number): T[][] {
+  return Array.from(generateChunks(arr, size));
+}

workspaces/javascript-leetcode-month/problems/2677-chunk-array/solutions/grabbing-slices/using-generators.ts

@@ -0,0 +1,19 @@
+function slice<T>(arr: readonly T[], start: number, end: number): T[] {
+  const res: T[] = [];
+
+  for (let i = start; i < end && i < arr.length; ++i) {
+    res.push(arr[i]);
+  }
+
+  return res;
+}
+
+function chunk<T>(arr: readonly T[], size: number): T[][] {
+  const res: T[][] = [];
+
+  for (let i = 0; i < arr.length; i += size) {
+    res.push(slice(arr, i, i + size));
+  }
+
+  return res;
+}

workspaces/javascript-leetcode-month/problems/2677-chunk-array/solutions/grabbing-slices/using-hand-rolled-slice-with-start-and-end.ts

@@ -0,0 +1,19 @@
+function slice<T>(arr: readonly T[], start: number, size: number): T[] {
+  const res: T[] = [];
+
+  for (let i = start; res.length < size && i < arr.length; ++i) {
+    res.push(arr[i]);
+  }
+
+  return res;
+}
+
+function chunk<T>(arr: readonly T[], size: number): T[][] {
+  const res: T[][] = [];
+
+  for (let i = 0; i < arr.length; i += size) {
+    res.push(slice(arr, i, size));
+  }
+
+  return res;
+}

workspaces/javascript-leetcode-month/problems/2677-chunk-array/solutions/grabbing-slices/using-hand-rolled-slice-with-start-and-size.ts

@@ -0,0 +1,17 @@
+function chunk<T>(arr: readonly T[], size: number): T[][] {
+  const res: T[][] = [];
+
+  for (let i = 0; i < arr.length; ++i) {
+    // New chunks start at indexes divisible by `size`.
+    if (i % size === 0) {
+      res.push([]);
+    }
+
+    // We can be certain that `res` is not empty because we'll add something
+    // to `res` during the very first iteration, when `i` is 0.
+    const lastChunk = res.at(-1)!;
+    lastChunk.push(arr[i]);
+  }
+
+  return res;
+}

workspaces/javascript-leetcode-month/problems/2677-chunk-array/solutions/processing-individual-elements/iterating-by-index.ts

@@ -0,0 +1,15 @@
+function chunk<T>(arr: readonly T[], size: number): T[][] {
+  const res: T[][] = [];
+
+  for (const element of arr) {
+    // If there's no last chunk, or if the last chunk is full, start a new
+    // chunk.
+    if (res.length === 0 || res.at(-1)!.length === size) {
+      res.push([]);
+    }
+
+    res.at(-1)!.push(element);
+  }
+
+  return res;
+}

workspaces/javascript-leetcode-month/problems/2677-chunk-array/solutions/processing-individual-elements/iterating-over-elements.ts

@@ -0,0 +1,14 @@
+function chunk<T>(arr: readonly T[], size: number): T[][] {
+  const res: T[][] = [];
+
+  for (const [index, element] of arr.entries()) {
+    // New chunks start at indexes divisible by `size`.
+    if (index % size === 0) {
+      res.push([]);
+    }
+
+    res.at(-1)!.push(element);
+  }
+
+  return res;
+}