# Check whether factorial of N is divisible by sum of first N natural numbers

• Difficulty Level : Hard
• Last Updated : 31 Mar, 2021

Given a number ‘N’. Check whether factorial of ‘N’ is divisible by the sum of first ‘N’ natural numbers or not? If divisibility is possible, then print YES else print NO.
Examples:

```Input: N = 3
Output: YES
As (1*2*3)%(1+2+3) = 0,
Hence divisibility is possible.

Input: N = 4
Output: NO
Here (1*2*3*4)%(1+2+3+4) != 0,
Hence  divisibility doesn't occur.```

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.

Approach:

1. Sum of first ‘n’ natural numbers: s = (n)*(n+1)/2 . This can be expressed as (n+1)!/2*(n-1)!
2. Now n!/s = 2*(n-1)!/(n+1).
3. From the above formula the observation is derived as:
• If ‘n+1’ is prime then ‘n!’ is not divisible by sum of first ‘n’ natural numbers.
• If ‘n+1’ is not prime then ‘n!’ is divisible by sum of first ‘n’ natural numbers.

For Example:

• Let n = 4.
• Hence ‘n!/s’ = 2*(3!)/5. = 1*2*3*2/5 .
• Here for n! to be divisible by ‘s’ we need the presence at least a multiple of ‘5’ in the numerator, i.e. in the given example numerator is expressed as the product of 3! and 2, For the entire product to be divisible by ‘5’
at least one multiple of 5 should be there i.e. 5*1 or 5*2 or 5*3 and so on. Since in the factorial term the highest number present is ‘n-1’ the product i.e. the numerator can never be expressed with terms of ‘n+1’ if ‘n+1’ is prime. Hence divisibility is never possible.
• In any other case whether ‘n+1’ is even or odd but not ‘prime’ the divisibility is always possible.

Note: Special care is to be taken for the case n=1. As 1! is always divisible by 1.
Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to check whether``// a number is prime or not.``bool` `is_prime(``int` `num)``{` `    ``// Count variable to store``    ``// the number of factors of 'num'``    ``int` `count = 0;` `    ``// Counting the number of factors``    ``for` `(``int` `i = 1; i * i <= (num); i++) {` `        ``if` `((num) % i == 0) {` `            ``if` `(i * i != (num))``                ``count += 2;` `            ``else``                ``count++;``        ``}``    ``}` `    ``// If number is prime return true``    ``if` `(count == 2)``        ``return` `true``;` `    ``else``        ``return` `false``;``}` `// Function to check for divisibility``string is_divisible(``int` `n)``{` `    ``// if 'n' equals 1 then divisibility is possible``    ``if` `(n == 1) {``        ``return` `"YES"``;``    ``}` `    ``// Else check whether 'n+1' is prime or not``    ``else` `{` `        ``// If 'n+1' is prime then 'n!' is``        ``// not divisible by 'n*(n+1)/2'``        ``if` `(is_prime(n + 1))``            ``return` `"NO"``;` `        ``// else divisibility occurs``        ``else``            ``return` `"YES"``;``    ``}``}` `// Driver Code``int` `main()``{` `    ``int` `n;` `    ``// Test for n=3``    ``n = 3;` `    ``cout << is_divisible(n) << endl;` `    ``// Test for n=4``    ``n = 4;` `    ``cout << is_divisible(n) << endl;` `    ``return` `0;``}`

## Java

 `class` `GfG``{` `// Function to check whether``// a number is prime or not.``static` `boolean` `is_prime(``int` `num)``{` `    ``// Count variable to store``    ``// the number of factors of 'num'``    ``int` `count = ``0``;` `    ``// Counting the number of factors``    ``for` `(``int` `i = ``1``; i * i <= (num); i++)``    ``{` `        ``if` `((num) % i == ``0``)``        ``{` `            ``if` `(i * i != (num))``                ``count += ``2``;` `            ``else``                ``count++;``        ``}``    ``}` `    ``// If number is prime return true``    ``if` `(count == ``2``)``        ``return` `true``;` `    ``else``        ``return` `false``;``}` `// Function to check for divisibility``static` `String is_divisible(``int` `n)``{` `    ``// if 'n' equals 1 then divisibility is possible``    ``if` `(n == ``1``)``    ``{``        ``return` `"YES"``;``    ``}` `    ``// Else check whether 'n+1' is prime or not``    ``else``    ``{` `        ``// If 'n+1' is prime then 'n!' is``        ``// not divisible by 'n*(n+1)/2'``        ``if` `(is_prime(n + ``1``))``            ``return` `"NO"``;` `        ``// else divisibility occurs``        ``else``            ``return` `"YES"``;``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{` `    ``int` `n;` `    ``// Test for n=3``    ``n = ``3``;` `    ``System.out.println(is_divisible(n));` `    ``// Test for n=4``    ``n = ``4``;` `    ``System.out.println(is_divisible(n));``}``}` `// This code is contributed by Prerna Saini`

## Python3

 `# Function to check whether``# a number is prime or not.``def` `is_prime(num):` `    ``# Count variable to store``    ``# the number of factors of 'num'``    ``count ``=` `0` `    ``# Counting the number of factors``    ``for` `i ``in` `range``(``1``, num ``+` `1``):` `        ``if` `i ``*` `i > num:``            ``break` `        ``if` `((num) ``%` `i ``=``=` `0``):` `            ``if` `(i ``*` `i !``=` `(num)):``                ``count ``+``=` `2``            ``else``:``                ``count ``+``=` `1``        ` `    ``# If number is prime return true``    ``if` `(count ``=``=` `2``):``        ``return` `True``    ``else``:``        ``return` `False` `# Function to check for divisibility``def` `is_divisible(n):` `    ``# if 'n' equals 1 then``    ``# divisibility is possible``    ``if` `(n ``=``=` `1``):``        ``return` `"YES"` `    ``# Else check whether 'n+1' is prime or not``    ``else``:` `        ``# If 'n+1' is prime then 'n!' is``        ``# not divisible by 'n*(n+1)/2'``        ``if` `(is_prime(n ``+` `1``)):``            ``return` `"NO"``            ` `        ``# else divisibility occurs``        ``else``:``            ``return` `"YES"``    ` `# Driver Code` `# Test for n=3``n ``=` `3` `print``(is_divisible(n))` `# Test for n=4``n ``=` `4` `print``(is_divisible(n))` `# This code is contributed``# by mohit kumar`

## C#

 `// C# implement the approach``class` `GfG``{` `// Function to check whether``// a number is prime or not.``static` `bool` `is_prime(``int` `num)``{` `    ``// Count variable to store``    ``// the number of factors of 'num'``    ``int` `count = 0;` `    ``// Counting the number of factors``    ``for` `(``int` `i = 1; i * i <= (num); i++)``    ``{` `        ``if` `((num) % i == 0)``        ``{` `            ``if` `(i * i != (num))``                ``count += 2;` `            ``else``                ``count++;``        ``}``    ``}` `    ``// If number is prime return true``    ``if` `(count == 2)``        ``return` `true``;` `    ``else``        ``return` `false``;``}` `// Function to check for divisibility``static` `string` `is_divisible(``int` `n)``{` `    ``// if 'n' equals 1 then divisibility is possible``    ``if` `(n == 1)``    ``{``        ``return` `"YES"``;``    ``}` `    ``// Else check whether 'n+1' is prime or not``    ``else``    ``{` `        ``// If 'n+1' is prime then 'n!' is``        ``// not divisible by 'n*(n+1)/2'``        ``if` `(is_prime(n + 1))``            ``return` `"NO"``;` `        ``// else divisibility occurs``        ``else``            ``return` `"YES"``;``    ``}``}` `// Driver Code``static` `void` `Main()``{` `    ``int` `n;` `    ``// Test for n=3``    ``n = 3;` `    ``System.Console.WriteLine(is_divisible(n));` `    ``// Test for n=4``    ``n = 4;` `    ``System.Console.WriteLine(is_divisible(n));``}``}` `// This code is contributed by mits`

## PHP

 ``

## Javascript

 ``
Output:
```YES
NO```

My Personal Notes arrow_drop_up