Related Articles

# Minimize swaps required to place largest and smallest array elements at first and last array indices

• Difficulty Level : Medium
• Last Updated : 06 May, 2021

Given an array arr[] of size N, the task is to find the minimum count of adjacent swaps required to rearrange the array elements such that the largest and the smallest array element present on the first and the last indices of the array respectively.

Examples:

Input: arr[] = {33, 44, 11, 12}
Output:
Explanation:
Swapping the pair (arr, arr) modifies arr[] to {44, 33, 11, 12}
Swapping the pair (arr, arr) modifies arr[] to {44, 33, 12, 11}
Therefore, the required output is 2.

Input: arr[]={11, 12, 58, 1, 78, 40, 76}
Output: 6

Approach: Follow the steps below to solve the problem:

• Traverse the array and calculate the index of the first occurrence of the largest array element say, X, and the last occurrence of the smallest array element say, Y.
• The count of adjacent swaps required to move the largest array element at the first index is equal to X.
• The count of adjacent swaps required to move the smallest array element at the last index is equal to N – 1 – Y.
• If X > Y, then one adjacent swap common in moving the largest element at the first index and the smallest element at the last index. Therefore, the total count of adjacent swaps required is equal to X + (N – 1 – Y) – 1.
• Otherwise, the total count of adjacent swaps required is equal to X + (N – 1 – Y).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to  find the minimum count of adjacent``// swaps to move largest and smallest element at the``// first and the last index of the array, respectively``int` `minimumMoves(``int``* a, ``int` `n)``{` `    ``// Stores the smallest array element``    ``int` `min_element = INT_MAX;` `    ``// Stores the smallest array element``    ``int` `max_element = INT_MIN;` `    ``// Stores the last occurrence of``    ``// the smallest array element``    ``int` `min_ind = -1;` `    ``// Stores the first occurrence of``    ``// the largest array element``    ``int` `max_ind = -1;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If a[i] is less than``        ``// min_element``        ``if` `(a[i] <= min_element) {` `            ``// Update min_element``            ``min_element = a[i];` `            ``// Update min_ind``            ``min_ind = i;``        ``}` `        ``// If a[i] is greater than``        ``// max_element``        ``if` `(a[i] > max_element) {` `            ``// Update max_element``            ``max_element = a[i];` `            ``// Update max_ind``            ``max_ind = i;``        ``}``    ``}` `    ``// If max_ind is equal``    ``// to min_ind``    ``if` `(max_ind == min_ind) {``        ``// Return 0``        ``return` `0;``    ``}` `    ``// If max_ind is greater than min_ind``    ``else` `if` `(max_ind > min_ind) {` `        ``return` `max_ind + (n - min_ind - 2);``    ``}` `    ``// Otherwise``    ``else` `{` `        ``return` `max_ind + n - min_ind - 1;``    ``}``}` `// Driver Code``int` `main()``{` `    ``// Input``    ``int` `arr[] = { 35, 46, 17, 23 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Print the result``    ``cout << minimumMoves(arr, N) << endl;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG``{` `// Function to  find the minimum count of adjacent``// swaps to move largest and smallest element at the``// first and the last index of the array, respectively``static` `int` `minimumMoves(``int` `[]a, ``int` `n)``{` `    ``// Stores the smallest array element``    ``int` `min_element = Integer.MAX_VALUE;` `    ``// Stores the smallest array element``    ``int` `max_element = Integer.MIN_VALUE;` `    ``// Stores the last occurrence of``    ``// the smallest array element``    ``int` `min_ind = -``1``;` `    ``// Stores the first occurrence of``    ``// the largest array element``    ``int` `max_ind = -``1``;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// If a[i] is less than``        ``// min_element``        ``if` `(a[i] <= min_element)``        ``{` `            ``// Update min_element``            ``min_element = a[i];` `            ``// Update min_ind``            ``min_ind = i;``        ``}` `        ``// If a[i] is greater than``        ``// max_element``        ``if` `(a[i] > max_element) {` `            ``// Update max_element``            ``max_element = a[i];` `            ``// Update max_ind``            ``max_ind = i;``        ``}``    ``}` `    ``// If max_ind is equal``    ``// to min_ind``    ``if` `(max_ind == min_ind) {``        ``// Return 0``        ``return` `0``;``    ``}` `    ``// If max_ind is greater than min_ind``    ``else` `if` `(max_ind > min_ind) {` `        ``return` `max_ind + (n - min_ind - ``2``);``    ``}` `    ``// Otherwise``    ``else` `{` `        ``return` `max_ind + n - min_ind - ``1``;``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{` `    ``// Input``    ``int` `arr[] = { ``35``, ``46``, ``17``, ``23` `};``    ``int` `N = arr.length;` `    ``// Print the result``    ``System.out.print(minimumMoves(arr, N) +``"\n"``);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 program for the above approach``import` `sys` `# Function to  find the minimum count of adjacent``# swaps to move largest and smallest element at the``# first and the last index of the array, respectively``def` `minimumMoves(a, n):``  ` `    ``# Stores the smallest array element``    ``min_element ``=` `sys.maxsize` `    ``# Stores the smallest array element``    ``max_element ``=` `-``sys.maxsize ``-` `1` `    ``# Stores the last occurrence of``    ``# the smallest array element``    ``min_ind ``=` `-``1` `    ``# Stores the first occurrence of``    ``# the largest array element``    ``max_ind ``=` `-``1` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(n):``      ` `        ``# If a[i] is less than``        ``# min_element``        ``if` `(a[i] <``=` `min_element):``          ` `            ``# Update min_element``            ``min_element ``=` `a[i]` `            ``# Update min_ind``            ``min_ind ``=` `i` `        ``# If a[i] is greater than``        ``# max_element``        ``if` `(a[i] > max_element):``          ` `            ``# Update max_element``            ``max_element ``=` `a[i]` `            ``# Update max_ind``            ``max_ind ``=` `i` `    ``# If max_ind is equal``    ``# to min_ind``    ``if` `(max_ind ``=``=` `min_ind):``      ` `        ``# Return 0``        ``return` `0` `    ``# If max_ind is greater than min_ind``    ``elif``(max_ind > min_ind):``        ``return` `max_ind ``+` `(n ``-` `min_ind ``-` `2``)` `    ``# Otherwise``    ``else``:``        ``return` `max_ind ``+` `n ``-` `min_ind ``-` `1` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Input``    ``arr ``=`  `[``35``, ``46``, ``17``, ``23``]``    ``N ``=` `len``(arr)` `    ``# Print the result``    ``print``(minimumMoves(arr, N))` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{` `  ``// Function to  find the minimum count of adjacent``  ``// swaps to move largest and smallest element at the``  ``// first and the last index of the array, respectively``  ``static` `int` `minimumMoves(``int` `[]a, ``int` `n)``  ``{` `    ``// Stores the smallest array element``    ``int` `min_element = ``int``.MaxValue;` `    ``// Stores the smallest array element``    ``int` `max_element = ``int``.MinValue;` `    ``// Stores the last occurrence of``    ``// the smallest array element``    ``int` `min_ind = -1;` `    ``// Stores the first occurrence of``    ``// the largest array element``    ``int` `max_ind = -1;` `    ``// Traverse the array []arr``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `      ``// If a[i] is less than``      ``// min_element``      ``if` `(a[i] <= min_element)``      ``{` `        ``// Update min_element``        ``min_element = a[i];` `        ``// Update min_ind``        ``min_ind = i;``      ``}` `      ``// If a[i] is greater than``      ``// max_element``      ``if` `(a[i] > max_element)``      ``{` `        ``// Update max_element``        ``max_element = a[i];` `        ``// Update max_ind``        ``max_ind = i;``      ``}``    ``}` `    ``// If max_ind is equal``    ``// to min_ind``    ``if` `(max_ind == min_ind)``    ``{` `      ``// Return 0``      ``return` `0;``    ``}` `    ``// If max_ind is greater than min_ind``    ``else` `if` `(max_ind > min_ind)``    ``{``      ``return` `max_ind + (n - min_ind - 2);``    ``}` `    ``// Otherwise``    ``else``    ``{``      ``return` `max_ind + n - min_ind - 1;``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``// Input``    ``int` `[]arr = { 35, 46, 17, 23 };``    ``int` `N = arr.Length;` `    ``// Print the result``    ``Console.Write(minimumMoves(arr, N) +``"\n"``);``  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`2`

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

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up