Skip to content
Related Articles
Generate all possible sorted arrays from alternate elements of two given sorted arrays
• Difficulty Level : Hard
• Last Updated : 03 Jun, 2021

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.

## 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);``    ``int` `m = ``sizeof``(B)/``sizeof``(B);``    ``generate(A, B, n, m);``    ``return` `0;``}`

## Java

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

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\

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up