Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
Given two sorted arrays A[] and B[] of size N, the task is to check if it is possible to merge two given sorted arrays into a new sorted array such that no two consecutive elements are from the same array.
Examples:
Input: A[] = {3, 5, 8}, B[] = {2, 4, 6}
Output: YesExplanation: Merged array = {B[0], A[0], B[1], A[1], B[2], A[2]}
Since the resultant array is sorted array, the required output is Yes.Input: A[] = {12, 4, 2, 5, 3}, B[] = {32, 13, 43, 10, 8}
Output: No
Approach: Follow the steps below to solve the problem:
- Initialize a variable, say flag = true to check if it is possible to form a new sorted array by merging the given two sorted arrays such that no two consecutive elements are from the same array.
- Initialize a variable, say prev to check if the previous element of the merge array are from the array A[] or the array B[]. If prev == 1 then the previous element are from the array A[] and if prev == 0 then the previous element are from the array B[].
- Traverse both the array using variables, i and j and check the following conditions:
- If A[i] < B[j] and prev != 0 then increment the value of i and update the value of prev to 0.
- If B[j] < A[i[ and prev != 1 then increment the value of j and update the value of prev to 1.
- If A[i] == B[j] and prev != 1 then increment the value of j and update the value of prev to 1.
- If A[i] == B[j] and prev != 0 then increment the value of i and update the value of prev to 0.
- If none of the above condition satisfy then update flag = false.
- Finally, print the value of flag.
Below is the implementation of the above approach:
C++
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function to check if it is possible to merge // the two given arrays with given conditions bool checkIfPossibleMerge( int A[], int B[], int N) { // Stores index of // the array A[] int i = 0; // Stores index of // the array B[] int j = 0; // Check if the previous element are from // the array A[] or from the array B[] int prev = -1; // Check if it is possible to merge the two // given sorted arrays with given conditions int flag = 1; // Traverse both the arrays while (i < N && j < N) { // If A[i] is less than B[j] and // previous element are not from A[] if (A[i] < B[j] && prev != 0) { // Update prev prev = 0; // Update i i++; } // If B[j] is less than A[i] and // previous element are not from B[] else if (B[j] < A[i] && prev != 1) { // Update prev prev = 1; // Update j j++; } // If A[i] equal to B[j] else if (A[i] == B[j]) { // If previous element // are not from B[] if (prev != 1) { // Update prev prev = 1; // Update j j++; } // If previous element is // not from A[] else { // Update prev prev = 0; // Update i i++; } } // If it is not possible to merge two // sorted arrays with given conditions else { // Update flag flag = 0; break ; } } return flag; } // Driver Code int main() { int A[3] = { 3, 5, 8 }; int B[3] = { 2, 4, 6 }; int N = sizeof (A) / sizeof (A[0]); if (checkIfPossibleMerge(A, B, N)) { cout << "Yes" ; } else { cout << "No" ; } return 0; } |
Java
// Java program to implement // the above approach import java.io.*; class GFG{ // Function to check if it is possible to merge // the two given arrays with given conditions static boolean checkIfPossibleMerge( int [] A, int [] B, int N) { // Stores index of // the array A[] int i = 0 ; // Stores index of // the array B[] int j = 0 ; // Check if the previous element are from // the array A[] or from the array B[] int prev = - 1 ; // Check if it is possible to merge the two // given sorted arrays with given conditions boolean flag = true ; // Traverse both the arrays while (i < N && j < N) { // If A[i] is less than B[j] and // previous element are not from A[] if (A[i] < B[j] && prev != 0 ) { // Update prev prev = 0 ; // Update i i++; } // If B[j] is less than A[i] and // previous element are not from B[] else if (B[j] < A[i] && prev != 1 ) { // Update prev prev = 1 ; // Update j j++; } // If A[i] equal to B[j] else if (A[i] == B[j]) { // If previous element // are not from B[] if (prev != 1 ) { // Update prev prev = 1 ; // Update j j++; } // If previous element is // not from A[] else { // Update prev prev = 0 ; // Update i i++; } } // If it is not possible to merge two // sorted arrays with given conditions else { // Update flag flag = false ; break ; } } return flag; } // Driver Code public static void main(String[] args) { int [] A = { 3 , 5 , 8 }; int [] B = { 2 , 4 , 6 }; int N = A.length; if (checkIfPossibleMerge(A, B, N)) { System.out.println( "Yes" ); } else { System.out.println( "No" ); } } } // This code is contributed by akhilsaini |
Python3
# Python3 program to implement # the above approach # Function to check if it is possible # to merge the two given arrays with # given conditions def checkIfPossibleMerge(A, B, N): # Stores index of # the array A[] i = 0 # Stores index of # the array B[] j = 0 # Check if the previous element # are from the array A[] or from # the array B[] prev = - 1 # Check if it is possible to merge # the two given sorted arrays with # given conditions flag = 1 # Traverse both the arrays while (i < N and j < N): # If A[i] is less than B[j] and # previous element are not from A[] if (A[i] < B[j] and prev ! = 0 ): # Update prev prev = 0 # Update i i + = 1 # If B[j] is less than A[i] and # previous element are not from B[] elif (B[j] < A[i] and prev ! = 1 ): # Update prev prev = 1 # Update j j + = 1 # If A[i] equal to B[j] elif (A[i] = = B[j]): # If previous element # are not from B[] if (prev ! = 1 ): # Update prev prev = 1 # Update j j + = 1 # If previous element is # not from A[] else : # Update prev prev = 0 # Update i i + = 1 # If it is not possible to merge two # sorted arrays with given conditions else : # Update flag flag = 0 break return flag # Driver Code if __name__ = = '__main__' : A = [ 3 , 5 , 8 ] B = [ 2 , 4 , 6 ] N = len (A) if (checkIfPossibleMerge(A, B, N)): print ( "Yes" ) else : print ( "No" ) # This code is contributed by akhilsaini |
C#
// C# program to implement // the above approach using System; class GFG{ // Function to check if it is possible to merge // the two given arrays with given conditions static bool checkIfPossibleMerge( int [] A, int [] B, int N) { // Stores index of // the array A[] int i = 0; // Stores index of // the array B[] int j = 0; // Check if the previous element are // from the array A[] or from the // array B[] int prev = -1; // Check if it is possible to merge // the two given sorted arrays with // given conditions bool flag = true ; // Traverse both the arrays while (i < N && j < N) { // If A[i] is less than B[j] and // previous element are not from A[] if (A[i] < B[j] && prev != 0) { // Update prev prev = 0; // Update i i++; } // If B[j] is less than A[i] and // previous element are not from B[] else if (B[j] < A[i] && prev != 1) { // Update prev prev = 1; // Update j j++; } // If A[i] equal to B[j] else if (A[i] == B[j]) { // If previous element // are not from B[] if (prev != 1) { // Update prev prev = 1; // Update j j++; } // If previous element is // not from A[] else { // Update prev prev = 0; // Update i i++; } } // If it is not possible to merge two // sorted arrays with given conditions else { // Update flag flag = false ; break ; } } return flag; } // Driver Code public static void Main() { int [] A = { 3, 5, 8 }; int [] B = { 2, 4, 6 }; int N = A.Length; if (checkIfPossibleMerge(A, B, N)) { Console.WriteLine( "Yes" ); } else { Console.WriteLine( "No" ); } } } // This code is contributed by akhilsaini |
Javascript
<script> // Javascript program to implement // the above approach // Function to check if it is possible to merge // the two given arrays with given conditions function checkIfPossibleMerge(A, B, N) { // Stores index of // the array A[] let i = 0; // Stores index of // the array B[] let j = 0; // Check if the previous element are from // the array A[] or from the array B[] let prev = -1; // Check if it is possible to merge the two // given sorted arrays with given conditions let flag = true ; // Traverse both the arrays while (i < N && j < N) { // If A[i] is less than B[j] and // previous element are not from A[] if (A[i] < B[j] && prev != 0) { // Update prev prev = 0; // Update i i++; } // If B[j] is less than A[i] and // previous element are not from B[] else if (B[j] < A[i] && prev != 1) { // Update prev prev = 1; // Update j j++; } // If A[i] equal to B[j] else if (A[i] == B[j]) { // If previous element // are not from B[] if (prev != 1) { // Update prev prev = 1; // Update j j++; } // If previous element is // not from A[] else { // Update prev prev = 0; // Update i i++; } } // If it is not possible to merge two // sorted arrays with given conditions else { // Update flag flag = false ; break ; } } return flag; } // Driver Code let A = [ 3, 5, 8 ]; let B = [ 2, 4, 6 ]; let N = A.length; if (checkIfPossibleMerge(A, B, N)) { document.write( "Yes" ); } else { document.write( "No" ); } // This code is contributed by splevel62. </script> |
Yes
Time Complexity: O(N)
Auxiliary Space: O(1)