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

Count Pairs That Form a Complete Day II - Problem

You're given an integer array hours representing time durations in hours. Your task is to find 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:

24 hours = 1 complete day
48 hours = 2 complete days
72 hours = 3 complete days

Key insight: Two numbers sum to a multiple of 24 if and only if the sum of their remainders when divided by 24 equals 0 or 24.

Example: If hours = [12, 12, 30, 24, 24], the pairs (0,1), (3,4) form complete days because 12+12=24 and 24+24=48.

Input & Output

example_1.py — Basic pairing

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

› Output: 2

💡 Note: Pair (0,1): hours[0] + hours[1] = 12 + 12 = 24 (1 complete day). Pair (3,4): hours[3] + hours[4] = 24 + 24 = 48 (2 complete days). Total: 2 pairs.

example_2.py — No valid pairs

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

› Output: 3

💡 Note: All pairs: (0,1)=120hrs, (0,2)=96hrs, (0,3)=75hrs, (1,2)=72hrs, (1,3)=51hrs, (2,3)=27hrs. Valid pairs: (0,1), (0,2), (1,2) as 120, 96, and 72 are all multiples of 24.

example_3.py — Single element

$ Input: [1, 23, 25, 47]

› Output: 2

💡 Note: Pair (0,1): 1 + 23 = 24. Pair (2,3): 25 + 47 = 72 (which is 24×3). Both form complete days.

Visualization

Tap to expand

Understanding the Visualization

Map to clock positions

Convert each hour to its position on 24-hour clock (hour % 24)

Find complements

For position X, find how many previous elements were at position (24-X)%24

Count pairs

Each complement match represents a valid pair that sums to multiple of 24

Key Takeaway

🎯 Key Insight: Only remainders modulo 24 matter! This reduces the problem to counting complementary remainders in a fixed-size array.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, with O(1) operations per element

✓ Linear Growth

Space Complexity

O(1)

Fixed-size array of 24 elements regardless of input size

✓ Linear Space

Constraints

1 ≤ hours.length ≤ 10⁵
1 ≤ hours[i] ≤ 10⁹
Note: This is the 'II' version, optimized for larger constraints

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 28 Apple 22

The optimal solution uses a one-pass hash table approach with remainder counting. Key insight: only the remainder when divided by 24 matters for pairing. For each element, we find its complement remainder and count previous elements with that remainder, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(1)	Use remainder frequency counting to find pairs efficiently in one pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of hours to see if their sum is divisible by 24

One-Pass Hash Table (Optimal) — Algorithm Steps

Create an array to count frequency of each remainder (0-23)
For each hour, calculate remainder = hour % 24
Calculate complement = (24 - remainder) % 24
Add frequency[complement] to result (pairs with previous elements)
Increment frequency[remainder] for current element
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate remainder

For each hour, find hour % 24

Find complement

Calculate what remainder would sum to 24 with current

Count and update

Add existing complement count, then update current remainder count

Code -

solution.c — C

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

long long countCompleteDayPairs(int* hours, int n) {
    int remainderCount[24] = {0};
    long long count = 0;
    
    for (int i = 0; i < n; i++) {
        int remainder = hours[i] % 24;
        int complement = (24 - remainder) % 24;
        count += remainderCount[complement];
        remainderCount[remainder]++;
    }
    
    return count;
}

int main() {
    int hours[100000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // skip '['
    while (scanf("%d", &hours[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    printf("%lld\n", countCompleteDayPairs(hours, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, with O(1) operations per element

✓ Linear Growth

Space Complexity

O(1)

Fixed-size array of 24 elements regardless of input size

✓ Linear Space

Constraints

1 ≤ hours.length ≤ 10⁵
1 ≤ hours[i] ≤ 10⁹
Note: This is the 'II' version, optimized for larger constraints

52.3K Views

Medium-High Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler