Count Good Meals - Practice Coding Problems

Count Good Meals - Problem

A good meal is a meal that contains exactly two different food items with a sum of deliciousness equal to a power of two.

You can pick any two different foods to make a good meal.

Given an array of integers deliciousness where deliciousness[i] is the deliciousness of the i-th item of food, return the number of different good meals you can make from this list modulo 10^9 + 7.

Note: Items with different indices are considered different even if they have the same deliciousness value.

Input & Output

Example 1 — Basic Case

$ Input: deliciousness = [1,3,5,7,9]

› Output: 4

💡 Note: Good meals are: (1,3)→4, (1,7)→8, (3,5)→8, (7,9)→16. All sums are powers of 2.

Example 2 — Duplicates

$ Input: deliciousness = [1,1,1,3,3,3,7]

› Output: 15

💡 Note: Multiple pairs can form same sum: 1+3=4 (9 combinations), 1+7=8 (3 combinations), 3+7=10 is not power of 2. Also 3+3=6 is not valid, but we need to check all pairs carefully.

Example 3 — No Valid Pairs

$ Input: deliciousness = [2,5,11]

› Output: 0

💡 Note: Check all pairs: 2+5=7 (not power of 2), 2+11=13 (not power of 2), 5+11=16 (power of 2). So result is 1, not 0. Actually (5,11)→16 is valid.

Constraints

1 ≤ deliciousness.length ≤ 2 × 10⁴
0 ≤ deliciousness[i] ≤ 2²⁰

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array of deliciousness values [1,3,5,7,9]

Find Pairs

Check all pairs for power-of-2 sums

Count Result

Return count of valid good meals

Key Takeaway

🎯 Key Insight: Only ~22 power-of-2 targets exist within constraints, so we can efficiently check complements using a hash map

Asked in

f Facebook 35 G Google 28 a Amazon 22

The key insight is that there are only ~22 possible power-of-2 sums within the constraint range (2^0 to 2^21). Best approach uses a hash map to count frequencies and check complements for each power-of-2 target in O(n) time. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Check every pair of elements to see if their sum is a power of two
Hash Map Optimization	O(n)	O(n)	Use hash map to count frequencies and check against power-of-2 targets

Brute Force — Algorithm Steps

Iterate through all pairs (i,j) where i < j
For each pair, check if sum is power of 2
Count valid pairs and return modulo 10^9+7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first element, compare with all others

Check Pairs

For each pair, test if sum is power of 2

Count Valid

Increment counter for valid pairs

Code -

solution.c — C

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

int isPowerOfTwo(int num) {
    return num > 0 && (num & (num - 1)) == 0;
}

int solution(int* deliciousness, int n) {
    const int MOD = 1000000007;
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (isPowerOfTwo(deliciousness[i] + deliciousness[j])) {
                count++;
            }
        }
    }
    
    return count % MOD;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int deliciousness[20000];
    int n = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        deliciousness[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(deliciousness, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all n×(n-1)/2 pairs

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

895 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