Skip to content
Related Articles

Related Articles

Improve Article
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
  • Last Updated : 23 Apr, 2021

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: Yes

Explanation: 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>
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 



My Personal Notes
arrow_drop_up
Previous
Count lexicographically increasing K-length strings possible from first N alphabets
Next

Lexicographically largest string possible consisting of at most K consecutive similar characters
Recommended Articles
Page :
Find original sequence from Array containing the sequence merged many times in order
07, Aug 20
Generate all possible sorted arrays from alternate elements of two given sorted arrays
01, Jul 15
Check if given strings can be made same by swapping two characters of same or different strings
07, Dec 20
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Check if two arrays can be made equal by swapping pairs of one of the arrays
03, Feb 21
Find a pair of elements swapping which makes sum of two arrays same
30, Jun 17
Check if all the elements can be made of same parity by inverting adjacent elements
06, Jan 20
Count elements of same value placed at same indices of two given arrays
03, Jan 21
Construct a graph which does not contain any pair of adjacent nodes with same value
25, Oct 20
Construct an N-ary Tree having no pair of adjacent nodes with same weight from given weights
03, Dec 20
Find the closest pair from two sorted arrays
11, Nov 14
Check if a Binary String can be sorted in decreasing order by removing non-adjacent characters
09, Apr 21
Check if a grid can become row-wise and column-wise sorted after adjacent swaps
06, Sep 17
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
Median of two sorted arrays of same size
28, Sep 09
Maximum adjacent difference in an array in its sorted form
27, May 18
Check if two strings can be made equal by swapping pairs of adjacent characters
03, Feb 21
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Check if any permutation of array contains sum of every adjacent pair not divisible by 3
15, Sep 20
Minimum sum of two elements from two arrays such that indexes are not same
13, Jun 17
Queries to check if any pair exists in an array having values at most equal to the given pair
04, Dec 20
Smallest prefix to be deleted such that remaining array can be rearranged to form a sorted array
22, Sep 20
Rearrange numbers in an array such that no two adjacent numbers are same
10, Jun 19
Check if a string can be split into two strings with same number of K-frequent characters
08, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ManikantaBandla
@ManikantaBandla
Vote for difficulty





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