Maximum Sized Array - Practice Coding Problems

Maximum Sized Array - Problem

You are a data structure architect tasked with creating the largest possible 3D array while staying within memory constraints!

Given a positive integer s representing your memory budget, you need to determine the maximum size n for a 3D array A of dimensions n × n × n.

Each element in the array is calculated using a special formula: A[i][j][k] = i * (j OR k), where 0 ≤ i, j, k < n and OR is the bitwise OR operation.

Your goal is to find the maximum possible value of n such that the sum of all elements in array A does not exceed s.

Example: If s = 10, you need to find the largest n where the total sum of all n³ elements ≤ 10.

Input & Output

example_1.py — Small Budget

$ Input: s = 8

› Output: 2

💡 Note: For n=2: A[0][0][0]=0, A[0][0][1]=0, A[0][1][0]=0, A[0][1][1]=0, A[1][0][0]=0, A[1][0][1]=1, A[1][1][0]=1, A[1][1][1]=1. Sum = 3 ≤ 8. For n=3, sum would be much larger, so answer is 2.

example_2.py — Larger Budget

$ Input: s = 100

› Output: 4

💡 Note: The largest 4×4×4 array has sum ≤ 100, but a 5×5×5 array would exceed the budget.

example_3.py — Minimal Budget

$ Input: s = 1

› Output: 1

💡 Note: Only a 1×1×1 array fits: A[0][0][0] = 0*(0|0) = 0 ≤ 1. Any larger array would exceed budget.

Constraints

1 ≤ s ≤ 10⁹
The answer n will be at most 1000 for given constraints
Note: Be careful with integer overflow when calculating sums

Visualization

Tap to expand

Understanding the Visualization

Understand Formula

Each cell A[i][j][k] = i * (j OR k) - the value depends on position and bitwise OR

Calculate Total

Sum all cells in the n×n×n cube to get total cost

Binary Search

Efficiently find the largest n where total ≤ budget

Key Takeaway

🎯 Key Insight: Binary search leverages the monotonic relationship between array size and total sum, allowing us to efficiently find the maximum feasible dimension in O(n² log n) time instead of O(n⁴).

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 29

The optimal approach uses binary search on the array size n combined with an optimized sum calculation. Instead of testing every possible n linearly, we efficiently narrow down the search space. The key insight is that the sum grows monotonically with n, making binary search perfect for finding the maximum feasible size.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n⁴)	O(1)	Try every possible n from 1 upward until sum exceeds s
Binary Search with Sum Formula	O(n² log n)	O(1)	Use binary search on n with optimized sum calculation

Brute Force (Linear Search) — Algorithm Steps

Start with n = 1
For each n, calculate sum of all A[i][j][k] = i * (j OR k)
Use three nested loops to iterate through all i, j, k combinations
If sum > s, return n-1
Otherwise increment n and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Test n=1

Calculate sum for 1×1×1 array

Test n=2

Calculate sum for 2×2×2 array

Test n=3

Continue until sum exceeds s

Code -

solution.c — C

#include <stdio.h>

int maxSizedArray(int s) {
    int n = 1;
    while (1) {
        long long totalSum = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    totalSum += (long long) i * (j | k);
                }
            }
        }
        
        if (totalSum > s) {
            return n - 1;
        }
        n++;
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

For each n we test (up to answer), we need O(n³) to calculate sum with three nested loops

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current n and running sum

✓ Linear Space

31.4K Views

Medium Frequency

~28 min Avg. Time

856 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 (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler