Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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

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

Method 1: 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’.

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




import java.io.*;
  
public 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, lennot 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
?>


Javascript




<script>
    /*
     * 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 != 0)
                printArr(C, len + 1);
  
            // Recur for all elements of A after current index
            for (var 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 (var 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) {
        var C = Array(m + n).fill(0);
  
        /* 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++)
            document.write(arr[i] + " ");
        document.write("<br/>");
    }
  
      
      
        var A = [ 10, 15, 25 ];
        var B = [ 5, 20, 30 ];
        var n = A.length;
        var m = B.length;
        generate(A, B, n, m);
  
// This code contributed by gauravrajput1
</script>


Output

10 20 
10 20 25 30 
10 30 
15 20 
15 20 25 30 
15 30 
25 30 

Time Complexity: O(N2)
Auxiliary Space: O(M+N)

\
 



Last Updated : 11 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads