Number of Ways to Earn Points - Problem

Number of Ways to Earn Points

Imagine you're taking an exam where you need to earn exactly a target number of points. The exam has n different types of questions, each with specific characteristics:

• Each question type i has count[i] available questions
• Each question of type i is worth marks[i] points
• Questions of the same type are indistinguishable

Your goal is to determine how many different ways you can select questions to earn exactly the target points. Since the answer can be very large, return it modulo 10⁹ + 7.

Example: If you have 3 questions of type A (worth 2 points each), selecting questions 1&2 is the same as selecting questions 1&3 or 2&3.

Input & Output

example_1.py — Basic Case

$ Input: target = 6, types = [[6,1],[3,2],[2,3]]

› Output: 7

💡 Note: You can choose: 6 type1 + 0 type2 + 0 type3 = 6*1 = 6 ✓, 4 type1 + 1 type2 + 0 type3 = 4*1 + 1*2 = 6 ✓, 2 type1 + 2 type2 + 0 type3 = 2*1 + 2*2 = 6 ✓, 0 type1 + 3 type2 + 0 type3 = 0*1 + 3*2 = 6 ✓, 3 type1 + 0 type2 + 1 type3 = 3*1 + 1*3 = 6 ✓, 1 type1 + 1 type2 + 1 type3 = 1*1 + 1*2 + 1*3 = 6 ✓, 0 type1 + 0 type2 + 2 type3 = 0*1 + 0*2 + 2*3 = 6 ✓

example_2.py — Simple Case

$ Input: target = 5, types = [[50,1],[3,4]]

› Output: 4

💡 Note: Ways: (5 type1, 0 type2), (1 type1, 1 type2) = 1+4=5. Only these 2 ways work since we can't use fractional questions.

example_3.py — Edge Case

$ Input: target = 18, types = [[6,1],[3,2],[2,3]]

› Output: 1

💡 Note: Only one way: use all questions = 6*1 + 3*2 + 2*3 = 6+6+6 = 18

Constraints

1 ≤ types.length ≤ 50
1 ≤ target ≤ 1000
types[i] = [count_i, marks_i]
1 ≤ count_i, marks_i ≤ 50

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

This is a bounded knapsack counting problem solved optimally with dynamic programming. Key insight: instead of finding maximum value, we count the number of ways to achieve exactly the target sum. The DP approach processes each question type once, updating possible scores, giving us O(target × Σcount[i]) time complexity.

Common Approaches

✓ Brute Force (Try All Combinations)

⏱️ Time: O(∏(count[i] + 1)) Space: O(n)

Try every possible way to select questions from each type. For each question type, try selecting 0, 1, 2, ... up to the available count, then recursively solve for remaining types and target.

Dynamic Programming (Optimal)

⏱️ Time: O(target × Σcount[i]) Space: O(target)

This is a bounded knapsack problem where we count the number of ways instead of finding maximum value. We use dynamic programming where dp[i] represents the number of ways to achieve exactly i points.

Brute Force (Try All Combinations) — Algorithm Steps

Start with the first question type
Try selecting 0 to count[i] questions of this type
For each selection, recursively solve for remaining types with updated target
Count all combinations that exactly reach the target
Return total count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Type 0

Try selecting 0, 1, 2... questions of first type

Recurse to Type 1

For each choice in step 1, try all possibilities for type 1

Continue Until End

Repeat until all types processed or target exceeded

Count Valid Paths

Count paths that exactly reach target = 0

Code -

solution.c — C

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

#define MOD 1000000007

static long long dp[1001];
static long long new_dp[1001];

int waysToReachTarget(int target, int types[][2], int n) {
    for (int i = 0; i <= target; i++) {
        dp[i] = 0;
    }
    dp[0] = 1;
    
    for (int t = 0; t < n; t++) {
        int count = types[t][0];
        int marks = types[t][1];
        
        for (int i = 0; i <= target; i++) {
            new_dp[i] = dp[i];
        }
        
        for (int current_points = 0; current_points <= target; current_points++) {
            if (dp[current_points] > 0) {
                for (int questions_used = 1; questions_used <= count; questions_used++) {
                    int points_gained = questions_used * marks;
                    int new_points = current_points + points_gained;
                    if (new_points <= target) {
                        new_dp[new_points] = (new_dp[new_points] + dp[current_points]) % MOD;
                    }
                }
            }
        }
        
        for (int i = 0; i <= target; i++) {
            dp[i] = new_dp[i];
        }
    }
    
    return (int)dp[target];
}

int main() {
    int target;
    scanf("%d", &target);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    int types[100][2];
    int n = 0;
    
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != '\0') {
        while (*p && *p != '[') p++;
        if (!*p) break;
        p++; // skip '['
        
        int a = (int)strtol(p, &p, 10);
        while (*p && (*p < '0' || *p > '9')) p++;
        int b = (int)strtol(p, &p, 10);
        
        types[n][0] = a;
        types[n][1] = b;
        n++;
        
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
    }
    
    printf("%d\n", waysToReachTarget(target, types, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(∏(count[i] + 1))

We try all combinations - for each type i, we have count[i]+1 choices (0 to count[i] questions)

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals number of question types

⚡ Linearithmic Space

52.4K Views

High Frequency

~25 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

Number of Ways to Earn Points - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler