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, 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 ?> |
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)
\
Recommended Articles