Count Good Meals

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: 12

💡 Note: Multiple pairs can form same sum: 1+3=4 (9 combinations), 1+7=8 (3 combinations). Total: 9+3=12.

Example 3 — No Valid Pairs

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

› Output: 1

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

Constraints

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

Visualization

Tap to expand

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

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

For each pair of indices (i,j) where i < j, calculate deliciousness[i] + deliciousness[j] and check if the sum is a power of two. Count all valid pairs.

Hash Map Optimization

⏱️ Time: O(n) Space: O(n)

For each element, check if its complement to form any power-of-2 sum exists in the hash map. Since there are only ~22 possible power-of-2 values within constraints, we can efficiently check all 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;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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