Number of Ways to Earn Points - Practice Coding Problems

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

Understanding the Visualization

Setup Your Strategy

Initialize with one way to get 0 points (answer nothing)

Consider Each Question Type

For each type, explore all possible ways to use 0, 1, 2, ... questions

Build Up Scores

Update the number of ways to achieve each possible total score

Find Your Answer

The result is the number of ways to achieve exactly target points

Key Takeaway

🎯 Key Insight: Transform the bounded knapsack problem from "find maximum value" to "count ways to reach exact target" using dynamic programming state transitions.

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(target × Σcount[i])	O(target)	Use DP to count ways to reach each possible score, processing one question type at a time
Brute Force (Try All Combinations)	O(∏(count[i] + 1))	O(n)	Generate all possible combinations of questions and count those summing to target

Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp array where dp[0] = 1 (one way to get 0 points)
For each question type, create a new dp array
For each possible score from 0 to target
For each number of questions we can use of current type
Update dp[score + questions*marks] += dp[score]
Return dp[target]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0] = 1, all others = 0

Process Type 1

For each score, try adding 1,2,3... questions of type 1

Process Type 2

For each current score, try adding questions of type 2

Final Answer

dp[target] contains total ways to reach target

Code -

solution.c — C

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

#define MOD 1000000007

int waysToReachTarget(int target, int types[][2], int n) {
    // dp[i] = number of ways to achieve exactly i points
    long long* dp = (long long*)calloc(target + 1, sizeof(long long));
    dp[0] = 1; // One way to get 0 points: select nothing
    
    // Process each question type
    for (int i = 0; i < n; i++) {
        int count = types[i][0];
        int marks = types[i][1];
        
        // Create new dp array for this iteration
        long long* newDp = (long long*)malloc((target + 1) * sizeof(long long));
        memcpy(newDp, dp, (target + 1) * sizeof(long long));
        
        // For each current achievable score
        for (int score = 0; score <= target; score++) {
            if (dp[score] == 0) continue;
            
            // Try using 1 to count questions of current type
            int maxQuestions = (count < (target - score) / marks) ? count : (target - score) / marks;
            
            for (int questionsUsed = 1; questionsUsed <= maxQuestions; questionsUsed++) {
                int newScore = score + questionsUsed * marks;
                if (newScore <= target) {
                    newDp[newScore] = (newDp[newScore] + dp[score]) % MOD;
                }
            }
        }
        
        free(dp);
        dp = newDp;
    }
    
    int result = dp[target];
    free(dp);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(target × Σcount[i])

For each question type, we iterate through target scores and up to count[i] questions

✓ Linear Growth

Space Complexity

O(target)

DP array of size target+1, can be optimized to single array

✓ Linear 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler