Maximum Value at a Given Index in a Bounded Array

Maximum Value at a Given Index in a Bounded Array - Problem

Imagine you're designing a mountain-like array where each element can only differ from its neighbors by at most 1. You need to construct an array of length n where you want to maximize the value at a specific index while keeping the total sum within a given budget.

The Challenge: Given three positive integers n, index, and maxSum, construct an array nums that satisfies:

Array has exactly n elements (0-indexed)
All elements are positive integers
Adjacent elements differ by at most 1: |nums[i] - nums[i+1]| ≤ 1
Total sum doesn't exceed maxSum
nums[index] is maximized

Your goal: Return the maximum possible value at nums[index].

Example: With n=4, index=2, maxSum=6, the optimal array is [1,2,3,2] where nums[2] = 3.

Input & Output

example_1.py — Basic Mountain

$ Input: n=4, index=2, maxSum=6

› Output: 2

💡 Note: The optimal array is [1,2,3,2] but sum=8 > 6. So we try [1,1,2,1] with sum=5 ≤ 6, giving nums[2]=2. Actually, we can do [1,1,2,2] with sum=6, so answer is 2.

example_2.py — Small Array

$ Input: n=1, index=0, maxSum=10

› Output: 10

💡 Note: With only one element, we can make it as large as possible: nums[0]=10, sum=10 ≤ 10.

example_3.py — Large Budget

$ Input: n=3, index=1, maxSum=18

› Output: 7

💡 Note: The optimal array is [6,7,6] with sum=19 > 18. We try [5,6,5] with sum=16 ≤ 18. But we can do better: [6,7,5] has sum=18 ≤ 18, so answer is 7.

Constraints

1 ≤ n ≤ 10⁹
0 ≤ index < n
1 ≤ maxSum ≤ 10⁹
All elements must be positive integers
Adjacent elements can differ by at most 1

Visualization

Tap to expand

Understanding the Visualization

Understand the Shape

Optimal array forms mountain: peak at index, slopes down to edges

Binary Search Setup

Search range [1, maxSum] for maximum valid peak height

Calculate Minimum Sum

For each height, compute minimum sum needed for optimal mountain

Adjust Search Range

If sum ≤ maxSum, try higher; if sum > maxSum, try lower

Key Takeaway

🎯 Key Insight: The optimal solution uses binary search on the peak height combined with mathematical formulas to calculate the minimum sum for each mountain shape, achieving O(log maxSum) time complexity.

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal approach uses binary search to find the maximum peak height efficiently. Key insight: the optimal array forms a mountain shape with peak at the target index and slopes down symmetrically to minimize total sum while maximizing the peak value. Time complexity: O(log maxSum).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log maxSum)	O(1)	Binary search on the answer - find maximum peak height that keeps sum ≤ maxSum
Brute Force (Try All Heights)	O(maxSum × n)	O(1)	Try every possible value at index and check if valid array can be constructed

Binary Search (Optimal) — Algorithm Steps

Set search range: low=1, high=maxSum
For middle value, calculate minimum sum for optimal mountain with that peak
If sum ≤ maxSum, this height is valid - try higher (low = mid + 1)
If sum > maxSum, this height is too high - try lower (high = mid - 1)
Continue until low > high, return the maximum valid height found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Set left=1, right=maxSum. Search space: [1...maxSum]

Test Middle

Try mid=(left+right)/2. Calculate minimum sum for this height.

Narrow Search

If sum ≤ maxSum: try higher (left=mid+1), else try lower (right=mid-1)

Find Answer

Continue until left > right. Return maximum valid height found.

Code -

solution.c — C

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

long long calculateMinSum(int n, int index, int height) {
    long long total = height; // Peak value
    
    // Left side
    int leftPositions = index;
    if (leftPositions > 0) {
        if (height > leftPositions) {
            long long triangleSum = (long long)leftPositions * (2LL * height - leftPositions - 1) / 2;
            total += triangleSum;
        } else {
            long long triangleSum = (long long)(height - 1) * height / 2;
            long long remainingOnes = leftPositions - (height - 1);
            total += triangleSum + remainingOnes;
        }
    }
    
    // Right side
    int rightPositions = n - index - 1;
    if (rightPositions > 0) {
        if (height > rightPositions) {
            long long triangleSum = (long long)rightPositions * (2LL * height - rightPositions - 1) / 2;
            total += triangleSum;
        } else {
            long long triangleSum = (long long)(height - 1) * height / 2;
            long long remainingOnes = rightPositions - (height - 1);
            total += triangleSum + remainingOnes;
        }
    }
    
    return total;
}

int maxValue(int n, int index, int maxSum) {
    int left = 1, right = maxSum;
    int result = 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (calculateMinSum(n, index, mid) <= maxSum) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int n, index, maxSum;
    scanf("%d %d %d", &n, &index, &maxSum);
    printf("%d\n", maxValue(n, index, maxSum));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log maxSum)

Binary search reduces search space by half each iteration, sum calculation is O(1)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for binary search variables

✓ Linear Space

21.5K Views

Medium Frequency

~18 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler