Merge pull request #30 from fcrezza/id-loops

Loops: while and for

Author: thickkoezz

1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md

@@ -1,4 +1,4 @@
-The answer: `1`.
+Jawabanya: `1`.
 
 ```js run
 let i = 3;
@@ -8,18 +8,18 @@ while (i) {
 }
 ```
 
-Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`.
+Setiap pengulangan mengurangi `i`  oleh `1`. Cek `while(i)` menghentikan perulangan ketika `i = 0`.
 
-Hence, the steps of the loop form the following sequence ("loop unrolled"):
+Oleh karena itu, langkah-langkah perulangan membentuk urutan berikut ("perulangan terbuka"):
 
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); // menampilkan 3, mengurangi i ke 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // menampilkan 2, mengurangi i ke 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // menampilkan 1, mengurangi i ke 0
 
-// done, while(i) check stops the loop
+// selesai while(i) cek menghentikan pengulangan
 ```

1-js/02-first-steps/12-while-for/1-loop-last-value/task.md

@@ -1,10 +1,10 @@
-importance: 3
+nilai penting: 3
 
 ---
 
-# Last loop value
+# Nilai terakhir perulangan
 
-What is the last value alerted by this code? Why?
+Apa nilai terakhir yang diperingatkan oleh kode ini? Mengapa?
 
 ```js
 let i = 3;

1-js/02-first-steps/12-while-for/2-which-value-while/solution.md

@@ -1,30 +1,30 @@
-The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
+Tugas mendemonstrasikan bagaimana bentuk postfix/prefix dapat menyebabkan hasil yang berbeda ketika digunakan dalam perbandingan
 
-1. **From 1 to 4**
+1. **Dari 1 ke 4**
 
     ```js run
     let i = 0;
     while (++i < 5) alert( i );
     ```
 
-    The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`.
+    nilai pertama adalah `i = 1`, karena `++i` pertama menaikan `i` dan mengembalikan nilai baru. Jadi perbandingan pertama adalah `1 < 5` dan `alert` menampilkan `1`.
 
-    Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable.
+    lalu diikuti `2, 3, 4…` -- nilainya muncul satu per satu. Perbandingan selalu menggunakan nilai yang ditambah, karna `++` sebelum variabel.
 
-    Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown.
-2. **From 1 to 5**
+    Akhirnya, `i = 4` naik menjadi `5`, perbandingan `while(5 < 5)` gagal, dan pengulangan berhenti. Jadi `5` tidak ditampilkan.
+2. **Dari 1 ke 5**
 
     ```js run
     let i = 0;
     while (i++ < 5) alert( i );
     ```
 
-    The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`).
+    Lagi, nilai pertama adalah `i = 1`. bentuk postfix dari `i++` menaikan `i` lalu mengembalikan nilai yang *lama*, jadi perbandinganya `i++ < 5` akan menggunakan `i = 0` (berbeda dengan `++i < 5`).
 
-    But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`.
+    Namun panggilan `alert` terpisah. ini adalah pernyataan lain yang berjalan setelah kenaikan dan perbandingan. Jadi ini mendapatkan yang sekarang `i = 1`.
 
-    Then follow `2, 3, 4…`
+    Lalu diikuti `2, 3, 4…`
 
-    Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`.
+    Mari berhenti di `i = 4`. bentuk prefix `++i` akan menaikannya dan menggunakan `5` di perbandingan. Tapi disini kita mempunyai bentuk postfix `i++`. jadi ini menaikan `i` ke `5`, namun mengembalikan nilai yang lama. Karna perbandingan yang sebenarnya adalah `while(4 < 5)` -- benar, dan kontrol berlanjut ke `alert`.
 
-    The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false.
+    Nilai `i = 5` adalah yang terkahir, karena pada langkah berikutnya `while(5 < 5)` adalah salah.

1-js/02-first-steps/12-while-for/2-which-value-while/task.md

@@ -1,20 +1,20 @@
-importance: 4
+nilai penting: 4
 
 ---
 
-# Which values does the while loop show?
+# Nilai mana yang ditampilkan perulangan while?
 
-For every loop iteration, write down which value it outputs and then compare it with the solution.
+Setiap perulangan, tulis nilai yang dikeluarkan dan bandingkan dengan solusinya.
 
-Both loops `alert` the same values, or not?
+Kedua perulangan `alert` nilai yang sama, atau tidak?
 
-1. The prefix form `++i`:
+1. Bentuk prefix `++i`:
 
     ```js
     let i = 0;
     while (++i < 5) alert( i );
     ```
-2. The postfix form `i++`
+2. Bentuk postfix `i++`
 
     ```js
     let i = 0;

1-js/02-first-steps/12-while-for/3-which-value-for/solution.md

@@ -1,17 +1,17 @@
-**The answer: from `0` to `4` in both cases.**
+**Jawabanya: dari `0` ke `4` di kedua kasus.**
 
 ```js run
 for (let i = 0; i < 5; ++i) alert( i );
 
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-That can be easily deducted from the algorithm of `for`:
+Itu dapat dengan mudah dikurangkan dari algoritma dari `for`:
 
-1. Execute once `i = 0` before everything (begin).
-2. Check the condition `i < 5`
-3. If `true` -- execute the loop body `alert(i)`, and then `i++`
+1. Jalankan sekali `i = 0` sebelum apapun (mulai).
+2. Cek kondisinya `i < 5`
+3. Jika `true` -- jalankan badan perulangan `alert(i)`, lalu `i++`
 
-The increment `i++` is separated from the condition check (2). That's just another statement.
+Kenaikan `i++` terpisah dari pengecekan kondisi (2). itu hanya pernyataan lain.
 
-The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
+Nilai yang dikembalikan oleh kenaikan tidak digunakan disini, jadi tidak ada bedanya antara `i++` dan `++i`.

1-js/02-first-steps/12-while-for/3-which-value-for/task.md

@@ -1,19 +1,19 @@
-importance: 4
+nilai penting: 4
 
 ---
 
-# Which values get shown by the "for" loop?
+# Nilai mana yang ditampilkan oleh perulangan "for" ?
 
-For each loop write down which values it is going to show. Then compare with the answer.
+Untuk setiap perulangan tulis nilai mana yang akan ditampilkan. lalu bandingkan dengan jawabanya
 
-Both loops `alert` same values or not?
+Kedua perulangan `alert` nilai yang sama atau tidak?
 
-1. The postfix form:
+1. Bentuk postfix:
 
     ```js
     for (let i = 0; i < 5; i++) alert( i );
     ```
-2. The prefix form:
+2. Bentuk prefix:
 
     ```js
     for (let i = 0; i < 5; ++i) alert( i );

1-js/02-first-steps/12-while-for/4-for-even/solution.md

@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-We use the "modulo" operator `%` to get the remainder and check for the evenness here.
+Kita menggunakan operator "modulo" `%` untuk mendapatkan sisanya dan untuk mengecek kegenapan disini.

1-js/02-first-steps/12-while-for/4-for-even/task.md

@@ -1,9 +1,9 @@
-importance: 5
+nilai penting: 5
 
 ---
 
-# Output even numbers in the loop
+# Menghasilkan angka genap di perulangan
 
-Use the `for` loop to output even numbers from `2` to `10`.
+Gunakan perulangan `for` untuk menghasilkan angka genap dari `2`sampai `10`.
 
 [demo]

1-js/02-first-steps/12-while-for/5-replace-for-while/task.md

@@ -1,10 +1,10 @@
-importance: 5
+nilai penting: 5
 
 ---
 
-# Replace "for" with "while"
+# Ganti "for" dengan "while"
 
-Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same).
+Tulis ulang kode ubah perulangan `for` ke `while` tanpa mengubah perlakunya (hasilnya harus tetap sama).
 
 ```js run
 for (let i = 0; i < 3; i++) {

1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md

@@ -3,13 +3,13 @@
 let num;
 
 do {
-  num = prompt("Enter a number greater than 100?", 0);
+  num = prompt("Masukan angka lebih dari 100?", 0);
 } while (num <= 100 && num);
 ```
 
-The loop `do..while` repeats while both checks are truthy:
+Perulangan `do..while` diulangi selagi kedua cek itu bernilai benar:
 
-1. The check for `num <= 100` -- that is, the entered value is still not greater than `100`.
-2. The check `&& num` is false when `num` is `null` or a empty string. Then the `while` loop stops too.
+1. Cek untuk `num <= 100` -- itu adalah, nilai yang dimasukan masih tidak lebih besar dari `100`.
+2. Cek `&& num` adalah salah ketika `num` adalah `null` atau sebuah string kosong. lalu perulangan `while` berhenti juga.
 
-P.S. If `num` is `null` then `num <= 100` is `true`, so without the 2nd check the loop wouldn't stop if the user clicks CANCEL. Both checks are required.
+P.S. Jika `num` adalah `null` lalu `num <= 100` adalah `true`, jadi tanpa pengecekan kedua perulangan tidak akan berhenti jika pengguna mengeclick CANCEL. Kedua cek dibutuhkan.