Perulangan FOR

Setelah menyelesaikan modul ini, mahasiswa diharapkan mampu:

1. Menjelaskan konsep perulangan terkendali dan posisinya sebagai struktur iteration.
2. Menulis perulangan for dengan arah naik menggunakan to.
3. Menulis perulangan for dengan arah turun menggunakan downto.
4. Mengidentifikasi tipe data yang sah untuk variabel pencacah.
5. Menjelaskan mengapa pencacah tidak boleh diubah di dalam blok perulangan.
6. Membedakan kapan perulangan for tidak dieksekusi sama sekali.
7. Menerapkan pola akumulasi untuk menghitung jumlah dan rata-rata.
8. Menerapkan pola pencacahan untuk menghitung kemunculan.
9. Menggambar flowchart perulangan for.
10. Memecahkan masalah nyata yang memerlukan perulangan terkendali.

Capaian Pembelajaran Mata Kuliah

Mahasiswa mampu merancang perulangan terkendali untuk memproses sekumpulan data atau mengulang operasi sejumlah kali tertentu, serta menerapkannya dalam penyelesaian masalah yang melibatkan akumulasi dan pencacahan.

Indikator Ketercapaian Modul

3.1 Konsep Perulangan Terkendali

Perulangan (loop) memungkinkan program menjalankan blok pernyataan berkali-kali. Perulangan dibedakan menjadi dua jenis berdasarkan cara pengendaliannya:

• Perulangan terkendali (counted loop) — jumlah iterasinya sudah diketahui sebelumnya. Dalam Pascal menggunakan for.
• Perulangan tak terkendali (conditional loop) — jumlah iterasinya bergantung pada kondisi. Dalam Pascal menggunakan while atau repeat. Dibahas pada Modul 9.

Perulangan for sangat tepat ketika kita tahu persis berapa kali operasi harus diulang: menjumlahkan bilangan 1 sampai 100, mencetak tabel perkalian, atau memproses data sebanyak n kali.

3.2 Sintaks Dasar Perulangan FOR

for pencacah := nilai_awal to nilai_akhir do
  pernyataan;

for pencacah := nilai_awal downto nilai_akhir do
  pernyataan;

Sintaks Pascal:

{ Perulangan naik }
for i := 1 to 5 do
  writeln('Iterasi ke-', i);

{ Perulangan turun }
for i := 5 downto 1 do
  writeln('Iterasi ke-', i);

Perulangan Naik (TO)

Pencacah dimulai dari nilai_awal, bertambah satu setiap iterasi, dan berhenti setelah mencapai nilai_akhir. Blok dieksekusi untuk setiap nilai dari nilai_awal hingga nilai_akhir, inklusif.

Perulangan for i := 1 to 5 akan menjalankan blok sebanyak 5 kali, dengan i bernilai 1, 2, 3, 4, dan 5.

Perulangan Turun (DOWNTO)

Pencacah dimulai dari nilai_awal, berkurang satu setiap iterasi, dan berhenti setelah mencapai nilai_akhir. Blok dieksekusi untuk setiap nilai dari nilai_awal turun hingga nilai_akhir, inklusif.

Perulangan for i := 5 downto 1 akan menjalankan blok sebanyak 5 kali, dengan i bernilai 5, 4, 3, 2, dan 1.

for i := 5 to 1 do
  writeln('Tidak akan tercetak');   { Tidak dieksekusi }

for i := 1 downto 5 do
  writeln('Juga tidak tercetak');   { Tidak dieksekusi }

3.3 Blok Pernyataan pada Perulangan FOR

Bila perulangan perlu mengeksekusi lebih dari satu pernyataan, gunakan begin...end.

for i := 1 to 5 do
begin
  writeln('Iterasi ke-', i);
  writeln('Kuadrat: ', i * i);
  writeln('---');
end;

Sama seperti pada if, tanpa blok begin...end, hanya pernyataan pertama yang dianggap bagian dari perulangan.

{ SALAH: hanya writeln pertama yang diulang }
for i := 1 to 5 do
  writeln('Iterasi ke-', i);
  writeln('Kuadrat: ', i * i);   { Hanya dieksekusi sekali, di luar loop }

3.4 Tipe Data Pencacah

Variabel pencacah pada perulangan for harus bertipe ordinal, sama seperti ekspresi penyeleksi pada case.

3.5 Aturan: Pencacah Tidak Boleh Diubah

Di dalam blok perulangan for, variabel pencacah tidak boleh diubah. Kompiler akan menolak kode yang mencoba melakukannya.

{ SALAH: mengubah nilai i di dalam loop }
for i := 1 to 10 do
begin
  writeln(i);
  i := i + 1;   { Kesalahan kompilasi }
end;

Aturan ini melindungi integritas iterasi. Bila Anda perlu mengubah nilai dalam langkah yang berbeda, gunakan variabel lain sebagai akumulator atau penghitung, atau gunakan perulangan while.

3.6 Pola Akumulasi: Menghitung Jumlah

Pola paling umum dalam perulangan adalah akumulasi: menambahkan nilai ke sebuah variabel akumulator di setiap iterasi. Variabel akumulator harus diinisialisasi ke 0 sebelum perulangan dimulai.

var
  i, total: integer;

begin
  total := 0;               { Inisialisasi akumulator }

  for i := 1 to 100 do
    total := total + i;     { Tambahkan i ke total }

  writeln('Jumlah 1 sampai 100 = ', total);   { 5050 }
end.

Jejak Akumulasi

3.7 Pola Akumulasi: Menghitung Rata-rata

Rata-rata dihitung dengan menjumlahkan semua nilai lalu membaginya dengan jumlah data. Perhatikan bahwa hasil pembagian harus disimpan dalam variabel bertipe real.

var
  i, n, nilai: integer;
  total: integer;
  rata: real;

begin
  write('Berapa banyak data? ');  readln(n);

  total := 0;

  for i := 1 to n do
  begin
    write('Data ke-', i, ': ');
    readln(nilai);
    total := total + nilai;
  end;

  if n > 0 then
    rata := total / n
  else
    rata := 0;

  writeln('Total: ', total);
  writeln('Rata-rata: ', rata:0:2);
end.

3.8 Pola Pencacahan: Menghitung Kemunculan

Selain menjumlahkan nilai, kita juga dapat menghitung berapa kali suatu kondisi terpenuhi.

var
  i, n, nilai: integer;
  jumlahGenap: integer;

begin
  write('Berapa banyak data? ');  readln(n);

  jumlahGenap := 0;      { Inisialisasi pencacah }

  for i := 1 to n do
  begin
    write('Data ke-', i, ': ');
    readln(nilai);

    if nilai mod 2 = 0 then
      jumlahGenap := jumlahGenap + 1;
  end;

  writeln('Jumlah bilangan genap: ', jumlahGenap);
end.

3.9 Mencari Nilai Maksimum dan Minimum

Pencarian nilai maksimum (atau minimum) melibatkan inisialisasi pembanding dengan nilai pertama, lalu membandingkan setiap nilai berikutnya.

var
  i, n, nilai: integer;
  maks: integer;

begin
  write('Berapa banyak data? ');  readln(n);

  if n < 1 then
  begin
    writeln('Data harus minimal satu.');
    exit;
  end;

  write('Data ke-1: ');  readln(maks);

  for i := 2 to n do
  begin
    write('Data ke-', i, ': ');
    readln(nilai);

    if nilai > maks then
      maks := nilai;
  end;

  writeln('Nilai maksimum: ', maks);
end.

3.10 Perulangan Bersarang

Perulangan for dapat berada di dalam perulangan for lain. Pencacah masing-masing harus berbeda nama.

var
  i, j: integer;

begin
  for i := 1 to 3 do
  begin
    for j := 1 to 3 do
      write(i, 'x', j, '=', i * j, '  ');
    writeln;      { Pindah baris setelah inner loop selesai }
  end;
end.

Keluaran:

1x1=1  1x2=2  1x3=3
2x1=2  2x2=4  2x3=6
3x1=3  3x2=6  3x3=9

Perulangan bersarang akan dibahas lebih mendalam pada Modul 10. Di sini kita hanya mengenal konsep dasarnya.

3.11 Menggunakan Variabel Pencacah Setelah Perulangan

Setelah perulangan for selesai, variabel pencacah menyimpan nilai terakhir yang membuat perulangan berhenti. Namun, nilai ini berbeda antara Pascal standar dan kompiler tertentu. Sebaiknya jangan mengandalkan nilai akhir pencacah setelah perulangan.

3.12 Kesalahan Umum pada Perulangan FOR

1. Lupa begin...end. Hanya pernyataan pertama yang diulang.
2. Mengubah pencacah di dalam loop. Menyebabkan kesalahan kompilasi.
3. Menukar to dan downto secara tidak sengaja. Perulangan tidak dieksekusi atau menghasilkan iterasi yang salah arah.
4. Lupa inisialisasi akumulator. Nilai akumulator berisi nilai acak dari memori sebelumnya.
5. Pembagian dengan nol pada rata-rata. Bila data kosong, pembagian akan gagal.
6. Menggunakan tipe real untuk pencacah. Tidak sah, harus ordinal.
7. Mengharapkan nilai akhir pencacah. Nilai akhir berbeda antar kompiler.
8. Perulangan tak berujung karena kesalahan logika. Meskipun for aman dari infinite loop, kesalahan mengubah variabel kontrol di luar bisa mengakibatkan perilaku tidak terduga.

3.13 Perbedaan Free Pascal dan Turbo Pascal

4.1 Flowchart Perulangan FOR Naik

flowchart TD
    A(["Mulai"]) --> B["i = nilai_awal"]
    B --> C{"i <= nilai_akhir?"}
    C -- "Ya" --> D["Eksekusi blok perulangan"]
    D --> E["i = i + 1"]
    E --> C
    C -- "Tidak" --> F(["Selesai"])
      

4.2 Flowchart Perulangan FOR Turun

flowchart TD
    A(["Mulai"]) --> B["i = nilai_awal"]
    B --> C{"i >= nilai_akhir?"}
    C -- "Ya" --> D["Eksekusi blok perulangan"]
    D --> E["i = i - 1"]
    E --> C
    C -- "Tidak" --> F(["Selesai"])
      

4.3 Flowchart Menghitung Jumlah 1 sampai N

flowchart TD
    A(["Mulai"]) --> B[/"Baca n"/]
    B --> C["total = 0"]
    C --> D["i = 1"]
    D --> E{"i <= n?"}
    E -- "Ya" --> F["total = total + i"]
    F --> G["i = i + 1"]
    G --> E
    E -- "Tidak" --> H[/"Tampilkan total"/]
    H --> I(["Selesai"])
      

4.4 Flowchart Mencari Nilai Maksimum

flowchart TD
    A(["Mulai"]) --> B[/"Baca n"/]
    B --> C[/"Baca nilai pertama"/]
    C --> D["maks = nilai"]
    D --> E["i = 2"]
    E --> F{"i <= n?"}
    F -- "Ya" --> G[/"Baca nilai ke-i"/]
    G --> H{"nilai > maks?"}
    H -- "Ya" --> I["maks = nilai"]
    H -- "Tidak" --> J["Pertahankan maks"]
    I --> K["i = i + 1"]
    J --> K
    K --> F
    F -- "Tidak" --> L[/"Tampilkan maks"/]
    L --> M(["Selesai"])
      

5.1 Pseudocode Menghitung Jumlah 1 sampai N

PROGRAM JumlahDeret
{ Menghitung jumlah bilangan dari 1 sampai n }

DEKLARASI
  n     : integer
  i     : integer
  total : integer

ALGORITMA
  write("Masukkan nilai n: ")
  read(n)

  total <- 0

  untuk i <- 1 sampai n lakukan
    total <- total + i
  akhir untuk

  write("Jumlah 1 sampai ", n, " = ", total)
END

5.2 Pseudocode Menghitung Rata-rata N Data

PROGRAM RataRataData
{ Menghitung rata-rata dari n data yang dimasukkan pengguna }

DEKLARASI
  n     : integer
  i     : integer
  nilai : integer
  total : integer
  rata  : real

ALGORITMA
  write("Berapa banyak data? ")
  read(n)

  total <- 0

  untuk i <- 1 sampai n lakukan
    write("Data ke-", i, ": ")
    read(nilai)
    total <- total + nilai
  akhir untuk

  jika n > 0 maka
    rata <- total / n
  selain itu
    rata <- 0
  akhir jika

  write("Total     : ", total)
  write("Rata-rata : ", rata)
END

5.3 Pseudocode Mencari Nilai Maksimum dan Minimum

PROGRAM CariEkstrem
{ Mencari nilai maksimum dan minimum dari n data }

DEKLARASI
  n    : integer
  i    : integer
  nilai : integer
  maks : integer
  min  : integer

ALGORITMA
  write("Berapa banyak data? ")
  read(n)

  jika n < 1 maka
    write("Data harus minimal satu.")
    selesai
  akhir jika

  write("Data ke-1: ")
  read(nilai)
  maks <- nilai
  min  <- nilai

  untuk i <- 2 sampai n lakukan
    write("Data ke-", i, ": ")
    read(nilai)

    jika nilai > maks maka
      maks <- nilai
    akhir jika

    jika nilai < min maka
      min <- nilai
    akhir jika
  akhir untuk

  write("Nilai maksimum: ", maks)
  write("Nilai minimum: ", min)
END

6.1 Program Cetak 1 sampai N

program CetakSampaiN;
{ Mencetak bilangan 1 sampai n }

var
  n, i: integer;

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

  for i := 1 to n do
    writeln(i);

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

Contoh keluaran untuk n = 5:

Masukkan nilai n: 5
1
2
3
4
5
--- Selesai ---

6.2 Program Menghitung Jumlah Deret

program JumlahDeret;
{ Menghitung jumlah deret 1 + 2 + 3 + ... + n }

var
  n, i: integer;
  total: integer;

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

  total := 0;

  for i := 1 to n do
    total := total + i;

  writeln;
  writeln('Deret: 1 + 2 + ... + ', n);
  writeln('Jumlah total = ', total);
end.

Contoh keluaran untuk n = 10:

Masukkan nilai n: 10

Deret: 1 + 2 + ... + 10
Jumlah total = 55

6.3 Program Menghitung Rata-rata N Data

program RataNData;
{ Menghitung rata-rata dari n data yang dimasukkan pengguna }

var
  n, i, nilai: integer;
  total: integer;
  rata: real;

begin
  write('Berapa banyak data? ');
  readln(n);

  if n < 1 then
  begin
    writeln('Jumlah data harus minimal satu.');
    exit;
  end;

  total := 0;

  for i := 1 to n do
  begin
    write('Data ke-', i, ': ');
    readln(nilai);
    total := total + nilai;
  end;

  rata := total / n;

  writeln;
  writeln('Jumlah data   : ', n);
  writeln('Total nilai   : ', total);
  writeln('Rata-rata     : ', rata:0:2);
end.

6.4 Program Tabel Perkalian

program TabelPerkalian;
{ Menampilkan tabel perkalian untuk sebuah angka }

var
  angka, i: integer;

begin
  write('Masukkan angka: ');
  readln(angka);

  writeln;
  writeln('Tabel perkalian ', angka);
  writeln('--------------------------------');

  for i := 1 to 10 do
    writeln(angka:3, ' x ', i:2, ' = ', angka * i:5);

  writeln('--------------------------------');
end.

Contoh keluaran untuk angka = 7:

Masukkan angka: 7

Tabel perkalian 7
--------------------------------
  7 x  1 =     7
  7 x  2 =    14
  7 x  3 =    21
  7 x  4 =    28
  7 x  5 =    35
  7 x  6 =    42
  7 x  7 =    49
  7 x  8 =    56
  7 x  9 =    63
  7 x 10 =    70
--------------------------------

6.5 Program Faktorial dan Deret Fibonacci

program FaktorialFibonacci;
{ Menghitung faktorial dan deret Fibonacci dengan for }

var
  n, i: integer;
  faktorial: int64;
  fib1, fib2, fibBaru: int64;

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

  { Bagian 1: Faktorial }
  if n < 0 then
    writeln('Faktorial tidak terdefinisi untuk bilangan negatif.')
  else
  begin
    faktorial := 1;

    for i := 1 to n do
      faktorial := faktorial * i;

    writeln(n, '! = ', faktorial);
  end;

  { Bagian 2: Fibonacci }
  if n < 1 then
    writeln('Deret Fibonacci membutuhkan n >= 1.')
  else
  begin
    writeln('Deret Fibonacci hingga suku ke-', n, ':');

    if n >= 1 then
    begin
      fib1 := 0;
      write(fib1);

      if n >= 2 then
      begin
        fib2 := 1;
        write(', ', fib2);

        for i := 3 to n do
        begin
          fibBaru := fib1 + fib2;
          write(', ', fibBaru);
          fib1 := fib2;
          fib2 := fibBaru;
        end;
      end;

      writeln;
    end;
  end;
end.

Contoh keluaran untuk n = 8:

Masukkan nilai n: 8
8! = 40320
Deret Fibonacci hingga suku ke-8:
0, 1, 1, 2, 3, 5, 8, 13

7.1 Program JumlahDeret

7.2 Program RataNData

7.3 Jejak Eksekusi JumlahDeret untuk n = 5

9.1 Deskripsi Masalah

Sebuah kedai kopi "Kopi Nusantara" ingin membuat laporan penjualan harian selama 7 hari. Setiap hari, kasir mencatat total pendapatan. Program akan menghitung: total pendapatan mingguan, rata-rata harian, hari dengan pendapatan tertinggi dan terendah, serta jumlah hari yang mencapai target harian.

9.2 Aturan Perhitungan

9.3 Flowchart Studi Kasus

flowchart TD
    A(["Mulai"]) --> B[/"Baca target harian"/]
    B --> C[/"Baca pendapatan hari ke-1"/]
    C --> D["total = pendapatan
maks = pendapatan
min = pendapatan
hariMaks = 1
hariMin = 1
hariCapaiTarget = 0"]
    D --> E{"pendapatan >= target?"}
    E -- "Ya" --> F["hariCapaiTarget = hariCapaiTarget + 1"]
    E -- "Tidak" --> G["Lewati"]
    F --> H["i = 2"]
    G --> H
    H --> I{"i <= 7?"}
    I -- "Ya" --> J[/"Baca pendapatan hari ke-i"/]
    J --> K["total = total + pendapatan"]
    K --> L{"pendapatan > maks?"}
    L -- "Ya" --> M["maks = pendapatan
hariMaks = i"]
    L -- "Tidak" --> N{"pendapatan < min?"}
    M --> O{"pendapatan >= target?"}
    N -- "Ya" --> P["min = pendapatan
hariMin = i"]
    N -- "Tidak" --> O
    P --> O
    O -- "Ya" --> Q["hariCapaiTarget = hariCapaiTarget + 1"]
    O -- "Tidak" --> R["Lewati"]
    Q --> S["i = i + 1"]
    R --> S
    S --> I
    I -- "Tidak" --> T["rata = total / 7"]
    T --> U[/"Tampilkan laporan lengkap"/]
    U --> V(["Selesai"])
      

9.4 Pseudocode Studi Kasus

PROGRAM LaporanPenjualan
{ Menganalisis penjualan selama 7 hari }

KONSTANTA
  JUMLAH_HARI = 7
  GARIS_GANDA = "=========================================="
  GARIS_TUNGGAL = "------------------------------------------"

DEKLARASI
  target          : currency
  pendapatan      : currency
  total           : currency
  rata            : real
  maks            : currency
  min             : currency
  hariMaks        : integer
  hariMin         : integer
  hariCapaiTarget : integer
  i               : integer

ALGORITMA
  write("Target harian (Rp)        : ")
  read(target)

  write("Pendapatan hari ke-1 (Rp) : ")
  read(pendapatan)

  total           <- pendapatan
  maks            <- pendapatan
  min             <- pendapatan
  hariMaks        <- 1
  hariMin         <- 1
  hariCapaiTarget <- 0

  jika pendapatan >= target maka
    hariCapaiTarget <- hariCapaiTarget + 1
  akhir jika

  untuk i <- 2 sampai JUMLAH_HARI lakukan
    write("Pendapatan hari ke-", i, " (Rp) : ")
    read(pendapatan)

    total <- total + pendapatan

    jika pendapatan > maks maka
      maks     <- pendapatan
      hariMaks <- i
    akhir jika

    jika pendapatan < min maka
      min     <- pendapatan
      hariMin <- i
    akhir jika

    jika pendapatan >= target maka
      hariCapaiTarget <- hariCapaiTarget + 1
    akhir jika
  akhir untuk

  rata <- total / JUMLAH_HARI

  write(GARIS_GANDA)
  write("LAPORAN PENJUALAN MINGGUAN")
  write("Kopi Nusantara")
  write(GARIS_GANDA)
  write("Target harian       : Rp ", target)
  write(GARIS_TUNGGAL)
  write("Total mingguan      : Rp ", total)
  write("Rata-rata harian    : Rp ", rata)
  write("Hari tertinggi      : Hari ke-", hariMaks, " (Rp ", maks, ")")
  write("Hari terendah       : Hari ke-", hariMin, " (Rp ", min, ")")
  write("Hari capai target   : ", hariCapaiTarget, " hari")
  write(GARIS_GANDA)
END

9.5 Implementasi dalam Pascal

program LaporanPenjualan;
{ Studi Kasus Modul 8 - Analisis penjualan mingguan dengan perulangan for }

const
  JUMLAH_HARI   = 7;
  GARIS_GANDA   = '==========================================';
  GARIS_TUNGGAL = '------------------------------------------';

var
  target          : currency;
  pendapatan      : currency;
  total           : currency;
  rata            : real;
  maks            : currency;
  min             : currency;
  hariMaks        : integer;
  hariMin         : integer;
  hariCapaiTarget : integer;
  i               : integer;

begin
  writeln('Laporan Penjualan Mingguan Kopi Nusantara');
  writeln(GARIS_TUNGGAL);
  writeln;

  write('Target harian (Rp)        : ');  readln(target);
  write('Pendapatan hari ke-1 (Rp) : ');  readln(pendapatan);

  total := pendapatan;
  maks := pendapatan;
  min := pendapatan;
  hariMaks := 1;
  hariMin := 1;
  hariCapaiTarget := 0;

  if pendapatan >= target then
    hariCapaiTarget := hariCapaiTarget + 1;

  for i := 2 to JUMLAH_HARI do
  begin
    write('Pendapatan hari ke-', i, ' (Rp) : ');
    readln(pendapatan);

    total := total + pendapatan;

    if pendapatan > maks then
    begin
      maks := pendapatan;
      hariMaks := i;
    end;

    if pendapatan < min then
    begin
      min := pendapatan;
      hariMin := i;
    end;

    if pendapatan >= target then
      hariCapaiTarget := hariCapaiTarget + 1;
  end;

  rata := total / JUMLAH_HARI;

  writeln;
  writeln(GARIS_GANDA);
  writeln('LAPORAN PENJUALAN MINGGUAN');
  writeln('Kopi Nusantara');
  writeln(GARIS_GANDA);
  writeln('Target harian       : Rp ', target:0:2);
  writeln(GARIS_TUNGGAL);
  writeln('Total mingguan      : Rp ', total:0:2);
  writeln('Rata-rata harian    : Rp ', rata:0:2);
  writeln('Hari tertinggi      : Hari ke-', hariMaks,
          ' (Rp ', maks:0:2, ')');
  writeln('Hari terendah       : Hari ke-', hariMin,
          ' (Rp ', min:0:2, ')');
  writeln('Hari capai target   : ', hariCapaiTarget, ' dari ',
          JUMLAH_HARI, ' hari');
  writeln(GARIS_GANDA);
end.

9.6 Contoh Keluaran

Laporan Penjualan Mingguan Kopi Nusantara
------------------------------------------

Target harian (Rp)        : 1500000
Pendapatan hari ke-1 (Rp) : 1650000
Pendapatan hari ke-2 (Rp) : 1420000
Pendapatan hari ke-3 (Rp) : 1850000
Pendapatan hari ke-4 (Rp) : 1230000
Pendapatan hari ke-5 (Rp) : 1720000
Pendapatan hari ke-6 (Rp) : 2150000
Pendapatan hari ke-7 (Rp) : 1580000

==========================================
LAPORAN PENJUALAN MINGGUAN
Kopi Nusantara
==========================================
Target harian       : Rp 1500000.00
------------------------------------------
Total mingguan      : Rp 11600000.00
Rata-rata harian    : Rp 1657142.86
Hari tertinggi      : Hari ke-6 (Rp 2150000.00)
Hari terendah       : Hari ke-4 (Rp 1230000.00)
Hari capai target   : 5 dari 7 hari
==========================================

9.7 Pembahasan

Beberapa keputusan perancangan penting pada program ini.

1. Konstanta JUMLAH_HARI. Dengan konstanta, kita dapat mengubah periode laporan (misalnya menjadi 30 hari) hanya dengan mengubah satu nilai. Struktur perulangan menyesuaikan otomatis.
2. Inisialisasi maks/min dengan data pertama. Membaca data pertama sebelum perulangan lalu menginisialisasi maks dan min dengannya menghindari masalah "nilai awal apa yang cocok untuk semua kasus". Bila kita inisialisasi maks dengan 0, kita akan salah bila semua data negatif.
3. Melacak indeks hari. Selain nilai maks dan min, kita juga menyimpan hariMaks dan hariMin. Ini memungkinkan laporan menyebutkan kapan puncak dan lembah terjadi, bukan hanya nilainya.
4. Pencacah hariCapaiTarget. Pola pencacahan ini menghitung berapa kali kondisi tertentu terpenuhi. Pola ini sangat umum dan akan sering muncul pada modul-modul berikutnya.
5. Tipe currency. Semua nilai moneter memakai tipe ini untuk menghindari kesalahan pembulatan.
6. Perulangan dimulai dari 2. Karena data ke-1 sudah dibaca sebelum perulangan, perulangan membaca data ke-2 hingga ke-7. Ini mencegah pembacaan ganda dan memastikan inisialisasi maks/min dari data nyata.

9.8 Pengembangan Selanjutnya

1. Perulangan for adalah perulangan terkendali dengan jumlah iterasi yang sudah diketahui.
2. Arah naik (to) menambah pencacah satu per iterasi hingga mencapai nilai akhir. Arah turun (downto) mengurangi pencacah satu per iterasi.
3. Rentang bersifat inklusif. for i := 1 to 5 menjalankan blok untuk i = 1, 2, 3, 4, 5.
4. Bila nilai awal melewati nilai akhir (untuk to) atau sebaliknya (untuk downto), perulangan tidak dieksekusi sama sekali.
5. Pencacah harus bertipe ordinal: integer, char, boolean, enumerasi, atau subrange.
6. Pencacah tidak boleh diubah di dalam blok perulangan.
7. Blok begin...end diperlukan bila ada lebih dari satu pernyataan.
8. Pola akumulasi untuk menghitung jumlah: inisialisasi akumulator ke 0, lalu total := total + nilai di dalam loop.
9. Pola pencacahan untuk menghitung kemunculan: inisialisasi pencacah ke 0, lalu tambahkan 1 setiap kondisi terpenuhi.
10. Pencarian nilai ekstrem dengan menginisialisasi maks/min dari data pertama, lalu membandingkan setiap nilai berikutnya.
11. Waspadai pembagian dengan nol saat menghitung rata-rata dari data kosong.
12. Jangan bergantung pada nilai pencacah setelah perulangan selesai, karena perilakunya berbeda antar kompiler.

Buku Teks

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

Dokumentasi Resmi

1. Free Pascal Team. Free Pascal Reference Guide. Bab tentang pernyataan for. Tersedia di freepascal.org/docs.html.
2. Free Pascal Team. Free Pascal Programmer's Guide. Bab tentang struktur kontrol dan pencacah ordinal.
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 perilaku nilai pencacah setelah perulangan di berbagai kompiler.