Open in App
Not now

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

• Difficulty Level : Hard
• Last Updated : 08 Dec, 2022

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` `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

 ` ``\$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

 ``

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)