BAB 1: PENDAHULUAN

1.1 KONSEP ALGORITMA

Dalam dunia komputasi dan teknologi informasi, algoritma menempati posisi paling sentral dan fundamental. Komputer tercanggih di dunia dengan kecepatan prosesor bernilai miliaran instruksi per detik pada hakikatnya hanyalah mesin bodoh (electronic calculating machine) yang tidak dapat melakukan apa pun tanpa adanya instruksi logis yang memandunya.

Instruksi-instruksi logis yang menuntun komputer untuk menyelesaikan suatu persoalan secara terstruktur inilah yang disebut sebagai algoritma.

1. Hubungan Masalah, Algoritma, dan Program

Proses pemecahan masalah (problem solving) menggunakan komputer mengikuti rantai transformasi yang berkesinambungan:

+-------------------+       +-----------------------+       +------------------------+       +----------------------+
| MASALAH (PROBLEM) | ----> | ALGORITMA (LOGIKA)    | ----> | PROGRAM (SOURCE CODE)  | ----> | EKSEKUSI KOMPUTER    |
| Dunia Nyata       |       | Rencana Langkah-      |       | Bahasa Pemrograman     |       | Menghasilkan Solusi  |
| Masukan & Sasaran |       | langkah Penyelesaian  |       | (C, Python, Java)      |       | Keluaran yang Benar  |
+-------------------+       +-----------------------+       +------------------------+       +----------------------+

1. Masalah (Problem): Kesenjangan antara kondisi saat ini dengan kondisi yang diharapkan yang memiliki sekumpulan data masukan (input) dan menuntut hasil keluaran (output) tertentu.
2. Algoritma (Algorithm): Rancangan strategi pemecahan masalah berupa urutan langkah logis yang independen dari perangkat keras maupun perangkat lunak.
3. Program (Computer Program): Implementasi konkrit dari algoritma yang ditulis menggunakan sintaks bahasa pemrograman tertentu (seperti C, C++, Pascal, Java, atau Python).
4. Eksekusi (Execution): Proses penerjemahan program oleh kompilator (compiler) atau penerjemah (interpreter) menjadi kode mesin biner (0 dan 1) yang diproses secara fisik oleh CPU dan RAM komputer.

2. Berpikir Komputasional (Computational Thinking)

Merancang algoritma menuntut penguasaan paradigma Berpikir Komputasional (Computational Thinking), yang terdiri atas empat pilar analitis:

+-------------------------------------------------------------------------------+
|                       EMPAT PILAR BERPIKIR KOMPUTASIONAL                      |
+--------------------------+----------------------------------------------------+
| Pilar                    | Peran dalam Perancangan Algoritma                  |
+--------------------------+----------------------------------------------------+
| 1. Dekomposisi           | Memecah masalah besar yang rumit menjadi sub-      |
|    (Decomposition)       | masalah yang lebih kecil dan mudah dikelola.       |
+--------------------------+----------------------------------------------------+
| 2. Pengenalan Pola       | Menemukan kesamaan atau keteraturan dari masalah   |
|    (Pattern Recognition) | yang pernah diselesaikan sebelumnya.               |
+--------------------------+----------------------------------------------------+
| 3. Abstraksi             | Memusatkan perhatian pada informasi yang relevan   |
|    (Abstraction)         | dan mengabaikan detail yang tidak esensial.        |
+--------------------------+----------------------------------------------------+
| 4. Perancangan Algoritma | Menyusun aturan instruksi langkah demi langkah     |
|    (Algorithm Design)    | yang runtut untuk menyelesaikan persoalan.         |
+--------------------------+----------------------------------------------------+

3. Independensi Algoritma terhadap Bahasa Pemrograman

Salah satu prinsip paling esensial yang harus dipahami oleh pemula adalah bahwa algoritma tidak sama dengan bahasa pemrograman:

• Algoritma adalah esensi ide dan logika penyelesaian masalah.
• Bahasa pemrograman adalah media penulisan atau notasi tata bahasa (gramatika).

Sebuah algoritma yang baik bersifat universal: algoritma yang sama untuk mencari nilai terbesar dari sekumpulan angka dapat diekspresikan dengan keanggunan yang sama ke dalam bahasa Python, ketatnya tipe data bahasa C, maupun pendekatan berorientasi objek dalam bahasa Java.

4. Ruang Lingkup Pembahasan Konsep Algoritma

Dalam sub-bab berikutnya, konsep algoritma akan dibedah secara komprehensif melalui lima pilar:

• 1.1.1 Definisi: Pengertian formal, terminologi para pakar, dan batasan komputasi.
• 1.1.2 Catatan Sejarah: Asal-usul nama dari Al-Khwarizmi hingga kontribusi Ada Lovelace dan Alan Turing.
• 1.1.3 Ciri Algoritma: Lima kriteria mutlak Donald E. Knuth (Finiteness, Definiteness, Input, Output, Effectiveness).
• 1.1.4 Sifat Algoritma: Karakteristik deterministik, keteraturan sekuensial, generalitas, dan efisiensi kompleksitas waktu/ruang.
• 1.1.5 Struktur Algoritma: Tiga struktur kontrol pembangun program (Runtunan, Pemilihan, Pengulangan) dan anatomi teks algoritma.

Rangkuman

Konsep algoritma adalah jantung dari ilmu komputer dan rekayasa perangkat lunak. Tanpa penguasaan logika algoritmik yang kuat, seseorang hanya akan menjadi pengetik kode (syntactic coder) tanpa kemampuan memecahkan masalah. Memahami algoritma sebagai jembatan independen antara masalah dunia nyata dengan eksekusi komputer adalah langkah awal terpenting bagi calon perekayasa perangkat lunak.

BAB 1: PENDAHULUAN

1.1.1 DEFINISI ALGORITMA

Kata algoritma memiliki makna yang sangat kaya dan telah didefinisikan oleh berbagai pakar ilmu komputer dan lembaga leksikografi dunia:

1. Definisi Menurut Para Ahli

1. Donald E. Knuth (Pakar Ilmu Komputer Stanford University & Penulis The Art of Computer Programming):

   "Algoritma adalah sekumpulan aturan berhingga (finite set of rules) yang memberikan urutan operasi untuk menyelesaikan suatu jenis masalah tertentu."

2. Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, & Clifford Stein (Penulis Buku Standar MIT Introduction to Algorithms):

   "Secara informal, sebuah algoritma adalah prosedur komputasi yang terdefinisi dengan baik (well-defined computational procedure) yang menerima satu atau sekumpulan nilai sebagai masukan (input) dan menghasilkan satu atau sekumpulan nilai sebagai keluaran (output). Jadi, algoritma adalah urutan langkah-langkah komputasi yang mentransformasikan masukan menjadi keluaran."

3. Kamus Besar Bahasa Indonesia (KBBI):

   "Algoritma adalah prosedur sistematis untuk memecahkan masalah matematis dalam langkah-langkah terbatas; atau urutan logis pengambilan keputusan untuk pemecahan masalah."

4. Dr. Rinaldi Munir (Institut Teknologi Bandung):

   "Algoritma adalah urutan langkah-langkah logis penyelesaian masalah yang disusun secara sistematis dan logis." Kata kuncinya adalah logis—setiap langkah harus bernilai benar atau salah (true/false) dan tidak boleh menimbulkan keraguan bagi pelaksana instruksi.

2. Tiga Unsur Fundamental Definisi Algoritma

Dari berbagai definisi di atas, dapat ditarik kesimpulan bahwa sebuah entitas komputasi baru dapat disebut sebagai algoritma jika memenuhi tiga pilar:

+-------------------------------------------------------------------------------+
|                       TIGA PILAR DEFINISI ALGORITMA                           |
+--------------------------+----------------------------------------------------+
| 1. Urutan Langkah Logis  | Instruksi tidak melompat secara acak, melainkan    |
|    (Logical Sequence)    | memiliki alur penalaran rasional yang teratur.     |
+--------------------------+----------------------------------------------------+
| 2. Keterbatasan Langkah  | Langkah harus berhingga (finite); harus ada titik  |
|    (Finiteness)          | mulai (Start) dan titik henti (Stop/Terminate).    |
+--------------------------+----------------------------------------------------+
| 3. Pencapaian Solusi     | Menghasilkan jawaban yang benar (correctness)      |
|    (Problem Resolution)  | sesuai spesifikasi luaran yang diharapkan.         |
+--------------------------+----------------------------------------------------+

3. Membedakan Algoritma, Pseudocode, Flowchart, dan Program

Sering kali terjadi kerancuan penggunaan istilah di kalangan pemula:

MASALAH DUNIA NYATA
       |
       v
+------------------+
| ALGORITMA        | ---> Ide konseptual, logika pemikiran solusi murni di otak manusia.
+------------------+
   |            \
   |             \ (Dituangkan dalam representasi visual)
   |              +----> +------------------+
   |                     | FLOWCHART        | ---> Bagan alir grafis dengan simbol geometris.
   |                     +------------------+
   v (Dituangkan dalam representasi teks)
+------------------+
| PSEUDOCODE       | ---> Teks semi-formal menyerupai bahasa pemrograman tingkat tinggi.
+------------------+
   |
   v (Diterjemahkan menjadi kode sintaksis komputer)
+------------------+
| PROGRAM          | ---> Kode sumber (.c, .py, .java) yang dapat dikompilasi oleh mesin.
+------------------+

4. Contoh Kasus Ilustrasi Klasik: Menukar Isi Dua Bejana

Untuk memahami logika algoritmik murni tanpa sintaks komputer, perhatikan masalah klasik berikut:

Masalah: Diberikan dua buah bejana, Bejana A berisi air berwarna Merah, dan Bejana B berisi air berwarna Biru. Buatlah algoritma untuk menukarkan isi kedua bejana tersebut sehingga Bejana A berisi air Biru dan Bejana B berisi air Merah! (Catatan: Air tidak boleh tercampur).

   KEADAAN AWAL:                DIBUTUHKAN BANTUAN:               KEADAAN AKHIR:
[ Bejana A ]  [ Bejana B ]        [ Bejana C ]              [ Bejana A ]  [ Bejana B ]
  ( MERAH )     ( BIRU )          ( KOSONG )                  ( BIRU )      ( MERAH )

Langkah Algoritma Solusi:

1. Langkah 1: Siapkan satu buah bejana bantu sementara yang kosong, sebut sebagai Bejana C.
2. Langkah 2: Tuangkan seluruh isi air Merah dari Bejana A ke dalam Bejana C. (Kondisi: A kosong, B berisi Biru, C berisi Merah).
3. Langkah 3: Tuangkan seluruh isi air Biru dari Bejana B ke dalam Bejana A. (Kondisi: A berisi Biru, B kosong, C berisi Merah).
4. Langkah 4: Tuangkan seluruh isi air Merah dari Bejana C ke dalam Bejana B. (Kondisi: A berisi Biru, B berisi Merah, C kembali kosong).
5. Selesai. Solusi tercapai dengan benar.

Logika penukaran dengan variabel perantara C inilah yang diimplementasikan dalam pemrograman komputer ketika menukar nilai dua variabel:

temp := A;
A := B;
B := temp;

Rangkuman

Algoritma adalah cetak biru nalar manusia untuk memecahkan persoalan secara runtut dan terukur. Memahami definisi algoritma secara jernih memampukan kita menyusun solusi secara terstruktur sebelum menyentuh papan ketik komputer untuk menuliskan baris kode program.

BAB 1: PENDAHULUAN

1.1.2 CATATAN SEJARAH ALGORITMA

Konsep algoritma bukanlah penemuan baru di era komputer modern. Sejarahnya merentang panjang melintasi peradaban manusia, berakar dari karya agung para ilmuwan matematika klasik, hingga bertransformasi menjadi fondasi revolusi komputasi elektronik abad ke-20.

1. Asal-Usul Etimologi: Muhammad ibn Musa al-Khwarizmi

Kata algoritma (algorithm) secara historis berasal dari nama seorang ilmuwan polymath, ahli matematika, astronomi, dan geografi terkemuka asal Persia yang bernama Abu Abdullah Muhammad ibn Musa al-Khwarizmi (hidup sekitar tahun 780 – 850 Masehi).

   ASAL MULA NAMA                 TRANSLASI LATIN                TRANSFORMASI MODERN
+--------------------+        +--------------------+        +---------------------+
|   AL-KHWARIZMI     | -----> |  ALGORISMI /       | -----> |      ALGORITHM      |
| (Nama Kota Asal di | (Abad  |  ALGORITMI         | (Abad  | (Makna: Urutan      |
| Khiva, Uzbekistan) |  12)   | (Aturan Berhitung) |  20)   | Langkah Pemecahan)  |
+--------------------+        +--------------------+        +---------------------+

Al-Khwarizmi berkarya di Baitul Hikmah (House of Wisdom) di Baghdad pada masa keemasan peradaban Islam di bawah pemerintahan Khalifah Al-Ma'mun dari Dinasti Abbasiyah. Dua karya tulis monumentalnya mengubah peradaban dunia:

1. Al-Kitāb al-mukhtaṣar fī ḥisāb al-jabr wal-muqābala: Buku pegangan matematika pertama yang menyajikan penyelesaian sistematis persamaan linier dan kuadrat. Kata Al-Jabr dari judul buku inilah yang diserap ke dalam seluruh bahasa dunia menjadi cabang ilmu matematika Aljabar (Algebra).
2. Kitāb al-Jam' wat-Tafrīq bi-Hisāb al-Hind: Kitab yang memperkenalkan sistem penomoran desimal Hindu-Arab (angka 0 sampai 9 dan konsep nilai tempat) ke dunia Barat.

Ketika buku kedua Al-Khwarizmi diterjemahkan ke dalam bahasa Latin pada abad ke-12 dengan judul Algoritmi de numero Indorum, para cendekiawan Eropa melafalkan namanya menjadi Algorismi atau Algoritmi. Pada masa itu, kata algorism diartikan sebagai "seni berhitung menggunakan angka Arab". Seiring berjalannya waktu, istilah tersebut bergeser menjadi algorithm dan maknanya diperluas menjadi sekumpulan instruksi langkah-demi-langkah yang teratur untuk menyelesaikan suatu permasalahan komputasi.

2. Tonggak Sejarah Evolusi Algoritma

Perjalanan algoritma dari coretan nalar di atas kertas perkamen hingga menjadi kode biner digital ditandai oleh empat tonggak peradaban besar:

+-------------------------------------------------------------------------------+
|                       EMPAT TONGGAK UTAMA SEJARAH ALGORITMA                   |
+----------------------+-----------------------------+--------------------------+
| Tokoh & Periode      | Karya Monumental            | Kontribusi bagi Komputasi|
+----------------------+-----------------------------+--------------------------+
| Euclid               | Algoritma Euclidean         | Algoritma tertua untuk   |
| (300 SM)             | (Buku Elements)             | mencari Pembagi Bersama  |
|                      |                             | Terbesar (PBT / GCD).    |
+----------------------+-----------------------------+--------------------------+
| Al-Khwarizmi         | Hisab al-Jabr wa'l-Muqabala | Meletakkan dasar metode  |
| (825 M)              | dan Sistem Angka Desimal    | perhitungan sistematis & |
|                      |                             | asal-usul nama Algoritma.|
+----------------------+-----------------------------+--------------------------+
| Augusta Ada Lovelace | Algoritma Mesin Analitis    | Dinobatkan sebagai       |
| (1843 M)             | (Analytical Engine Babbage) | Pemrogram Komputer       |
|                      |                             | Pertama di Dunia.        |
+----------------------+-----------------------------+--------------------------+
| Alan Turing          | Mesin Turing Universal      | Meletakkan dasar teori   |
| (1936 M)             | (Turing Machine)            | komputabilitas formal    |
|                      |                             | dan batas algoritma.     |
+----------------------+-----------------------------+--------------------------+

A. Algoritma Euclidean (300 SM):

Salah satu algoritma tertua yang masih dipelajari dan digunakan hingga hari ini dirumuskan oleh matematikawan Yunani Kuno, Euclid, untuk mencari Faktor Persekutuan Terbesar (FPB) dari dua bilangan bulat positif tanpa perlu melakukan faktorisasi prima secara manual:

• Bagi bilangan besar dengan bilangan kecil, lalu ganti bilangan besar dengan sisa baginya, ulangi hingga sisa bagi bernilai nol.

B. Augusta Ada Lovelace (1843):

Putri dari penyair Inggris Lord Byron ini bekerja sama dengan Charles Babbage yang merancang mesin hitung mekanis raksasa bernama Analytical Engine.

• Dalam catatannya yang terkenal (Notes on the Analytical Engine), Ada menuliskan urutan instruksi langkah perulangan mekanis untuk menghitung Bilangan Bernoulli.
• Melalui catatan tersebut, Ada Lovelace diakui secara resmi dalam sejarah ilmu komputer sebagai The World's First Computer Programmer.

C. Alan Turing dan Mesin Turing (1936):

Matematikawan jenius Inggris, Alan Mathison Turing, menerbitkan makalah revolusioner berjudul "On Computable Numbers".

• Turing merumuskan model matematis teoretis berupa Mesin Turing (Turing Machine): sebuah mesin pita tak hingga yang mampu membaca, menulis, dan memindahkan kepala pembaca berdasarkan tabel status.
• Konsep ini membuktikan bahwa instruksi algoritmik apa pun di alam semesta dapat dieksekusi oleh mesin mekanis sederhana, sekaligus menjadi fondasi kelahiran komputer elektronik digital modern.

Rangkuman

Catatan sejarah membuktikan bahwa algoritma lahir dari puncak kecerdasan intelektual lintas peradaban manusia: dimulai dari perumusan aljabar dan sistem desimal oleh Al-Khwarizmi di Timur Tengah, dirajut menjadi logika instruksi mesin oleh Ada Lovelace, dan diformalkan menjadi fondasi sains komputasi oleh Alan Turing. Mempelajari sejarah algoritma menumbuhkan apresiasi bahwa di balik setiap baris kode modern terdapat warisan keilmuan yang telah teruji selama ribuan tahun.

BAB 1: PENDAHULUAN

1.1.3 CIRI ALGORITMA

Tidak semua daftar instruksi atau urutan langkah dapat serta-merta disebut sebagai algoritma dalam sains komputasi. Resep memasak kue atau panduan merakit lemari memang memuat langkah-langkah kerja, namun sering kali mengandung instruksi ambigu seperti "masukkan gula secukupnya" atau "aduk hingga mengembang". Instruksi seperti itu mustahil dapat dipahami dan dieksekusi oleh mesin komputer.

Untuk dapat diakui secara sah sebagai algoritma komputasi, pakar ilmu komputer legendaris Donald E. Knuth dalam karya monumentalnya The Art of Computer Programming menetapkan lima ciri mutlak (five essential properties) yang wajib dipenuhi:

+-------------------------------------------------------------------------------+
|                       LIMA CIRI MUTLAK ALGORITMA (DONALD KNUTH)               |
+--------------------------+----------------------------------------------------+
| 1. Keterbatasan          | Harus berhenti setelah sejumlah langkah berhingga; |
|    (Finiteness)          | tidak boleh berjalan tanpa akhir (infinite loop).  |
+--------------------------+----------------------------------------------------+
| 2. Kepastian             | Setiap langkah harus jelas, tidak ambigu, dan      |
|    (Definiteness)        | memiliki interpretasi tunggal yang presisi.        |
+--------------------------+----------------------------------------------------+
| 3. Masukan               | Memiliki nol atau lebih nilai masukan dari luar    |
|    (Input)               | sebelum atau saat eksekusi dimulai.                |
+--------------------------+----------------------------------------------------+
| 4. Keluaran              | Wajib menghasilkan minimal satu nilai luaran       |
|    (Output)              | yang merupakan solusi dari masalah.                |
+--------------------------+----------------------------------------------------+
| 5. Efektivitas           | Setiap instruksi harus realistis dan dapat         |
|    (Effectiveness)       | diselesaikan dalam waktu yang masuk akal.          |
+--------------------------+----------------------------------------------------+

1. Keterbatasan (Finiteness)

Sebuah algoritma harus memiliki akhir. Proses komputasi harus berhenti (terminate) setelah mengeksekusi sejumlah langkah tertentu yang berhingga, baik setelah 5 langkah, 1.000 langkah, maupun 1 juta langkah.

• Kondisi Henti (Stopping Condition): Setiap struktur perulangan wajib memiliki syarat pembatas yang pada akhirnya akan bernilai salah (false).
• Bahaya Perulangan Tanpa Akhir (Infinite Loop): Jika kondisi henti tidak pernah tercapai, komputer akan terjebak dalam eksekusi abadi yang menyebabkan program membeku (hang) dan menghabiskan daya baterai atau memori RAM.

  { CONTOH SALAH: Melanggar Ciri Finiteness }
  i := 1;
  while (i > 0) do
  begin
      write(i);
      i := i + 1; { Nilai i selalu lebih besar dari 0, tidak akan pernah berhenti! }
  end;
  

2. Kepastian (Definiteness)

Setiap langkah komputasi harus terdefinisi secara pasti, tepat, tegas, dan tidak bermakna ganda (unambiguous).

• Tidak boleh ada keraguan bagi pelaksana algoritma mengenai tindakan apa yang harus diambil pada setiap detik eksekusi.
• Contoh Ambigu (Salah): "Bagi angka X dengan angka Y" (Jika $Y=0$, operasi pembagian dengan nol tidak terdefinisi dan sistem akan crash!).
• Contoh Pasti (Benar): "Jika $Y \neq 0$, maka hitung $Z = X / Y$; jika $Y = 0$, tampilkan pesan kesalahan 'Pembagi tidak boleh nol'!".

3. Masukan (Input)

Algoritma memiliki nol atau lebih masukan (inputs) yang diberikan kepada sistem:

• Masukan adalah besaran data yang disuplai sebelum algoritma mulai bekerja atau dibaca secara interaktif dari pengguna (keyboard, berkas dokumen, sensor).
• Mengapa Nol Masukan Diizinkan? Sebuah algoritma tetap sah meskipun tidak memerlukan masukan sama sekali dari luar, selama nilai datanya telah didefinisikan secara internal di dalam algoritma itu sendiri.
  • Contoh: Algoritma untuk mencetak teks "Selamat Datang Mahasiswa Baru", atau algoritma untuk menghitung dan mencetak nilai konstanta matematika $\pi$ hingga 50 digit desimal.

4. Keluaran (Output)

Algoritma wajib menghasilkan minimal satu atau lebih keluaran (outputs):

• Keluaran adalah hasil akhir pemrosesan yang memiliki hubungan logis dengan masukan yang diberikan.
• Keluaran dapat berupa nilai angka, pesan teks di layar monitor, berkas laporan di hard disk, sinyal kontrol aktuator robot, atau perubahan status basis data.
• Algoritma yang tidak menghasilkan keluaran apa pun adalah algoritma yang tidak berguna (useless), karena tujuan utama dari algoritma adalah memecahkan masalah dan mengomunikasikan hasilnya kepada dunia luar.

5. Efektivitas (Effectiveness)

Setiap instruksi di dalam algoritma harus bersifat efektif dan mendasar (sufficiently basic / primitive):

• Setiap langkah harus dapat dikerjakan secara fisik oleh manusia menggunakan pensil dan kertas dalam rentang waktu yang wajar dan realistis.
• Contoh Instruksi yang Tidak Efektif: "Carilah seluruh bilangan bulat prima terbesar di alam semesta sebelum melanjutkan ke langkah berikutnya" (Instruksi ini mustahil dapat diselesaikan karena bilangan prima berjumlah tak hingga).

Rangkuman

Kelima ciri Donald E. Knuth (Finiteness, Definiteness, Input, Output, Effectiveness) adalah filter penentu yang membedakan antara sekadar rangkaian kalimat bebas dengan algoritma komputasi sejati. Setiap pemrogram yang menyusun algoritma wajib menguji rancangannya terhadap kelima kriteria ini untuk memastikan solusinya valid, andal, dan siap dieksekusi oleh mesin.

BAB 1: PENDAHULUAN

1.1.4 SIFAT ALGORITMA

Di samping lima ciri formal yang dirumuskan oleh Donald E. Knuth, sebuah algoritma yang dirancang dalam rekayasa perangkat lunak memiliki sifat-sifat hakiki (intrinsic properties) yang menentukan kualitas, keanggunan (elegance), dan efisiensi implementasinya di dunia nyata.

Sifat-Sifat Utama Algoritma

+-------------------------------------------------------------------------------+
|                         LIMA SIFAT INTRINSIK ALGORITMA                        |
+--------------------------+----------------------------------------------------+
| Sifat                    | Makna dan Karakteristik dalam Komputasi            |
+--------------------------+----------------------------------------------------+
| 1. Independen Bahasa     | Berdiri sendiri; tidak terikat pada dialek atau    |
|    (Language Independent)| aturan sintaks dari bahasa pemrograman tertentu.   |
+--------------------------+----------------------------------------------------+
| 2. Keteraturan Urutan    | Setiap langkah memiliki presedensi kronologis      |
|    (Sequential Ordering) | yang tidak boleh ditukar sembarangan.              |
+--------------------------+----------------------------------------------------+
| 3. Generalitas           | Mampu menyelesaikan seluruh kelas persoalan yang   |
|    (Generality)          | sama untuk sembarang rentang nilai masukan sah.    |
+--------------------------+----------------------------------------------------+
| 4. Deterministik         | Menghasilkan keluaran yang konsisten sama jika     |
|    (Determinism)         | diberikan himpunan masukan yang sama persis.       |
+--------------------------+----------------------------------------------------+
| 5. Efisiensi Sumber Daya | Meminimalkan waktu eksekusi CPU dan konsumsi       |
|    (Efficiency)          | alokasi memori RAM (diukur via Notasi Big-O).      |
+--------------------------+----------------------------------------------------+

1. Independensi terhadap Bahasa Pemrograman (Language Independence)

Sifat paling mendasar dari algoritma adalah kebebasannya dari belenggu bahasa pemrograman.

• Algoritma ditulis pada tingkat konseptual menggunakan notasi yang universal (seperti bahasa alami terstruktur atau pseudocode).
• Sebagai perbandingan: sebuah resep makanan yang ditulis dalam bahasa Indonesia, Inggris, maupun Prancis tetap merupakan resep yang sama selama komposisi dan langkahnya identik.
• Demikian pula algoritma pencarian biner (Binary Search) memiliki esensi logika yang persis sama, baik diimplementasikan menggunakan bahasa tingkat rendah seperti Assembly, bahasa terstruktur seperti C, maupun bahasa modern seperti Python dan Java.

2. Keteraturan dan Presedensi Urutan (Sequential Ordering)

Langkah-langkah di dalam algoritma tersusun secara berurutan dan memiliki keterikatan logis yang ketat (flow of control):

• Mengubah urutan dua baris instruksi dapat berakibat fatal pada kebenaran hasil.
• Contoh Kesalahan Presedensi:

  URUTAN SALAH:                         URUTAN BENAR:
  1. Hitung Luas = Panjang * Lebar      1. Masukkan nilai Panjang dan Lebar
  2. Masukkan nilai Panjang dan Lebar   2. Hitung Luas = Panjang * Lebar
  

  Pada urutan yang salah, komputer mencoba mengalikan variabel sebelum nilainya diinput dari pengguna, menghasilkan nilai sampah (garbage value).

3. Generalitas (Generality / Universality)

Algoritma yang bermutu tinggi tidak dirancang khusus hanya untuk menyelesaikan satu angka tertentu (hardcoded), melainkan memiliki cakupan penyelesaian yang umum:

• Algoritma yang Buruk: Algoritma yang hanya bisa menghitung luas segitiga jika alasnya 10 dan tingginya 5.
• Algoritma yang Baik (General): Algoritma yang menerima parameter variabel $a$ dan $t$ untuk sembarang nilai bilangan riil positif, sehingga dapat digunakan berulang kali untuk jutaan kasus perhitungan yang berbeda.

4. Sifat Deterministik (Determinism)

Sebagian besar algoritma komputasi standar bersifat deterministik:

• Jika algoritma dijalankan 100 kali dengan nilai masukan $X$ yang sama pada kondisi awal yang sama, algoritma tersebut dijamin akan menempuh langkah-langkah yang identik dan menghasilkan keluaran $Y$ yang persis sama pada setiap percobaan.
• Tidak ada unsur ketidakpastian atau kebetulan gaib dalam eksekusinya. (Catatan: Dalam bidang lanjut terdapat algoritma probabilistik/acak yang menggunakan pembangkit bilangan acak untuk heuristik optimasi, namun logika alurnya tetap terukur secara statistik).

5. Efisiensi Sumber Daya (Resource Efficiency)

Dua buah algoritma yang berbeda dapat sama-sama menghasilkan jawaban yang benar untuk masalah yang sama, namun dengan efisiensi yang sangat bertolak belakang. Efisiensi algoritma diukur dalam dua dimensi:

1. Kompleksitas Waktu ($T(n)$): Berapa banyak jumlah operasi instruksi dasar yang dieksekusi seiring bertambahnya ukuran data masukan $n$.
2. Kompleksitas Ruang ($S(n)$): Berapa banyak alokasi memori RAM tambahan yang dibutuhkan selama proses eksekusi berlangsung.

Dalam ilmu komputer, efisiensi ini dinyatakan melalui Notasi Asimtotik Big-O ($\mathcal{O}$):

Tingkat Efisiensi:
[ PALING CEPAT / EFISIEN ]                                   [ PALING LAMBAT / BOROS ]
  O(1) --------> O(log n) --------> O(n) --------> O(n^2) --------> O(2^n)
 Konstanta      Logaritmik        Linier         Kuadratik       Eksponensial

Contoh Kasus: Untuk mencari satu nama di antara 1.000.000 data:

• Algoritma Pencarian Linier ($\mathcal{O}(n)$) membutuhkan hingga 1.000.000 kali perbandingan.
• Algoritma Pencarian Biner ($\mathcal{O}(\log n)$) hanya membutuhkan maksimal 20 kali perbandingan!

Rangkuman

Sifat-sifat algoritma—mulai dari independensi bahasa, keteraturan urutan, generalitas, sifat deterministik, hingga efisiensi komputasi—menjadi standar keunggulan dalam rekayasa perangkat lunak. Program yang hebat tidak hanya sekadar berjalan menghasilkan jawaban yang benar, melainkan dibangun di atas algoritma yang elegan, hemat sumber daya, dan tahan uji.

BAB 1: PENDAHULUAN

1.1.5 STRUKTUR ALGORITMA

Dalam teori sains komputer, Teorema Struktur Program Böhm-Jacopini (1966) membuktikan bahwa program komputer serumit apa pun—mulai dari aplikasi kalkulator sederhana hingga sistem operasi pesawat antariksa—pada dasarnya dapat disusun hanya dengan mengombinasikan tiga struktur kontrol dasar: Runtunan (Sequence), Pemilihan (Selection), dan Pengulangan (Repetition).

Tiga Struktur Kontrol Pembangun Algoritma

    A. RUNTUNAN (SEQUENCE)               B. PEMILIHAN (SELECTION)             C. PENGULANGAN (REPETITION)
       [ Instruksi 1 ]                           < Kondisi? >                       +---> < Kondisi? >
             |                                    /        \                        |        /     \
             v                                  Ya          Tidak                   |      Ya       Tidak
       [ Instruksi 2 ]                         /              \                     |      /          \
             |                           [ Instruksi A ] [ Instruksi B ]            |  [ Badan ]       v
             v                                 \              /                     +--[  Loop ]    (Lanjut)
       [ Instruksi 3 ]                          +------+-----+

1. Struktur Runtunan (Sequence Structure)

Struktur runtunan adalah struktur paling mendasar di mana instruksi-instruksi dieksekusi secara berurutan baris demi baris, dari atas ke bawah, tanpa ada percabangan arah atau pengulangan langkah.

• Setiap baris instruksi hanya dikerjakan tepat satu kali setelah instruksi sebelumnya selesai dikerjakan secara tuntas.

Contoh Pseudocode Runtunan (Menghitung Luas Persegi Panjang):

program HitungLuasPersegiPanjang
{ Menghitung luas persegi panjang dari masukan panjang dan lebar }

deklarasi:
    panjang, lebar, luas : real

deskripsi:
    read(panjang)
    read(lebar)
    luas <- panjang * lebar
    write(luas)

2. Struktur Pemilihan / Percabangan (Selection Structure)

Struktur pemilihan digunakan ketika langkah komputasi harus memilih satu dari beberapa alternatif jalur eksekusi berdasarkan pengujian kondisi logika Boolean bernilai Benar (True) atau Salah (False).

Varian Bentuk Percabangan:

1. Percabangan Satu Kondisi (IF - THEN): Aksi hanya dikerjakan jika kondisi bernilai True; jika False, tidak ada tindakan apa pun.
2. Percabangan Dua Kondisi (IF - THEN - ELSE): Mengerjakan Aksi 1 jika kondisi True, atau mengerjakan Aksi 2 jika kondisi False.
3. Percabangan Majemuk / Banyak Arah (DEPENDS ON / SWITCH - CASE): Memilih satu aksi di antara banyak alternatif nilai pembanding diskrit.

Contoh Pseudocode Pemilihan (Menentukan Bilangan Genap/Ganjil):

program CekGenapGanjil
{ Menentukan apakah sebuah bilangan bulat adalah genap atau ganjil }

deklarasi:
    bilangan : integer

deskripsi:
    read(bilangan)
    if (bilangan mod 2 = 0) then
        write("Bilangan Genap")
    else
        write("Bilangan Ganjil")
    endif

3. Struktur Pengulangan (Repetition / Iteration Structure)

Struktur pengulangan digunakan untuk mengeksekusi sekumpulan instruksi yang sama secara berulang kali selama suatu kondisi tertentu masih terpenuhi. Pengulangan mengeliminasi keharusan menulis baris kode yang sama berulang-ulang.

Tiga Konstruksi Pengulangan:

1. Konstruksi WHILE - DO (Entry-Controlled Loop): Kondisi diuji di awal sebelum badan perulangan dikerjakan. Jika kondisi sudah bernilai salah sejak awal, badan perulangan tidak akan dikerjakan sama sekali (0 kali).
2. Konstruksi REPEAT - UNTIL (Exit-Controlled Loop): Kondisi diuji di akhir setelah badan perulangan dikerjakan. Badan perulangan dijamin dikerjakan minimal satu kali (1 kali).
3. Konstruksi FOR (Counter-Controlled Loop): Digunakan ketika jumlah perulangan sudah diketahui secara pasti di awal (misalnya mengulang sebanyak 10 kali).

Contoh Pseudocode Pengulangan (Mencetak Angka 1 sampai 5 dengan FOR):

program CetakAngka
deklarasi:
    i : integer

deskripsi:
    for i <- 1 to 5 do
        write(i)
    endfor

Anatomi Standar Teks Algoritma

Dalam konvensi akademik ilmu komputer (seperti pada standar notasi Rinaldi Munir), sebuah teks algoritma yang terstruktur secara profesional dibagi menjadi Tiga Bagian Utama:

+-------------------------------------------------------------------------------+
|                       STRUKTUR TEKS ALGORITMA STANDAR                         |
+-------------------------------------------------------------------------------+
| 1. BAGIAN JUDUL        | Memuat nama algoritma dan penjelasan ringkas         |
|    (Algorithmic Header)| mengenai spesifikasi masalah, masukan, dan keluaran. |
+------------------------+------------------------------------------------------+
| 2. BAGIAN DEKLARASI    | Tempat mendefinisikan seluruh variabel, konstanta,   |
|    (Declaration Part)  | tipe data bentukan, dan nama prosedur/fungsi.        |
+------------------------+------------------------------------------------------+
| 3. BAGIAN DESKRIPSI    | Memuat inti langkah-langkah logika pemecahan masalah |
|    (Description Part)  | yang ditulis menggunakan notasi pseudocode.          |
+------------------------+------------------------------------------------------+

Contoh Teks Algoritma Utuh yang Menggabungkan Ketiganya:

program HitungFaktorial
{ Menghitung nilai faktorial N! = 1 * 2 * ... * N dari masukan bilangan bulat N >= 0 }

deklarasi:
    N, i : integer
    faktorial : longint

deskripsi:
    read(N)
    if (N < 0) then
        write("Nilai N tidak boleh negatif!")
    else
        faktorial <- 1
        for i <- 1 to N do
            faktorial <- faktorial * i
        endfor
        write("Hasil Faktorial = ", faktorial)
    endif

Rangkuman

Struktur algoritma bertumpu pada fondasi kokoh Teorema Böhm-Jacopini: seluruh program di dunia tersusun dari kombinasi Runtunan, Pemilihan, dan Pengulangan. Dengan mengorganisasikan kode ke dalam tiga bagian baku (Judul, Deklarasi, dan Deskripsi), algoritma yang kita bangun akan memiliki keterbacaan yang tinggi, mudah dipahami, serta mudah ditranslasikan ke dalam bahasa pemrograman apa pun.

BAB 1: PENDAHULUAN

1.2 FLOWCHARTING

Dalam perancangan algoritma, menyusun logika hanya dalam bentuk teks terkadang menyulitkan pemahaman alur kerja yang kompleks, terutama ketika melibatkan banyak percabangan dan perulangan bersarang. Untuk memvisualisasikan alur penyelesaian masalah secara intuitif, para perekayasa perangkat lunak menggunakan metode Bagan Alir (Flowcharting).

Bagan Alir (Flowchart) adalah representasi grafis visual dari langkah-langkah instruksi suatu algoritma yang menggunakan simbol-simbol geometris standar industri (berdasarkan standar ANSI / ISO) yang saling dihubungkan dengan garis panah berarah untuk menunjukkan jalannya eksekusi program.

1. Simbol-Simbol Standar Flowchart (ANSI/ISO)

Setiap simbol geometris dalam flowchart memiliki makna fungsional yang spesifik dan tidak boleh dipertukarkan penggunaannya:

+-------------------------------------------------------------------------------+
|                       TABEL SIMBOL STANDAR FLOWCHART (ANSI/ISO)               |
+----------------------+-----------------------------+--------------------------+
| Nama Simbol          | Bentuk Geometris            | Fungsi dan Keterangan    |
+----------------------+-----------------------------+--------------------------+
| 1. Terminator        | Oval / Persegi Berujung     | Menandai titik awal      |
|                      | Melengkung                  | (Mulai/Start) dan akhir  |
|                      |                             | (Selesai/End) algoritma. |
+----------------------+-----------------------------+--------------------------+
| 2. Input / Output    | Jajaran Genjang             | Operasi pembacaan data   |
|    (Data)            | (Parallelogram)             | (read/input) atau cetak  |
|                      |                             | hasil data (write/print).|
+----------------------+-----------------------------+--------------------------+
| 3. Proses            | Persegi Panjang             | Operasi kalkulasi rumus  |
|    (Process)         | (Rectangle)                 | matematika atau penugasan|
|                      |                             | nilai variabel (assign). |
+----------------------+-----------------------------+--------------------------+
| 4. Keputusan         | Belah Ketupat               | Pengujian kondisi logika |
|    (Decision)        | (Diamond)                   | dengan dua cabang jalur: |
|                      |                             | "Ya" (True) / "Tidak"(F).|
+----------------------+-----------------------------+--------------------------+
| 5. Persiapan         | Segi Enam                   | Penyiapan nilai awal atau|
|    (Preparation)     | (Hexagon)                   | inisialisasi variabel    |
|                      |                             | pencacah perulangan FOR. |
+----------------------+-----------------------------+--------------------------+
| 6. Sub-Program       | Persegi Panjang Bergaris    | Pemanggilan prosedur     |
|    (Predefined Proc) | Ganda di Sisi Kiri-Kanan    | atau fungsi modular yang |
|                      |                             | terdefinisi di tempat lain|
+----------------------+-----------------------------+--------------------------+
| 7. On-Page Connector | Lingkaran Kecil             | Penghubung alur pada satu|
|                      | (Small Circle)              | halaman yang sama untuk  |
|                      |                             | menghindari garis silang.|
+----------------------+-----------------------------+--------------------------+
| 8. Off-Page Connector| Segi Lima Terbalik          | Penghubung alur jika     |
|                      | (Pentagon)                  | diagram bersambung ke    |
|                      |                             | lembar halaman lain.     |
+----------------------+-----------------------------+--------------------------+
| 9. Garis Alir        | Garis Panah Berarah         | Menunjukkan arah urutan  |
|    (Flowline)        | (Directional Arrow)         | jalannya eksekusi program|
+----------------------+-----------------------------+--------------------------+

2. Pedoman dan Kaidah Perancangan Flowchart yang Baik

Agar flowchart mudah dibaca, konsisten, dan bebas dari cacat logika, perancang wajib mematuhi aturan baku berikut:

1. Arah Aliran Standar: Bagan alir selalu digambar mengalir dari atas ke bawah (top-to-bottom) atau dari kiri ke kanan (left-to-right).
2. Titik Awal dan Titik Akhir yang Jelas: Sebuah flowchart harus memiliki tepat satu simbol Terminator Mulai (Start), dan harus bermuara pada minimal satu simbol Terminator Selesai (End).
3. Kaidah Simbol Keputusan (Decision Box): Simbol belah ketupat harus memiliki tepat satu garis alir masuk dan minimal dua garis alir keluar yang masing-masing diberi label yang tegas (misal: "Ya" / "Tidak").
4. Hindari Persilangan Garis (No Intersecting Lines): Garis alir tidak boleh saling memotong sembarangan karena akan membingungkan pembaca. Jika alur terlalu rumit atau panjang, gunakan simbol Konektor (On-Page Connector).
5. Bahasa Ringkas dan Padat: Teks di dalam simbol harus ringkas, padat, dan langsung pada inti operasi (misal: "Hitung Luas = P * L" atau "Nilai >= 60?").

3. Contoh Kasus Nyata: Menentukan Kelulusan Mahasiswa

Perhatikan perancangan flowchart berikut untuk menentukan status kelulusan mahasiswa berdasarkan nilai ujian:

flowchart TD
    Start([Mulai]) --> InputData[/Input Nilai Ujian/]
    InputData --> CekNilai{Nilai >= 60?}
    CekNilai -- Ya --> CetakLulus[/Tampilkan 'LULUS'/]
    CekNilai -- Tidak --> CetakGagal[/Tampilkan 'TIDAK LULUS'/]
    CetakLulus --> Selesai([Selesai])
    CetakGagal --> Selesai

Penjelasan Alur:

1. Program dimulai pada simbol Terminator [Mulai].
2. Alur turun ke simbol Input [/Input Nilai Ujian/] untuk membaca angka nilai dari pengguna.
3. Alur masuk ke simbol Decision {Nilai >= 60?}:
   • Jika kondisi bernilai Ya (Nilai $\ge$ 60), alur bercabang ke kanan dan menampilkan pesan "LULUS".
   • Jika kondisi bernilai Tidak (Nilai $<$ 60), alur bercabang ke kiri dan menampilkan pesan "TIDAK LULUS".
4. Kedua cabang bertemu kembali menuju satu titik akhir pada simbol Terminator ([Selesai]).

4. Perbandingan Flowchart vs. Pseudocode

Kedua metode representasi algoritma memiliki keunggulan dan kelemahan masing-masing:

+------------------------------------+------------------------------------+
| Flowchart (Representasi Grafis)    | Pseudocode (Representasi Teks)     |
+------------------------------------+------------------------------------+
| Kelebihan:                         | Kelebihan:                         |
| - Sangat visual dan mudah dipahami | - Sangat ringkas dan hemat tempat  |
|   oleh orang awam/pemula.          | - Sangat mudah ditranslasikan      |
| - Cacat logika mudah terdeteksi.   |   langsung ke kode pemrograman.    |
| Kelemahan:                         | Kelemahan:                         |
| - Memakan banyak halaman kertas    | - Kurang visual; alur percabangan  |
|   untuk program yang panjang.      |   rumit sulit dibayangkan seketika |
| - Sulit dimodifikasi jika ada satu |   oleh pemula.                     |
|   langkah yang harus disisipkan.   |                                    |
+------------------------------------+------------------------------------+

Rangkuman

Flowcharting adalah keterampilan dasar yang sangat berharga bagi pemrogram untuk memetakan alur pemikiran sebelum dituangkan ke dalam kode. Dengan menguasai simbol-simbol standar ANSI/ISO, menaati kaidah arah aliran, dan memahami perbandingannya dengan pseudocode, seorang perekayasa perangkat lunak dapat merancang solusi komputasi yang jelas, terstruktur, dan mudah dikomunikasikan kepada seluruh tim pengembang.

BAB 2: TIPE DATA, VARIABEL, NILAI, DAN EKSPRESI

2.1 TIPE DATA

Dalam merancang algoritma dan program komputer, data adalah bahan mentah utama yang diolah oleh instruksi pemrosesan. Namun, data di dunia nyata sangat beragam: ada data berupa angka bulat (seperti umur atau jumlah anak), data berkoma pecahan (seperti tinggi badan atau indeks prestasi kumulatif), data huruf (seperti inisial nama atau golongan darah), serta data bernilai logika benar/salah (seperti status kelulusan).

Komputer tidak dapat memperlakukan seluruh data tersebut secara seragam. Setiap data harus diberi kategori atau label yang jelas. Kategori pengelompokan inilah yang disebut sebagai Tipe Data (Data Type).

1. Definisi Tipe Data

Tipe Data adalah klasifikasi yang menentukan jenis nilai yang dapat ditampung oleh suatu variabel, besaran alokasi memori yang dibutuhkan di komputer, serta himpunan operasi yang sah yang dapat dikenakan terhadap data tersebut.

+-------------------------------------------------------------------------------+
|                       TIGA ELEMEN PENENTU TIPE DATA                           |
+--------------------------+----------------------------------------------------+
| Elemen                   | Penjelasan dan Implikasi Teknis                    |
+--------------------------+----------------------------------------------------+
| 1. Domain Nilai          | Rentang himpunan nilai yang sah yang boleh dimiliki|
|    (Value Domain)        | oleh data (misal: Boolean hanya bernilai {T, F}).  |
+--------------------------+----------------------------------------------------+
| 2. Alokasi Memori        | Jumlah byte fisik memori RAM yang dialokasikan     |
|    (Memory Footprint)    | oleh sistem operasi (misal: 1 byte, 4 byte, 8 byte)|
+--------------------------+----------------------------------------------------+
| 3. Operasi yang Sah      | Kumpulan operator matematika/logika yang diizinkan |
|    (Valid Operations)    | (misal: angka boleh dikalikan, teks tidak boleh).  |
+--------------------------+----------------------------------------------------+

Contoh Analogi: Mengalikan dua buah angka ($5 \times 3 = 15$) adalah operasi yang sah dan bermakna logis. Namun, mengalikan dua buah nama orang ($"Budi" \times "Siti"$) adalah operasi yang tidak terdefinisi dan tidak sah. Tipe data mencegah terjadinya kesalahan operasi semacam ini sejak dini.

2. Klasifikasi dan Taksonomi Tipe Data

Secara garis besar, tipe data dalam ilmu komputasi diklasifikasikan ke dalam hierarki berikut:

                                  [ TIPE DATA ]
                                        |
         +------------------------------+------------------------------+
         |                                                             |
   [ TIPE DASAR ]                                               [ TIPE BENTUKAN ]
 (Primitive / Basic)                                         (User-Defined / Composite)
   - Integer (Bilangan Bulat)                                  - Rekaman / Struct (Record)
   - Real / Float (Bilangan Riil)                              - Larik / Array
   - Char (Karakter Tunggal)                                   - Enumerasi (Enum)
   - Boolean (Logika Benar/Salah)                              - Rentang (Subrange)
   - String (Untaian Teks)                                     - Pointer (Penunjuk Memori)

1. Tipe Dasar (Primitive / Atomic Data Types): Tipe data standar bawaan sistem yang sifatnya atomik (tunggal dan tidak dapat diurai lagi menjadi bagian yang lebih kecil). Pembahasan lengkap disajikan pada Sub-bab 2.1.1.
2. Tipe Bentukan (Composite / User-Defined Data Types): Tipe data yang didefinisikan sendiri oleh pemrogram dengan cara merangkai atau mengombinasikan satu atau beberapa tipe dasar untuk memodelkan struktur data yang lebih rumit. Pembahasan lengkap disajikan pada Sub-bab 2.1.2.

3. Sistem Pengecekan Tipe Data (Type Systems)

Dalam implementasinya ke bahasa pemrograman, terdapat dua mazhab penanganan tipe data:

1. Bahasa Bertipe Statis (Statically Typed Languages): Tipe data variabel harus dideklarasikan secara eksplisit di awal sebelum program dijalankan. Kompilator akan memeriksa kesesuaian tipe data pada saat kompilasi.
   • Contoh Bahasa: C, C++, Pascal, Java, Rust.
   • Kelebihan: Sangat aman, meminimalkan bug runtime, dan eksekusi program sangat cepat.
2. Bahasa Bertipe Dinamis (Dynamically Typed Languages): Tipe data tidak perlu dideklarasikan secara manual; interpreter secara otomatis menentukan tipe data berdasarkan nilai yang dimasukkan saat program sedang berjalan.
   • Contoh Bahasa: Python, JavaScript, PHP.
   • Kelebihan: Sangat fleksibel dan cepat untuk penulisan skrip prototipe.

Rangkuman

Tipe data adalah fondasi integritas komputasi. Dengan memahami definisi, batasan domain nilai, dan aturan operasi yang berlaku pada masing-masing tipe data, pemrogram dapat merancang struktur data yang efisien, hemat memori, dan bebas dari kesalahan kalkulasi logika.

BAB 2: TIPE DATA, VARIABEL, NILAI, DAN EKSPRESI

2.1.1 TIPE DASAR

Tipe Dasar (Primitive Data Types) adalah tipe data standar baku yang disediakan langsung oleh hampir semua bahasa pemrograman dan mesin komputasi. Tipe dasar bersifat atomik, artinya nilainya bersifat tunggal dan tidak dapat dipecah-pecah lagi menjadi elemen yang lebih kecil.

Dalam algoritma dan pemrograman terstruktur, terdapat lima tipe dasar utama: Bilangan Bulat (Integer), Bilangan Riil (Real), Karakter (Char), Logika (Boolean), dan Teks (String).

1. Bilangan Bulat (Integer)

Tipe Integer digunakan untuk menampung data angka yang tidak memiliki komponen pecahan desimal, mencakup bilangan bulat negatif, nol, dan bilangan bulat positif.

+-------------------------------------------------------------------------------+
|                       HIERARKI UKURAN TIPE DATA INTEGER                       |
+----------------------+---------------+----------------------------------------+
| Nama Sub-Tipe        | Alokasi Memori| Rentang Nilai yang Sah                 |
+----------------------+---------------+----------------------------------------+
| Byte / Unsigned Char | 1 Byte (8 bit)| 0 s/d 255                              |
| Short Integer        | 2 Byte (16 bit)| -32.768 s/d 32.767                     |
| Standard Integer     | 4 Byte (32 bit)| -2.147.483.648 s/d 2.147.483.647       |
| Long Integer         | 8 Byte (64 bit)| -9.223.372.036.854.775.808 s/d ...     |
+----------------------+---------------+----------------------------------------+

Operator Aritmatika pada Integer:

• Penjumlahan (+) & Pengurangan (-): $15 + 4 = 19$, $15 - 4 = 11$.
• Perkalian (*): $15 \times 4 = 60$.
• Pembagian Bulat (div): Menghasilkan hasil bagi bulat dengan membuang sisa pecahan: $$15\ \mathbf{div}\ 4 = 3$$
• Sisa Pembagian / Modulus (mod atau %): Menghasilkan sisa bagi dari pembagian bulat: $$15\ \mathbf{mod}\ 4 = 1\quad \text{(karena } 15 = (3 \times 4) + \mathbf{1}\text{)}$$

Catatan Operasi: Operator mod sangat krusial dalam algoritma untuk memeriksa kelipatan bilangan (misal: jika $X \bmod 2 = 0$, maka $X$ adalah bilangan genap).

2. Bilangan Riil (Real / Floating-Point)

Tipe Real digunakan untuk menampung data angka yang memiliki bagian pecahan berkoma (desimal) atau rentang nilai yang sangat besar/kecil menggunakan format notasi ilmiah eksponensial.

• Contoh Nilai Riil Desimal: 3.14159, -0.0075, 125.50.
• Notasi Ilmiah Eksponensial:
  • 1.75e4 bermakna $1.75 \times 10^4 = 17.500$
  • 3.2e-3 bermakna $3.2 \times 10^{-3} = 0.0032$

Standar Presisi IEEE 754:

1. Presisi Tunggal (Single Precision / Float): Dialokasikan sebesar 4 byte (32 bit), memberikan ketelitian hingga 7 digit desimal.
2. Presisi Ganda (Double Precision / Double): Dialokasikan sebesar 8 byte (64 bit), memberikan ketelitian hingga 15–17 digit desimal.

Catatan Operator: Operator pembagian riil menggunakan simbol garis miring biasa (/). Berbeda dengan div, pembagian riil mempertahankan angka desimal: $15 / 4 = 3.75$.

3. Karakter (Char)

Tipe Char digunakan untuk merepresentasikan satu simbol karakter tunggal. Karakter ditulis dengan diapit oleh tanda petik tunggal ('...').

• Contoh Nilai: 'A', 'z', '9', '%', ' ' (karakter spasi).
• Pengkodean Karakter (ASCII): Setiap karakter disimpan di memori komputer sebagai kode bilangan bulat standar ASCII (0–127).
  • Karakter 'A' memiliki kode ASCII $65$.
  • Karakter 'B' memiliki kode ASCII $66$.
  • Karakter '0' memiliki kode ASCII $48$.
• Fungsi Ordinal Karakter:
  • ord('A') menghasilkan angka $65$.
  • chr(65) menghasilkan karakter 'A'.
• Karakter dapat dibandingkan menggunakan operator relasional berdasarkan nilai ordinalnya: 'A' < 'B' bernilai True karena $65 < 66$.

4. Logika (Boolean)

Tipe data Boolean diambil dari nama matematikawan Inggris George Boole. Tipe ini hanya memiliki tepat dua kemungkinan nilai kebenaran: $$\mathbf{Domain} = {\mathbf{true},\ \mathbf{false}}$$

Operator Logika Boolean:

• not (Negasi/Kebalikan): Membalikkan nilai logika.
• and (Konjungsi): Bernilai true hanya jika kedua belah pihak bernilai true.
• or (Disjungsi): Bernilai true jika salah satu atau kedua pihak bernilai true.
• xor (Exclusive Or): Bernilai true jika kedua belah pihak memiliki nilai logika yang berbeda.

+-------------------------------------------------------------------------------+
|                       TABEL KEBENARAN OPERATOR BOOLEAN                        |
+-------+-------+-------------+-------------+------------+----------------------+
|   P   |   Q   |   not P     |   P and Q   |   P or Q   |        P xor Q       |
+-------+-------+-------------+-------------+------------+----------------------+
| true  | true  |   false     |    true     |    true    |         false        |
| true  | false |   false     |    false    |    true    |         true         |
| false | true  |   true      |    false    |    true    |         true         |
| false | false |   true      |    false    |    false   |         false        |
+-------+-------+-------------+-------------+------------+----------------------+

5. Teks (String)

Tipe String adalah kumpulan atau untaian dari nol atau lebih karakter yang diapit oleh tanda petik ganda ("...") atau petik tunggal.

• Contoh Nilai: "Teknik Informatika", "20261", "" (string kosong / empty string).
• Operasi Penggabungan (Concatenation): Menggunakan operator +:

  "Belajar " + "Algoritma"  --->  "Belajar Algoritma"
  

• Fungsi Panjang String (length): Menghitung jumlah karakter di dalam string:

  length("Informatika")     --->  11
  

Tabel Ringkasan Tipe Dasar

Rangkuman

Kelima tipe dasar (Integer, Real, Char, Boolean, dan String) adalah batu bata penyusun seluruh struktur data di komputer. Pemilihan tipe dasar yang tepat akan menjamin program dapat melakukan komputasi aritmatika dan evaluasi logika dengan presisi tinggi serta mengonsumsi alokasi memori secara optimal.

BAB 2: TIPE DATA, VARIABEL, NILAI, DAN EKSPRESI

2.1.2 TIPE BENTUKAN

Dalam kehidupan sehari-hari, data yang kita jumpai jarang sekali berdiri sendiri sebagai entitas tunggal yang sederhana. Seorang mahasiswa, misalnya, bukan hanya sekadar nomor induk (string) atau indeks prestasi (real), melainkan satu kesatuan utuh yang memiliki NIM, Nama Lengkap, Jurusan, Tanggal Lahir, dan IPK.

Jika kita hanya mengandalkan tipe dasar, kita terpaksa harus membuat puluhan variabel yang terpisah-pisah dan tidak saling terkait. Untuk memodelkan entitas dunia nyata secara elegan, ilmu pemrograman menyediakan fasilitas Tipe Bentukan (User-Defined / Composite Types)—yaitu tipe data baru yang didefinisikan dan dinamai sendiri oleh pemrogram dengan mengombinasikan tipe-tipe data yang telah ada sebelumnya.

Ragam Tipe Bentukan dalam Algoritma

Terdapat beberapa varian tipe bentukan yang umum digunakan:

+-------------------------------------------------------------------------------+
|                       TAKSONOMI TIPE DATA BENTUKAN                            |
+--------------------------+----------------------------------------------------+
| Jenis Tipe Bentukan      | Karakteristik dan Skenario Penggunaan              |
+--------------------------+----------------------------------------------------+
| 1. Rekaman (Record/Struct) Menggabungkan beberapa medan (field) berbeda tipe. |
|                          | Contoh: Data Mahasiswa, Titik Koordinat, Jam Waktu.|
+--------------------------+----------------------------------------------------+
| 2. Penamaan Ulang (Alias)| Memberikan nama baru yang lebih bermakna bisnis    |
|                          | kepada tipe dasar yang sudah ada.                  |
+--------------------------+----------------------------------------------------+
| 3. Rentang (Subrange)    | Membatasi domain nilai dari suatu tipe ordinal     |
|                          | (misal: angka 1 s/d 12 untuk representasi Bulan).  |
+--------------------------+----------------------------------------------------+
| 4. Enumerasi (Enum)      | Mendefinisikan himpunan nilai diskrit berupa       |
|                          | daftar nama konstanta (misal: nama-nama Hari).     |
+--------------------------+----------------------------------------------------+

1. Tipe Terstruktur / Rekaman (Record / Struct)

Tipe Rekaman (Record) adalah tipe bentukan yang paling penting dan paling luas digunakan. Record mengelompokkan satu atau beberapa elemen data yang masing-masing disebut sebagai medan (field).

Medan-medan di dalam sebuah record dapat memiliki tipe data yang berbeda-beda (heterogen).

Contoh 1: Mendefinisikan Tipe Titik Koordinat 2 Dimensi ($X, Y$)

Dalam notasi teks algoritma:

type Titik : record < x : real, 
                      y : real >

Contoh 2: Mendefinisikan Tipe Data Waktu (Jam)

type Jam : record < hh : integer,   { jam: 0..23 }
                    mm : integer,   { menit: 0..59 }
                    ss : integer >  { detik: 0..59 }

Contoh 3: Mendefinisikan Tipe Data Mahasiswa

type Mahasiswa : record < nim  : string,
                          nama : string,
                          ipk  : real >

Pengaksesan Medan Record (Field Selector):

Untuk mengisi atau membaca nilai dari suatu medan di dalam record, digunakan operator titik (.):

deklarasi:
    mhs : Mahasiswa
    p : Titik

deskripsi:
    { Mengisi nilai ke dalam medan record }
    mhs.nim  <- "2026001"
    mhs.nama <- "Budi Susanto"
    mhs.ipk  <- 3.85

    p.x <- 12.5
    p.y <- 7.0

    { Menampilkan isi medan record }
    write(mhs.nama, " meraih IPK: ", mhs.ipk)

2. Rekaman Bersarang (Nested Record)

Sebuah record dapat memuat medan yang tipe datanya adalah record lain:

type Tanggal : record < hari  : integer,
                        bulan : integer,
                        tahun : integer >

type Karyawan : record < nik       : string,
                         nama      : string,
                         tgl_lahir : Tanggal > { Medan bertipe record Tanggal }

deklarasi:
    staf : Karyawan

deskripsi:
    staf.nama <- "Citra Lestari"
    staf.tgl_lahir.hari  <- 16
    staf.tgl_lahir.bulan <- 9
    staf.tgl_lahir.tahun <- 2000

3. Penamaan Ulang Tipe (Type Alias)

Pemrogram dapat memberikan nama alias baru pada tipe dasar untuk meningkatkan keterbacaan kode (code readability):

type BilanganBulat = integer
type Pecahan = real
type Huruf = char

deklarasi:
    total_gaji : BilanganBulat
    rasio : Pecahan

4. Tipe Rentang Nilai (Subrange Type)

Tipe rentang membatasi domain nilai dari suatu tipe dasar berurutan (ordinal):

type IndexBulan = 1 .. 12
type NilaiMutu  = 'A' .. 'E'

deklarasi:
    bulan_sekarang : IndexBulan
    mutu : NilaiMutu

Jika ada instruksi yang mencoba memasukkan angka 15 ke dalam variabel bulan_sekarang, sistem kompilator akan langsung menolak dan membangkitkan pesan kesalahan batas (out of range error).

5. Tipe Enumerasi (Enumerated Type)

Tipe enumerasi mendefinisikan tipe data baru yang nilainya secara eksplisit hanya berupa daftar konstanta pengenal terhitung:

type Hari = (Senin, Selasa, Rabu, Kamis, Jumat, Sabtu, Minggu)
type StatusMenikah = (Lajang, Menikah, Duda, Janda)

deklarasi:
    hari_kerja : Hari
    status_staf : StatusMenikah

deskripsi:
    hari_kerja <- Senin
    status_staf <- Menikah

Secara internal di memori komputer, nilai enumerasi disimpan sebagai deretan bilangan bulat mulai dari $0, 1, 2, \dots$ (Senin = 0, Selasa = 1, dst.).

Rangkuman

Tipe bentukan memberikan keleluasaan tak terbatas bagi pemrogram untuk membangun struktur data yang meniru kompleksitas dunia nyata. Melalui pendefinisian rekaman (record/struct), penamaan ulang alias, pembatasan rentang (subrange), dan enumerasi (enum), algoritma yang dirancang menjadi jauh lebih terstruktur, modular, dan memiliki integritas tipe yang kuat.

BAB 2: TIPE DATA, VARIABEL, NILAI, DAN EKSPRESI

2.2 Variabel

1. Definisi dan Konsep Variabel

Dalam pemrograman dan perancangan algoritma, variabel adalah lokasi atau wadah di memori komputer (RAM) yang diberi nama (identifier) untuk menyimpan suatu nilai yang tipe datanya telah ditentukan. Nilai yang tersimpan di dalam variabel bersifat dinamis, artinya dapat diubah atau diperbarui sewaktu-waktu selama program berjalan (runtime), namun tipe data dari variabel tersebut bersifat tetap (static typing) pada kebanyakan bahasa prosedural.

Secara konseptual, variabel menghubungkan tiga atribut penting:

1. Nama (Identifier): Simbol atau label yang digunakan programmer untuk mereferensikan lokasi memori.
2. Alamat Memori (Memory Address): Lokasi fisik/logis heksadesimal di memori tempat data disimpan.
3. Nilai (Content/Value): Data aktual yang disimpan pada alamat memori tersebut, yang format penyimpanannya diatur oleh tipe data variabel.

       +-----------------------------------------------+
       |             REPRESENTASI MEMORI              |
       +-----------------------------------------------+
       Nama Variabel       : usia
       Tipe Data           : integer (4 bytes)
       Alamat Memori       : 0x7FFF5FBFF8C4
       Nilai Saat Ini      : 21
       +-----------------------------------------------+
       |  00000000 | 00000000 | 00000000 | 00010101   | -> Nilai biner
       +-----------------------------------------------+

2. Aturan Penamaan Pengenal (Identifier)

Pengenal (identifier) adalah nama yang dideklarasikan oleh pemrogram untuk menamai variabel, konstanta, fungsi, prosedur, tipe bentukan, atau modul. Untuk memastikan kode program valid dan dapat dipahami secara konsisten oleh kompilator/interpreter, aturan penamaan pengenal berikut harus dipatuhi:

2.1 Aturan Sintaksis Wajib

1. Karakter Pertama: Harus berupa huruf alfabet (a-z, A-Z) atau karakter garis bawah (underscore _). Tidak boleh diawali dengan angka.
2. Karakter Selanjutnya: Dapat terdiri atas kombinasi huruf, angka (0-9), dan garis bawah (_).
3. Tidak Boleh Memuat Spasi atau Simbol Khusus: Spasi, tanda hubung (-), titik (.), tanda seru (!), tanda tanya (?), atau simbol matematika (+, *, /) tidak diizinkan.
4. Bukan Merupakan Kata Kunci (Reserved Words): Tidak boleh menggunakan kata baku bahasa pemrograman, seperti if, else, while, for, program, var, integer, begin, end, dsb.
5. Kepekaan Huruf (Case Sensitivity): Pada bahasa seperti C, C++, Java, dan Python, huruf besar dan kecil dibedakan (jumlah, Jumlah, dan JUMLAH adalah tiga variabel yang berbeda). Pada Pascal atau SQL dasar, penamaan bersifat case-insensitive.

2.2 Perbandingan Nama Valid dan Tidak Valid

2.3 Konvensi Gaya Penulisan (Naming Conventions)

Selain aturan sintaksis, pemrogram profesional mengikuti konvensi penulisan agar kode mudah dibaca (clean code):

• camelCase: Karakter kata pertama berhuruf kecil, huruf pertama kata berikutnya berhuruf besar (contoh: totalGajiKaryawan, hitungLuasLingkaran). Banyak digunakan pada Java, JavaScript, dan C#.
• snake_case: Seluruh kata ditulis huruf kecil dan dipisahkan garis bawah (contoh: total_gaji_karyawan, hitung_luas_lingkaran). Standar di C dan Python.
• PascalCase: Huruf pertama setiap kata berhuruf besar (contoh: TotalGajiKaryawan). Umum dipakai untuk penamaan kelas (class) atau tipe data bentukan.
• Deskriptif dan Bermakna: Hindari variabel satu huruf seperti x, y, z kecuali untuk indeks perulangan sederhana. Gunakan nama yang mencerminkan isi (misal: kecepatanAwal, bukan ka).

3. Deklarasi Variabel

Mendeklarasikan variabel berarti memberi tahu komputer nama variabel dan tipe data nilai yang akan ditampung. Deklarasi memungkinkan kompilator mengalokasikan ruang memori yang tepat.

3.1 Sintaks Notasi Algoritmik (Pseudocode)

Dalam teks algoritma baku, deklarasi ditulis pada bagian DEKLARASI:

DEKLARASI:
    nama_siswa     : string
    umur           : integer
    ipk            : real
    status_aktif   : boolean
    
    { Deklarasi variabel dengan tipe yang sama sekaligus }
    panjang, lebar, tinggi, volume : real

3.2 Pemetaan Sintaks pada Berbagai Bahasa Pemrograman

/* Bahasa C / C++ */
char nama_siswa[50];
int umur;
float ipk;
bool status_aktif;
double panjang, lebar, tinggi, volume;

{ Bahasa Pascal }
var
    nama_siswa   : string;
    umur         : integer;
    ipk          : real;
    status_aktif : boolean;
    panjang, lebar, tinggi, volume : real;

# Bahasa Python (Dynamic Typing / Type Hinting)
nama_siswa: str = "Budi"
umur: int = 20
ipk: float = 3.75
status_aktif: bool = True

4. Ruang Lingkup Variabel (Variable Scope)

Ruang lingkup (scope) menentukan wilayah program tempat suatu variabel dapat diakses dan digunakan:

1. Variabel Global:

   • Dideklarasikan di luar seluruh blok fungsi/prosedur.
   • Dapat diakses dan dimodifikasi oleh seluruh bagian program.
   • Bertahan selama seluruh eksekusi program berlangsung.
   • Catatan Praktik: Penggunaan berlebihan variabel global dihindari karena dapat menimbulkan efek samping (side effects) yang sulit dilacak saat debugging.

2. Variabel Lokal:

   • Dideklarasikan di dalam suatu blok instruksi tertentu (misalnya di dalam fungsi, prosedur, atau perulangan).
   • Hanya dikenali dan dapat diakses di dalam blok tersebut.
   • Dialokasikan saat blok fungsi dimasuki dan dihapus (deallocated) dari memori begitu eksekusi keluar dari blok tersebut.

5. Konstanta

Konstanta adalah identifier yang menyimpan nilai tetap yang tidak dapat diubah nilainya sepanjang program berjalan setelah diinisialisasi pertama kali.

Manfaat Konstanta:

• Menghindari magic numbers (nilai angka asing di tengah kode tanpa keterangan yang jelas).
• Memudahkan pemeliharaan (jika nilai berubah di masa depan, cukup perbarui pada satu titik deklarasi).
• Mencegah kekeliruan modifikasi nilai penting secara tidak sengaja.

DEKLARASI:
    konstanta PI = 3.14159265
    konstanta MAX_MAHASISWA = 100
    konstanta PAJAK = 0.11

/* Bahasa C */
const double PI = 3.14159265;
#define MAX_MAHASISWA 100

6. Rangkuman Materi

• Variabel adalah penamaan atas alamat memori untuk menyimpan nilai yang dapat berubah selama eksekusi program.
• Penamaan variabel wajib memenuhi kaidah pengenal (identifier): diawali huruf/underscore, tidak mengandung spasi, dan bukan reserved word.
• Deklarasi variabel mengikat nama variabel dengan tipe data tertentu guna mengalokasikan ruang memori yang proporsional.
• Ruang lingkup variabel terbagi menjadi variabel lokal (spesifik pada blok fungsi) dan variabel global (dapat diakses seluruh program).
• Konstanta digunakan untuk nilai acuan tetap yang nilainya dijamin tidak berubah selama program berjalan.

BAB 2: TIPE DATA, VARIABEL, NILAI, DAN EKSPRESI

2.3 Pemberian Nilai

1. Konsep Dasar Pemberian Nilai

Pemberian nilai (assignment) adalah mekanisme memasukkan atau menyimpan suatu data/nilai ke dalam variabel yang telah dideklarasikan di memori. Sebelum sebuah variabel diberi nilai, variabel tersebut berada dalam keadaan belum terdefinisi (undefined) atau berisi nilai sampah (garbage value) sisa alokasi memori sebelumnya.

Terdapat dua mekanisme utama dalam pengisian nilai ke suatu variabel:

1. Pengisian Secara Langsung (Assignment Statement) melalui kode program.
2. Pengisian Melalui Pembacaan (Input Statement) dari peranti masukan (keyboard, berkas, sensor).

                 +-----------------------------------+
                 |     MEKANISME PEMBERIAN NILAI     |
                 +-----------------+-----------------+
                                   |
            +----------------------+----------------------+
            |                                             |
   [Pengisian Langsung]                        [Pembacaan Masukan]
  - Lewat kode algoritma                     - Lewat pengguna / keyboard
  - Operator: <-, :=, =                      - Instruksi: read, readln
  - Evaluasi nilai ekspresi                  - Menunggu interaksi luar

2. Pengisian Nilai Secara Langsung (Assignment Statement)

Pengisian nilai secara langsung dilakukan dengan mengevaluasi ekspresi atau nilai literal di sisi kanan (R-value) lalu menyimpannya ke dalam variabel di sisi kiri (L-value).

2.1 Konsep L-Value dan R-Value

• L-Value (Left Value): Harus berupa lokasi memori yang dapat dimodifikasi, yaitu nama variabel. Nilai konstanta atau ekspresi tidak boleh berada di sisi kiri.
• R-Value (Right Value): Merupakan nilai data, nama variabel lain, atau ekspresi hasil perhitungan yang akan dievaluasi dan disalin ke L-value.

       Variabel (L-Value)  <--  Ekspresi / Nilai (R-Value)
          [  gajiTotal  ]  <--  [ gajiPokok + tunjangan ]

Catatan Kesalahan Sintaksis:

• x <- 10 (Benar)
• 10 <- x (Salah: 10 adalah nilai konstan, bukan lokasi variabel / L-Value)
• a + b <- c (Salah: ekspresi penjumlahan tidak dapat menjadi tujuan penyimpanan)

2.2 Notasi Pemberian Nilai Berdasarkan Bahasa

• Notasi Algoritmik Baku: Menggunakan simbol panah ke kiri <- (atau :=).
• Bahasa Pascal: Menggunakan titik dua sama dengan :=.
• Bahasa C, C++, Java, Python: Menggunakan tanda sama dengan tunggal =.

{ Notasi Algoritmik }
x <- 25
nama <- "Ahmad"
luas <- panjang * lebar
status <- true

2.3 Kesesuaian Tipe (Type Compatibility) dan Konversi Tipe (Type Casting)

Nilai yang diberikan ke dalam suatu variabel harus memiliki tipe data yang cocok dengan deklarasi variabel tersebut:

• Tipe Sama: Tipe data di sisi kanan sama persis dengan tipe variabel di sisi kiri.
• Konversi Otomatis (Implicit Type Casting / Coercion): Tipe dengan rentang lebih kecil dapat otomatis dimasukkan ke tipe yang lebih luas tanpa kehilangan presisi (misalnya bilangan integer ditugaskan ke variabel real).

  double berat;
  int angka = 70;
  berat = angka; // Sah: 70 otomatis dikonversi menjadi 70.0
  

• Konversi Eksplisit (Explicit Type Casting): Pemrogram secara sadar memaksa konversi tipe data, meski ada potensi pemotongan nilai (truncation).

  int desimal_potong;
  double pecahan = 9.87;
  desimal_potong = (int)pecahan; // Nilai menjadi 9 (bagian desimal dibuang)
  

3. Pengisian Nilai Melalui Pembacaan (Input Statement)

Pengisian melalui pembacaan dilakukan secara interaktif dengan membaca masukan dari pengguna melalui papan ketik (keyboard) saat program dijalankan (runtime).

3.1 Notasi Algoritmik

Instruksi pembacaan dalam teks algoritma ditulis dengan kata kerja read atau readln:

• read(x): Membaca nilai dari masukan dan menyimpannya ke variabel x. Kursor masukan tetap berada di baris yang sama.
• readln(x) atau read(x, ...): Membaca nilai lalu memindahkan kursor pembacaan ke baris berikutnya (newline).

DEKLARASI:
    nama : string
    nilai_ujian : real

ALGORITMA:
    output("Masukkan nama mahasiswa: ")
    read(nama)
    output("Masukkan nilai ujian: ")
    read(nilai_ujian)

3.2 Pemetaan Sintaks Input pada Berbagai Bahasa

4. Inisialisasi Variabel

Inisialisasi adalah proses pemberian nilai awal (initial value) kepada variabel pada saat variabel tersebut dideklarasikan atau sebelum digunakan dalam operasi perhitungan pertama kali.

Bahaya Mengabaikan Inisialisasi:

Jika variabel digunakan dalam perhitungan akumulasi (misalnya penjumlahan berkelanjutan atau perkalian faktorial) tanpa diinisialisasi, komputer akan menghitung data acak (garbage data) yang tersisa di blok RAM tersebut, mengakibatkan hasil kalkulasi yang salah total.

{ Contoh bahaya tanpa inisialisasi }
DEKLARASI:
    total, i : integer

ALGORITMA:
    total <- 0      { Inisialisasi wajib! Jika diabaikan, nilai total awal tak terdefinisi }
    FOR i <- 1 TO 5 DO
        total <- total + i
    ENDFOR
    write(total)

5. Penugasan Gabungan (Compound Assignment)

Pada bahasa modern turunan C (C, C++, Java, Python), tersedia operator penugasan gabungan yang memadukan operasi aritmatika dengan operasi penugasan sekaligus untuk menyederhanakan penulisan kode:

6. Studi Kasus Klasik: Penukaran Nilai Dua Variabel (Swapping)

Salah satu penerapan dasar pemberian nilai adalah mempertukarkan isi dari dua buah variabel, misalnya menukar isi gelas teh dan gelas kopi.

6.1 Menggunakan Variabel Sementara (Temporary Variable)

Cara standar yang paling aman adalah menyiapkan variabel penampung sementara (temp):

DEKLARASI:
    A, B, temp : integer

ALGORITMA:
    A <- 10
    B <- 20
    
    { Proses Pertukaran }
    temp <- A    { 1. Simpan nilai A ke temp (temp = 10) }
    A <- B       { 2. Salin nilai B ke A       (A = 20)    }
    B <- temp    { 3. Salin nilai temp ke B    (B = 10)    }

           [Langkah 1]               [Langkah 2]               [Langkah 3]
      A (10) ------> temp (10)   B (20) ------> A (20)    temp (10) ------> B (10)

6.2 Tanpa Variabel Sementara (Metode Aritmatika)

Dapat diterapkan khusus untuk tipe data bilangan (integer / real):

ALGORITMA:
    A <- A + B   { A menampung total kedua nilai: 10 + 20 = 30 }
    B <- A - B   { B mendapatkan nilai awal A:   30 - 20 = 10 }
    A <- A - B   { A mendapatkan nilai awal B:   30 - 10 = 20 }

7. Rangkuman Materi

• Pemberian nilai (assignment) memindahkan hasil evaluasi sisi kanan (R-value) ke lokasi memori variabel sisi kiri (L-value).
• Dua cara utama pengisian nilai: secara langsung melalui assignment (<-, :=, =) dan secara dinamis melalui pembacaan peranti masukan (read, scanf, cin).
• Inisialisasi variabel sangat penting untuk memastikan variabel tidak mengandung nilai sampah (garbage value) sebelum dioperasikan.
• Kesesuaian tipe data wajib diperhatikan; apabila tipe tidak cocok, diperlukan konversi tipe (casting).
• Pertukaran nilai dua variabel (swapping) secara umum memerlukan variabel bantu sementara untuk mencegah hilangnya data asli.

BAB 2: TIPE DATA, VARIABEL, NILAI, DAN EKSPRESI

2.4 Menampilkan Nilai

1. Konsep Operasi Keluaran (Output Operation)

Operasi keluaran (output) adalah proses penyampaian informasi atau data dari memori komputer ke media peranti keluaran (output device), seperti layar monitor (console/terminal), media penyimpanan berkas (file), atau pencetak (printer).

Dalam pemrograman antarmuka baris perintah (command line interface / CLI), operasi penulisan ke layar berfungsi untuk:

1. Menyampaikan hasil komputasi dan pengolahan data kepada pengguna.
2. Memberikan instruksi arahan (prompts) sebelum operasi pembacaan masukan (input).
3. Melacak jalannya proses algoritma (logging / debugging).

         +--------------------+         Instruksi Keluaran
         |   MEMORI RAM       |       (write / writeln / print)
         |   - Variabel       | -----------------------------------> [ LAYAR MONITOR ]
         |   - Teks Literal   |                                      Teks / Nilai Angka
         |   - Hasil Ekspresi |
         +--------------------+

2. Instruksi Penulisan: write dan writeln

Dalam notasi algoritmik standar, operasi keluaran umumnya dinyatakan dengan kata kunci write atau output:

• write(...): Menampilkan nilai parameter yang diberikan ke layar tanpa memindahkan posisi kursor ke baris baru. Karakter berikutnya yang dicetak akan berada persis di sebelah kanan keluaran sebelumnya.
• writeln(...) (write line): Menampilkan nilai parameter ke layar lalu memindahkan posisi kursor ke awal baris berikutnya (newline).

{ Notasi Algoritmik }
write("Algoritma ")
write("dan ")
writeln("Pemrograman")
writeln("Teknik Informatika")

Hasil Tampilan pada Layar Monitor:

Algoritma dan Pemrograman
Teknik Informatika

3. Komponen yang Dapat Ditampilkan

Operasi keluaran bersifat fleksibel dan dapat mencetak berbagai jenis entitas:

3.1 Teks Literal (Constant String)

Teks yang diapit oleh tanda petik (tunggal '...' atau ganda "...") akan dicetak persis seperti apa adanya:

write("Selamat Datang di Laboratorium Komputer")

3.2 Nilai Variabel

Nama variabel yang dituliskan tanpa tanda petik akan dievaluasi oleh sistem, dan isi data di dalam alamat memorilah yang dicetak:

DEKLARASI:
    nama : string
    nilai_akhir : real
ALGORITMA:
    nama <- "Budi Santoso"
    nilai_akhir <- 88.5
    write(nama)         { Mencetak: Budi Santoso }
    write(nilai_akhir)  { Mencetak: 88.5 }

3.3 Hasil Evaluasi Ekspresi Langsung

Ekspresi matematika atau relasional dapat langsung ditempatkan di dalam argumen keluaran tanpa harus disimpan terlebih dahulu ke variabel perantara:

write(15 * 4)           { Mencetak: 60 }
write(7 > 3)            { Mencetak: true }

3.4 Penggabungan Teks Literal dan Variabel

Pencetakan informasi interaktif biasanya menggabungkan teks penjelasan bersama nilai variabel:

• Dalam algoritma / Pascal: menggunakan pemisah tanda koma ,.
• Dalam Python / Java: menggunakan tanda tambah + (string concatenation) atau format string.

write("Nilai akhir mahasiswa ", nama, " adalah ", nilai_akhir)

4. Karakter Khusus (Escape Sequences)

Pada sebagian besar bahasa pemrograman berbasis teks (C, C++, Java, Python), karakter kontrol khusus diawali dengan tanda garis miring terbalik (backslash \):

Contoh implementasi:

printf("No\tNama\tNilai\n1\tAndi\t90\n2\tBudi\t85\n");

5. Format Penataan Tampilan (Formatting Output)

Menampilkan angka pecahan (floating point / real) tanpa format sering menghasilkan representasi notasi ilmiah yang sulit dibaca (misalnya 3.141592653589793e+00). Pemrogram dapat mengatur lebar kolom dan presisi desimal.

5.1 Format Penataan pada Pascal

Sintaks: variabel : lebar_kolom : jumlah_desimal

writeln(ipk:4:2);    { Lebar total minimal 4 digit, dengan 2 angka di belakang koma }

5.2 Format Penataan pada C (printf)

Menggunakan penentu format (format specifiers):

• %d atau %i: Bilangan bulat (integer).
• %f : Bilangan pecahan (float / double).
• %.2f: Bilangan pecahan dengan 2 angka di belakang koma.
• %s : Teks / string.
• %c : Karakter tunggal.

printf("Nama Mahasiswa: %s\n", nama);
printf("IPK Kumulatif : %.2f\n", ipk);
printf("Alokasi Dana  : Rp %10.2f\n", totalDana); // Rata kanan lebar 10

6. Perbandingan Perintah Output pada Berbagai Bahasa

7. Rangkuman Materi

• Operasi keluaran mengalirkan data dari memori ke antarmuka terminal/layar untuk dibaca pengguna.
• Perbedaan utama write dan writeln terletak pada perpindahan kursor baris baru (newline) di akhir pencetakan.
• Komponen keluaran dapat berupa teks literal, nilai variabel, maupun hasil evaluasi ekspresi aritmatika secara langsung.
• Karakter escape (seperti \n dan \t) digunakan untuk mengontrol tata letak baris dan perataan teks.
• Format penataan (formatting) sangat esensial saat menyajikan data angka desimal dan menyusun laporan tabel agar rapi dan mudah dianalisis.

BAB 2: TIPE DATA, VARIABEL, NILAI, DAN EKSPRESI

2.5 Ekspresi

1. Konsep Dasar Ekspresi

Ekspresi (expression) adalah kombinasi dari operan (operand) dan operator yang disusun mengikuti aturan sintaksis tertentu yang apabila dievaluasi (dihitung) oleh komputer akan menghasilkan sebuah nilai baru dengan tipe data tertentu.

Secara formal, komponen pembentuk ekspresi terdiri atas:

1. Operan (Operand): Objek atau nilai yang dioperasikan. Operan dapat berupa nilai literal (misalnya: 5, "Halo"), variabel (misalnya: x, lebar), atau hasil pemanggilan fungsi yang mengembalikan nilai.
2. Operator: Simbol khusus yang memerintahkan kompilator untuk melakukan manipulasi matematis, logis, atau relasional tertentu terhadap operan.

       +--------------------------------------------------------+
       |                  ANATOMI EKSPRESI                      |
       +--------------------------------------------------------+
                       hasil <- (panjang * 2) + lebar
                                 ^^^^^^^   ^    ^^^^^
                                 Operan    |    Operan
                                        Operator
       +--------------------------------------------------------+

Berdasarkan jumlah operan yang dilibatkan, operator dibedakan menjadi:

• Operator Unari (Unary): Hanya melibatkan 1 operan (contoh: -x, NOT benar, ++i).
• Operator Binari (Binary): Melibatkan 2 operan (contoh: a + b, x > y, p AND q).
• Operator Ternari (Ternary): Melibatkan 3 operan (contoh operator kondisional: kondisi ? nilai1 : nilai2).

2. Jenis-Jenis Ekspresi

Berdasarkan tipe data hasil evaluasinya, ekspresi dalam pemrograman diklasifikasikan ke dalam empat kategori utama:

2.1 Ekspresi Aritmatika

Ekspresi yang operannya berupa bilangan (integer atau real) dan hasil evaluasinya berupa nilai numerik (integer atau real).

2.2 Ekspresi Relasional (Perbandingan)

Ekspresi yang membandingkan dua nilai atau ekspresi lain. Hasil evaluasi ekspresi relasional selalu berupa nilai kebenaran logika (boolean: true atau false).

2.3 Ekspresi Logika (Boolean)

Ekspresi yang operannya bertipe data boolean dan hasil perhitungannya menghasilkan nilai boolean (true atau false).

Operator logika dasar meliputi:

1. NOT (Negasi): Membalik nilai kebenaran.
2. AND (Konjungsi): Bernilai true hanya jika kedua operan bernilai true.
3. OR (Disjungsi): Bernilai true jika setidaknya salah satu operan bernilai true.
4. XOR (Exclusive OR): Bernilai true jika salah satu operan true, tetapi bernilai false jika keduanya bernilai sama.

Tabel Kebenaran (Truth Table):

Evaluasi Hubung Singkat (Short-Circuit Evaluation):

Bahasa modern mengoptimalkan evaluasi logika:

• Pada A AND B: Jika A bernilai false, komputer tidak akan memeriksa B karena hasil akhir sudah pasti false.
• Pada A OR B: Jika A bernilai true, komputer tidak akan memeriksa B karena hasil akhir sudah pasti true.

2.4 Ekspresi String

Ekspresi yang melibatkan tipe data string. Operasi utama pada string adalah penggabungan (concatenation):

str1 <- "Teknik "
str2 <- "Informatika"
hasil <- str1 + str2   { hasil berisi "Teknik Informatika" }

3. Presedensi dan Asosiativitas Operator (Operator Precedence)

Ketika sebuah ekspresi memuat lebih dari satu operator tanpa tanda kurung, komputer mengevaluasi operator tersebut berdasarkan tingkat kekuatan atau prioritas presedensi (precedence hierarchy).

Tabel hierarki prioritas dari tingkat tertinggi ke terendah:

    PRIORITAS TERTINGGI
           |      1. Tanda Kurung: ( ... )
           |      2. Unary: +, -, NOT, ++, --
           |      3. Perpangkatan: ^
           |      4. Perkalian & Pembagian: *, /, div, mod (%)
           |      5. Penjumlahan & Pengurangan: +, -
           |      6. Relasional: <, <=, >, >=, =, <>
           |      7. Logika AND: AND
           |      8. Logika OR & XOR: OR, XOR
           v      9. Penugasan: <-, :=, =
    PRIORITAS TERENDAH

Asosiativitas Operator (Associativity)

Jika terdapat dua operator dengan tingkat presedensi yang sama bersebelahan (misalnya penjumlahan dan pengurangan, atau perkalian dan pembagian), arah evaluasi ditentukan oleh aturan asosiativitas:

• Mayoritas operator aritmatika dan relasional dievaluasi dari kiri ke kanan (left-to-right).
• Operator penugasan dievaluasi dari kanan ke kiri (right-to-left).

4. Contoh Langkah Demi Langkah Evaluasi Ekspresi

Contoh 1: Ekspresi Aritmatika Campuran

Hitung hasil evaluasi ekspresi: $$hasil = 10 + 4 \times 3^2 - 18 \div 2$$

Langkah evaluasi kompilator:

1. Operasi perpangkatan dievaluasi terlebih dahulu: $3^2 \to 9$. $\to 10 + 4 \times 9 - 18 \div 2$
2. Operasi perkalian dan pembagian (kiri ke kanan):
   • $4 \times 9 \to 36$
   • $18 \div 2 \to 9$ $\to 10 + 36 - 9$
3. Operasi penjumlahan dan pengurangan (kiri ke kanan):
   • $10 + 36 \to 46$
   • $46 - 9 \to 37$
4. Hasil akhir = 37.

Contoh 2: Ekspresi Campuran Aritmatika, Relasional, dan Logika

Misalkan variabel didefinisikan: a = 5, b = 8, c = 12 Evaluasi ekspresi logika berikut: $$(a \times 2 + b > c) \text{ AND } (c \text{ mod } a = 2)$$

Langkah evaluasi:

1. Evaluasi sub-ekspresi kiri: (a * 2 + b > c)
   • Perkalian: 5 * 2 menghasilkan 10
   • Penjumlahan: 10 + 8 menghasilkan 18
   • Relasional: 18 > 12 menghasilkan true
2. Evaluasi sub-ekspresi kanan: (c mod a = 2)
   • Sisa bagi: 12 mod 5 menghasilkan 2
   • Relasional: 2 = 2 menghasilkan true
3. Evaluasi operasi logika:
   • true AND true menghasilkan true.

5. Praktik Terbaik Penulisan Ekspresi

1. Gunakan Tanda Kurung Eksplisit: Meskipun aturan presedensi ada, penulisan tanda kurung ( ... ) sangat dianjurkan untuk memperjelas maksud logika kode dan menghindari ambiguitas bagi pembaca kode.
   • Ambigu: x = a + b * c / d - e
   • Jelas: x = a + ((b * c) / d) - e
2. Waspadai Pembagian Nol (Division by Zero): Pastikan pembagi pada operator /, div, maupun mod tidak bernilai nol sebelum operasi dijalankan guna menghindari kesalahan waktu henti (runtime error / exception).
3. Manfaatkan Short-Circuit Evaluation: Letakkan kondisi pengecekan keabsahan data di awal ekspresi AND (misal: penyebut <> 0 AND total / penyebut > 5).

6. Rangkuman Materi

• Ekspresi mengombinasikan operan dan operator untuk menghasilkan nilai keluaran baru.
• Berdasarkan tipe hasil perhitungannya, ekspresi dibedakan menjadi ekspresi aritmatika, relasional, logika, dan string.
• Ekspresi relasional dan logika menghasilkan tipe boolean (true / false).
• Urutan penghitungan ditentukan oleh hierarki presedensi operator; tanda kurung () memiliki tingkat prioritas mutlak tertinggi.
• Aturan asosiativitas menentukan urutan komputasi ketika beberapa operator memiliki tingkat prioritas yang setara.

BAB 3: INSTRUKSI UTAMA

3.1 Instruksi Runtunan

1. Konsep Dasar Instruksi Runtunan (Sequence)

Instruksi runtunan (sequence structure) merupakan struktur kendali paling mendasar dalam pemrograman prosedural. Runtunan terdiri atas satu atau lebih instruksi (pernyataan) yang dieksekusi secara berurutan, baris demi baris, dari instruksi pertama sampai instruksi terakhir, tanpa adanya lompatan (branching) atau perulangan (looping).

Secara konseptual, prinsip eksekusi sekuensial mengikuti kaidah:

1. Urutan Pengerjaan: Instruksi $S_k$ dikerjakan setelah instruksi $S_{k-1}$ selesai dieksekusi.
2. Ketergantungan Keadaan (State Dependency): Nilai akhir dari suatu instruksi menjadi keadaan awal (pre-condition) bagi instruksi berikutnya.
3. Eksekusi Sekali: Setiap instruksi dalam blok sekuensial dikerjakan tepat satu kali.
4. Akhir Instruksi: Instruksi terakhir menghasilkan keadaan akhir (post-condition) dari algoritma.

                  +--------------------------+
                  |         MULAI            |
                  +-------------+------------+
                                |
                                v
                  +--------------------------+
                  |       Instruksi 1        |
                  +-------------+------------+
                                |
                                v
                  +--------------------------+
                  |       Instruksi 2        |
                  +-------------+------------+
                                |
                                v
                  +--------------------------+
                  |       Instruksi 3        |
                  +-------------+------------+
                                |
                                v
                  +--------------------------+
                  |        SELESAI           |
                  +--------------------------+

2. Efek dan Pengaruh Urutan Instruksi

Dalam struktur runtunan, urutan penulisan instruksi sangat menentukan kebenaran hasil akhir algoritma. Menukar posisi dua buah instruksi sering kali mengubah hasil komputasi atau bahkan menyebabkan galat logika (logical error).

Contoh Analisis Urutan:

Perhatikan dua algoritma berikut yang memiliki instruksi serupa namun urutannya berbeda:

Versi A (Urutan Benar):

DEKLARASI:
    harga_barang, diskon, harga_bayar : real

ALGORITMA:
    harga_barang <- 100000
    diskon <- 0.10 * harga_barang    { diskon = 10.000 }
    harga_bayar <- harga_barang - diskon { harga_bayar = 90.000 }
    write(harga_bayar)

Versi B (Urutan Keliru / Logical Error):

DEKLARASI:
    harga_barang, diskon, harga_bayar : real

ALGORITMA:
    harga_barang <- 100000
    harga_bayar <- harga_barang - diskon { SALAH: diskon belum memiliki nilai/terdefinisi }
    diskon <- 0.10 * harga_barang
    write(harga_bayar)

Pada Versi B, variabel diskon diakses sebelum diberi nilai (uninitialized variable), menghasilkan perhitungan yang tidak valid.

3. Struktur Program Runtunan dalam Notasi Algoritmik

Struktur runtunan umumnya mengikuti pola klasik: Masukan (Input) $\to$ Pemrosesan (Process) $\to$ Keluaran (Output) (IPO Pattern).

PROGRAM HitungLuasDanKelilingPersegiPanjang
{ Menghitung luas dan keliling persegi panjang berdasarkan panjang dan lebar yang dibaca dari masukan }

DEKLARASI:
    panjang, lebar   : real
    luas, keliling   : real

ALGORITMA:
    { 1. Masukan }
    output("Masukkan panjang: ")
    read(panjang)
    output("Masukkan lebar: ")
    read(lebar)

    { 2. Pemrosesan }
    luas <- panjang * lebar
    keliling <- 2 * (panjang + lebar)

    { 3. Keluaran }
    output("Luas Persegi Panjang     : ", luas)
    output("Keliling Persegi Panjang : ", keliling)

4. Implementasi pada Berbagai Bahasa Pemrograman

4.1 Bahasa C

#include <stdio.h>

int main() {
    float panjang, lebar, luas, keliling;

    /* Masukan */
    printf("Masukkan panjang: ");
    scanf("%f", &panjang);
    printf("Masukkan lebar: ");
    scanf("%f", &lebar);

    /* Pemrosesan */
    luas = panjang * lebar;
    keliling = 2 * (panjang + lebar);

    /* Keluaran */
    printf("Luas Persegi Panjang     : %.2f\n", luas);
    printf("Keliling Persegi Panjang : %.2f\n", keliling);

    return 0;
}

4.2 Bahasa Pascal

program HitungPersegiPanjang;
var
    panjang, lebar, luas, keliling: real;
begin
    { Masukan }
    write('Masukkan panjang: ');
    readln(panjang);
    write('Masukkan lebar: ');
    readln(lebar);

    { Pemrosesan }
    luas := panjang * lebar;
    keliling := 2 * (panjang + lebar);

    { Keluaran }
    writeln('Luas Persegi Panjang     : ', luas:0:2);
    writeln('Keliling Persegi Panjang : ', keliling:0:2);
end.

4.3 Bahasa Python

# Masukan
panjang = float(input("Masukkan panjang: "))
lebar = float(input("Masukkan lebar: "))

# Pemrosesan
luas = panjang * lebar
keliling = 2 * (panjang + lebar)

# Keluaran
print(f"Luas Persegi Panjang     : {luas:.2f}")
print(f"Keliling Persegi Panjang : {keliling:.2f}")

5. Karakteristik dan Aspek Penting Runtunan

1. Deterministik: Diberikan nilai masukan yang identik, program runtunan selalu menghasilkan keluaran yang sama persis dan menempuh jalur instruksi yang tidak pernah berubah.
2. Keterbacaan Alur: Mudah ditelusuri (traced) dengan membuat tabel jejak (trace table) yang memetakan perubahan nilai tiap variabel pada setiap baris instruksi.
3. Penyusunan Efisien: Instruksi yang tidak saling bergantung dapat diparalelkan pada arsitektur modern (pipelining / multithreading), namun dependensi data (instruksi $B$ membutuhkan hasil instruksi $A$) menuntut eksekusi tetap serial.

6. Rangkuman Materi

• Instruksi runtunan adalah eksekusi instruksi secara linear dari atas ke bawah tanpa cabang maupun putaran.
• Urutan instruksi memegang peranan krusial; kekeliruan urutan berakibat pada kegagalan komputasi (logic error).
• Model Masukan-Proses-Keluaran (Input-Process-Output) merupakan arketipe utama dari program berstruktur runtunan.
• Pemahaman runtunan adalah fondasi mutlak sebelum memahami struktur kendali pemilihan (branching) dan perulangan (looping).

BAB 3: INSTRUKSI UTAMA

3.2 Instruksi Pemilihan

1. Konsep Dasar Instruksi Pemilihan (Selection Structure)

Instruksi pemilihan (selection atau branching) adalah struktur kendali aliran program yang memungkinkan komputer mengambil keputusan untuk memilih salah satu dari beberapa alternatif jalur aksi yang tersedia berdasarkan pemenuhan suatu kondisi logika tertentu.

Dalam permasalahan nyata, penyelesaian masalah jarang sekali bersifat murni sekuensial. Sering kali terdapat kondisi prasyarat sebelum suatu tindakan dapat dijalankan. Sebagai contoh:

• Jika nilai akhir mahasiswa $\ge 60$, maka mahasiswa dinyatakan LULUS, jika tidak, mahasiswa dinyatakan TIDAK LULUS.
• Jika total belanja $> Rp 500.000$, maka berikan diskon 10%.

                         +--------------------------+
                         |      KONDISI LOGIKA      |
                         |        (Kondisi?)        |
                         +------------+-------------+
                                      |
                         +------------+------------+
                   BENAR |                         | SALAH
                         v                         v
               +-------------------+     +-------------------+
               |  Jalur Aksi 1     |     |  Jalur Aksi 2     |
               |  (Jika True)      |     |  (Jika False)     |
               +---------+---------+     +---------+---------+
                         |                         |
                         +------------+------------+
                                      |
                                      v
                         +--------------------------+
                         |   Instruksi Lanjutan     |
                         +--------------------------+

2. Kondisi Logika (Boolean Expression)

Kondisi logika adalah ekspresi yang menghasilkan nilai kebenaran bertipe boolean: true (benar) atau false (salah).

Kondisi logika dibentuk melalui:

1. Kondisi Tunggal: Melibatkan satu ekspresi relasional.
   • Contoh: nilai >= 75, umur < 17, status == "aktif"
2. Kondisi Majemuk: Menggabungkan dua atau lebih ekspresi relasional menggunakan operator logika (AND, OR, NOT).
   • Contoh: (umur >= 17) AND (sudah_menikah == false)
   • Contoh: (hari == "Sabtu") OR (hari == "Minggu")

3. Klasifikasi Struktur Pemilihan

Berdasarkan jumlah alternatif jalur keputusan, instruksi pemilihan dikelompokkan menjadi:

3.1 Pemilihan Satu Kasus (Single Alternative)

Aksi hanya dijalankan apabila kondisi bernilai true. Jika kondisi bernilai false, tidak ada aksi khusus yang dilakukan dan program langsung melanjutkan ke instruksi berikutnya.

• Notasi: IF kondisi THEN aksi ENDIF

3.2 Pemilihan Dua Kasus (Dual Alternative)

Menyediakan dua alternatif tindakan: aksi pertama dieksekusi jika kondisi bernilai true, dan aksi kedua dieksekusi jika kondisi bernilai false.

• Notasi: IF kondisi THEN aksi_1 ELSE aksi_2 ENDIF

3.3 Pemilihan Banyak Kasus (Multiple Alternatives)

Digunakan ketika terdapat tiga atau lebih kemungkinan alternatif tindakan. Dapat diselesaikan dengan:

• Rangkaian bertingkat: IF ... THEN ... ELSE IF ... THEN ... ELSE ... ENDIF
• Struktur pemilihan nilai diskrit: CASE pemilih OF ... ENDCASE

3.4 Pemilihan Bersarang (Nested Selection)

Kondisi di mana di dalam blok aksi suatu struktur IF terdapat struktur IF lainnya. Pendekatan ini digunakan untuk memvalidasi kondisi yang hierarkis atau bertingkat.

IF kondisi_1 THEN
    IF kondisi_1A THEN
        aksi_1A
    ELSE
        aksi_1B
    ENDIF
ELSE
    aksi_2
ENDIF

4. Perbandingan Pendekatan: IF-THEN-ELSE vs CASE

5. Prinsip Desain dalam Pemilihan (Best Practices)

1. Lengkap (Exhaustive): Pastikan seluruh domain kondisi terlayani. Selalu sediakan cabang ELSE atau DEFAULT sebagai penanganan kasus tak terduga (fallback / error handler).
2. Hindari Jebakan Tingkat Bersarang Berlebih: Struktur pemilihan bertingkat yang terlalu dalam (deeply nested if, $>3$ level) menyulitkan pengujian (cyclomatic complexity tinggi). Refaktorisasi dengan fungsi bantu atau operator logika gabungan.
3. Urutan Pengecekan: Pada rantai else-if, letakkan kondisi yang paling sering terpenuhi (most probable) di posisi paling atas guna menghemat waktu evaluasi CPU.

6. Rangkuman Materi

• Instruksi pemilihan mengalihkan alur jalannya eksekusi program ke jalur tertentu berdasarkan evaluasi ekspresi logika boolean.
• Kondisi dapat berupa kondisi relasional tunggal maupun kondisi logika majemuk gabungan AND, OR, NOT.
• Struktur pemilihan mencakup satu kasus, dua kasus, banyak kasus, dan kasus bersarang (nested).
• Pemilihan antara konstruksi IF dan CASE didasarkan pada karakteristik data penguji: nilai kontinu/majemuk menggunakan IF, sedangkan nilai diskrit ordinal cocok menggunakan CASE.

BAB 3: INSTRUKSI UTAMA

3.2.1 Instruksi if / then / else

1. Definisi dan Konsep

Instruksi if / then / else adalah konstruksi pemilihan paling mendasar dan universal dalam bahasa pemrograman tingkat tinggi. Struktur ini mengevaluasi ekspresi logika kondisi boolean; jika kondisi tersebut bernilai benar (true), maka sekumpulan instruksi tertentu dieksekusi, dan jika salah (false), eksekusi diarahkan ke jalur instruksi alternatif atau dilewati.

2. Bentuk-Bentuk Konstruksi IF

2.1 Satu Kasus (IF - THEN)

Bentuk ini hanya mengeksekusi blok instruksi jika kondisi bernilai true. Jika kondisi bernilai false, program tidak melakukan aksi tambahan apa pun dan langsung melanjutkan ke instruksi berikutnya.

Notasi Algoritmik:

IF kondisi THEN
    aksi
ENDIF

Flowchart Satu Kasus:

                +-------------------------+
                |         Kondisi         |
                +------------+------------+
                       |           |
                 BENAR |           | SALAH
                       v           |
                +-------------+    |
                |    Aksi     |    |
                +------+------+    |
                       |           |
                       v           v
                +-------------------------+
                |    Instruksi Lanjutan   |
                +-------------------------+

Contoh Kasus: Pemberian Diskon Belanja

IF total_belanja >= 100000 THEN
    diskon <- 0.05 * total_belanja
    total_bayar <- total_belanja - diskon
ENDIF

2.2 Dua Kasus (IF - THEN - ELSE)

Bentuk ini menyediakan dua jalur eksekusi yang saling eksklusif (mutually exclusive). Tepat salah satu dari kedua aksi pasti dieksekusi, tidak mungkin keduanya atau tidak ada sama sekali.

Notasi Algoritmik:

IF kondisi THEN
    aksi_1   { dikerjakan jika kondisi bernilai TRUE }
ELSE
    aksi_2   { dikerjakan jika kondisi bernilai FALSE }
ENDIF

Contoh Kasus: Penentuan Bilangan Genap atau Ganjil

PROGRAM CekGenapGanjil
DEKLARASI:
    bilangan : integer
ALGORITMA:
    output("Masukkan bilangan bulat: ")
    read(bilangan)

    IF (bilangan mod 2 = 0) THEN
        output(bilangan, " adalah bilangan GENAP")
    ELSE
        output(bilangan, " adalah bilangan GANJIL")
    ENDIF

2.3 Tiga Kasus atau Lebih (IF - THEN - ELSE IF - ELSE)

Digunakan untuk menguji beberapa kondisi secara sekuensial. Kondisi diuji dari atas ke bawah. Begitu salah satu kondisi bernilai true, aksi terkait dieksekusi dan seluruh sisa blok ELSE IF dilewati.

Notasi Algoritmik:

IF kondisi_1 THEN
    aksi_1
ELSE IF kondisi_2 THEN
    aksi_2
ELSE IF kondisi_3 THEN
    aksi_3
ELSE
    aksi_default
ENDIF

Contoh Kasus: Konversi Nilai Angka ke Huruf Mutu (Grade)

PROGRAM KonversiNilai
DEKLARASI:
    nilai : real
    indeks : char
ALGORITMA:
    read(nilai)
    IF nilai >= 85.0 THEN
        indeks <- 'A'
    ELSE IF nilai >= 75.0 THEN
        indeks <- 'B'
    ELSE IF nilai >= 60.0 THEN
        indeks <- 'C'
    ELSE IF nilai >= 45.0 THEN
        indeks <- 'D'
    ELSE
        indeks <- 'E'
    ENDIF
    output("Indeks Nilai: ", indeks)

2.4 Struktur Pemilihan Bersarang (Nested IF)

Struktur di mana sebuah blok IF berada di dalam blok IF lainnya.

Contoh Kasus: Penentuan Tahun Kabisat Aturan kalender Gregorius: Tahun adalah kabisat jika habis dibagi 400, ATAU habis dibagi 4 tetapi tidak habis dibagi 100.

PROGRAM CekKabisat
DEKLARASI:
    tahun : integer
ALGORITMA:
    read(tahun)
    IF (tahun mod 4 = 0) THEN
        IF (tahun mod 100 = 0) THEN
            IF (tahun mod 400 = 0) THEN
                output("Tahun Kabisat")
            ELSE
                output("Bukan Tahun Kabisat")
            ENDIF
        ELSE
            output("Tahun Kabisat")
        ENDIF
    ELSE
        output("Bukan Tahun Kabisat")
    ENDIF

Penyederhanaan dengan Operator Logika Kompleks:

IF ((tahun mod 400 = 0) OR ((tahun mod 4 = 0) AND (tahun mod 100 <> 0))) THEN
    output("Tahun Kabisat")
ELSE
    output("Bukan Tahun Kabisat")
ENDIF

3. Pemetaan Sintaks Lintas Bahasa Pemrograman

4. Jebakan Umum Pemula (Common Pitfalls)

1. Kesalahan Operator Penugasan vs Perbandingan pada Bahasa C/C++:

   /* SALAH: Menggunakan operator penugasan = */
   if (x = 10) { /* x diisi 10, bernilai true konstan */ }
   
   /* BENAR: Menggunakan operator kesetaraan == */
   if (x == 10) { /* Menguji apakah x bernilai 10 */ }
   

2. Masalah Dangling Else: Terjadi saat struktur if-then-else tidak memakai tanda pengelompokan (seperti {} pada C atau begin-end pada Pascal), sehingga bagian else secara otomatis berpasangan dengan if terdekat sebelumnya, yang mungkin tidak sesuai dengan niat asli pemrogram.
3. Titik Koma Prematur (Premature Semicolon):

   /* SALAH */
   if (nilai > 80); // Tanda titik koma mengakhiri blok if di sini!
   {
       printf("Lulus\n"); // Baris ini selalu tercetak terlepas dari kondisi!
   }
   

5. Operator Kondisional Ternari (Ternary Operator)

Bahasa turunan C, Java, dan Python menyediakan notasi ringkas untuk operasi pemilihan dua kasus sederhana:

/* C / C++ / Java */
status = (nilai >= 60) ? "LULUS" : "GAGAL";

# Python
status = "LULUS" if nilai >= 60 else "GAGAL"

6. Rangkuman Materi

• Struktur if-then-else mengarahkan jalannya program berdasarkan evaluasi kondisi boolean.
• Tersedia varian satu kasus, dua kasus, rantai banyak kasus (else if), dan pemilihan bersarang (nested if).
• Pemrogram wajib cermat terhadap operator relasional (== bukan =), pembatasan blok instruksi majemuk ({} atau begin-end), dan penanganan dangling else.

BAB 3: INSTRUKSI UTAMA

3.2.2 Instruksi case

1. Definisi dan Konsep Dasar Instruksi CASE

Instruksi case (dikenal juga sebagai switch-case dalam keluarga bahasa C) adalah bentuk khusus dari struktur pemilihan banyak alternatif (multi-way selection). Struktur ini dirancang untuk menyederhanakan penulisan kode percabangan bertingkat yang bergantung pada pencocokan nilai suatu ekspresi diskrit terhadap sekumpulan konstanta nilai pilihan.

Alih-alih menulis rantai panjang IF - THEN - ELSE IF - ELSE yang mengevaluasi variabel yang sama berulang-ulang, instruksi case mengevaluasi ekspresi pemilih (selector) hanya satu kali, lalu langsung mengarahkan program ke label kasus yang nilainya cocok.

                      +-----------------------------+
                      |   EKSPRESI PEMILIH (KUNCI)  |
                      +--------------+--------------+
                                     |
               +-----------+---------+---------+-----------+
         Nilai 1           | Nilai 2           | Nilai 3   | Tak Ada Cocok
               v           v                   v           v
          +---------+ +---------+         +---------+ +---------+
          | Aksi 1  | | Aksi 2  |         | Aksi 3  | | Default |
          +----+----+ +----+----+         +----+----+ +----+----+
               |           |                   |           |
               +-----------+---------+---------+-----------+
                                     |
                                     v
                      +-----------------------------+
                      |     Instruksi Lanjutan      |
                      +-----------------------------+

2. Aturan dan Karakteristik Pemilih (Selector)

1. Tipe Data Ordinal/Diskrit: Ekspresi pemilih pada instruksi case wajib bertipe data diskrit/ordinal, seperti:
   • Bilangan bulat (integer: byte, short, int, long)
   • Karakter (char)
   • Tipe data terenumerasi (enumerated type)
2. Tipe Riil Dilarang: Tipe data pecahan (float, real, double) tidak diperbolehkan menjadi pemilih karena sifat ketidakpastian presisi representasi heksadesimal floating-point di memori.
3. Konstanta Kasus Harus Unik: Setiap label kasus harus memiliki nilai konstan yang unik dan tidak boleh terjadi duplikasi cabang nilai yang sama dalam satu struktur case.

3. Notasi Algoritmik dan Variasi Label Kasus

3.1 Bentuk Umum

CASE ekspresi_pemilih OF
    nilai_1 : aksi_1
    nilai_2 : aksi_2
    nilai_3 : aksi_3
    OTHERWISE : aksi_default
ENDCASE

3.2 Variasi Penulisan Label Nilai

• Nilai Tunggal: 1 : aksi
• Daftar Beberapa Nilai: 1, 3, 5, 7, 9 : aksi_ganjil
• Jangkauan/Rentang Nilai (Range): 1..5 : aksi_hari_kerja (didukung pada Pascal)

4. Contoh Kasus Penerapan

Kasus 1: Penentuan Nama Hari Berdasarkan Nomor Hari (1 - 7)

PROGRAM MenentukanHari
DEKLARASI:
    no_hari : integer
ALGORITMA:
    output("Masukkan nomor hari (1-7): ")
    read(no_hari)

    CASE no_hari OF
        1 : output("Hari: Senin")
        2 : output("Hari: Selasa")
        3 : output("Hari: Rabu")
        4 : output("Hari: Kamis")
        5 : output("Hari: Jumat")
        6 : output("Hari: Sabtu")
        7 : output("Hari: Minggu")
        OTHERWISE : output("Nomor hari tidak valid (harus 1-7)!")
    ENDCASE

Kasus 2: Sistem Menu Program Kalkulator Sederhana

PROGRAM KalkulatorMini
DEKLARASI:
    a, b, hasil : real
    pilihan : char
ALGORITMA:
    output("=== MENU KALKULATOR ===")
    output(" [+] Penjumlahan")
    output(" [-] Pengurangan")
    output(" [*] Perkalian")
    output(" [/] Pembagian")
    output("Pilih operasi: ")
    read(pilihan)

    output("Masukkan bilangan pertama: ")
    read(a)
    output("Masukkan bilangan kedua: ")
    read(b)

    CASE pilihan OF
        '+' : hasil <- a + b
              output("Hasil Penjumlahan: ", hasil)
        '-' : hasil <- a - b
              output("Hasil Pengurangan: ", hasil)
        '*' : hasil <- a * b
              output("Hasil Perkalian  : ", hasil)
        '/' : IF (b <> 0) THEN
                  hasil <- a / b
                  output("Hasil Pembagian  : ", hasil)
              ELSE
                  output("Kesalahan: Pembagian dengan nol tidak didefinisikan!")
              ENDIF
        OTHERWISE : output("Operasi tidak dikenali!")
    ENDCASE

5. Implementasi Lintas Bahasa dan Fenomena Fall-Through

5.1 Bahasa C / C++ / Java (Pentingnya Instruksi break)

Pada bahasa turunan C, struktur switch-case memiliki perilaku bawaan yang disebut fall-through: jika instruksi break; tidak disertakan di akhir setiap blok kasus, eksekusi program akan terus "merosot" menembus kasus-kasus berikutnya tanpa memeriksa nilai kasus lagi!

#include <stdio.h>

int main() {
    int angka = 1;
    switch (angka) {
        case 1:
            printf("Satu ");
            // Tanpa 'break', program lanjut ke case 2!
        case 2:
            printf("Dua ");
            break;
        default:
            printf("Lainnya");
    }
    // Output yang keluar: "Satu Dua "
    return 0;
}

Implementasi Standar dengan break:

switch (pilihan) {
    case 1:
        aksi_1();
        break;
    case 2:
        aksi_2();
        break;
    default:
        aksi_default();
        break;
}

5.2 Bahasa Pascal

Pada Pascal, setiap kasus otomatis terisolasi (tidak ada fall-through), sehingga tidak memerlukan perintah break.

case no_hari of
    1..5: writeln('Hari Kerja');
    6, 7: writeln('Akhir Pekan');
else
    writeln('Nomor hari salah');
end;

5.3 Python 3.10+ (Structural Pattern Matching)

Python menggunakan kata kunci match dan case:

match no_hari:
    case 1:
        print("Senin")
    case 2:
        print("Selasa")
    case 6 | 7:
        print("Akhir Pekan")
    case _:
        print("Nomor hari tidak valid") # wildcard default

6. Keunggulan Arsitektur: Tabel Lompatan (Jump Table)

Secara teknis di level bahasa mesin/rakitan (assembly), rantai if-else if membutuhkan serangkaian instruksi komparasi berurutan dengan kompleksitas waktu $O(n)$.

Sebaliknya, kompilator dapat menerjemahkan struktur switch-case yang padat menjadi tabel lompatan (jump table) berbasis larik pointer ke alamat kode. Melalui mekanisme ini, CPU melompat langsung ke alamat instruksi yang bersangkutan dengan kompleksitas waktu konstan $O(1)$, terlepas dari seberapa banyak pilihan kasus yang ada.

7. Rangkuman Materi

• Instruksi case menyederhanakan pemilihan banyak alternatif bernilai diskrit ordinal (integer, char, enum).
• Tipe pecahan (real/float) dilarang digunakan sebagai pemilih.
• Klausul penanganan alternatif tak cocok (OTHERWISE, else, default) wajib disertakan untuk menjamin reliabilitas program.
• Pada bahasa C, C++, dan Java, sertakan instruksi break pada setiap akhir kasus untuk mencegah perilaku fall-through.
• Dari sisi efisiensi mesin, switch-case lebih optimal dibanding rantai panjang if-else if karena dapat dioptimalkan menjadi jump table.

BAB 3: INSTRUKSI UTAMA

3.3 Instruksi Pengulangan

1. Konsep Dasar Instruksi Pengulangan (Looping / Iteration)

Instruksi pengulangan (looping, iteration, atau repetition) adalah struktur kendali program yang memungkinkan sekumpulan instruksi dieksekusi secara berulang kali selama suatu kondisi tertentu masih terpenuhi (bernilai true), atau hingga suatu kondisi penghenti tercapai.

Pengulangan merupakan salah satu keunggulan utama komputer dibandingkan manusia: kemampuan menjalankan jutaan tugas repetitif dengan kecepatan tinggi dan tingkat akurasi yang sempurna tanpa mengalami kelelahan.

Manfaat Utama Struktur Pengulangan:

