Perulangan WHILE dan REPEAT-UNTIL

Setelah menyelesaikan modul ini, mahasiswa diharapkan mampu:

1. Menjelaskan konsep perulangan tak terkendali dan kapan menggunakannya.
2. Menulis perulangan while dengan uji kondisi di awal.
3. Menulis perulangan repeat-until dengan uji kondisi di akhir.
4. Membedakan kapan menggunakan while dan kapan repeat.
5. Mengidentifikasi risiko infinite loop dan cara mencegahnya.
6. Menerapkan pola validasi input berulang.
7. Menerapkan pola sentinel value untuk menghentikan perulangan berdasarkan data.
8. Memilih struktur perulangan yang tepat berdasarkan karakteristik masalah.
9. Menggambar flowchart untuk while dan repeat-until.
10. Memecahkan masalah nyata dengan perulangan tak terkendali.

Capaian Pembelajaran Mata Kuliah

Mahasiswa mampu merancang perulangan tak terkendali untuk memproses data yang jumlahnya tidak diketahui sebelumnya, melakukan validasi input, dan mengimplementasikan algoritma iteratif berbasis kondisi.

Indikator Ketercapaian Modul

3.1 Mengapa Perulangan Tak Terkendali

Perulangan for memerlukan pengetahuan tentang jumlah iterasi. Namun banyak situasi nyata tidak memiliki informasi ini:

• Meminta pengguna memasukkan data sampai dia mengetik nilai sentinel.
• Memvalidasi input sampai nilainya sesuai rentang.
• Membangun menu interaktif yang terus berjalan sampai dipilih "keluar".
• Mencari nilai dalam struktur data sampai ditemukan atau data habis.
• Menghitung deret sampai nilai suku melewati ambang tertentu.

Untuk kasus seperti ini, Pascal menyediakan while dan repeat-until yang mengulang selama kondisi tertentu terpenuhi.

3.2 Perulangan WHILE: Uji di Awal

selama kondisi lakukan
  pernyataan
akhir selama

Sintaks Pascal:

while kondisi do
  pernyataan;

Kondisi diperiksa sebelum setiap iterasi. Bila kondisi bernilai false pada pemeriksaan pertama, blok perulangan tidak dieksekusi sama sekali.

Contoh: Mencetak 1 sampai 5

var
  i: integer;

begin
  i := 1;
  while i <= 5 do
  begin
    writeln(i);
    i := i + 1;
  end;
end.

Perhatikan tiga komponen penting perulangan while:

1. Inisialisasi di luar perulangan (i := 1;).
2. Kondisi pada baris while (i <= 5).
3. Perubahan variabel kontrol di dalam blok (i := i + 1;).

3.3 Perulangan REPEAT-UNTIL: Uji di Akhir

ulangi
  pernyataan
sampai kondisi

Sintaks Pascal:

repeat
  pernyataan;
until kondisi;

Blok perulangan dieksekusi terlebih dahulu, baru kemudian kondisi diperiksa. Bila kondisi bernilai true, perulangan berhenti. Artinya, blok selalu dieksekusi minimal satu kali.

Contoh: Mencetak 1 sampai 5

var
  i: integer;

begin
  i := 1;
  repeat
    writeln(i);
    i := i + 1;
  until i > 5;
end.

Perulangan berhenti ketika i > 5 bernilai true. Jadi iterasi terjadi untuk i = 1, 2, 3, 4, 5.

3.4 Perbandingan WHILE vs REPEAT-UNTIL

3.5 Pola Validasi Input Berulang

Pola paling umum untuk repeat-until adalah meminta input sampai pengguna memasukkan nilai yang sah.

var
  nilai: integer;

begin
  repeat
    write('Masukkan nilai (0-100): ');
    readln(nilai);

    if (nilai < 0) or (nilai > 100) then
      writeln('Nilai tidak valid. Coba lagi.');
  until (nilai >= 0) and (nilai <= 100);

  writeln('Nilai yang Anda masukkan: ', nilai);
end.

Perhatikan bahwa kondisi until menyatakan kondisi berhenti, yaitu ketika nilai sudah valid. Pesan kesalahan ditampilkan bila nilai tidak valid, lalu perulangan mengulang dari awal.

3.6 Pola Sentinel Value

Sentinel value adalah nilai khusus yang menandakan akhir data. Ketika pengguna memasukkan nilai sentinel, perulangan berhenti. Pola ini memungkinkan pemrosesan data dalam jumlah tak terbatas.

const
  SENTINEL = -1;

var
  nilai, total, jumlah: integer;

begin
  total := 0;
  jumlah := 0;

  writeln('Masukkan nilai (-1 untuk selesai):');

  write('Nilai: ');
  readln(nilai);

  while nilai <> SENTINEL do
  begin
    total := total + nilai;
    jumlah := jumlah + 1;

    write('Nilai: ');
    readln(nilai);
  end;

  if jumlah > 0 then
    writeln('Rata-rata: ', total / jumlah:0:2)
  else
    writeln('Tidak ada data yang dimasukkan.');
end.

3.7 Mencegah Infinite Loop

Infinite loop terjadi ketika kondisi perulangan tidak pernah menjadi false (pada while) atau tidak pernah menjadi true (pada repeat-until).

Penyebab umum:

1. Lupa mengubah variabel kontrol di dalam blok.
2. Kondisi yang salah logika (misalnya < seharusnya >).
3. Variabel kontrol diubah tapi tidak memengaruhi kondisi.
4. Konversi tipe yang tidak disengaja mengubah nilai.
5. Input pengguna yang tidak pernah memenuhi kondisi keluar.

3.8 Perulangan Bersarang dengan WHILE

while juga dapat bersarang di dalam while atau for. Setiap perulangan harus memiliki variabel kontrol sendiri.

var
  i, j: integer;

begin
  i := 1;
  while i <= 3 do
  begin
    j := 1;
    while j <= 3 do
    begin
      write(i, 'x', j, '=', i * j, '  ');
      j := j + 1;
    end;
    writeln;
    i := i + 1;
  end;
end.

3.9 Konversi Antar Struktur Perulangan

Setiap struktur perulangan dapat dikonversi ke struktur lainnya. Memahami konversi ini memperdalam pemahaman tentang kapan masing-masing lebih tepat.

FOR ke WHILE

{ Versi FOR }
for i := 1 to 5 do
  writeln(i);

{ Versi WHILE - ekuivalen }
i := 1;
while i <= 5 do
begin
  writeln(i);
  i := i + 1;
end;

WHILE ke REPEAT

{ Versi WHILE }
i := 1;
while i <= 5 do
begin
  writeln(i);
  i := i + 1;
end;

{ Versi REPEAT - ekuivalen }
i := 1;
repeat
  writeln(i);
  i := i + 1;
until i > 5;

3.10 Kesalahan Umum pada WHILE dan REPEAT

1. Lupa mengubah variabel kontrol. Menyebabkan infinite loop.
2. Titik koma sebelum until. Kesalahan sintaks; until adalah bagian dari konstruksi repeat dan tidak dipisahkan titik koma.
3. Kondisi terbalik pada until. Menuliskan kondisi lanjut, bukan kondisi berhenti.
4. Inisialisasi variabel kontrol di dalam loop. Nilai ter-reset setiap iterasi dan loop tidak berhenti.
5. Menggunakan while untuk situasi yang butuh minimal satu iterasi. Blok tidak dieksekusi sama sekali bila kondisi awal salah.
6. Lupa blok begin...end pada while. Hanya pernyataan pertama yang diulang.
7. Kondisi yang kompleks tanpa tanda kurung. Menyebabkan prioritas operator yang tidak diinginkan.
8. Variabel kontrol diubah pada kondisi yang tidak dievaluasi. Misalnya mengubah variabel hanya di dalam cabang if yang mungkin tidak dijalankan.

3.11 Perbedaan Free Pascal dan Turbo Pascal

4.1 Flowchart Perulangan WHILE

flowchart TD
    A(["Mulai"]) --> B["Inisialisasi"]
    B --> C{"Kondisi?"}
    C -- "True" --> D["Eksekusi blok"]
    D --> E["Update variabel kontrol"]
    E --> C
    C -- "False" --> F(["Selesai"])
      

4.2 Flowchart Perulangan REPEAT-UNTIL

flowchart TD
    A(["Mulai"]) --> B["Inisialisasi"]
    B --> C["Eksekusi blok"]
    C --> D["Update variabel kontrol"]
    D --> E{"Kondisi berhenti?"}
    E -- "False" --> C
    E -- "True" --> F(["Selesai"])
      

4.3 Flowchart Validasi Input dengan REPEAT

flowchart TD
    A(["Mulai"]) --> B[/"Baca nilai"/]
    B --> C{"nilai dalam
rentang 0-100?"}
    C -- "Tidak" --> D[/"Tampilkan pesan kesalahan"/]
    D --> B
    C -- "Ya" --> E[/"Tampilkan nilai"/]
    E --> F(["Selesai"])
      

4.4 Flowchart Menu Interaktif dengan Sentinel

flowchart TD
    A(["Mulai"]) --> B["total = 0
jumlah = 0"]
    B --> C[/"Baca nilai"/]
    C --> D{"nilai = -1?"}
    D -- "Ya" --> H{"jumlah > 0?"}
    D -- "Tidak" --> E["total = total + nilai"]
    E --> F["jumlah = jumlah + 1"]
    F --> C
    H -- "Ya" --> I["rata = total / jumlah"]
    H -- "Tidak" --> J["Tampilkan pesan kosong"]
    I --> K[/"Tampilkan rata-rata"/]
    J --> K
    K --> L(["Selesai"])
      

5.1 Pseudocode Validasi Input Berulang

PROGRAM ValidasiInput
{ Meminta input sampai nilai berada dalam rentang yang sah }

KONSTANTA
  NILAI_MIN = 0
  NILAI_MAKS = 100

DEKLARASI
  nilai : integer
  valid : boolean

ALGORITMA
  valid <- false

  selama valid = false lakukan
    write("Masukkan nilai (0-100): ")
    read(nilai)

    jika (nilai >= NILAI_MIN) dan (nilai <= NILAI_MAKS) maka
      valid <- true
    selain itu
      write("Kesalahan: nilai tidak valid. Coba lagi.")
    akhir jika
  akhir selama

  write("Nilai yang Anda masukkan: ", nilai)
END

5.2 Pseudocode Rata-rata dengan Sentinel

PROGRAM RataSentinel
{ Menghitung rata-rata data sampai pengguna memasukkan -1 }

KONSTANTA
  SENTINEL = -1

DEKLARASI
  nilai   : integer
  total   : integer
  jumlah  : integer
  rata    : real

ALGORITMA
  total <- 0
  jumlah <- 0

  write("Masukkan nilai (-1 untuk berhenti):")

  ulangi
    write("Nilai: ")
    read(nilai)

    jika nilai <> SENTINEL maka
      total <- total + nilai
      jumlah <- jumlah + 1
    akhir jika
  sampai nilai = SENTINEL

  jika jumlah > 0 maka
    rata <- total / jumlah
    write("Jumlah data   : ", jumlah)
    write("Total nilai   : ", total)
    write("Rata-rata     : ", rata)
  selain itu
    write("Tidak ada data yang dimasukkan.")
  akhir jika
END

5.3 Pseudocode Menu Interaktif dengan Loop

PROGRAM MenuLoop
{ Menu yang dapat dipilih berulang sampai pengguna keluar }

DEKLARASI
  pilihan : integer
  selesai : boolean

ALGORITMA
  selesai <- false

  selama selesai = false lakukan
    write("============================")
    write("       MENU UTAMA")
    write("============================")
    write("1. Lihat data")
    write("2. Tambah data")
    write("3. Hapus data")
    write("0. Keluar")
    write("============================")
    write("Pilihan: ")
    read(pilihan)

    kasus pilihan dari
      1 : write("Menampilkan data...")
      2 : write("Menambah data...")
      3 : write("Menghapus data...")
      0 : selesai <- true
      selain itu
        write("Pilihan tidak valid")
    akhir kasus

    write("")
  akhir selama

  write("Terima kasih. Program selesai.")
END

6.1 Program Mencetak 1 sampai N dengan WHILE

program WhileCetakN;
{ Mencetak 1 sampai n menggunakan while }

var
  n, i: integer;

begin
  write('Masukkan nilai n: ');
  readln(n);

  writeln;
  writeln('Mencetak 1 sampai ', n, ':');

  i := 1;
  while i <= n do
  begin
    write(i, ' ');
    i := i + 1;
  end;

  writeln;
  writeln('Selesai.');
end.

Contoh keluaran untuk n = 8:

Masukkan nilai n: 8

Mencetak 1 sampai 8:
1 2 3 4 5 6 7 8
Selesai.

6.2 Program Validasi Nilai Berulang

program ValidasiUlang;
{ Meminta input sampai nilai valid }

const
  NILAI_MIN = 0;
  NILAI_MAKS = 100;

var
  nama: string;
  nilai: integer;

begin
  write('Nama mahasiswa : ');
  readln(nama);

  repeat
    write('Nilai ujian (0-100): ');
    readln(nilai);

    if (nilai < NILAI_MIN) or (nilai > NILAI_MAKS) then
      writeln('  -> Nilai tidak valid. Silakan coba lagi.');
  until (nilai >= NILAI_MIN) and (nilai <= NILAI_MAKS);

  writeln;
  writeln('========================================');
  writeln('Data berhasil disimpan');
  writeln('========================================');
  writeln('Nama  : ', nama);
  writeln('Nilai : ', nilai);
  writeln('========================================');
end.

6.3 Program Rata-rata dengan Sentinel

program RataSentinel;
{ Menghitung rata-rata data sampai -1 dimasukkan }

const
  SENTINEL = -1;

var
  nilai, total, jumlah: integer;
  rata: real;

begin
  total := 0;
  jumlah := 0;

  writeln('Program Penghitung Rata-rata');
  writeln('Masukkan nilai (ketik -1 untuk selesai)');
  writeln('----------------------------------------');

  repeat
    write('Nilai: ');
    readln(nilai);

    if nilai <> SENTINEL then
    begin
      total := total + nilai;
      jumlah := jumlah + 1;
    end;
  until nilai = SENTINEL;

  writeln;
  writeln('----------------------------------------');

  if jumlah > 0 then
  begin
    rata := total / jumlah;
    writeln('Jumlah data   : ', jumlah);
    writeln('Total nilai   : ', total);
    writeln('Rata-rata     : ', rata:0:2);
  end
  else
    writeln('Tidak ada data yang dimasukkan.');
end.

Contoh sesi interaksi:

Program Penghitung Rata-rata
Masukkan nilai (ketik -1 untuk selesai)
----------------------------------------
Nilai: 85
Nilai: 92
Nilai: 78
Nilai: 88
Nilai: 95
Nilai: -1

----------------------------------------
Jumlah data   : 5
Total nilai   : 438
Rata-rata     : 87.60

6.4 Program Menu Interaktif dengan WHILE

program MenuLoop;
{ Menu interaktif yang dapat dipilih berulang }

uses
  crt;

var
  pilihan: integer;
  selesai: boolean;

begin
  selesai := false;

  while not selesai do
  begin
    ClrScr;

    writeln('========================================');
    writeln('           MENU UTAMA');
    writeln('========================================');
    writeln('1. Lihat data mahasiswa');
    writeln('2. Tambah data mahasiswa');
    writeln('3. Hapus data mahasiswa');
    writeln('0. Keluar');
    writeln('========================================');
    write('Pilihan Anda: ');
    readln(pilihan);

    writeln;
    case pilihan of
      1 : writeln('Menampilkan 10 data mahasiswa...');
      2 : writeln('Formulir penambahan data dibuka.');
      3 : writeln('Konfirmasi penghapusan diperlukan.');
      0 : begin
            selesai := true;
            writeln('Terima kasih. Program selesai.');
          end;
    else
      writeln('Pilihan tidak valid. Silakan coba lagi.');
    end;

    if not selesai then
    begin
      writeln;
      writeln('Tekan Enter untuk melanjutkan...');
      readln;
    end;
  end;
end.

6.5 Program Konversi Bilangan Desimal ke Biner

program DesimalBiner;
{ Mengkonversi bilangan desimal positif ke biner dengan while }

var
  n, asli: int64;
  biner: string;
  digit: char;

begin
  write('Masukkan bilangan desimal: ');
  readln(n);

  if n < 0 then
    writeln('Hanya menerima bilangan non-negatif.')
  else if n = 0 then
    writeln('Biner: 0')
  else
  begin
    asli := n;
    biner := '';

    while n > 0 do
    begin
      if (n mod 2) = 0 then
        digit := '0'
      else
        digit := '1';

      biner := digit + biner;
      n := n div 2;
    end;

    writeln('Desimal: ', asli);
    writeln('Biner  : ', biner);
  end;
end.

Contoh keluaran untuk n = 2025:

Masukkan bilangan desimal: 2025
Desimal: 2025
Biner  : 11111101001

Perhatikan bagaimana while bekerja: kita terus membagi n dengan 2 dan menyimpan sisanya. Karena kita tidak tahu berapa bit yang dibutuhkan, while adalah pilihan yang tepat.

7.1 Program RataSentinel

7.2 Program DesimalBiner

7.3 Jejak Eksekusi DesimalBiner untuk n = 13

Hasil akhir: 13 desimal = 1101 biner. Verifikasi: 1×8 + 1×4 + 0×2 + 1×1 = 8 + 4 + 0 + 1 = 13. Benar.

9.1 Deskripsi Masalah

Maskapai "Nusantara Air" ingin membuat program pemesanan tiket yang interaktif. Penumpang dapat memesan beberapa tiket dalam satu transaksi, memasukkan nama penumpang dan kelas penerbangan untuk setiap tiket. Program menghitung subtotal setiap tiket, akumulasi total, dan menampilkan ringkasan transaksi.

9.2 Aturan Tarif dan Diskon

Diskon diberikan berdasarkan jumlah tiket:

• 1-2 tiket: tanpa diskon
• 3-5 tiket: diskon 5 persen
• 6 tiket atau lebih: diskon 10 persen

9.3 Flowchart Studi Kasus

flowchart TD
    A(["Mulai"]) --> B["total = 0
jumlahTiket = 0
lagi = true"]
    B --> C{"lagi = true?"}
    C -- "Tidak" --> L["Hitung diskon berdasarkan jumlahTiket"]
    C -- "Ya" --> D[/"Baca nama penumpang"/]
    D --> E[/"Baca kelas E/B/F"/]
    E --> F["Tentukan tarif berdasarkan kelas"]
    F --> G{"Kelas valid?"}
    G -- "Tidak" --> H[/"Tampilkan error, tidak tambah tiket"/]
    G -- "Ya" --> I["total = total + tarif
jumlahTiket = jumlahTiket + 1"]
    H --> J[/"Tanya lagi? (Y/T)"/]
    I --> J
    J --> K{"Jawaban = T?"}
    K -- "Ya" --> M["lagi = false"]
    K -- "Tidak" --> C
    M --> C
    L --> N["diskon = total * persenDiskon"]
    N --> O["totalAkhir = total - diskon"]
    O --> P[/"Tampilkan ringkasan transaksi"/]
    P --> Q(["Selesai"])
      

9.4 Pseudocode Studi Kasus

PROGRAM PemesananTiket
{ Sistem pemesanan tiket pesawat dengan perulangan tak terkendali }

KONSTANTA
  TARIF_EKONOMI  = 750000
  TARIF_BISNIS   = 1500000
  TARIF_FIRST    = 2800000
  GARIS_GANDA    = "=========================================="
  GARIS_TUNGGAL  = "------------------------------------------"

DEKLARASI
  namaPenumpang : string
  kelas         : char
  tarif         : currency
  total         : currency
  diskon        : currency
  totalAkhir    : currency
  jumlahTiket   : integer
  persenDiskon  : integer
  jawaban       : char
  lagi          : boolean
  valid         : boolean

ALGORITMA
  total       <- 0
  jumlahTiket <- 0
  lagi        <- true

  write(GARIS_GANDA)
  write("PEMESANAN TIKET NUSANTARA AIR")
  write(GARIS_GANDA)

  selama lagi = true lakukan
    write("")
    write("Pemesanan tiket ke-", jumlahTiket + 1)
    write("Nama penumpang    : ")
    read(namaPenumpang)
    write("Kelas (E/B/F)     : ")
    read(kelas)

    kelas <- UpCase(kelas)
    valid <- true

    kasus kelas dari
      'E' : tarif <- TARIF_EKONOMI
      'B' : tarif <- TARIF_BISNIS
      'F' : tarif <- TARIF_FIRST
      selain itu
        valid <- false
    akhir kasus

    jika valid = true maka
      total       <- total + tarif
      jumlahTiket <- jumlahTiket + 1
      write("Tarif: Rp ", tarif)
    selain itu
      write("Kelas tidak valid. Tiket tidak ditambahkan.")
    akhir jika

    write("Tambah tiket lagi? (Y/T): ")
    read(jawaban)

    jika UpCase(jawaban) = 'T' maka
      lagi <- false
    akhir jika
  akhir selama

  { Hitung diskon berdasarkan jumlah tiket }
  jika jumlahTiket <= 2 maka
    persenDiskon <- 0
  selain jika jumlahTiket <= 5 maka
    persenDiskon <- 5
  selain itu
    persenDiskon <- 10
  akhir jika

  diskon     <- total * persenDiskon / 100
  totalAkhir <- total - diskon

  write("")
  write(GARIS_GANDA)
  write("RINGKASAN TRANSAKSI")
  write(GARIS_GANDA)
  write("Jumlah tiket      : ", jumlahTiket)
  write("Subtotal          : Rp ", total)
  write("Diskon (", persenDiskon, "%)     : Rp ", diskon)
  write(GARIS_TUNGGAL)
  write("Total bayar       : Rp ", totalAkhir)
  write(GARIS_GANDA)
END

9.5 Implementasi dalam Pascal

program PemesananTiket;
{ Studi Kasus Modul 9 - Pemesanan tiket pesawat dengan while }

uses
  crt;

const
  TARIF_EKONOMI = 750000;
  TARIF_BISNIS  = 1500000;
  TARIF_FIRST   = 2800000;
  GARIS_GANDA   = '==========================================';
  GARIS_TUNGGAL = '------------------------------------------';

var
  namaPenumpang : string[50];
  kelas         : char;
  tarif         : currency;
  total         : currency;
  diskon        : currency;
  totalAkhir    : currency;
  jumlahTiket   : integer;
  persenDiskon  : integer;
  jawaban       : char;
  lagi          : boolean;
  valid         : boolean;

begin
  total := 0;
  jumlahTiket := 0;
  lagi := true;

  writeln(GARIS_GANDA);
  writeln('PEMESANAN TIKET NUSANTARA AIR');
  writeln(GARIS_GANDA);

  while lagi do
  begin
    writeln;
    writeln('Pemesanan tiket ke-', jumlahTiket + 1);

    write('Nama penumpang    : ');
    readln(namaPenumpang);

    write('Kelas (E/B/F)     : ');
    readln(kelas);

    kelas := UpCase(kelas);
    valid := true;
    tarif := 0;

    case kelas of
      'E' : tarif := TARIF_EKONOMI;
      'B' : tarif := TARIF_BISNIS;
      'F' : tarif := TARIF_FIRST;
    else
      valid := false;
    end;

    if valid then
    begin
      total := total + tarif;
      jumlahTiket := jumlahTiket + 1;
      writeln('Tarif             : Rp ', tarif:0:0);
    end
    else
      writeln('Kelas tidak valid. Tiket tidak ditambahkan.');

    writeln;
    write('Tambah tiket lagi? (Y/T): ');
    readln(jawaban);

    if UpCase(jawaban) = 'T' then
      lagi := false;
  end;

  { Hitung diskon berdasarkan jumlah tiket }
  if jumlahTiket <= 2 then
    persenDiskon := 0
  else if jumlahTiket <= 5 then
    persenDiskon := 5
  else
    persenDiskon := 10;

  diskon := total * persenDiskon / 100;
  totalAkhir := total - diskon;

  writeln;
  writeln(GARIS_GANDA);
  writeln('RINGKASAN TRANSAKSI');
  writeln(GARIS_GANDA);
  writeln('Jumlah tiket      : ', jumlahTiket);
  writeln('Subtotal          : Rp ', total:0:2);
  writeln('Diskon (', persenDiskon, '%)     : Rp ', diskon:0:2);
  writeln(GARIS_TUNGGAL);
  writeln('Total bayar       : Rp ', totalAkhir:0:2);
  writeln(GARIS_GANDA);
end.

9.6 Contoh Keluaran

==========================================
PEMESANAN TIKET NUSANTARA AIR
==========================================

Pemesanan tiket ke-1
Nama penumpang    : Andi Wijaya
Kelas (E/B/F)     : B
Tarif             : Rp 1500000

Tambah tiket lagi? (Y/T): Y

Pemesanan tiket ke-2
Nama penumpang    : Budi Santoso
Kelas (E/B/F)     : E
Tarif             : Rp 750000

Tambah tiket lagi? (Y/T): Y

Pemesanan tiket ke-3
Nama penumpang    : Citra Dewi
Kelas (E/B/F)     : F
Tarif             : Rp 2800000

Tambah tiket lagi? (Y/T): T

==========================================
RINGKASAN TRANSAKSI
==========================================
Jumlah tiket      : 3
Subtotal          : Rp 5050000.00
Diskon (5%)     : Rp 252500.00
------------------------------------------
Total bayar       : Rp 4797500.00
==========================================

9.7 Pembahasan

Beberapa keputusan perancangan penting pada program ini.

1. Perulangan while dengan flag lagi. Kita menggunakan variabel boolean lagi sebagai penanda. Selama lagi bernilai true, perulangan berlanjut. Ketika pengguna menjawab "T", lagi menjadi false dan perulangan berhenti.
2. Flag vs langsung kondisi. Kita bisa menuliskan kondisi perulangan langsung sebagai while UpCase(jawaban) <> 'T' do, tetapi menggunakan flag membuat logika lebih jelas dan mudah diubah.
3. Validasi kelas di dalam perulangan. Bila kelas tidak valid, tiket tidak ditambahkan. Total dan jumlah tiket hanya bertambah setelah kelas tervalidasi. Ini menjaga integritas data.
4. Diskon dihitung setelah semua tiket dipesan. Karena diskon bergantung pada jumlah total tiket, kita perlu menyimpan seluruh tiket terlebih dahulu, lalu menghitung diskon di akhir. Di modul berikutnya, kita akan menggunakan array untuk menyimpan detail setiap tiket.
5. Konversi UpCase sebelum case. Ini memastikan pengguna dapat memasukkan 'e' atau 'E' tanpa masalah.
6. Penanganan kasus jumlahTiket = 0. Bila pengguna langsung menjawab 'T' pada permintaan pertama, total tetap 0 dan jumlahTiket tetap 0. Program tetap menampilkan ringkasan dengan nilai nol.

9.8 Pengembangan Selanjutnya

1. Perulangan while menguji kondisi di awal. Blok mungkin tidak dieksekusi sama sekali.
2. Perulangan repeat-until menguji kondisi di akhir. Blok selalu dieksekusi minimal satu kali.
3. Kondisi pada while menyatakan kapan perulangan berlanjut. Kondisi pada repeat menyatakan kapan perulangan berhenti.
4. Tiga komponen perulangan: inisialisasi sebelum loop, kondisi pada header loop, dan update variabel kontrol di dalam blok.
5. Infinite loop terjadi ketika kondisi tidak pernah berubah. Penyebab umum: lupa update variabel kontrol atau kondisi logika yang salah.
6. Pola validasi input berulang menggunakan repeat-until: ulangi permintaan sampai input memenuhi kriteria.
7. Pola sentinel value menggunakan nilai khusus (misalnya -1) sebagai penanda akhir data. Sangat berguna untuk memproses data dalam jumlah tak terbatas.
8. Pola flag boolean menggunakan variabel boolean untuk mengontrol perulangan, berguna ketika ada beberapa kondisi berhenti.
9. Konversi antar struktur perulangan memungkinkan. Setiap for dapat ditulis ulang sebagai while, dan sebaliknya, meskipun keterbacaan bisa berbeda.
10. Perulangan bersarang dapat dilakukan dengan while, tetapi setiap perulangan harus memiliki variabel kontrol sendiri.
11. Titik koma sebelum until adalah kesalahan sintaks. until adalah bagian dari konstruksi repeat.
12. Pemilihan struktur perulangan: for untuk jumlah iterasi pasti, while untuk iterasi kondisional yang mungkin nol, dan repeat untuk iterasi kondisional yang minimal satu.

Buku Teks

1. Jensen, K., & Wirth, N. (1991). Pascal User Manual and Report (4th ed.). Springer-Verlag. Bab 9 membahas pernyataan while dan repeat.
2. Cantu, M. (2020). Object Pascal Handbook. Marco Cantu. Bab tentang struktur kontrol dan perulangan kondisional.
3. Cooper, D., & Clancy, M. (1982). Oh! Pascal! W. W. Norton & Company. Bab tentang iterasi kondisional.
4. Grogono, P. (1995). Programming with Pascal. Addison-Wesley. Bab 7 membahas struktur perulangan tak terkendali.
5. Knuth, D. E. (1997). The Art of Computer Programming, Volume 1 (3rd ed.). Addison-Wesley. Bab tentang pola iteratif dan algoritma berbasis kondisi.

Dokumentasi Resmi

1. Free Pascal Team. Free Pascal Reference Guide. Bab tentang pernyataan while dan repeat. Tersedia di freepascal.org/docs.html.
2. Free Pascal Team. Free Pascal Programmer's Guide. Bab tentang struktur kontrol dan kondisi.
3. Lazarus IDE Documentation. Panduan penggunaan perulangan pada aplikasi.

Artikel dan Sumber Daring

1. IEEE Computer Society. (1990). IEEE Standard for Pascal (IEEE Std 770-1983). Bab tentang pernyataan iteratif.
2. Wirth, N. (1971). "The Programming Language Pascal." Acta Informatica, 1(1), 35-63. Bab tentang struktur kontrol.
3. Free Pascal Community Forum. Diskusi tentang perbedaan performa antara for, while, dan repeat.