Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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 <bits/stdc++.h>
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 <stdio.h>
#include <stdbool.h>
 
// 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




<script>
    // A backtracking based Javascript Program to fill
    // two instances of all numbers from 1 to n
    // in a specific way
     
    // 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.
    function fillUtil(res, curr, 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
        let 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()
    function fill(n)
    {
     
        // Create an array of size 2n and
        // initialize all elements in it as 0
        let res=new Array(2 * n);
        let 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++)
            document.write(res[i] + " ");
        }
        else
            document.write("Not Possible");
    }
     
    fill(7);
 
// This code is contributed by divyeshrabadiya07.
</script>


Output: 

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

Time Complexity: O(n^2)

Space complexity: O(n)
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.

 



Last Updated : 06 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads