# 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 = [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 = 2
swap element at index (2, 5) 1 2 3 9 5 6 5 9
because sortarr = 3
swap element at index (3, 6) 1 2 3 5 5 6 9 9
because sortarr = 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 ``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 arr,``                             ``int` `k, ``int` `n)``{``    ` `    ``// sortarr is sorted array of arr``    ``Vector sortarr = ``new` `Vector();``    ``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 arr = ``new` `Vector();``    ``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

 ``

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.

My Personal Notes arrow_drop_up