---

fun containsNumber(
    array: ArrayList<Int>,
    number: Int
): Boolean {

    for (item in array) {

        if (item == number) {
            return true
        }
    }

    return false
}


fun main() {

    val array1 = arrayOf(
        5, 3, 8, 1, 2,
        7, 4, 9, 6, 10,
        3, 5, 2, 8, 1
    )

    val array2 = arrayOf(
        15, 12, 11, 14, 13,
        10, 9, 8, 7, 6,
        5, 4, 3, 2, 1
    )


    // ----------------------------
    // СПОСОБ 1
    // ----------------------------

    val result1 = ArrayList<Int>()

    for (number in array1) {

        if (!result1.contains(number)) {
            result1.add(number)
        }
    }

    for (number in array2) {

        if (!result1.contains(number)) {
            result1.add(number)
        }
    }

    result1.sort()

    println("Способ 1:")
    println(result1)


    // ----------------------------
    // СПОСОБ 2
    // ----------------------------

    val result2 = ArrayList<Int>()

    for (number in array1) {

        if (!containsNumber(result2, number)) {
            result2.add(number)
        }
    }

    for (number in array2) {

        if (!containsNumber(result2, number)) {
            result2.add(number)
        }
    }


    // Пузырьковая сортировка

    for (i in 0 until result2.size - 1) {

        for (j in 0 until result2.size - i - 1) {

            if (result2[j] > result2[j + 1]) {

                val temp = result2[j]

                result2[j] = result2[j + 1]

                result2[j + 1] = temp
            }
        }
    }

    println("Способ 2:")
    println(result2)
}



fun findSubArray(
    array: Array<Int>,
    k: Int
): Int {

    for (start in array.indices) {

        var sum = 0

        for (end in start until array.size) {

            sum += array[end]

            if (sum == k) {
                return start
            }
        }
    }

    return -1
}


fun main() {

    val array = Array(50) { i ->
        i + 1
    }

    val k = 42

    val index = findSubArray(array, k)

    println("Индекс первого вхождения подмассива = $index")
}


import kotlin.random.Random


fun maxDifferenceBuiltIn(array: Array<Int>): Int {

    var maxDifference = Int.MIN_VALUE

    for (i in 0 until array.size - 1) {

        val rightPart =
            array.copyOfRange(i + 1, array.size)

        val maxAfter =
            rightPart.maxOrNull()!!

        val difference =
            maxAfter - array[i]

        if (difference > maxDifference) {
            maxDifference = difference
        }
    }

    return maxDifference
}


fun maxDifferenceManual(array: Array<Int>): Int {

    var min = array[0]

    var maxDifference =
        array[1] - array[0]

    for (i in 1 until array.size) {

        val difference =
            array[i] - min

        if (difference > maxDifference) {
            maxDifference = difference
        }

        if (array[i] < min) {
            min = array[i]
        }
    }

    return maxDifference
}


fun main() {

    val array = Array(100) {
        Random.nextInt(-100, 101)
    }

    println("Массив:")
    println(array.joinToString())

    println()
    println(
        "Способ 1: ${maxDifferenceBuiltIn(array)}"
    )

    println(
        "Способ 2: ${maxDifferenceManual(array)}"
    )
}


fun countManual(
    array: Array<Int>,
    number: Int
): Int {

    var count = 0

    for (item in array) {

        if (item == number) {
            count++
        }
    }

    return count
}


fun main() {

    val array = arrayOf(
        3, 7, 2, 7, 3,
        1, 2, 7, 1, 3,
        5, 5, 7, 3, 2,
        1, 5, 7, 3, 2
    )


    // -----------------------
    // СПОСОБ 1
    // -----------------------

    val result1 = array.copyOf()

    result1.sortWith(
        compareByDescending<Int> { number ->

            array.count { it == number }

        }.thenBy { number ->

            number
        }
    )

    println("Способ 1:")
    println(result1.joinToString())


    // -----------------------
    // СПОСОБ 2
    // -----------------------

    val result2 = array.copyOf()

    for (i in 0 until result2.size - 1) {

        for (j in 0 until result2.size - i - 1) {

            val first = result2[j]
            val second = result2[j + 1]

            val firstCount =
                countManual(array, first)

            val secondCount =
                countManual(array, second)


            if (
                firstCount < secondCount ||
                firstCount == secondCount &&
                first > second
            ) {

                val temp = result2[j]

                result2[j] = result2[j + 1]

                result2[j + 1] = temp
            }
        }
    }


    println("Способ 2:")
    println(result2.joinToString())
}