Maximum Sized Array - Practice Coding Problems

Maximum Sized Array - Problem

Given a positive integer s, let A be a 3D array of dimensions n × n × n, where each element A[i][j][k] is defined as:

A[i][j][k] = i * (j OR k)

where 0 <= i, j, k < n and OR is the bitwise OR operation.

Return the maximum possible value of n such that the sum of all elements in array A does not exceed s.

Input & Output

Example 1 — Small Budget

$ Input: s = 6

› Output: 2

💡 Note: For n=2: sum = 0*(0|0) + 0*(0|1) + 0*(1|0) + 0*(1|1) + 1*(0|0) + 1*(0|1) + 1*(1|0) + 1*(1|1) = 0+0+0+0+0+1+1+1 = 3. For n=3: sum would be much larger. So maximum n=2.

Example 2 — Larger Budget

$ Input: s = 100

› Output: 4

💡 Note: For n=4, the sum of all A[i][j][k] = i*(j|k) values is within budget 100, but n=5 would exceed it.

Example 3 — Minimum Case

$ Input: s = 0

› Output: 1

💡 Note: For n=1: only A[0][0][0] = 0*(0|0) = 0, so sum=0 ≤ 0. For n=2, sum=3 > 0. Maximum n=1.

Constraints

1 ≤ s ≤ 10⁹
The answer n will be at most 10⁴

Visualization

Tap to expand

Understanding the Visualization

3D Array

Each A[i][j][k] = i * (j OR k)

Sum Constraint

Find max n where total sum ≤ s

Binary Search

Efficiently find the answer

Key Takeaway

🎯 Key Insight: The sum is monotonically increasing with n, enabling binary search on the answer space for optimal efficiency

Asked in

G Google 25 f Facebook 18 M Microsoft 15 a Amazon 12

The key insight is that the sum function is monotonically increasing, allowing binary search on the answer space. The optimal approach uses binary search with mathematical formula to compute sums efficiently. Time: O(log²n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(log²n)	O(1)	Binary search on the answer space to find maximum valid n efficiently
Brute Force	O(n⁴)	O(1)	Try every possible value of n starting from 1 until sum exceeds s
Mathematical Formula	O(n log n)	O(1)	Use mathematical formula to compute sum directly without triple loops

Binary Search on Answer — Algorithm Steps

Set left=1, right=large_value as search bounds
For mid=(left+right)/2, compute sum using formula
If sum <= s, search right half (left=mid+1)
If sum > s, search left half (right=mid-1)
Return the maximum valid n found

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Bounds

left=1, right=10000

Check Middle

Calculate sum for mid, compare with s

Narrow Search

Eliminate half of search space

Code -

solution.c — C

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

long long calculateSum(int n) {
    if (n == 0) return 0;
    
    long long total = 0;
    int maxBits = (int)log2(n) + 1;
    
    for (int bit = 0; bit < maxBits; bit++) {
        long long bitVal = 1LL << bit;
        if (bitVal >= n) break;
        
        long long countWithBit = (long long)n * n - (long long)(n - bitVal) * (n - bitVal);
        long long sumI = (long long)n * (n - 1) / 2;
        
        total += bitVal * sumI * countWithBit;
    }
    
    return total;
}

int solution(int s) {
    int left = 1, right = 10000;
    int result = 0;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (calculateSum(mid) <= s) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int s;
    scanf("%d", &s);
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log²n)

Binary search takes O(log n) iterations, each sum calculation is O(log n)

⚡ Linearithmic

Space Complexity

O(1)

Only uses variables for binary search bounds and computation

✓ Linear Space

23.4K Views

Medium Frequency

~35 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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler