Reading the constraints

Let us see how constraints change the algorithm you would write.

Scenario 1: n ≤ 10

Problem: “Find the maximum sum of any subset of the array.”

Constraint: n ≤ 10.

Approach: Brute force. Try all 2^n subsets. That is 2^10 = 1024 operations. Instant.

function maxSubsetSum(arr) {
  let max = 0;
  // Iterate through all 2^n subsets using bitmask
  for (let mask = 0; mask < (1 << arr.length); mask++) {
    let sum = 0;
    for (let i = 0; i < arr.length; i++) {
      if (mask & (1 << i)) sum += arr[i];
    }
    max = Math.max(max, sum);
  }
  return max;  // O(2^n)
}

With n ≤ 10, this O(2^n) solution is fine. You are not trying to be clever. The constraint gives you permission to brute force.

Scenario 2: n ≤ 1,000

Problem: “Find the longest common subsequence (LCS) of two strings.”

Constraint: n ≤ 1,000 (length of each string).

Approach: Dynamic programming. Build a 2D table of size n × n. That is 10⁶ operations (filling the table). Feasible.

function lcs(s1, s2) {
  const n = s1.length, m = s2.length;
  const dp = Array(n + 1).fill(0).map(() => Array(m + 1).fill(0));
  
  for (let i = 1; i <= n; i++) {
    for (let j = 1; j <= m; j++) {
      if (s1[i - 1] === s2[j - 1]) {
        dp[i][j] = dp[i - 1][j - 1] + 1;
      } else {
        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
      }
    }
  }
  return dp[n][m];  // O(n²)
}

With n ≤ 1,000, O(n²) is safe. If n were 10⁶, this would not work.

Scenario 3: n ≤ 10⁶

Problem: “Count how many elements in the array are greater than the average.”

Constraint: n ≤ 10⁶.

Approach: Single pass. Compute the sum (O(n)), compute the average, count (O(n)). Total: O(n). ~10⁶ operations. Instant.

function countAboveAverage(arr) {
  const sum = arr.reduce((a, b) => a + b, 0);
  const avg = sum / arr.length;
  return arr.filter(x => x > avg).length;  // O(n)
}

With n ≤ 10⁶, a single pass is required. O(n²) is 10¹² operations — hopeless. O(n log n) is ~2×10⁷ operations — overkill for this problem (though still acceptable). O(n) is ideal.

These three scenarios show the same principle: the constraint narrows down which complexity is even worth considering.

Let us trace how the constraint eliminates options. Imagine reading a problem:

Problem statement: “Given an array of size n, find if there exists a pair of elements whose sum equals target.”

Now you read the constraint: “1 ≤ n ≤ 100,000.”

      1
      Constraint: n ≤ 100,000
    

      2
      Budget: ~10^8 operations
    

      3
      Work backwards to find the complexity you need...
    

The constraint does not tell you which O(n log n) algorithm to use, but it tells you that anything slower will not work. This is invaluable.