Replace Elements with Greatest Element on Right Side

Replace Elements with Greatest Element on Right Side - Problem

Array Easy

Given an array arr, your task is to transform it by replacing every element with the greatest element among all the elements to its right side. The rightmost element has no elements to its right, so it should be replaced with -1.

For example, if you have the array [17, 18, 5, 4, 6, 1], you need to:

Replace 17 with the maximum of [18, 5, 4, 6, 1] which is 18
Replace 18 with the maximum of [5, 4, 6, 1] which is 6
Replace 5 with the maximum of [4, 6, 1] which is 6
Continue this process...
Replace the last element 1 with -1

The goal is to return the modified array after all replacements are complete.

Input & Output

example_1.py — Basic Array

$ Input: arr = [17,18,5,4,6,1]

› Output: [18,6,6,6,1,-1]

💡 Note: For index 0: max of [18,5,4,6,1] is 18. For index 1: max of [5,4,6,1] is 6. For index 2: max of [4,6,1] is 6. For index 3: max of [6,1] is 6. For index 4: max of [1] is 1. Index 5 becomes -1.

example_2.py — Single Element

$ Input: arr = [400]

› Output: [-1]

💡 Note: There's only one element, so it has no elements to its right. According to the problem, it should be replaced with -1.

example_3.py — Decreasing Array

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

› Output: [7,5,3,1,-1]

💡 Note: In a decreasing array, each element's replacement is simply the next element to its right, except the last which becomes -1.

Constraints

1 ≤ arr.length ≤ 10⁴
1 ≤ arr[i] ≤ 10⁵
Follow-up: Could you solve it without using extra space?

Visualization

Tap to expand

Understanding the Visualization

Start at the End

Begin from the last element. Since it has no elements to its right, replace it with -1. Track the maximum seen so far.

Move Backwards

For each element moving right to left, replace it with the current maximum, then update the maximum with the current element's original value.

Complete the Process

Continue until you reach the beginning. Each element gets replaced with the maximum of all elements that were originally to its right.

Key Takeaway

🎯 Key Insight: Working backwards allows us to incrementally build the maximum of right-side elements, achieving optimal O(n) time complexity with constant space.

Asked in

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

The optimal solution uses reverse iteration to solve this problem in O(n) time and O(1) space. By traversing the array from right to left while tracking the maximum element seen so far, we can replace each element with the correct value in a single pass. This approach is much more efficient than the naive O(n²) solution that repeatedly scans subarrays.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each element, scan all elements to its right to find the maximum
Reverse Iteration (Optimal)	O(n)	O(1)	Traverse from right to left, keeping track of the maximum seen so far

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each element from index 0 to n-2
For each element, scan all elements from current index + 1 to end
Find the maximum among these right-side elements
Replace current element with this maximum
Replace the last element with -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Process element at index 0

Scan indices 1-5 to find maximum (18)

Process element at index 1

Scan indices 2-5 to find maximum (6)

Process element at index 2

Scan indices 3-5 to find maximum (6)

Code -

solution.c — C

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

int* replaceElements(int* arr, int arrSize, int* returnSize) {
    *returnSize = arrSize;
    
    // Process each element except the last one
    for (int i = 0; i < arrSize - 1; i++) {
        int maxRight = arr[i + 1];
        // Find maximum in right subarray
        for (int j = i + 2; j < arrSize; j++) {
            if (arr[j] > maxRight) {
                maxRight = arr[j];
            }
        }
        arr[i] = maxRight;
    }
    
    // Replace last element with -1
    arr[arrSize - 1] = -1;
    return arr;
}

int main() {
    int arr[] = {17, 18, 5, 4, 6, 1};
    int size = 6;
    int returnSize;
    int* result = replaceElements(arr, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan up to n-1 elements to find maximum

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, modifying array in-place

✓ Linear Space

68.5K Views

Medium Frequency

~15 min Avg. Time

2.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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler