Count Good Meals - Practice Coding Problems

Count Good Meals - Problem

Count Good Meals

You're hosting a dinner party and want to create the perfect meal combinations! A good meal consists of exactly two different food items whose combined deliciousness equals a power of two (1, 2, 4, 8, 16, 32, ...).

Given an array deliciousness where deliciousness[i] represents the deliciousness value of the i^th food item, return the number of different good meals you can create.

Important: Items at different indices are considered different even if they have the same deliciousness value. Return your answer modulo 10⁹ + 7.

Example: If deliciousness = [1,3,5,7,9], you can make meals like (1,3)→4=2², (3,5)→8=2³, (7,9)→16=2⁴

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Good meals are: (1,3)→4=2², (1,7)→8=2³, (3,5)→8=2³, (7,9)→16=2⁴. Total count = 4.

example_2.py — Duplicates

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

› Output: 15

💡 Note: Pairs: 6 pairs of (1,3)→4=2², 6 pairs of (1,7)→8=2³, 3 pairs of (3,3)→6≠power of 2. Wait, let me recalculate: (1,3) gives us 3×3=9 combinations, (1,7) gives us 3×1=3 combinations, (3,7) isn't power of 2. Actually: 9+3=12 invalid calculation. Correct: 3×3=9 pairs for (1,3), 3×1=3 pairs for (1,7), total=12. Need to verify.

example_3.py — Edge Case

$ Input: deliciousness = [2048]

› Output: 0

💡 Note: Only one element, cannot form any pairs. Output is 0.

Constraints

1 ≤ deliciousness.length ≤ 10⁵
0 ≤ deliciousness[i] ≤ 2²⁰
Maximum possible sum is 2²¹, so we only need to check 22 powers of two
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Setup Kitchen

Prepare a special catalog (hash map) to track ingredients as you encounter them

Magic Numbers

Pre-calculate all magical totals (powers of 2: 1, 2, 4, 8, 16, 32, 64...)

Perfect Pairing

For each new ingredient, check if any previous ingredient would create a magical total

Count Combinations

Add up all the valid magical combinations discovered

Key Takeaway

🎯 Key Insight: Instead of checking all n² pairs, we only check n × 22 complement lookups by leveraging the limited set of possible power-of-two sums!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a hash map to store frequencies while checking for power-of-two complements. Instead of checking all pairs (O(n²)), we process each element once and check only 22 possible powers of two, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n * 22) = O(n)	O(n)	Build hash map and search for power-of-two complements simultaneously in one pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair of food items to see if their sum is a power of two

One-Pass Hash Table (Optimal) — Algorithm Steps

Create a hash map to store frequency of food items seen so far
Pre-generate all relevant powers of two (1, 2, 4, 8, ..., 2^21)
For each food item, check against all powers of two to find complements
If complement exists in hash map, add its frequency to result
Add current food item to hash map and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Element

Take current food item and check against all powers of two

Find Complements

For each power of two, calculate complement = power - current_food

Hash Lookup

Check if complement exists in hash map and add its frequency to result

Update Map

Add current food to hash map for future lookups

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_HASH 100000

typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

Node* hash_table[MAX_HASH];

int hash_func(int key) {
    return ((long long)key * 31) % MAX_HASH;
}

void put(int key, int value) {
    int idx = hash_func(key);
    Node* node = hash_table[idx];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->key = key;
    new_node->value = value;
    new_node->next = hash_table[idx];
    hash_table[idx] = new_node;
}

int get(int key) {
    int idx = hash_func(key);
    Node* node = hash_table[idx];
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

int countPairs(int* deliciousness, int deliciousnessSize) {
    long long count = 0;
    
    // Initialize hash table
    for (int i = 0; i < MAX_HASH; i++) {
        hash_table[i] = NULL;
    }
    
    // Pre-generate powers of two
    int powers[22];
    for (int i = 0; i < 22; i++) {
        powers[i] = 1 << i;
    }
    
    for (int i = 0; i < deliciousnessSize; i++) {
        int food = deliciousness[i];
        
        // Check complements
        for (int j = 0; j < 22; j++) {
            int complement = powers[j] - food;
            int freq = get(complement);
            if (freq > 0) {
                count = (count + freq) % MOD;
            }
        }
        
        // Add current food
        put(food, get(food) + 1);
    }
    
    return (int) count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 22) = O(n)

Single pass through array, checking at most 22 powers of two for each element

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n unique elements in worst case

⚡ Linearithmic Space

38.5K Views

High Frequency

~25 min Avg. Time

1.5K 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler