Related Articles
Sort an array by swapping elements of different type specified by another array
• Last Updated : 16 Apr, 2021

Given two arrays a[] and b[] which contains the integer elements and their respective types (either type 0 or type 1) respectively, the task is to check if it is possible to sort the array in non-decreasing order by swapping elements of different types only.
Examples:

Input: a[] = {30, 20, 20, 10}, b[] = {1, 1, 1, 1}
Output: No
Explanation:
Since all elements are of same type, no swaps are allowed and the given array is not sorted in non-decreasing order.
Input: a[] = {6, 5, 4}, b[] = {1, 1, 0}
Output: Yes
Explanation:
Swap 4 and 6 to convert the array into non-decreasing order.

Approach:
To solve the problem mentioned above, the following observations need to be made:

• If the array a[] is already sorted in non-decreasing order, then the answer is Yes.
• If the array a[] is not sorted and all the elements are of the same type, then the answer is No as no swaps are possible.
• In any other case, the answer is Yes as we can always sort the array. This is because we will have at least one element whose type is different from the other elements, so we can swap it with all the other elements any number of times till all the elements are in their sorted position.

Below is the implementation of the above approach:

## C++

 `// C++ program to check if it``// is possible to sort the``// array in non-decreasing``// order by swapping``// elements of different types` `#include ``using` `namespace` `std;` `// Function to check if it is``// possible to sort the array``// in non-decreasing order by``// swapping elements of``// different types``bool` `sorting_possible(``int` `a[],``                      ``int` `b[], ``int` `n)``{``    ``// Consider the array``    ``// to be already sorted``    ``bool` `sorted = ``true``;` `    ``int` `type1 = 0, type0 = 0, i;` `    ``// checking if array is``    ``// already sorted``    ``for` `(i = 1; i < n; i++) {``        ``// Check for a pair which``        ``// is in decreasing order``        ``if` `(a[i] < a[i - 1]) {` `            ``sorted = ``false``;``            ``break``;``        ``}``    ``}` `    ``// Count the frequency of``    ``// each type of element``    ``for` `(i = 0; i < n; i++) {``        ``// type0 stores count``        ``// of elements of type 0``        ``if` `(b[i] == 0)``            ``type0++;` `        ``// type1 stores count``        ``// of elements of type 1``        ``else``            ``type1++;``    ``}` `    ``// Return true if array``    ``// is already sorted``    ``if` `(sorted)``        ``return` `true``;` `    ``// Return false if all``    ``// elements are of same``    ``// type and array``    ``// is unsorted``    ``else` `if` `(type1 == n``             ``|| type0 == n)``        ``return` `false``;` `    ``// Possible for all``    ``// other cases``    ``else``        ``return` `true``;``}` `// Driver Program``int` `main()``{``    ``int` `a[] = { 15, 1, 2, 17, 6 };``    ``int` `b[] = { 1, 1, 0, 1, 1 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);` `    ``bool` `res = sorting_possible(a, b, n);` `    ``if` `(res)``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;``}`

## Java

 `// Java program to check if it is``// possible to sort the array in``// non-decreasing order by swapping``// elements of different types``import` `java.util.*;` `class` `GFG{` `// Function to check if it is``// possible to sort the array``// in non-decreasing order by``// swapping elements of``// different types``static` `boolean` `sorting_possible(``int` `a[],``                                ``int` `b[],``                                ``int` `n)``{``    ` `    ``// Consider the array``    ``// to be already sorted``    ``boolean` `sorted = ``true``;` `    ``int` `type1 = ``0``, type0 = ``0``, i;` `    ``// Checking if array is``    ``// already sorted``    ``for``(i = ``1``; i < n; i++)``    ``{``        ` `       ``// Check for a pair which``       ``// is in decreasing order``       ``if` `(a[i] < a[i - ``1``])``       ``{``           ``sorted = ``false``;``           ``break``;``       ``}``    ``}` `    ``// Count the frequency of``    ``// each type of element``    ``for``(i = ``0``; i < n; i++)``    ``{``        ` `       ``// type0 stores count``       ``// of elements of type 0``       ``if` `(b[i] == ``0``)``           ``type0++;``     ` `       ``// type1 stores count``       ``// of elements of type 1``       ``else``           ``type1++;``    ``}` `    ``// Return true if array``    ``// is already sorted``    ``if` `(sorted)``        ``return` `true``;` `    ``// Return false if all elements``    ``// are of same type and array``    ``// is unsorted``    ``else` `if` `(type1 == n || type0 == n)``        ``return` `false``;` `    ``// Possible for all``    ``// other cases``    ``else``        ``return` `true``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `a[] = { ``15``, ``1``, ``2``, ``17``, ``6` `};``    ``int` `b[] = { ``1``, ``1``, ``0``, ``1``, ``1` `};``    ``int` `n = a.length;``    ` `    ``boolean` `res = sorting_possible(a, b, n);` `    ``if` `(res)``        ``System.out.print(``"Yes"``);``    ``else``        ``System.out.print(``"No"``);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to check if it``# is possible to sort the``# array in non-decreasing``# order by swapping``# elements of different types` `# Function to check if it is``# possible to sort the array``# in non-decreasing order by``# swapping elements of different types``def` `sorting_possible(a, b, n):``    ` `    ``# Consider the array``    ``# to be already sorted``    ``sorted` `=` `True``    ` `    ``type1 ``=` `0``    ``type0 ``=` `0``    ` `    ``# Checking if array is``    ``# already sorted``    ``for` `i ``in` `range``(``1``, n):``        ` `        ``# Check for a pair which``        ``# is in decreasing order``        ``if` `(a[i] < a[i ``-` `1``]):``            ``sorted` `=` `False``            ``break``    ` `    ``# Count the frequency of``    ``# each type of element``    ``for` `i ``in` `range``(n):``        ` `        ``# type0 stores count``        ``# of elements of type 0``        ``if` `(b[i] ``=``=` `0``):``            ``type0 ``+``=` `1``        ` `        ``# type1 stores count``        ``# of elements of type 1``        ``else``:``            ``type1 ``+``=` `1``    ` `    ``# Return true if array``    ``# is already sorted``    ``if` `(``sorted` `!``=` `False``):``        ``return` `True``    ` `    ``# Return false if all elements``    ``# are of same type and array``    ``# is unsorted``    ``elif` `(type1 ``=``=` `n ``or` `type0 ``=``=` `n):``        ``return` `False``        ` `    ``# Possible for all``    ``# other cases``    ``else``:``        ``return` `True``    ` `# Driver code``a ``=` `[ ``15``, ``1``, ``2``, ``17``, ``6` `]``b ``=` `[ ``1``, ``1``, ``0``, ``1``, ``1` `]` `n ``=` `len``(a)``res ``=` `sorting_possible(a, b, n)` `if` `(res !``=` `False``):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)``    ` `# This code is contributed by sanjoy_62`

## C#

 `// C# program to check if it is``// possible to sort the array in``// non-decreasing order by swapping``// elements of different types``using` `System;` `class` `GFG{` `// Function to check if it is``// possible to sort the array``// in non-decreasing order by``// swapping elements of``// different types``static` `bool` `sorting_possible(``int` `[]a,``                             ``int` `[]b,``                             ``int` `n)``{``    ` `    ``// Consider the array``    ``// to be already sorted``    ``bool` `sorted = ``true``;` `    ``int` `type1 = 0, type0 = 0, i;` `    ``// Checking if array is``    ``// already sorted``    ``for``(i = 1; i < n; i++)``    ``{``       ` `       ``// Check for a pair which``       ``// is in decreasing order``       ``if` `(a[i] < a[i - 1])``       ``{``           ``sorted = ``false``;``           ``break``;``       ``}``    ``}` `    ``// Count the frequency of``    ``// each type of element``    ``for``(i = 0; i < n; i++)``    ``{``       ` `       ``// type0 stores count``       ``// of elements of type 0``       ``if` `(b[i] == 0)``           ``type0++;``           ` `       ``// type1 stores count``       ``// of elements of type 1``       ``else``           ``type1++;``    ``}` `    ``// Return true if array``    ``// is already sorted``    ``if` `(sorted)``        ``return` `true``;` `    ``// Return false if all elements``    ``// are of same type and array``    ``// is unsorted``    ``else` `if` `(type1 == n || type0 == n)``        ``return` `false``;` `    ``// Possible for all``    ``// other cases``    ``else``        ``return` `true``;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]a = { 15, 1, 2, 17, 6 };``    ``int` `[]b = { 1, 1, 0, 1, 1 };``    ``int` `n = a.Length;``    ` `    ``bool` `res = sorting_possible(a, b, n);` `    ``if` `(res)``        ``Console.Write(``"Yes"``);``    ``else``        ``Console.Write(``"No"``);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:
`Yes`

Illustration:

a[] = {15, 1, 2, 17, 6}
Only 2 is of type 0 and rest are of type 1.
Hence the following steps leads to a sorted array:
15, 1, 2, 17, 6 – > 15, 1, 6, 17, 2
15, 1, 6, 17, 2 -> 15, 1, 6, 2, 17
15, 1, 6, 2, 17 -> 2, 1, 6, 15, 17
2, 1, 6, 15, 17 -> 1, 2, 6, 15, 17

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.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up