Longest Increasing Subsequence in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the dp array with 1s for each element.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

A0

Bundefined

Cnull

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing dp with 0 instead of 1.

Using undefined or null which causes errors.

Each element starts with a subsequence length of 1 (the element itself).

2fill in blank

medium

Complete the code to compare current and previous elements for increasing order.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

A<=

B>

C<

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>=' or '<=' which allows equal elements.

Using '<' or '<=' in the wrong direction.

We want to find strictly increasing subsequences, so nums[i] must be greater than nums[j].

3fill in blank

hard

Fix the error in returning the maximum length from dp array.

DSA Javascript

return Math.[1](...dp);

Drag options to blanks, or click blank then click option'

Amin

Bsum

Cmax

Daverage

Attempts:

3 left

💡 Hint

Common Mistakes

Using Math.min which gives the smallest value.

Trying to sum or average which is incorrect.

The longest increasing subsequence length is the maximum value in dp array.

4fill in blank

hard

Fill both blanks to complete the nested loop for LIS calculation.

DSA Javascript

for (let [1] = 1; [1] < length; [1]++) {
  for (let [2] = 0; [2] < [1]; [2]++) {
    if (nums[[1]] > nums[[2]]) {
      dp[[1]] = Math.max(dp[[1]], dp[[2]] + 1);
    }
  }
}

Drag options to blanks, or click blank then click option'

Ai

Bj

Ck

Dx

Attempts:

3 left

💡 Hint

Common Mistakes

Using same variable name for both loops.

Using variables that do not follow common conventions.

The outer loop uses 'i' and inner loop uses 'j' to compare elements for LIS.

5fill in blank

hard

Fill all three blanks to create the full LIS function.

DSA Javascript

function lengthOfLIS(nums) {
  const length = nums.length;
  if (length === 0) return 0;
  const dp = new Array(length).fill([1]);
  for (let [2] = 1; [2] < length; [2]++) {
    for (let [3] = 0; [3] < [2]; [3]++) {
      if (nums[[2]] > nums[[3]]) {
        dp[[2]] = Math.max(dp[[2]], dp[[3]] + 1);
      }
    }
  }
  return Math.max(...dp);
}

Drag options to blanks, or click blank then click option'

A1

Bi

Cj

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing dp with 0.

Using wrong loop variable names.

Not returning the maximum value from dp.

Initialize dp with 1, use i and j as loop variables for LIS calculation.

Practice

1. What does the Longest Increasing Subsequence (LIS) problem ask you to find in a sequence of numbers?

easy

A. The longest subsequence where numbers are all equal

B. The longest subsequence where each number is smaller than the previous one

C. The longest subsequence with alternating increasing and decreasing numbers

D. The longest subsequence where each number is larger than the previous one

Solution

1. Step 1: Understand the definition of LIS and compare options

   The Longest Increasing Subsequence is a subsequence where every next number is strictly greater than the previous one. The longest subsequence where each number is larger than the previous one matches the definition exactly, others describe different patterns.

2. Final Answer:

   The longest subsequence where each number is larger than the previous one -> Option D

3. Quick Check:

   LIS = strictly increasing subsequence [OK]

Hint: LIS means strictly increasing numbers in order [OK]

Common Mistakes:

• Confusing increasing with decreasing subsequence
• Thinking LIS means contiguous elements only
• Assuming equal numbers are allowed in LIS

2. Which of the following JavaScript code snippets correctly initializes an array to store LIS lengths for each element in the input array arr?

easy

A. const lis = Array(arr.length).fill(0);

B. const lis = new Array(arr.length).fill(null);

C. const lis = new Array(arr.length).fill(1);

D. const lis = new Array(arr.length).fill(undefined);

Solution

1. Step 1: Understand LIS initialization and check syntax

   Each element starts with LIS length 1 because each element alone is a subsequence. const lis = new Array(arr.length).fill(1); correctly creates an array of length arr.length filled with 1s.

2. Final Answer:

   const lis = new Array(arr.length).fill(1); -> Option C

3. Quick Check:

   Initialize LIS array with 1s [OK]

Hint: LIS array starts with 1 for each element [OK]

Common Mistakes:

• Filling with 0 instead of 1
• Using fill(null) or fill(undefined) which are incorrect for LIS
• Not matching array length to input array

3. What is the length of the Longest Increasing Subsequence for the array [10, 22, 9, 33, 21, 50, 41, 60]?

