# Fill two instances of all numbers from 1 to n in a specific way

Given a number n, create an array of size 2n such that the array contains 2 instances of every number from 1 to n, and the number of elements between two instances of a number i is equal to i. If such a configuration is not possible, then print the same.

Examples:

```Input: n = 3
Output: res[] = {3, 1, 2, 1, 3, 2}

Input: n = 2
Output: Not Possible

Input: n = 4
Output: res[] = {4, 1, 3, 1, 2, 4, 3, 2}```

We strongly recommend to minimize the browser and try this yourself first.

One solution is to Backtracking. The idea is simple, we place two instances of n at a place, then recur for n-1. If recurrence is successful, we return true, else we backtrack and try placing n at different location. Following is implementation of the idea.

## C++

 `// A backtracking based C++ Program to fill  ` `// two instances of all numbers from 1 to n ` `// in a specific way  ` `#include ` `using` `namespace` `std; ` ` `  `// A recursive utility function to fill  ` `// two instances of numbers from 1 to n  ` `// in res[0..2n-1]. 'curr' is current value of n.  ` `bool` `fillUtil(``int` `res[], ``int` `curr, ``int` `n)  ` `{  ` `    ``// If current number becomes 0,  ` `    ``// then all numbers are filled  ` `    ``if` `(curr == 0)  ` `    ``return` `true``;  ` ` `  `    ``// Try placing two instances of 'curr' at  ` `    ``// all possible locations till solution is found  ` `    ``int` `i;  ` `    ``for` `(i = 0; i < 2 * n - curr - 1; i++)  ` `    ``{  ` `        ``// Two 'curr' should be placed at  ` `        ``// 'curr+1' distance  ` `        ``if` `(res[i] == 0 && res[i + curr + 1] == 0)  ` `        ``{  ` `             `  `            ``// Plave two instances of 'curr'  ` `            ``res[i] = res[i + curr + 1] = curr;  ` `     `  `            ``// Recur to check if the above placement  ` `            ``// leads to a solution  ` `            ``if` `(fillUtil(res, curr - 1, n))  ` `                ``return` `true``;  ` `     `  `            ``// If solution is not possible,  ` `            ``// then backtrack  ` `            ``res[i] = res[i + curr + 1] = 0;  ` `        ``}  ` `    ``}  ` `    ``return` `false``;  ` `}  ` ` `  `// This function prints the result for ` `// input number 'n' using fillUtil()  ` `void` `fill(``int` `n)  ` `{  ` `    ``// Create an array of size 2n and ` `    ``// initialize all elements in it as 0  ` `    ``int` `res[2 * n], i;  ` `    ``for` `(i = 0; i < 2 * n; i++)  ` `    ``res[i] = 0;  ` ` `  `    ``// If solution is possible,  ` `    ``// then print it.  ` `    ``if` `(fillUtil(res, n, n))  ` `    ``{  ` `        ``for` `(i = 0; i < 2 * n; i++)  ` `        ``cout << res[i] << ``" "``;  ` `    ``}  ` `    ``else` `        ``cout << ``"Not Possible"``;  ` `}  ` ` `  `// Driver Code ` `int` `main()  ` `{  ` `    ``fill(7);  ` `    ``return` `0;  ` `}  ` ` `  `// This code is contributed ` `// by SHUBHAMSINGH8410 `

