Maximum AND Sum of Array - Practice Coding Problems

Maximum AND Sum of Array - Problem

Maximum AND Sum of Array

You are given an integer array nums of length n and an integer numSlots such that 2 * numSlots >= n. There are numSlots slots numbered from 1 to numSlots.

Your task is to optimally place all n integers into the slots such that each slot contains at most two numbers. The AND sum of a given placement is the sum of the bitwise AND of every number with its respective slot number.

Example: Placing the numbers [1, 3] into slot 1 and [4, 6] into slot 2 gives:
(1 AND 1) + (3 AND 1) + (4 AND 2) + (6 AND 2) = 1 + 1 + 0 + 2 = 4

Return the maximum possible AND sum of nums given numSlots slots. This is a challenging optimization problem that requires exploring different assignment strategies to maximize the total bitwise AND sum.

Input & Output

example_1.py — Basic case

$ Input: nums = [1,2,3,4,5,6], numSlots = 3

› Output: 9

💡 Note: One optimal assignment is: Slot 1: [1,4] → (1&1)+(4&1) = 1+0 = 1, Slot 2: [2,6] → (2&2)+(6&2) = 2+2 = 4, Slot 3: [3,5] → (3&3)+(5&3) = 3+1 = 4. Total: 1+4+4 = 9

example_2.py — Simple case

$ Input: nums = [1,3,10,4,7,1], numSlots = 9

› Output: 24

💡 Note: One optimal assignment is to place each number in its own slot: (1&1)+(3&2)+(10&3)+(4&4)+(7&5)+(1&6) = 1+2+2+4+5+0 = 14. But we can do better by strategic placement to get 24.

example_3.py — Edge case

$ Input: nums = [1], numSlots = 1

› Output: 1

💡 Note: Only one number and one slot. The AND sum is simply (1&1) = 1.

Visualization

Tap to expand

Understanding the Visualization

Setup rooms

We have numSlots rooms numbered 1 to numSlots, each can hold up to 2 guests

Calculate rent

Each guest pays rent equal to (guest_number AND room_number)

Track occupancy

Use bitmask to efficiently track how many guests are in each room

Find optimal assignment

Use dynamic programming to try all valid assignments and maximize total rent

Key Takeaway

🎯 Key Insight: Use bitmask to efficiently represent all possible room occupancy states, and dynamic programming with memoization to avoid recomputing subproblems, making this exponential problem tractable.

Time & Space Complexity

Time Complexity

⏱️

O(n * 3^numSlots)

Each slot has 3 states, so 3^numSlots possible states, and we process n numbers

✓ Linear Growth

Space Complexity

O(3^numSlots)

Memoization table stores results for all possible slot state combinations

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ numSlots ≤ 9
1 ≤ n ≤ 2 * numSlots
1 ≤ nums[i] ≤ 15
Each slot can contain at most 2 numbers

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 6

The optimal solution uses dynamic programming with bitmask to track slot occupancy states. Each slot can hold 0, 1, or 2 numbers, represented using 2 bits per slot in a bitmask. We use memoization to cache results for each (number_index, slot_state_mask) combination, achieving O(n * 3^numSlots) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Assignments)	O((2*numSlots)^n)	O(n)	Generate all possible ways to assign numbers to slots and find maximum
Dynamic Programming with Bitmask (Optimal)	O(n * 3^numSlots)	O(3^numSlots)	Use bitmask DP to track slot states and memoize subproblem results

Brute Force (Try All Assignments) — Algorithm Steps

Start with the first number in the array
For each number, try placing it in each slot that has space (0 or 1 numbers)
Recursively solve for the remaining numbers
Calculate AND sum for each complete assignment
Return the maximum sum found across all assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first number

Try placing first number in each available slot

Recursive exploration

For each placement, recursively solve remaining numbers

Backtrack and try next

Remove number from slot and try next position

Find maximum

Return the maximum sum across all complete assignments

Code -

solution.c — C

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

int backtrack(int index, int* nums, int numsSize, int* slots, int numSlots) {
    if (index == numsSize) {
        return 0;
    }
    
    int maxSum = 0;
    for (int slot = 1; slot <= numSlots; slot++) {
        if (slots[slot - 1] < 2) {
            slots[slot - 1]++;
            int currentSum = (nums[index] & slot) + backtrack(index + 1, nums, numsSize, slots, numSlots);
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
            slots[slot - 1]--;
        }
    }
    
    return maxSum;
}

int maximumANDSum(int* nums, int numsSize, int numSlots) {
    int* slots = (int*)calloc(numSlots, sizeof(int));
    int result = backtrack(0, nums, numsSize, slots, numSlots);
    free(slots);
    return result;
}

int main() {
    int nums[] = {1, 2, 3, 4, 5, 6};
    int numSlots = 3;
    printf("%d\n", maximumANDSum(nums, 6, numSlots));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((2*numSlots)^n)

For each of n numbers, we try up to 2*numSlots positions, leading to exponential growth

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals the number of elements

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ numSlots ≤ 9
1 ≤ n ≤ 2 * numSlots
1 ≤ nums[i] ≤ 15
Each slot can contain at most 2 numbers

23.8K Views

Medium Frequency

~35 min Avg. Time

847 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 (Try All Assignments) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler