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

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

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 

Python3

# A utility function to print an array 
def printArr(arr,n): 
  
    for i in range(n): 
        print(arr[i] , " ",end="") 
    print() 
   
''' 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 '''
def generateUtil(A,B,C,i,j,m,n,len,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 k in range(i,m): 
          
            if ( not 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,  not 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, not flag) 
                  
      
    else:   
    
        # Include valid element from B and recur 
        for l in range(j,n): 
          
            if (B[l] > C[len]): 
              
                C[len+1] = B[l] 
                generateUtil(A, B, C, i, l+1, m, n, len+1, not flag) 
              
  
# Wrapper function  
def generate(A,B,m,n): 
  
    C=[]    #output array  
    for i in range(m+n+1): 
        C.append(0) 
    generateUtil(A, B, C, 0, 0, m, n, 0, True) 
   
   
# Driver program 
  
A = [10, 15, 25] 
B = [5, 20, 30] 
n = len(A) 
m = len(B) 
  
generate(A, B, n, m) 
  
# This code is contributed 
# by Anant Agarwal. 

C#

// C# Program to generate all possible 
// sorted arrays from alternate elements 
// of two given sorted arrays 
using System; 
  
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 */
   public virtual void generateUtil(int[] A, int[] B, 
                                    int[] C, int i,  
                                    int j, int m, int n, 
                                    int len, bool flag) { 
      
    // Include valid  
    // element from A                                    
    if (flag)  
    { 
          
        // 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  
public virtual 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  
public virtual void printArr(int[] arr, int n) { 
      
    for (int i = 0; i < n; i++) { 
        Console.Write(arr[i] + " "); 
    } 
    Console.WriteLine(""); 
} 
  
// Driver Code 
public static void Main(string[] args) { 
      
    GenerateArrays generate = new GenerateArrays(); 
      
    int[] A = new int[] {10, 15, 25}; 
    int[] B = new int[] {5, 20, 30}; 
      
    int n = A.Length; 
    int m = B.Length; 
    generate.generate(A, B, n, m); 
} 
} 
  
// This code is contributed by Shrikant13 

PHP

<?php  
  
/* 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 */
function generateUtil(&$A, &$B, &$C, $i, $j, 
                       $m, $n, $len, $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 ($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 ($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 */
function generate(&$A, &$B, $m, $n) 
{ 
    $C = array_fill(0, ($m + $n), NULL); /* output array */
    generateUtil($A, $B, $C, 0, 0, $m, $n, 0, true); 
} 
  
// A utility function to print an array 
function printArr(&$arr, $n) 
{ 
    for ($i = 0; $i < $n; $i++) 
        echo $arr[$i] . " "; 
    echo "\n"; 
} 
  
// Driver Code 
$A = array(10, 15, 25); 
$B = array(5, 20, 30); 
$n = sizeof($A); 
$m = sizeof($B); 
generate($A, $B, $n, $m); 
  
// This code is contributed by ChitraNayal 
?> 

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\

My Personal Notes

Suggest a Topic

C++

Java

Python3

C#

PHP

Recommended Posts: