Skip to content
Related Articles

Related Articles

Minimum swaps required to bring all elements less than or equal to k together

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 30 Jun, 2022

Given an array of n positive integers and a number k. Find the minimum number of swaps required to bring all the numbers less than or equal to k together. 
 

Input:  arr[] = {2, 1, 5, 6, 3}, k = 3
Output: 1

Explanation: 
To bring elements 2, 1, 3 together, swap 
element '5' with '3' such that final array
will be-
arr[] = {2, 1, 3, 6, 5}

Input:  arr[] = {2, 7, 9, 5, 8, 7, 4}, k = 5
Output: 2

 

A simple solution is to first count all elements less than or equal to k(say ‘good’). Now traverse for every sub-array and swap those elements whose value is greater than k. The time complexity of this approach is O(n2)
An efficient approach is to use the two-pointer technique and a sliding window. The time complexity of this approach is O(n)
 

  1. Find the count of all elements which are less than or equal to ‘k’. Let’s say the count is ‘cnt’
  2. Using the two-pointer technique for a window of length ‘cnt’, each time keep track of how many elements in this range are greater than ‘k’. Let’s say the total count is ‘bad’.
  3. Repeat step 2, for every window of length ‘cnt’ and take a minimum of count ‘bad’ among them. This will be the final answer.

Flowchart

Flowchart minswap


C++




// C++ program to find minimum swaps required
// to club all elements less than or equals
// to k together
#include <iostream>
using namespace std;
 
// Utility function to find minimum swaps
// required to club all elements less than
// or equals to k together
int minSwap(int *arr, int n, int k) {
     
    // Find count of elements which are
    // less than equals to k
    int count = 0;
    for (int i = 0; i < n; ++i)
        if (arr[i] <= k)
            ++count;
     
    // Find unwanted elements in current
    // window of size 'count'
    int bad = 0;
    for (int i = 0; i < count; ++i)
        if (arr[i] > k)
            ++bad;
     
    // Initialize answer with 'bad' value of
    // current window
    int ans = bad;
    for (int i = 0, j = count; j < n; ++i, ++j) {
         
        // Decrement count of previous window
        if (arr[i] > k)
            --bad;
         
        // Increment count of current window
        if (arr[j] > k)
            ++bad;
         
        // Update ans if count of 'bad'
        // is less in current window
        ans = min(ans, bad);
    }
    return ans;
}
 
