# 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.

 `#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; ` `} `

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

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

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