Kotlin中的同一个程序与Python中的同一个程序会产生不同的结果

Question

I wrote two functions in different languages according to the algorithm that tests the primality of a number given by the overview for Project Euler problem 7. I don't find any difference in these two functions, but they give me different results. Why?

First one in Kotlin:

import kotlin.math.floor
import kotlin.math.sqrt

fun isPrime(n: Int): Boolean {
    if (n == 1) return false
    else if (n < 4) return true
    else if (n % 2 == 0) return false
    else if (n < 9) return true
    else if (n % 3 == 0) return false
    else {
        val r = floor(sqrt(n.toDouble())).toInt()
        var f = 5
        while (f <= r) {
            if (n % f == 0) return false
            else if (n % (f + 2) == 0) return false
            f += 6
        }
        return true
    }
}

fun main(args: Array<String>) {
    var sum = 5
    var n = 5
    while (n <= 2000000) {
        if (isPrime(n)) sum += n
        n += 2
        if (n <= 2000000 && isPrime(n)) sum += n
        n += 4
    }

    println(sum)
}

the output is 1179908154

Then the one in Python:

import math

def isPrime(n):
    if n==1 :
        return False
    elif n<4 :
        return True
    elif n%2==0:
        return False
    elif n<9:
        return True
    elif n%3==0:
        return False
    else:
        r=math.floor(math.sqrt(n))
        f=5
        while(f<=r):
            if n%f==0:
                return False
            elif n%(f+2)==0:
                return False
            f+=6
    return True

sum =5
n =5
while n<=2000000:
    if isPrime(n):
        sum+=n
    n+=2
    if n<=2000000 and isPrime(n):
        sum+=n
    n+=4
print(sum)

The output is 142913828922

These two program are same, but why they gave me different answer? And.... First time ask a question in English. Sorry for the language.

Answer 1

This is a case of integer limit jumping ( overflow ).

The output of python is correct. If you see actual value 142913828922 this is above 32bit limit of kotlin int ie 2^37. I dont know kotlin code but you can use java equivalent long for this purpose.

Answer 2

Looks like an overflow on the part of Kotlin. Kotlin is still limited to the JVM, and you're likely processing values which are just a bit too big for Int .

If you convert everything in Kotlin to a Long , you get the same number as you do in Python. Note: Python implicitly converts large numbers over to a long-like type, so you don't have to do that on your own, but that's a striking difference between the two languages.

fun isPrime(n: Long): Boolean {
    if (n == 1L) return false
    else if (n < 4) return true
    else if (n % 2 == 0L) return false
    else if (n < 9) return true
    else if (n % 3 == 0L) return false
    else {
        val r = floor(sqrt(n.toDouble())).toInt()
        val r1 = floor(sqrt(n.toDouble()))
        var f = 5
        while (f <= r) {
            if (n % f == 0L) return false
            else if (n % (f + 2L) == 0L) return false
            f += 6
        }
        return true
    }
}