Count Pairs That Form a Complete Day II - Practice Coding Problems

Count Pairs That Form a Complete Day II - Problem

Given an integer array hours representing times in hours, return an integer denoting the number of pairs i, j where i < j and hours[i] + hours[j] forms a complete day.

A complete day is defined as a time duration that is an exact multiple of 24 hours. For example, 1 day is 24 hours, 2 days is 48 hours, 3 days is 72 hours, and so on.

Input & Output

Example 1 — Basic Case

$ Input: hours = [12,12,30,24,24]

› Output: 2

💡 Note: The valid pairs are (0,1) where 12+12=24 and (3,4) where 24+24=48. Both sums are multiples of 24.

Example 2 — Mixed Remainders

$ Input: hours = [72,48,24,3]

› Output: 3

💡 Note: Valid pairs: (0,3) gives 72+3=75=24×3+3, wait that's wrong. Let me recalculate: 72%24=0, 48%24=0, 24%24=0, 3%24=3. We need pairs that sum to multiple of 24. Actually (0,1): 72+48=120=24×5, (0,2): 72+24=96=24×4, (1,2): 48+24=72=24×3. So answer is 3.

Example 3 — No Valid Pairs

$ Input: hours = [1,2,3,4]

› Output: 0

💡 Note: No pair sums to a multiple of 24: 1+2=3, 1+3=4, 1+4=5, 2+3=5, 2+4=6, 3+4=7. None are divisible by 24.

Constraints

1 ≤ hours.length ≤ 5 × 10⁵
1 ≤ hours[i] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input Hours

Array of hours: [12, 12, 30, 18, 6]

Find Pairs

Check which pairs sum to multiples of 24

Count Result

Return total number of valid pairs

Key Takeaway

🎯 Key Insight: Two hours form a complete day if their sum is divisible by 24

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is that two hours form a complete day if their remainders modulo 24 sum to 0 or 24. The frequency count approach groups hours by remainder and calculates pairs mathematically. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Check every pair of hours to see if their sum is divisible by 24
Frequency Count (Optimized)	O(n)	O(1)	Count remainders modulo 24 and calculate pairs mathematically

Brute Force — Algorithm Steps

Iterate through all pairs (i, j) with i < j
Check if hours[i] + hours[j] is divisible by 24
Count valid pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Pairs

Compare all pairs (i,j) where i < j

Sum & Test

Calculate sum and check if divisible by 24

Count Valid

Count pairs that form complete days

Code -

solution.c — C

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

int solution(int* hours, int n) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if ((hours[i] + hours[j]) % 24 == 0) {
                count++;
            }
        }
    }
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int hours[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            hours[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(hours, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops checking all pairs

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a counter variable

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler