Exercise ini bagus karena menggabungkan beberapa materi yang sudah kamu pelajari sebelumnya sekaligus:

• Triple
• when
• if/kondisi
• operator ==
• Boolean
• konsep koordinat 3D
• dan sedikit cara berpikir algoritmik.

Ada juga beberapa kesalahan/ketidakjelasan di subtitle, jadi saya akan luruskan supaya kamu tidak membawa konsep yang salah.

1. Apa yang diminta oleh exercise?

Soalnya meminta kita membuat program untuk menentukan posisi sebuah titik 3D.

Titik 3D memiliki tiga koordinat:

(x, y, z)

Contoh:

(10, 0, 5)

Artinya:

x = 10
y = 0
z = 5

Kita ingin menentukan apakah titik tersebut berada pada:

1. XY plane
2. XZ plane
3. YZ plane
4. atau ordinary point / titik biasa

2. Apa itu titik 3D?

Sebelumnya kamu sudah belajar Pair dan Triple.

Untuk titik 2D, kita hanya membutuhkan:

(x, y)

Misalnya:

(10, 5)

Ini bisa direpresentasikan dengan:

val point = Pair(10, 5)

Tetapi titik 3D membutuhkan:

(x, y, z)

Maka kita bisa menggunakan:

val point = Triple(10, 0, 5)

Secara konsep:

point
 ├── first  = x
 ├── second = y
 └── third  = z

3. Kenapa menggunakan Triple?

Karena kita mempunyai tiga nilai yang saling berkaitan.

Misalnya:

val point = Triple(10, 0, 5)

berarti:

x = 10
y = 0
z = 5

Triple cocok untuk menyimpan tiga nilai tersebut dalam satu object.

Tetapi ada satu hal penting:

Triple sendiri tidak tahu bahwa first adalah X, second adalah Y, dan third adalah Z.

Itu adalah kesepakatan kita sebagai programmer.

Misalnya:

val point = Triple(10, 0, 5)

kita memutuskan:

first  → X
second → Y
third  → Z

4. Bagaimana cara menentukan sebuah titik berada di plane mana?

Ini inti dari exercise.

Kita harus memahami konsep koordinat 3D terlebih dahulu.

Ada tiga plane utama:

XY plane
XZ plane
YZ plane

5. XY plane

Sebuah titik berada pada XY plane jika:

z = 0

Kenapa?

Karena pada bidang XY, kita hanya bergerak pada:

X
Y

sedangkan koordinat Z berada di:

0

Contoh:

(10, 5, 0)

Karena:

x = 10
y = 5
z = 0

maka titik tersebut berada di:

XY plane

6. XZ plane

Sebuah titik berada pada XZ plane jika:

y = 0

Contoh:

(10, 0, 5)

Karena:

y = 0

maka:

(10, 0, 5)
       ↑
       Y = 0

Titik tersebut berada di:

XZ plane

7. YZ plane

Sebuah titik berada pada YZ plane jika:

x = 0

Contoh:

(0, 5, 10)

Karena:

x = 0

maka titik tersebut berada pada:

YZ plane

8. Kalau tidak ada koordinat yang 0?

Misalnya:

(10, 5, 7)

Periksa:

x = 10 ❌
y = 5  ❌
z = 7  ❌

Tidak ada yang bernilai 0.

Jadi titik tersebut bukan berada pada salah satu dari tiga coordinate planes.

Kita bisa menyebutnya:

ordinary point

atau:

titik biasa di ruang 3D.

9. Ada kasus khusus: titik (0, 0, 0)

Ini penting.

Titik:

(0, 0, 0)

disebut origin.

Origin sebenarnya terletak pada ketiga plane:

XY
XZ
YZ

karena:

z = 0
y = 0
x = 0

Jadi kalau exercise hanya ingin menentukan “plane mana”, kita perlu menentukan bagaimana kasus origin harus ditangani.

Subtitle tidak menjelaskan ini dengan baik.

Untuk latihan dasar, biasanya kita bisa menganggap origin sebagai kasus khusus atau memilih satu kategori tertentu sesuai requirement soal.

10. Sekarang kita buat algoritmanya

Sebelum menulis Kotlin, jangan langsung coding.

Biasakan melakukan ini:

Pahami masalah → buat algoritma → baru tulis kode.

Kita punya:

(x, y, z)

Kemudian:

Jika z == 0
    → XY plane

Jika y == 0
    → XZ plane

Jika x == 0
    → YZ plane

Jika semuanya bukan 0
    → ordinary point

Secara sederhana:

              z == 0?
              /     \
            YES      NO
             ↓        ↓
          XY plane   y == 0?
                     /      \
                   YES       NO
                    ↓         ↓
                 XZ plane    x == 0?
                              /    \
                            YES     NO
                             ↓       ↓
                         YZ plane  ordinary

Ini adalah algoritma sebelum menjadi kode.

11. Mengapa when cocok?

Kita memiliki beberapa kemungkinan.

Misalnya:

z == 0
y == 0
x == 0
tidak ada

Kita bisa menggunakan if/else if.

Tetapi kita juga bisa menggunakan when.

Misalnya:

when {
    z == 0 -> println("XY plane")
    y == 0 -> println("XZ plane")
    x == 0 -> println("YZ plane")
    else -> println("Ordinary point")
}

Perhatikan bentuknya.

Ini berbeda dari:

when (number) {
    1 -> ...
    2 -> ...
}

Di sini kita menggunakan:

when {
    condition1 -> ...
    condition2 -> ...
    condition3 -> ...
    else -> ...
}

12. Kenapa tidak ada (variable) setelah when?

Karena sekarang kita tidak sedang mengatakan:

“Cari nilai yang sama dengan X.”

Kita sedang memberikan kondisi Boolean.

Contohnya:

z == 0

Expression tersebut menghasilkan:

true

atau:

false

Jadi:

when {
    z == 0 -> ...
    y == 0 -> ...
    x == 0 -> ...
}

bisa dibaca:

“WHEN kondisi z == 0 benar, lakukan ini.”

13. Hubungkan dengan materi Boolean

Kamu sudah belajar bahwa:

z == 0

adalah comparison expression.

Hasilnya:

true / false

Contoh:

val z = 0

z == 0

hasil:

true

Sedangkan:

val z = 5

z == 0

hasil:

false

Maka when menggunakan Boolean tersebut untuk menentukan branch.

14. Contoh sederhana tanpa Triple

Sebelum menggunakan Triple, coba lihat versi paling sederhananya:

val x = 10
val y = 5
val z = 0

when {
    z == 0 -> println("XY plane")
    y == 0 -> println("XZ plane")
    x == 0 -> println("YZ plane")
    else -> println("Ordinary point")
}

Karena:

z = 0

maka:

z == 0
  ↓
true

Output:

XY plane

15. Sekarang kita gunakan Triple

Misalnya:

val point = Triple(10, 5, 0)

Secara konsep:

point.first  = 10 → X
point.second = 5  → Y
point.third  = 0  → Z

Kita bisa mengakses:

point.first
point.second
point.third

Jadi kita bisa menulis:

when {
    point.third == 0 -> println("XY plane")
    point.second == 0 -> println("XZ plane")
    point.first == 0 -> println("YZ plane")
    else -> println("Ordinary point")
}

16. Tetapi kode bisa dibuat lebih mudah dibaca

Daripada terus menulis:

point.first
point.second
point.third

kita bisa mengambil nilai tersebut ke variable:

val point = Triple(10, 5, 0)

val x = point.first
val y = point.second
val z = point.third

Sekarang:

x = 10
y = 5
z = 0

Kode berikut menjadi jauh lebih mudah dibaca:

when {
    z == 0 -> println("XY plane")
    y == 0 -> println("XZ plane")
    x == 0 -> println("YZ plane")
    else -> println("Ordinary point")
}

17. Program lengkap

Untuk latihan ini, versi yang sederhana dan mudah dipahami bisa seperti ini:

fun main() {
    val point = Triple(10, 5, 0)

    val x = point.first
    val y = point.second
    val z = point.third

    when {
        z == 0 -> println("Point is on XY plane")
        y == 0 -> println("Point is on XZ plane")
        x == 0 -> println("Point is on YZ plane")
        else -> println("Ordinary point")
    }
}

Output:

Point is on XY plane

Karena:

(10, 5, 0)
       ↑
      z=0

18. Mari kita test beberapa titik

Kasus 1

val point = Triple(10, 5, 0)

Berarti:

x = 10
y = 5
z = 0

Maka:

z == 0 → true

Output:

Point is on XY plane

Kasus 2

val point = Triple(10, 0, 5)

Berarti:

x = 10
y = 0
z = 5

Pengecekan:

z == 0 → false
y == 0 → true

Output:

Point is on XZ plane

Kasus 3

val point = Triple(0, 5, 10)

Berarti:

x = 0
y = 5
z = 10

Pengecekan:

z == 0 → false
y == 0 → false
x == 0 → true

Output:

Point is on YZ plane

Kasus 4

val point = Triple(10, 5, 7)

Tidak ada yang 0:

x = 10 ❌
y = 5  ❌
z = 7  ❌

Maka:

Ordinary point

19. Kenapa urutan pengecekan penting?

Perhatikan kode:

when {
    z == 0 -> println("XY plane")
    y == 0 -> println("XZ plane")
    x == 0 -> println("YZ plane")
    else -> println("Ordinary point")
}

when akan mengambil branch pertama yang cocok.

Misalnya:

(0, 0, 5)

Berarti:

x = 0
y = 0
z = 5

Maka:

z == 0 → false
y == 0 → true
x == 0 → true

Ada dua kondisi yang benar:

y == 0
x == 0

Tetapi yang dipakai adalah:

y == 0

karena muncul lebih dahulu.

Ini kembali ke konsep sebelumnya:

when menggunakan branch pertama yang cocok.

20. Inilah alasan kita harus memahami algoritma

Sebelum menulis:

when {
    ...
}

kita harus tahu:

“Apa yang harus diperiksa terlebih dahulu?”

Ini sebenarnya latihan problem solving, bukan hanya latihan syntax Kotlin.

Programmer yang bagus tidak sekadar hafal:

when
for
while
if

tetapi bisa mengubah masalah:

"tentukan posisi titik 3D"

menjadi:

1. Ambil x
2. Ambil y
3. Ambil z
4. Periksa z
5. Periksa y
6. Periksa x
7. Jika tidak ada yang 0 → ordinary point

Barulah dibuat kode.

21. Ada satu hal yang perlu diluruskan dari subtitle

Subtitle mengatakan kurang lebih:

“if x equal equal to y and y equal equal to z…”

Bagian ini membingungkan dan bukan inti dari algoritma plane.

Kita tidak perlu mengecek:

x == y && y == z

untuk menentukan apakah titik berada di XY/XZ/YZ plane.

Yang benar adalah:

XY → z == 0
XZ → y == 0
YZ → x == 0

Itulah hubungan matematis yang penting.

22. Koreksi lain: “axis” vs “plane”

Subtitle beberapa kali mencampur:

axis

dan:

plane.

Ini berbeda.

Axis

Ada tiga sumbu:

X-axis
Y-axis
Z-axis

Plane

Ada tiga bidang koordinat:

XY plane
XZ plane
YZ plane

Jadi kalau:

z == 0

kita mengatakan:

titik berada pada XY plane

bukan otomatis:

Z-axis.

Ini perbedaan istilah yang penting.

23. Visualisasi konsepnya

Bayangkan ruang 3D:

          Z
          ↑
          |
          |
          |
          +----------→ X
         /
        /
       ↓
       Y

XY plane

Z = 0

Jadi:

(x, y, 0)

XZ plane

Y = 0

Jadi:

(x, 0, z)

YZ plane

X = 0

Jadi:

(0, y, z)

24. Hubungan dengan Triple yang sudah kamu pelajari

Sebelumnya:

val point = Triple(10, 20, 30)

kamu sudah belajar:

first
second
third

Sekarang kita memberikan makna kepada ketiga posisi tersebut:

Triple
 ├── first  → X
 ├── second → Y
 └── third  → Z

Kemudian kita gunakan:

val x = point.first
val y = point.second
val z = point.third

Lalu:

x/y/z
 ↓
comparison
 ↓
Boolean
 ↓
when
 ↓
hasil

Ini adalah gabungan dari banyak materi yang sudah kamu pelajari.

25. Bahkan when bisa langsung menghasilkan value

Karena kamu baru saja belajar when expression, kita juga bisa membuat program yang lebih Kotlin-style.

Misalnya:

val position = when {
    z == 0 -> "XY plane"
    y == 0 -> "XZ plane"
    x == 0 -> "YZ plane"
    else -> "Ordinary point"
}

println(position)

Di sini when menghasilkan String.

Jadi:

when
 ↓
"XY plane"
 ↓
position

Ini persis konsep dari lesson sebelumnya.

26. Versi lengkap dengan when expression

fun main() {
    val point = Triple(10, 5, 0)

    val x = point.first
    val y = point.second
    val z = point.third

    val position = when {
        z == 0 -> "XY plane"
        y == 0 -> "XZ plane"
        x == 0 -> "YZ plane"
        else -> "Ordinary point"
    }

    println(position)
}

Menurut saya, versi ini lebih bagus untuk latihan saat ini, karena sekaligus memperkuat dua materi:

Triple
+
when expression

27. Pola berpikir yang harus kamu ambil dari exercise ini

Jangan hanya menghafal programnya.

Yang jauh lebih penting adalah pola:

MASALAH
   ↓
Identifikasi data
   ↓
x, y, z
   ↓
Identifikasi aturan
   ↓
z == 0 → XY
y == 0 → XZ
x == 0 → YZ
   ↓
Pilih control flow
   ↓
when
   ↓
Output

Ini yang dimaksud instructor ketika mengatakan bahwa exercise penting untuk melatih algorithm dan problem solving.

28. Ringkasan super penting

Triple

Digunakan untuk menyimpan tiga nilai:

val point = Triple(10, 5, 0)

Mengambil nilai

val x = point.first
val y = point.second
val z = point.third

Menentukan plane

z == 0 → XY plane
y == 0 → XZ plane
x == 0 → YZ plane

Menggunakan when

when {
    z == 0 -> "XY plane"
    y == 0 -> "XZ plane"
    x == 0 -> "YZ plane"
    else -> "Ordinary point"
}

Mental model terakhir

Simpan diagram ini:

             Triple
          (x, y, z)
              ↓
       ambil x, y, z
              ↓
       cek kondisi Boolean
              ↓
           when
              ↓
    ┌─────────┼─────────┐
    ↓         ↓         ↓
 z == 0     y == 0     x == 0
    ↓         ↓         ↓
   XY        XZ         YZ
  plane     plane      plane
              │
        tidak ada yang 0
              ↓
       Ordinary point

Jadi exercise ini sebenarnya bukan sekadar latihan when. Kamu sedang belajar pola yang sangat penting dalam programming:

Data → aturan/condition → Boolean → control flow → hasil.

Dan ini merupakan langkah awal menuju cara berpikir algoritmik yang akan terus kamu gunakan ketika nanti programnya jauh lebih kompleks.