Solving Questions With Brainpower - Practice Coding Problems

Solving Questions With Brainpower - Problem

You're taking an exam with n questions arranged in a sequence. Each question has two properties:

Points: The score you earn for solving it
Brainpower: How many subsequent questions you must skip if you solve this one

Given a 2D array questions where questions[i] = [points_i, brainpower_i], you must process questions in order from index 0. For each question, you can either:

Solve it: Earn points_i points but skip the next brainpower_i questions
Skip it: Move to the next question without earning points

Example: Given [[3,2], [4,3], [4,4], [2,5]]

If you solve question 0: earn 3 points, skip questions 1 and 2, then decide on question 3
If you skip question 0 and solve question 1: earn 4 points, skip questions 2 and 3

Return the maximum points you can earn from the entire exam.

Input & Output

example_1.py — Basic Case

$ Input: questions = [[3,2],[4,3],[4,4],[2,5]]

› Output: 5

💡 Note: Maximum points can be earned by solving questions 1 and 3: skip question 0, solve question 1 (earn 4 points, skip questions 2 and 3), then solve question 3 (earn 2 points). Wait, that's wrong. Actually: solve question 0 (3 points, skip 1,2) + solve question 3 (2 points) = 5. Or solve question 1 (4 points, skip 2,3) = 4. Or solve question 2 (4 points, skip everything after) = 4. The maximum is actually 7: solve question 0 (3 points, skip to question 3) + solve question 3 (2 points) = 5. Wait, let me recalculate: solve question 1 (4 points, skip 2,3) = 4, OR skip 0,1 and solve question 2 (4 points) = 4, OR solve question 0 (3 points) + solve question 3 (2 points) = 5.

example_2.py — Single Question

$ Input: questions = [[1,1]]

› Output: 1

💡 Note: There's only one question. We can solve it to earn 1 point, or skip it to earn 0 points. The maximum is 1.

example_3.py — High Brainpower

$ Input: questions = [[21,5],[92,3],[74,2],[39,4],[58,2],[5,5],[49,4],[65,3]]

› Output: 157

💡 Note: With high brainpower values, we need to be strategic about which questions to solve to maximize points while accounting for the skip penalties.

Constraints

1 ≤ questions.length ≤ 10⁵
questions[i].length == 2
1 ≤ points_i, brainpower_i ≤ 10⁵
Process questions in order from index 0

Visualization

Tap to expand

Understanding the Visualization

Assess Each Question

Look at points gained vs future questions blocked

Work Backwards

Start from the end to know future opportunities

Make Optimal Choice

Choose solve vs skip based on maximum total benefit

Build Complete Strategy

Combine optimal choices to get maximum points

Key Takeaway

🎯 Key Insight: Dynamic Programming eliminates the need to recalculate the same subproblems by working backwards and storing optimal results for each position.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses Dynamic Programming working backwards from the last question. For each question, we choose the maximum between solving it (earning points + optimal score from valid next position) and skipping it (optimal score from next question). This achieves O(n) time complexity by eliminating redundant calculations through memoization.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(2^n)	O(n)	Try all possible combinations of solving/skipping questions recursively
Dynamic Programming (Optimal)	O(n)	O(n)	Work backwards using memoization to avoid redundant calculations

Recursive Brute Force — Algorithm Steps

Start from question 0
For each question, try both options: solve or skip
If solving: add points and recurse from (current + brainpower + 1)
If skipping: recurse from (current + 1)
Return maximum of both options
Base case: return 0 when past the last question

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Question 0

Begin with the first question and two choices

Branch for Each Choice

Create branches for solve vs skip decisions

Recursive Exploration

Continue recursively until all questions are processed

Return Maximum

Bubble up the maximum score from all paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

long long solve(int questions[][2], int n, int i) {
    if (i >= n) {
        return 0;
    }
    
    // Option 1: Solve current question
    long long solveCurrent = questions[i][0] + solve(questions, n, i + questions[i][1] + 1);
    
    // Option 2: Skip current question
    long long skipCurrent = solve(questions, n, i + 1);
    
    return solveCurrent > skipCurrent ? solveCurrent : skipCurrent;
}

long long mostPoints(int questions[][2], int n) {
    return solve(questions, n, 0);
}

int main() {
    int n;
    scanf("%d", &n);
    int questions[n][2];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &questions[i][0], &questions[i][1]);
    }
    printf("%lld\n", mostPoints(questions, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each question, we make 2 recursive calls, leading to 2^n total calls

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can go up to n levels in the worst case

⚡ Linearithmic Space

52.0K Views

Medium Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler