Skip to content
Related Articles

Related Articles

Check if an array can be sorted by swapping pairs from indices consisting of unequal elements in another array
  • Difficulty Level : Expert
  • Last Updated : 18 Feb, 2021

Given an array A[] of size N and a binary array B[] of size N, the task is to check if the array A[] can be converted into a sorted array by swapping pairs (A[i], A[j]) if B[i] is not equal to B[j]. If the array A[] can be sorted, then print “Yes“. Otherwise, print “No“.

Examples:

Input: A[] = {3, 1, 2}, B[] = {0, 1, 1}
Output: Yes
Explanation:
Swap element at position 1 and position 2 of A[] since B[1]!=B[2]. So, A[] = {1, 3, 2}, B[] = {1, 0, 1}
Now, swap element at position 2 and position 3 of A[] since B[2]!=B[3]. So, A[] = {1, 2, 3}. Hence, it is sorted.

Input: A[] = {5, 15, 4}, B[] = {0, 0, 0}
Output: No

Approach: The problem can be solved based on the following observations:



If at least two elements of the array, B[] are different, then it is possible to swap any two elements of the array A[].

Follow the steps below to solve the problem:

  • Check if the given array A[] is already sorted in ascending order or not. If found to be true, then print “Yes”.
  • Otherwise, count the number of 1s and 0s present in the array B[].
    • If the array B[] contains at least one 0 and one 1, then print “Yes”.
    • Otherwise, print “No”.

Below is the implementation of the above approach:

C++




// C++ Program for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if array, A[] can be converted
// into sorted array by swapping (A[i], A[j]) if B[i]
// not equal to B[j]
bool checkifSorted(int A[], int B[], int N)
{
 
  // Stores if array A[] is sorted
  // in descending order or not
  bool flag = false;
 
  // Traverse the array A[]
  for (int i = 0; i < N - 1; i++) {
 
    // If A[i] is greater than A[i + 1]
    if (A[i] > A[i + 1]) {
 
      // Update flag
      flag = true;
      break;
    }
  }
 
  // If array is sorted
  // in ascending order
  if (!flag) {
    return true;
  }
 
  // count = 2: Check if 0s and 1s
  // both present in the B[]
  int count = 0;
 
  // Traverse the array
  for (int i = 0; i < N; i++) {
 
    // If current element is 0
    if (B[i] == 0) {
 
      // Update count
      count++;
      break;
    }
  }
 
 
  // Traverse the array B[]
  for (int i = 0; i < N; i++) {
 
    // If current element is 1
    if (B[i] == 1) {
      count++;
      break;
    }
  }
 
  // If both 0s and 1s are present
  // in the array
  if (count == 2) {
    return true;
  }
  return false;
}
 
// Driver Code
int main()
{
  // Input array A[]
  int A[] = { 3, 1, 2 };
 
  // Input array B[]
  int B[] = { 0, 1, 1 };
 
  int N = sizeof(A) / sizeof(A[0]);
  // Function call
  bool check = checkifSorted(A, B, N);
 
  // If true,print YES
  if (check) {
    cout << "YES" <<endl;
  }
  // Else print NO
  else {
    cout << "NO" <<endl;
  }
 
  return 0;
}
Java



// Java program of the above approach
import java.io.*;
 
class GFG {
 
     
    // Function to check if array, A[] can be converted
    // into sorted array by swapping (A[i], A[j]) if B[i]
    // not equal to B[j]
    static boolean checkifSorted(int A[], int B[], int N)
    {
         
        // Stores if array A[] is sorted
        // in descending order or not
        boolean flag = false;
 
        // Traverse the array A[]
        for (int i = 0; i < N - 1; i++) {
 
            // If A[i] is greater than A[i + 1]
            if (A[i] > A[i + 1]) {
 
                // Update flag
                flag = true;
                break;
            }
        }
 
        // If array is sorted
        // in ascending order
        if (!flag) {
            return true;
        }
 
        // count = 2: Check if 0s and 1s
        // both present in the B[]
        int count = 0;
 
        // Traverse the array
        for (int i = 0; i < N; i++) {
             
            // If current element is 0
            if (B[i] == 0) {
                 
                // Update count
                count++;
                break;
            }
        }
         
         
        // Traverse the array B[]
        for (int i = 0; i < N; i++) {
             
            // If current element is 1
            if (B[i] == 1) {
                count++;
                break;
            }
        }
 
        // If both 0s and 1s are present
        // in the array
        if (count == 2) {
            return true;
        }
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Input array A[]
        int A[] = { 3, 1, 2 };
 
        // Input array B[]
        int B[] = { 0, 1, 1 };
 
        int N = A.length;
        // Function call
        boolean check = checkifSorted(A, B, N);
 
        // If true,print YES
        if (check) {
            System.out.println("YES");
        }
        // Else print NO
        else {
            System.out.println("NO");
        }
    }
}
Python3



# Python program of the above approach
     
# Function to check if array, A[] can be converted
# into sorted array by swapping (A[i], A[j]) if B[i]
# not equal to B[j]
def checkifSorted(A, B, N):
   
  # Stores if array A[] is sorted
  # in descending order or not
  flag = False
 
  # Traverse the array A[]
  for i in range( N - 1):
     
    # If A[i] is greater than A[i + 1]
    if (A[i] > A[i + 1]):
       
      # Update flag
      flag = True
      break
 
  # If array is sorted
  # in ascending order
  if (not flag):
    return True
 
  # count = 2: Check if 0s and 1s
  # both present in the B[]
  count = 0
 
  # Traverse the array
  for i in range(N):
     
    # If current element is 0
    if (B[i] == 0):
       
      # Update count
      count += 1
      break
         
  # Traverse the array B[]
  for i in range(N):
     
    # If current element is 1
    if B[i]:
      count += 1
      break
       
  # If both 0s and 1s are present
  # in the array
  if (count == 2):
    return True
       
  return False
 
# Driver Code
# Input array A[]
A = [ 3, 1, 2 ]
 
# Input array B[]
B = [ 0, 1, 1 ]
N = len(A)
 
# Function call
check = checkifSorted(A, B, N)
 
# If true,print YES
if (check):
  print("YES")
         
# Else print NO
else:
  print("NO")
  
# This code is contributed by rohitsingh07052
C#



// C# program of the above approach
using System;
public class GFG
{
     
    // Function to check if array, A[] can be converted
    // into sorted array by swapping (A[i], A[j]) if B[i]
    // not equal to B[j]
    static bool checkifSorted(int []A, int []B, int N)
    {
         
        // Stores if array A[] is sorted
        // in descending order or not
        bool flag = false;
 
        // Traverse the array A[]
        for (int i = 0; i < N - 1; i++) {
 
            // If A[i] is greater than A[i + 1]
            if (A[i] > A[i + 1]) {
 
                // Update flag
                flag = true;
                break;
            }
        }
 
        // If array is sorted
        // in ascending order
        if (!flag) {
            return true;
        }
 
        // count = 2: Check if 0s and 1s
        // both present in the B[]
        int count = 0;
 
        // Traverse the array
        for (int i = 0; i < N; i++) {
             
            // If current element is 0
            if (B[i] == 0) {
                 
                // Update count
                count++;
                break;
            }
        }
         
         
        // Traverse the array B[]
        for (int i = 0; i < N; i++)
        {
             
            // If current element is 1
            if (B[i] == 1)
            {
                count++;
                break;
            }
        }
 
        // If both 0s and 1s are present
        // in the array
        if (count == 2)
        {
            return true;
        }
        return false;
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        // Input array A[]
        int []A = { 3, 1, 2 };
 
        // Input array B[]
        int []B = { 0, 1, 1 };
        int N = A.Length;
         
        // Function call
        bool check = checkifSorted(A, B, N);
 
        // If true,print YES
        if (check) {
            Console.WriteLine("YES");
        }
        // Else print NO
        else {
            Console.WriteLine("NO");
        }
    }
}
 
// This code is contributed by AnkThon
Output: 
YES
 
Time Complexity: O(N)
Auxiliary Space: O(1)
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.
My Personal Notes
arrow_drop_up
Previous
Count ways to make product of array elements even by replacements
Next

Partition array into two subsets with minimum Bitwise XOR between their maximum and minimum
Recommended Articles
Page :
Check if an array can be converted to another given array by swapping pairs of unequal elements
15, Feb 21
Maximize given integer by swapping pairs of unequal bits
29, Jan 21
Longest increasing subsequence consisting of elements from indices divisible by previously selected indices
04, Dec 20
Maximize difference between odd and even indexed array elements by swapping unequal adjacent bits in their binary representations
22, Feb 21
Check if array can be sorted by swapping pairs having GCD equal to the smallest element in the array
16, Sep 20
Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
17, Sep 20
Minimize count of unequal elements at corresponding indices between given arrays
26, Aug 20
Count pairs with product of indices equal to the product of elements present at those indices
18, Mar 21
Minimize array length by repeatedly replacing pairs of unequal adjacent array elements by their sum
04, Sep 20
Check if a string can be made equal to another string by swapping or replacement of characters
24, Jan 21
Check if end of a sorted Array can be reached by repeated jumps of one more, one less or same number of indices as previous jump
24, Nov 20
Check if the array can be sorted using swaps between given indices only
20, Mar 19
Check if two arrays can be made equal by swapping pairs of one of the arrays
03, Feb 21
Reduce array to a single element by repeatedly replacing adjacent unequal pairs with their maximum
29, Oct 20
Count unequal element pairs from the given Array
26, Feb 20
Maximize Array sum by swapping at most K elements with another array
18, May 20
Maximize maximum possible subarray sum of an array by swapping with elements from another array
03, Jan 21
Sort an array by swapping elements of different type specified by another array
18, Jun 20
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
16, Nov 20
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Check if a queue can be sorted into another queue using a stack
09, May 18
Check if Array elements can be maximized upto M by adding all elements from another array
02, Jul 20
Maximum distance between two unequal elements
31, May 19
Last element remaining by deleting two largest elements and replacing by their absolute difference if they are unequal
16, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
aditya7409
@aditya7409
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox