Skip to content
Related Articles

Related Articles

Improve Article

Find if array can be sorted by swaps limited to multiples of k

  • Last Updated : 25 May, 2021

Given an array and a number k, the task is to check if the given array can be sorted or not with limited swap operations. We can swap arr[i] only with arr[i] or arr[i + k] or arr[i + 2*k] or arr[i + 3*k] and so on. In general an element at index i can be swapped with elements at indexes i + j*k where j = 0, 1, 2, 3, …
Note : Any number of swaps can be performed on the array.

Examples:

Input: arr[8] = [1, 5, 6, 9, 2, 3, 5, 9], k = 3 
Output: Possible to sort 
Explanation: 1 5 6 9 2 3 5 9 
0 1 2 3 4 5 6 7 here k is 3 
0 can swap with 0 + 3 = (3) element 
1 can swap with 1 + 3 = (4) element 
2 can swap with 2 + 3 = (5) element 
3 can swap with 3 + 3 = (6) element 
4 can swap with 4 + 3 = (7) element 
we can see that element at index 0, 3, 6 can swap with each other 
we can see that element at index 1, 4, 7 can swap with each other 
we can see that element at index 2, 5 can swap with each other 
element 0 can never swap with 7, 1, 4, 2, 5 
swap element at index (1, 4) 1 2 6 9 5 3 5 9 
because sortarr[1] = 2 
swap element at index (2, 5) 1 2 3 9 5 6 5 9 
because sortarr[2] = 3 
swap element at index (3, 6) 1 2 3 5 5 6 9 9 
because sortarr[3] = 5 
by swapping in this case we are able to reach 1 2 3 5 5 6 9 9

Input :arr=[1, 4, 2, 3], k = 2 
Output : Not possible to sort 
Explanation: 1 4 2 3 
0 1 2 3 where k is 2 
0 can swap with 0 + 2 = (2) element. 
1 can swap with 1 + 2 = (3) element. 
we can see that element at index 0, 2 can swap with each other. 
we can see that element at index 1, 3 can swap with each other. 
no need to swap element at index (0, 2) 1 4 2 3 
0 1 2 3 
at index 1 of sorted array is 2 
2 is not present in 1 + j * 2, where j = {0, 1} 
so since 2 can never come at index 1 of array, 
array can not be sort. 
array is not sorted after swapping.

Input :arr[] = [1, 4, 2, 3], k = 1 
Output : Possible to sort 
Explanation: 1 4 2 3 
0 1 2 3 where k is 1 
when k is 1 it is always possible to sort 
because swap take place between adjacent element. 
 



Approach: 
1) Create sortArr[] as sorted version of given arr. 
2) Compare this array with sorted array. 
3) Iterate over for loop, to compare index i. 
4) Now index i, element is compared with 
index = i + j * k 
where j = 0, 1, 2….. 
5) if for particular i element of sortArr[i] match with sequence arr[index], then flag is 1 and 
swap arr[i], arr[index] 
6) if no swap then flag is 0 and that means no element is found in sequence 
7) if flag is 0 break for loop and print Not possible 
8) else print Possible

C++14




#include <bits/stdc++.h>
using namespace std;
 
// CheckSort function
// To check if array can be sorted
void CheckSort(vector<int> arr,int k,int n){
 
    // sortarr is sorted array of arr
    vector<int> sortarr(arr.begin(),arr.end());
 
    sort(sortarr.begin(),sortarr.end());
 
    // if k = 1 then (always possible to sort)
    // swapping can easily give sorted
    // array
    if (k == 1)
        printf("yes");
    else
    {
        int flag = 0;
         
        // comparing sortarray with array
        for (int i = 0; i < n; i++)
        {
            flag = 0;
 
            // element at index j
            // must be in j = i + l * k form
            // where i = 0, 1, 2, 3...
            // where l = 0, 1, 2, 3, ..n-1
            for (int j = i; j < n; j += k)
            {
 
                //if element is present
                //then swapped
                if (sortarr[i] == arr[j]){
                    swap(arr[i], arr[j]);
                    flag = 1;
                    break;
                }
                if (j + k >= n)
                    break;
 
            }
 
 
            // if element of sorted array
            // does not found in its sequence
            // then flag remain zero
            // that means arr can not be
            // sort after swapping
            if (flag == 0)
                break;
 
            }
 
        // if flag is 0
        // Not possible
        // else Possible
        if (flag == 0)
            printf("Not possible to sort");
        else
            printf("Possible to sort");
        }
}
 
 
// Driver code
int main()
{
    // size of step
    int k = 3;
 
    // array initialized
    vector<int> arr ={1, 5, 6, 9, 2, 3, 5, 9};
 
    // length of arr
    int n =arr.size();
 
    // calling function
    CheckSort(arr, k, n);
 
    return 0;
}
 
// This code is contributed by mohit kumar 29

Java




import java.util.*;
 
class GFG{
     
// CheckSort function
// To check if array can be sorted
public static void CheckSort(Vector<Integer> arr,
                             int k, int n)
{
     
    // sortarr is sorted array of arr
    Vector<Integer> sortarr = new Vector<Integer>();
    for(int i = 0; i < arr.size(); i++)
    {
        sortarr.add(arr.get(i));
    }
  
    Collections.sort(sortarr);
  
    // If k = 1 then (always possible to sort)
    // swapping can easily give sorted
    // array
    if (k == 1)
        System.out.println("yes");
    else
    {
        int flag = 0;
          
        // Comparing sortarray with array
        for(int i = 0; i < n; i++)
        {
            flag = 0;
  
            // Element at index j
            // must be in j = i + l * k form
            // where i = 0, 1, 2, 3...
            // where l = 0, 1, 2, 3, ..n-1
            for(int j = i; j < n; j += k)
            {
                 
                // If element is present
                //then swapped
                if (sortarr.get(i) == arr.get(j))
                {
                    Collections.swap(arr, i, j);
                    flag = 1;
                    break;
                }
                if (j + k >= n)
                    break;
            }
  
            // If element of sorted array
            // does not found in its sequence
            // then flag remain zero
            // that means arr can not be
            // sort after swapping
            if (flag == 0)
                break;
        }
         
        // If flag is 0
        // Not possible
        // else Possible
        if (flag == 0)
            System.out.println("Not possible to sort");
        else
            System.out.println("Possible to sort");
    }
}
 
// Driver code
public static void main(String[] args)
{
     
    // Size of step
    int k = 3;
  
    // Array initialized
    Vector<Integer> arr = new Vector<Integer>();
    arr.add(1);
    arr.add(5);
    arr.add(6);
    arr.add(9);
    arr.add(2);
    arr.add(3);
    arr.add(5);
    arr.add(9);
  
    // Length of arr
    int n = arr.size();
  
    // Calling function
    CheckSort(arr, k, n);
}
}
 
// This code is contributed by divyeshrabadiya07

Python3




# CheckSort function
# To check if array can be sorted
def CheckSort(arr, k, n):
     
    # sortarr is sorted array of arr
    sortarr = sorted(arr)
     
    # if k = 1 then (always possible to sort)
    # swapping can easily give sorted
    # array
    if (k == 1):
        print("yes")
    else:
         
        # comparing sortarray with array
        for i in range(0, n):
            flag = 0
             
            # element at index j
            # must be in j = i + l * k form
            # where i = 0, 1, 2, 3...
            # where l = 0, 1, 2, 3, ..n-1
            for j in range(i, n, k):
 
                # if element is present
                # then swapped
                if (sortarr[i] == arr[j]):
                    arr[i], arr[j] = arr[j], arr[i]
                    flag = 1
                    break
                if (j + k >= n):
                    break
 
            # if element of sorted array
            # does not found in its sequence
            # then flag remain zero
            # that means arr can not be
            # sort after swapping
            if (flag == 0):
                break
             
        # if flag is 0
        # Not possible
        # else Possible
        if (flag == 0):
            print("Not possible to sort")
        else:
            print("Possible to sort")
 
 
# Driver code
if __name__ == "__main__":
    # size of step
    k = 3
 
    # array initialized
    arr =[1, 5, 6, 9, 2, 3, 5, 9]
 
    # length of arr
    n = len(arr)
 
    # calling function
    CheckSort(arr, k, n)   

C#




using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG{
   
// CheckSort function
// To check if array can be sorted
static void CheckSort(ArrayList arr, int k, int n)
{
     
    // sortarr is sorted array of arr
    ArrayList sortarr = new ArrayList(arr);
    sortarr.Sort();
     
    // If k = 1 then (always possible to sort)
    // swapping can easily give sorted
    // array
    if (k == 1)
        Console.Write("yes");
    else
    {
        int flag = 0;
          
        // Comparing sortarray with array
        for(int i = 0; i < n; i++)
        {
            flag = 0;
             
            // Element at index j
            // must be in j = i + l * k form
            // where i = 0, 1, 2, 3...
            // where l = 0, 1, 2, 3, ..n-1
            for(int j = i; j < n; j += k)
            {
                 
                // If element is present
                // then swapped
                if ((int)sortarr[i] == (int)arr[j])
                {
                    int tmp = (int)arr[i];
                    arr[i] = (int)arr[j];
                    arr[j] = tmp;
                    flag = 1;
                    break;
                }
                 
                if (j + k >= n)
                {
                    break;
                }
            }
 
            // If element of sorted array
            // does not found in its sequence
            // then flag remain zero
            // that means arr can not be
            // sort after swapping
            if (flag == 0)
            {
                break;
            }
        }
         
        // If flag is 0
        // Not possible
        // else Possible
        if (flag == 0)
            Console.Write("Not possible to sort");
        else
            Console.Write("Possible to sort");
    }
}
 
// Driver code
public static void Main(string[] args)
{
     
    // Size of step
    int k = 3;
  
    // Array initialized
    ArrayList arr = new ArrayList(){ 1, 5, 6, 9,
                                     2, 3, 5, 9 };
  
    // Length of arr
    int n = arr.Count;
  
    // Calling function
    CheckSort(arr, k, n);
}
}
 
// This code is contributed by rutvik_56

Javascript




<script>
      // CheckSort function
      // To check if array can be sorted
      function CheckSort(arr, k, n)
      {
       
        // sortarr is sorted array of arr
        var sortarr = arr.sort((a, b) => a - b);
 
        // If k = 1 then (always possible to sort)
        // swapping can easily give sorted
        // array
        if (k === 1) document.write("yes");
        else
        {
          var flag = 0;
           
          // Comparing sortarray with array
          for (var i = 0; i < n; i++) {
            flag = 0;
 
            // Element at index j
            // must be in j = i + l * k form
            // where i = 0, 1, 2, 3...
            // where l = 0, 1, 2, 3, ..n-1
            for (var j = i; j < n; j += k)
            {
             
              // If element is present
              // then swapped
              if (sortarr[i] === arr[j])
              {
                var tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
                flag = 1;
                break;
              }
 
              if (j + k >= n) {
                break;
              }
            }
 
            // If element of sorted array
            // does not found in its sequence
            // then flag remain zero
            // that means arr can not be
            // sort after swapping
            if (flag === 0) {
              break;
            }
          }
 
          // If flag is 0
          // Not possible
          // else Possible
          if (flag === 0) document.write("Not possible to sort");
          else document.write("Possible to sort");
        }
      }
 
      // Driver code
      // Size of step
      var k = 3;
 
      // Array initialized
      var arr = [1, 5, 6, 9, 2, 3, 5, 9];
 
      // Length of arr
      var n = arr.length;
 
      // Calling function
      CheckSort(arr, k, n);
       
      // This code is contributed by rdtank.
    </script>
Output: 
Possible to sort

 

Performance Analysis: 
Time complexity: O(N^2) Where N is size of array. worst case
Auxiliary Space: O(N) where N is size of array.
 

 

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