Skip to content
Related Articles
Maximize the last Array element as per the given conditions
• Difficulty Level : Medium
• Last Updated : 29 May, 2021

Given an array arr[] consisting of N integers, rearrange the array such that it satisfies the following conditions:

1. arr must be 1.
2. Difference between adjacent array elements should not exceed 1, that is, arr[i] – arr[i-1] ≤ 1 for all 1 ≤ i < N.

The permissible operations are as follows:

1. Rearrange the elements in any way.
2. Reduce any element to any number ≥ 1.

The task is to find the maximum possible value that can be placed at the last index of the array.

Examples:

Input: arr[] = {3, 1, 3, 4}
Output:
Explanation:
Subtracting 1 from the first element modifies the array to {2, 1, 3, 4}.
Swapping the first two elements modifies the array to {1, 2, 3, 4}.
Therefore, maximum value placed at the last index is 4.
Input: arr[] = {1, 1, 1, 1}
Output: 1

Approach:
To solve the given problem, sort the given array and balance it according to the given condition starting from left towards right. Follow the below steps to solve the problem:

• Sort the array in ascending order.
• If the first element is not 1, make it 1.
• Traverse the array over the indices [1, N – 1) and check if every adjacent element has a difference of ≤ 1.
• If not, decrement the value till the difference becomes ≤ 1.
• Return the last element of the array.

Below is the implementation of the above problem:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum possible value``// that can be placed at the last index``int` `maximizeFinalElement(``int` `arr[], ``int` `n)``{``    ``// Sort array in ascending order``    ``sort(arr, arr + n);` `    ``// If the first element``    ``// is not equal to 1``    ``if` `(arr != 1)``        ``arr = 1;` `    ``// Traverse the array to make``    ``// difference between adjacent``    ``// elements <=1``    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(arr[i] - arr[i - 1] > 1) {``            ``arr[i] = arr[i - 1] + 1;``        ``}``    ``}``    ``return` `arr[n - 1];``}` `// Driver Code``int` `main()``{``    ``int` `n = 4;``    ``int` `arr[] = { 3, 1, 3, 4 };` `    ``int` `max = maximizeFinalElement(arr, n);``    ``cout << max;` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{` `// Function to find the maximum possible value``// that can be placed at the last index``public` `static` `int` `maximizeFinalElement(``int` `arr[],``                                       ``int` `n)``{``    ` `    ``// Sort the array elements``    ``// in ascending order``    ``Arrays.sort(arr);` `    ``// If the first element is``    ``// is not equal to 1``    ``if` `(arr[``0``] != ``1``)``        ``arr[``0``] = ``1``;` `    ``// Traverse the array to make``    ``// difference between adjacent``    ``// elements <=1``    ``for``(``int` `i = ``1``; i < n; i++)``    ``{``        ``if` `(arr[i] - arr[i - ``1``] > ``1``)``        ``{``            ``arr[i] = arr[i - ``1``] + ``1``;``        ``}``    ``}``    ``return` `arr[n - ``1``];``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``int` `n = ``4``;``    ``int` `arr[] = { ``3``, ``1``, ``3``, ``4` `};``  ` `    ``int` `max = maximizeFinalElement(arr, n);``    ``System.out.print(max);``}``}`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the maximum possible value``# that can be placed at the last index``def` `maximizeFinalElement(arr, n):``    ` `    ``# Sort the array elements``    ``# in ascending order``    ``arr.sort();` `    ``# If the first element is``    ``# is not equal to 1``    ``if` `(arr[``0``] !``=` `1``):``        ``arr[``0``] ``=` `1``;` `    ``# Traverse the array to make``    ``# difference between adjacent``    ``# elements <=1``    ``for` `i ``in` `range``(``1``, n):``        ``if` `(arr[i] ``-` `arr[i ``-` `1``] > ``1``):``            ``arr[i] ``=` `arr[i ``-` `1``] ``+` `1``;` `    ``return` `arr[n ``-` `1``];` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``n ``=` `4``;``    ``arr ``=` `[``3``, ``1``, ``3``, ``4``];``    ` `    ``max` `=` `maximizeFinalElement(arr, n);``    ``print``(``max``);``    ` `# This code is contributed by Princi Singh`

## C#

 `// C# Program to implement``// the above approach``using` `System;``class` `GFG{` `// Function to find the maximum possible value``// that can be placed at the last index``public` `static` `int` `maximizeFinalElement(``int` `[]arr,``                                       ``int` `n)``{``    ``// Sort the array elements``    ``// in ascending order``    ``Array.Sort(arr);` `    ``// If the first element is``    ``// is not equal to 1``    ``if` `(arr != 1)``        ``arr = 1;` `    ``// Traverse the array to make``    ``// difference between adjacent``    ``// elements <=1``    ``for` `(``int` `i = 1; i < n; i++)``    ``{``        ``if` `(arr[i] - arr[i - 1] > 1)``        ``{``            ``arr[i] = arr[i - 1] + 1;``        ``}``    ``}` `    ``return` `arr[n - 1];``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 4;``    ``int` `[]arr = { 3, 1, 3, 4 };` `    ``int` `max = maximizeFinalElement(arr, n);``    ``Console.WriteLine(max);``}``}` `// This code is contributed by sapnasingh4991`

## Javascript

 ``
Output:
`4`

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up