Problem:
Score : 300 points

Problem Statement

Given any integer x, Aoki can do the operation below.

Operation: Replace x with the absolute difference of x and K.

You are given the initial value of an integer N. Find the minimum possible value taken by N after Aoki does the operation zero or more times.

Constraints

0 ≤ N ≤ 10^{18}

1 ≤ K ≤ 10^{18}

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the minimum possible value taken by N after Aoki does the operation zero or more times.

Sample Input 1

7 4

Sample Output 1

1

Initially, N=7.

After one operation, N becomes |7-4| = 3.

After two operations, N becomes |3-4| = 1, which is the minimum value taken by N.

Sample Input 2

2 6

Sample Output 2

2

N=2 after zero operations is the minimum.

Sample Input 3

1000000000000000000 1

Sample Output 3

0

Solution in Kotlin (1.0.0) (judge verdict: Wrong Answer)


import java.util.*

const val mInf = 1 shl 31
const val inf = mInf - 1
private val sc = Scanner(System.`in`)

fun readWord(): String = sc.next()
fun readLine(): String = sc.nextLine()
fun readInt(): Int = readLine().toInt()

fun readArray(): List<String> = readLine().split(" ").toList()
fun readStringList(size: Int): List<String> = (0 until size).map { readLine() }


fun readMultiRowToStringArray(size: Int, f: (String) -> Unit = {}): Array<String> =
    Array(size) { readLine().apply(f) }

fun readMultiRowToIntArray(size: Int, f: (Int) -> Unit = {}): IntArray =
    IntArray(size) { readLine().toInt().apply(f) }

fun readMultiRowToBooleanArray(size: Int, f: (String) -> Boolean): BooleanArray = BooleanArray(size) { f(readLine()) }

//
fun readRowSplitToStringArray(size: Int, f: (String) -> String = { it }): Array<String> =
    Array(size) { sc.next().apply { f } }

fun readRowSplitToIntArray(size: Int, f: (Int) -> Unit = { }): IntArray =
    IntArray(size) { sc.next().toInt().apply(f) }

fun readRowSplitToBooleanArray(size: Int, f: (String) -> Boolean): BooleanArray = BooleanArray(size) { f(sc.next()) }

fun main(args: Array<String>) {
    val (N, K) = readRowSplitToStringArray(2).map { it.toLong() }

    var min = N
    val map = mutableMapOf<Long, Boolean>()
    while (true) {
        val result = if (N > K) N % K else K - N
        if (map[result] != null) break
         else {
            min=Math.min(min,result)
            map[result] = true
        }
    }
    println(min)
}