• Efisiensi Kode (Code Reusability): Mencegah duplikasi baris kode instruksi yang identik (DRY - Don't Repeat Yourself).
• Fleksibilitas Dinamis: Mampu memproses volume data dalam jumlah yang tidak pasti atau baru diketahui saat program berjalan (runtime).
• Kemudahan Pemeliharaan (Maintainability): Jika terjadi perubahan algoritma pada blok aksi berulang, pemrogram cukup memodifikasi satu blok perulangan saja.

2. Anatomi dan Komponen Pembentuk Perulangan

Setiap konstruksi perulangan yang benar dan terbebas dari kesalahan logika harus memiliki empat elemen penting berikut:

        +--------------------------------------------------------------+
        |                       ANATOMI PERULANGAN                     |
        +--------------------------------------------------------------+
        1. Inisialisasi       : i <- 1
        2. Evaluasi Kondisi   : i <= 100 ?
        3. Badan Perulangan   : output("Data ke-", i)
        4. Pembaruan Pencacah : i <- i + 1
        +--------------------------------------------------------------+

1. Inisialisasi (Initialization): Mempersiapkan keadaan awal dari variabel pengendali perulangan (loop control variable / counter) sebelum siklus pertama dimulai.
2. Kondisi Perulangan (Loop Condition): Ekspresi boolean yang dievaluasi sebelum atau sesudah setiap siklus perulangan untuk menentukan apakah pengulangan harus dilanjutkan atau dihentikan.
3. Badan Perulangan (Loop Body): Satu atau lebih instruksi atau aksi komputasi yang ingin dieksekusi secara berulang.
4. Pembaruan / Terminasi (Update / Iteration Step): Instruksi yang mengubah nilai variabel pengendali (misalnya penambahan i <- i + 1 atau pengurangan i <- i - 1) agar kondisi terminasi pada akhirnya tercapai.

3. Klasifikasi Struktur Perulangan

Terdapat dua dimensi utama dalam mengklasifikasikan struktur perulangan:

3.1 Berdasarkan Posisi Pengujian Kondisi

               [ PRE-TEST LOOP ]                        [ POST-TEST LOOP ]
             (while-do, for-do)                       (repeat-until, do-while)

                +------------+                             +------------+
                | Evaluasi   |                             |   Badan    |
                |  Kondisi   |                             | Perulangan |
                +-----+------+                             +-----+------+
            True |    | False                                    |
                 v    v                                          v
          +---------+ +--------+                           +------------+
          |  Badan  | | Selesai|                           |  Evaluasi  |
          |  Loop   | +--------+                           |   Kondisi  |
          +----+----+                                      +-----+------+
               |                                       Ulang |   | Selesai
               +-----(putar balik)                           +---+

1. Pengujian di Awal (Pre-test Loop):
   • Kondisi dievaluasi sebelum badan perulangan dikerjakan.
   • Jika kondisi bernilai salah sejak awal, badan perulangan tidak akan pernah dikerjakan sama sekali (0 kali).
   • Contoh: konstruksi WHILE - DO dan FOR.
2. Pengujian di Akhir (Post-test Loop):
   • Kondisi dievaluasi setelah badan perulangan dikerjakan.
   • Badan perulangan dijamin pasti dieksekusi minimal satu kali (1 kali), meskipun kondisi sejak awal sudah terpenuhi/tidak terpenuhi.
   • Contoh: konstruksi REPEAT - UNTIL (Pascal) dan DO - WHILE (C/C++/Java).

3.2 Berdasarkan Kepastian Jumlah Putaran

1. Perulangan Tertentu (Definite Loop): Jumlah siklus perulangan sudah diketahui secara pasti sebelum perulangan mulai dieksekusi (misalnya mengulang 100 kali, memproses seluruh 50 elemen array). Konstruksi yang ideal adalah FOR.
2. Perulangan Tidak Tertentu (Indefinite Loop): Jumlah putaran perulangan tidak diketahui secara pasti di awal, melainkan bergantung pada kejadian dinamis saat eksekusi (misalnya menunggu pengguna menekan tombol 'Q', membaca data sampai akhir berkas EOF, atau menunggu tebakan angka benar). Konstruksi yang ideal adalah WHILE atau REPEAT.

4. Perulangan Tak Berhingga (Infinite Loop)

Infinite loop adalah kondisi galat logika fatal di mana perulangan berjalan terus-menerus tanpa pernah berhenti karena kondisi penghenti tidak pernah tercapai, yang dapat menghabiskan sumber daya CPU dan menyebabkan program membeku (hang / crash).

Penyebab Umum Terjadinya Infinite Loop:

1. Lupa Menuliskan Pembaruan Pencacah (Missing Counter Increment):

   i <- 1
   WHILE (i <= 5) DO
       write(i)
       { Lupa menulis i <- i + 1; nilai i selamanya 1! }
   ENDWHILE
   

2. Arah Perubahan Pencacah yang Terbalik (Wrong Direction):

   i <- 1
   WHILE (i <= 5) DO
       write(i)
       i <- i - 1   { Mengurangi i menjadikannya 0, -1, -2... makin menjauhi 5 }
   ENDWHILE
   

3. Kondisi Penghenti yang Mustahil Terpenuhi: Menggunakan pengujian persamaan mutlak (==) pada bilangan pecahan yang rentan ketidaktepatan presisi representasi memori.

5. Pengendali Alur Tambahan: break dan continue

Dalam implementasi bahasa pemrograman nyata, tersedia dua kata kunci khusus untuk menginterupsi jalannya perulangan:

• break: Menghentikan eksekusi perulangan secara paksa seketika itu juga dan melompat keluar ke instruksi berikutnya di luar blok perulangan.
• continue: Menghentikan siklus iterasi yang sedang berlangsung saat itu juga, lalu segera melompat ke iterasi berikutnya (melewati instruksi-instruksi di bawahnya pada siklus tersebut).

for (int k = 1; k <= 10; k++) {
    if (k == 3) continue; // Lewati angka 3, langsung ke iterasi k = 4
    if (k == 8) break;    // Hentikan perulangan total ketika k mencapai 8
    printf("%d ", k);
}
// Hasil keluaran: 1 2 4 5 6 7

6. Perulangan Bersarang (Nested Loops)

Perulangan bersarang adalah konstruksi di mana sebuah struktur perulangan berada di dalam badan perulangan lain. Pendekatan ini umum digunakan untuk manipulasi struktur multidimensi (seperti matriks atau tabel), pola baris-kolom grafis, dan algoritma pengurutan data (bubble sort, insertion sort).

{ Mencetak tabel perkalian 1 s.d. 3 }
FOR i <- 1 TO 3 DO
    FOR j <- 1 TO 3 DO
        write(i * j, " ")
    ENDFOR
    writeln()
ENDFOR

7. Rangkuman Materi

• Instruksi pengulangan mengotomatiskan eksekusi blok kode secara berulang berdasarkan kondisi logika.
• Empat pilar penting perulangan: inisialisasi, kondisi pengujian, badan perulangan, dan pembaruan nilai variabel pengendali.
• Berdasarkan letak evaluasinya, perulangan terbagi atas pre-test (kondisi di awal) dan post-test (kondisi di akhir).
• Berdasarkan kepastian siklusnya, perulangan dibedakan menjadi definite (for) dan indefinite (while, repeat-until).
• Pemrogram wajib memastikan perubahan nilai pengendali loop menuju kondisi terminasi guna menghindari terjadinya infinite loop.

BAB 3: INSTRUKSI UTAMA

3.3.1 Perulangan while – do

1. Definisi dan Konsep Perulangan while – do

Struktur perulangan while – do adalah bentuk perulangan dengan pengujian kondisi di awal (pre-test loop). Pada struktur ini, ekspresi kondisi boolean dievaluasi terlebih dahulu sebelum badan perulangan dijalankan. Selama (while) kondisi tersebut bernilai benar (true), maka aksi di dalam badan perulangan akan terus dikerjakan (do). Begitu kondisi dievaluasi dan bernilai salah (false), perulangan langsung berakhir dan program melompat ke instruksi berikutnya di luar blok perulangan.

Ciri Khas Utama:

• Jumlah Eksekusi Minimum = 0: Jika kondisi boolean bernilai salah sejak awal sebelum perulangan pertama dimulai, badan perulangan sama sekali tidak akan pernah dijalankan.
• Perulangan Tidak Tentu (Indefinite Loop): Sangat ideal digunakan ketika jumlah pengulangan belum dapat dipastikan di awal, melainkan bergantung pada dinamika data masukan atau kondisi komputasi.

                         +--------------------------+
                         |      KONDISI BOOLEAN     |
                   +---> |         (Kondisi?)       |
                   |     +------------+-------------+
                   |                  |
                   |            BENAR |   SALAH
                   |                  v     +---------------------+
                   |          +-------------+                     |
                   |          | Badan Loop  |                     |
                   |          | (Aksi & Inc)|                     |
                   |          +------+------+                     |
                   |                 |                            |
                   +-----------------+                            v
                                                     +--------------------+
                                                     | Selesai Perulangan |
                                                     +--------------------+

2. Notasi Algoritmik

Dalam notasi algoritmik standar, format penulisan while – do adalah:

WHILE kondisi DO
    aksi_1
    aksi_2
    ...
    pembaruan_kondisi
ENDWHILE

3. Contoh Kasus dan Tabel Penelusuran (Trace Table)

Kasus 1: Mencetak Deret Bilangan Bulat 1 hingga 5

PROGRAM CetakDeret
DEKLARASI:
    i : integer
ALGORITMA:
    i <- 1              { 1. Inisialisasi awal }
    WHILE (i <= 5) DO   { 2. Evaluasi kondisi }
        write(i, " ")   { 3. Badan perulangan }
        i <- i + 1      { 4. Pembaruan pencacah }
    ENDWHILE
    writeln("Selesai")

Tabel Penelusuran (Trace Table):

Hasil tampilan layar: 1 2 3 4 5 Selesai

Kasus 2: Menghitung Akumulasi Total dan Rata-rata dengan Nilai Sentinela (Sentinel Value)

Nilai sentinela adalah nilai tanda khusus (misalnya -999) yang digunakan untuk mengindikasikan akhir dari urutan data masukan tanpa memerlukan jumlah data yang ditentukan sebelumnya.

PROGRAM HitungRataRataSentinel
DEKLARASI:
    nilai, total : real
    cacah : integer
ALGORITMA:
    total <- 0
    cacah <- 0
    
    output("Masukkan nilai pertama (atau -999 untuk keluar): ")
    read(nilai)

    WHILE (nilai <> -999) DO
        total <- total + nilai
        cacah <- cacah + 1
        
        output("Masukkan nilai berikutnya (atau -999): ")
        read(nilai)  { Pembaruan nilai sentinela }
    ENDWHILE

    IF (cacah > 0) THEN
        output("Total Nilai: ", total)
        output("Rata-rata  : ", total / cacah)
    ELSE
        output("Tidak ada data yang diproses.")
    ENDIF

Kasus 3: Validasi Masukan Pengguna (Input Validation Loop)

Memastikan pengguna memasukkan data sesuai batas yang diizinkan (misalnya nilai ujian harus antara 0 s.d. 100).

PROGRAM ValidasiInput
DEKLARASI:
    skor : integer
ALGORITMA:
    output("Masukkan skor ujian (0-100): ")
    read(skor)

    { Selama nilai salah, paksa input ulang }
    WHILE (skor < 0 OR skor > 100) DO
        output("Kesalahan! Skor harus antara 0 dan 100. Masukkan kembali: ")
        read(skor)
    ENDWHILE

    output("Skor valid diterima: ", skor)

4. Implementasi Lintas Bahasa Pemrograman

4.1 Bahasa C / C++

#include <stdio.h>

int main() {
    int i = 1;
    while (i <= 5) {
        printf("%d ", i);
        i++;
    }
    printf("\n");
    return 0;
}

4.2 Bahasa Pascal

program DeretWhile;
var
    i: integer;
begin
    i := 1;
    while i <= 5 do
    begin
        write(i, ' ');
        i := i + 1;
    end;
    writeln;
end.

4.3 Bahasa Python

i = 1
while i <= 5:
    print(i, end=" ")
    i += 1
print()

5. Galat Logika Umum (Common Logical Pitfalls)

1. Lupa Menuliskan Baris Pembaruan Variabel Pengendali: Mengakibatkan kondisi perulangan selalu bernilai true selamanya (infinite loop).
2. Kondisi Awal Langsung Salah (Zero Iteration Error): Jika inisialisasi salah (misalnya i = 10 padahal kondisi while (i <= 5)), badan loop tidak akan pernah dijalankan satu kali pun.
3. Kesalahan Batas Hitungan (Off-By-One Error): Ketidaktelitian memilih operator relasional < atau <=, yang berakibat iterasi kurang satu kali atau berlebih satu kali dari yang diharapkan.

6. Rangkuman Materi

• Struktur while – do adalah perulangan dengan evaluasi kondisi di muka (pre-test loop).
• Jumlah iterasi minimum adalah nol (0 kali), yaitu saat kondisi awal bernilai false.
• Sangat tepat diterapkan pada kasus di mana banyaknya perulangan bergantung pada peristiwa dinamis (misalnya masukan sentinela atau validasi formulir).
• Pembaruan variabel pengendali loop di dalam tubuh perulangan wajib ada untuk mencegah pembekuan program akibat infinite loop.

BAB 3: INSTRUKSI UTAMA

3.3.2 Perulangan repeat – until

1. Definisi dan Konsep Perulangan repeat – until

Struktur perulangan repeat – until adalah konstruksi pengulangan dengan pengujian kondisi di akhir (post-test loop). Pada struktur ini, instruksi-instruksi di dalam badan perulangan dikerjakan terlebih dahulu (repeat), baru kemudian kondisi logika dievaluasi pada bagian bawah (until).

Dua Karakteristik Fundamental:

1. Jumlah Eksekusi Minimum Pasti 1 Kali: Karena pemeriksaan kondisi baru dilakukan setelah badan perulangan dieksekusi, maka seluruh instruksi di dalam badan perulangan dijamin pasti dijalankan minimal satu kali, terlepas dari apakah kondisi bernilai benar atau salah pada awalnya.
2. Logika Kondisi Penghenti (Termination Condition): Berbeda dengan struktur while-do yang terus berputar selama kondisi benar, struktur repeat-until terus berputar selama kondisi masih salah (false), dan baru berhenti ketika kondisi menjadi benar (true).

                   +--------------------------+
                   |       Mulai Siklus       |
                   +------------+-------------+
                                |
                                v
                   +--------------------------+
                   |     Badan Perulangan     |<----+
                   |     (Aksi & Pembaruan)   |     |
                   +------------+-------------+     |
                                |                   |
                                v                   |
                   +--------------------------+     |
                   |      EVALUASI KONDISI    |     | SALAH (ULANG)
                   |      (Apakah Selesai?)   |-----+
                   +------------+-------------+
                                |
                          BENAR | (BERHENTI)
                                v
                   +--------------------------+
                   |    Instruksi Lanjutan    |
                   +--------------------------+

2. Notasi Algoritmik

Dalam notasi algoritmik standar, blok badan perulangan secara otomatis dibatasi oleh kata kunci pembuka REPEAT dan penutup UNTIL, sehingga tidak memerlukan kata kunci tambahan begin-end:

REPEAT
    aksi_1
    aksi_2
    pembaruan_kondisi
UNTIL kondisi_berhenti

3. Perbandingan Logika: repeat – until vs do – while

Perlu diperhatikan perbedaan semantik yang sangat penting antara Pascal dan bahasa-bahasa turunan C (C, C++, Java, C#):

Hukum Negasi (De Morgan): Sebuah perulangan Pascal until (i > 5) ekuivalen dengan instruksi C while (i <= 5).

4. Contoh Kasus Penerapan

Kasus 1: Antarmuka Menu Interaktif Berulang

Menu aplikasi harus ditampilkan kepada pengguna minimal satu kali, dan baru akan berhenti berputar jika pengguna secara sengaja memilih opsi keluar (0).

PROGRAM MenuAplikasi
DEKLARASI:
    pilihan : integer
ALGORITMA:
    REPEAT
        output("===============================")
        output("       SISTEM AKADEMIK         ")
        output("===============================")
        output(" 1. Lihat Kartu Rencana Studi  ")
        output(" 2. Lihat Transkrip Nilai      ")
        output(" 3. Jadwal Kuliah              ")
        output(" 0. Keluar Aplikasi            ")
        output("Pilihan Anda (0-3): ")
        read(pilihan)

        CASE pilihan OF
            1 : output("Menampilkan KRS...")
            2 : output("Menampilkan Transkrip...")
            3 : output("Menampilkan Jadwal...")
            0 : output("Terima kasih telah menggunakan sistem.")
            OTHERWISE : output("Pilihan tidak valid!")
        ENDCASE
    UNTIL (pilihan = 0)

Kasus 2: Permainan Tebak Angka Rahasia

Komputer menyimpan angka rahasia (misal 7), dan meminta pengguna menebak hingga tebakannya tepat.

PROGRAM TebakAngka
DEKLARASI:
    konstanta RAHASIA = 7
    tebakan, percobaan : integer
ALGORITMA:
    percobaan <- 0
    REPEAT
        output("Tebak angka rahasia (1-10): ")
        read(tebakan)
        percobaan <- percobaan + 1

        IF (tebakan < RAHASIA) THEN
            output("Tebakan Anda terlalu kecil!")
        ELSE IF (tebakan > RAHASIA) THEN
            output("Tebakan Anda terlalu besar!")
        ENDIF
    UNTIL (tebakan = RAHASIA)

    output("Selamat! Anda berhasil menebak dalam ", percobaan, " kali percobaan.")

5. Implementasi Lintas Bahasa Pemrograman

5.1 Bahasa Pascal (repeat - until)

program UlangRepeat;
var
    i: integer;
begin
    i := 1;
    repeat
        write(i, ' ');
        i := i + 1;
    until i > 5;
    writeln;
end.

5.2 Bahasa C / C++ (do - while)

Ingat: kondisinya adalah kebalikan dari until Pascal.

#include <stdio.h>

int main() {
    int i = 1;
    do {
        printf("%d ", i);
        i++;
    } while (i <= 5); // Lanjut selama i <= 5
    printf("\n");
    return 0;
}

5.3 Bahasa Python

Python tidak menyediakan struktur do-while atau repeat-until secara langsung. Konsep ini lazim diimplementasikan dengan perulangan while True yang diinterupsi oleh instruksi break:

i = 1
while True:
    print(i, end=" ")
    i += 1
    if i > 5:  # Kondisi terminasi
        break
print()

6. Kapan Memilih repeat – until Dibanding while – do?

Gunakan struktur repeat – until jika dan hanya jika:

1. Badan instruksi mutlak harus dijalankan setidaknya satu kali sebelum pengujian kelayakan dapat dievaluasi (seperti menampilkan menu, membaca formulir sandi, atau membaca data acak dari sensor).
2. Data kondisi penghenti baru diperoleh di dalam badan perulangan itu sendiri melalui proses interaksi masukan.

7. Rangkuman Materi

• Struktur repeat – until adalah perulangan dengan evaluasi di akhir (post-test loop).
• Menjamin eksekusi badan instruksi minimal 1 kali.
• Berputar selama kondisi bernilai salah (false), dan berhenti seketika kondisi menjadi benar (true).
• Pada bahasa C/C++/Java, ekuivalen fungsinya adalah do – while, namun dengan logika kondisi yang terbalik.
• Sangat ideal untuk pembuatan sistem menu interaktif, permainan giliran, dan validasi input langsung.

BAB 3: INSTRUKSI UTAMA

3.3.3 Pengulangan for

1. Definisi dan Konsep Perulangan for

Struktur perulangan for adalah bentuk konstruksi pengulangan yang paling tepat digunakan ketika jumlah perulangan (banyaknya iterasi) sudah diketahui atau dapat ditentukan secara pasti (definite loop) sebelum proses perulangan dimulai.

Perulangan for secara otomatis mengelola variabel pencacah (counter), mulai dari inisialisasi nilai awal, pemeriksaan kondisi batas akhir, hingga penambahan (increment) atau pengurangan (decrement) nilai pencacah di setiap akhir siklus putaran.

Keunggulan Struktur for:

• Kompak dan Ringkas: Inisialisasi, kondisi batas, dan pembaruan pencacah terangkum dalam satu baris deklarasi kepala perulangan.
• Minim Galat Infinite Loop: Karena mekanisme pembaruan pencacah diatur secara otomatis oleh sistem/struktur bahasa.

2. Bentuk dan Arah Pencacahan

Dalam notasi algoritmik baku, perulangan for memiliki dua bentuk arah pencacahan utama serta variasi nilai langkah (step):

2.1 Pencacahan Menaik (Ascending / TO)

Pencacah bergerak dari nilai awal yang lebih kecil menuju nilai akhir yang lebih besar dengan penambahan otomatis sebesar +1 pada setiap putaran.

FOR pencacah <- nilai_awal TO nilai_akhir DO
    aksi
ENDFOR

Catatan: Jika nilai_awal > nilai_akhir, badan perulangan tidak akan dieksekusi sama sekali (0 kali).

2.2 Pencacahan Menurun (Descending / DOWNTO)

Pencacah bergerak dari nilai awal yang lebih besar menuju nilai akhir yang lebih kecil dengan pengurangan otomatis sebesar -1 pada setiap putaran.

FOR pencacah <- nilai_awal DOWNTO nilai_akhir DO
    aksi
ENDFOR

Catatan: Jika nilai_awal < nilai_akhir, badan perulangan tidak akan dieksekusi sama sekali (0 kali).

2.3 Pencacahan dengan Nilai Langkah (STEP)

Secara bawaan (default), langkah kenaikan/penurunan bernilai 1. Klausul STEP memungkinkan pemrogram menentukan interval lompatan tertentu (misal melompat 2, 5, atau 10).

FOR i <- 1 TO 10 STEP 2 DO
    write(i, " ") { Mencetak angka ganjil: 1 3 5 7 9 }
ENDFOR

3. Contoh Kasus Penerapan

Kasus 1: Perhitungan Nilai Faktorial ($N!$)

Faktorial didefinisikan sebagai hasil kali semua bilangan bulat positif dari 1 hingga $N$: $$N! = 1 \times 2 \times 3 \times \dots \times N$$

PROGRAM HitungFaktorial
DEKLARASI:
    N, i : integer
    faktorial : longint
ALGORITMA:
    output("Masukkan nilai N: ")
    read(N)

    faktorial <- 1  { Elemen identitas perkalian }

    FOR i <- 1 TO N DO
        faktorial <- faktorial * i
    ENDFOR

    output("Nilai dari ", N, "! adalah: ", faktorial)

Kasus 2: Menghitung Mundur (Countdown) dengan DOWNTO

PROGRAM HitungMundur
DEKLARASI:
    detik : integer
ALGORITMA:
    output("Hitung mundur peluncuran:")
    FOR detik <- 5 DOWNTO 1 DO
        output(detik, "...")
    ENDFOR
    output("LUNCURKAN!")

Kasus 3: Perulangan Bersarang (Nested For) untuk Membuat Pola Bintang

Membuat segitiga siku-siku dengan tinggi $N$ baris:

PROGRAM PolaSegitiga
DEKLARASI:
    N, baris, kolom : integer
ALGORITMA:
    read(N)
    FOR baris <- 1 TO N DO
        FOR kolom <- 1 TO baris DO
            write("* ")
        ENDFOR
        writeln() { Pindah baris }
    ENDFOR

Tampilan keluaran jika $N = 4$:

* 
* * 
* * * 
* * * * 

4. Implementasi Lintas Bahasa Pemrograman

4.1 Bahasa Pascal

Pascal mempertahankan keselarasan ketat dengan notasi algoritmik baku:

program DeretFor;
var
    i: integer;
begin
    { Menaik }
    for i := 1 to 5 do
        write(i, ' ');
    writeln;

    { Menurun }
    for i := 5 downto 1 do
        write(i, ' ');
    writeln;
end.

4.2 Bahasa C / C++ / Java

Keluarga bahasa C memiliki konstruksi for yang sangat fleksibel: for (inisialisasi; kondisi; pembaruan).

#include <stdio.h>

int main() {
    // Menaik
    for (int i = 1; i <= 5; i++) {
        printf("%d ", i);
    }
    printf("\n");

    // Menurun dengan langkah 2
    for (int i = 10; i >= 2; i -= 2) {
        printf("%d ", i);
    }
    printf("\n");
    return 0;
}

4.3 Bahasa Python

Python menggunakan fungsi generator range(start, stop, step):

# range(start, stop) -> stop bersifat eksklusif (tidak termasuk)
for i in range(1, 6): # menghasilkan 1 s.d. 5
    print(i, end=" ")
print()

# range menurun dengan step negatif
for i in range(5, 0, -1): # menghasilkan 5, 4, 3, 2, 1
    print(i, end=" ")
print()

5. Aturan Penting: Integritas Variabel Pencacah

ATURAN EMAS: Jangan pernah memodifikasi nilai variabel pencacah (counter) secara manual di dalam badan perulangan for!

{ KESALAHAN LOGIKA FATAL: }
FOR i <- 1 TO 10 DO
    write(i)
    i <- i + 2   { SANGAT TIDAK DIANJURKAN! Merusak keteraturan siklus loop }
ENDFOR

Memanipulasi pencacah secara manual di dalam tubuh for melanggar konsep definite loop dan dapat menimbulkan hasil iterasi yang tidak dapat diprediksi atau bahkan memicu infinite loop. Jika langkah iterasi bersifat dinamis, gunakanlah konstruksi while – do.

6. Matriks Perbandingan Ketiga Struktur Perulangan

7. Rangkuman Materi

• Struktur for dirancang khusus untuk perulangan dengan jumlah iterasi terdefinisi pasti (definite loop).
• Menyediakan mode pencacahan menaik (TO), menurun (DOWNTO), dan bernilai langkah kustom (STEP).
• Variabel pencacah dikelola secara otomatis sehingga lebih aman dari bahaya infinite loop.
• Variabel pencacah tidak boleh dimodifikasi nilainya di dalam badan perulangan.
• Pemilihan antara for, while, atau repeat harus disesuaikan dengan karakteristik persoalan (kepastian iterasi dan lokasi pengujian kondisi).