Why do these two similar pieces of code produce different results?

Question

I've been experimenting with Python as a begninner for the past few hours. I wrote a recursive function, that returns recurse(x) as x! in Python and in Java, to compare the two. The two pieces of code are identical, but for some reason, the Python one works, whereas the Java one does not. In Python, I wrote: ``` x = int(raw_input("Enter: ")) def recurse(num): if num != 0: num = num * recurse(num-1) else: return 1 return num print recurse(x) ``` Where variable num multiplies itself by num-1 until it reaches 0, and outputs the result. In Java, the code is very similar, only longer: ``` public class Default { static Scanner input = new Scanner(System.in); public static void main(String[] args){ System.out.print("Enter: "); int x = input.nextInt(); System.out.print(recurse(x)); } public static int recurse(int num){ if(num != 0){ num = num * recurse(num - 1); } else { return 1; } return num; } ``` } If I enter 25, the Python Code returns 1.5511x10E25, which is the correct answer, but the J…

Accepted Answer

Two words - integer overflow

While not an expert in python, I assume it may expand the size of the integer type according to its needs.

In Java, however, the size of an `int` type is fixed - 32bit, and since `int` is signed, we actually have only 31 bits to represent positive numbers. Once the number you assign is bigger than the maximum, it overflows the int (which is - there is no place to represent the whole number).

While in the C language the behavior in such case is undefined, in Java it is well defined, and it just takes the least 4 bytes of the result.

For example:

```
System.out.println(Integer.MAX_VALUE + 1);
// Integer.MAX_VALUE = 0x7fffffff
```

results in:

```
-2147483648
// 0x7fffffff + 1 = 0x800000000
```

Edit

Just to make it clearer, here is another example. The following code:

```
int a = 0x12345678;
int b = 0x12345678;
System.out.println("a*b as int multiplication (overflown) [DECIMAL]: " + (a*b));
System.out.println("a*b as int multiplication (overflown) [HEX]: 0x" + Integer.toHexString(a*b));
System.out.println("a*b as long multiplication (overflown) [DECIMAL]: " + ((long)a*b));
System.out.println("a*b as long multiplication (overflown) [HEX]: 0x" + Long.toHexString((long)a*b));
```

outputs:

```
a*b as int multiplication (overflown) [DECIMAL]: 502585408
a*b as int multiplication (overflown) [HEX]: 0x1df4d840
a*b as long multiplication (overflown) [DECIMAL]: 93281312872650816
a*b as long multiplication (overflown) [HEX]: 0x14b66dc1df4d840
```

And you can see that the second output is the least 4 bytes of the 4 output

Why do these two similar pieces of code produce different results?

Solution

Problem