medium

A. 4

B. 5

C. 6

D. 7

Solution

1. Step 1: Identify increasing subsequences and confirm no longer exists

   Possible LIS includes [10, 22, 33, 50, 60] which has length 5. Checking other subsequences shows none longer than 5.

2. Final Answer:

   5 -> Option B

3. Quick Check:

   LIS length for given array = 5 [OK]

Hint: Trace increasing numbers, pick longest chain [OK]

Common Mistakes:

• Counting non-increasing sequences
• Confusing subsequence with subarray
• Missing longer subsequences by skipping elements

4. Consider this JavaScript code snippet to find LIS length:

function lengthOfLIS(arr) {
  const lis = new Array(arr.length).fill(1);
  for (let i = 1; i < arr.length; i++) {
    for (let j = 0; j < i; j++) {
      if (arr[i] > arr[j]) {
        lis[i] = Math.max(lis[i], lis[j] + 1);
      }
    }
  }
  return lis[arr.length];
}

What is the error in this code?

medium

A. Returns lis[arr.length] which is undefined, should return max value in lis array

B. Incorrect initialization of lis array with 1s

C. The inner loop should start from i instead of 0

D. The comparison should be arr[i] < arr[j] instead of arr[i] > arr[j]

Solution

1. Step 1: Check return statement and correct return logic

   Returning lis[arr.length] accesses out-of-bounds index (undefined). Should return the maximum value in lis array, e.g., Math.max(...lis).

2. Final Answer:

   Returns lis[arr.length] which is undefined, should return max value in lis array -> Option A

3. Quick Check:

   Return max LIS length, not out-of-bounds element [OK]

Hint: Return max value in lis array, not lis[arr.length] [OK]

Common Mistakes:

• Returning wrong index from lis array
• Misunderstanding loop ranges
• Reversing comparison operators

5. Given the array [3, 10, 2, 1, 20], which of the following code snippets correctly finds the length of the Longest Increasing Subsequence using binary search optimization?

hard

A. function lengthOfLIS(arr) {
const tails = [];
for (const num of arr) {
let left = 0, right = tails.length;
while (left < right) {
const mid = Math.floor((left + right) / 2);
if (tails[mid] < num) left = mid + 1;
else right = mid;
}
tails[left] = num;
}
return tails.length;
}

B. function lengthOfLIS(arr) {
const tails = [];
for (const num of arr) {
let left = 0, right = tails.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (tails[mid] <= num) left = mid + 1;
else right = mid - 1;
}
tails[left] = num;
}
return tails.length;
}

C. function lengthOfLIS(arr) {
const tails = [];
for (const num of arr) {
let left = 0, right = tails.length;
while (left < right) {
const mid = Math.ceil((left + right) / 2);
if (tails[mid] > num) right = mid - 1;
else left = mid + 1;
}
tails[left] = num;
}
return tails.length;
}

D. function lengthOfLIS(arr) {
const tails = [];
for (const num of arr) {
let left = 0, right = tails.length;
while (left < right) {
const mid = Math.floor((left + right) / 2);
if (tails[mid] > num) right = mid;
else left = mid + 1;
}
tails[left] = num;
}
return tails.length;
}

Solution

1. Step 1: Understand binary search in tails array and check boundaries/conditions

   We find the position to replace or append the current number to keep tails sorted. function lengthOfLIS(arr) { const tails = []; for (const num of arr) { let left = 0, right = tails.length; while (left < right) { const mid = Math.floor((left + right) / 2); if (tails[mid] < num) left = mid + 1; else right = mid; } tails[left] = num; } return tails.length; } uses correct boundaries and conditions: left < right, mid floor, tails[mid] < num moves left up.

2. Final Answer:

   function lengthOfLIS(arr) { const tails = []; for (const num of arr) { let left = 0, right = tails.length; while (left < right) { const mid = Math.floor((left + right) / 2); if (tails[mid] < num) left = mid + 1; else right = mid; } tails[left] = num; } return tails.length; } -> Option A

3. Quick Check:

   Binary search with left < right and tails[mid] < num [OK]

Hint: Use binary search with left < right and tails[mid] < num [OK]

Common Mistakes:

• Using wrong binary search boundaries (<= instead of <)
• Incorrect mid calculation (ceil instead of floor)
• Wrong comparison operators in binary search