{"lang": "Kotlin", "source_code": "import kotlin.collections.*\nimport kotlin.io.*\nimport kotlin.math.*\nimport kotlin.Array\n\nclass Main{\n\n fun solve(inp : InputReader) {\n val (n,k) = inp.readlnInts()\n val a = inp.readlnInts().toIntArray()\n val lim = a[k - 1]\n val ans = a.filter{it > 0 && it >= lim}.count()\n print(ans)\n }\n\n class InputReader{\n public fun readln() = readLine()!!\n public fun readlnInt() = readln().toInt()\n public fun readlnLong() = readln().toLong()\n public fun readlnDouble() = readln().toDouble()\n\n public fun readlnStrings() = readln().split(\" \")\n public fun readlnInts() = readlnStrings().map{it.toInt()}\n public fun readlnLongs() = readlnStrings().map{it.toLong()}\n public fun readlnDoubles() = readlnStrings().map{it.toDouble()}\n }\n}\n\nfun main(args : Array ){\n Main().solve(Main.InputReader())\n}", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "92b3aee48693b7187524a021980f1ba9", "src_uid": "193ec1226ffe07522caf63e84a7d007f", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun readString() = readLine()!!\nfun readStrings() = readString().split(\" \")\nfun readInt() = readString().toInt()\nfun readInts() = readStrings().map { it.toInt() }\nfun readLong() = readString().toLong()\nfun readLongs() = readStrings().map { it.toLong() }\nfun readDouble() = readString().toDouble()\nfun readDoubles() = readStrings().map { it.toDouble() }\n\nfun main() {\n val (k, r) = readInts()\n var i = 1\n while (true) {\n if ((i * k) % 10 == 0 || (i * k - r) % 10 == 0) {\n print(i)\n break\n }\n i++\n }\n}\n\n", "lang_cluster": "Kotlin", "tags": ["brute force", "math", "constructive algorithms", "implementation"], "code_uid": "addf96fc77bc88a09dd50763f1490c53", "src_uid": "18cd1cd809df4744bb7bcd7cad94e2d3", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main()\n{\n var (n, k) = readLine()!!.split(\" \").map { it.toInt() }\n \n while (k > 0)\n {\n if (n % 10 == 0) n /= 10\n else n -= 1\n k -= 1\n }\n \n println(n)\n}\n", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "657c9627433e0ad69e7a41b926ac8d81", "src_uid": "064162604284ce252b88050b4174ba55", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.BufferedReader\nimport java.io.InputStreamReader\n\nfun steps(distance: Int): Int {\n return if (distance > 5)\n steps(distance - 5) + 1\n else 1\n}\n\nfun main(args: Array) {\n val reader = BufferedReader(InputStreamReader(System.`in`))\n val s = reader.readLine().toInt()\n println(steps(s))\n}", "lang_cluster": "Kotlin", "tags": ["math"], "code_uid": "5129513efc69bc2f4a43537c2456c7f3", "src_uid": "4b3d65b1b593829e92c852be213922b6", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main(args: Array) {\n val sum = readLine()!!.split(' ').map { it.toInt() }.reduce { total, next -> total + next }\n println(if (sum > 0 && sum % 5 == 0) sum / 5 else \"-1\")\n}\n", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "5e067c68e5551d30019efba16b374fdb", "src_uid": "af1ec6a6fc1f2360506fc8a34e3dcd20", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.*\nimport java.util.*\nimport kotlin.collections.ArrayList\n\nfun main(args: Array) {\n val inputStream = System.`in`\n val outputStream = System.out\n val inputReader = InputReader(inputStream)\n val out = PrintWriter(outputStream)\n\n val n = inputReader.nextInt()\n val k = inputReader.nextLong()\n val str = inputReader.next()\n\n val letters = BooleanArray(26)\n val list = ArrayList(n)\n for (i in 0 until str.length) {\n val char = str[i]\n val node = Node(char, i, n)\n if (letters[char - 'a']) {\n node.isSame = true\n } else {\n letters[char - 'a'] = true\n }\n list.add(node)\n }\n for (i in 0 until list.size) {\n val ai = list[i]\n for (j in i + 1 until list.size) {\n val aj = list[j]\n ai.addNext(aj.char - 'a', aj)\n }\n }\n\n for (node in list) {\n find(node)\n }\n\n val totalCountArray = LongArray(n)\n for (i in 0 until n) {\n for (node in list) {\n if (!node.isSame) {\n totalCountArray[i] += node.countArray[i]\n }\n }\n }\n\n var totalCost = 0L\n var selectCount = 0L\n for (i in n - 1 downTo 0) {\n if (selectCount + totalCountArray[i] < k) {\n totalCost += (n - 1 - i) * totalCountArray[i]\n selectCount += totalCountArray[i]\n } else {\n val over = (selectCount + totalCountArray[i]) - k\n totalCost += (n - 1 - i) * (totalCountArray[i] - over)\n selectCount += (totalCountArray[i] - over)\n break\n }\n }\n\n if (selectCount < k) {\n if (selectCount == k - 1) {\n println(totalCost + n)\n } else {\n println(-1)\n }\n } else {\n println(totalCost)\n }\n}\n\nprivate fun find(node: Node) {\n if (node.hasCul) {\n return\n }\n\n node.countArray[0]++\n for (next in node.nextList) {\n find(next)\n for (i in 0 until next.countArray.size) {\n if (next.countArray[i] > 0) {\n node.countArray[i + 1] += next.countArray[i]\n }\n }\n }\n\n node.hasCul = true\n}\n\nclass Node(var char: Char, var index: Int, n: Int) {\n private val nextArray: Array = arrayOfNulls(26)\n var hasCul = false\n var isSame = false\n var nextCount = 0\n val nextList = ArrayList()\n\n val countArray = LongArray(n)\n\n override fun toString(): String {\n return \"$char\"\n }\n\n fun addNext(index: Int, node: Node) {\n if (nextArray[index] == null) {\n nextCount++\n nextArray[index] = node\n nextList.add(node)\n }\n }\n}\n\nclass InputReader(stream: InputStream) {\n private var reader: BufferedReader = BufferedReader(InputStreamReader(stream))\n private var tokenizer = StringTokenizer(\"\")\n\n /** get next word */\n @Throws(IOException::class)\n operator fun next(): String {\n while (!tokenizer.hasMoreTokens()) {\n //TODO add check for eof if necessary\n tokenizer = StringTokenizer(\n reader.readLine()\n )\n }\n return tokenizer.nextToken()\n }\n\n fun nextLong() = next().toLong()\n fun nextInt() = next().toInt()\n fun nextDouble() = next().toDouble()\n fun nextFloat() = next().toFloat()\n}", "lang_cluster": "Kotlin", "tags": ["strings", "dp"], "code_uid": "45875e55913a05a2f9e2efaefd61614f", "src_uid": "ae5d21919ecac431ea7507cb1b6dc72b", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main(args: Array) {\n val name: String = readLine()!!\n val chars: MutableSet = name.toCharArray().toMutableSet()\n if (chars.count() %2 == 0) {\n print(\"CHAT WITH HER!\")\n } else {\n print(\"IGNORE HIM!\")\n }\n}", "lang_cluster": "Kotlin", "tags": ["brute force", "strings", "implementation"], "code_uid": "caede7748d090e5ce8a1f8ec933ed592", "src_uid": "a8c14667b94b40da087501fd4bdd7818", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n val r = System.`in`.bufferedReader()\n val s = StringBuilder()\n //val k = r.readLine()!!.toInt()\n val (a, b) = r.readLine()!!.split(\" \").map { it.toInt() }.sorted()\n val c = 7-b\n println(\"${c/ gcd(c, 6)}/${6/ gcd(c, 6)}\")\n\n}\n\ntailrec fun gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)", "lang_cluster": "Kotlin", "tags": ["math", "probabilities"], "code_uid": "152604d6a242a5255599ee00d7aa1a9b", "src_uid": "f97eb4ecffb6cbc8679f0c621fd59414", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.util.*\nfun readln() = readLine()!!\nfun readint() = readln().toInt()\nfun readlong() = readln().toLong()\nfun readdouble() = readln().toDouble()\nfun readstrings() = readln().split(\" \")\nfun readints() = readstrings().map { it.toInt() }\nfun readlongs() = readstrings().map { it.toLong() }\nfun readdoubles() = readstrings().map { it.toDouble() }\n\nvar mod=998244353L\n\nfun pw(a:Long,b:Long):Long{\n var c=b\n var d=a\n var res=1L\n while(c>0){\n if((c and 1L)!=0L){\n res*=d\n res%=mod\n }\n d*=d\n d%=mod\n c/=2\n }\n return res\n}\n\nfun inv(a:Long):Long{\n return pw(a,mod-2L)\n}\n\nfun main() {\n var tt = 1\n var f=LongArray(500010){1L}\n for(i in 2..500000){\n f[i]=f[i-1]*i.toLong()%mod\n }\n while (tt-- > 0) {\n var (n,k)=readints()\n var ans=0L\n for(i in 1..n-k+1){\n var cnt=n/i\n if(cnt) {\n Thread(null, Solution(), \"name\", 1 shl 27).start()\n}\n", "lang_cluster": "Kotlin", "tags": ["brute force", "implementation"], "code_uid": "8b6de2ac897391569afb0227e9668cc3", "src_uid": "699444eb6366ad12bc77e7ac2602d74b", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "\nimport java.util.*\n\nfun main(args: Array) = with(Scanner(System.`in`)){\n val s = nextLine()\n val chars = s.toCharArray()\n val size= chars.size\n val middle = (size - 1) / 2\n\n val odd = size % 2 != 0\n\n var j = size - 1\n var i = 0\n var counter = 1\n\n var palindrom = true\n while(true){\n val begin = chars[i]\n val end = chars[j]\n if(begin != end){\n if (counter == 0){\n palindrom = false\n break\n }\n counter--\n }\n if (i == middle){\n break\n }\n i++\n j--\n }\n if((palindrom && counter == 0) ||( palindrom && counter == 1 && odd) ){\n println(\"YES\")\n } else {\n println(\"NO\")\n }\n}\n ", "lang_cluster": "Kotlin", "tags": ["brute force", "strings", "constructive algorithms"], "code_uid": "9be9ff35b661e3eb0c387e0eb45c0e49", "src_uid": "fe74313abcf381f6c5b7b2057adaaa52", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.math.BigInteger\n\nfun readInt(): Int {\n return readLine()!!.toInt()\n}\n\nfun readLong(): Long {\n return readLine()!!.toLong()\n}\n\nfun readBigInt(): BigInteger {\n return readLine()!!.toBigInteger()\n}\n\nfun readInts(): List {\n return readLine()!!.split(\" \").map(String::toInt)\n}\n\nfun readLongs(): List {\n return readLine()!!.split(\" \").map(String::toLong)\n}\n\nfun readBigInts(): List {\n return readLine()!!.split(\" \").map(String::toBigInteger)\n}\n\nclass Solution(private val n: Int, private val b: Int, private val a: List) {\n fun solve() {\n var even = 0\n var odd = 0\n val possibleCuts = mutableListOf()\n for (i in a.indices) {\n if (a[i] % 2 == 0)\n even++\n else\n odd++\n if (even == odd && i + 1 < a.size)\n possibleCuts.add(kotlin.math.abs(a[i] - a[i + 1]))\n }\n if (even != odd)\n println(0)\n else {\n val possibleCutsArray = possibleCuts.toIntArray()\n possibleCutsArray.sort()\n var ans = 0\n var sum = 0\n for (cost in possibleCutsArray)\n if (sum + cost <= b) {\n sum += cost\n ans++\n }\n println(ans)\n }\n }\n}\n\nfun main() {\n val (n, b) = readInts()\n val a = readInts()\n val solution = Solution(n, b, a)\n solution.solve()\n}\n", "lang_cluster": "Kotlin", "tags": ["sortings", "dp", "greedy"], "code_uid": "aab4882b64b4c291dbc95fec1c2af40a", "src_uid": "b3f8e769ee7719ea5c9f458428b16a4e", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n val a = readLine()!!\n val b = readLine()!!\n println(a.zip(b).map { (i, j) -> if (i==j) '0' else '1'}.joinToString(separator = \"\"))\n}\n", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "4a7b083a621215eb1a0f7af94c97c96f", "src_uid": "3714b7596a6b48ca5b7a346f60d90549", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n var n = readLine()!!.toInt() + 1\n val total = readLine()!!.split(\" \").map{ it.toInt() }.reduce{ sum, e -> sum + e }\n var count = 0\n for(i in 1..5) {\n if((i + total) % n != 1)\n count++\n }\n println(count)\n}", "lang_cluster": "Kotlin", "tags": ["math", "implementation"], "code_uid": "3eeed671f58ad5ce92185f0931b8c51a", "src_uid": "ff6b3fd358c758324c19a26283ab96a4", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "private fun readLn() = readLine()!! // string line\nprivate fun readInt() = readLn().toInt() // single int\nprivate fun readStrings() = readLn().split(\" \") // list of strings\nprivate fun readInts() = readStrings().map { it.toInt() } // list of ints\n\nfun main() {\n val(n, k) = readInts()\n val a = readInts()\n \n var cnt : Int = 0\n \n for (i in 0..n - 1) {\n if (a[i] > k) break\n else ++cnt\n }\n \n if (cnt == n) {\n println(cnt)\n return\n }\n \n for (i in n - 1 downTo 0) {\n if (a[i] > k) break\n else ++cnt\n }\n \n println(cnt)\n}", "lang_cluster": "Kotlin", "tags": ["brute force", "implementation"], "code_uid": "3dfd44ca65f3224069b2de9271135222", "src_uid": "ecf0ead308d8a581dd233160a7e38173", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "// kotlin oj template code from uwi(Codeforces), and convert to kotlin by lety\nimport java.io.ByteArrayInputStream\nimport java.io.IOException\nimport java.io.InputStream\nimport java.io.PrintWriter\nimport java.util.Arrays\nimport java.util.InputMismatchException\nimport kotlin.math.absoluteValue\n\nlateinit var `is`: InputStream\nlateinit var out: PrintWriter\nvar INPUT = \"\"\n\n//val oj = System.getProperty(\"ONLINE_JUDGE\") != null\nval oj = true\nval inbuf = ByteArray(1024)\nvar lenbuf = 0\nvar ptrbuf = 0\n\nlateinit var cum: Array\n\nfun solve()\n{\n val n = ni()\n val s = ns()\n var r = 0\n\n for(i in 1 until n)\n {\n if( s[i] == s[i-1] )\n {\n r++\n }\n }\n\n println(r)\n}\n\n\nfun main() {\n `is` = if (oj) System.`in` else ByteArrayInputStream(INPUT.toByteArray())\n out = PrintWriter(System.out)\n\n val s = System.currentTimeMillis()\n solve()\n out.flush()\n tr((System.currentTimeMillis() - s).toString() + \"ms\")\n}\n\nprivate fun readByte(): Int {\n if (lenbuf == -1) throw InputMismatchException()\n if (ptrbuf >= lenbuf) {\n ptrbuf = 0\n try {\n lenbuf = `is`.read(inbuf)\n } catch (e: IOException) {\n throw InputMismatchException()\n }\n\n if (lenbuf <= 0) return -1\n }\n return inbuf[ptrbuf++].toInt()\n}\n\nprivate fun isSpaceChar(c: Int): Boolean = !(c >= 33 && c <= 126)\n\nprivate fun skip(): Int {\n var b: Int = readByte()\n while (b != -1 && isSpaceChar(b)) {\n b = readByte()\n }\n return b\n}\n\n// using ns()\nprivate fun nd(): Double = ns().toDouble()\n\n// using ns()\nprivate fun nc(): Char = skip().toChar()\n\n// input until whitespace\nprivate fun ns(): String {\n var b = skip()\n val sb = StringBuilder()\n while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')\n sb.appendCodePoint(b)\n b = readByte()\n }\n return sb.toString()\n}\n\nprivate fun ns(n: Int): CharArray {\n val buf = CharArray(n)\n var b = skip()\n var p = 0\n while (p < n && !isSpaceChar(b)) {\n buf[p++] = b.toChar()\n b = readByte()\n }\n return if (n == p) buf else Arrays.copyOf(buf, p)\n}\n\n// matrix\nprivate fun nm(n: Int, m: Int): Array {\n val map = Array(n) { CharArray(m) }\n for (i in 0 until n) map[i] = ns(m)\n return map\n}\n\nprivate fun pm(matrix: Array) {\n val n = matrix.size\n val m = matrix[0].size\n repeat(n)\n {\n repeat(m)\n { jt ->\n out.print(matrix[it][jt])\n }\n out.println()\n }\n out.flush()\n}\n\n// int array\nprivate fun na(n: Int): IntArray {\n val a = IntArray(n)\n for (i in 0 until n) a[i] = ni()\n return a\n}\n\nprivate fun ni(): Int {\n var num = 0\n var b: Int = readByte()\n var minus = false\n while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {\n b = readByte()\n }\n if (b == '-'.toInt()) {\n minus = true\n b = readByte()\n }\n\n while (true) {\n if (b >= '0'.toInt() && b <= '9'.toInt()) {\n num = num * 10 + (b - '0'.toInt())\n } else {\n return if (minus) -num else num\n }\n b = readByte()\n }\n}\n\nprivate fun nl(): Long {\n var num: Long = 0\n var b: Int = readByte()\n var minus = false\n while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {\n b = readByte()\n }\n if (b == '-'.toInt()) {\n minus = true\n b = readByte()\n }\n\n while (true) {\n if (b >= '0'.toInt() && b <= '9'.toInt()) {\n num = num * 10 + (b - '0'.toInt())\n } else {\n return if (minus) -num else num\n }\n b = readByte()\n }\n}\n\nprivate fun tr(vararg o: Any) {\n// if (!oj) println(Arrays.deepToString(o))\n}\n\n", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "5865165eb2eb2654478a82154c7facec", "src_uid": "d561436e2ddc9074b98ebbe49b9e27b8", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n fun readInt() = readLine()!!.toInt()\n fun readLong() = readLine()!!.toLong()\n fun readInts() = readLine()!!.split(\" \").map(String::toInt)\n fun readLongs() = readLine()!!.split(\" \").map(String::toLong)\n\n val n = readInt()\n print(3 * n / 2)\n}", "lang_cluster": "Kotlin", "tags": ["math", "number theory"], "code_uid": "20e5500212029d159f09164f5c993a96", "src_uid": "031e53952e76cff8fdc0988bb0d3239c", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.BufferedInputStream\nimport java.util.*\n\nfun main(args: Array) {\n val scanner = Scanner(BufferedInputStream(System.`in`))\n\n val n = scanner.nextInt()\n val m = scanner.nextInt()\n\n val foods = mutableMapOf()\n repeat (m) {\n val food = scanner.nextInt()\n foods[food] = foods.getOrDefault(food, 0) + 1\n }\n\n var left = 0\n var right = m / n\n while (left < right) {\n val mid = (left + right + 1) / 2\n val canSurviveMid = canSurvive(mid, n, foods)\n if (canSurviveMid) {\n left = mid\n } else {\n right = mid - 1\n }\n }\n println(left)\n}\n\nfun canSurvive(day: Int, people: Int, foods: MutableMap): Boolean {\n var sumPeople = 0L\n for (food in foods) {\n sumPeople += food.value / day\n }\n\n return sumPeople >= people\n}\n", "lang_cluster": "Kotlin", "tags": ["brute force", "implementation", "binary search"], "code_uid": "8c8823b278c26099386d21a81807995d", "src_uid": "b7ef696a11ff96f2e9c31becc2ff50fe", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main(args: Array) {\n var (a, b, n) = readLine()!!.split(' ').map { it.toInt() }\n\n fun gcd(x: Int, y: Int) = x.toBigInteger().gcd(y.toBigInteger()).toInt()\n\n while (true) {\n val ax = gcd(a, n)\n if (ax > n) {\n println(1)\n return\n }\n n -= ax\n val bx = gcd(b, n)\n if (bx > n) {\n println(0)\n return\n }\n n -= bx\n }\n}", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "80db0853ee0f76d898fff6e2936ce169", "src_uid": "0bd6fbb6b0a2e7e5f080a70553149ac2", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "class TransitionMatrix {\n val matrix : Array\n\n init {\n this.matrix = Array(4, {_ -> LongArray(4, {_ -> 0L})})\n }\n\n operator fun get(i : Int, j : Int) : Long {\n return this.matrix[i][j]\n }\n\n operator fun set(i : Int, j : Int, x : Long) {\n this.matrix[i][j] = x\n }\n\n operator fun times(other : TransitionMatrix) : TransitionMatrix {\n val modulo = 1000000007L\n val result = TransitionMatrix()\n for (i in 0 .. 3) {\n for (j in 0 .. 3) {\n var x = 0L\n for (k in 0 .. 3) {\n x = (x + (this[i,k] * other[k,j])) % modulo\n }\n result[i,j] = x\n }\n }\n return result\n }\n}\n\nfun identity_matrix() : TransitionMatrix {\n val result = TransitionMatrix()\n result[0,0] = 1L\n result[1,1] = 1L\n result[2,2] = 1L\n result[3,3] = 1L\n return result\n}\n\nfun ant_matrix() : TransitionMatrix {\n val result = TransitionMatrix()\n for (i in 0 .. 3) {\n for (j in 0 .. 3) {\n result[i,j] = 1L\n }\n }\n result[0,0] = 0L\n result[1,1] = 0L\n result[2,2] = 0L\n result[3,3] = 0L\n return result\n}\n\nfun num_paths(n : Int) : Long {\n fun raise_to(t : TransitionMatrix, x : Int) : TransitionMatrix {\n if (x == 0) {\n val result = identity_matrix()\n return result\n } else if ((x % 2) == 0) {\n val t_sqr = t * t\n val x_div_2 = x / 2\n val result = raise_to(t_sqr, x_div_2)\n return result\n } else {\n val t_sqr = t * t\n val x_minus_1_div_2 = (x - 1) / 2\n val result = t * raise_to(t_sqr, x_minus_1_div_2)\n return result\n }\n }\n val t_matrix = ant_matrix()\n val result = raise_to(t_matrix, n)\n return result[0,0]\n}\n\nfun main(args : Array) {\n val n_nullable_str = readLine()\n if (n_nullable_str == null) {\n // Do nothing ...\n } else {\n val n_str = n_nullable_str\n val n = n_str.toInt()\n val result = num_paths(n)\n println(\"${result}\")\n }\n}\n", "lang_cluster": "Kotlin", "tags": ["math", "matrices", "dp"], "code_uid": "36082ec9eb1d0640c12a69ffa50bf557", "src_uid": "77627cc366a22e38da412c3231ac91a8", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n when (readLine()!!.toInt()) {\n 2 -> println(2)\n else -> println(1)\n }\n}", "lang_cluster": "Kotlin", "tags": ["math", "constructive algorithms"], "code_uid": "24e2c8a09ba900385c4fe6b6d939dcd5", "src_uid": "c30b372a9cc0df4948dca48ef4c5d80d", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "\nimport java.util.*\n\nfun main(args: Array) {\n val sc = Scanner(System.`in`)\n\n val n = sc.nextInt()\n val cubes = Array(n * 6, { _ -> HashSet()})\n var notz = false\n for (i in 0 until n) {\n for (j in 0 until 6) {\n val cur = sc.nextInt()\n if (cur != 0) {\n notz = true\n }\n cubes[i].add(cur)\n }\n }\n if (!notz) {\n println(0)\n } else {\n for (i in 1..1001) {\n if (i == 1000 || !aux(cubes, i)) {\n println(i - 1)\n break\n }\n }\n }\n}\n\nfun aux(pos: Array>, num: Int):Boolean {\n val hun = if (num / 100 > 0) num / 100 else null\n val ten = if ((num % 100) / 10 > 0) (num % 100) / 10 else null\n val one = num % 10\n if (ten == null && hun == null) {\n return one in pos[0] || one in pos[1] || one in pos[2]\n }\n if (hun == null) {\n return one in pos[0] && (ten in pos[1] || ten in pos[2]) ||\n one in pos[1] && (ten in pos[0] || ten in pos[2]) ||\n one in pos[2] && (ten in pos[0] || ten in pos[1])\n }\n return one in pos[0] && ten in pos[1] && hun in pos[2] ||\n one in pos[1] && ten in pos[0] && hun in pos[2] ||\n one in pos[0] && ten in pos[2] && hun in pos[1] ||\n one in pos[1] && ten in pos[2] && hun in pos[0] ||\n one in pos[2] && ten in pos[1] && hun in pos[0] ||\n one in pos[2] && ten in pos[0] && hun in pos[1]\n}\n", "lang_cluster": "Kotlin", "tags": ["brute force", "implementation"], "code_uid": "859d87c67120a13d2a0350db388d3a05", "src_uid": "20aa53bffdfd47b4e853091ee6b11a4b", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n val n = readLine()!!.toInt()\n var num = readLine()!!.split(' ').map { it.toInt() }.toIntArray()\n var count = Array(100){0}\n for (i in num){\n count[i-1]++\n }\n var max = 0\n for ( i in count )\n max = if (i > max) i else max\n print(max)\n}", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "5370b7afe5c2ba612b08fd53c0acb97b", "src_uid": "f30329023e84b4c50b1b118dc98ae73c", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.*\nimport java.util.*\n\nfun DataReader.solve(out: PrintWriter) {\n val n = nextInt()\n val k = nextInt()\n\n val s = nextToken()\n\n val used = BooleanArray(n)\n\n fun dfs(u: Int): Boolean {\n if (u < 0 || u >= n || used[u] || s[u] == '#') return false\n if (s[u] == 'T') return true\n used[u] = true\n\n return dfs(u - k) || dfs(u + k)\n }\n\n out.println(dfs(s.indexOf('G')).toYesNo())\n}\n\nfun Boolean.toYesNo() = if (this) \"YES\" else \"NO\"\n\nclass DataReader(private val reader: BufferedReader) {\n var st : StringTokenizer? = null\n companion object {\n fun createFromFile(name: String) = DataReader(BufferedReader(FileReader(name)))\n }\n\n fun next() : String? {\n while (st == null || !st!!.hasMoreTokens()) {\n val s = reader.readLine() ?: return null\n st = StringTokenizer(s)\n }\n\n return st?.nextToken()\n }\n\n fun nextToken() = next()!!\n\n fun nextInt() = nextToken().toInt()\n fun nextLong() = nextToken().toLong()\n fun readIntArray(n: Int) : IntArray {\n val result = IntArray(n)\n result.indices.forEach { i -> result[i] = nextInt() }\n return result\n }\n\n fun nextLine() = reader.readLine()\n}\n\nfun main(args: Array) {\n val r: Reader\n val out: PrintWriter\n if (System.getProperty(\"ONLINE_JUDGE\") == null) {\n r = FileReader(\"input.txt\")\n out = PrintWriter(\"output.txt\")\n } else {\n r = InputStreamReader(System.`in`)\n out = PrintWriter(System.out)\n }\n\n DataReader(BufferedReader(r)).solve(out)\n out.flush()\n}\n", "lang_cluster": "Kotlin", "tags": ["strings", "implementation"], "code_uid": "fb6678cedcaad6b6f894c118edd54369", "src_uid": "189a9b5ce669bdb04b9d371d74a5dd41", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.BufferedReader\nimport java.io.IOException\nimport java.io.InputStreamReader\nimport java.util.*\nimport kotlin.collections.ArrayList\nimport kotlin.math.*\nfun main() {\n val fs = CodeForces.FastReader()\n var n = fs.nextLong()\n var k = fs.nextLong()\n var set = HashSet()\n var bool = true\n for (i in 1..k) {\n var rest = n%i\n if(!set.contains(rest)) set.add(rest)\n else{\n bool = false\n break;\n }\n }\n if(bool) println(\"Yes\") else println(\"No\")\n}\n\nclass CodeForces {\n internal class FastReader {\n private var br: BufferedReader = BufferedReader(InputStreamReader(System.`in`))\n private var st: StringTokenizer? = null\n\n operator fun next(): String {\n while (st == null || !st!!.hasMoreElements()) {\n try {\n st = StringTokenizer(br.readLine())\n } catch (e: IOException) {\n e.printStackTrace()\n }\n\n }\n return st!!.nextToken()\n }\n\n fun nextInt(): Int {\n return Integer.parseInt(next())\n }\n\n fun nextLong(): Long {\n return java.lang.Long.parseLong(next())\n }\n\n fun nextDouble(): Double {\n return java.lang.Double.parseDouble(next())\n }\n\n fun nextLine(): String {\n var str = \"\"\n try {\n str = br.readLine()\n } catch (e: IOException) {\n e.printStackTrace()\n }\n return str\n }\n\n fun readIntArray(n: Int): IntArray {\n val a = IntArray(n)\n for (i in 0 until n) a[i] = nextInt()\n return a\n }\n\n fun readLongArray(n: Int): LongArray {\n val a = LongArray(n)\n for (i in 0 until n) a[i] = nextLong()\n return a\n }\n\n fun readDoubleArray(n: Int): DoubleArray {\n val a = DoubleArray(n)\n for (i in 0 until n) a[i] = nextDouble()\n return a\n }\n }\n}\n", "lang_cluster": "Kotlin", "tags": ["brute force", "number theory"], "code_uid": "14cee42f18bc45b7b2cb8f1ba3dff33c", "src_uid": "5271c707c9c72ef021a0baf762bf3eb2", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n val r = System.`in`.bufferedReader()\n val s = StringBuilder()\n //val k = r.readLine()!!.toInt()\n val (a, b, c, d) = r.readLine()!!.split(\" \").map { it.toInt() }\n val v256 = 256\n val v32 = 32\n val ans = minOf(a, c, d)*v256 + minOf(b, a- minOf(a, c, d))*v32\n println(ans)\n\n}", "lang_cluster": "Kotlin", "tags": ["math", "greedy", "implementation", "brute force"], "code_uid": "ed8ff30c525a9517b93006e548d96056", "src_uid": "082b31cc156a7ba1e0a982f07ecc207e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.BufferedInputStream\nimport java.util.*\n\nfun main(args: Array) {\n val scanner = Scanner(BufferedInputStream(System.`in`))\n\n val n = scanner.nextInt()\n val x = Array(n) { scanner.nextInt() }\n val y = Array(n) { scanner.nextInt() }\n\n println(if (x.sum() >= y.sum()) \"YES\" else \"NO\")\n}\n", "lang_cluster": "Kotlin", "tags": ["math"], "code_uid": "1f391cd80a719ce5be25e6f51c05e09f", "src_uid": "e0ddac5c6d3671070860dda10d50c28a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin 1.4", "source_code": "@file:Suppress(\"NOTHING_TO_INLINE\", \"EXPERIMENTAL_FEATURE_WARNING\", \"OVERRIDE_BY_INLINE\", \"DEPRECATION\")\r\n@file:OptIn(ExperimentalStdlibApi::class)\r\n\r\nimport java.io.PrintWriter\r\nimport java.util.StringTokenizer\r\nimport kotlin.collections.ArrayDeque\r\nimport kotlin.math.*\r\nimport kotlin.random.*\r\nimport java.util.TreeMap\r\nimport java.util.TreeSet\r\nimport java.util.PriorityQueue\r\n// import java.util.*\r\n\r\n@JvmField val INPUT = System.`in`\r\n@JvmField val OUTPUT = System.out\r\n\r\n@JvmField val reader = INPUT.bufferedReader()\r\nfun readLine(): String? = reader.readLine()\r\nfun readLn() = reader.readLine()!!\r\n@JvmField var _tokenizer: StringTokenizer = StringTokenizer(\"\")\r\nfun read(): String {\r\n while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(reader.readLine() ?: return \"\", \" \")\r\n return _tokenizer.nextToken()\r\n}\r\nfun readInt() = read().toInt()\r\nfun readDouble() = read().toDouble()\r\nfun readLong() = read().toLong()\r\nfun readStrings(n: Int) = List(n) { read() }\r\nfun readString() = readStrings(1)[0]\r\nfun readLines(n: Int) = List(n) { readLn() }\r\nfun readInts(n: Int = 2) = List(n) { read().toInt() }\r\nfun readIntArray(n: Int) = IntArray(n) { read().toInt() }\r\nfun readDoubles(n: Int) = List(n) { read().toDouble() }\r\nfun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }\r\nfun readLongs(n: Int = 2) = List(n) { read().toLong() }\r\nfun readLongArray(n: Int) = LongArray(n) { read().toLong() }\r\n\r\n// val isLocal = System.getenv(\"IS_LOCAL_CP\") == \"true\"\r\n\r\n@JvmField\r\nval writer = PrintWriter(OUTPUT)\r\n\r\n// ----------------------------------------------------------------------------\r\n\r\nclass UnionFind {\r\n\r\n private val parents = mutableMapOf()\r\n private val sizes = mutableMapOf()\r\n\r\n fun union(a: Int, b: Int) {\r\n val fa = find(a)\r\n val fb = find(b)\r\n if (fa != fb) {\r\n parents[fa] = fb\r\n sizes[fb] = (sizes[fb] ?: 1) + (sizes[fa] ?: 1)\r\n }\r\n }\r\n\r\n fun find(a: Int): Int {\r\n fun getOrDefault(value: Int) = parents.getOrDefault(value, value)\r\n\r\n var parent = getOrDefault(a)\r\n while (parent != getOrDefault(parent)) {\r\n parents[parent] = getOrDefault(getOrDefault(parent))\r\n parent = parents[parent]!!\r\n }\r\n return parent\r\n }\r\n\r\n fun connected(a: Int, b: Int): Boolean {\r\n return find(a) == find(b)\r\n }\r\n\r\n fun getSize(a: Int): Int {\r\n return sizes[find(a)] ?: 1\r\n }\r\n}\r\n\r\nclass UnionFindArray(private val n: Int) {\r\n\r\n private val parents = IntArray(n + 1) { it }\r\n\r\n fun union(a: Int, b: Int) {\r\n val fa = find(a)\r\n val fb = find(b)\r\n if (fa != fb) {\r\n parents[fa] = fb\r\n }\r\n }\r\n\r\n fun find(a: Int): Int {\r\n var parent = parents[a]\r\n while (parent != parents[parent]) {\r\n parents[parent] = parents[parents[parent]]\r\n parent = parents[parent]\r\n }\r\n return parent\r\n }\r\n\r\n fun connected(a: Int, b: Int): Boolean {\r\n return find(a) == find(b)\r\n }\r\n}\r\n\r\nclass Trie() {\r\n\r\n /** Initialize your data structure here. */\r\n private val root = Node()\r\n\r\n /** Inserts a word into the trie. */\r\n fun insert(word: String) {\r\n var node = root\r\n for (char in word) {\r\n if (!node.children.contains(char)) {\r\n node.children[char] = Node()\r\n }\r\n node = node.children[char]!!\r\n }\r\n node.hasWord = true\r\n }\r\n\r\n /** Returns if the word is in the trie. */\r\n fun search(word: String): Boolean {\r\n return findNode(word)?.hasWord ?: false\r\n }\r\n\r\n /** Returns if there is any word in the trie that starts with the given prefix. */\r\n fun startsWith(prefix: String): Boolean {\r\n return findNode(prefix) != null\r\n }\r\n\r\n private fun findNode(prefix: String): Node? {\r\n var node = root\r\n for (char in prefix) {\r\n node = node.children[char] ?: return null\r\n }\r\n return node\r\n }\r\n\r\n private class Node(\r\n var hasWord: Boolean = false,\r\n val children: MutableMap = mutableMapOf()\r\n )\r\n}\r\n\r\n// 所有函数的下标从 0 开始\r\n// query(index): sum[0, index]\r\nclass BinaryIndexedTree {\r\n\r\n private val bit: IntArray\r\n\r\n constructor(n: Int) {\r\n this.bit = IntArray(n + 1)\r\n }\r\n\r\n constructor(nums: IntArray) {\r\n this.bit = IntArray(nums.size + 1)\r\n val prefix = IntArray(bit.size)\r\n for (i in 1 until nums.size + 1) {\r\n prefix[i] = prefix[i - 1] + nums[i - 1]\r\n bit[i] = prefix[i] - prefix[i - lowbit(i)]\r\n }\r\n }\r\n\r\n fun query(index: Int): Int {\r\n var result = 0\r\n var i = index + 1\r\n while (i > 0) {\r\n result += bit[i]\r\n i -= lowbit(i)\r\n }\r\n return result\r\n }\r\n\r\n fun update(index: Int, x: Int) {\r\n val value = query(index) - query(index - 1)\r\n add(index, x - value)\r\n }\r\n\r\n fun add(index: Int, x: Int) {\r\n var i = index + 1\r\n while (i < bit.size) {\r\n bit[i] += x\r\n i += lowbit(i)\r\n }\r\n }\r\n\r\n override fun toString(): String {\r\n return IntArray(bit.size - 1) { query(it) - query(it - 1) }.toList().toString()\r\n }\r\n\r\n private fun lowbit(x: Int): Int {\r\n return x.and(-x)\r\n }\r\n}\r\n\r\n// 所有函数的下标从 0 开始\r\n// query(index): max[0, index]\r\n// udpate(index, x): 更新 [0, index] 之间的最大值，只能越来越大\r\nclass BinaryIndexedTreeMax {\r\n\r\n private val bit: IntArray\r\n\r\n constructor(n: Int) {\r\n this.bit = IntArray(n + 1)\r\n }\r\n\r\n fun query(index: Int): Int {\r\n var result = 0\r\n var i = index + 1\r\n while (i > 0) {\r\n result = Math.max(result, bit[i])\r\n i -= lowbit(i)\r\n }\r\n return result\r\n }\r\n\r\n fun update(index: Int, x: Int) {\r\n var i = index + 1\r\n while (i < bit.size) {\r\n bit[i] = Math.max(bit[i], x)\r\n i += lowbit(i)\r\n }\r\n }\r\n\r\n private fun lowbit(x: Int): Int {\r\n return x.and(-x)\r\n }\r\n}\r\n\r\nclass SparseTableMax(private val nums: IntArray) {\r\n\r\n private val st: Array\r\n\r\n init {\r\n val n = nums.size\r\n val logN = Integer.numberOfTrailingZeros(Integer.highestOneBit(n))\r\n this.st = Array(n * 2) { IntArray(logN + 1) }\r\n for (i in 0 until n) {\r\n st[i][0] = nums[i]\r\n }\r\n for (j in 1 until logN + 1) {\r\n for (i in 0 until n) {\r\n st[i][j] = st[i][j - 1]\r\n if (i + 1.shl(j - 1) < n) {\r\n st[i][j] = Math.max(st[i][j], st[i + 1.shl(j - 1)][j - 1])\r\n }\r\n }\r\n }\r\n }\r\n\r\n fun query(left: Int, right: Int): Int {\r\n if (left > right) {\r\n return -1\r\n }\r\n val len = right - left + 1\r\n val k = Integer.numberOfTrailingZeros(Integer.highestOneBit(len))\r\n return Math.max(st[left][k], st[right - 1.shl(k) + 1][k])\r\n }\r\n}\r\n\r\nclass SparseTableMin(private val nums: IntArray) {\r\n\r\n private val st: Array\r\n\r\n init {\r\n val n = nums.size\r\n val logN = Integer.numberOfTrailingZeros(Integer.highestOneBit(n))\r\n this.st = Array(n * 2) { IntArray(logN + 1) { Int.MAX_VALUE / 2 } }\r\n for (i in 0 until n) {\r\n st[i][0] = nums[i]\r\n }\r\n for (j in 1 until logN + 1) {\r\n for (i in 0 until n) {\r\n st[i][j] = st[i][j - 1]\r\n if (i + 1.shl(j - 1) < n) {\r\n st[i][j] = Math.min(st[i][j], st[i + 1.shl(j - 1)][j - 1])\r\n }\r\n }\r\n }\r\n }\r\n\r\n fun query(left: Int, right: Int): Int {\r\n if (left > right) {\r\n return -1\r\n }\r\n val len = right - left + 1\r\n val k = Integer.numberOfTrailingZeros(Integer.highestOneBit(len))\r\n return Math.min(st[left][k], st[right - 1.shl(k) + 1][k])\r\n }\r\n}\r\n\r\nclass PrefixSum2D(private val grid: Array) {\r\n\r\n private val prefix: Array\r\n\r\n init {\r\n val (m, n) = Pair(grid.size, grid[0].size)\r\n prefix = Array(m + 1) { IntArray(n + 1) }\r\n for (i in 0 until m) {\r\n var row = 0\r\n for (j in 0 until n) {\r\n row += grid[i][j]\r\n prefix[i + 1][j + 1] = prefix[i][j + 1] + row\r\n }\r\n }\r\n }\r\n\r\n fun query(up: Int, left: Int, bottom: Int, right: Int): Int {\r\n return prefix[up][left] + prefix[bottom + 1][right + 1] -\r\n prefix[bottom + 1][left] - prefix[up][right + 1]\r\n }\r\n}\r\n\r\n// ----------------------------------------------------------------------------\r\n\r\ntypealias Graph = Array>\r\n\r\nprivate fun edgesToGraph(n: Int, edges: Array>, directed: Boolean = false): Graph {\r\n val graph = Array(n) { mutableListOf() }\r\n for ((a, b) in edges) {\r\n graph[a].add(b)\r\n if (!directed) {\r\n graph[b].add(a)\r\n }\r\n }\r\n return graph\r\n}\r\n\r\nprivate fun PrintWriter.printNums(nums: List) {\r\n if (nums.isEmpty()) {\r\n println()\r\n return\r\n }\r\n for (i in 0 until nums.size - 1) {\r\n print(nums[i])\r\n print(' ')\r\n }\r\n println(nums.last())\r\n}\r\n\r\nprivate fun lengthOfLIS(numsInput: List): Int {\r\n val nums = unify(numsInput)\r\n val bit = BinaryIndexedTreeMax(nums.size + 1)\r\n var result = 0\r\n for (num in nums) {\r\n val len = bit.query(num - 1) + 1\r\n bit.update(num, len)\r\n result = Math.max(result, len)\r\n }\r\n return result\r\n}\r\n\r\nprivate fun unify(nums: List): List {\r\n val numToIndex = nums.sorted().mapIndexed { index, num -> num to index }.toMap()\r\n return nums.map { numToIndex[it]!! }\r\n}\r\n\r\nprivate fun fastPow(a: Long, exp: Long, mod: Long): Long {\r\n var result = 1L % mod\r\n var base = a % mod\r\n var remain = exp\r\n while (remain != 0L) {\r\n if (remain % 2L == 1L) {\r\n result = (result * base) % mod\r\n }\r\n base = (base * base) % mod\r\n remain /= 2L\r\n }\r\n return result\r\n}\r\n\r\nprivate fun gcd(a: Int, b: Int): Int {\r\n return if (b == 0) a else gcd(b, a % b)\r\n}\r\n\r\nprivate fun gcdL(a: Long, b: Long): Long {\r\n return if (b == 0L) a else gcdL(b, a % b)\r\n}\r\n\r\nprivate fun lcm(a: Int, b: Int): Int {\r\n return ((a.toLong() * b.toLong()) / gcd(a, b)).toInt()\r\n}\r\n\r\nprivate fun lcmL(a: Long, b: Long): Long {\r\n return (a * b) / gcdL(a, b)\r\n}\r\n\r\nprivate fun wordToCharCount(word: String): IntArray {\r\n val charCount = IntArray(26)\r\n for (char in word) {\r\n charCount[char.toIndex()]++\r\n }\r\n return charCount\r\n}\r\n\r\nprivate fun Char.toIndex(): Int {\r\n return this.toInt() - 'a'.toInt()\r\n}\r\n\r\nprivate fun Char.toDigit(): Int {\r\n return this.toInt() - '0'.toInt()\r\n}\r\n\r\nprivate fun Boolean.toYesNo(upper: Boolean = false): String {\r\n val yesNo = if (this) \"Yes\" else \"No\"\r\n return if (upper) yesNo.toUpperCase() else yesNo\r\n}\r\n\r\nprivate fun LongArray.modSum(mod: Long = MODL): Long {\r\n var sum = 0L\r\n for (num in this) {\r\n sum = (sum + num) % mod\r\n }\r\n return sum\r\n}\r\n\r\nprivate fun IntArray.swap(i: Int, j: Int) {\r\n val temp = this[i]\r\n this[i] = this[j]\r\n this[j] = temp\r\n}\r\n\r\nprivate fun LongArray.swap(i: Int, j: Int) {\r\n val temp = this[i]\r\n this[i] = this[j]\r\n this[j] = temp\r\n}\r\n\r\nprivate fun CharArray.swap(i: Int, j: Int) {\r\n val temp = this[i]\r\n this[i] = this[j]\r\n this[j] = temp\r\n}\r\n\r\nprivate fun List.toArrayDeque(): ArrayDeque {\r\n return ArrayDeque(this)\r\n}\r\n\r\nprivate fun List.toPair(): Pair {\r\n return Pair(this[0], this[1])\r\n}\r\n\r\nprivate fun List.listEquals(other: List): Boolean {\r\n return (0 until this.size).all { this[it] == other[it] }\r\n}\r\n\r\nprivate fun > List.isSorted(): Boolean {\r\n return this.listEquals(this.sorted())\r\n}\r\n\r\nprivate val DIR = listOf(\r\n listOf(1, 0), listOf(0, -1), listOf(-1, 0), listOf(0, 1)\r\n)\r\n\r\nprivate const val MOD = 998244353\r\nprivate const val MODL = 998244353L\r\n// private const val MOD = 1000000007\r\n// private const val MODL = 1000000007L\r\nprivate const val EPS = 0.000001\r\n\r\n// ----------------------------------------------------------------------------\r\n\r\nfun main() {\r\n val go: Runnable = Runnable {\r\n writer.solve()\r\n writer.flush()\r\n }\r\n Thread(null, go, \"thread\", 1L.shl(28)).start()\r\n // writer.solve()\r\n // writer.flush()\r\n}\r\n\r\nprivate fun PrintWriter.solve() {\r\n val n = readInt()\r\n val x = readLong()\r\n println(requiredLen(n, x))\r\n\r\n // test()\r\n}\r\n\r\nprivate fun test() {\r\n // println(ULong.MAX_VALUE)\r\n // println(ULong.MAX_VALUE.toString().length)\r\n\r\n\r\n // var num: ULong = 26u\r\n // while (true) {\r\n // val str = num.toString()\r\n // val len = str.length\r\n // println(\"$len, $str\")\r\n // num *= 6u\r\n // if (len >= 19) {\r\n // break\r\n // }\r\n // }\r\n\r\n val random = Random(12345L)\r\n repeat(100) {\r\n // val n = random.nextInt(18) + 2\r\n // var max = 1L\r\n // repeat(n - 1) {\r\n // max *= 10L\r\n // }\r\n // val x = random.nextLong(max - 2L) + 1L\r\n val n = 10\r\n val x = random.nextLong(1000L) + 1L\r\n\r\n val r1 = requiredLen(n, x)\r\n val r2 = requiredLen1(n, x)\r\n if (r1 != r2) {\r\n println(\"$n, $x. $r1, $r2\")\r\n }\r\n }\r\n}\r\n\r\nprivate fun requiredLen(n: Int, x: Long): Int {\r\n val MAX = 10000\r\n val queue = listOf(x).toArrayDeque()\r\n var step = 0\r\n while (queue.isNotEmpty()) {\r\n val next = mutableListOf()\r\n while (queue.isNotEmpty()) {\r\n val num = queue.removeFirst()\r\n if (num < 0L) {\r\n return step\r\n }\r\n val str = num.toString()\r\n if (str.length == n) {\r\n return step\r\n }\r\n if (str.length > n) {\r\n continue\r\n }\r\n val digits = BooleanArray(10)\r\n for (char in str) {\r\n val d = char.toDigit()\r\n if (d <= 1 || digits[d]) {\r\n continue\r\n }\r\n digits[d] = true\r\n next.add(num * d)\r\n }\r\n }\r\n next.sortBy { -it }\r\n queue.addAll(next.subList(0, Math.min(MAX, next.size)))\r\n step++\r\n }\r\n return -1\r\n}\r\n\r\nprivate fun requiredLen1(n: Int, x: Long): Int {\r\n val queue = listOf(x).toArrayDeque()\r\n var step = 0\r\n while (queue.isNotEmpty()) {\r\n val nextQueue = ArrayDeque>()\r\n var maxLen = 0\r\n while (queue.isNotEmpty()) {\r\n val num = queue.removeFirst()\r\n if (num < 0L) {\r\n return step\r\n }\r\n val str = num.toString()\r\n if (str.length == n) {\r\n return step\r\n }\r\n if (str.length > n) {\r\n continue\r\n }\r\n val digits = BooleanArray(10)\r\n for (char in str) {\r\n digits[char.toDigit()] = true\r\n }\r\n for (d in 2 until 10) {\r\n if (!digits[d]) {\r\n continue\r\n }\r\n val nextNum = num * d\r\n val nextStr = nextNum.toString()\r\n nextQueue.addLast(Pair(nextNum, nextStr))\r\n maxLen = Math.max(maxLen, nextStr.length)\r\n }\r\n }\r\n for ((num, str) in nextQueue) {\r\n // if (str.length >= maxLen - 3) {\r\n queue.addLast(num)\r\n // }\r\n }\r\n step++\r\n // println(queue)\r\n }\r\n return -1\r\n}\r\n", "lang_cluster": "Kotlin", "tags": ["brute force", "dfs and similar", "shortest paths", "dp", "data structures"], "code_uid": "ec778129d58543dd0bb0505a7304e91f", "src_uid": "cedcc3cee864bf8684148df93804d029", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.BufferedReader\nimport java.io.InputStream\nimport java.io.InputStreamReader\nimport java.util.*\nimport kotlin.collections.ArrayList\nimport kotlin.math.sqrt\n\n\nfun main() {\n val sc = Scanner.sysIn\n\n val x = sc.nextInt()\n val n = sc.nextLong()\n\n val primes = ArrayList()\n\n fun isPrime(k: Int): Boolean {\n if (k == 1) return false\n if (k == 2 || k == 3) return true\n for (i in 2..sqrt(k.toDouble()).toInt()) {\n if (k % i == 0) {\n return false\n }\n }\n return true\n\n }\n\n for (i in 2..sqrt(x.toDouble()).toInt()) {\n if (x % i == 0) {\n if (isPrime(i) && !primes.contains(x / i))\n primes += i\n if (isPrime(x / i) && !primes.contains(x / i))\n primes += x / i\n }\n }\n if (isPrime(x)) primes += x\n\n //primes.forEach { println(it) }\n\n val mod = 1000000007\n fun power(x: Long, p: Long): Long = when {\n p == 0L -> 1\n p == 1L -> x % mod\n p % 2 == 0L -> {\n val cur = power(x, p / 2)\n (cur * cur) % mod\n }\n else -> (power(x, p - 1) * x) % mod\n }\n\n var ans = 1L\n\n for (p in primes) {\n var curP = p.toLong()\n while (n / curP > 0) {\n //println(curP)\n ans = (ans * power(p.toLong(), n / curP)) % mod\n if ((curP * p) / p != curP) break\n curP *= p\n }\n }\n\n println(ans)\n}\n\nclass Scanner(s: InputStream) {\n var st: StringTokenizer? = null\n val br: BufferedReader = BufferedReader(InputStreamReader(s))\n\n operator fun next(): String {\n while (st == null || !st!!.hasMoreTokens())\n st = StringTokenizer(br.readLine())\n return st!!.nextToken()\n }\n\n fun nextInt(): Int {\n return Integer.parseInt(next())\n }\n\n fun nextLong(): Long {\n return java.lang.Long.parseLong(next())\n }\n\n fun nextLine(): String {\n return br.readLine()\n }\n\n fun nextDouble(): Double {\n return java.lang.Double.parseDouble(next())\n }\n\n companion object {\n val sysIn = Scanner(System.`in`)\n }\n\n}\n\nval rnd = Random()\nfun IntArray.sort() {\n val n = this.size\n for (i in 0 until n - 1) {\n val randomPos = i + rnd.nextInt(n - i - 1) + 1\n this[i] = this[i] xor this[randomPos]\n this[randomPos] = this[randomPos] xor this[i]\n this[i] = this[i] xor this[randomPos]\n }\n Arrays.sort(this)\n}\n\nfun LongArray.sort() {\n val n = this.size\n for (i in 0 until n - 1) {\n val randomPos = i + rnd.nextInt(n - i - 1) + 1\n this[i] = this[i] xor this[randomPos]\n this[randomPos] = this[randomPos] xor this[i]\n this[i] = this[i] xor this[randomPos]\n }\n Arrays.sort(this)\n}", "lang_cluster": "Kotlin", "tags": ["math", "number theory"], "code_uid": "7ce8913db7b2da5e742ee214db1c4887", "src_uid": "04610fbaa746c083dda30e21fa6e1a0c", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main(){\n readLine()!!\n val s = readLine()!!\n\n var d = 0\n for (c in s){\n if (c=='+'){\n d++\n }else{\n if (d==0) d=1\n d--\n }\n\n }\n println(d)\n}", "lang_cluster": "Kotlin", "tags": ["math", "implementation"], "code_uid": "6eb1c293cfb8de95d5835960db6aac9d", "src_uid": "a593016e4992f695be7c7cd3c920d1ed", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.BufferedInputStream\nimport java.util.*\n\nfun main(args: Array) {\n val scanner = Scanner(BufferedInputStream(System.`in`))\n\n val n = scanner.nextLong()\n val k = scanner.nextLong()\n\n if (k <= n + 1) {\n println((k - 1) / 2)\n return\n }\n\n if (k >= n * 2) {\n println(0)\n return\n }\n\n if (k % 2 == 1L) {\n println(n - k / 2)\n return\n } else {\n println(n - k / 2)\n return\n }\n}\n", "lang_cluster": "Kotlin", "tags": ["math"], "code_uid": "d3100365ee060af86e7744595d1acefb", "src_uid": "98624ab2fcd2a50a75788a29e04999ad", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Kotlin 1.4", "source_code": "private fun readLn() = readLine()!!\r\nprivate fun readInt() = readLn().toInt()\r\nprivate fun readStrings() = readLn().split(\" \") \r\nprivate fun readInts() = readStrings().map{it.toInt()} \r\n\r\nfun main() {\r\n val (n, MOD) = readInts()\r\n fun add (x : Long, y : Long) : Long = if (x + y < MOD) x + y else x + y - MOD\r\n fun sub (x : Long, y : Long) : Long = if (x < y) x - y + MOD else x - y\r\n val DP = Array(n + 1){LongArray(0){0}}\r\n DP[0] = LongArray(1){1}\r\n for (i in 1..n) {\r\n val dim = i * (i - 1) / 2\r\n DP[i] = LongArray(dim + 1){0}\r\n var sum = 0L\r\n for (j in 0..dim) {\r\n if (j < DP[i - 1].size) sum = add(sum, DP[i - 1][j])\r\n DP[i][j] = sum\r\n if (j >= i - 1) sum = sub(sum, DP[i - 1][j - i + 1])\r\n }\r\n }\r\n val pf = LongArray(n * n){0}\r\n var ans = 0L\r\n for (cut in 2 until n) {\r\n val dim = cut * (cut - 1) / 2\r\n for (i in 1..dim) pf[i] = add(pf[i - 1], DP[cut][i])\r\n fun range (l : Int, r : Int) : Long {\r\n if (l > minOf(r, dim)) return 0L\r\n return sub(pf[minOf(r, dim)], if (l > 0) pf[l - 1] else 0)\r\n }\r\n var (tot, aux, sum) = arrayOf(0L, 0L, 0L)\r\n for (x in dim downTo 0) {\r\n val yo = (range(x + cut + 1, dim) * (cut * (cut + 1) / 2) + sum) % MOD\r\n tot = add(tot, DP[cut][x] * yo % MOD)\r\n if (x + cut <= dim) sum = sub(sum, DP[cut][x + cut] * (cut * (cut + 1) / 2 - 1) % MOD)\r\n sum = add(sum, aux)\r\n if (x + cut - 1 <= dim) aux = sub(aux, DP[cut][x + cut - 1] * 2 % MOD)\r\n aux = add(aux, DP[cut][x] * (cut + 1) % MOD)\r\n aux = sub(aux, range(x, x + cut - 2))\r\n }\r\n for (i in (cut + 2)..n) tot = tot * i % MOD\r\n ans = add(ans, tot)\r\n }\r\n println(ans)\r\n}", "lang_cluster": "Kotlin", "tags": ["math", "dp", "combinatorics", "fft"], "code_uid": "a0bb1b0e08f291b314bac0d3058ad7ee", "src_uid": "ae0320a57d73fab1d05f5d10fbdb9e1a", "difficulty": 2400.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.lang.AssertionError\nimport java.util.*\n \nprivate fun readLn() = readLine()!! // string line\nprivate fun readInt() = readLn().toInt() // single int\nprivate fun readLong() = readLn().toLong() // single long\nprivate fun readDouble() = readLn().toDouble() // single double\nprivate fun readStrings() = readLn().split(\" \") // list of strings\nprivate fun readInts() = readStrings().map { it.toInt() } // list of ints\nprivate fun readLongs() = readStrings().map { it.toLong() } // list of longs\nprivate fun readDoubles() = readStrings().map { it.toDouble() } // list of doubles\n \nprivate fun myAssert(x: Boolean) {\n if (!x) {\n throw AssertionError()\n }\n}\n\nfun main(args: Array) {\n// var s = Scanner(System.`in`)\n var (n, t, k, d) = readInts()\n // t minutes for an over to bake k carrot cakes\n // needs at least n cakes\n // d minutes to build a new oven\n // 8 6 4 5\n // 6 minutes to make 4 cakes, 5 minutes to build a new oven\n var tt = t\n var kk = k\n while (kk < n) {\n kk += k\n tt += t\n }\n if (t + d < tt) {\n println(\"YES\")\n } else {\n println(\"NO\")\n }\n}\n", "lang_cluster": "Kotlin", "tags": ["brute force", "implementation"], "code_uid": "204405ba1a8b8918954169d3b1f89d93", "src_uid": "32c866d3d394e269724b4930df5e4407", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import kotlin.math.min\n\nfun main() {\n val (n , m) = readLine()!!.split(' ').map(String::toInt)\n println(doIt(n, m))\n}\n\nfun doIt(n: Int, m: Int): Int {\n return if (m == 0) 1 else min(m, n - m)\n}\n", "lang_cluster": "Kotlin", "tags": ["math", "greedy"], "code_uid": "58b596cf5a4bf793cbbe039845f4ef0d", "src_uid": "c05d0a9cabe04d8fb48c76d2ce033648", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.*\nimport java.util.*\nimport kotlin.math.*\n\nfun main(){\n\tval f = BufferedReader(InputStreamReader(System.`in`))\n\n\tval a = f.readLine().map{Character.getNumericValue(it)}.toIntArray()\n\n\tval sum1 = a[0] + a[1] + a[2]\n\tval sum2 = a[3] + a[4] + a[5]\n\n\tif(sum1 == sum2) println(0)\n\telse{\n\n\t\tval a1 = IntArray(3){a[it]}.sorted()\n\t\tval a2 = IntArray(3){a[it+3]}.sorted()\n\n\t\tval changes = IntArray(6)\n\t\t//check 1\n\t\tif(sum1 > sum2){\n\t\t\t//get max 3\n\t\t\tfor(k in 0 until 3){\n\t\t\t\tchanges[k] = a1[k]\n\t\t\t\tchanges[k+3] = 9-a2[k]\n\t\t\t}\n\t\t} else {\n\t\t\tfor(k in 0 until 3){\n\t\t\t\tchanges[k] = a2[k]\n\t\t\t\tchanges[k+3] = 9-a1[k]\n\t\t\t}\n\t\t}\n\n\t\tchanges.sort()\n\n\t\tval dif = Math.abs(sum1-sum2)\n\n\t\tvar sumdif = 0\n\t\tvar answer = 0\n\t\tvar i = 5\n\t\twhile(sumdif < dif){\n\t\t\tsumdif += changes[i]\n\t\t\ti--\n\t\t\tanswer++\n\t\t}\n\n\t\tprintln(answer)\n\t}\n}\n", "lang_cluster": "Kotlin", "tags": ["brute force", "greedy", "implementation"], "code_uid": "f18976ccb526712c03944c72a5342b09", "src_uid": "09601fd1742ffdc9f822950f1d3e8494", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "import java.io.*\nimport java.util.*\nimport kotlin.collections.*\nimport kotlin.math.*\n\nval maxn = 200005\nval sz = 1024 * 1024\nval inf0 = 2e9\nval inf = inf0.toInt()\nval INF0 = 4e18\nval INF = INF0.toLong()\nval eps = 1e-6\nval MOD = 998244353L\n\nfun solve() {\n val n = nextLong()\n val k = nextLong()\n val m = nextLong()\n val d = nextInt()\n var ans = 0L\n for (i in 1..d) {\n val num1 = k * (i - 1) + 1\n val num2 = k * i\n if (num1 > n) break\n //x * num1 <= n <= x * (num2 + 1) - 1\n //n + 1 <= x * (num2 + 1)\n val xl = divup(n + 1, num2 + 1)\n val xr = n / num1\n if (m >= xl) ans = max(ans, min(xr, m) * i)\n }\n println(ans)\n}\n\nval multitest = false\n\nfun main() {\n var t = 1\n if (multitest) t = nextInt()\n for (i in 1..t) solve()\n out.flush()\n}\n\nfun maxPair(a: Pair, b: Pair): Pair {\n if (a.first > b.first) return a\n if (b.first > a.first) return b\n if (a.second > b.second) return a\n return b\n}\n\nfun back(a: ArrayList): Int {\n return a[a.size - 1]\n}\n\n//val t = IntArray(2 * sz)\n//val t = Array(2 * sz) { ArrayList() }\n\n/*\nfun add(v: Int, vl: Int, vr: Int, x: Int, y: Int) {\n if (vl == vr) {\n t[v].add(y)\n return\n }\n val vm = (vl + vr) / 2\n if (x <= vm)\n add(v * 2 + 1, vl, vm, x, y)\n else\n add(v * 2 + 2, vm + 1, vr, x, y)\n}\n\nfun build() {\n //for (i in (sz - 1)..(2 * sz - 2)) t[i].sort()\n var i = sz - 2\n while (i >= 0) {\n val n1 = t[2 * i + 1].size\n val n2 = t[2 * i + 2].size\n var i1 = 0\n var i2 = 0\n for (j in 1..(n1 + n2)) {\n if (i1 == n1) {\n t[i].add(t[2 * i + 2][i2++])\n } else if (i2 == n2) {\n t[i].add(t[2 * i + 1][i1++])\n } else {\n if (t[2 * i + 1][i1] < t[2 * i + 2][i2])\n t[i].add(t[2 * i + 1][i1++])\n else\n t[i].add(t[2 * i + 2][i2++])\n }\n }\n i--\n }\n}\n\nfun query(v: Int, vl: Int, vr: Int, lx: Int, rx: Int): Int {\n if (vl > rx || lx > vr) return 0\n if (vl >= lx && vr <= rx) {\n if (t[v].isEmpty()) return 0\n //return upperBound(t[v], ry) - lowerBound(t[v], ly)\n return upperBound(t[v], rx)\n }\n val vm = (vl + vr) / 2\n return query(v * 2 + 1, vl, vm, lx, rx) +\n query(v * 2 + 2, vm + 1, vr, lx, rx)\n}\n\n */\n\n/*\n\nfun upd(v: Int, vl: Int, vr: Int, i: Int, x: Int) {\n if (i < vl || i > vr) return\n if (vl == vr) {\n t[v] = x\n return\n }\n val vm = (vl + vr) / 2\n upd(v * 2 + 1, vl, vm, i, x)\n upd(v * 2 + 2, vm + 1, vr, i, x)\n t[v] = max(t[v * 2 + 1], t[v * 2 + 2])\n}\n\n*/\n\n/*\n\nfun query(v: Int, vl: Int, vr: Int, l: Int, r: Int): Int {\n if (vl > r || l > vr) return -1\n if (vl >= l && vr <= r) return t[v]\n val vm = (vl + vr) / 2\n return max(query(v * 2 + 1, vl, vm, l, r), query(v * 2 + 2, vm + 1, vr, l, r))\n}\n\n */\n\nfun upperBound(a: ArrayList, x: Int): Int {\n if (a[0] > x) return 0\n if (back(a) <= x) return a.size\n var l = 0\n var r = a.size - 1\n while (l != r) {\n val m = (l + r) / 2\n if (a[m] > x) r = m else l = m + 1\n }\n return l\n}\n\nfun lowerBound(a: ArrayList, x: Int): Int {\n if (back(a) < x) return a.size\n var l = 0\n var r = a.size - 1\n while (l != r) {\n val m = (l + r) / 2\n if (a[m] >= x) r = m else l = m + 1\n }\n return l\n}\n\n/*\n\nval fact = LongArray(maxn)\nval invfact = LongArray(maxn)\n\nfun calcFactorials() {\n fact[0] = 1\n for (i in 1..maxn - 1) fact[i] = (fact[i - 1] * i.toLong()) % MOD\n for (i in 0..maxn - 1) invfact[i] = powmod(fact[i], MOD - 2, MOD)\n}\n\nfun cnk(n: Int, k: Int, m: Long): Long {\n return ((fact[n] * invfact[k]) % m) * invfact[n - k] % m\n}\n\n*/\n\nfun powmod(x: Long, d: Long, m: Long): Long {\n if (d == 0L) return 1\n if (d % 2 == 0L) {\n val y = powmod(x, d / 2, m)\n return (y * y) % m\n }\n return x * powmod(x, d - 1, m) % m\n}\n\nfun divup(x: Int, y: Int): Int {\n return (x + y - 1) / y\n}\n\nfun divup(x: Long, y: Long): Long {\n return (x + y - 1) / y\n}\n\nfun gcd(x: Long, y: Long): Long {\n if (x == 0L || y == 0L) return x + y\n if (x > y) return gcd(x % y, y)\n return gcd(y % x, x)\n}\n\nfun end() {\n out.flush()\n System.exit(0)\n}\n\nfun printIntArray(a: IntArray) {\n for (x in a) print(\"$x \")\n print(\"\\n\")\n}\n\nfun printIntArrayList(a: ArrayList) {\n for (x in a) print(\"$x \")\n print(\"\\n\")\n}\n\nfun nextInt() = next().toInt()\nfun nextLong() = next().toLong()\nfun nextDouble() = next().toDouble()\n\nval reader = BufferedReader(InputStreamReader(System.`in`))\nval out = PrintWriter(System.out, false)\nvar tokenizer = StringTokenizer(\"\")\n\nfun println(o: Any) = out.println(o)\nfun print(o: Any) = out.print(o)\n\nfun next(): String {\n while (!tokenizer.hasMoreTokens())\n tokenizer = StringTokenizer(reader.readLine())\n return tokenizer.nextToken()\n}\n\nfun increase(map: HashMap, k: Int) {\n map[k] = 1 + if (map.containsKey(k)) map[k]!! else 0\n}\n\nfun decrease(map: HashMap, k: Int) {\n map[k] = -1 + if (map.containsKey(k)) map[k]!! else 0\n}", "lang_cluster": "Kotlin", "tags": ["math"], "code_uid": "c703801fd1b7ed196b37dc0f2c48d7dd", "src_uid": "ac2e795cd44061db8da13e3947ba791b", "difficulty": 2000.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "fun main() {\n val r = System.`in`.bufferedReader()\n val s = StringBuilder()\n //val len = r.readLine()!!.toInt()\n //val (len, k) = r.readLine()!!.split(\" \").map { it.toInt() }\n val (a, b, c) = r.readLine()!!.split(\" \").map { it.toInt() }\n val d = minOf(a+b+c, 2*a+2*b)\n val e = minOf(2*(a+c), 2*(b+c))\n println(minOf(d, e))\n}", "lang_cluster": "Kotlin", "tags": ["implementation"], "code_uid": "b2f4bf4c909cfeeb314ce3f772468508", "src_uid": "26cd7954a21866dbb2824d725473673e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "/**\n * Created by enitihas on 20/6/17.\n */\nimport java.io.BufferedReader\nimport java.io.InputStream\nimport java.io.InputStreamReader\nimport java.io.PrintWriter\nimport java.util.*\n\n/**\n * Created by enitihas on 20/6/17.\n */\nfun main(args: Array) {\n val sc = Scanner(BufferedReader(InputStreamReader(System.`in`)))\n val pw = PrintWriter(System.out)\n solve(sc,pw)\n sc.close()\n pw.close()\n}\n\nfun solve(sc: Scanner, pw: PrintWriter) {\n val n = sc.nextInt()\n val x = sc.nextInt()\n var ans = -1\n val moves = n%6\n val balls = intArrayOf(0,0,0)\n balls[x] = 1\n for (i in moves downTo 1) {\n if(i%2==0) {\n val temp = balls[2]\n balls[2] = balls[1]\n balls[1] = temp\n }\n else {\n val temp = balls[1]\n balls[1] = balls[0]\n balls[0] = temp\n }\n }\n ans = balls.indexOf(1)\n println(ans)\n}\n", "lang_cluster": "Kotlin", "tags": ["math", "constructive algorithms", "implementation"], "code_uid": "2aa828f87b5be2eef09beef0c7802570", "src_uid": "7853e03d520cd71571a6079cdfc4c4b0", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Kotlin", "source_code": "const val MOD = 1000000007L\n\nfun main() {\n val n = readLine()!!.toInt()\n val factorial = LongArray(n + 1)\n factorial[0] = 1L\n for (j in 1..n) {\n factorial[j] = (j.toLong() * factorial[j - 1]) % MOD\n }\n val factInv = LongArray(n + 1) { factorial[it] pow -1 }\n fun permute(a: Int, b: Int) = (factorial[a] * factInv[b]) % MOD\n fun arrange(a: Int, b: Int): Long {\n val here = n / a\n val above = here / b\n return ((here - above).toLong() * permute(n - above - 1, n - here)) % MOD\n }\n var lg = 0\n while (1 shl lg <= n) {\n lg++\n }\n lg--\n var curr = 1L\n for (e in 0..lg) {\n curr *= arrange(1 shl e, 2)\n curr %= MOD\n }\n var answer = curr\n if (n >= 3 * (1 shl (lg - 1))) {\n for (e in lg downTo 1) {\n curr *= arrange(1 shl e, 3) pow -1\n curr %= MOD\n curr *= arrange(3 * (1 shl (e - 1)), 2)\n curr %= MOD\n curr *= arrange(1 shl (e - 1), 2) pow -1\n curr %= MOD\n curr *= arrange(1 shl (e - 1), 3)\n curr %= MOD\n answer += curr\n }\n answer %= MOD\n }\n println(answer)\n}\n\nval MOD_TOTIENT = (MOD - 1).toInt()\n\ninfix fun Long.pow(power: Int): Long {\n var e = power\n e %= MOD_TOTIENT\n if (e < 0) {\n e += MOD_TOTIENT\n }\n if (e == 0 && this == 0L) {\n return this\n }\n var b = this % MOD\n var res = 1L\n while (e > 0) {\n if (e and 1 != 0) {\n res *= b\n res %= MOD\n }\n b *= b\n b %= MOD\n e = e shr 1\n }\n return res\n}", "lang_cluster": "Kotlin", "tags": ["math", "dp", "combinatorics", "number theory"], "code_uid": "77050f7e360b8f72b7195a2c670de016", "src_uid": "b2d59b1279d891dba9372a52364bced2", "difficulty": 2500.0, "exec_outcome": "PASSED"}