Pairs of Songs With Total Durations Divisible by 60

Pairs of Songs With Total Durations Divisible by 60 - Problem

You're managing a music streaming service and need to create perfect playlist pairs for your users. Given an array of song durations (in seconds), you need to find all pairs of songs where the combined duration is divisible by 60 seconds (i.e., forms a complete minute multiple).

More formally, given an array time where time[i] represents the duration of the i-th song in seconds, return the number of pairs (i, j) where:

i < j (to avoid counting the same pair twice)
(time[i] + time[j]) % 60 == 0 (sum is divisible by 60)

Example: If you have songs with durations [30, 20, 150, 100, 40], the pairs (30, 150) and (20, 100) both sum to 180 seconds (3 minutes), and (20, 40) sums to 60 seconds (1 minute).

Input & Output

example_1.py — Basic Case

$ Input: [30, 20, 150, 100, 40]

› Output: 3

💡 Note: Three pairs sum to multiples of 60: (30+150=180), (20+100=120), (20+40=60)

example_2.py — Edge Case with Zeros

$ Input: [60, 60, 60]

› Output: 3

💡 Note: All songs have remainder 0, so any pair works: (60+60=120), (60+60=120), (60+60=120) - total 3 unique pairs

example_3.py — No Valid Pairs

$ Input: [269, 230, 175]

› Output: 0

💡 Note: Remainders are 29, 50, 55. No two remainders sum to 0 or 60, so no valid pairs exist

Visualization

Tap to expand

Understanding the Visualization

Map to Clock

Each song duration gets mapped to a position 0-59 on a 60-second clock

Find Complements

For each position, find what other position would complete a full rotation (sum to 0 mod 60)

Count Pairs

Count how many songs are at complementary positions

Handle Special Cases

Positions 0 and 30 pair with themselves, requiring special combination counting

Key Takeaway

🎯 Key Insight: Use modular arithmetic to transform the problem from checking all pairs to counting complement remainders, reducing complexity from O(n²) to O(n).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with constant time operations

✓ Linear Growth

Space Complexity

O(1)

Fixed-size array of 60 elements regardless of input size

✓ Linear Space

Constraints

1 ≤ time.length ≤ 6 × 10⁴
1 ≤ time[i] ≤ 500
Follow-up: Can you solve it in O(n) time?

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses modular arithmetic with a one-pass hash table approach. By tracking remainders (mod 60) and finding complements that sum to 60, we achieve O(n) time complexity instead of the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair of songs to see if their sum is divisible by 60
One-Pass Hash Table (Optimal)	O(n)	O(1)	Use remainders mod 60 to find complement pairs in a single pass

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop to iterate through each song (i = 0 to n-2)
Use inner loop to check all songs after current song (j = i+1 to n-1)
For each pair (i,j), check if (time[i] + time[j]) % 60 == 0
Count valid pairs and return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first song and compare with all subsequent songs

Check Pairs

For each pair, calculate sum and check divisibility by 60

Count Valid

Increment counter when a valid pair is found

Continue

Move to next song and repeat until all pairs checked

Code -

solution.c — C

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

int numPairsDivisibleBy60(int* time, int timeSize) {
    int count = 0;
    
    // Check all possible pairs
    for (int i = 0; i < timeSize; i++) {
        for (int j = i + 1; j < timeSize; j++) {
            if ((time[i] + time[j]) % 60 == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int time[1000];
    int n = 0;
    char c;
    int num = 0;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (reading) {
            time[n++] = num;
            num = 0;
            reading = 0;
        }
    }
    if (reading) time[n++] = num;
    
    printf("%d\n", numPairsDivisibleBy60(time, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterate through all possible pairs of songs

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for counters

✓ Linear Space

Constraints

1 ≤ time.length ≤ 6 × 10⁴
1 ≤ time[i] ≤ 500
Follow-up: Can you solve it in O(n) time?

68.2K Views

High Frequency

~18 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler