---
# System prepended metadata

title: Soal Bab 5

---

# Soal Bab 5

## Prelab 5.1 Loop `while`

#### 1. (Pilihan Ganda) SOWJ Checkpoint Ch. 4.2 No. 4.3 Hal 200
Berapa banyak "Saya senang pemrograman Java!" dicetak oleh kode berikut?

```java
int count = 0;
while (count < 10)
{
    System.out.println("Saya senang pemrograman Java!");
}
```

a. 10
b. 9
c*. infinite (tak hingga)
d. 0

#### 2. (Short Answer) Big Java Self-Check Ch. 4.1 No. 5 Hal 143
Apa yang dicetak oleh loop berikut?
```java
int n = 1;
while (n < 100)
{
    n = 2 * n;
    System.out.print(n + " ");
}
```

Jawab: 2 4 8 16 32 64

#### 3. (Code Runner) SOWJ Algorithm Workbench Ch. 4 No. 5 (dimodifikasi)
Suatu populasi koloni bakteri berkembang biak dengan laju 20% per hari. Misalkan, jika populasi awal dari koloni bakteri tersebut adalah 1.000. Maka pada hari ke-1 populasi tersebut menjadi 1.000 x (1 + 0.5) = 1.500. Pada hari ke-2 populasi tersebut menjadi 1.500 x (1 + 0.5) = .... Dan seterusnya.
Perhatikan potongan kode program berikut:

```java
public class PopulasiBakteri
{
    public static void main(String[] args)
    {
        final double LAJU = 0.2;
        double popAwal = 100000;
        double popBerjalan;
        int hari;
        
        
        // Tuliskan loop while yang menghitung banyaknya hari 
        // yang diperlukan untuk populasi bakteri berkembang
        // biak menjadi 3 kali lipat dari populasi awal.
        // Tuliskan loop while Anda di bawah comment ini.
        
        
        
        
        
        
        // Akhir dari loop while Anda.
        System.out.println("Waktu yang dibutuhkan untuk populasi bakteri +
                           ")
        
        
    }
}
```


Tambahkan statement loop `while` pada program di atas sehingga program tersebut menghitung banyaknya hari yang diperlukan sehingga populasi bakteri tersebut menjadi tiga kali lipat dari populasi awal. 


#### 4. Big Java Review Exercise Ch. 4 R4.1 a
Tuliskan loop `while` yang mencetak kuadrat bilangan cacah dari 0 sampai dengan n. Misalkan, jika `n` adalah 100, maka loop ini mencetak `0 1 4 9 16 25 36 49 64 81`

#### 5. Big Java Review Exercise Ch. 4 R.4.1 c
Tuliskan loop `while` yang mencetak $2^k$ untuk $k = 0, 1, 2, 3, ...$ yang nilainya kurang dari `n`. Misalkan, jika `n` adlaah 100, maka loop ini mencetak `1 2 4 8 16 32 64`.


## Prelab 5.2 Loop `do-while`

#### 1. (Code Runner - kode sebagian)SOWJ Algorithm Workbench Ch. 4 No. 7.
Ubah loop `while` di bawah menjadi loop `do-while`:

```java
Scanner keyboard = new Scanner(System.in);
int x = 1;
while (x > 0)
{
    System.out.print("Masukkan sebuah angka: ");
    x = keyboard.nextInt();
}
```

// setting code runner:
- Hanya kode statement loop `do-while` yang diminta. Bukan program lengkap.
- Cek apakah kode yang dimasukkan menggunakan loop while. Jika ya, salahkan.


#### 2. Big Java Ch. 4.4 Self Check Hal 157 No. 16
Lengkapi statement `do-while` di kotak jawaban sehingga statement tersebut meminta input ke pengguna berupa angka bulat antara 0 sampai dengan 100 (termasuk 0 dan 100) dan memeriksa apakah angka yang dimasukkan sudah sesuai. Jika angka yang dimasukkan tidak sesuai (misalkan jika pengguna memasukkan angka negatif -10 atau atau angka lebih besar dari 100 seperti 120), maka minta ulang angka yang sesuai ke pengguna. 

// code runner dengan gapfill

```java
do 
{
    System.out.print("Masukkan angka bulat 0 s.d 100: ");
    angka = keyboard.nextInt();
}
while(<Isi dengan kode Anda>)
```

Output dari statement `do-while` yang benar harusnya seperti berikut:

#### 3. Big Java Review Exercise Ch. 4 R4.16 (Konversi loop `do-while` ke loop `while`)
Ubah loop `do-while` berikut menjadi loop `while`:

```java
int n = in.nextInt();
double x = 0;
double s;
do
{
    s = 1.0 / (1 + n * n);
    n++;
    x = x + 2;
}
while (s > 0.01);
```


![](https://i.imgur.com/tVbW9Qa.png)


#### 4. SOWJ Algorithm Workbench Ch. 4 No. 2

Tuliskan sebuah loop `do-while` yang meminta pengguna untuk memasukkan dua angka integer. Lalu jumlahkan kedua angka tersebut dan tampilkan. Setelah itu, loop menanyakan pengguna apakah ingin melakukan operasi tersebut kembali. Jika ya, loop mengulang; jika tidak loop berhenti.

Output yang diharapkan:

```shell
Masukkan angka 1: 45
Masukkan angka 2: 67
Jumlah = 112
Apakah Anda ingin melakukan ini kembali (Y atau N)? Y
Masukkan angka 1: 98
Masukkan angka 2: 103
Jumlah = 201
Apakah Anda ingin melakukan ini kembali (Y atau N)? N
```

## Prelab 5.3 Loop `for`

#### 1. SOWJ Algorithm Workbench No. 5
Tuliskan loop `for` yang memberikan output rangkaian angka-angka kelipatan 10 seperti berikut:

```
0, 10, 20, 30, 40, 50, ..., 1000
```

Tanda titik tiga (`...`) bukan merupakan bagian output. Output Anda seharusnya tidak ada titik tiga tapi berupa rangkaian angka-angka kelipatan 10 yang dipisahkan koma dan dimulai dari 0 sampai dengan 1000.

#### 2. SOWJ Checkpoint Hal. 216 Nomor 4.9
(Soal Gapfill)
Apa output dari statement loop `for` berikut:

a)
```java
for (int count = 0; count < 6; count++)
{
    System.out.println(count + count);
}
```

b)
```java
for (int value = -5; value < 5; value++)
{
    System.out.print(value + " ");
}
```

c)
```java
int x;
for (x = 5; x <= 14; x += 3)
{
    System.out.println(x);
}
```

#### 3. SOWJ Checkpoint Hal. 216 Nomor 4.11
Tuliskan loop `for` yang menampilkan angka-angka ganjil dari 1 sampai dengan 49 (1 dan 49 termasuk).

Tambahkan spasi antar angka-angka


#### 4. SOWJ Algorithm Workbench No. 9
Ubah loop `while` berikut menjadi loop `for`:

```java
int count = 0;
while (count < 50)
{
    System.out.println("count is " + count);
    count++;
}
```

#### 5. Big Java Review Exercise Ch. 4 R4.4 (Output dari loop `for`)
Apa output dari loop-loop `for` berikut?
a.
```java
for (int i = 1; i < 10; i++)
{
    System.out.print(i + " ");
}
```

b.
```java
for (int i = 1; i < 10; i += 2)
{
    System.out.print(i + " ");
}
```

c.
```java
for (int i = 10; i > 1; i--)
{
    System.out.print(i + " ");
}
```

d.
```java
for (int i = 1; i < 10; i = i * 2)
{
    System.out.print(i + " ");
}
```

e. 
```java
for (int i = 1; i < 10; i++)
{
    if (i % 2 == 0)
    {
        System.out.print(i + " ");
    }
}
```


## Prelab 5.4 Pengaplkasian Loop pada Program

#### 2. SOWJ Programming Challenges Ch 4. No. 1
Tuliskan sebuah program yang meminta penggunakan untuk memasukkan sebuah angka integer positif bukan nol, menggunakan loop untuk menghitung jumlah dari semua integer dari 1 sampai dengan angka yang dimasukkan pengguna, lalu menampilkan jumlah tersebut. Misalkan, jika pengguna memasukkan 50, maka loop akan menghitung jujmlah dari 1, 2, 3, 4, ..., 50.

Asumsikan pengguna selalu memasukkan angka yang valid.


#### 1. SOWJ Algorithm Workbench No. 11 (Input Validasi)
Tuliskan loop untuk validasi input yang meminta pengguna untuk memasukkan sebuah angka angara 1 sampai dengan 4 (1 dan 4 termasuk).





## Prelab 5.5 - 5.6 Loop Tersarang dan Simulasi

#### 1. Big Java Programming Exercises Ch. 4 P4.19
Tuliskan sebuah program yang mencetak tabel perkalian, seperti berikut:

 1    2    3    4    5    6    7    8    9   10
 2    4    6    8   10   12   14   16   18   20
 3    6    9   12   15   18   21   24   27   30
. . .
10   20   30   40   50   60   70   80   90  100

Tanda ... bukan merupakan output namun dituliskan di atas untuk menyingkat. Output program Anda seharusnya tidak menampilkan ..., namun angka-angka.

(Kode untuk mencetak diberikan di preload).

#### 2. SOWJ Algorithm Workbench Ch 4. No. 13 (modifikasi)
Tuliskan loop tersarang yang menggambar pola berikut:
```shell
*******
******
*****
****
***
**
*
```

Banyaknya bintang pada baris pertama harus sejumlah `n`.


## Lab Activity

#### 1. Big Java P4.17 (Faktor Prima)

Faktor prima dari suatu bilangan asli adalah bilangan-bilangan prima yang membagi habis bilangan tersebut. Misalkan, 150 dapat dihasilkan dari perkalian bilangan-bilangan prima seperti berikut: 150 = 2 x 3 x 5 x 5, sehingga faktor prima dari 150 adalah 2, 3, 5, 5.

Tuliskan sebuah program yang meminta pengguna memasukkan sebuah integer positif dan menampilkan semua faktor-faktor primanya. Misalkan, jika pengguna memasukkan angka 150, program menampilkan output:
```shell
2
3
5
5
```


```
Tetapkan faktor = 2.
Tetapkan hasilBagi = n.
Ulangi langkah-langkah berikut selama faktor kurang dari atau sama dengan hasilBagi:
    Cari modulus dari hasilBagi dengan faktor.
    Jika modulus sama dengan 0 (yang berarti hasilBagi dapat dibagi habis dengan faktor), cetak faktor dan tetapkan hasilBagi dengan hasilBagi / faktor.
    Jika modulus tidak sama dengan 0 (yang berarti hasilBagi tidak dapat dibagi habis dengan faktor), inkrementasi faktor.
```
Algoritma:
1. Tetapkan faktor = 2.
2. Selama faktor kurang dari atau sama dengan n ulangi langkah-langkah berikut:
   Bagi n dengan faktor. Jika sisa hasil bagi adalah 0 (ini berarti n dapat dibagi habis oleh faktor), cetak faktor dan tetapkan n dengan hasil bagi. Jika sisa hasil bagi tidak sama dengan 0 (ini berarti n tidak dapat dibagi dengan faktor), inkrementasi faktor.
   
#### 2. SOWJ Programming Challenges Ch 4. No. 2 (Jarak Tempuh)

![](https://i.imgur.com/a42K2a5.png)

Sudah ada di bank soal.
Tambahkan Validasi Input: Jangan menerima angka negatif untuk kecepatan dan jangan menerima nilai kurang dari 1 untuk waktu tempuh.
Tambahkan penjelasan ketentuan pencetakan tabel. (kode untuk mencetak diberikan di preload)

#### 3. Big Java Programming Exercise Ch. 4 P4.5 (Modifikasi)
Tuliskan sebuah program yang membaca rangkaian angka-angka floating point positif. Minta pengguna untuk memasukkan angka-angka sampai dengan pengguna memasukkan nilai sentinel -1, lalu hitung dan tampilkan:
- Rata-rata dari rangkaian angka-angka floating point yang dimasukkan pengguna.
- Nilai terkecil dari angka-angka floating point yang dimasukkan pengguna.
- Nilai terbesar dari angka-angka floating point yang dimasukkan pengguna.
- Selisih nilai terbesar dan terkecil dari angka-angka floating point yang dimasukkan pengguna.

#### 4. Big Java Programming Exercise Ch. 4 P4.30
![](https://i.imgur.com/35N2wxn.png)
Sudah ada di bank soal.

#### 5. Big Java Programming Exercise Ch. 4 P4.16
![](https://i.imgur.com/3cQ41p4.png)

Sudah ada di bank soal
Diperjelas penjelasan fibonacci nya.