0Pricing
Kotlin Academy · Pelajaran

fold, reduce, dan runningFold

Agregasikan elemen koleksi dengan fold, reduce, dan fungsi akumulasi.

fold, reduce, dan runningFold adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Operasi Agregasi

fold dan reduksi mengagregasi koleksi menjadi satu nilai. fold menerima nilai awal; reduksi menggunakan elemen pertama sebagai nilai awal. runningFold mengembalikan setiap hasil perantara.

Dasar-Dasar fold

fold(seed) { acc, x -> ... } dimulai dengan nilai awal dan menggabungkan setiap elemen dengan akumulator.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    val sum = nums.fold(0) { acc, n -> acc + n }
    println(sum) // 10
}

fold dengan Nilai Awal Nonnumerik

Nilai awal dapat berupa tipe apa pun. fold dapat mengubah List<T> menjadi hasil yang sama sekali berbeda.

fun main() {
    val words = listOf("hello", "world", "kotlin")
    val joined = words.fold("") { acc, w -> if (acc.isEmpty()) w else "$acc, $w" }
    println(joined) // hello, world, kotlin
}

Reduksi Dasar

reduce menggunakan elemen pertama sebagai nilai awal. Lambda menggabungkan dua elemen pada satu waktu.

fun main() {
    val nums = listOf(2, 3, 4, 5)
    val product = nums.reduce { acc, n -> acc * n }
    println(product) // 120
}

Reduksi pada Daftar Kosong Menimbulkan Galat

reduce memerlukan setidaknya satu elemen. Gunakan reduceOrNull demi keamanan, atau pilih fold dengan nilai awal.

fun main() {
    val empty: List<Int> = emptyList()
    println(empty.reduceOrNull { a, b -> a + b }) // null
    println(empty.fold(0) { a, b -> a + b })       // 0
}

fold vs Reduksi

Gunakan fold ketika Anda memerlukan tipe hasil yang berbeda atau nilai bawaan. Gunakan reduksi ketika tipe hasil sama dengan tipe elemen dan daftar berisi setidaknya satu elemen.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    println(nums.reduce { a, b -> a + b })       // 10
    println(nums.fold(100) { a, b -> a + b })   // 110 (seed 100)
}

runningFold

runningFold mengembalikan daftar setiap akumulator perantara—berguna untuk jumlah kumulatif dan alur pemrosesan langkah demi langkah.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    val running = nums.runningFold(0) { acc, n -> acc + n }
    println(running) // [0, 1, 3, 6, 10]
}

Contoh Jumlah Kumulatif

Pola analitik yang umum: total kumulatif dari bulan ke bulan.

fun main() {
    val monthly = listOf(100, 150, 80, 200, 120)
    val cumulative = monthly.runningReduce { acc, x -> acc + x }
    println(cumulative) // [100, 250, 330, 530, 650]
}

Membangun Peta dengan fold

Lipat daftar menjadi Map dengan mengakumulasikannya ke dalam peta yang dapat diubah.

fun main() {
    val words = listOf("apple", "banana", "cherry")
    val byLetter = words.fold(mutableMapOf<Char, MutableList<String>>()) { acc, w ->
        val key = w[0]
        acc.getOrPut(key) { mutableListOf() }.add(w)
        acc
    }
    println(byLetter)
}

Membangun Daftar dengan fold

fold dapat mentransformasi urutan menjadi daftar terstruktur—misalnya, mengelompokkan duplikat yang berurutan.

fun main() {
    val nums = listOf(1, 1, 2, 3, 3, 3, 4)
    val grouped = nums.fold(mutableListOf<MutableList<Int>>()) { acc, n ->
        if (acc.isEmpty() || acc.last().last() != n) acc.add(mutableListOf(n))
        else acc.last().add(n)
        acc
    }
    println(grouped) // [[1, 1], [2], [3, 3, 3], [4]]
}

foldIndexed

Teruskan indeks bersama setiap elemen—berguna untuk agregasi yang memperhatikan posisi.

fun main() {
    val nums = listOf(10, 20, 30)
    val weighted = nums.foldIndexed(0) { i, acc, n -> acc + (i + 1) * n }
    // 1*10 + 2*20 + 3*30 = 140
    println(weighted)
}

reduceRight

reduceRight mengagregasi dari kanan ke kiri. Hal ini penting ketika operasinya tidak komutatif (misalnya, urutan penggabungan string).

fun main() {
    val words = listOf("a", "b", "c", "d")
    val leftToRight = words.reduce { acc, w -> "$acc-$w" }
    val rightToLeft = words.reduceRight { w, acc -> "$w-$acc" }
    println(leftToRight)   // a-b-c-d
    println(rightToLeft)   // a-b-c-d (same here but operation matters)
}

Pemeriksaan Cepat

Fungsi mana yang mengembalikan daftar berisi setiap nilai akumulator perantara?

Ringkasan

fold mengagregasi dengan nilai awal (tipe apa pun). Reduksi menggunakan elemen pertama sebagai nilai awal (daftar harus tidak kosong). runningFold / runningReduce mengembalikan setiap nilai perantara. Gunakan fungsi-fungsi ini untuk jumlah, hasil kali, pembuatan peta, pengelompokan, dan transformasi langkah demi langkah.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “fold, reduce, dan runningFold” gratis?

Ya — teks lengkap “fold, reduce, dan runningFold” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “fold, reduce, dan runningFold”?

Agregasikan elemen koleksi dengan fold, reduce, dan fungsi akumulasi. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “fold, reduce, dan runningFold” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. map dan flatMap: Mengubah Setiap Elemen
  2. filter, filterNot, dan partition
  3. fold, reduce, dan runningFold
  4. Merangkai Pipeline dan Menghindari List Perantara dengan Sequence
← Kembali ke Kotlin Academy