# Count number of ways to arrange first N numbers

• Difficulty Level : Hard
• Last Updated : 27 Mar, 2023

Count number of ways to arrange the first N natural numbers in a line such that the left-most number is always 1 and no two consecutive numbers have an absolute difference greater than 2.

Examples:

Input: N = 4
Output:
The only possible arrangements are (1, 2, 3, 4),
(1, 2, 4, 3), (1, 3, 4, 2) and (1, 3, 2, 4).

Input: N = 6
Output:

Naive approach: Generate all the permutations and count how many of them satisfy the given conditions.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count``// of required arrangements``int` `countWays(``int` `n)``{` `    ``// Create a vector``    ``vector<``int``> a;``    ``int` `i = 1;` `    ``// Store numbers from 1 to n``    ``while` `(i <= n)``        ``a.push_back(i++);` `    ``// To store the count of ways``    ``int` `ways = 0;` `    ``// Generate all the permutations``    ``// using next_permutation in STL``    ``do` `{``        ``// Initialize flag to true if first``        ``// element is 1 else false``        ``bool` `flag = (a[0] == 1);` `        ``// Checking if the current permutation``        ``// satisfies the given conditions``        ``for` `(``int` `i = 1; i < n; i++) {` `            ``// If the current permutation is invalid``            ``// then set the flag to false``            ``if` `(``abs``(a[i] - a[i - 1]) > 2)``                ``flag = 0;``        ``}` `        ``// If valid arrangement``        ``if` `(flag)``            ``ways++;` `        ``// Generate the next permutation``    ``} ``while` `(next_permutation(a.begin(), a.end()));` `    ``return` `ways;``}` `// Driver code``int` `main()``{``    ``int` `n = 6;` `    ``cout << countWays(n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the``// above approach``import` `java.util.*;``class` `GFG{` `// Function to return the count``// of required arrangements``static` `int` `countWays(``int` `n)``{``  ``// Create a vector``  ``Vector a =``         ``new` `Vector<>();``  ``int` `i = ``1``;` `  ``// Store numbers from``  ``// 1 to n``  ``while` `(i <= n)``    ``a.add(i++);` `  ``// To store the count``  ``// of ways``  ``int` `ways = ``0``;` `  ``// Generate all the permutations``  ``// using next_permutation in STL``  ``do``  ``{``    ``// Initialize flag to true``    ``// if first element is 1``    ``// else false``    ``boolean` `flag = (a.get(``0``) == ``1``);` `    ``// Checking if the current``    ``// permutation satisfies the``    ``// given conditions``    ``for` `(``int` `j = ``1``; j < n; j++)``    ``{``      ``// If the current permutation``      ``// is invalid then set the``      ``// flag to false``      ``if` `(Math.abs(a.get(j) -``                   ``a.get(j - ``1``)) > ``2``)``        ``flag = ``false``;``    ``}` `    ``// If valid arrangement``    ``if` `(flag)``      ``ways++;` `    ``// Generate the next permutation``  ``} ``while` `(next_permutation(a));` `  ``return` `ways;``}``  ` `static` `boolean` `next_permutation(Vector p)``{``  ``for` `(``int` `a = p.size() - ``2``;``           ``a >= ``0``; --a)``    ``if` `(p.get(a) < p.get(a + ``1``))``      ``for` `(``int` `b = p.size() - ``1``;; --b)``        ``if` `(p.get(b) > p.get(a))``        ``{``          ``int` `t = p.get(a);``          ``p.set(a, p.get(b));``          ``p.set(b, t);` `          ``for` `(++a, b = p.size() - ``1``;``                 ``a < b; ++a, --b)``          ``{``            ``t = p.get(a);``            ``p.set(a, p.get(b));``            ``p.set(b, t);``          ``}``          ``return` `true``;``        ``}``  ``return` `false``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``  ``int` `n = ``6``;``  ``System.out.print(countWays(n));``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 implementation of the approach``from` `itertools ``import` `permutations` `# Function to return the count``# of required arrangements``def` `countWays(n):``    ` `    ``# Create a vector``    ``a ``=` `[]``    ``i ``=` `1``    ` `    ``# Store numbers from 1 to n``    ``while` `(i <``=` `n):``        ``a.append(i)``        ``i ``+``=` `1``        ` `    ``# To store the count of ways``    ``ways ``=` `0``    ` `    ``# Generate the all permutation``    ``for` `per ``in` `list``(permutations(a)):``        ` `        ``# Initialize flag to true if first``        ``# element is 1 else false``        ``flag ``=` `1` `if` `(per[``0``] ``=``=` `1``) ``else` `0``        ` `        ``# Checking if the current permutation``        ``# satisfies the given conditions``        ``for` `i ``in` `range``(``1``, n):``            ` `            ``# If the current permutation is invalid``            ``# then set the flag to false``            ``if` `(``abs``(per[i] ``-` `per[i ``-` `1``]) > ``2``):``                ``flag ``=` `0``                ` `        ``# If valid arrangement``        ``if` `(flag):``            ``ways ``+``=` `1` `    ``return` `ways``    ` `# Driver code``n ``=` `6` `print``(countWays(n))` `# This code is contributed by shivanisinghss2110`

## C#

 `// C# implementation of the``// above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// Function to return the count``// of required arrangements``static` `int` `countWays(``int` `n)``{``  ``// Create a vector``  ``List<``int``> a =``       ``new` `List<``int``>();``  ``int` `i = 1;` `  ``// Store numbers from``  ``// 1 to n``  ``while` `(i <= n)``    ``a.Add(i++);` `  ``// To store the count``  ``// of ways``  ``int` `ways = 0;` `  ``// Generate all the``  ``// permutations using``  ``// next_permutation in STL``  ``do``  ``{``    ``// Initialize flag to true``    ``// if first element is 1``    ``// else false``    ``bool` `flag = (a[0] == 1);` `    ``// Checking if the current``    ``// permutation satisfies the``    ``// given conditions``    ``for` `(``int` `j = 1; j < n; j++)``    ``{``      ``// If the current permutation``      ``// is invalid then set the``      ``// flag to false``      ``if` `(Math.Abs(a[j] -``                   ``a[j - 1]) > 2)``        ``flag = ``false``;``    ``}` `    ``// If valid arrangement``    ``if` `(flag)``      ``ways++;` `    ``// Generate the next``    ``// permutation``  ``} ``while` `(next_permutation(a));` `  ``return` `ways;``}``  ` `static` `bool` `next_permutation(List<``int``> p)``{``  ``for` `(``int` `a = p.Count - 2;``           ``a >= 0; --a)``    ``if` `(p[a] < p[a + 1])``      ``for` `(``int` `b = p.Count - 1;; --b)``        ``if` `(p[b] > p[a])``        ``{``          ``int` `t = p[a];``          ``p[a] = p[b];``          ``p[b]  =  t;` `          ``for` `(++a, b = p.Count - 1;``                 ``a < b; ++a, --b)``          ``{``            ``t = p[a];``            ``p[a] = p[b];``            ``p[b] = t;``          ``}``          ``return` `true``;``        ``}``  ``return` `false``;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``  ``int` `n = 6;``  ``Console.Write(countWays(n));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`9`

Efficient approach: This problem can be solved using dynamic programming
A better linear approach to this problem relies on the following observation. Look for the position of 2. Let a[i] be the number of ways for n = i. There are three cases:

1. 12_____ – “2” in the second position.
2. 1*2____ – “2” in the third position.
1**2___ – “2” in the fourth position is impossible because only possible way is (1342), which is same as case 3.
1***2__ – “2” in the fifth position is impossible because 1 must be followed by 3, 3 by 5 and 2 needs 4 before it so it becomes 13542, again as case 3.
3. 1_(i – 2)terms___2 – “2” in the last position (1357642 and similar)

For each case, the following are the sub-task:
Adding 1 to each term of a[i – 1] i.e. (1__(i – 1) terms__).
As for 1_2_____ there can only be one 1324___(i – 4) terms____ i.e. a[i – 3].

Hence, the recurrence relation will be,

a[i] = a[i – 1] + a[i – 3] + 1

And the base cases will be:

a[0] = 0
a[1] = 1
a[2] = 1

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count``// of required arrangements``int` `countWays(``int` `n)``{``    ``// Create the dp array``    ``int` `dp[n + 1];` `    ``// Initialize the base cases``    ``// as explained above``    ``dp[0] = 0;``    ``dp[1] = 1;` `    ``// (12) as the only possibility``    ``dp[2] = 1;` `    ``// Generate answer for greater values``    ``for` `(``int` `i = 3; i <= n; i++) {``        ``dp[i] = dp[i - 1] + dp[i - 3] + 1;``    ``}` `    ``// dp[n] contains the desired answer``    ``return` `dp[n];``}` `// Driver code``int` `main()``{``    ``int` `n = 6;` `    ``cout << countWays(n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `// Function to return the count``// of required arrangements``static` `int` `countWays(``int` `n)``{``    ``// Create the dp array``    ``int` `[]dp = ``new` `int``[n + ``1``];` `    ``// Initialize the base cases``    ``// as explained above``    ``dp[``0``] = ``0``;``    ``dp[``1``] = ``1``;` `    ``// (12) as the only possibility``    ``dp[``2``] = ``1``;` `    ``// Generate answer for greater values``    ``for` `(``int` `i = ``3``; i <= n; i++)``    ``{``        ``dp[i] = dp[i - ``1``] + dp[i - ``3``] + ``1``;``    ``}` `    ``// dp[n] contains the desired answer``    ``return` `dp[n];``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``int` `n = ``6``;``    ``System.out.println(countWays(n));``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python implementation of the approach` `# Function to return the count``# of required arrangements``def` `countWays(n):``    ` `    ``# Create the dp array``    ``dp ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]` `    ``# Initialize the base cases``    ``# as explained above``    ``dp[``0``] ``=` `0``    ``dp[``1``] ``=` `1` `    ``# (12) as the only possibility``    ``dp[``2``] ``=` `1` `    ``# Generate answer for greater values``    ``for` `i ``in` `range``(``3``, n ``+` `1``):``        ``dp[i] ``=` `dp[i ``-` `1``] ``+` `dp[i ``-` `3``] ``+` `1` `    ``# dp[n] contains the desired answer``    ``return` `dp[n]` `# Driver code``n ``=` `6` `print``(countWays(n))` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach``using` `System;``class` `GFG``{` `// Function to return the count``// of required arrangements``static` `int` `countWays(``int` `n)``{``    ``// Create the dp array``    ``int` `[]dp = ``new` `int``[n + 1];` `    ``// Initialize the base cases``    ``// as explained above``    ``dp[0] = 0;``    ``dp[1] = 1;` `    ``// (12) as the only possibility``    ``dp[2] = 1;` `    ``// Generate answer for greater values``    ``for` `(``int` `i = 3; i <= n; i++)``    ``{``        ``dp[i] = dp[i - 1] + dp[i - 3] + 1;``    ``}` `    ``// dp[n] contains the desired answer``    ``return` `dp[n];``}` `// Driver code``public` `static` `void` `Main()``{``    ``int` `n = 6;``    ``Console.WriteLine(countWays(n));``}``}` `// This code is contributed by Code@Mech.`

## Javascript

 ``

Output:

`9`

Time Complexity: O(N)
Space Complexity: O(N)

Efficient approach : Space optimization O(1)

In previous approach the current value dp[i] is depend upon the previous 2 values i.e. dp[i-1] and dp[i-3] so instead of using array of size N we can create 3 variables prev1 , prev2, prev3 to keep track of previous 3 computations.

Implementations Steps :

• Create variables prev1, prev2, prev3 to store previous computations.
• Initialize them with base cases.
• Create a variable curr to store current value.
• Now iterate over subproblems and get the current value from previous values.
• After every iteration update prev1, prev2 and prev3 for further iterations.
• At last return final answer.

Implementation:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count``// of required arrangements``int` `countWays(``int` `n)``{`  `    ``// Initialize the base cases``    ``// as explained above``    ``int` `prev1 =0;``    ``int` `prev2 =1;``    ``int` `prev3 =1;``    ` `    ``// to store current value``    ``int` `curr;``    ` `    ``// Generate answer for greater values``    ``for` `(``int` `i = 3; i <= n; i++) {``        ``curr = prev3 + prev1 + 1;``        ` `        ``// assigning values for further iterations``        ``prev1 = prev2;``        ``prev2=prev3;``        ``prev3=curr;``    ``}` `    ``// curr contains the desired answer``    ``return` `curr;``}` `// Driver code``int` `main()``{``    ``int` `n = 6;``    ` `      ``// function call``    ``cout << countWays(n);` `    ``return` `0;``}`

Output

`9`

Time Complexity: O(N)
Space Complexity: O(1)

My Personal Notes arrow_drop_up