View difference between Paste ID: iP1kVw4R and bqBYmQYg

 package ru
 
 import java.util.concurrent.atomic.LongAdder
 import kotlin.math.absoluteValue
 
 private const val BOARD_SIZE = 15
 private val counter = LongAdder()
 
 fun main(args: Array<String>) {
     val board = IntArray(BOARD_SIZE)
     val start = System.nanoTime()
     try {
         successfulComb(intArrayOf(), board)
     } catch (e: Exception) {
     }
     println(System.nanoTime() - start)
     println(counter.sum())
 
 }
 
 tailrec fun successfulComb(head: IntArray, tail: IntArray): IntArray {
     if (tail.isEmpty()) {
-        if (head[0] > 7) throw IllegalArgumentException()
+
     } else {
         for (i in 0 until BOARD_SIZE) {
             if (!fights(head, i)) return successfulComb(head + i, tail.copyOfRange(1,tail.size))
-            if (!fights(head, i)) return successfulComb(head + i, tail.sliceArray(1 until tail.size))
+
     }
     val newHead = prepareNextIteraion(head, tail)
     return successfulComb(newHead, IntArray(BOARD_SIZE - newHead.size))
 }
 
 private fun prepareNextIteraion(head: IntArray, tail: IntArray): IntArray {
     resetHead(head)
     tail.fill(0)
     val count = findLastZeroesCount(head)
     return head.copyOfRange(0, head.size - count)
-    return head.sliceArray(0 until head.size - count)
+
 
 fun findLastZeroesCount(head: IntArray): Int {
     var count = 0
     for (i in head.size - 1 downTo 0) {
         if (head[i] == 0) count++
         else break
     }
     return count
 }
 
 fun resetHead(head: IntArray) {
     for (i in head.size - 1 downTo 0) {
         do {
             head[i]++
         } while (head[i] < BOARD_SIZE && fights(head.copyOfRange(0, i), head[i]))
-        } while (head[i] < BOARD_SIZE && fights(head.sliceArray(0 until i), head[i]))
+
         head.fill(0, i + 1, head.size)
-        for (j in i + 1 until head.size) {
+
-            head[j] = 0
+
     }
     throw IllegalArgumentException()
 }
 
 fun fights(head: IntArray, position: Int): Boolean {
     for (index in head.indices) {
         if (head[index] == position) return true
         if ((head[index] - position).absoluteValue == (index - head.size).absoluteValue) return true
     }
     return false
 }