Diophantine Equation in Kotlin

The challenge

In mathematics, a Diophantine equation is a polynomial equation, usually with two or more unknowns, such that only the integer solutions are sought or studied.

In this kata we want to find all integers `x, y` (`x >= 0, y >= 0`) solutions of a diophantine equation of the form:

x2 – 4 * y2 = n

(where the unknowns are `x` and `y`, and `n` is a given positive number) in decreasing order of the positive xi.

If there is no solution return `[]` or `"[]"` or `""`. (See “RUN SAMPLE TESTS” for examples of returns).

Examples:

```// [[45003, 22501], [9003, 4499], [981, 467], [309, 37]]
solEquaStr(90005)

// []
solEquaStr(90002)
```

Hint:

x2 – 4 * y2 = (x – 2*y) * (x + 2*y)

The solution in Kotlin

Option 1:

```package diophequa
import kotlin.math.sqrt

fun solEquaStr(n:Long):String {
if ( (n % 2 == 0L) and  (n/2 % 2 == 1L)) return "[]"
val lower = if (n % 2 == 0L) {2} else {1}
val limit = sqrt(n.toDouble()).toInt()
val strings = mutableListOf<String>()
for (a in lower..limit step 2) {
if (n % a != 0L) continue
val b = n/a
if (((a+b) % 2 != 0L) or ((b-a) % 4 != 0L)) continue
val x = (a+b)/2
val y = (b-a)/4
}
return strings.joinToString(prefix = "[",postfix = "]")
}
```

Option 2:

```package diophequa

import kotlin.math.ceil
import kotlin.math.pow
import kotlin.math.sqrt

fun solEquaStr(n: Long): String {
val pairs = mutableListOf<Pair<Long, Long>>()
val (low, high) = ceil(sqrt(n.toDouble())).toLong() to ceil(n.toDouble() / 2).toLong()
(high downTo low).forEach { x ->
val y = findY(n, x)
}

return pairs
.sortedByDescending { it.first }
.joinToString(", ", "[", "]") { (x, y) -> "[\$x, \$y]" }
}

fun findY(n: Long, x: Long) = sqrt((x.toDouble().pow(2) - n) / 4)

fun Double.isInteger() = this == Math.floor(this) && !this.isInfinite()
Best Practices1Clever0

```

Option 3:

```package diophequa

fun solEquaStr(n:Long):String {
return (1..Math.sqrt(n.toDouble()).toInt()).filter {
(n % it).toInt() == 0 && (n / it - it).toInt() % 4 == 0
}.map {
listOf((n / it + it) / 2, (n / it - it) / 4)
}.toString()
}
```

Test cases to validate our solution

```package diophequa

import org.junit.Assert.*
import org.junit.Test
import kotlin.test.assertEquals
import java.util.Random

class diophanteTest {
@Test
fun test1() {
assertEquals("[[3, 1]]", solEquaStr(5))
}
@Test
fun test2() {
assertEquals("[[4, 1]]", solEquaStr(12))
}
@Test
fun test3() {
assertEquals("[[7, 3]]", solEquaStr(13))
}
@Test
fun test4() {
assertEquals("[[4, 0]]", solEquaStr(16))
}
@Test
fun test5() {
assertEquals("[[9, 4]]", solEquaStr(17))
}
@Test
fun test6() {
assertEquals("[[6, 2]]", solEquaStr(20))
}
@Test
fun test7() {
assertEquals("[[4501, 2250]]", solEquaStr(9001))
}
@Test
fun test8() {
assertEquals("[[2252, 1125]]", solEquaStr(9004))
}
@Test
fun test9() {
assertEquals("[[4503, 2251], [903, 449]]", solEquaStr(9005))
}
@Test
fun test10() {
assertEquals("[[1128, 562]]", solEquaStr(9008))
}
@Test
fun test11() {
val a = "[[4505, 2252], [1503, 750], [647, 320], [505, 248], [415, 202], [353, 170], [225, 102], [153, 60], [135, 48], [103, 20], [97, 10], [95, 2]]"
assertEquals(a, solEquaStr(9009))
}
@Test
fun test12() {
assertEquals("[[45001, 22500]]", solEquaStr(90001))
}
@Test
fun test13() {
assertEquals("[]", solEquaStr(90002))
}
@Test
fun test14() {
assertEquals("[[22502, 11250]]", solEquaStr(90004))
}
@Test
fun test15() {
assertEquals("[[45003, 22501], [9003, 4499], [981, 467], [309, 37]]", solEquaStr(90005))
}
@Test
fun test16() {
assertEquals("[[45005, 22502], [15003, 7500], [5005, 2498], [653, 290], [397, 130], [315, 48]]", solEquaStr(90009))
}
@Test
fun test17() {
assertEquals("[[112502, 56249], [56254, 28123], [37506, 18747], [22510, 11245], [18762, 9369], [12518, 6241], [11270, 5615], [7530, 3735], [6286, 3107], [4550, 2225], [3810, 1845], [2590, 1205], [2350, 1075], [1650, 675], [1430, 535], [1150, 325], [1050, 225], [950, 25]]", solEquaStr(900000))
}
@Test
fun test18() {
assertEquals("[[450001, 225000]]", solEquaStr(900001))
}
@Test
fun test19() {
assertEquals("[[225002, 112500], [32150, 16068]]", solEquaStr(900004))
}
@Test
fun test20() {
assertEquals("[[450003, 225001], [90003, 44999]]", solEquaStr(900005))
}
@Test
fun test21() {
assertEquals("[[4500001, 2250000], [73801, 36870]]", solEquaStr(9000001))
}
@Test
fun test22() {
assertEquals("[[2250002, 1125000], [173090, 86532], [132370, 66168], [10402, 4980]]", solEquaStr(9000004))
}
@Test
fun test23() {
assertEquals("[[4500003, 2250001], [900003, 449999], [642861, 321427], [155187, 77579], [128589, 64277], [31107, 15481], [22269, 11033], [4941, 1963]]", solEquaStr(9000005))
}
@Test
fun test24() {
assertEquals("[[45000001, 22500000], [6428575, 3214284], [3461545, 1730766], [494551, 247230]]", solEquaStr(90000001))
}
@Test
fun test25() {
assertEquals("[[22500002, 11250000], [252898, 126360], [93602, 46560], [22498, 10200]]", solEquaStr(90000004))
}
//@Test
//fun test26() {
//  assertEquals("[[450000005, 225000002], [150000003, 75000000], [50000005, 24999998], [26470597, 13235290], [8823555, 4411752], [2941253, 1470550]]", solEquaStr(900000009))
//}
//@Test
//fun test27() {
//  assertEquals("[[225000004, 112500001], [75000004, 37499999], [3358276, 1679071], [1119604, 559601]]", solEquaStr(900000012))
//}
//@Test
//fun test28() {
//  assertEquals("[[4500000021, 2250000010], [155172429, 77586200]]", solEquaStr(9000000041L))
//}
@Test
fun testA() {
println("Random Tests")
var u:Long = 0
for (i in 0..5)
{
val a = randInt(5, 2000)
val b = randInt(5, 800)
var v = (a * a - 4 * b * b).toLong()
if (v < 0) u = -v else u = v
val sol = solEquaStrFD(u)
assertEquals(sol, solEquaStr(u))
}
}
companion object {
private fun randInt(min:Int, max:Int):Int {
return min + (Math.random() * ((max - min) + 1)).toInt()
}
fun solEquaStrFD(n:Long):String {
var res = "["
var i:Long = 1
while (i < Math.sqrt(n.toDouble()) + 1)
{
if (n % i == 0L)
{
val p = i + (n / i).toLong()
val q = (n / i).toLong() - i
if ((p % 2 == 0L) && (q % 4 == 0L))
{
val c = "[" + java.lang.Long.toString((p / 2).toLong()) + ", " + java.lang.Long.toString((q / 4).toLong()) + "], "
res += c
}
}
i++
}
if (res == "[")
return "[]"
else
return res.substring(0, res.length - 2) + "]"
}
}
}

```
Tags:
Subscribe
Notify of