Number of Music Playlists - Practice Coding Problems

Number of Music Playlists - Problem

Create Perfect Music Playlists

You have a music library with n different songs and want to create a playlist of exactly goal songs for your road trip. But there's a catch - you want to avoid repetitive listening while ensuring variety:

🎵 Rule 1: Every song must be played at least once
🔄 Rule 2: A song can only be repeated after k other different songs have been played

For example, if k=2 and you play song A, you must play 2 other different songs before you can play song A again.

Your task: Count how many different valid playlists you can create. Since this number can be astronomically large, return the result modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n=3, goal=3, k=1

› Output: 6

💡 Note: With 3 songs and goal of 3, we must use each song exactly once. There are 3! = 6 permutations: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]. Since k=1, no repetitions are allowed anyway.

example_2.py — With Repetition

$ Input: n=2, goal=3, k=0

› Output: 6

💡 Note: With k=0, we can repeat songs immediately. Valid playlists: [1,1,2], [1,2,1], [1,2,2], [2,1,1], [2,1,2], [2,2,1]. Each uses both songs at least once.

example_3.py — Gap Constraint

$ Input: n=2, goal=3, k=1

› Output: 2

💡 Note: With k=1, we need 1 different song between repetitions. Valid playlists are [1,2,1] and [2,1,2]. Playlists like [1,1,2] are invalid because the two 1's are adjacent.

Visualization

Tap to expand

Add New Song: If we haven't used all n songs yet (j < n)🔄 Repeat Old Song: If we have more than k songs to choose from (j > k)Dynamic Programming Formuladp[i][j] = dp[i-1][j-1] × (n-j+1) + dp[i-1][j] × max(0, j-k)where i = playlist length, j = unique songs usedBase case: dp[0][0] = 1, Answer: dp[goal][n]Complexity: O(goal × n) time, O(goal × n) spaceEfficient solution handling constraints up to goal=100, n=100

Understanding the Visualization

Empty Playlist

Start with no songs played (dp[0][0] = 1)

Add First Song

Choose any of n songs for first position

Branching Decisions

At each position, decide: new song or repeat old song?

Apply Constraints

New song only if j < n; repeat only if j > k

Final Count

Sum all ways to reach goal length with all n songs used

Key Takeaway

🎯 Key Insight: At each step, we have exactly two choices: introduce a new song (if available) or repeat an old song (if the k-gap constraint allows it). Dynamic programming efficiently counts all valid combinations.

Time & Space Complexity

Time Complexity

⏱️

O(goal × n)

We fill a 2D DP table of size goal × n, each cell computed in O(1)

✓ Linear Growth

Space Complexity

O(goal × n)

DP table stores goal × n states, can be optimized to O(n) with rolling array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
1 ≤ goal ≤ 100
0 ≤ k < n
goal ≥ n (must be able to play all songs at least once)

Asked in

♪ Spotify 15 G Google 12 Apple 8 a Amazon 6

The optimal solution uses dynamic programming with state dp[i][j] representing the number of ways to create a playlist of length i using exactly j unique songs. At each position, we can either add a new song (multiply by remaining songs) or repeat an old song (multiply by songs available for repetition based on the k-gap constraint).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(goal × n)	O(goal × n)	Use memoization to build playlists efficiently by tracking used songs and positions

Dynamic Programming (Optimal) — Algorithm Steps

Define DP state: dp[i][j] = ways to make playlist of length i with j unique songs
Base case: dp[0][0] = 1 (one way to make empty playlist with 0 songs)
Transition: For each position, either add new song or repeat old song
New song: dp[i][j] += dp[i-1][j-1] * (n - j + 1)
Old song: dp[i][j] += dp[i-1][j] * max(0, j - k)
Return dp[goal][n]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = 1 (empty playlist)

Add New Song

dp[i][j] += dp[i-1][j-1] * (n-j+1)

Repeat Old Song

dp[i][j] += dp[i-1][j] * (j-k)

Final Answer

Return dp[goal][n]

Code -

solution.c — C

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

#define MOD 1000000007
#define min(a,b) ((a) < (b) ? (a) : (b))

int numMusicPlaylists(int n, int goal, int k) {
    // dp[i][j] = number of playlists of length i with j unique songs
    long long** dp = (long long**)malloc((goal + 1) * sizeof(long long*));
    for (int i = 0; i <= goal; i++) {
        dp[i] = (long long*)calloc(n + 1, sizeof(long long));
    }
    
    dp[0][0] = 1;
    
    for (int i = 1; i <= goal; i++) {
        for (int j = 1; j <= min(i, n); j++) {
            // Add a new song
            if (j <= n) {
                dp[i][j] = (dp[i][j] + dp[i-1][j-1] * (n - j + 1)) % MOD;
            }
            
            // Repeat an old song
            if (j > k) {
                dp[i][j] = (dp[i][j] + dp[i-1][j] * (j - k)) % MOD;
            }
        }
    }
    
    int result = dp[goal][n];
    
    // Free memory
    for (int i = 0; i <= goal; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    int n, goal, k;
    scanf("%d %d %d", &n, &goal, &k);
    printf("%d\n", numMusicPlaylists(n, goal, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(goal × n)

We fill a 2D DP table of size goal × n, each cell computed in O(1)

✓ Linear Growth

Space Complexity

O(goal × n)

DP table stores goal × n states, can be optimized to O(n) with rolling array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
1 ≤ goal ≤ 100
0 ≤ k < n
goal ≥ n (must be able to play all songs at least once)

18.2K Views

Medium Frequency

~25 min Avg. Time

847 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