Generate all possible sorted arrays from alternate elements of two given sorted arrays

4.2

Given two sorted arrays A and B, generate all possible arrays such that first element is taken from A then from B then from A and so on in increasing order till the arrays exhausted. The generated arrays should end with an element from B.

For Example 
A = {10, 15, 25}
B = {1, 5, 20, 30}

The resulting arrays are:
  10 20
  10 20 25 30
  10 30
  15 20
  15 20 25 30
  15 30
  25 30

Source: Microsoft Interview Question

We strongly recommend you to minimize your browser and try this yourself first.

The idea is to use recursion. In the recursive function, a flag is passed to indicate whether current element in output should be taken from ‘A’ or ‘B’. Below is C++ implementation.

C

#include<bits/stdc++.h>
using namespace std;

void printArr(int arr[], int n);

/* Function to generates and prints all sorted arrays from alternate elements of
   'A[i..m-1]' and 'B[j..n-1]'
   If 'flag' is true, then current element is to be included from A otherwise
   from B.
   'len' is the index in output array C[]. We print output  array  each time
   before including a character from A only if length of output array is
   greater than 0. We try than all possible combinations */
void generateUtil(int A[], int B[], int C[], int i, int j, int m, int n,
                  int len, bool flag)
{
    if (flag) // Include valid element from A
    {
        // Print output if there is at least one 'B' in output array 'C'
        if (len)
            printArr(C, len+1);

        // Recur for all elements of A after current index
        for (int k = i; k < m; k++)
        {
            if (!len)
            {
                /* this block works for the very first call to include
                 	the first element in the output array */
                C[len] = A[k];

                // don't increment lem as B is included yet
                generateUtil(A, B, C, k+1, j, m, n, len, !flag);
            }
            else  	/* include valid element from A and recur */
            {
                if (A[k] > C[len])
                {
                    C[len+1] = A[k];
                    generateUtil(A, B, C, k+1, j, m, n, len+1, !flag);
                }
            }
        }
    }
    else   /* Include valid element from B and recur */
    {
        for (int l = j; l < n; l++)
        {
            if (B[l] > C[len])
            {
                C[len+1] = B[l];
                generateUtil(A, B, C, i, l+1, m, n, len+1, !flag);
            }
        }
    }
}

/* Wrapper function */
void generate(int A[], int B[], int m, int n)
{
    int C[m+n];	/* output array */
    generateUtil(A, B, C, 0, 0, m, n, 0, true);
}

// A utility function to print an array
void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << endl;
}

// Driver program
int main()
{
    int A[] = {10, 15, 25};
    int B[] = {5, 20, 30};
    int n = sizeof(A)/sizeof(A[0]);
    int m = sizeof(B)/sizeof(B[0]);
    generate(A, B, n, m);
    return 0;
}

Java

class GenerateArrays {

    /* Function to generates and prints all sorted arrays from alternate
       elements of 'A[i..m-1]' and 'B[j..n-1]'
       If 'flag' is true, then current element is to be included from A 
       otherwise from B.
       'len' is the index in output array C[]. We print output array  
       each time before including a character from A only if length of 
       output array is greater than 0. We try than all possible 
       combinations */
    void generateUtil(int A[], int B[], int C[], int i, int j, int m, int n,
            int len, boolean flag) 
    {
        if (flag) // Include valid element from A
        {
            // Print output if there is at least one 'B' in output array 'C'
            if (len != 0) 
                printArr(C, len + 1);

            // Recur for all elements of A after current index
            for (int k = i; k < m; k++) 
            {
                if (len == 0) 
                {
                    /* this block works for the very first call to include
                    the first element in the output array */
                    C[len] = A[k];

                    // don't increment lem as B is included yet
                    generateUtil(A, B, C, k + 1, j, m, n, len, !flag);
                } 
                
                /* include valid element from A and recur */
                else if (A[k] > C[len]) 
                {
                        C[len + 1] = A[k];
                        generateUtil(A, B, C, k + 1, j, m, n, len + 1, !flag);
                }
            }
        } 
        
        /* Include valid element from B and recur */
        else
        {
            for (int l = j; l < n; l++) 
            {
                if (B[l] > C[len]) 
                {
                    C[len + 1] = B[l];
                    generateUtil(A, B, C, i, l + 1, m, n, len + 1, !flag);
                }
            }
        }
    }

    /* Wrapper function */
    void generate(int A[], int B[], int m, int n) 
    {
        int C[] = new int[m + n];
     
        /* output array */
        generateUtil(A, B, C, 0, 0, m, n, 0, true);
    }

    // A utility function to print an array
    void printArr(int arr[], int n) 
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
        System.out.println("");
    }

    public static void main(String[] args) 
    {
        GenerateArrays generate = new GenerateArrays();
        int A[] = {10, 15, 25};
        int B[] = {5, 20, 30};
        int n = A.length;
        int m = B.length;
        generate.generate(A, B, n, m);
    }
}

// This code has been contributed by Mayank Jaiswal


Output:
10 20
10 20 25 30
10 30
15 20
15 20 25 30
15 30
25 30

This article is contributed by Gaurav Ahirwar. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above\

GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.

Recommended Posts:



4.2 Average Difficulty : 4.2/5.0
Based on 108 vote(s)










Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.