# Count number of ways to arrange first N numbers

• Difficulty Level : Hard
• Last Updated : 09 Jun, 2021

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:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 == 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 == 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
a = 1
a = 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;``    ``dp = 1;` `    ``// (12) as the only possibility``    ``dp = 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;``    ``dp = 1;` `    ``// (12) as the only possibility``    ``dp = 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`

My Personal Notes arrow_drop_up