# Check if an array can be converted to another given array by swapping pairs of unequal elements

• Difficulty Level : Easy
• Last Updated : 30 Apr, 2021

Given two arrays arr1[] and arr2[] of size N, consisting of binary integers, the task is to check if arr1[] can be converted to arr2[] by swapping any pair of array elements (arr1[i], arr1[j]) such that i < j and arr1[i] is 1 and arr1[j] is 0 (any number of times). If it is possible to do so, then print “Yes”. Otherwise, print “No”.

Examples:

Input: arr1[] = {0, 1, 1, 0}, arr2[] = {0, 0 1, 1}
Output: Yes
Explanation:
The array arr1[] can be made equal to arr2[] by swapping arr1[1] and arr1[3].

Input: arr1[] = {1, 0, 1}, arr2[] = {0, 1, 0}
Output: No

Approach: The idea to solve this problem is based on the following observations:

• The operation doesnâ€™t change the frequency of the number of ones and zeros in array arr1[], so if the number of 0s or 1s are different among arrays, they can never become equal with the above operation.
• If some prefix of arr2[] contains more 1s than the prefix of arr1[] of the same length, then it is not possible to make arr1[] and arr2[] equal, since 1 can be shifted to right only.
• Otherwise, in all other cases, arrays can be made equal.

Follow the below steps to solve the problem:

• Initialize a variable, say count with 0, to store the differences of the prefix sum of arr1[] and arr2[].
• Count the number of 1s and 0s in both arrays and check if the number of 1s and 0s in arr1[] is not equal to the number of 1s and 0s in arr2[] and then print “No”.
• Iterate over the range [1, N – 1] using the variable i and do the following:
• Add the value (arr1[i] – arr2[i]) to the variable count.
• If the value of count is less than 0, then print “No” else continue for the next pair of elements.
• After completing the above steps, if the count isn’t negative at any step then print “Yes”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to check if arr1[] can be``// converted to arr2[] by swapping pair``// (i, j) such that i < j and arr[i] is``// 1 and arr[j] is 0``void` `canMakeEqual(``int` `arr1[], ``int` `arr2[], ``int` `N)``{``    ``// Stores the differences of prefix``    ``// sum of arr1 and arr2``    ``int` `count = 0;` `    ``// Stores the count of 1 and``    ``// zero of arr1``    ``int` `arr1_one = 0, arr1_zero = 0;` `    ``// Stores the count of 1 and``    ``// zero of arr2``    ``int` `arr2_one = 0, arr2_zero = 0;` `    ``// Iterate in the range [0, N - 1]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If arr1[i] is 1, then``        ``// increment arr1_one by one``        ``if` `(arr1[i] == 1) {``            ``arr1_one++;``        ``}` `        ``// Otherwise increment``        ``// arr1_zero by one``        ``else` `if` `(arr1[i] == 0) {``            ``arr1_zero++;``        ``}` `        ``// If arr2[i] is 1, then``        ``// increment arr2_one by one``        ``if` `(arr2[i] == 1) {``            ``arr2_one++;``        ``}` `        ``// Otherwise increment``        ``// arr2_zero by one``        ``else` `if` `(arr2[i] == 0) {``            ``arr2_zero++;``        ``}``    ``}` `    ``// Check if number of 1s and 0s``    ``// of arr1 is equal to number of``    ``// 1s and 0s of arr2 respectievly``    ``if` `(arr1_one != arr2_one || arr1_zero != arr2_zero) {``        ``cout << ``"No"``;``        ``return``;``    ``}` `    ``// Iterate over the range [0, N-1]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Increment count by differences``        ``// arr1[i] and arr2[i]``        ``count = count + (arr1[i] - arr2[i]);` `        ``// Check if number of 1's in``        ``// arr2 are more than arr1 and``        ``// then print "No"``        ``if` `(count < 0) {``            ``cout << ``"No"``;``            ``return``;``        ``}``    ``}` `    ``// Finally, print "Yes"``    ``cout << ``"Yes"``;``}` `// Driver Code``int` `main()``{``    ``// Given input arrays``    ``int` `arr1[] = { 0, 1, 1, 0 };``    ``int` `arr2[] = { 0, 0, 1, 1 };` `    ``// Size of the array``    ``int` `N = ``sizeof``(arr1) / ``sizeof``(arr1[0]);` `    ``// Function Call``    ``canMakeEqual(arr1, arr2, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{` `  ``// Function to check if arr1[] can be``  ``// converted to arr2[] by swapping pair``  ``// (i, j) such that i < j and arr[i] is``  ``// 1 and arr[j] is 0``  ``static` `void` `canMakeEqual(``int` `[]arr1, ``int` `[]arr2, ``int` `N)``  ``{` `    ``// Stores the differences of prefix``    ``// sum of arr1 and arr2``    ``int` `count = ``0``;` `    ``// Stores the count of 1 and``    ``// zero of arr1``    ``int` `arr1_one = ``0``, arr1_zero = ``0``;` `    ``// Stores the count of 1 and``    ``// zero of arr2``    ``int` `arr2_one = ``0``, arr2_zero = ``0``;` `    ``// Iterate in the range [0, N - 1]``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// If arr1[i] is 1, then``      ``// increment arr1_one by one``      ``if` `(arr1[i] == ``1``) {``        ``arr1_one++;``      ``}` `      ``// Otherwise increment``      ``// arr1_zero by one``      ``else` `if` `(arr1[i] == ``0``) {``        ``arr1_zero++;``      ``}` `      ``// If arr2[i] is 1, then``      ``// increment arr2_one by one``      ``if` `(arr2[i] == ``1``) {``        ``arr2_one++;``      ``}` `      ``// Otherwise increment``      ``// arr2_zero by one``      ``else` `if` `(arr2[i] == ``0``) {``        ``arr2_zero++;``      ``}``    ``}` `    ``// Check if number of 1s and 0s``    ``// of arr1 is equal to number of``    ``// 1s and 0s of arr2 respectievly``    ``if` `(arr1_one != arr2_one || arr1_zero != arr2_zero) {``      ``System.out.print(``"No"``);``      ``return``;``    ``}` `    ``// Iterate over the range [0, N-1]``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// Increment count by differences``      ``// arr1[i] and arr2[i]``      ``count = count + (arr1[i] - arr2[i]);` `      ``// Check if number of 1's in``      ``// arr2 are more than arr1 and``      ``// then print "No"``      ``if` `(count < ``0``) {``        ``System.out.print(``"No"``);``        ``return``;``      ``}``    ``}` `    ``// Finally, print "Yes"``    ``System.out.print(``"Yes"``);``  ``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ` `    ``// Given input arrays``    ``int` `[]arr1 = { ``0``, ``1``, ``1``, ``0` `};``    ``int` `[]arr2 = { ``0``, ``0``, ``1``, ``1` `};` `    ``// Size of the array``    ``int` `N = arr1.length;` `    ``// Function Call``    ``canMakeEqual(arr1, arr2, N);``}``}` `// This code is contributed by code_hunt.`

## Python3

 `# Python 3 program for the above approach` `# Function to check if arr1[] can be``# converted to arr2[] by swapping pair``# (i, j) such that i < j and arr[i] is``# 1 and arr[j] is 0``def` `canMakeEqual(arr1, arr2, N):``  ` `    ``# Stores the differences of prefix``    ``# sum of arr1 and arr2``    ``count ``=` `0` `    ``# Stores the count of 1 and``    ``# zero of arr1``    ``arr1_one ``=` `0``    ``arr1_zero ``=` `0` `    ``# Stores the count of 1 and``    ``# zero of arr2``    ``arr2_one ``=` `0``    ``arr2_zero ``=` `0` `    ``# Iterate in the range [0, N - 1]``    ``for` `i ``in` `range``(N):``      ` `        ``# If arr1[i] is 1, then``        ``# increment arr1_one by one``        ``if` `(arr1[i] ``=``=` `1``):``            ``arr1_one ``+``=` `1` `        ``# Otherwise increment``        ``# arr1_zero by one``        ``elif``(arr1[i] ``=``=` `0``):``            ``arr1_zero ``+``=` `1` `        ``# If arr2[i] is 1, then``        ``# increment arr2_one by one``        ``if` `(arr2[i] ``=``=` `1``):``            ``arr2_one ``+``=` `1` `        ``# Otherwise increment``        ``# arr2_zero by one``        ``elif` `(arr2[i] ``=``=` `0``):``            ``arr2_zero ``+``=` `1` `    ``# Check if number of 1s and 0s``    ``# of arr1 is equal to number of``    ``# 1s and 0s of arr2 respectievly``    ``if` `(arr1_one !``=` `arr2_one ``or` `arr1_zero !``=` `arr2_zero):``        ``print``(``"No"``)``        ``return` `    ``# Iterate over the range [0, N-1]``    ``for` `i ``in` `range``(N):` `        ``# Increment count by differences``        ``# arr1[i] and arr2[i]``        ``count ``=` `count ``+` `(arr1[i] ``-` `arr2[i])` `        ``# Check if number of 1's in``        ``# arr2 are more than arr1 and``        ``# then print "No"``        ``if` `(count < ``0``):``            ``print``(``"No"``)``            ``return` `    ``# Finally, print "Yes"``    ``print``(``"Yes"``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given input a``    ``arr1 ``=`  `[``0``, ``1``, ``1``, ``0``]``    ``arr2 ``=`  `[``0``, ``0``, ``1``, ``1``]` `    ``# Size of the array``    ``N ``=` `len``(arr1)``    ` `    ``# Function Call``    ``canMakeEqual(arr1, arr2, N)``    ` `    ``# This code is contributed by ipg2016107.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `  ``// Function to check if arr1[] can be``  ``// converted to arr2[] by swapping pair``  ``// (i, j) such that i < j and arr[i] is``  ``// 1 and arr[j] is 0``  ``static` `void` `canMakeEqual(``int` `[]arr1, ``int` `[]arr2, ``int` `N)``  ``{` `    ``// Stores the differences of prefix``    ``// sum of arr1 and arr2``    ``int` `count = 0;` `    ``// Stores the count of 1 and``    ``// zero of arr1``    ``int` `arr1_one = 0, arr1_zero = 0;` `    ``// Stores the count of 1 and``    ``// zero of arr2``    ``int` `arr2_one = 0, arr2_zero = 0;` `    ``// Iterate in the range [0, N - 1]``    ``for` `(``int` `i = 0; i < N; i++) {` `      ``// If arr1[i] is 1, then``      ``// increment arr1_one by one``      ``if` `(arr1[i] == 1) {``        ``arr1_one++;``      ``}` `      ``// Otherwise increment``      ``// arr1_zero by one``      ``else` `if` `(arr1[i] == 0) {``        ``arr1_zero++;``      ``}` `      ``// If arr2[i] is 1, then``      ``// increment arr2_one by one``      ``if` `(arr2[i] == 1) {``        ``arr2_one++;``      ``}` `      ``// Otherwise increment``      ``// arr2_zero by one``      ``else` `if` `(arr2[i] == 0) {``        ``arr2_zero++;``      ``}``    ``}` `    ``// Check if number of 1s and 0s``    ``// of arr1 is equal to number of``    ``// 1s and 0s of arr2 respectievly``    ``if` `(arr1_one != arr2_one || arr1_zero != arr2_zero) {``      ``Console.WriteLine(``"No"``);``      ``return``;``    ``}` `    ``// Iterate over the range [0, N-1]``    ``for` `(``int` `i = 0; i < N; i++) {` `      ``// Increment count by differences``      ``// arr1[i] and arr2[i]``      ``count = count + (arr1[i] - arr2[i]);` `      ``// Check if number of 1's in``      ``// arr2 are more than arr1 and``      ``// then print "No"``      ``if` `(count < 0) {``        ``Console.WriteLine(``"No"``);``        ``return``;``      ``}``    ``}` `    ``// Finally, print "Yes"``    ``Console.WriteLine(``"Yes"``);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{` `    ``// Given input arrays``    ``int` `[]arr1 = { 0, 1, 1, 0 };``    ``int` `[]arr2 = { 0, 0, 1, 1 };` `    ``// Size of the array``    ``int` `N = arr1.Length;` `    ``// Function Call``    ``canMakeEqual(arr1, arr2, N);``  ``}` `}` `// This code is contributed by bgangwar59.`

## Javascript

 ``
Output:
`Yes`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up