# Sum of all numbers that can be formed with permutations of n digits

• Difficulty Level : Medium
• Last Updated : 25 Oct, 2022

Given n distinct digits (from 0 to 9), find sum of all n digit numbers that can be formed using these digits. It is assumed that numbers formed with leading 0 are allowed.

Example:

```Input: 1 2 3
Output: 1332
Explanation
Numbers Formed: 123 , 132 , 312 , 213, 231 , 321
123 + 132 + 312 + 213 + 231 + 321 = 1332```
Recommended Practice

Total numbers that can be formed using n digits is total number of permutations of n digits, i.e factorial(n). Now, since the number formed is a n-digit number, each digit will appear factorial(n)/n times at each position from least significant digit to most significant digit. Therefore, sum of digits at a position = (sum of all the digits) * (factorial(n)/n).

```Considering the example digits as 1 2 3

factorial(3)/3 = 2

Sum of digits at least significant digit = (1 + 2 + 3) * 2 = 12

Similarly sum of digits at tens, hundreds place is 12.
(This sum will contribute as 12 * 100)

Similarly sum of digits at tens, thousands place is 12.
(This sum will contribute as 12 * 1000)

Required sum of all numbers = 12 + (10 * 12) + (100 * 12) = 1332```

Implementation:

## C++

 `// C++ program to find sum of numbers formed``// by all permutations of given set of digits``#include` `// function to calculate factorial of a number``int` `factorial(``int` `n)``{``    ``int` `f = 1;``    ``if` `(n==0||n==1)``        ``return` `1;``    ``for` `(``int` `i=2; i<=n; i++)``        ``f = f*i;``    ``return` `f;``}` `// Function to calculate sum of all numbers``int` `getSum(``int` `arr[],``int` `n)``{``    ``// calculate factorial``    ``int` `fact = factorial(n);` `    ``// sum of all the given digits at different``    ``// positions is same and is going to be stored``    ``// in digitsum.``    ``int` `digitsum = 0;``    ``for` `(``int` `i=0; i

## Java

 `// Java program to find sum``// of numbers formed by all``// permutations of given set``// of digits``import` `java.io.*;` `class` `GFG``{``    ` `// function to calculate``// factorial of a number``static` `int` `factorial(``int` `n)``{``    ``int` `f = ``1``;``    ``if` `(n == ``0``|| n == ``1``)``        ``return` `1``;``    ``for` `(``int` `i = ``2``; i <= n; i++)``        ``f = f * i;``    ``return` `f;``}` `// Function to calculate``// sum of all numbers``static` `int` `getSum(``int` `arr[], ``int` `n)``{``    ``// calculate factorial``    ``int` `fact = factorial(n);` `    ``// sum of all the given``    ``// digits at different``    ``// positions is same and``    ``// is going to be stored``    ``// in digitsum.``    ``int` `digitsum = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``digitsum += arr[i];``    ``digitsum *= (fact / n);` `    ``// Compute result (sum``    ``// of all the numbers)``    ``int` `res = ``0``;``    ``for` `(``int` `i = ``1``, k = ``1``;``             ``i <= n; i++)``    ``{``        ``res += (k * digitsum);``        ``k = k * ``10``;``    ``}` `    ``return` `res;``}` `// Driver Code``public` `static` `void` `main (String[] args)``{` `    ``// n distinct digits``    ``int` `arr[] = {``1``, ``2``, ``3``};``    ``int` `n = arr.length;``    ` `    ``// Print sum of all``    ``// the numbers formed``    ``System.out.println(getSum(arr, n));``}``}` `// This code is contributed``// by ajit`

## Python3

 `# Python3 program to find sum of``# numbers formed by all permutations``# of given set of digits` `# function to calculate factorial``# of a number``def` `factorial(n):` `    ``f ``=` `1``    ``if` `(n ``=``=` `0` `or` `n ``=``=` `1``):``        ``return` `1``    ``for` `i ``in` `range``(``2``, n ``+` `1``):``        ``f ``=` `f ``*` `i``    ``return` `f` `# Function to calculate sum``# of all numbers``def` `getSum(arr, n):` `    ``# calculate factorial``    ``fact ``=` `factorial(n)` `    ``# sum of all the given digits at``    ``# different positions is same and``    ``# is going to be stored in digitsum.``    ``digitsum ``=` `0``    ``for` `i ``in` `range``(n):``        ``digitsum ``+``=` `arr[i]``    ``digitsum ``*``=` `(fact ``/``/` `n)` `    ``# Compute result (sum of``    ``# all the numbers)``    ``res ``=` `0``    ``i ``=` `1``    ``k ``=` `1``    ``while` `i <``=` `n :``        ``res ``+``=` `(k ``*` `digitsum)``        ``k ``=` `k ``*` `10``        ``i ``+``=` `1` `    ``return` `res` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``# n distinct digits``    ``arr ``=` `[``1``, ``2``, ``3``]``    ``n ``=` `len``(arr)` `    ``# Print sum of all the numbers formed``    ``print``(getSum(arr, n))` `# This code is contributed by ita_c`

## C#

 `// C# program to find sum``// of numbers formed by all``// permutations of given set``// of digits``using` `System;` `class` `GFG``{``    ` `// function to calculate``// factorial of a number``static` `int` `factorial(``int` `n)``{``    ``int` `f = 1;``    ``if` `(n == 0|| n == 1)``        ``return` `1;``    ``for` `(``int` `i = 2; i <= n; i++)``        ``f = f * i;``    ``return` `f;``}` `// Function to calculate``// sum of all numbers``static` `int` `getSum(``int` `[]arr,``                  ``int` `n)``{``    ``// calculate factorial``    ``int` `fact = factorial(n);` `    ``// sum of all the given``    ``// digits at different``    ``// positions is same and``    ``// is going to be stored``    ``// in digitsum.``    ``int` `digitsum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``digitsum += arr[i];``    ``digitsum *= (fact / n);` `    ``// Compute result (sum``    ``// of all the numbers)``    ``int` `res = 0;``    ``for` `(``int` `i = 1, k = 1;``            ``i <= n; i++)``    ``{``        ``res += (k * digitsum);``        ``k = k * 10;``    ``}` `    ``return` `res;``}` `// Driver Code``static` `public` `void` `Main ()``{` `    ``// n distinct digits``    ``int` `[]arr = {1, 2, 3};``    ``int` `n = arr.Length;``    ` `    ``// Print sum of all``    ``// the numbers formed``    ``Console.WriteLine(getSum(arr, n));``}``}` `// This code is contributed``// by akt_mit`

## PHP

 ``

## Javascript

 ``

Output

`1332`

Time Complexity: O(n)
Auxiliary Space: O(1)

This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up