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

• Difficulty Level : Hard
• Last Updated : 09 Mar, 2022

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) ` `        ``{ ` `            `  `            ``// 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] = 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)` `        ``{` `           ``// 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] = 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``) ` `        ``{ ` `            `  `            ``// 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] = 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) ` `        ``{ ` `            `  `            ``// 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] = 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`

## Javascript

 ``

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.