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

Count Pairs That Form a Complete Day I - Problem

You're given an array of hours representing different time durations. Your task is to find how many pairs of these hours can be combined to form a complete day (exactly 24 hours or any multiple of 24).

A complete day means the sum of two hours equals 24k where k is any positive integer:

1 day = 24 hours
2 days = 48 hours
3 days = 72 hours
and so on...

Important: You can only count pairs where i < j (avoid counting the same pair twice).

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

Input & Output

example_1.py — Basic case

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

› Output: 2

💡 Note: The pairs (0,1) and (3,4) form complete days: 12+12=24 and 24+24=48. Both are multiples of 24.

example_2.py — No valid pairs

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

› Output: 3

💡 Note: Valid pairs are (0,3): 72+3=75→no, (1,3): 48+3=51→no, (2,3): 24+3=27→no, (0,1): 72+48=120→yes, (0,2): 72+24=96→yes, (1,2): 48+24=72→yes. So 3 pairs total.

example_3.py — Single element

$ Input: hours = [1]

› Output: 0

💡 Note: With only one element, no pairs can be formed, so the result is 0.

Visualization

Tap to expand

Understanding the Visualization

Shape Classification

Each hour gets a shape based on hour % 24 (0-23 possible shapes)

Complement Search

For each piece, we look for pieces with complementary shapes

Perfect Matches

Shape A + Shape B = 24 means they form a complete circle

Count & Update

Count existing matches, then add current piece to collection

Key Takeaway

🎯 Key Insight: The magic of modular arithmetic transforms a complex pairing problem into simple complement counting. Each remainder from 0-23 has exactly one complement that forms a complete day!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each operation is O(1) with hash map

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 24 different remainders (0 to 23), which is constant space

✓ Linear Space

Constraints

1 ≤ hours.length ≤ 100
1 ≤ hours[i] ≤ 10⁹
All pairs must satisfy i < j condition

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses modular arithmetic with a hash table to count pairs in O(n) time. Key insight: two numbers form a complete day if their remainders when divided by 24 sum to 0 or 24. We track remainder frequencies and count complementary pairs in a single pass.

Common Approaches

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

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each element with index i
For each i, iterate through all elements j where j > i
Check if (hours[i] + hours[j]) % 24 == 0
If yes, increment the pair counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Check element at index 0 against all elements after it

Check pair sums

For each pair, calculate sum and check if divisible by 24

Move to next element

Continue with element at index 1, then 2, and so on

Count valid pairs

Increment counter whenever we find a pair that sums to multiple of 24

Code -

solution.c — C

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

int countCompleteDayPairs(int* hours, int hoursSize) {
    int count = 0;
    
    // Check all pairs (i, j) where i < j
    for (int i = 0; i < hoursSize; i++) {
        for (int j = i + 1; j < hoursSize; j++) {
            // Check if sum is divisible by 24
            if ((hours[i] + hours[j]) % 24 == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int hours[1000];
    int size = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input
    char* token = strtok(input, "[],\n ");
    while (token != NULL && size < 1000) {
        hours[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", countCompleteDayPairs(hours, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have nested loops: outer loop runs n times, inner loop runs up to n times, giving us n×n operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track indices and count, no additional data structures

✓ Linear Space

Constraints

1 ≤ hours.length ≤ 100
1 ≤ hours[i] ≤ 10⁹
All pairs must satisfy i < j condition

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler