Sort an array by swapping elements of different type specified by another array

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to check if it
// is possible to sort the
// array in non-decreasing
// order by swapping
// elements of different types
  
#include <bits/stdc++.h>
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[0]);
  
    bool res = sorting_possible(a, b, n);
  
    if (res)
        cout << "Yes";
    else
        cout << "No";
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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

competitive-programming-img




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Rajput-Ji, sanjoy_62