# 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
Recommended Articles
Page :