Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

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

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: 2 
Explanation: 
Swapping the pair (arr[0], arr[1]) modifies arr[] to {44, 33, 11, 12} 
Swapping the pair (arr[2], arr[3]) 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:

Below is the implementation of the above approach:




// C++ program for the above approach
#include <bits/stdc++.h>
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 a[]
    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[0]);
 
    // Print the result
    cout << minimumMoves(arr, N) << endl;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// 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


















                        






                        























                                    



                                    




                                    




                                    


                                



















# 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# 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


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


// javascript program of the above approach


 


// 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



function minimumMoves(a, n)



{


 



    // Stores the smallest array element




    let min_element = Number.MAX_VALUE;



 



    // Stores the smallest array element




    let max_element = Number.MIN_VALUE;



 



    // Stores the last occurrence of




    // the smallest array element




    let min_ind = -1;



 



    // Stores the first occurrence of




    // the largest array element




    let max_ind = -1;



 



    // Traverse the array arr[]




    for (let 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




     



       // Input




    let arr = [ 35, 46, 17, 23 ];




    let N = arr.length;



 



    // Print the result




    document.write(minimumMoves(arr, N) +"\n");



 


</script>


















                        






                        








Output: 

2


 


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

	

        Article Tags : 
        

            Arrays
DSA
Mathematical
Technical Scripter        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Minimize swaps required to make the first and last elements the largest and smallest elements in the array respectively

          
2. Minimum number of swaps required to make parity of array elements  same as their indices

          
3. Count pairs of indices having sum of indices same as the sum of elements at those indices

          
4. Count of indices pairs such that product of elements at these indices is equal to absolute difference of indices

          
5. Count of unordered pair of indices such that ratio of elements at these indices is same as ratio of indices

          
6. Minimize swaps required to maximize the count of elements replacing a greater element in an Array

          
7. Minimize count of swaps of adjacent elements required to make an array increasing

          
8. Minimum number of swaps required to minimize sum of absolute differences between adjacent array elements

          
9. Place first N natural numbers at indices not equal to their values in an array

          
10. Minimize swaps required to make all prime-indexed elements as prime

          
11. Lexicographically largest string using at most K swaps at same parity indices

          
12. Minimum swaps to minimize the sum of first K elements of the Permutation

          
13. Minimize swaps between two arrays such that sum of the first array exceeds sum of the second array

          
14. Rearrange an array in order - smallest, largest, 2nd smallest, 2nd largest, ..

          
15. Find the Array Permutation having sum of elements at odd indices greater than sum of elements at even indices

          
16. Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array

          
17. Minimize swaps of pairs of characters required such that no two adjacent characters in the string are same

          
18. Minimize replacements of leftmost largest array element required to make all array elements equal

          
19. Count distinct sequences obtained by replacing all elements of subarrays having equal first and last elements with the first element any number of times

          
20. Minimum number of swaps required to sort an array of first N number

          
21. Minimum adjacent swaps required to get Kth smallest number greater than given number

          
22. Minimum swaps to reach permuted array with at most 2 positions left swaps allowed

          
23. Minimum swaps of similar indexed elements required to make all elements of one of the two given arrays equal

          
24. Minimize absolute difference between the smallest and largest array elements by minimum increment decrement operations

          
25. Minimize difference between the largest and smallest array elements by K replacements