 Open in App
Not now

# Count ways to rearrange digits of a number such that it is divisible by 2

• Last Updated : 21 Mar, 2023

Given a positive integer N, count the number of possible distinct rearrangements of the digits of N (in decimal representation), such that the resultant number is divisible by 2.

Note: There is no 0 in the number.

Examples:

Input: N = 957
Output: 0
Explanation: There is no even digit in the number. So no even number can be made.

Input: N = 54321
Output: 48

Approach: The problem can be solved based on the below mathematical idea:

A number is only divisible by 2 when the digit at the rightmost side is divisible by 2. So count the number of even digits in N. Say there are total X digits and M even digits in total. So total number of possible even numbers are (X-1)! * M [because we can put each of the even digit at the end and arrange all other digits in any way].

But there can be several same arrangements. So to avoid this in the calculation we have to divide the value by the factorial of frequency of each digit.

Follow the below steps to solve the problem:

• If N = 0 then return 1.
• Find the count of 2, 4, 6, 8 in N and store it in EvenCount(say).
• Find the count of digits in N and store it in DigitCount(say).
• Store frequency of digits in N in Cnt[] array.
• If EvenCount = 0 then return 0
• Else, store (DigitCount – 1)! * EvenCount in res.
• Now traverse from 0 to 9, and set res = res/fact(Cnt[i]).
• fact(Cnt[i]) is factorial of Cnt[i].
• Return res as the required answer.

Below is the implementation of the above approach

## C++

 `// C++ code to implement the above approach`   `#include ` `using` `namespace` `std;`   `// Function to calculate factorial of N` `int` `factorial(``int` `N)` `{` `    ``return` `(N == 1 || N == 0) ? 1 : N * factorial(N - 1);` `}`   `// Function to count permutations` `long` `checkPerm(``int` `N)` `{` `    ``// Edge Case` `    ``if` `(N == 0)` `        ``return` `1;`   `    ``// Initialize the variables` `    ``int` `EvenCount = 0;` `    ``int` `DigitCount = 0;`   `    ``vector<``int``> Cnt(10, 0);`   `    ``// Calculate count of digit and Number of` `    ``// 2, 4, 6, 8 in N` `    ``while` `(N) {` `        ``int` `X = N % 10;` `        ``Cnt[X]++;` `        ``if` `((X % 2) == 0)` `            ``EvenCount++;` `        ``DigitCount++;` `        ``N /= 10;` `    ``}`   `    ``// Return count of total possible` `    ``// rearrangement` `    ``int` `res = EvenCount` `                  ``? factorial((DigitCount - 1)) * EvenCount` `                  ``: 0;`   `    ``if` `(res == 0)` `        ``return` `0;`   `    ``for` `(``int` `i = 0; i < 10; i++) {` `        ``res /= factorial(Cnt[i]);` `    ``}`   `    ``return` `res;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 54321;` `    ``cout << checkPerm(N);` `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach` `import` `java.io.*;`   `class` `GFG ` `{`   `  ``// Function to calculate factorial of N` `  ``public` `static` `int` `factorial(``int` `N)` `  ``{` `    ``return` `(N == ``1` `|| N == ``0``) ? ``1` `      ``: N * factorial(N - ``1``);` `  ``}`   `  ``// Function to count permutations` `  ``public` `static` `long` `checkPerm(``int` `N)` `  ``{` `    ``// Edge Case` `    ``if` `(N == ``0``)` `      ``return` `1``;`   `    ``// Initialize the variables` `    ``int` `EvenCount = ``0``;` `    ``int` `DigitCount = ``0``;`   `    ``int` `Cnt[] = ``new` `int``[``10``];`   `    ``// Calculate count of digit and Number of` `    ``// 2, 4, 6, 8 in N` `    ``while` `(N > ``0``) {` `      ``int` `X = N % ``10``;` `      ``Cnt[X]++;` `      ``if` `((X % ``2``) == ``0``)` `        ``EvenCount++;` `      ``DigitCount++;` `      ``N /= ``10``;` `    ``}`   `    ``// Return count of total possible` `    ``// rearrangement` `    ``int` `res = EvenCount!=``0` `? factorial((DigitCount - ``1``))` `      ``* EvenCount` `      ``: ``0``;`   `    ``if` `(res == ``0``)` `      ``return` `0``;`   `    ``for` `(``int` `i = ``0``; i < ``10``; i++) {` `      ``res /= factorial(Cnt[i]);` `    ``}`   `    ``return` `res;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``54321``;` `    ``System.out.print(checkPerm(N));` `  ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python code to implement the above approach` `import` `math`   `# Function to calculate factorial of N` `def` `factorial(N):` `    ``if``(N ``=``=` `1` `or` `N ``=``=` `0``):` `        ``return` `1` `    ``return` `N ``*` `factorial(N ``-` `1``)` `  `  `# Function to count permutations` `def` `checkPerm(N):` `  `  `    ``# Edge Case` `    ``if` `(N ``=``=` `0``):` `        ``return` `1` `      `  `    ``# Initialize the variables` `    ``EvenCount ``=` `0` `    ``DigitCount ``=` `0` `    `  `    ``Cnt ``=` `[``0``]``*``10` `    `  `    ``# Calculate count of digit and Number of` `    ``# 2, 4, 6, 8 in N` `    ``while``(N):` `        ``X ``=` `N ``%` `10` `        ``Cnt[X] ``+``=` `1` `        ``if``((X ``%` `2``) ``=``=` `0``):` `            ``EvenCount ``+``=` `1` `        ``DigitCount ``+``=` `1` `        ``N ``=` `math.floor(N``/``10``)`   `    ``# Return count of total possible` `    ``# rearrangement` `    ``res ``=` `0` `    ``if``(EvenCount):` `        ``res ``=` `factorial((DigitCount ``-` `1``)) ``*` `EvenCount` `        `  `    ``if` `(res ``=``=` `0``):` `        ``return` `0` `    ``for` `i ``in` `range``(``0``, ``10``):` `        ``res ``=` `math.floor(res``/``factorial(Cnt[i]))` `        `  `    ``return` `res`   `# Driver Code` `N ``=` `54321` `print` `(checkPerm(N))`   `# This code is contributed by ksam24000`

