Funktionen und Rekursion in Kotlin 1.9: Eine ausführliche Anleitung

Функции и рекурсия в Kotlin

Что такое функция и зачем она нужна?

Представь, что ты учишься печь пирожки. Каждый раз, когда хочешь пирожок, ты не изобретаешь рецепт заново, а просто берешь готовый рецепт и повторяешь действия. В программировании функция — это такой же «рецепт»: кусок кода, который делает одно конкретное дело и может быть вызван в любой момент.

Зачем это нужно?

• Не повторяться. Если нужно 10 раз посчитать сумму, не надо писать один и тот же код 10 раз.
• Проще читать. Вместо длинного кода — понятные названия действий.
• Легко исправлять. Ошибка в одном месте — исправил в функции, и всё заработало.

Основной синтаксис функций в Kotlin

Функция в Kotlin начинается со слова fun. Дальше идет имя, в скобках — параметры (то, что мы передаем в функцию), а после скобок — тип результата, который функция возвращает.

fun имяФункции(параметр1: Тип, параметр2: Тип): ТипРезультата {
    // тело функции
    return результат
}

Если функция ничего не возвращает, пишем Unit (или просто ничего не пишем).

Пример 1: Сумма двух чисел (семейный бюджет)

Напишем функцию, которая принимает два числа (доходы) и возвращает их сумму.

fun summa(dohod1: Int, dohod2: Int): Int {
    return dohod1 + dohod2
}

fun main() {
    println("Введите первый доход:")
    val a = readLine()!!.toInt()
    println("Введите второй доход:")
    val b = readLine()!!.toInt()
    println("Общая сумма: ${summa(a, b)}")
}

Как это работает: Мы создали «рецепт» summa, который складывает два числа. В main мы просим пользователя ввести числа, а потом вызываем функцию и печатаем результат.

Пример 2: Сравнение температур

Функция принимает две температуры и возвращает большую.

fun bolshayaTemp(t1: Double, t2: Double): Double {
    if (t1 > t2) {
        return t1
    } else {
        return t2
    }
}

fun main() {
    println("Введите первую температуру:")
    val a = readLine()!!.toDouble()
    println("Введите вторую температуру:")
    val b = readLine()!!.toDouble()
    println("Большая температура: ${bolshayaTemp(a, b)}")
}

Пример 3: Проверка четности числа

Функция проверяет, четное ли число (делится ли на 2 без остатка).

fun proverkaChetnosti(chislo: Int): Boolean {
    return chislo % 2 == 0
}

fun main() {
    println("Введите количество коробок:")
    val n = readLine()!!.toInt()
    if (proverkaChetnosti(n)) {
        println("Число четное, можно упаковать в пары.")
    } else {
        println("Число нечетное, одна коробка лишняя.")
    }
}

Пример 4: Реверс строки

Функция переворачивает строку задом наперед.

fun revers(stroka: String): String {
    var result = ""
    for (i in stroka.length - 1 downTo 0) {
        result += stroka[i]
    }
    return result
}

fun main() {
    println("Введите сообщение:")
    val text = readLine()!!
    println("Перевернутое сообщение: ${revers(text)}")
}

Пример 5: Поиск минимального элемента в списке

Функция находит самую низкую температуру за день.

fun minimumTemp(temperaturi: List<Double>): Double {
    var min = temperaturi[0]
    for (t in temperaturi) {
        if (t < min) {
            min = t
        }
    }
    return min
}

fun main() {
    println("Введите температуры через пробел:")
    val input = readLine()!!
    val listTemp = input.split(" ").map { it.toDouble() }
    println("Минимальная температура: ${minimumTemp(listTemp)}")
}

Рекурсия — функция вызывает саму себя

Рекурсия — это когда функция внутри своего кода вызывает саму себя. Представь матрешку: большая матрешка открывается, внутри — такая же, но поменьше, и так до самой маленькой. Рекурсия работает похоже: большая задача разбивается на такую же, но чуть проще.

Чтобы рекурсия не была бесконечной, обязательно нужно условие остановки — момент, когда функция перестает вызывать себя.

Пример рекурсии: факториал числа

Факториал числа 5 (обозначается 5!) — это 5 × 4 × 3 × 2 × 1. Можно посчитать так: 5! = 5 × 4!, а 4! = 4 × 3! и так далее. 1! = 1 — это условие остановки.

fun factorial(n: Int): Int {
    return if (n == 1) {
        1  // условие остановки
    } else {
        n * factorial(n - 1)  // рекурсивный вызов
    }
}

fun main() {
    println("Введите число:")
    val chislo = readLine()!!.toInt()
    println("Факториал числа $chislo = ${factorial(chislo)}")
}

Как это работает: factorial(5) считает: «5 × factorial(4)». factorial(4) считает: «4 × factorial(3)». И так до factorial(1), который просто возвращает 1. Потом все результаты собираются обратно: 1 × 2 × 3 × 4 × 5 = 120.

Частые ошибки новичков

• Забыли return. Если функция должна возвращать значение, а return не написали — будет ошибка.
• Бесконечная рекурсия. Нет условия остановки — программа зависнет или упадет с ошибкой.
• Путают параметры и аргументы. Параметры — это то, что написано в определении функции (в скобках). Аргументы — это конкретные значения, которые мы передаем при вызове.
• Имена функций. Называйте функции понятно: summa, revers, а не f1, func2.

Итоговый пример: задача про бюджет и температуру

Представь, что у тебя есть данные о доходах за неделю и о температуре на улице. Нужно посчитать общий доход и найти самую высокую температуру. Мы используем две функции: одну для суммы, другую для максимума.

fun summaDohodov(dohodi: List<Int>): Int {
    var sum = 0
    for (d in dohodi) {
        sum += d
    }
    return sum
}

fun maxTemp(temp: List<Double>): Double {
    var max = temp[0]
    for (t in temp) {
        if (t > max) {
            max = t
        }
    }
    return max
}

fun main() {
    println("Введите доходы за неделю через пробел:")
    val dohodi = readLine()!!.split(" ").map { it.toInt() }
    println("Общий доход: ${summaDohodov(dohodi)}")

    println("Введите температуры за неделю через пробел:")
    val temp = readLine()!!.split(" ").map { it.toDouble() }
    println("Максимальная температура: ${maxTemp(temp)}")
}

Теперь ты знаешь главное: функции помогают не писать одно и то же много раз, а рекурсия — решать сложные задачи, разбивая их на простые шаги. Пробуй писать свои функции — это сделает код понятным и красивым!