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 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)
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\
Please Login to comment...