learn: solve Longest Increasing Subsequence (#300) via guided TDD

[pertrai1]

Problem

Longest Increasing Subsequence — Medium

Approach

1D bottom-up DP: initialize dp[i] = 1 for all i, then for each index i scan all j < i — if nums[j] < nums[i], update dp[i] = max(dp[i], dp[j] + 1). Return the maximum value in dp.

Complexity

• Time: O(n²) — triangular scan: for each of n elements, look back at up to i predecessors
• Space: O(n) — dp array of length n

Pattern

1D Dynamic Programming (bottom-up tabulation)

Learning Summary

• Mode: Coach (learner wrote all implementation code)
• Cycles: 6 guided cycles
• Tests: 6 test cases
• Hint Levels Used: None — implementation required no hints; one L1 checkpoint clarification on invariant definition
• Key Insight: Every element starts as a valid length-1 subsequence (dp[i] = 1). For each i, look back at all j < i where nums[j] < nums[i] and take the best extension: dp[i] = max(dp[i], dp[j] + 1). The answer is the max across all dp[i].
• Pattern Checkpoints: 1/1 PASS (correct after two follow-up questions on invariant precision)

🧠 Self-Review Questions

1. Why does initializing dp[i] = 1 for all i satisfy the base case?

Answer

Every single element is itself a valid strictly increasing subsequence of length 1. There is no prerequisite — even a single number qualifies. So before looking at any predecessor, dp[i] = 1 is always correct.

2. What would break if the condition were nums[j] <= nums[i] instead of nums[j] < nums[i]?

Answer

The problem requires a *strictly* increasing subsequence. Allowing equal elements (<=) would count [1,1,1] as a length-3 LIS, but the correct answer is 1. The strict inequality gate is what makes the all-identical-elements edge case return 1.

Files

• README.md — Problem statement
• longest-increasing-subsequence.ts — Solution
• longest-increasing-subsequence.test.ts — Test suite (6 cases)
• POST_MORTEM.md — Interview debrief

Summary by CodeRabbit

• New Features

  • Added solution for LeetCode Problem 300 – Longest Increasing Subsequence.

• Documentation

  • Added detailed problem documentation with examples, explanations, and constraints.
  • Added comprehensive interview debrief documenting session insights and assessment feedback.
  • Updated problem index to include the new problem.

• Tests

  • Added test suite covering standard cases and edge cases.

[pertrai1]

💡 Educational Note — The base case is the whole key

const dp: number[] = new Array(length).fill(1);

This single line embeds the most important invariant of the algorithm: every element is a valid increasing subsequence of length 1 on its own. Initializing to 1 (not 0) means we never have to special-case the single-element scenario — the recurrence in the inner loop can only increase dp[i], never decrease it. If no valid predecessor j exists (e.g. a fully descending array), the value stays at 1 — which is exactly right.

Why it matters for interviews: Candidates who initialize to 0 often get tripped up by the all-same or descending cases. Recognizing that 1 is the correct base case comes from understanding the DP state: dp[i] = length of LIS ending at index i, and every element ends an LIS of at least length 1.

[github-actions]

Claude encountered an error —— View job

---

I'll analyze this and get back to you.

[pertrai1]

💡 Educational Note — The recurrence in two lines

if (nums[j] < nums[i]) {
  dp[i] = Math.max(dp[i], dp[j] + 1);
}

These two lines are the entire algorithm. The condition nums[j] < nums[i] enforces strict increase — if you change it to <=, the all-identical-elements case breaks immediately. The Math.max ensures dp[i] always holds the best extension found so far across all valid predecessors j.

Pattern family note: This exact structure — "for each i, look back at all j < i and take the best valid extension" — reappears in many DP problems: Longest Bitonic Subsequence, Maximum Sum Increasing Subsequence, and Russian Doll Envelopes (with a twist). Recognizing this inner loop shape is the key to spotting the O(n²) DP family.

[github-actions]

---

🤖 Gemini Code Review (Model: gemini-2.5-flash)

Code Review: Longest Increasing Subsequence (LIS)

This is an excellent first pass at the Longest Increasing Subsequence problem! You've correctly identified and implemented the standard Dynamic Programming approach, which is a great foundation. Let's break down the solution.

---

1. Pattern Identification

This solution uses Dynamic Programming (1D Tabulation). Specifically, it's a bottom-up approach where the solution to smaller subproblems is used to build up the solution for larger subproblems.

2. Complexity Verification

• Time Complexity:

  • Stated: Not explicitly stated in the code, but the POST_MORTEM.md correctly identifies O(n²).
  • Verification: The outer loop runs n times (from i = 0 to length - 1). The inner loop runs i times (from j = 0 to i - 1). This results in approximately 1 + 2 + ... + (n-1) operations, which simplifies to n * (n-1) / 2 comparisons. Therefore, the time complexity is indeed O(n²). This is accurate.

• Space Complexity:

  • Stated: Not explicitly stated in the code, but the POST_MORTEM.md correctly identifies O(n).
  • Verification: The solution uses a dp array of size n (where n is nums.length). This array stores n numbers. Therefore, the space complexity is O(n). This is accurate.

3. Key Insight

The key insight for this Dynamic Programming solution is defining the state dp[i] as the length of the longest strictly increasing subsequence that ends at nums[i].

With this definition:

1. Base Case: Every element nums[i] can form an increasing subsequence of length 1 by itself. So, dp[i] is initialized to 1 for all i.
2. Recurrence Relation: To find dp[i], we iterate through all previous elements nums[j] where j < i. If nums[j] is strictly less than nums[i] (nums[j] < nums[i]), it means nums[i] can extend the increasing subsequence ending at nums[j]. In this case, the length of such a subsequence would be dp[j] + 1. We want to find the longest such subsequence, so dp[i] becomes the maximum of its current value (1, or a previously found longer subsequence) and dp[j] + 1 for all valid j.
   • dp[i] = max(dp[i], dp[j] + 1) for all j < i where nums[j] < nums[i].
3. Final Result: After filling the entire dp array, the overall longest increasing subsequence might end at any index. Therefore, the answer is the maximum value in the entire dp array.

This approach ensures that when we calculate dp[i], we have already computed the LIS lengths for all j < i, allowing us to build upon those solutions.

4. Edge Case Analysis

The current solution handles the following edge cases correctly:

• Single element array: [42] -> dp will be [1], Math.max returns 1. Correct.
• Already sorted ascending array: [1,2,3,4,5] -> dp will become [1,2,3,4,5], Math.max returns 5. Correct.
• Fully descending array: [5,4,3,2,1] -> dp will remain [1,1,1,1,1] because nums[j] < nums[i] will never be true. Math.max returns 1. Correct.
• Array with all identical elements: [7,7,7,7,7,7,7] -> dp will remain [1,1,1,1,1,1,1] because nums[j] < nums[i] will never be true (it's nums[j] == nums[i]). Math.max returns 1. Correct.
• Arrays with negative numbers: The logic nums[j] < nums[i] works correctly for negative numbers as well. For example, [-2, -1, 0, 1] would result in dp becoming [1, 2, 3, 4], and Math.max returning 4. Correct.

Additional Edge Cases to Consider (though the current solution handles them):

• Constraints: The problem states 1 <= nums.length <= 2500. This means an empty array [] is not a valid input based on constraints, so no special handling is needed for it.
• Mixed positive/negative numbers: The solution naturally handles this due to the generic comparison nums[j] < nums[i].

The test suite covers the critical scenarios well.

5. Learning Points

• Similar Problems using this pattern:

  • Longest Common Subsequence (LCS): A 2D DP problem that extends the idea of building up solutions from subproblems, often involving "match or don't match" choices.
  • House Robber (1D DP): Another classic 1D DP where dp[i] depends on dp[i-1] and dp[i-2].
  • Coin Change (1D DP): dp[i] represents the minimum coins for amount i.
  • Maximum Length of Repeated Subarray: Similar 2D DP structure to LCS.
  • Word Break: Another DP problem, often solved with a boolean dp array.

• Common mistakes people make with this pattern:

  • Incorrect DP state definition: Not clearly defining what dp[i] (or dp[i][j]) represents is the most common pitfall. This leads to incorrect recurrence relations.
  • Incorrect base cases: Failing to properly initialize the dp array or handle the simplest subproblems.
  • Off-by-one errors in loops: Incorrect loop bounds or indexing can lead to out-of-bounds access or missing valid transitions.
  • Not considering all previous states: For LIS, it's crucial to check all j < i where nums[j] < nums[i], not just j = i-1.
  • Returning dp[n-1] instead of Math.max(...dp): The LIS doesn't necessarily end at the last element of the input array.

• Variations of this problem:

  • O(n log n) LIS: This is a classic follow-up. It involves a more advanced technique using patience sorting (or a tails array and binary search) to achieve better time complexity. It's an excellent problem to tackle next to deepen your understanding.
  • Longest Decreasing Subsequence (LDS): Trivial variation, just reverse the comparison nums[j] > nums[i].
  • Longest Bitonic Subsequence: Find the longest subsequence that first increases, then decreases. This can be solved by combining LIS and LDS calculations.
  • Russian Doll Envelopes: This problem is essentially LIS applied to 2D pairs after a clever sorting step. It tests your ability to adapt the LIS pattern.
  • Number of Longest Increasing Subsequences: Instead of just the length, count how many distinct LIS exist. This requires a second DP array to store counts.

6. Code Quality

The code quality is very good:

• Variable Naming: length, dp, nums, i, j are all clear and standard.
• Code Structure: The nested loops are straightforward and follow the typical DP tabulation structure.
• Readability: The code is concise and easy to understand.
• TypeScript Best Practices:
  • const is used for length and dp, which is appropriate as they are not reassigned.
  • Type annotations (: number[]) are correctly used.
  • new Array(length).fill(1) is an idiomatic and efficient way to initialize the dp array.
  • Math.max(...dp) is a clean way to find the maximum value in the array.

The POST_MORTEM.md correctly points out the missing semicolons in expect lines in the test file, which is a minor stylistic point, but good to be consistent.

7. Alternative Approaches

1. O(n log n) Solution (Patience Sorting / Binary Search):

   • Approach: This is the optimal solution in terms of time complexity. It maintains a tails array, where tails[k] stores the smallest ending element of all increasing subsequences of length k+1.
     • When iterating through nums[i]:
       • If nums[i] is greater than all elements in tails, it extends the longest LIS found so far, so append nums[i] to tails.
       • Otherwise, find the smallest element in tails that is greater than or equal to nums[i] using binary search. Replace that element with nums[i]. This helps maintain a tails array with the smallest possible tail for each length, allowing for potentially longer subsequences later.
   • Trade-offs:
     • Pros: Significantly faster time complexity (O(n log n)).
     • Cons: More complex to understand and implement correctly. The tails array does not represent an actual LIS, only its properties.

2. Recursive with Memoization (Top-Down Dynamic Programming):

   • Approach: Define a recursive function memoizedLIS(index) that calculates the LIS ending at nums[index]. This function would recursively call itself for previous indices and store results in a memo (e.g., a dp array or a Map).
   • Trade-offs:
     • Pros: Can sometimes be more intuitive to design for certain DP problems, as it directly translates the recursive definition.
     • Cons: Typically has the same time and space complexity as the bottom-up approach (O(n²) time, O(n) space for LIS), but might incur slightly higher overhead due to recursion stack calls. For this specific problem, bottom-up is often clearer.

Your current O(n²) DP solution is the standard and most intuitive DP approach for LIS, and it's a great starting point for understanding the problem. The O(n log n) solution is a fantastic next step to explore once you're comfortable with this one.

[coderabbitai]

📝 Walkthrough

Walkthrough

This PR introduces a complete implementation of the Longest Increasing Subsequence problem (LeetCode 300), including an O(n²) dynamic programming solution, comprehensive test coverage, problem documentation, and an interview debrief detailing the problem-solving session.

Changes

Cohort / File(s)	Summary
Documentation and Problem Registry docs/PROBLEMS.md, leetcode/medium/0300-longest-increasing-subsequence/README.md, leetcode/medium/0300-longest-increasing-subsequence/POST_MORTEM.md	Added problem entry to registry, documented LeetCode problem statement with examples and constraints, and created interview debrief capturing session insights across 6 cycles including DP pattern recognition, complexity analysis, and growth recommendations.
Implementation and Tests leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.ts, leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.test.ts	Implemented O(n²) dynamic programming solution using nested loops to compute LIS length; added test suite covering standard examples, edge cases (identical elements, single element, sorted/descending arrays).

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~12 minutes

Poem

🐰 A longest path through numbers I did find,
With nested loops that trace each mind,
From 10 to 7, the order grows,
DP patterns dance as logic flows,
One hundred problems, yet we hare along! 🐇

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 0.00% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'learn: solve Longest Increasing Subsequence (#300) via guided TDD' clearly and concisely captures the main objective of the PR: solving LeetCode problem #300 using test-driven development.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch tdd/0300-longest-increasing-subsequence

Tip

Issue Planner is now in beta. Read the docs and try it out! Share your feedback on Discord.

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[pertrai1]

🎯 How This Solution Works

Imagine you're watching a parade of numbers march past, and you're trying to build the longest conga line where each person must be taller than the one in front of them.

Here's the trick: instead of tracking the one "best" conga line globally, you keep a personal record for each person — "if this person is the last one in a conga line, what's the longest that line could be?" That's your dp array.

At the start, everyone has a line of length 1 (just themselves). Then, for each new person i who steps up, you look back at every person j who came before. If person j is shorter (strictly), then person i can join the end of person j's line. You take the best deal available: dp[i] = max(dp[i], dp[j] + 1).

By the time you've processed everyone, each dp[i] holds the answer to "what's the longest line ending exactly here?" The global answer is just the max across all of them.

The beautiful thing is that you never have to decide which conga line to commit to while you're building — you try all of them simultaneously. That's what makes DP so powerful: deferred decisions, memoized subproblems.

The follow-up rabbit hole: The problem hints at an O(n log n) solution. That version maintains a "tails array" — a sorted list of the smallest tail element for each possible line length — and uses binary search to place each new number. Same answer, completely different intuition. Worth exploring once you're fluent with this O(n²) version.

[github-actions]

---

🤖 Gemini Code Review (Model: gemini-2.5-flash)

Here's a detailed review of the provided Longest Increasing Subsequence solution:

---

1. Pattern Identification

This solution uses Dynamic Programming (DP), specifically a 1D bottom-up (tabulation) approach. The problem asks for the longest subsequence with a specific property, and the solution builds up the answer for larger subproblems from the solutions of smaller, overlapping subproblems.

2. Complexity Verification

• Time Complexity: O(n^2)

  • Verification: The stated time complexity in POST_MORTEM.md is accurate.
  • Explanation: There are two nested for loops. The outer loop iterates n times (from i = 0 to n-1). The inner loop iterates i times (from j = 0 to i-1). This results in approximately n * (n-1) / 2 operations, which simplifies to O(n^2). The final Math.max(...dp) operation takes O(n) time, but it doesn't change the overall quadratic complexity.

• Space Complexity: O(n)

  • Verification: The stated space complexity in POST_MORTEM.md is accurate.
  • Explanation: The solution uses a dp array of size n to store the lengths of increasing subsequences. This array grows linearly with the input size.

3. Key Insight

The key insight for this O(n^2) DP solution is to define dp[i] as the length of the longest strictly increasing subsequence that ends at nums[i].

With this definition:

1. Every element nums[i] can, at minimum, form an increasing subsequence of length 1 (itself). This is the base case, so dp is initialized with all 1s.
2. To find dp[i], we look at all previous elements nums[j] where j < i.
3. If nums[j] < nums[i], it means nums[i] can be appended to an increasing subsequence ending at nums[j]. The length of this new subsequence would be dp[j] + 1.
4. We then take the maximum of all such dp[j] + 1 values for valid js, along with the initial 1 (for nums[i] itself), to determine dp[i].
5. Finally, the overall LIS length is the maximum value found anywhere in the dp array, because the longest subsequence might not necessarily end at the last element of the input array.

4. Edge Case Analysis

The current solution correctly handles several important edge cases:

• Single element array: nums = [42]
  • length = 1, dp = [1]. The loops don't run or only the outer loop runs once. Math.max(...dp) correctly returns 1.
  • Covered by test: it('returns 1 for a single element array')
• Already sorted array: nums = [1, 2, 3, 4, 5]
  • dp will correctly become [1, 2, 3, 4, 5], and Math.max returns 5.
  • Covered by test: it('returns the length of the input array when already sorted')
• Fully descending array: nums = [5, 4, 3, 2, 1]
  • The condition nums[j] < nums[i] will never be met. dp remains [1, 1, 1, 1, 1], and Math.max returns 1.
  • Covered by test: it('should return 1 when the input is fully descending')
• All identical elements: nums = [7, 7, 7, 7]
  • The condition nums[j] < nums[i] will never be met (due to strict inequality). dp remains [1, 1, 1, 1], and Math.max returns 1.
  • Covered by test: it('returns 1 when all elements are identical')
• Negative numbers and zero: The problem constraints allow numbers from -10^4 to 10^4. The comparison nums[j] < nums[i] works correctly with negative numbers and zero, so the algorithm inherently handles them.
  • Potential missing test case: While the algorithm handles them, explicitly adding a test case like [-2, -1, 0, -5, 1] (LIS: [-2, -1, 0, 1], length 4) would demonstrate awareness of the full input domain, as noted in the POST_MORTEM.md.

The constraints specify 1 <= nums.length, so an empty array is not an allowed input.

5. Learning Points

• Similar problems using this pattern:
  • Longest Common Subsequence (LCS): A classic 2D DP problem that extends the idea of building solutions from subproblems, often involving two strings/arrays.
  • Maximum Subarray: A simpler 1D DP problem where dp[i] might represent the maximum sum ending at index i.
  • House Robber / Climbing Stairs: Other foundational 1D DP problems where the optimal solution for i depends on i-1 or i-2.
  • Russian Doll Envelopes (LeetCode 354): This problem requires a clever initial sorting step to transform it into an LIS problem on one dimension after sorting the other. It's a great test of applying LIS in a disguised form.
• Common mistakes people make with this pattern:
  • Incorrect dp state definition: A frequent error is defining dp[i] as the LIS up to index i, rather than ending at index i. The latter makes the recurrence much cleaner.
  • Incorrect base case: Forgetting to initialize dp[i] to 1 (every element is an LIS of length 1).
  • Off-by-one errors: In loop bounds or array indexing.
  • Not finding the global maximum: Forgetting that the LIS might not end at the last element of the input array, and therefore requiring a final pass (or tracking a global maximum during computation) over the dp array.
  • Strict vs. non-strict inequality: Depending on the problem, sometimes nums[j] <= nums[i] is required instead of nums[j] < nums[i]. For LIS, it's strictly increasing.
• Variations of this problem:
  • O(n log n) LIS: This is a very common follow-up. It uses a different approach involving a tails array and binary search (often called patience sorting). tails[k] stores the smallest ending element of an increasing subsequence of length k+1. This significantly improves time complexity.
  • Finding the actual subsequence: Instead of just the length, reconstruct the actual sequence by storing predecessor indices.
  • Longest Decreasing Subsequence (LDS): A minor variation where the condition becomes nums[j] > nums[i].
  • Longest Bitonic Subsequence: Finding a subsequence that first increases and then decreases (can be solved by combining LIS and LDS).

6. Code Quality

The code quality is excellent for this specific implementation:

• Variable Naming: length, dp, i, j, nums are standard, clear, and descriptive.
• Code Structure: The solution is well-structured, easy to follow, and directly reflects the DP recurrence.
• Readability: The code is highly readable.
• TypeScript Best Practices:
  • const is used for length and dp which are not reassigned. let is correctly used for loop counters.
  • Type annotations (: number[]) are clear.
  • Modern ES6+ syntax (new Array(length).fill(1), Math.max(...dp)) is used effectively.

No significant improvements are needed for this O(n^2) DP approach.

7. Alternative Approaches

1. O(n log n) Solution (Patience Sorting / Binary Search):

   • Approach: Instead of dp[i] storing the LIS ending at nums[i], this method maintains a tails array. tails[k] stores the smallest tail of all increasing subsequences of length k+1. When iterating through nums[i], we either extend the longest subsequence (if nums[i] is larger than all tails) or find the smallest tail tails[k] that nums[i] can replace to form a new increasing subsequence of length k+1 (using binary search).
   • Trade-offs:
     • Pros: Significantly better time complexity (O(n log n)), which is optimal for comparison-based LIS.
     • Cons: More complex to understand and implement compared to the O(n^2) DP. The tails array doesn't directly represent a valid LIS at any point, only its length.

2. Recursive with Memoization (Top-down DP):

   • Approach: Define a recursive function memoizedLIS(index, prevIndex) that calculates the LIS length starting from index, given that nums[prevIndex] was the last element included in the subsequence. Use a 2D memoization table to store results of subproblems.
   • Trade-offs:
     • Pros: Can sometimes be more intuitive to formulate directly from the recursive definition.
     • Cons: Still O(n^2) time and O(n^2) space (for the memoization table, if prevIndex can be any previous index), or O(n) space if prevIndex is optimized away. Often has higher constant factors due to recursion overhead. For LIS, the bottom-up O(n^2) solution is generally preferred over top-down if not going for O(n log n).

[github-actions]

✅ Test Results

Tests have been executed for this pull request.

📊 Coverage Summary

Metric	Coverage
Statements	94.54%
Branches	91.13%
Functions	88.23%
Lines	94.44%

Check the workflow logs for detailed test output.

[sonarqubecloud]

Quality Gate failed

Failed conditions
40.9% Coverage on New Code (required ≥ 80%)

See analysis details on SonarQube Cloud

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 3876fdf3e5

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Handle empty input before taking max

When nums is empty, dp is also empty and Math.max(...dp) returns -Infinity, which is not a valid LIS length and can propagate incorrect results for callers outside LeetCode’s constrained input set. Adding an early return (typically 0) for length === 0 prevents this incorrect sentinel value from escaping.

Useful? React with 👍 / 👎.

[coderabbitai]

🧹 Nitpick comments (2)

leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.test.ts (1)

4-27: Good coverage — consider adding a negative-numbers test case.

The six tests cover the main scenarios well. One gap: the problem constraints allow nums[i] in [-10⁴, 10⁴], and there's no test with negative values (e.g., [-1, -2, 0, 3] → 3). This would exercise the full input domain and aligns with the POST_MORTEM's own recommendation. As per coding guidelines: "Verify the solution correctly solves the problem for all test cases, including edge cases: empty arrays, single elements, negative numbers, null values."

💡 Suggested addition

   it('should return 1 when the input is fully descending', () => {
     expect(lengthOfLIS([5, 4, 3, 2, 1])).toBe(1);
   });
+
+  it('handles negative numbers correctly', () => {
+    expect(lengthOfLIS([-1, -2, 0, 3])).toBe(3);
+  });
 });

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.test.ts`
around lines 4 - 27, Add a unit test to cover negative numbers: create a new it
block in longest-increasing-subsequence.test.ts (alongside the other tests) that
calls lengthOfLIS with a negative-containing array such as [-1, -2, 0, 3] and
asserts the expected result (3); reference the existing test file and the
lengthOfLIS function when adding the test so it follows the same style and
naming convention (e.g., "returns 3 for [-1,-2,0,3] (negative numbers)").

leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.ts (1)

1-14: Add complexity analysis and algorithmic pattern comments.

The solution is correct and clean, but per coding guidelines it should document the algorithmic pattern and time/space complexity with reasoning. A brief comment block would suffice:

💡 Suggested comment addition

+/**
+ * Pattern: 1D Dynamic Programming (bottom-up tabulation)
+ * dp[i] = length of the longest strictly increasing subsequence ending at nums[i]
+ *
+ * Time:  O(n²) — for each of n elements, scan up to i predecessors → n(n-1)/2 comparisons
+ * Space: O(n)  — single dp array of length n
+ */
 export function lengthOfLIS(nums: number[]): number {

As per coding guidelines: "Use TypeScript type annotations for all parameters and return types with complexity analysis in code comments" and "Document the algorithmic pattern used in solution code comments." Based on learnings: "Include examples in comments for complex algorithms in solution files" and "Explain WHY the complexity is what it is, including amortized analysis when applicable."

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.ts`
around lines 1 - 14, Add a concise comment block above the lengthOfLIS function
that names the algorithmic pattern ("dynamic programming - LIS via DP over
previous elements"), states time complexity O(n^2) with brief reasoning (two
nested loops causing quadratic work) and space complexity O(n) with reasoning
(dp array of length n), and include a short example input->output line showing
how dp updates for a small array (e.g., [10,9,2,5,3,7,101,18] -> 4). Reference
the function name lengthOfLIS and the dp array in the comment so reviewers can
quickly see the mapping between explanation and code.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In
`@leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.test.ts`:
- Around line 4-27: Add a unit test to cover negative numbers: create a new it
block in longest-increasing-subsequence.test.ts (alongside the other tests) that
calls lengthOfLIS with a negative-containing array such as [-1, -2, 0, 3] and
asserts the expected result (3); reference the existing test file and the
lengthOfLIS function when adding the test so it follows the same style and
naming convention (e.g., "returns 3 for [-1,-2,0,3] (negative numbers)").

In
`@leetcode/medium/0300-longest-increasing-subsequence/longest-increasing-subsequence.ts`:
- Around line 1-14: Add a concise comment block above the lengthOfLIS function
that names the algorithmic pattern ("dynamic programming - LIS via DP over
previous elements"), states time complexity O(n^2) with brief reasoning (two
nested loops causing quadratic work) and space complexity O(n) with reasoning
(dp array of length n), and include a short example input->output line showing
how dp updates for a small array (e.g., [10,9,2,5,3,7,101,18] -> 4). Reference
the function name lengthOfLIS and the dp array in the comment so reviewers can
quickly see the mapping between explanation and code.

[github-actions]

📅 Spaced Repetition Reviews Scheduled!

Great job solving #0300 - Longest Increasing Subsequence! 🎉

To help you retain this knowledge long-term, I've scheduled 5 review sessions using spaced repetition:

Review	Interval	Schedule Logic
1st Review	1 day after solving	Scheduled now
2nd Review	3 days after 1st review	Auto-scheduled when 1st completes
3rd Review	7 days after 2nd review	Auto-scheduled when 2nd completes
4th Review	14 days after 3rd review	Auto-scheduled when 3rd completes
5th Review	30 days after 4th review	Auto-scheduled when 4th completes

What to expect:

• Your 1st review is scheduled for tomorrow
• Each subsequent review is scheduled automatically when you complete the previous one
• This ensures proper spacing even if you complete a review a few days late
• GitHub issues will be created automatically for each review
• Each issue will link back to your solution

🧠 Why Spaced Repetition?

Research shows that reviewing material at increasing intervals dramatically improves retention. This adaptive scheduling ensures optimal spacing based on when you actually complete each review!

Check docs/reviews/review-schedule.json to see your review schedule.