// Driver code
int main() {
     
    int arr[] = {2, 1, 5, 6, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
    cout << minSwap(arr, n, k) << "\n";
     
    int arr1[] = {2, 7, 9, 5, 8, 7, 4};
    n = sizeof(arr1) / sizeof(arr1[0]);
    k = 5;
    cout << minSwap(arr1, n, k);
    return 0;
}


Java




// Java program to find minimum
// swaps required to club all
// elements less than or equals
// to k together
import java.lang.*;
 
class GFG {
     
// Utility function to find minimum swaps
// required to club all elements less than
// or equals to k together
static int minSwap(int arr[], int n, int k) {
 
    // Find count of elements which are
    // less than equals to k
    int count = 0;
    for (int i = 0; i < n; ++i)
    if (arr[i] <= k)
        ++count;
 
    // Find unwanted elements in current
    // window of size 'count'
    int bad = 0;
    for (int i = 0; i < count; ++i)
    if (arr[i] > k)
        ++bad;
 
    // Initialize answer with 'bad' value of
    // current window
    int ans = bad;
    for (int i = 0, j = count; j < n; ++i, ++j) {
 
    // Decrement count of previous window
    if (arr[i] > k)
        --bad;
 
    // Increment count of current window
    if (arr[j] > k)
        ++bad;
 
    // Update ans if count of 'bad'
    // is less in current window
    ans = Math.min(ans, bad);
    }
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = {2, 1, 5, 6, 3};
    int n = arr.length;
    int k = 3;
    System.out.print(minSwap(arr, n, k) + "\n");
 
    int arr1[] = {2, 7, 9, 5, 8, 7, 4};
    n = arr1.length;
    k = 5;
    System.out.print(minSwap(arr1, n, k));
}
}
 
// This code is contributed by Anant Agarwal.


Python3




# Python3 program to find
# minimum swaps required
# to club all elements less
# than or equals to k together
 
# Utility function to find
# minimum swaps required to
# club all elements less than
# or equals to k together
def minSwap(arr, n, k) :
     
    # Find count of elements
    # which are less than
    # equals to k
    count = 0
    for i in range(0, n) :
        if (arr[i] <= k) :
            count = count + 1
     
    # Find unwanted elements
    # in current window of
    # size 'count'
    bad = 0
    for i in range(0, count) :
        if (arr[i] > k) :
            bad = bad + 1
     
    # Initialize answer with
    # 'bad' value of current
    # window
    ans = bad
    j = count
    for i in range(0, n) :
         
        if(j == n) :
            break
             
        # Decrement count of
        # previous window
        if (arr[i] > k) :
            bad = bad - 1
         
        # Increment count of
        # current window
        if (arr[j] > k) :
            bad = bad + 1
         
        # Update ans if count
        # of 'bad' is less in
        # current window
        ans = min(ans, bad)
 
        j = j + 1
 
    return ans
 
# Driver code
arr = [2, 1, 5, 6, 3]
n = len(arr)
k = 3
print (minSwap(arr, n, k))
 
arr1 = [2, 7, 9, 5, 8, 7, 4]
n = len(arr1)
k = 5
print (minSwap(arr1, n, k))
 
# This code is contributed by
# Manish Shaw(manishshaw1)


C#




// C# program to find minimum
// swaps required to club all
// elements less than or equals
// to k together
using System;
 
class GFG {
     
    // Utility function to find minimum swaps
    // required to club all elements less than
    // or equals to k together
    static int minSwap(int []arr, int n, int k) {
     
        // Find count of elements which are
        // less than equals to k
        int count = 0;
        for (int i = 0; i < n; ++i)
        if (arr[i] <= k)
            ++count;
     
        // Find unwanted elements in current
        // window of size 'count'
        int bad = 0;
        for (int i = 0; i < count; ++i)
        if (arr[i] > k)
            ++bad;
     
        // Initialize answer with 'bad' value of
        // current window
        int ans = bad;
        for (int i = 0, j = count; j < n; ++i, ++j) {
     
            // Decrement count of previous window
            if (arr[i] > k)
                --bad;
         
            // Increment count of current window
            if (arr[j] > k)
                ++bad;
         
            // Update ans if count of 'bad'
            // is less in current window
            ans = Math.Min(ans, bad);
        }
        return ans;
    }
     
    // Driver code
    public static void Main()
    {
        int []arr = {2, 1, 5, 6, 3};
        int n = arr.Length;
        int k = 3;
        Console.WriteLine(minSwap(arr, n, k));
     
        int []arr1 = {2, 7, 9, 5, 8, 7, 4};
        n = arr1.Length;
        k = 5;
        Console.WriteLine(minSwap(arr1, n, k));
    }
}
 
// This code is contributed by vt_m.


PHP




<?php
// PHP program to find
// minimum swaps required
// to club all elements
// less than or equals
// to k together
 
// Utility function to
// find minimum swaps
// required to club all
// elements less than
// or equals to k together
function minSwap($arr, $n, $k)
{
     
    // Find count of elements
    // which are less than
    // equals to k
    $count = 0;
    for ($i = 0; $i < $n; ++$i)
        if ($arr[$i] <= $k)
            ++$count;
     
    // Find unwanted elements in current
    // window of size 'count'
    $bad = 0;
    for ($i = 0; $i < $count; ++$i)
        if ($arr[$i] > $k)
            ++$bad;
     
    // Initialize answer
    // with 'bad' value of
    // current window
    $ans = $bad;
    for ($i = 0, $j = $count; $j < $n;
                        ++$i, ++$j)
    {
         
        // Decrement count of
        // previous window
        if ($arr[$i] > $k)
            --$bad;
         
        // Increment count of
        // current window
        if ($arr[$j] > $k)
            ++$bad;
         
        // Update ans if count of 'bad'
        // is less in current window
        $ans = min($ans, $bad);
    }
    return $ans;
}
 
// Driver code
$arr = array(2, 1, 5, 6, 3);
$n = sizeof($arr);
$k = 3;
echo(minSwap($arr, $n, $k) . "\n");
     
$arr1 = array(2, 7, 9, 5, 8, 7, 4);
$n = sizeof($arr1);
$k = 5;
echo(minSwap($arr1, $n, $k));
 
// This code is contributed by Ajit.
?>


Javascript




<script>
 
// Utility function to find minimum swaps
// required to club all elements less than
// or equals to k together
function minSwap(arr,  n,  k) {
     
    // Find count of elements which are
    // less than equals to k
    var count = 0;
    for (var i = 0; i < n; ++i)
        if (arr[i] <= k)
            ++count;
     
    // Find unwanted elements in current
    // window of size 'count'
    var bad = 0;
    for (var i = 0; i < count; ++i)
        if (arr[i] > k)
            ++bad;
     
    // Initialize answer with 'bad' value of
    // current window
    var ans = bad;
    for (var i = 0, j = count; j < n; ++i, ++j) {
         
        // Decrement count of previous window
        if (arr[i] > k)
            --bad;
         
        // Increment count of current window
        if (arr[j] > k)
            ++bad;
         
        // Update ans if count of 'bad'
        // is less in current window
        ans = Math.min(ans, bad);
    }
    return ans;
}
 
    // Driver code
    var arr=[2, 1, 5, 6, 3];
    var n =5;
    var k = 3;
    document.write(minSwap(arr, n, k) + "<br>");
     
    var arr1 = [2, 7, 9, 5, 8, 7, 4];
    n = 7;
    k = 5;
    document.write(minSwap(arr1, n, k));
 
// This code is by Akshit Nikita Saxena
</script>


Output

1
2

Another approach for solving this problem is just using simple Sliding window technique and without using any pointers which can be done in O(N) time

  1. We will name our sliding window as snowballsize. Our snowBallsize will start from 0 and we will increase its size as we encounter any element greater than K. Our snowball window will have only elements which are greater than K.
  2. If we see an element arr[i] value less than k , we will swap the element arr[i] with our first element of snowball which has value greater than K.
  3. we will keep count variable to keep track of number of swaps.

Java




/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    private static int minSwap(int[] arr, int n, int k)
    {
 
        int snowBallSize = 0; // initially snowBallsize is 0
        int count = 0;
 
        for (int i = 0; i < n; i++) {
            // we will increment our
            // snowBall only if we see an
            // element greater than K
            if (arr[i] > k) {
                snowBallSize++;
            }
            // this case will handle if we see an element less than <= k,
              // then we will swap the element arr[i] which is less
            // than K, with our first element of snowBall window which is greater than K.
            else if (snowBallSize > 0) {
                int tmp = arr[i];
                arr[i] = arr[i - snowBallSize];
                arr[i - snowBallSize] = tmp;
 
                count++; 
            }
        }
        return count;
    }
 
    public static void main(String[] args)
    {
       
          int arr1[] = { 2, 7, 9, 5, 8, 7, 4 };
        int n = arr1.length;
        int k = 5;
        System.out.println("min swaps = "
                           + minSwap(arr1, n, k));
        System.out.println("Array after min swaps = "
                           + Arrays.toString(arr1));
       
          int arr2[] = {2, 1, 5, 6, 3};
        n = arr2.length;
        k = 3;
        System.out.println("min swaps = "
                           + minSwap(arr2, n, k));
        System.out.println("Array after min swaps = "
                           + Arrays.toString(arr2));
       
    }
}


Output

min swaps = 2
Array after min swaps = [2, 5, 4, 7, 8, 7, 9]
min swaps = 1
Array after min swaps = [2, 1, 3, 6, 5]

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!