The Number of Ways to Make the Sum - Practice Coding Problems

The Number of Ways to Make the Sum - Problem

Imagine you're a cashier at a vintage arcade where coins have unusual denominations! You have access to:

Unlimited coins of values 1, 2, and 6
Only 2 coins of value 4

Given a target sum n, your task is to determine how many different ways you can make change to reach exactly that amount.

Important: The order of coins doesn't matter - using coins [2, 2, 6] is considered the same as [2, 6, 2].

Since the number of ways can be astronomically large, return your answer modulo 10⁹ + 7.

Example: For n = 4, you could make it with: [4], [2, 2], [1, 1, 1, 1], [1, 1, 2] - that's 4 different ways!

Input & Output

example_1.py — Basic case

$ Input: n = 4

› Output: 4

💡 Note: Four ways to make sum 4: [4], [2,2], [1,1,1,1], [1,1,2]. The single 4-coin, two 2-coins, four 1-coins, or two 1-coins plus one 2-coin.

example_2.py — Medium case

$ Input: n = 8

› Output: 12

💡 Note: Multiple combinations possible including using 0, 1, or 2 of the 4-coins. Examples: [4,4], [6,2], [6,1,1], [2,2,2,2], [1,1,1,1,1,1,1,1], etc.

example_3.py — Edge case

$ Input: n = 1

› Output: 1

💡 Note: Only one way to make sum 1: using a single coin of value 1, since we cannot use fractional coins or combinations that exceed the target.

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize DP array where dp[i] = ways to make sum i

Process Unlimited

Handle unlimited coins {1,2,6} using standard coin change DP

Add Limited

Add contributions from 1 or 2 uses of the limited 4-coin

Combine

Sum all valid ways: dp[n] + dp[n-4] + dp[n-8]

Key Takeaway

🎯 Key Insight: Separate unlimited coins (use standard DP) from limited coins (enumerate all valid usages). This decomposition makes complex constraint problems manageable.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the DP array for each coin type, total time is proportional to n times number of coin types

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store the number of ways for each sum

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
You have unlimited coins of values 1, 2, and 6
You have exactly 2 coins of value 4
Return answer modulo 10⁹ + 7

Asked in

G Google 32 a Amazon 28 f Meta 19 ⊞ Microsoft 15 Apple 12

This problem combines classic coin change DP with limited quantity constraints. The optimal approach first solves coin change for unlimited coins {1,2,6}, then adds contributions from using 0, 1, or 2 of the limited 4-coins. Time complexity: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(n)	Single DP pass handling all coin types with their quantity constraints

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP array where dp[i] represents ways to make sum i
Process unlimited coins {1, 2, 6} using standard coin change DP
Process limited coin (4) with quantity constraint of 2
For coin 4, use a reverse iteration to avoid overcounting
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set dp[0] = 1, all others = 0

Process unlimited coins

For each coin {1,2,6}, update all reachable sums

Add limited coin contributions

Add dp[n-4] and dp[n-8] if valid

Code -

solution.c — C

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

#define MOD 1000000007

int numWays(int n) {
    // First solve for unlimited coins {1, 2, 6}
    long long* dp = (long long*)calloc(n + 1, sizeof(long long));
    dp[0] = 1;
    
    int unlimitedCoins[] = {1, 2, 6};
    for (int j = 0; j < 3; j++) {
        int coin = unlimitedCoins[j];
        for (int i = coin; i <= n; i++) {
            dp[i] = (dp[i] + dp[i - coin]) % MOD;
        }
    }
    
    // Add contributions from using 1 or 2 coins of value 4
    long long result = dp[n]; // Using 0 coins of value 4
    
    if (n >= 4) {
        result = (result + dp[n - 4]) % MOD; // Using 1 coin of value 4
    }
    
    if (n >= 8) {
        result = (result + dp[n - 8]) % MOD; // Using 2 coins of value 4
    }
    
    int finalResult = (int) result;
    free(dp);
    return finalResult;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the DP array for each coin type, total time is proportional to n times number of coin types

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store the number of ways for each sum

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
You have unlimited coins of values 1, 2, and 6
You have exactly 2 coins of value 4
Return answer modulo 10⁹ + 7

38.4K Views

High Frequency

~18 min Avg. Time

1.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler