# Maximize the last Array element as per the given conditions

• Difficulty Level : Easy
• 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)

My Personal Notes arrow_drop_up