Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count Derangements (Permutation such that no element appears in its original position)

  • Difficulty Level : Medium
  • Last Updated : 20 Jan, 2022

A Derangement is a permutation of n elements, such that no element appears in its original position. For example, a derangement of {0, 1, 2, 3} is {2, 3, 1, 0}.
Given a number n, find the total number of Derangements of a set of n elements.

Examples : 

Input: n = 2
Output: 1
For two elements say {0, 1}, there is only one 
possible derangement {1, 0}

Input: n = 3
Output: 2
For three elements say {0, 1, 2}, there are two 
possible derangements {2, 0, 1} and {1, 2, 0}

Input: n = 4
Output: 9
For four elements say {0, 1, 2, 3}, there are 9
possible derangements {1, 0, 3, 2} {1, 2, 3, 0}
{1, 3, 0, 2}, {2, 3, 0, 1}, {2, 0, 3, 1}, {2, 3,
1, 0}, {3, 0, 1, 2}, {3, 2, 0, 1} and {3, 2, 1, 0}

Let countDer(n) be count of derangements for n elements. Below is the recursive relation to it.  

countDer(n) = (n - 1) * [countDer(n - 1) + countDer(n - 2)]

How does above recursive relation work? 

There are n – 1 way for element 0 (this explains multiplication with n – 1). 
Let 0 be placed at index i. There are now two possibilities, depending on whether or not element i is placed at 0 in return. 

  1. i is placed at 0: This case is equivalent to solving the problem for n-2 elements as two elements have just swapped their positions.
  2. i is not placed at 0: This case is equivalent to solving the problem for n-1 elements as now there are n-1 elements, n-1 positions and every element has n-2 choices

Below is the simple solution based on the above recursive formula:

C++




// A Naive Recursive C++ program
// to count derangements
#include <bits/stdc++.h>
using namespace std;
 
int countDer(int n)
{
  // Base cases
  if (n == 1) return 0;
  if (n == 2) return 1;
 
  // countDer(n) = (n-1)[countDer(n-1) + der(n-2)]
  return (n - 1) * (countDer(n - 1) + countDer(n - 2));
}
 
// Driver Code
int main()
{
    int n = 4;
    cout << "Count of Derangements is "
         << countDer(n);
    return 0;
}
Java



// A Naive Recursive java
// program to count derangements
import java.io.*;
 
class GFG
{
     
    // Function to count
    // derangements
    static int countDer(int n)
    {
        // Base cases
        if (n == 1) return 0;
        if (n == 2) return 1;
         
        // countDer(n) = (n-1)[countDer(n-1) + der(n-2)]
        return (n - 1) * (countDer(n - 1) +
                          countDer(n - 2));
    }
     
    // Driver Code
    public static void main (String[] args)
    {
        int n = 4;
        System.out.println( "Count of Derangements is "
                             +countDer(n));
 
    }
}
 
// This code is contributed by vt_m
Python3



# A Naive Recursive Python3
# program to count derangements
 
def countDer(n):
     
    # Base cases
    if (n == 1): return 0
    if (n == 2): return 1
     
    # countDer(n) = (n-1)[countDer(n-1) + der(n-2)]
    return (n - 1) * (countDer(n - 1) +
                      countDer(n - 2))
 
# Driver Code
n = 4
print("Count of Derangements is ", countDer(n))
 
 
# This code is contributed by Azkia Anam.
C#



// A Naive Recursive C#
// program to count derangements
using System;
 
class GFG
{
     
    // Function to count
    // derangements
    static int countDer(int n)
    {
        // Base cases
        if (n == 1) return 0;
        if (n == 2) return 1;
         
        // countDer(n) = (n-1)[countDer(n-1) + der(n-2)]
        return (n - 1) * (countDer(n - 1) +
                          countDer(n - 2));
    }
     
    // Driver Code
    public static void Main ()
    {
        int n = 4;
        Console.Write( "Count of Derangements is " +
                        countDer(n));
 
    }
}
 
// This code is contributed by nitin mittal.
PHP



<?php
// A Naive Recursive PHP program
// to count derangements
 
function countDer($n)
{
     
    // Base cases
    if ($n == 1)
        return 0;
    if ($n == 2)
        return 1;
     
    // countDer(n) = (n-1)[countDer(n-1) +
    // der(n-2)]
    return ($n - 1) * (countDer($n - 1) +
                       countDer($n - 2));
}
 
    // Driver Code
    $n = 4;
    echo "Count of Derangements is ", countDer($n);
 
// This code is contributed by nitin mittal.
?>
Javascript



<script>
 
    // A Naive Recursive Javascript
    // program to count derangements
     
    // Function to count
    // derangements
    function countDer(n)
    {
        // Base cases
        if (n == 1) return 0;
        if (n == 2) return 1;
          
        // countDer(n) = (n-1)[countDer(n-1) + der(n-2)]
        return (n - 1) * (countDer(n - 1) + countDer(n - 2));
    }
     
    let n = 4;
    document.write("Count of Derangements is " + countDer(n));
     
</script>
Output
Count of Derangements is 9
Time Complexity: T(n) = T(n-1) + T(n-2) which is exponential. 
We can observe that this implementation does repeat work. For example, see recursion tree for countDer(5), countDer(3) is being evaluated twice. 
cdr() ==> countDer()

                    cdr(5)   
                 /         \     
             cdr(4)          cdr(3)   
           /      \         /     \
       cdr(3)     cdr(2)  cdr(2)   cdr(1)
An Efficient Solution is to use Dynamic Programming to store results of subproblems in an array and build the array in bottom-up manner. 
C++



// A Dynamic programming based C++
// program to count derangements
#include <bits/stdc++.h>
using namespace std;
 
int countDer(int n)
{
    // Create an array to store
    // counts for subproblems
    int der[n + 1] = {0};
 
    // Base cases
    der[1] = 0;
    der[2] = 1;
 
    // Fill der[0..n] in bottom up manner
    // using above recursive formula
    for (int i = 3; i <= n; ++i)
        der[i] = (i - 1) * (der[i - 1] +
                            der[i - 2]);
 
    // Return result for n
    return der[n];
}
 
// Driver code
int main()
{
    int n = 4;
    cout << "Count of Derangements is "
         << countDer(n);
    return 0;
}
Java



// A Dynamic programming based
// java program to count derangements
import java.io.*;
 
class GFG
{
     
    // Function to count
    // derangements
    static int countDer(int n)
    {
        // Create an array to store
        // counts for subproblems
        int der[] = new int[n + 1];
     
        // Base cases
        der[1] = 0;
        der[2] = 1;
     
        // Fill der[0..n] in bottom up
        // manner using above recursive
        // formula
        for (int i = 3; i <= n; ++i)
            der[i] = (i - 1) * (der[i - 1] +
                                der[i - 2]);
     
        // Return result for n
        return der[n];
    }
     
    // Driver program
    public static void main (String[] args)
    {
        int n = 4;
        System.out.println("Count of Derangements is " +
                            countDer(n));
     
    }
}
 
// This code is contributed by vt_m
Python3



# A Dynamic programming based Python3
# program to count derangements
 
def countDer(n):
     
    # Create an array to store
    # counts for subproblems
    der = [0 for i in range(n + 1)]
     
    # Base cases
    der[1] = 0
    der[2] = 1
     
    # Fill der[0..n] in bottom up manner
    # using above recursive formula
    for i in range(3, n + 1):
        der[i] = (i - 1) * (der[i - 1] +
                            der[i - 2])
         
    # Return result for n
    return der[n]
 
# Driver Code
n = 4
print("Count of Derangements is ", countDer(n))
 
# This code is contributed by Azkia Anam.
C#



// A Dynamic programming based
// C# program to count derangements
using System;
 
class GFG
{
     
    // Function to count
    // derangements
    static int countDer(int n)
    {
        // Create an array to store
        // counts for subproblems
        int []der = new int[n + 1];
     
        // Base cases
        der[1] = 0;
        der[2] = 1;
     
        // Fill der[0..n] in bottom up
        // manner using above recursive
        // formula
        for (int i = 3; i <= n; ++i)
            der[i] = (i - 1) * (der[i - 1] +
                                der[i - 2]);
     
        // Return result for n
        return der[n];
    }
     
    // Driver code
    public static void Main ()
    {
        int n = 4;
        Console.Write("Count of Derangements is " +
                       countDer(n));
     
    }
}
 
// This code is contributed by nitin mittal
PHP



<?php
// A Dynamic programming based PHP
// program to count derangements
 
function countDer($n)
{
    // Create an array to store
    // counts for subproblems
 
    // Base cases
    $der[1] = 0;
    $der[2] = 1;
 
    // Fill der[0..n] in bottom up manner
    // using above recursive formula
    for ($i = 3; $i <= $n; ++$i)
        $der[$i] = ($i - 1) * ($der[$i - 1] +
                               $der[$i - 2]);
 
    // Return result for n
    return $der[$n];
}
 
// Driver code
$n = 4;
echo "Count of Derangements is ",
                    countDer($n);
 
// This code is contributed by aj_36
?>
Javascript



<script>
 
    // A Dynamic programming based
    // javascript program to count
    // derangements
     
    // Function to count
    // derangements
    function countDer(n)
    {
        // Create an array to store
        // counts for subproblems
        let der = new Array(n + 1);
      
        // Base cases
        der[1] = 0;
        der[2] = 1;
      
        // Fill der[0..n] in bottom up
        // manner using above recursive
        // formula
        for (let i = 3; i <= n; ++i)
            der[i] = (i - 1) * (der[i - 1] +
                                der[i - 2]);
      
        // Return result for n
        return der[n];
    }
     
    let n = 4;
    document.write(
    "Count of Derangements is " + countDer(n)
    );
     
</script>
Output
Count of Derangements is 9
Time Complexity : O(n) 
Auxiliary Space : O(n)
Thanks to Utkarsh Trivedi for suggesting the above solution.
A More Efficient Solution Without using Extra Space.
As we only need to remember only two previous values So, instead of Storing the values in an array two variables can be used to just store the required previous only.
Below is the implementation of the above approach:
C++



// C++ implementation of the above
// approach
 
#include <iostream>
using namespace std;
 
int countDer(int n)
{
 
    // base case
    if (n == 1 or n == 2) {
        return n - 1;
    }
 
    // Variable for just storing
    // previous values
    int a = 0;
    int b = 1;
 
    // using above recursive formula
    for (int i = 3; i <= n; ++i) {
        int cur = (i - 1) * (a + b);
        a = b;
        b = cur;
    }
 
    // Return result for n
    return b;
}
 
// Driver Code
int main()
{
 
    cout << "Count of Dearrangements is " << countDer(4);
    return 0;
}
 
 // Code contributed by skagnihotri
Java



// Java implementation of the
// above approach
 
import java.io.*;
 
class GFG {
   
    // Function to count derangements 
    static int countDer(int n) {
        // Base case
          if(n == 1 || n == 2) {
            return n-1;
        }
       
        // Variable for storing prev values
        int a = 0;
          int b = 1;
       
        // manner using above recursive formula
        for (int i = 3; i <= n; ++i) {
            int cur = (i-1)*(a+b);
            a = b;
              b = cur;
        }
             
        // Return result for n
        return b;
    }
       
    // Driver Code
    public static void main (String[] args) 
    {
        int n = 4;
        System.out.println("Count of Dearrangements is " + 
                            countDer(n));
       
    }
   
  // Code contributed by skagnihotri
}
Python3



# Python program to count derangements
   
def countDer(n):
       
    # Base Case
    if n == 1 or n == 2:
      return n-1;
         
    # Variables for storing previous values
    a = 0
    b = 1
     
    # using above recursive formula
    for i in range(3, n + 1):
        cur = (i-1)*(a+b)
        a = b
        b = cur
         
    # Return result for n
    return b
   
# Driver Code
n = 4
print("Count of Dearrangements is ", countDer(n))
# Code contributed by skagnihotri
C#



// C# implementation of the above
// approach
using System;
 
class GFG{
     
// Function to count
// derangements
static int countDer(int n)
{
     
    // Base case
    if (n == 1 || n == 2)
    {
        return n - 1;
    }
 
    // Variable for just storing
    // previous values
    int a = 0;
    int b = 1;
 
    // Using above recursive formula
    for(int i = 3; i <= n; ++i)
    {
        int cur = (i - 1) * (a + b);
        a = b;
        b = cur;
    }
 
    // Return result for n
    return b;
}
 
// Driver code
public static void Main()
{
    Console.Write("Count of Dearrangements is " +
                   countDer(4));
}
}
 
// This code is contributed by koulick_sadhu
Javascript



<script>
 
    // Javascript implementation
    // of the above approach
     
    // Function to count
    // derangements
    function countDer(n)
    {
 
        // Base case
        if (n == 1 || n == 2)
        {
            return n - 1;
        }
 
        // Variable for just storing
        // previous values
        let a = 0;
        let b = 1;
 
        // Using above recursive formula
        for(let i = 3; i <= n; ++i)
        {
            let cur = (i - 1) * (a + b);
            a = b;
            b = cur;
        }
 
        // Return result for n
        return b;
    }
     
    document.write("Count of Derangements is "
    + countDer(4));
 
</script>
Output
Count of Derangements is 9
Time Complexity: O(n) 
Auxiliary Space: O(1)
Thanks to Shubham Kumar for suggesting the above solution.
References: 
https://en.wikipedia.org/wiki/Derangement
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes
arrow_drop_up
Previous
Count ways to distribute m items among n people
Next

Amazon(Barcelona) Interview Experience for SDE | Off-Campus Internship
Recommended Articles
Page :
Rencontres Number (Counting partial derangements)
08, Mar 18
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Count N-digit numbers such that every position is divisible by the digit at that position
20, Jul 21
Lexicographically smallest permutation with no digits at Original Index
15, Nov 18
Permutation of a number whose sum with the original number is equal to another given number
18, Feb 21
Lexicographically smallest permutation of {1, .. n} such that no. and position do not match
14, Sep 17
Count of right shifts for each array element to be in its sorted position
25, Jul 20
Find the element that appears once
03, Oct 12
Minimum time to return array to its original state after given modifications
14, Nov 18
Count occurrences of an element in a matrix of size N * N generated such that each element is equal to product of its indices
25, Feb 21
Count occurrences of an element in a matrix of size N * N generated such that each element is equal to product of its indices | Set-2
02, Mar 21
Rearrange an Array such that Sum of same-indexed subsets differ from their Sum in the original Array
31, Jul 20
Check if permutation of one string can break permutation of another
28, Jul 20
Maximum element in an array such that its previous and next element product is maximum
02, Jul 19
Generate longest possible array with product K such that each array element is divisible by its previous adjacent element
12, Mar 21
Find the original matrix when largest element in a row and a column are given
18, Apr 19
Find the original Array from given array where ith element is the average of first i elements
23, Oct 21
Kth smallest positive integer Y such that its sum with X is same as its bitwise OR with X
25, Aug 21
Find N numbers such that a number and its reverse are divisible by sum of its digits
06, May 20
Count of Distinct strings possible by inserting K characters in the original string
28, Jul 20
Count of ordered triplets (R, G, B) in a given original string
31, May 20
Count of iterations to make minimum as 0 by rotating Array followed by reducing it from original Array
12, Jan 22
Count permutation such that sequence is non decreasing
29, Aug 19
Count of Array elements greater than all elements on its left and next K elements on its right
05, Aug 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!