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 conditionsbool 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 Codeint 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;} |
chevron_right
filter_none
Java
// Java program to implement// the above approachimport java.io.*;class GFG{// Function to check if it is possible to merge// the two given arrays with given conditionsstatic 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 Codepublic 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 |
chevron_right
filter_none
Python3
# Python3 program to implement# the above approach# Function to check if it is possible # to merge the two given arrays with # given conditionsdef 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 Codeif __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 |
chevron_right
filter_none
C#
// C# program to implement// the above approachusing System;class GFG{// Function to check if it is possible to merge// the two given arrays with given conditionsstatic 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 Codepublic 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 |
chevron_right
filter_none
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.
