这是一个查找数字阶乘的程序。 为什么我得到0作为答案？ 我应该改用哪种数据类型？

Question

I'm relatively new to C. I made this program to find the factorial of any number. Upon executing the program, when I provide 33 as the input - I get 2147483648 as the answer. If I provide 34, I get 0 as the answer.

Getting to my question - Why did I get 0 as the answer? The datatype I've used has a range of 0-4294967295. Am I getting 0 cause this is outside the range of unsigned int? Which datatype should I use if I want to get a large number as the output?

Compiler used - GCC 8.2.1

Here's the code -

#include<stdio.h>
#include<stdlib.h>
int fact(unsigned int n)
{
        int result;
        if(n==0 || n==1)
                result=1;
        else
                result=n*fact(n-1);
        return result;
}
int main()
{
        unsigned int n,ans;
        printf("Enter n:");
        scanf("%u",&n);
        ans=fact(n);
        printf("Factorial of %u:%u",n,ans);
}

Answer 1

33! is actually way out of the range of a 32 bit int , whether signed or unsigned. 12! has a value of 479001600, while 13! has a value of 6227020800 , so you go out of range at 13! .

Note also that result is defined as an int and you return an int from fact . This means you end up with signed integer overflow which invokes undefined behavior . This can be fixed by changing the type of both to unsigned , although you're still limited to 12! .

You can try using unsigned long long for your types instead. That will get you up to 20! . If you want values larger than that, you need to use a bigint library such as GMP.

Answer 2

The factorial grows very quickly . 13! is already outside the range representable by a 32-bit unsigned integer. Unsigned arithmetic returns the remainder when a result is not representable -- that is, you get only the least-significant bits of the true mathematical result. You could go a bit higher by using a wider data type, but not much. You need an arbitrary-precision arithmetic package and a lot of memory to go much further.

As for why the result you get for 34! is exactly zero , note that among the factors 1 * 2 * 3 * ... * 33 * 34 there are 17 that are multiples of two, 8 of which are also multiples of 4, 4 of which are also multiples of 8, two of which are multiples of 16, and one of which is 32. That's a total of 32 2s in the prime factorization of the mathematical result, so the remainder modulo 2 ³² is exactly zero.

Answer 3

An unsigned int has a range of 0 to 2^32-1 , or 2^32 = 4,294,967,296 different values. Assigning your result a value higher than 2^32-1 = 4,294,967,295 makes the value overflow. This simply means it loops back to 0 , after which it can increase up to 4,294,967,295 again.

The first overflow happens when calculating 13! , when we would expect the result value to be 13! = 6,227,020,800 13! = 6,227,020,800 . However, we did not take the overflow into account. The value of result will instead equal the remainder of the equation 13! % 2^32 13! % 2^32 , or 1,932,053,504 , because that's how much result increases after the last (and, in this case, only) loop back to 0 .

Now, 33! or 34! represent values that are are unimaginably large, and make result overflow many times. We can calculate how many times 33! causes an overflow simply by dividing it by 2^32 , resulting in around 2.02e27 overflows. However, your question isn't concerned with how many overflows happen, but with the value of the remainder after the last overflow. In this case, it equals 33! % 2^32 = 2,147,483,648 33! % 2^32 = 2,147,483,648 . We can do the same for 34 : 34! % 2^32 = 0 34! % 2^32 = 0 .

What this means is that, coincidentally, 2^32 is a proper divisor of 34! . Or, isn't this coincidental after all ?

Edit : like others have suggested, you should take a look at the GMP Bignum library with no limit in precision arithmetic except that of your machine.

Answer 4

Your assumption The datatype I've used has a range of 0-4294967295. is not right. you define ans parameter as unsigned int which has range of 0-4294967295 but in your fact function, you are using int which has range of -2,147,483,648 to 2,147,483,647 .

So you should change yout code as this:

#include<stdio.h>
#include<stdlib.h>
unsigned int fact(unsigned int n)
{
        unsigned int result;
        if(n==0 || n==1)
                result=1;
        else
                result=n*fact(n-1);
        return result;
}
int main()
{
        unsigned int n,ans;
        printf("Enter n:");
        scanf("%u",&n);
        ans=fact(n);
        printf("Factorial of %u:%u",n,ans);
}

You can also use unsigned long long instead of unsigned int which will support bigger numbers and is more suitable for factorial calculation.

#include<stdio.h>
#include<stdlib.h>
unsigned long long fact(unsigned int n)
{
        unsigned long long result;
        if(n==0 || n==1)
                result=1;
        else
                result=n*fact(n-1);
        return result;
}
int main()
{
        unsigned int n;
        unsigned long long ans;
        printf("Enter n:");
        scanf("%u",&n);
        ans=fact(n);
        printf("Factorial of %u:%u",n,ans);
}

More reading on data types and their range: https://www.tutorialspoint.com/cprogramming/c_data_types.htm

Answer 5

You get 0 when you overflow your data types. Formally the behaviour on overflowing an int is undefined . If you switch consistently to unsigned types, then the overflow is such that the behaviour is consistent with arithmetic modulo 2 raised to the power of the number of bits in your unsigned type.

Since a large factorial is a multiple of a power of 2, 0 will be attained for a surprisingly small input, as you observe here.