## C#

 `// C# implementation` `using` `System;` `public` `class` `GFG ` `{`   `  ``// Function to calculate factorial of N` `  ``static` `public` `int` `factorial(``int` `N)` `  ``{` `    ``return` `(N == 1 || N == 0) ? 1` `      ``: N * factorial(N - 1);` `  ``}`   `  ``// Function to count permutations` `  ``static` `public` `long` `checkPerm(``int` `N)` `  ``{` `    ``// Edge Case` `    ``if` `(N == 0)` `      ``return` `1;`   `    ``// Initialize the variables` `    ``int` `EvenCount = 0;` `    ``int` `DigitCount = 0;`   `    ``//  vector Cnt(10, 0);` `    ``int``[] Cnt = ``new` `int``;` `    ``Array.Fill<``int``>(Cnt, 0);` `    ``// Calculate count of digit and Number of` `    ``// 2, 4, 6, 8 in N` `    ``while` `(N > 0) {` `      ``int` `X = N % 10;` `      ``Cnt[X]++;` `      ``if` `((X % 2) == 0)` `        ``EvenCount++;` `      ``DigitCount++;` `      ``N = (N / 10);` `    ``}`   `    ``// Return count of total possible` `    ``// rearrangement` `    ``int` `res` `      ``= EvenCount > 0` `      ``? factorial((DigitCount - 1)) * EvenCount` `      ``: 0;`   `    ``if` `(res == 0)` `      ``return` `0;`   `    ``for` `(``int` `i = 0; i < 10; i++) {` `      ``res = (res / factorial(Cnt[i]));` `    ``}` `    ``return` `res;` `  ``}` `  ``static` `public` `void` `Main()` `  ``{` `    ``int` `N = 54321;` `    ``Console.WriteLine(checkPerm(N));` `    ``// Code` `  ``}` `}`   `// This code is contributed by ksam24000`

## Javascript

 `// JavaScript code to implement the above approach`   `// Function to calculate factorial of N` `const factorial = (N) => {` `    ``return` `(N == 1 || N == 0) ? 1 : N * factorial(N - 1);` `}`   `// Function to count permutations` `const checkPerm = (N) => {` `    ``// Edge Case` `    ``if` `(N == 0)` `        ``return` `1;`   `    ``// Initialize the variables` `    ``let EvenCount = 0;` `    ``let DigitCount = 0;`   `    ``let Cnt = ``new` `Array(10).fill(0);`   `    ``// Calculate count of digit and Number of` `    ``// 2, 4, 6, 8 in N` `    ``while` `(N) {` `        ``let X = N % 10;` `        ``Cnt[X]++;` `        ``if` `((X % 2) == 0)` `            ``EvenCount++;` `        ``DigitCount++;` `        ``N = parseInt(N / 10);` `    ``}`   `    ``// Return count of total possible` `    ``// rearrangement` `    ``let res = EvenCount` `        ``? factorial((DigitCount - 1)) * EvenCount` `        ``: 0;`   `    ``if` `(res == 0)` `        ``return` `0;`   `    ``for` `(let i = 0; i < 10; i++) {` `        ``res = parseInt(res / factorial(Cnt[i]));` `    ``}`   `    ``return` `res;` `}`   `// Driver Code`   `let N = 54321;` `console.log(checkPerm(N));`   `// This code is contributed by rakeshsahni`

Output

`48`

Time Complexity: O(N!),because the factorial function calculates the factorial of a given number using recursion, which has a time complexity of O(N!). The checkPerm function also has a time complexity of O(N!), since it calls the factorial function multiple times.
Auxiliary Space: O(1)

Optimize approach :

To optimize this above approach, you can make the following changes:

• Use a loop to calculate the factorial of N rather than a recursive function. This will reduce the time complexity of the factorial function from O(N!) to O(N).
• Use a single integer variable to count the number of even digits and the number of digits in N rather than two separate variables. This will reduce the space complexity of the checkPerm function from O(2) to O(1).
• Use a single array to count the number of occurrences of each digit in N rather than an array for each digit. This will reduce the space complexity of the checkPerm function from O(10) to O(1).

Here is the optimized version of the code :

## C++

 `#include` `using` `namespace` `std;`   `// Function to count permutations` `long` `checkPerm(``int` `N) {` `    ``// Edge Case` `    ``if` `(N == 0) ``return` `1;`   `    ``// Initialize the variables` `    ``int` `evenCount = 0;` `    ``int` `digitCount = 0;`   `    ``int` `count = {0};`   `    ``// Calculate count of digit and Number of` `    ``// 2, 4, 6, 8 in N` `    ``while` `(N > 0) {` `        ``int` `X = N % 10;` `        ``count[X]++;` `        ``if` `((X % 2) == 0) evenCount++;` `        ``digitCount++;` `        ``N /= 10;` `    ``}`   `    ``// Calculate factorial of digitCount - 1` `    ``int` `factorial = 1;` `    ``for` `(``int` `i = 2; i < digitCount; i++) {` `        ``factorial *= i;` `    ``}`   `    ``// Return count of total possible` `    ``// rearrangement` `    ``int` `res = evenCount != 0 ? factorial * evenCount : 0;`   `    ``if` `(res == 0) ``return` `0;`   `    ``for` `(``int` `i = 0; i < 10; i++) {` `        ``int` `factorial2 = 1;` `        ``for` `(``int` `j = 2; j <= count[i]; j++) {` `            ``factorial2 *= j;` `        ``}` `        ``res /= factorial2;` `    ``}`   `    ``return` `res;` `}`   `// Driver Code` `int` `main() {` `    ``int` `N = 54321;` `    ``cout << checkPerm(N);` `    ``return` `0;` `}` `// this code is contributed by devendrsalunke `

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;`   `import` `java.io.*;`   `class` `GFG {`   `  ``// Function to count permutations` `  ``public` `static` `long` `checkPerm(``int` `N) {` `    ``// Edge Case` `    ``if` `(N == ``0``) ``return` `1``;`   `    ``// Initialize the variables` `    ``int` `evenCount = ``0``;` `    ``int` `digitCount = ``0``;`   `    ``int``[] count = ``new` `int``[``10``];`   `    ``// Calculate count of digit and Number of` `    ``// 2, 4, 6, 8 in N` `    ``while` `(N > ``0``) {` `      ``int` `X = N % ``10``;` `      ``count[X]++;` `      ``if` `((X % ``2``) == ``0``) evenCount++;` `      ``digitCount++;` `      ``N /= ``10``;` `    ``}`   `    ``// Calculate factorial of digitCount - 1` `    ``int` `factorial = ``1``;` `    ``for` `(``int` `i = ``2``; i < digitCount; i++) {` `      ``factorial *= i;` `    ``}`   `    ``// Return count of total possible` `    ``// rearrangement` `    ``int` `res = evenCount != ``0` `? factorial * evenCount : ``0``;`   `    ``if` `(res == ``0``) ``return` `0``;`   `    ``for` `(``int` `i = ``0``; i < ``10``; i++) {` `      ``int` `factorial2 = ``1``;` `      ``for` `(``int` `j = ``2``; j <= count[i]; j++) {` `        ``factorial2 *= j;` `      ``}` `      ``res /= factorial2;` `    ``}`   `    ``return` `res;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args) {` `    ``int` `N = ``54321``;` `    ``System.out.print(checkPerm(N));` `  ``}` `}`

## Python3

 `# Function to count permutations` `def` `checkPerm(N):` `    ``# Edge Case` `    ``if` `N ``=``=` `0``:` `        ``return` `1`   `    ``# Initialize the variables` `    ``evenCount ``=` `0` `    ``digitCount ``=` `0`   `    ``count ``=` `[``0``] ``*` `10`   `    ``# Calculate count of digit and Number of` `    ``# 2, 4, 6, 8 in N` `    ``while` `N > ``0``:` `        ``X ``=` `N ``%` `10` `        ``count[X] ``+``=` `1` `        ``if` `X ``%` `2` `=``=` `0``:` `            ``evenCount ``+``=` `1` `        ``digitCount ``+``=` `1` `        ``N ``/``/``=` `10`   `    ``# Calculate factorial of digitCount - 1` `    ``factorial ``=` `1` `    ``for` `i ``in` `range``(``2``, digitCount):` `        ``factorial ``*``=` `i`   `    ``# Return count of total possible` `    ``# rearrangement` `    ``res ``=` `factorial ``*` `evenCount ``if` `evenCount !``=` `0` `else` `0`   `    ``if` `res ``=``=` `0``:` `        ``return` `0`   `    ``for` `i ``in` `range``(``10``):` `        ``factorial2 ``=` `1` `        ``for` `j ``in` `range``(``2``, count[i] ``+` `1``):` `            ``factorial2 ``*``=` `j` `        ``res ``/``/``=` `factorial2`   `    ``return` `res`   `# Driver Code` `N ``=` `54321` `print``(checkPerm(N))` `# This code is contributed by prasad264`

## C#

 `using` `System;`   `class` `GFG {`   `  ``// Function to count permutations` `  ``public` `static` `long` `CheckPerm(``int` `N) {` `    ``// Edge Case` `    ``if` `(N == 0) ``return` `1;`   `    ``// Initialize the variables` `    ``int` `evenCount = 0;` `    ``int` `digitCount = 0;`   `    ``int``[] count = ``new` `int``;`   `    ``// Calculate count of digit and Number of` `    ``// 2, 4, 6, 8 in N` `    ``while` `(N > 0) {` `      ``int` `X = N % 10;` `      ``count[X]++;` `      ``if` `((X % 2) == 0) evenCount++;` `      ``digitCount++;` `      ``N /= 10;` `    ``}`   `    ``// Calculate factorial of digitCount - 1` `    ``int` `factorial = 1;` `    ``for` `(``int` `i = 2; i < digitCount; i++) {` `      ``factorial *= i;` `    ``}`   `    ``// Return count of total possible` `    ``// rearrangement` `    ``int` `res = evenCount != 0 ? factorial * evenCount : 0;`   `    ``if` `(res == 0) ``return` `0;`   `    ``for` `(``int` `i = 0; i < 10; i++) {` `      ``int` `factorial2 = 1;` `      ``for` `(``int` `j = 2; j <= count[i]; j++) {` `        ``factorial2 *= j;` `      ``}` `      ``res /= factorial2;` `    ``}`   `    ``return` `res;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args) {` `    ``int` `N = 54321;` `    ``Console.Write(CheckPerm(N));` `  ``}` `}`

## Javascript

 `// Function to count permutations` `function` `checkPerm(N) {` `// Edge Case` `if` `(N == 0) ``return` `1;`   `// Initialize the variables` `let evenCount = 0;` `let digitCount = 0;`   `let count = ``new` `Array(10).fill(0);`   `// Calculate count of digit and Number of` `// 2, 4, 6, 8 in N` `while` `(N > 0) {` `let X = N % 10;` `count[X]++;` `if` `((X % 2) == 0) evenCount++;` `digitCount++;` `N = Math.floor(N / 10);` `}`   `// Calculate factorial of digitCount - 1` `let factorial = 1;` `for` `(let i = 2; i < digitCount; i++) {` `factorial *= i;` `}`   `// Return count of total possible` `// rearrangement` `let res = evenCount != 0 ? factorial * evenCount : 0;`   `if` `(res == 0) ``return` `0;`   `for` `(let i = 0; i < 10; i++) {` `let factorial2 = 1;` `for` `(let j = 2; j <= count[i]; j++) {` `factorial2 *= j;` `}` `res /= factorial2;` `}`   `return` `res;` `}`   `// Driver Code` `let N = 54321;` `console.log(checkPerm(N));`

Output

`48`

Time complexity : O(N), where N is the number of digits in the input number. This is because the factorial function, which calculates the factorial of a given number using a loop, has a time complexity of O(N). The checkPerm function also has a time complexity of O(N), since it iterates through all the digits of the input number to count the number of even digits and the number of occurrences of each digit.

Auxiliary Space :  O(1), since it uses a fixed number of variables regardless of the size of the input.

My Personal Notes arrow_drop_up
Related Articles