## C

 `// A backtracking based C Program to fill two instances of all numbers  ` `// from 1 to n in a specific way ` `#include ` `#include ` ` `  `// A recursive utility function to fill two instances of numbers from  ` `// 1 to n in res[0..2n-1].  'curr' is current value of n. ` `bool` `fillUtil(``int` `res[], ``int` `curr, ``int` `n) ` `{ ` `     ``// If current number becomes 0, then all numbers are filled ` `     ``if` `(curr == 0) ``return` `true``; ` ` `  `     ``// Try placing two instances of 'curr' at all possible locations ` `     ``// till solution is found ` `     ``int` `i; ` `     ``for` `(i=0; i<2*n-curr-1; i++) ` `     ``{ ` `        ``// Two 'curr' should be placed at 'curr+1' distance ` `        ``if` `(res[i] == 0 && res[i + curr + 1] == 0) ` `        ``{ ` `           ``// Plave two instances of 'curr' ` `           ``res[i] = res[i + curr + 1] = curr; ` ` `  `           ``// Recur to check if the above placement leads to a solution ` `           ``if` `(fillUtil(res, curr-1, n)) ` `               ``return` `true``; ` ` `  `           ``// If solution is not possible, then backtrack ` `           ``res[i] = res[i + curr + 1] = 0; ` `        ``} ` `     ``} ` `     ``return` `false``; ` `} ` ` `  `// This function prints the result for input number 'n' using fillUtil() ` `void` `fill(``int` `n) ` `{ ` `    ``// Create an array of size 2n and initialize all elements in it as 0 ` `    ``int` `res[2*n], i; ` `    ``for` `(i=0; i<2*n; i++) ` `       ``res[i] = 0; ` ` `  `    ``// If solution is possible, then print it. ` `    ``if` `(fillUtil(res, n, n)) ` `    ``{ ` `        ``for` `(i=0; i<2*n; i++) ` `           ``printf``(``"%d "``, res[i]); ` `    ``} ` `    ``else` `        ``puts``(``"Not Possible"``); ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `  ``fill(7); ` `  ``return` `0; ` `} `

## Java

 `// A backtracking based C++ Program to fill  ` `// two instances of all numbers from 1 to n ` `// in a specific way ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `     `  `// A recursive utility function to fill  ` `// two instances of numbers from 1 to n  ` `// in res[0..2n-1]. 'curr' is current value of n.  ` `static` `boolean` `fillUtil(``int` `res[], ``int` `curr, ``int` `n)  ` `{  ` `    ``// If current number becomes 0,  ` `    ``// then all numbers are filled  ` `    ``if` `(curr == ``0``)  ` `    ``return` `true``;  ` ` `  `    ``// Try placing two instances of 'curr' at  ` `    ``// all possible locations till solution is found  ` `    ``int` `i;  ` `    ``for` `(i = ``0``; i < ``2` `* n - curr - ``1``; i++)  ` `    ``{  ` `        ``// Two 'curr' should be placed at  ` `        ``// 'curr+1' distance  ` `        ``if` `(res[i] == ``0` `&& res[i + curr + ``1``] == ``0``)  ` `        ``{  ` `             `  `            ``// Plave two instances of 'curr'  ` `            ``res[i] = res[i + curr + ``1``] = curr;  ` `     `  `            ``// Recur to check if the above placement  ` `            ``// leads to a solution  ` `            ``if` `(fillUtil(res, curr - ``1``, n))  ` `                ``return` `true``;  ` `     `  `            ``// If solution is not possible,  ` `            ``// then backtrack  ` `            ``res[i] = res[i + curr + ``1``] = ``0``;  ` `        ``}  ` `    ``}  ` `    ``return` `false``;  ` `}  ` ` `  `// This function prints the result for ` `// input number 'n' using fillUtil()  ` `static` `void` `fill(``int` `n)  ` `{  ` `    ``// Create an array of size 2n and ` `    ``// initialize all elements in it as 0  ` `    ``int` `res[] = ``new` `int``[``2` `* n]; ` `    ``int` `i;  ` `    ``for` `(i = ``0``; i < ``2` `* n; i++)  ` `    ``res[i] = ``0``;  ` ` `  `    ``// If solution is possible,  ` `    ``// then print it.  ` `    ``if` `(fillUtil(res, n, n))  ` `    ``{  ` `        ``for` `(i = ``0``; i < ``2` `* n; i++)  ` `            ``System.out.print(res[i] + ``" "``);  ` `    ``}  ` `    ``else` `        ``System.out.print(``"Not Possible"``);  ` `}  ` ` `  `// Driver Code ` `public` `static` `void` `main (String[] args) ` `{ ` `    ``fill(``7``);  ` `}  ` `} ` ` `  `// This code is contributed by ajit `

## Python3

 `# A backtracking based Python3 Program ` `# to fill two instances of all numbers ` `# from 1 to n in a specific way ` `def` `fillUtil(res, curr, n): ` `     `  `    ``# A recursive utility function to fill  ` `    ``# two instances of numbers from 1 to n ` `    ``# in res[0..2n-1]. 'curr' is current value of n.  ` ` `  `    ``# If current number becomes 0, ` `    ``# then all numbers are filled ` `    ``if` `curr ``=``=` `0``: ` `        ``return` `True` ` `  `    ``# Try placing two instances of 'curr' at all  ` `    ``# possible locations till solution is found ` `    ``for` `i ``in` `range``(``2` `*` `n ``-` `curr ``-` `1``): ` ` `  `        ``# Two 'curr' should be placed ` `        ``# at 'curr+1' distance ` `        ``if` `res[i] ``=``=` `0` `and` `res[i ``+` `curr ``+` `1``] ``=``=` `0``: ` ` `  `            ``# Place two instances of 'curr' ` `            ``res[i] ``=` `res[i ``+` `curr ``+` `1``] ``=` `curr ` ` `  `            ``# Recur to check if the above  ` `            ``# placement leads to a solution ` `            ``if` `fillUtil(res, curr ``-` `1``, n): ` `                ``return` `True` ` `  `            ``# If solution is not possible,  ` `            ``# then backtrack ` `            ``res[i] ``=` `0` `            ``res[i ``+` `curr ``+` `1``] ``=` `0` ` `  `    ``return` `False` ` `  `def` `fill(n): ` `     `  `    ``# This function prints the result ` `    ``# for input number 'n' using fillUtil() ` ` `  `    ``# Create an array of size 2n and ` `    ``# initialize all elements in it as 0 ` `    ``res ``=` `[``0``] ``*` `(``2` `*` `n) ` ` `  `    ``# If solution is possible, then print it. ` `    ``if` `fillUtil(res, n, n): ` `        ``for` `i ``in` `range``(``2` `*` `n): ` `            ``print``(res[i], end ``=` `' '``) ` `        ``print``() ` `    ``else``: ` `        ``print``(``"Not Possible"``) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``fill(``7``) ` ` `  `# This code is contributed by vibhu4agarwal `

## C#

 `// A backtracking based C# Program to fill  ` `// two instances of all numbers from 1 to n ` `// in a specific way  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// A recursive utility function to fill  ` `// two instances of numbers from 1 to n  ` `// in res[0..2n-1]. 'curr' is current value of n.  ` `static` `bool` `fillUtil(``int` `[]res, ``int` `curr, ``int` `n)  ` `{  ` `    ``// If current number becomes 0,  ` `    ``// then all numbers are filled  ` `    ``if` `(curr == 0)  ` `    ``return` `true``;  ` ` `  `    ``// Try placing two instances of 'curr' at  ` `    ``// all possible locations till solution is found  ` `    ``int` `i;  ` `    ``for` `(i = 0; i < 2 * n - curr - 1; i++)  ` `    ``{  ` `        ``// Two 'curr' should be placed at  ` `        ``// 'curr+1' distance  ` `        ``if` `(res[i] == 0 && res[i + curr + 1] == 0)  ` `        ``{  ` `             `  `            ``// Plave two instances of 'curr'  ` `            ``res[i] = res[i + curr + 1] = curr;  ` `     `  `            ``// Recur to check if the above placement  ` `            ``// leads to a solution  ` `            ``if` `(fillUtil(res, curr - 1, n))  ` `                ``return` `true``;  ` `     `  `            ``// If solution is not possible,  ` `            ``// then backtrack  ` `            ``res[i] = res[i + curr + 1] = 0;  ` `        ``}  ` `    ``}  ` `    ``return` `false``;  ` `}  ` ` `  `// This function prints the result for ` `// input number 'n' using fillUtil()  ` `static` `void` `fill(``int` `n)  ` `{  ` `    ``// Create an array of size 2n and ` `    ``// initialize all elements in it as 0  ` `    ``int` `[]res=``new` `int``[2 * n]; ` `    ``int` `i;  ` `    ``for` `(i = 0; i < (2 * n); i++)  ` `    ``res[i] = 0;  ` ` `  `    ``// If solution is possible,  ` `    ``// then print it.  ` `    ``if` `(fillUtil(res, n, n))  ` `    ``{  ` `        ``for` `(i = 0; i < 2 * n; i++)  ` `        ``Console.Write (res[i] + ``" "``);  ` `    ``}  ` `    ``else` `        ``Console.Write (``"Not Possible"``);  ` `}  ` ` `  `// Driver Code ` `static` `public` `void` `Main () ` `{ ` `    ``fill(7); ` `}  ` `} ` ` `  `// This code is contributed by ajit `

Output:

`7 3 6 2 5 3 2 4 7 6 5 1 4 1`

The above solution may not be the best possible solution. There seems to be a pattern in the output. I an Looking for a better solution from other geeks.

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.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.