P. 1
Algoritma

Algoritma

|Views: 410|Likes:
Published by Arief Nur Khoerudin

More info:

Published by: Arief Nur Khoerudin on Oct 08, 2012
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

11/04/2013

pdf

text

original

Sections

i

DAFTAR ISI

BAB I : PENGANTAR ............................................... 1
A. Pengertian Algoritma & Pemrograman ................................... 1
1. Algoritma ............................................................................................................................ 1
2. Pemrograman ...................................................................................................................... 1
B. Tipe-tipe Algoritma Berdasarkan Format Penulisan .................... 1
1. Deskriptif ............................................................................................................................ 1
2. Flow Chart (Diagram Alir) .................................................................................................. 2
3. Pseudocode ......................................................................................................................... 3
C. Flow Chart (Diagram Alir) ................................................ 4
1. Pengertian ........................................................................................................................... 4
2. Simbol-simbol Flow Chart .................................................................................................. 4
3. Bentuk-bentuk Dasar Struktur Logika Flow Chart ............................................................... 5
BAB II : DASAR-DASAR ALGORITMA ..................... 7
A. Struktur Penulisan Algoritma ............................................ 7
1. Kepala Algoritma ................................................................................................................ 7
2. Deklarasi ............................................................................................................................. 8
3. Deskripsi ............................................................................................................................. 8
B. Komentar (Comment) Algoritma .......................................... 8
C. Penamaan/Pengenal (Identifier) .......................................... 9
D. Tipe Data ................................................................. 9
1. Integer ................................................................................................................................ 9
2. Real .................................................................................................................................. 10
3. Char .................................................................................................................................. 10
4. String ................................................................................................................................ 10
5. Boolean............................................................................................................................. 10
E. Variabel ..................................................................11
F. Konstanta ................................................................11
G. Ekspresi ..................................................................11

ii
1. operator aritmatika ............................................................................................................ 11
2. operator perbandingan ....................................................................................................... 12
3. operator string ................................................................................................................... 12
4. Logika .............................................................................................................................. 12
5. Tingkatan-tingkatan dalam operator .................................................................................. 13
H. Penugasan (Assigment) ..................................................13
I. Input dan Output ........................................................14
1. Input ................................................................................................................................. 15
2. Output ............................................................................................................................... 16
BAB III : RUNTUNAN ............................................ 17
A. Pengertian ...............................................................17
B. Contoh-contoh ...........................................................18
1. Algoritma Luas Segitiga () ........................................................................................... 18
2. Algoritma Komisi Salesman ()...................................................................................... 18
3. Algoritma Gaji Karyawan () ...................................................................................... 19
4. Algoritma Konversi Waktu ke Total Detik () ............................................................. 20
5. Algoritma Konversi Total Detik ke Waktu ().......................................................... 20
6. Algoritma Pembulatan Seratusan () ................................................................ 21
7. Algoritma Pertukaran Data () ................................................................................ 22
8. Algoritma Menghitung Selisih Waktu () ......................................................... 23
C. Latihan ...................................................................25
BAB IV : PEMILIHAN ........................................... 26
A. Pengertian ...............................................................26
B. Pemilihan 1 Kasus ........................................................27
1. Pendahuluan...................................................................................................................... 27
2. Algoritma Pengecekan Negatif () ................................................................................... 27
3. Algoritma Pemberian Diskon () ................................................................................. 27
C. Pemilihan 2 Kasus ........................................................29
1. Pendahuluan...................................................................................................................... 29
2. Algoritma Ganjil Genap () ......................................................................................... 29
3. Algoritma Terbesar dari 2 Bilangan () ........................................................................... 31
4. Algoritma Menghitung Uang Lembur () ............................................................. 31
5. Algoritma Tahun Kabisat () ............................................................................ 32
6. Algoritma Syarat Keanggotaan Suatu Jangkauan/Range () ..................................... 33
7. Algoritma Syarat Keanggotaan Diluar Range () ..................................................... 34
D. Pemilihan Lebih dari 2 Kasus ...........................................34

iii
1. Pendahuluan...................................................................................................................... 34
2. Algoritma Menentukan Positif, Nol, atau Negatif () ................................................... 35
3. Algoritma Gaji Berdasarkan Golongan () ................................................................... 36
4. Algoritma Penentuan Nomor Kuadran Titik Koordinat () ................................... 37
5. Algoritma Tahun Kabisat () ................................................................................... 40
6. Algoritma Menentukan Grade Nilai Akhir () .......................................................... 41
7. Algoritma Penambahan 1 Detik Pada Waktu () ............................................... 43
8. Algoritma Terbesar dari 3 Bilangan (Bandingkan Satu-Satu) () ............................. 44
9. Algoritma Terbesar dari 3 Bilangan (Pohon Keputusan) () .................................... 45
10. Algoritma Terbesar Dari 3 Bilangan (Sekuensial) () ............................................. 46
E. Latihan ...................................................................48
BAB V : PENGULANGAN ...................................... 49
A. Pengertian ...............................................................49
B. Definite Loop ............................................................49
1. Contoh-contoh .................................................................................................................. 50
2. Algoritma Mencetak Barisan () ...................................................................................... 51
3. Algoritma Penjumlahan Deret () ................................................................................ 52
4. Algoritma Hitung Rata-rata dari n Data () .............................................................. 53
5. Algoritma Perhitungan Banyaknya yang Lulus () ................................................... 53
6. Algoritma Terbesar dari n Data Bilangan () ............................................................ 54
7. Algoritma Nilai Tertinggi () ................................................................................... 55
8. Algoritma Faktorial () ............................................................................................ 56
9. Algoritma Pangkat Bulat ()............................................................................. 56
10. Algoritma Menentukan Prima () ....................................................................... 58
C. Indefinite Loop ..........................................................59
1. Algoritma Menghitung Jumlahan Data .............................................................................. 62
2. Algoritma Pemasukkan Password ...................................................................................... 65
3. Algoritma Estimasi Nilai Akar Kuadrat ............................................................................. 67
4. Algoritma Menentukan Prima (Perbaikan) ......................................................................... 69
D. Latihan ...................................................................71
BAB VI : ARRAY (LARIK) ...................................... 72
A. Pendahuluan ..............................................................72
1. Pengertian ......................................................................................................................... 72
2. Cara Pendeklarasian .......................................................................................................... 72
3. Cara Pemakaian Array....................................................................................................... 73
B. Array 1 Dimensi .........................................................74

iv
1. Algoritma Menghitung Rata-rata ....................................................................................... 74
2. Algoritma Menentukan Terbesar ....................................................................................... 75
3. Algoritma Menentukan Nama Mahasiswa Nilai Tertinggi .................................................. 77
4. Algoritma Menghitung Jumlah Kelulusan.......................................................................... 79
5. Algoritma Rekapitulasi Grade ........................................................................................... 81
C. Metode Pencarian ........................................................84
1. Metode Sekuensial ............................................................................................................ 85
2. Metode Biner .................................................................................................................... 87
D. Metode Pengurutan ......................................................89
1. Metode Pengurutan Bubble (Bubble Sort) ......................................................................... 90
2. Metode Seleksi (Selection Sort) ......................................................................................... 92
3. Metode Penyisipan (Insertion Sort).................................................................................... 94
E. Array Multi Dimensi .....................................................97
1. Algoritma Pengolahan Data Nilai per Kelas ....................................................................... 99
F. Matriks ................................................................. 100
1. Pengertian ....................................................................................................................... 100
2. Pengisian Matriks ............................................................................................................ 101
3. Algoritma Pengecekan Matriks ........................................................................................ 104
4. Algoritma Penjumlahan Matriks ...................................................................................... 105
5. Algoritma Perkalian Matriks ........................................................................................... 107
G. Latihan ................................................................. 108
BAB VII : RECORD (REKAMAN) ......................... 110
A. Pendahuluan ............................................................ 110
1. Pengertian ....................................................................................................................... 110
2. Cara Pendeklarasian ........................................................................................................ 110
3. Cara Pemakaian Record .................................................................................................. 111
B. Contoh Penggunaan Record ............................................ 112
1. Algoritma Perhitungan Selisih Waktu .............................................................................. 112
2. Algoritma Perhitungan Bilangan Kompleks Sederhana .................................................... 113
C. Array of Record ....................................................... 114
1. Pengertian ....................................................................................................................... 114
2. Contoh Pendeklarasian .................................................................................................... 115
3. Cara Pengisian Data ke Variabel Array of Record ........................................................... 115

v
D. Contoh Penggunaan Array of Record ................................. 116
1. Algoritma Perhitungan Nilai Siswa.................................................................................. 116
2. Algoritma Pengurutan Pada Data Array of Record ........................................................... 117
3. Algoritma Pencarian Pada Data Array of Record ............................................................. 117





1
BAB I : PENGANTAR
A. Pengertian Algoritma & Pemrograman
1. Algoritma
Asal usul kata algoritma dapat Anda baca dalam buku “The Art of Computer
Programming Second Edition Volume I” yang ditulis oleh Donald E. Knuth (1973, p1-
2). Menurut Donald E. Knuth (1973,p4), algoritma dalam pengertian modern
mempunyai kemiripan dengan istilah resep, proses, metode, teknik, prosedur, rutin.
Algoritma adalah sekumpulan aturan-aturan berhingga yang memberikan sederetan
operasi-operasi untuk menyelesaikan suatu jenis masalah yang khusus.
Menurut Rinaldi Munir, algoritma adalah urutan langkah-langkah logis
penyelesaian masalah yang disusun secara sistematis.
Berdasarkan dua pengertian algoritma di atas, dapat disimpulkan bahwa algoritma
merupakan suatu istilah yang luas, yang tidak hanya berkaitan dengan dunia komputer.
2. Pemrograman
Pemrograman berasal dari kata program yang diberi awalan pe– dan akhiran –an.
Dalam buku ini, program berarti program komputer. Pengertian program komputer
menurut John M. Zelle, Ph.D. dalam bukunya yang berjudul “Python Programming:
An Introduction to Computer Science” (2002, p1) adalah sekumpulan instruksi
langkah per langkah yang memberitahukan mengenai yang harus dilakukan komputer
secara tepat. Pemrograman adalah segala kegiatan pembuatan program komputer.
Kemudian terdapat pula istilah bahasa pemrograman yang berarti bahasa yang
digunakan dalam pembuatan program komputer.
Berdasarkan pengertian algoritma dan pemrograman, maka dapat dikatakan
bahwa program merupakan hasil penerapan dari algoritma-algoritma. Akan tetapi,
dalam buku ini tidak dibahas materi mengenai pembuatan program komputer. Buku
ini memfokuskan teknik-teknik pembuatan algoritma itu sendiri. Nama mata kuliah
Algoritma dan Pemrograman dalam hal ini berarti mempelajari pembuatan algoritma-
algoritma yang dapat diterapkan dalam pemrograman.
B. Tipe-ti pe Algoritma Berdasarkan Format Penulisan
Algoritma adalah independen terhadap bahasa pemrograman tertentu, artinya
algoritma yang telah dibuat tidak boleh hanya dapat diterapkan pada bahasa
pemrograman tertentu. Penulisan algoritma tidak terikat pada suatu aturan tertentu,
tetapi harus jelas maksudnya untuk tiap langkah algoritmanya. Namun pada dasarnya
algoritma dibagi menjadi beberapa macam berdasarkan format penulisannya, yaitu:
1. Deskriptif
Algoritma bertipe deskriptif maksudnya adalah algoritma yang ditulis dalam
bahasa manusia sehari-hari (misalnya bahasa Indonesia atau bahasa Inggris) dan dalam
bentuk kalimat. Setiap langkah algoritmanya diterangkan dalam satu atau beberapa
kalimat.

2
Sebagai contoh misalnya algoritma menentukan bilangan terbesar dari 3 bilangan
berikut ini:
Algoritma Menentukan_bilangan_terbesar_dari_3_bilangan
1. Meminta input 3 bilangan dari user, misalkan bilangan a, b, dan c.
2. Apabila bilangan a lebih besar dari b maupun c, maka bilangan a
merupakan bilangan terbesar
3. Jika tidak (bilangan a tidak lebih besar dari b atau c) berarti
bilangan a sudah pasti bukan bilangan terbesar. Kemungkinannya
tinggal bilangan b atau c. Apabila bilangan b lebih besar dari c,
maka b merupakan bilangan terbesar. Sebaliknya apabila bilangan b
tidak lebih besar dari c, maka bilangan c merupakan yang terbesar.
4. Selesai.
2. Flow Chart (Diagram Alir)
Selain dalam bentuk tulisan, algoritma juga dapat ditulis dalam bentuk diagram-
diagram dengan anak panah sebagai penunjuk urutan langkah algoritmanya. Algoritma
yang ditulis dengan simbol-simbol demikian yang dinamakan flow chart.
Mengenai lambang-lambang yang digunakan akan dibahas pada bagian
selanjutnya. Sekarang diberikan suatu contoh algoritma menentukan bilangan terbesar
dari 3 bilangan seperti yang dicontohkan sebelumnya, tetapi ditulis dalam bentuk flow
chart.

START
INPUT
a, b, c
(a>b) and (a>c)?
(b>c)?
OUTPUT a
OUTPUT c OUTPUT b
END
FALSE TRUE
TRUE FALSE


3
3. Pseudocode
Pseudo berarti imitasi dan code berarti kode yang dihubungkan dengan instruksi
yang ditulis dalam bahasa komputer (kode bahasa pemrograman). Apabila
diterjemahkan secara bebas, maka pseudocode berarti tiruan atau imitasi dari kode
bahasa pemrograman.
Pada dasarnya, pseudocode merupakan suatu bahasa yang memungkinkan
programmer untuk berpikir terhadap permasalahan yang harus dipecahkan tanpa harus
memikirkan syntax dari bahasa pemrograman yang tertentu. Tidak ada aturan
penulisan syntax di dalam pseudocode. Jadi pseudocode digunakan untuk
menggambarkan logika urut-urutan dari program tanpa memandang bagaimana bahasa
pemrogramannya.
Walaupun pseudocode tidak ada aturan penulisan syntax, di dalam buku ini akan
diberikan suatu aturan-aturan penulisan syntax yang cukup sederhana agar pembaca
dapat lebih mudah dalam mempelajari algoritma-algoritma yang ada di dalam buku
ini. Pseudocode yang ditulis di dalam buku ini akan menyerupai (meniru) syntax-
syntax dalam bahasa Pascal. Namun dibuat sesederhana mungkin sehingga tidak akan
ada kesulitan bagi pembaca untuk memahami algoritma-algoritma dalam buku ini
walaupun pembaca belum pernah mempelajari bahasa Pascal.
Contoh algoritma menentukan bilangan terbesar dari tiga bilangan yang ditulis
dalam bentuk pseudocode bergaya buku ini.
01| ALGORITMA Menentukan_terbesar_dari_3_bilangan
02| Deklarasi:
03| a,b,c, terbesar : integer
04|
05| Deskripsi:
06| Read(a,b,c)
07| If (a>b) and (a>c) then
08| Terbesar  a
09| Else
10| If b>c then
11| Terbesar  b
12| Else
13| Terbesar  c
14| Endif
15| Endif
16| Write(terbesar)


4
C. Flow Chart (Diagram Alir)
1. Pengertian
Diagram alir atau flow chart adalah suatu bagan yang menggambarkan arus logika
dari data yang akan diproses dalam suatu program dari awal sampai akhir. Diagram
alir terdiri dari simbol-simbol yang mewakili fungsi-fungsi langkah program dan garis
alir (flow lines) menunjukkan urutan dari simbol-simbol yang akan dikerjakan.
2. Simbol-simbol Flow Chart
Simbol terminal (terminator)

digunakan untuk menunjukkan awal dan akhir algoritma


Simbol persiapan (preparation)

digunakan untuk memberikan nilai awal suatu variabel atau suatu
counter

Simbol proses (process)

digunakan untuk proses perhitungan aritmatika atau proses
pemindahan data


Simbol Data (data)

digunakan untuk menunjukkan proses input maupun output
data.


Simbol Keputusan (decision)

digunakan untuk pengambilan keputusan dua jalur atau lebih
dalam flow chart.

Simbol Penghubung (on-page reference)

digunakan untuk menunjukkan hubungan arus flow chart yang terputus,
tetapi masih dalam halaman yang sama.

Simbol Penghubung Halaman Lain (off-page reference)

digunakan untuk menunjukkan hubungan arus flow chart yang terputus
yang berada di halaman lain.


5
3. Bentuk-bentuk Dasar Struktur Logika Flow Chart
Runtunan (Sequence Structure)

Pemilihan/Percabangan IF (Selection Structure)
TRUE FALSE


Pengulangan FOR (FOR Loop Structure)

6
Pengulangan WHILE-DO
(WHILE-DO Structure)
TRUE
FALSE

Pengulangan REPEAT-UNTIL
(REPEAT-UNTIL Structure)
TRUE
FALSE





7
BAB II : DASAR-DASAR ALGORITMA
A. Strukt ur Penul isan Algoritma
Mulai dari bab ini dan seterusnya, penulisan algoritma hendaknya menggunakan
format pseudocode agar nantinya mudah diterjemahkan ke dalam bahasa
pemrograman Pascal dalam mata kuliah Pemrograman pada semester berikutnya.
Penulisan algoritma dalam format pseudocode ini mengikuti aturan-aturan yang
dipakai dalam buku tulisan Rinaldi Munir yang berjudul “Algoritma dan
Pemrograman”. Dalam buku tersebut, struktur penulisan algoritma dibagi menjadi 3
bagian yaitu bagian kepala, bagian deklarasi, dan bagian deskripsi. Struktur
lengkapnya dapat dilihat di bawah ini.
01| Algoritma NAMA_ALGORITMA
02| {Penjelasan tentang algoritma, yang berisi uraian singkat mengenai
apa yang dilakukan oleh algoritma}
03| DEKLARASI
04| {semua nama yang dipakai, meliputi nama tipe, nama tetapan, nama
variabel, nama prosedur, dan nama fungsi didefinisikan di sini}
05|
06| DESKRIPSI:
07| {semua langkah/aksi algoritma dituliskan di sini}
1. Kepala Algoritma
Kepala algoritma adalah bagian yang terdiri dari nama algoritma dan penjelasan
algoritma. Aturan pemberian nama algoritma mengacu pada aturan pemberian nama
pengenal yang akan dibahas pada bagian berikutnya.
Nama algoritma hendaknya singkat, namun mencerminkan isi algoritma secara
keseluruhan. Bagian penjelasan algoritma berisi penjelasan mengenai hal-hal yang
dilakukan oleh algoritma secara singkat. Contoh kepala algoritma dapat dilihat di
bawah ini.
01| Algoritma LUAS_SEGITIGA
02| {Menghitung luas segitiga berdasarkan panjang alas dan tinggi
segitiga yang diinput user. Luas segitiga dapat diperoleh dari
rumus Luas = 0,5 x alas x tinggi}

01| Algoritma Menentukan_Bilangan_Prima
02| {Menentukan apakah suatu bilangan bulat yang diinputkan oleh user
merupakan bilangan prima atau komposit. Algoritma akan mencetak
kata “prima” apabila bilangan tersebut adalah bilangan prima, dan
sebaliknya akan mencetak kata “komposit” bila bilangan tersebut
bukan bilangan prima}

8
2. Deklarasi
Bagian deklarasi berisikan semua nama pengenal yang dipakai di dalam
algoritma. Nama tersebut dapat berupa nama tetapan (konstanta), nama peubah
(variabel), nama tipe, nama prosedur, dan nama fungsi. Contohnya dapat dilihat di
bawah ini.
01| DEKLARASI
02| {nama tetapan}
03| const Npeg = 100 {jumlah pegawai}
04| const phi = 3.14 {nilai phi}
05| {nama tipe}
06| type TTitik : record {tipe koordinat bidang kartesius}
07| < x,
08| y : integer
09| >
10| {nama peubah}
11| c : char {karakter yang dibaca}
12| Q : TTitik {titik dalam koordinat kartesius}
13| ketemu : boolean {keadaan hasil pencarian}
14|
15| function IsPrima(input x:integer)  boolean
16| {mengembalikan nilai true bila x adalah prima, atau false bila x
adalah komposit}
17|
18| procedure Tukar(input/output a,b : integer)
19| {mempertukarkan isi variabel a dan b}
3. Deskripsi
Bagian deskripsi merupakan inti dari algoritma. Bagian ini berisi uraian langkah-
langkah penyelesaian masalah. Langkah-langkah ini dituliskan dengan notasi-notasi
yang akan dijelaskan pada bab-bab selanjutnya.

B. Komentar (Comment) Algoritma
Penulisan algoritma yang baik selalu disertai pemberian komentar. Komentar
merupakan suatu penjelasan mengenai suatu hal yang tertulis dalam algoritma dan
komentar bukanlah merupakan bagian dari langkah-langkah penyelesaian suatu
algoritma.
Komentar ditulis di antara tanda baca kurung kurawal buka dan kurung
kurawal tutup. “ { } “. Pada bagian kepala algoritma, penjelasan algoritma
merupakan suatu komentar. Contoh lainnya dapat Anda lihat dalam contoh bagian
deklarasi di atas. Pemberian komentar bukanlah suatu keharusan, namun algoritma

9
yang disertai komentar-komentar yang tepat akan memudahkan pembaca lainnya
untuk mengerti algoritma yang Anda buat.
C. Penamaan/ Pengenal (Ident ifier)
Dalam algoritma, ada beberapa hal yang harus diberi nama atau pengenal. Hal-hal
tersebut meliputi: nama algoritma, nama tetapan (konstanta), nama peubah (variabel),
nama tipe, nama prosedur, dan nama fungsi.

Pemberian nama harus mengikuti aturan-aturan sebagai berikut:
1. hanya boleh terdiri dari huruf, angka, atau garis bawah
2. tidak boleh dimulai dengan angka
3. tidak membedakan huruf kapital maupun huruf kecil (non case-sensitive)
4. panjang tidak dibatasi
5. harus unik, artinya tidak boleh ada nama pengenal yang sama untuk hal yang
berbeda
6. hendaknya mencerminkan kegunaannya

Pemberian nama pengenal ini biasanya mengikuti salah satu dari 2 gaya berikut:
1. pemisah antar-kata menggunakan tanda garis bawah.
Contoh: Luas_Segitiga
2. pemisah antar-kata menggunakan huruf kapital
Contoh: LuasSegitiga

Beberapa contoh penamaan yang valid maupun tidak valid:
01| Nama_4_Pegawai {valid}
02| 2_luas {salah, karena diawali angka}
03| ^LuasSegitiga {salah, karena terdapat tanda ^}
04| Luas_Segitiga_&_Lingk {salah, karena terdapat tanda &}
05| Hati2 {valid}
D. Tipe Data
Dalam dunia pemrograman komputer selalu melibatkan data, karena
pemrograman tidak bisa terlepas dari kegiatan mengolah data menjadi informasi yang
diperlukan. Untuk menjamin konsistensi data dan efisiensi penggunaan memori
komputer, maka data dibedakan menjadi beberapa tipe.
Dalam algoritma, tipe data yang ada lebih sedikit dibanding bahasa pemrograman
dikarenakan algoritma hanya menekankan pada penyelesaian masalah. Beberapa tipe
data tersebut adalah:
1. Integer
Merupakan tipe data bilangan bulat, baik yang negatif, nol, maupun bilangan
positif. Dalam algoritma, semua bilangan bulat termasuk dalam tipe ini, tanpa ada
batasan.

10
2. Real
Merupakan tipe data bilangan pecahan. Semua bilangan yang mengandung tanda
desimal tergolong dalam tipe ini. Tanda desimal yang dipakai adalah tanda titik, bukan
tanda koma. Sebagai contohnya, nilai 0,5 (nol koma lima) ditulis menjadi 0.5. Tipe ini
juga mendukung penulisan dalam bentuk ilmiah, misalnya 2.64E-2 artinya 2.64 x 10
-2
.
3. Char
Merupakan tipe data karakter. Semua data yang hanya terdiri dari 1 karakter
tergolong dalam tipe ini. Misalnya data jenis kelamin yang hanya diisikan huruf L atau
P. Penulisan data tipe char harus diapit oleh tanda petik tunggal. Karakter-karakter
yang diperbolehkan terdefinisi dalam tabel ASCII.
4. String
Merupakan tipe data kalimat. Semua data yang terdiri dari 1 karakter atau lebih
dapat digolongkan ke dalam tipe ini. Syaratnya sama dengan tipe char, yaitu harus
diapit oleh tanda petik tunggal.
5. Boolean
Merupakan tipe data yang hanya mempunyai nilai TRUE atau FALSE. Penulisan
TRUE ataupun FALSE tidak membedakan huruf kapital ataupun non-kapital. Hanya
saja penulisannya tidak boleh disingkat menjadi huruf T atau huruf F saja.

Berikut ini merupakan tabel contoh-contoh data berbagai tipe.
Nama Tipe Nilai yang diizinkan
Integer
8
-74
0
Real
7.5
3E2
3.2E-4
0.0
0.5
Char
„a‟
„!‟
„3‟
„,‟
„?‟
„‟‟‟ {yaitu 1 buah karakter tanda petik tunggal}
String
„mahasiswa‟
„a‟
„7483‟
„?w?‟
„.....‟
„pergi!‟
„i‟‟l love you 4ever‟


11
Boolean
True
tRuE
FALse
False
E. Vari abel
Variabel merupakan sesuatu yang digunakan sebagai tempat penyimpanan nilai
dalam memori yang isinya dapat diubah.
Contoh:
01| k,l : integer
02| c : char
03| kalimat : string
04| nilai1, nilai2, rata2 : real
F. Konstanta
Konstanta merupakan suatu nilai yang telah ditetapkan di awal pembuatan
algoritma dan nilainya tidak dapat diubah oleh proses dalam algoritma. Cara
mendefinisikan konstanta adalah dengan menambahkan kata kunci const diawal nama
konstanta dan diletakkan di bagian deklarasi.
Contoh:
01| Deklarasi:
02| const phi = 3.14
03| const k = 0.5
04| const password = „SeCReT‟
G. Ekspresi
Ekspresi adalah serangkaian perhitungan nilai yang menghasilkan suatu nilai yang
diinginkan. Ekspresi terdiri dari operand dan operator. Operand adalah nilai-nilai
yang akan dihitung. Operator adalah lambang operasi yang dipakai dalam perhitungan.
Contoh: 6 + 3, angka 6 dan 3 adalah operand, sedangkan tanda + merupakan operator.
Operand dapat berupa tetapan (konstanta), peubah (variabel), atau hasil dari suatu
fungsi. Operator dapat berupa operator unary, yaitu operator yang hanya memerlukan
1 operand, dan operator binary, yaitu operator yang memerlukan 2 operand.
Beberapa jenis operator yang dipakai dalam algoritma adalah:
1. operator aritmatika
Lambang
Operator
Jenis Tipe Operand1 Tipe Operand2 Tipe Hasil
+, – unary
Integer
Real

Integer
Real

12
+, –, * Binary
Integer
Integer
Real
Real
Integer
Real
Integer
Real
Integer
Real
Real
Real
Div Binary integer integer integer
/ Binary
Integer
Integer
Real
Real
Integer
Real
Integer
Real
Real
Real
Real
Real
Mod Binary Integer Integer integer
2. operator perbandingan
Lambang
Operator
Jenis Tipe Operand1 Tipe Operand2 Tipe Hasil
<
<=
>
>=
=
<>
Binary
Binary
Binary
Binary
Binary
Binary
Binary
Integer
Integer
Real
Char
Char
String
Boolean
Integer
Real
Real
Char
String
String
Boolean
Boolean
Boolean
Boolean
Boolean
Boolean
Boolean
Boolean

Keterangan:
1. perbandingan char mengacu pada urutan karakter dalam tabel ASCII.
Contoh: „a‟ > „A‟ akan menghasilkan true
2. perbandingan string, dibandingkan per karakter yang berkesesuaian mulai dari
karakter pertama.
Contoh: „abc‟ > „aBc‟ akan menghasilkan true.
3. perbandingan boolean, false diidentikkan dengan angka 0, sedangkan true
diidentikkan dengan angka 1. Jadi true > false akan menghasilkan true.
3. operator string
Yaitu lambang + yang merupakan operasi penyambungan (concatenation)
Contoh: „anak‟ + „ku‟ akan menghasilkan „anakku‟
4. Logika
Lambang
Operator
Jenis Tipe Operand1 Tipe Operand2 Tipe Hasil
not Unary Boolean Boolean
and, or, xor Binary Boolean Boolean Boolean


13
a not a
True
False
False
True

a b a and b a or b a xor b
true
true
false
false
true
false
true
false
true
false
false
false
true
true
true
false
false
true
true
false
5. Tingkatan-tingkatan dalam operator
Precedence operator Keterangan
First (High) NOT + – Unary operator
Second
* / div mod Perkalian dan pembagian
AND Boolean
Third
+ – Penjumlahan
OR XOR Boolean
Fourth (Low)
= <> < >
>= <=
Relasional

H. Penugasan (Assigment)
Penugasan atau Assignment merupakan pemberian nilai ke variabel secara
langsung. Notasi yang digunakan adalah  . Nilai yang dapat diberikan adalah
tetapan, peubah, ekspresi, maupun nilai yang dihasilkan oleh fungsi. Syarat
penugasan adalah nilai yang diberikan harus sesuai dengan tipe variabel.
Apabila tipenya tidak sama, maka berlaku tipe yang lebih luas dapat menampung
tipe yang lebih sempit. Tipe integer dapat ditampung oleh tipe real, sebaliknya tipe
real tidak dapat ditampung oleh tipe integer. Begitu pula dengan string dan char,
char dapat diberikan ke string, namun tidak sebaliknya.

14
Contohnya:
01| Deklarasi:
02| a,b : integer
03| c,d : real
04| nama1, nama2 : string
05| huruf : char
06| ketemu : boolean
07|
08| Deskripsi:
09| a  3 {boleh}
10| b  a + 4 {boleh}
11| c  3 {boleh}
12| a  0.5 {tidak boleh karena a tidak dapat menampung real}
13| a  b + c {tidak boleh karena b+c bertipe real}
14| huruf  „?‟ {boleh}
15| nama1  „Ani‟  {boleh}
16| nama2  nama1 + huruf {boleh}
17| nama1  „a‟ {boleh}
18| huruf  nama1 {tidak boleh karena nama1 bertipe string}
19| ketemu  true {boleh}
20| ketemu  „true‟ {tidak boleh karena „true‟ bertipe string}
I. Input dan Output
Menurut Donald E. Knuth (1973, p4-6), algoritma memiliki 5 ciri pokok, yaitu:
1. Finiteness
Algoritma harus selalu berakhir setelah melakukan sejumlah langkah berhingga.
2. Definiteness
Setiap langkah dari suatu algoritma harus terdefinisi secara tepat (logis).
3. Input
Suatu algoritma dapat tidak memiliki input, ataupun memiliki satu atau lebih dari
satu input.
4. Output
Suatu algoritma harus memiliki paling sedikit satu output.
5. Effectiveness
Algoritma yang dibuat diharapkan efektif, artinya setiap langkah yang hendak
dilaksanakan dalam algoritma haruslah sederhana sehingga dapat secara prinsip
dilakukan dengan tepat dan dalam waktu yang masuk akal apabila dilakukan
secara manual oleh manusia dengan menggunakan pensil dan kertas.


15
1. Input
Input artinya meminta data yang diperlukan dari user. Sebagai contoh, dalam
menghitung luas persegi panjang, tentu diperlukan data berupa besarnya panjang dan
lebar bangun persegi panjang tersebut. Dengan kata lain, algoritma menentukan luas
persegi panjang mempunyai 2 input berupa panjang dan lebar persegi panjang.
Algoritma di buku ini menggunakan kata kunci read untuk menginput data.
Bentuk penulisannya adalah
Read(variabel1, variabel2, ..., variabeln)
Data yang dapat diinputkan hanyalah data berupa integer, real, char, atau string.
Sedangkan data boolean tidak dapat diinputkan menggunakan read. Dalam
algoritma, kita tidak perlu memikirkan dari peralatan mana user menginput data,
apakah dari mouse, keyboard, scanner, dan lain sebagainya. Hal itu merupakan
masalah pemrograman. Pembuat algoritma juga tidak perlu memikirkan masalah
tampilan saat penginputan berlangsung.
Contohnya adalah
01| Algoritma ContohPenginputan
02| {contoh penggunaan read untuk menginput sejumlah data dari user}
03| Deklarasi:
04| a,b,c : integer
05| d : real
06| e : char
07| f : string
08| g : boolean
09| Deskripsi
10| {menginput data bil bulat, kemudian dimasukkan ke variabel a}
11| Read(a)
12| {menginput 2 data integer, dimasukkan ke variabel b dan c}
13| read(b,c)
14| {menginput data pecahan, kemudian dimasukkan ke variabel d}
15| read(d)
16| {menginput data bulat dan pecahan}
17| read(a,d)
18| {menginput data bulat, pecahan, dan 1 karakter}
19| read(a,d,e)
20| {menginput data string}
21| read(f)
22| {berikut ini adalah suatu kesalahan}
23| read(g) {data boolean tidak dapat diinputkan}

16
2. Output
Output artinya mencetak informasi yang dihasilkan oleh algoritma. Sebagai
contoh dalam algoritma menghitung luas persegi panjang, hasil akhir yang diinginkan
adalah luas persegi panjang. Dengan kata lain, algoritma tersebut memiliki satu output
yaitu luas persegi panjang.
Algoritma dalam buku ini menggunakan kata kunci write untuk mencetak suatu
data. Bentuk penulisannya adalah
write(data1, data2, ..., datan)
dimana data dapat berupa suatu data konstan, nama konstanta, ekspresi, maupun
suatu variabel.
Dalam algoritma, kita tidak mempermasalahkan ke peralatan mana data tersebut
akan dicetak, karena merupakan masalah pemrograman. Kita juga tidak
mempermasalahkan dalam format bagaimana data tersebut dicetak.
Contoh:
01| Algoritma ContohPengoutputan
02| {berisi contoh-contoh penggunaan write untuk mencetak data}
03| deklarasi:
04| const k = 0.5
05| a : integer
06| b : real
07| c : char
08| d : string
09| e : boolean
10| deskripsi
11| read(a) {menginput sebuah data integer}
12| write(a) {mencetak data hasil input tadi}
13| write(b) {tidak boleh, karena variabel b belum ada isinya}
14| c  „y‟
15| d  „stmik‟
16| write(c,d) {mencetak isi variabel c dan d}
17| write(„Susi kuliah di „,d) {mencetak Susi kuliah di stmik}
18| write(5 + 6) {mencetak bilangan 11, yaitu hasil dari 5+6}
19| e  2 = 1 + 3
20| write(e) {mencetak FALSE karena e berisikan false}
21| write(k) {mencetak 0.5 karena k berisi 0.5}

17
BAB III : RUNTUNAN
A. Pengertian
Runtunan merupakan struktur algoritma yang mempunyai ciri-ciri sebagai
berikut:
1. tiap instruksi dikerjakan satu per satu
2. tiap instruksi dikerjakan tepat hanya sekali, dengan kata lain tidak ada instruksi
yang diulang
3. instruksi dikerjakan berurutan mulai dari instruksi pertama hingga instruksi
terakhir
4. akhir dari instruksi terakhir merupakan akhir algoritma.

Dalam algoritma, urutan instruksi adalah penting. Hal ini dapat dilihat dalam
contoh berikut ini.
01| Algoritma Contoh_Runtunan_1
02| Deklarasi:
03| a, b : integer
04| Deskripsi
05| a  10
06| a  2*a
07| b  a
08| write(b) {mencetak nilai 20}

01| Algoritma Contoh_Runtunan_2
02| Deklarasi:
03| a, b : integer
04| Deskripsi
05| a  10
06| b  a
07| a  2*a
08| write(b) {mencetak nilai 10}
Dalam contoh di atas, instruksi ke-2 dan ke-3 dipertukarkan, ternyata
menghasilkan output atau keluaran yang berbeda. Hal ini menunjukkan bahwa urutan
instruksi merupakan hal yang sangat penting karena sangat mempengaruhi hasil
output.

18
B. Contoh-contoh
1. Algoritma Luas Segitiga ()
Buatlah algoritma untuk menghitung luas segitiga jika diketahui panjang alas dan
tinggi segitiga.
Analisis:
input : alas (a) dan tinggi (t) segitiga
output : luas (L) segitiga
rumus : L = 0,5 x a x t
Langkah pengerjaan:
1. meminta input data alas dan tinggi segitiga dari user
2. menghitung luas segitiga menggunakan rumus
3. mencetak output berupa luas segitiga
01| Algoritma Menghitung_Luas_Segitiga
02| {Menghitung luas segitiga jika diketahui panjang alas dan tinggi
segitiga. Alas dan tinggi diinput dari user. Kemudian Luas
dihitung menggunakan rumus Luas = 0,5 x alas x tinggi. Kemudian
mencetak output berupa luas segitiga}
03| Deklarasi:
04| a, t, L : real
05| Deskripsi
06| read(a,t)
07| L  0.5 * a * t
08| write(L)
2. Algoritma Komisi Salesman ()
Buatlah algoritma untuk menghitung komisi yang diterima salesman berdasarkan
jumlah penjualan yang dicapainya. Salesman tersebut mendapat komisi 10% dari hasil
penjualannya. Input algoritma ini adalah nama salesman dan jumlah penjualan yang
dicapainya. Sedangkan outputnya adalah nama salesman dan besar komisi yang
diperolehnya.
Analisis:
input: nama salesman (nama) dan jumlah penjualan (j)
output: nama salesman (nama) dan besar komisi (komisi)
rumus: komisi = 10% x jumlah penjualan
Langkah pengerjaan:
1. menginput data nama salesman dan jumlah penjualan
2. menghitung komisi menggunakan rumus
3. mencetak nama dan komisi

19
01| Algoritma Menghitung_Komisi_Salesman
02| {Menghitung besarnya komisi yang diperoleh salesman berdasarkan
jumlah penjualan. Besarnya komisi adalah 10% dari jumlah penjualan
yang dicapainya. Kemudian algorima akan mencetak nama salesman dan
komisi sebagai outputnya.}
03| Deklarasi:
04| nama : string {nama salesman}
05| j : integer {jumlah penjualan}
06| komisi : real {komisi yang diperoleh}
07| Deskripsi
08| read(nama, j)
09| komisi  0.1 * j
10| write(nama, komisi)
3. Algoritma Gaji Karyawan ()
Buatlah algoritma untuk menghitung gaji karyawan. Diberikan nama karyawan
dan besarnya gaji pokok. Gaji bersih yang diterima pegawai adalah gaji pokok
ditambah besarnya tunjangan kemudian dikurangi pajak. Tunjangan karyawan
dihitung 20% dari gaji pokok, sedangkan pajak adalah 15% dari gaji pokok ditambah
tunjangan. Keluaran yang diharapkan adalah nama karyawan, besarnya tunjangan,
pajak, dan gaji bersihnya.
Analisis:
input: nama karyawan (nama) dan besarnya gaji pokok (gaji_pokok)
output: nama karyawan (nama), tunjangan (tunj), pajak (pjk), dan gaji bersih
(gaji_bersih)
rumus: tunj = 20% x gaji_pokok
pjk = 15% x (gaji_pokok + tunj)
gaji_bersih = gaji_pokok + tunj – pajak
Langkah pengerjaan:
1. menginput nama karyawan dan gaji pokok
2. menghitung tunjangan
3. menghitung pajak
4. menghitung gaji bersih
5. mencetak nama, tunjangan, pajak, dan gaji bersih
01| Algoritma Menghitung_Gaji_Karyawan
02| {Diberikan nama karyawan dan gaji pokok. Kemudian menghitung
tunjangan, pajak, dan gaji bersih berdasarkan gaji pokok.
Tunjangan adalah 20% dari gaji pokok. Pajak adalah 15% dari gaji
pokok ditambah tunjangan. Gaji bersih adalah gaji pokok ditambah
tunjangan dikurangi pajak. Keluaran yang diharapkan adalah nama
karyawan, tunjangan, pajak, dan gaji bersih.}

20
03| Deklarasi:
04| nama : string
05| gaji_pokok : integer
06| tunj, pjk, gaji_bersih : real
07| Deskripsi
08| read(nama, gaji_pokok)
09| tunj  0.2 * gaji_pokok
10| pjk  0.15 * (gaji_pokok + tunj)
11| gaji_bersih  gaji_pokok + tunj – pjk
12| write(nama, tunj, pjk, gaji_bersih)
4. Algoritma Konversi Waktu ke Total Detik ()
Buatlah algoritma untuk mengkonversi jam-menit-detik ke total detik. Data jam-
menit-detik diinput dari user. Contoh, misalnya data jam-menit-detiknya adalah 1 jam
30 menit 40 detik, maka besarnya total detik adalah 5440 detik.
Analisis:
input: jam (j), menit (m), detik (d)
output: total detik (total)
Rumus:
ingat bahwa 1 jam = 3600 detik dan 1 menit = 60 detik.
maka total detik = jam x 3600 + menit x 60 + detik
Langkah pengerjaan:
1. menginput jam, menit, dan detik
2. menghitung total detik menggunakan rumus
3. mencetak total detik
01| Algoritma Konversi_Waktu_Ke_Detik
02| {mengkonversi jam-menit-detik ke total detik. Data yang diinput
adalah jam, menit, dan detik. Outputnya adalah total detiknya.}
03| Deklarasi:
04| j, m, d, total : integer
05| Deskripsi
06| read(j,m,d)
07| total  j*3600 + m*60 + d
08| write(total)
5. Algoritma Konversi Total Detik ke Waktu ()
Buatlah algoritma untuk mengkonversi total detik ke bentuk jam-menit-detik.
Data total detik diinput oleh user. Contohnya, misalnya data total detiknya adalah
5440 detik, maka outputnya adalah 1 jam 30 menit 40 detik.

21
Analisis:
input: total detik (total)
output: jam (j), menit (m), detik (d)
rumus:
Pada dasarnya, yang hendak dikerjakan adalah mencari tahu total detik tersebut sama
dengan berapa jam dan berapa sisa detiknya. Dari sisa detik tersebut, barulah dicari
berapa menit dan sisa berapa detik.
Contohnya:
misalkan total detiknya adalah 5440 detik.
Maka 5440 detik dibagi 3600 adalah 1 jam sisa 1840 detik.
Kemudian, 1840 detik dibagi 60 adalah 30 menit sisa 40 detik.
Jadi 5440 detik = 1 jam 30 menit 40 detik.
Dari contoh di atas dapat disimpulkan rumus-rumus berikut:
jam = total div 3600
sisa = total mod 3600
menit = sisa div 60
detik = sisa mod 60
Langkah pengerjaan:
1. menginput total detik
2. menghitung jam dari total detik
3. menghitung sisa pembagian jam dari total detik
4. menghitung menit dari sisa
5. menghitung detik dari sisa
6. mencetak jam, menit, dan detik
01| Algoritma Konversi_Total_Detik_ke_Waktu
02| {Diberikan suatu total detik. Hendak dicari berapa jam, menit, dan
detiknya.}
03| Deklarasi:
04| j,m,d, sisa, total : integer
05| Deskripsi
06| read(total)
07| j  total div 3600
08| sisa  total mod 3600
09| m  sisa div 60
10| d  sisa mod 60
11| write(j,m,d)
6. Algoritma Pembulatan Seratusan ()
Buatlah algoritma untuk membulatkan suatu data harga ke dalam ratusan. Data
harus dibulatkan ke atas. Misalnya harga suatu barang adalah 8374 rupiah. Maka
harga dibulatkan menjadi 8400 rupiah.

22
Analisis:
input: data harga (harga)
output: hasil pembulatan (hasil)
Caranya:
1. Ambil dua angka terakhirnya dengan cara di mod dengan 100. Dalam kasus di
atas, 8374 mod 100 = 74.
2. Kemudian hitunglah 100 dikurangi 2 angka terakhir tersebut. Dalam kasus di atas,
100 – 74 = 26.
3. Hasil pembulatannya adalah harga ditambah hasil langkah ke-2. Dalam kasus di
atas, hasil pembulatan dari 8374 adalah 8374 + 26 = 8400.
01| Algoritma Pembulatan_Ratusan
02| {menginput suatu harga barang. Kemudian harga barang tersebut akan
dibulatkan dalam ratusan ke atas.}
03| Deklarasi:
04| harga, hasil : integer
05| Deskripsi
06| read(harga)
07| hasil  100 - harga mod 100 + harga
08| write(hasil)
Algoritma di atas mempunyai kelemahan, yaitu akan menghasilkan output yang
salah apabila nilai dari harga dalam kelipatan 100. Terdapat cara lain dalam
melakukan pembulatan ratusan. Hal ini dituliskan dalam algoritma berikut ini.
01| Algoritma Pembulatan_Ratusan_2
02| {menginput suatu harga barang. Kemudian harga barang tersebut akan
dibulatkan dalam ratusan ke atas.}
03| Deklarasi:
04| Harga, hasil : integer
05| Deskripsi
06| Read(harga)
07| Hasil  (harga + 99) div 100 * 100
08| Write(hasil)
7. Algoritma Pertukaran Data ()
Buatlah algoritma yang saling menukarkan isi dari 2 variabel. Tipe variabel
dianggap bertipe real.
Analisis:
Langkah pertama tentu saja adalah meminta input dua data real ke variabel tersebut.
Misalkan nama variabelnya adalah data1 dan data2. Data1 tidak boleh langsung
dipindahkan ke data2, demikian juga sebaliknya. Misalnya langsung diberi pernyataan
data2  data1, maka informasi yang terdapat di data2 akan hilang. Oleh karena itu,
sebelumnya, informasi dari data2 harus dipindahkan terlebih dahulu ke suatu
variabel sementara, misalnya diberi nama temp. Selanjutnya informasi di data1

23
dapat dipindah ke variabel data2 Kemudian informasi data2 yang tersimpan di variabel
temp dapat dipindahkan ke variabel data1.
Untuk lebih jelasnya, perhatikan ilustrasi berikut:



01| Algoritma Pertukaran_Data
02| {menukar isi dari 2 variabel bertipe real}
03| Deklarasi:
04| data1, data2, temp : real
05| Deskripsi
06| read(data1,data2)
07| temp  data2
08| data2  data1
09| data1  temp
10| write(data1,data2)
8. Algoritma Menghitung Selisih Waktu ()
Diberikan dua buah data waktu dalam bentuk jam-menit-detik. Buatlah algoritma
untuk menghitung selisihnya dan ditampilkan dalam bentuk jam-menit-detik. Asumsi
waktu pertama adalah waktu awal, dan waktu kedua adalah waktu akhir. Selisih
adalah waktu kedua dikurangi waktu pertama.
analisis:
input: waktu1: jam (j1), menit (m1), detik (d1)
waktu2: jam (j2), menit (m2), detik (d2)
output: waktu3: jam (j3), menit (m3), detik (d3)

24
Cara pengerjaan:
1. ubah waktu1 menjadi total detik (total1)
2. ubah waktu2 menjadi total detik (total2)
3. cari selisih total detik (total3), yaitu total3 = total2 – total1
4. ubah total3 menjadi dalam bentuk jam (j3), menit (m3), dan detik (d3)
5. cetak j3, m3, dan d3
01| Algoritma Menghitung_Selisih_waktu
02| {Diberikan waktu awal dan waktu akhir dalam bentuk jam-menit-
detik. Kemudian mencari selisih waktunya dalam bentuk jam-menit-
detik}
03| Deklarasi:
04| j1, m1, d1,
05| j2, m2, d2,
06| j3, m3, d3,
07| total1, total2, total3, sisa : integer
08| Deskripsi
09| read(j1,m1,d1) {menginput waktu awal}
10| read(j2,m2,d2) {menginput waktu akhir}
11|
12| {mengubah waktu awal ke total detik}
13| total1  3600*j1 + 60*m1 + d1
14|
15| {mengubah waktu akhir ke total detik}
16| total2  3600*j2 + 60*m2 + d2
17| {mencari selisih total waktu}
18| total3  total2 – total1
19| {mengubah total3 menjadi bentuk jam-menit-detik}
20| j3  total3 div 3600
21| sisa  total3 mod 3600
22| m3  sisa div 60
23| d3  sisa mod 60
24| {mencetak hasilnya}
25| write(j3,m3,d3)

25
C. Latihan
1. Buatlah algoritma untuk menghitung luas dan keliling lingkaran berdasarkan jari-
jarinya.
2. Buatlah algoritma yang mengkonversi suhu dalam fahrenheit ke derajat celsius.
3. Buatlah algoritma menghitung jumlah uang yang harus dibayarkan pembeli
berdasarkan beratnya buah jeruk yang dibeli. Diketahui bahwa harga barang per kg
adalah 500 rupiah/100 gram. Diketahui pula pembeli berhak mendapatkan diskon
sebesar 5%. Hasil keluaran yang diinginkan adalah total harga sebelum diskon,
diskon, dan total harga setelah diskon.
4. Buatlah algoritma pembulatan seperti pada algoritma nomor 6. Tetapi pembulatan
yang diinginkan adalah dalam ribuan. Sebagai contoh, apabila harga barang
7.423.525 rupiah, maka dibulatkan menjadi 7.424.000 rupiah.
5. Buatlah algoritma yang meminta input sebuah bilangan bulat, kemudian algoritma
akan memberikan keluaran (output) berupa angka satuan, puluhan, dan ratusannya.
Contoh, apabila diinputkan bilangan 1.234.567 (1 juta 234 ribu 567), maka
algoritma akan menghasilkan output bilangan 7 satuan, 6 puluhan, dan 5 ratusan.
Apabila diinputkan bilangan 73 (tujuh puluh tiga) maka algoritma akan
menghasilkan output bilangan 3 satuan, 7 puluhan, dan 0 ratusan.


26
BAB IV : PEMILIHAN
A. Pengertian
Dalam bab runtunan, setiap baris proses dalam algoritma akan selalu dikerjakan.
Namun, ada saat dimana kita menginginkan satu atau beberapa proses dalam algoritma
tersebut hanya dikerjakan apabila memenuhi syarat atau kondisi tertentu.
Dalam algoritma, kita dapat menggunakan struktur percabangan IF. Bentuk
penulisan struktur IF adalah
IF kondisi THEN
proses_1
...
proses_n
END IF
atau
IF kondisi THEN
proses_1
...
proses_n
ELSE
proses_a
...
proses_x
END IF
Kondisi dalam struktur IF di atas adalah suatu nilai boolean yang dapat bernilai
TRUE atau bernilai FALSE. Kondisi dalam hal ini dapat berupa suatu ekspresi yang
menghasilkan nilai boolean (ekspresi boolean) atau juga dapat berupa suatu
variabel yang bertipe boolean.
Dalam struktur IF di atas, proses_1 hingga proses_n hanya akan dikerjakan
apabila kondisi bernilai TRUE. Sedangkan proses_a hingga proses_x hanya akan
dikerjakan apabila kondisi bernilai FALSE.
Hal yang perlu diperhatikan dalam struktur IF adalah bahwa struktur IF tidak
harus memiliki bagian ELSE. Bagian ELSE digunakan apabila ada proses yang
hendak dikerjakan untuk kondisi bernilai FALSE.
Perhatikan pula bahwa proses ditulis sedikit menjorok ke dalam. Hal ini disebut
dengan indent. Indent sangat diperlukan untuk memudahkan dalam pembacaan suatu
algoritma. Mulai saat ini, perhatikan setiap indent yang terdapat pada contoh algoritma
dalam buku ini.

27
B. Pemilihan 1 Kasus
1. Pendahuluan
Dalam algoritma, terkadang suatu proses hanya dikerjakan bila memenuhi kondisi
tertentu, misalnya mencetak pesan kesalahan bila terjadi kesalahan input dari user.
Tentu saja bila user tidak melakukan kesalahan input, maka pesan kesalahan tersebut
tidak boleh tercetak.
Contoh lainnya adalah pemberian diskon belanja untuk pembeli yang membeli
dengan jumlah harga minimal tertentu. Tentu saja bila pembeli tidak mencapai jumlah
pembelian minimum yang telah ditentukan, maka pembeli tidak akan diberikan
diskon. Contoh-contoh ini adalah contoh-contoh algoritma untuk satu kasus, yaitu
kasus suatu proses hendak dikerjakan atau tidak dikerjakan.
2. Algoritma Pengecekan Negatif ()
Buatlah algoritma untuk mencetak kata “negatif” apabila user menginputkan
suatu bilangan negatif.
Analisis:
Suatu bilangan dikatakan negatif apabila bilangan tersebut kurang daripada nol.
Langkah pengerjaan:
1. Input suatu bilangan, misalkan n
2. Cek kondisi n<0. Apabila bernilai true, cetaklah kata “negatif”.
01| Algoritma Pengecekan_Negatif
02| {Diinput suatu bilangan, apabila negatif, maka cetaklah kata
“negatif”}
03| Deklarasi:
04| n : real
05| Deskripsi
06| Read(n)
07| If n<0 then
08| write(„negatif‟)
09| end if
3. Algoritma Pemberian Diskon ()
Sebuah toko yang sedang melakukan promosi memberikan diskon sebesar 10%
untuk pembeli yang melakukan transaksi minimal Rp100.000,00. Buatlah algoritma
untuk menampilkan diskon dan total yang harus dibayar pembeli.
Analisis:
input: Total belanja pembeli (belanja)
output: besarnya diskon (diskon) dan total pembayaran (total)
Langkah pengerjaan:
1. input total belanja pembeli
2. cek kondisi belanja ≥ Rp100.000,00. Apabila bernilai true maka menghitung
diskon dengan rumus diskon = 10% x belanja.

28
3. Hitung total pembayaran dengan rumus total = belanja – diskon
4. Cetak nilai diskon dan total pembayaran.
01| Algoritma Pemberian_Diskon
02| {Diinput total belanja pembelian. Diskon sebesar 10% diberikan
dengan syarat total belanja minimal Rp100.000,-. Algoritma
memberikan output besarnya diskon yang diperoleh dan total yang
harus dibayarkan pembeli.}
03| Deklarasi:
04| belanja : integer
05| diskon, total : real
06| Deskripsi
07| read(belanja)
08| if belanja >= 100000 then
09| diskon  0.1 * belanja
10| end if
11| total  belanja – diskon
12| write(diskon, total)
Dalam algoritma di atas, baris ke-09 hanya akan dikerjakan apabila memenuhi
kondisi belanja ≥ 100000. Akibatnya, apabila kondisi belanja ≥ 100000 bernilai
FALSE, maka perhitungan baris ke-11 adalah ilegal karena variabel diskon belum
diberi nilai. Maka variabel diskon sebelumnya haruslah diberi nilai awal (inisialisasi).
Algoritma yang lengkap dapat dilihat di bawah ini.
01| Algoritma Pemberian_Diskon
02| {Diinput total belanja pembelian. Diskon sebesar 10% diberikan
dengan syarat total belanja minimal Rp100.000,-. Algoritma
memberikan output besarnya diskon yang diperoleh dan total yang
harus dibayarkan pembeli.}
03| Deklarasi:
04| belanja : integer
05| diskon, total : real
06| Deskripsi
07| read(belanja)
08| diskon  0 {inisialisasi}
09| if belanja >= 100000 then
10| diskon  0.1 * belanja
11| end if
12| total  belanja – diskon
13| write(diskon, total)

29
C. Pemilihan 2 Kasus
1. Pendahuluan
Kadang terdapat 2 proses yang saling berlawanan, dan tidak boleh dikerjakan
dalam satu saat. Hal inilah yang disebut pemilihan untuk 2 kasus. Proses dipilih
berdasarkan syarat atau kondisi, bila memenuhi maka dikerjakan proses pertama, jika
tidak memenuhi maka dikerjakan proses kedua.
Sebagai contohnya, misalnya dalam menentukan apakah suatu bilangan bulat
yang diinputkan user adalah bilangan genap atau bilangan ganjil. Apabila yang
diinputkan adalah bilangan genap, maka dicetak keterangan yang menyatakan
bilangan genap. Sebaliknya jika bukan bilangan genap, pastilah bilangan tersebut
merupakan bilangan ganjil.
2. Algoritma Ganjil Genap ()
Buatlah algoritma untuk mencetak kata “GENAP” apabila bilangan bulat yang
diinputkan user adalah bilangan genap, dan mencetak kata “GANJIL” apabila bilangan
bulat yang diinputkan user adalah bilangan ganjil.
Analisis:
input: suatu bilangan bulat (n)
Kita tahu bahwa suatu bilangan bulat apabila bukan genap, pastilah merupakan
bilangan ganjil. Jadi, kasus ganjil dan genap merupakan sesuatu yang berlawanan. Hal
ini tergolong ke dalam struktur pemilihan 2 kasus.
Syarat suatu bilangan dikatakan genap adalah bilangan tersebut habis dibagi 2.
Dengan kata lain, bilangan n dibagi dengan 2 bersisa 0. Operator untuk menghitung
sisa hasil bagi adalah MOD. Jadi syarat bahwa n bilangan genap adalah n mod 2 = 0.
01| Algoritma Menentukan_Genap_Ganjil
02| {Mencetak “Genap” bila bilangan yang diinput user adalah genap,
dan “Ganjil” bila ganjil}
03| Deklarasi:
04| n : integer
05| Deskripsi
06| read(n)
07| if n mod 2 = 0 then
08| write(„GENAP‟)
09| else
10| write(„GANJIL‟)
11| end if

Algoritma di atas dapat juga ditulis menjadi
01| Algoritma Menentukan_Genap_Ganjil
02| {Mencetak “Genap” bila bilangan yang diinput user adalah genap,
dan “Ganjil” bila ganjil}

30
03| Deklarasi:
04| n : integer
05| genap : boolean
06| Deskripsi
07| read(n)
08| genap  n mod 2 = 0
09| if genap = TRUE then
10| write(„Genap‟)
11| else
12| write(„Ganjil‟)
13| end if

Perhatikan baris ke-08. Kondisi atau syarat genap ganjilnya bilangan n dapat kita
tampung di dalam suatu variabel bertipe boolean, dalam hal ini kita namakan genap.
Misalnya user menginput bilangan 4. Maka n berisikan bilangan bulat 4. Diperoleh 4
mod 2 = 0 adalah bernilai TRUE. Kemudian nilai TRUE tersebut akan diisikan ke
variabel genap. Selanjutnya dalam baris ke-09, isi variabel genap dibandingkan
dengan nilai boolean TRUE. Karena TRUE = TRUE adalah TRUE, maka algoritma
menghasilkan output “GENAP”.
Perhatikan tabel berikut:
Genap Genap = TRUE Not Genap Genap = FALSE
TRUE TRUE FALSE FALSE
FALSE FALSE TRUE TRUE

Ternyata nilai dari ekspresi Genap = TRUE adalah sama dengan nilai dari
variabel genap. Berdasarkan pengamatan ini, maka baris ke-09 pada algoritma di atas
dapat diganti menjadi if genap then.
...
if genap then
...

Algoritma di atas juga dapat ditulis dari sudut pandang GANJIL, yaitu syaratnya
diganti menjadi genap = FALSE. Maka
...
if genap = FALSE then
write(‘GANJIL’)
else
write(‘GENAP’)
end if


31
dapat diganti menjadi
...
if not genap then
...
3. Algoritma Terbesar dari 2 Bilangan ()
Diinputkan dua buah bilangan bulat dari user. Buatlah algoritma untuk mencetak
bilangan yang terbesar dari dua bilangan tersebut.
Analisis:
Input: 2 bilangan bulat (a dan b)
Apabila a>b, maka yang dicetak adalah a. Apabila a<b, maka yang dicetak adalah b.
Tetapi apabila a = b, maka kita dapat mencetak a atau b. Oleh karena itu, kita dapat
menyimpulkan bahwa kita mencetak a apabila a≥b, dan mencetak b apabila terjadi
sebaliknya.
01| Algoritma Menentukan_Terbesar_dari_2_Bilangan_Bulat
02| {Diinput 2 bilangan bulat. Kemudian mencetak yang terbesar}
03| Deklarasi:
04| a, b, terbesar : integer
05| Deskripsi
06| read(a,b)
07| if a >= b then
08| terbesar  a
09| else
10| terbesar  b
11| end if
12| write(terbesar)
4. Algoritma Menghitung Uang Lembur ()
Karyawan PT “ABC” digaji berdasarkan jumlah jam kerjanya selama satu
minggu. Upah per jam adalah Rp2.000,00. Bila jumlah jam kerja lebih besar dari 48
jam, maka sisanya dianggap sebagai jam lembur. Upah lembur adalah Rp3.000,00.
Buatlah algoritma untuk menampilkan upah normal, uang lembur, dan total upah yang
diterima karyawan.
Analisis:
input: jumlah jam kerja (n)
output: upah normal (upah), uang lembur (lembur), dan total upah (total)
Upah per jam, upah lembur, dan batas jam lembur dapat dijadikan sebagai konstanta.
Kasus ini memberikan kita dua kemungkinan, yaitu apakah karyawan menerima
lembur atau tidak menerima lembur (lembur = 0). Syarat seorang karyawan menerima
lembur adalah apabila n > 48. Uang lembur yang diterima adalah selisih jam kerja
dengan batas jam lembur dikalikan dengan upah lembur. Oleh karena itu, dapat kita
simpulkan bahwa rumus yang dipakai adalah

32
Apabila karyawan tidak mendapat uang lembur, maka
lembur = 0, upah = n x 2000
Apabila karyawan mendapatkan uang lembur, maka
lembur = (n – 48) x 3000, sedangkan upah = 48 x 2000, bukan upah = n x 2000.
01| Algoritma Upah_Karyawan
02| {menentukan upah mingguan karyawan. Upah normal Rp2000,-/jam dan
upah lembur Rp3000,-/jam. Apabila jam kerja karyawan lebih dari
48, maka sisanya dihitung lembur. Algoritma menghasilkan output
jumlah upah normal, jumlah uang lembur, dan total upah yang
diterima karyawan}
03| Deklarasi:
04| const upah_per_jam = 2000
05| const upah_lembur = 3000
06| const batas_lembur = 48
07| n, upah, lembur, total : integer
08| Deskripsi:
09| read(n)
10| if n > 48 then {menerima lembur}
11| upah  batas_lembur * upah_per_jam
12| lembur  (n – batas_lembur)*upah_lembur
13| else {tidak menerima lembur}
14| upah  n * upah_per_jam
15| lembur  0 {penting}
16| end if
17| total  upah + lembur
18| write(upah, lembur, total)
5. Algoritma Tahun Kabisat ()
Tahun kabisat adalah tahun yang memenuhi syarat berikut: (a) kelipatan 4; (b)
bukan kelipatan 100; (c) kelipatan 400. Jadi, perhatikan tabel berikut:
Tahun Kabisat?
1996 Ya
1900 Bukan
2000 Ya
Berdasarkan keterangan di atas, buatlah algoritma untuk menentukan apakah
suatu tahun merupakan tahun kabisat atau bukan.
Analisis:
input: tahun (n)
Perhatikan syarat tahun kabisat bagian (a) dan (b). Dari 2 syarat tersebut dapat kita
simpulkan bahwa syaratnya adalah kelipatan 4 dan bukan kelipatan 100, atau
kelipatan 400. Dengan demikian, maka syaratnya yang lengkap adalah
(n mod 4 = 0) and (n mod 100 <> 0) or (n mod 400 = 0)

33
Percobaan:
Tahun (n) n mod 4 = 0 n mod 100 <> 0 n mod 400 = 0 Hasil
1996 TRUE TRUE FALSE TRUE
1900 TRUE FALSE FALSE FALSE
2000 TRUE FALSE TRUE TRUE
01| Algoritma Menentukan_Kabisat
02| {menentukan kabisat atau tidak dari suatu tahun}
03| Deklarasi:
04| n : integer
05| kabisat : boolean
06| Deskripsi
07| read(n)
08| kabisat  (n mod 4 = 0) and (n mod 100 <> 0) or (n mod 400 = 0)
09| if kabisat then
10| write(„KABISAT‟)
11| else
12| write(„BUKAN KABISAT‟)
13| end if
6. Algoritma Syarat Keanggotaan Suatu Jangkauan/Range ()
Diketahui bahwa himpunan penyelesaian suatu pertidaksamaan adalah
} 3 3 | { s s ÷ = x x HP . Diinputkan suatu bilangan x. Buatlah algoritma untuk mencetak
“Penyelesaian” bila HP x e dan mencetak “Bukan Penyelesaian” bila HP x e .
Analisis:
Persyaratan -3 s x s 3 tidak memenuhi bentuk penulisan eksresi perbandingan yang
benar. Maka persyaratan tersebut harus dipisah menjadi 2 bagian, yaitu x≥-3 dan xs3.
Kedua persyaratan tersebut harus digabung dengan menggunakan operator boolean
AND (Mengapa?). Oleh karena itu, persyaratan keanggotaan x secara lengkap adalah
) 3 ( ) 3 ( s ÷ > x AND x
01| Algoritma Menentukan_Keanggotaan_range
02| {Diinput suatu bilangan x. Algoritma menghasilkan TRUE apabila x
adalah anggota HP = {x | -3 <= x <= 3} dan mencetak FALSE bila
bukan}
03| Deklarasi:
04| x : real
05| syarat : boolean
06| Deskripsi
07| read(x)
08| syarat  (x >= -3) and (x <= 3)
09| if syarat then

34
10| write(„Penyelesaian‟)
11| else
12| write(„Bukan Penyelesaian‟)
13| end if

7. Algoritma Syarat Keanggotaan Diluar Range ()
Diketahui bahwa himpunan penyelesaian suatu pertidaksamaan adalah
} 3 | { } 3 | { ÷ < > = x x x x HP  . Diinputkan suatu bilangan x.
Buatlah algoritma untuk mencetak “Penyelesaian” bila HP x e dan mencetak
“Bukan Penyelesaian” bila HP x e .
Analisis:
Perhatikan bahwa himpunan HP merupakan gabungan (union) dari dua himpunan,
yaitu {x | x > 3} dan {x | x < -3}. Himpunan yang pertama mempunyai syarat x > 3
dan himpunan ke dua mempunyai syarat x < -3. Maka kedua persyaratan tersebut
harus digabung dengan menggunakan operator boolean OR (Mengapa?). Oleh karena
itu, persyaratan keanggotaan x secara lengkap adalah
) 3 ( ) 3 ( ÷ < > x OR x
01| Algoritma Menentukan_Keanggotaan_range
02| {Diinput suatu bilangan x. Algoritma menghasilkan TRUE apabila x
adalah anggota HP = {x | x > 3} U {x | x < -3} dan mencetak FALSE
bila bukan}
03| Deklarasi:
04| x : real
05| syarat : boolean
06| Deskripsi
07| read(x)
08| syarat  (x > 3) or (x < -3)
09| if syarat then
10| write(„Penyelesaian‟)
11| else
12| write(„Bukan Penyelesaian‟)
13| end if
D. Pemilihan Lebih dari 2 Kasus
1. Pendahuluan
Terkadang kita harus memilih lebih dari 2 pilihan yang ada. Misalnya
menentukan apakah suatu bilangan bulat yang diinputkan user adalah bilangan positif,
negatif, atau nol. Contoh lainnya adalah dalam menentukan gaji pokok karyawan
berdasarkan golongan (kepangkatan).

35
Apabila terdapat lebih dari 2 pilihan, maka kita dapat memandang kasus tersebut
sebagai kasus 2 pilihan, yaitu YA atau BUKAN. Sebagai contoh, kasus menentukan
positif, nol, atau negatif; dapat dipandang sebagai kasus dengan 2 pilihan saja, yaitu
apakah bilangan tersebut adalah bilangan positif atau bukan. Apabila bukan, maka
bilangan tesebut hanya dimungkinkan merupakan bilangan nol atau negatif. Dalam hal
ini (nol atau negatif) merupakan kasus dengan 2 pilihan.
Dengan kata lain, kasus lebih dari 2 pilihan dapat dipandang menjadi kasus 2
pilihan yaitu apakah tergolong pilihan pertama atau bukan. Kemudian untuk bagian
bukan (else), pilihan yang ada telah tereduksi (berkurang) satu. Apabila masih lebih,
maka pilihan masih bisa direduksi lagi dengan cara yang sama, yaitu memandang
apakah tergolong pilihan kedua atau bukan.
2. Algoritma Menentukan Positif, Nol, atau Negatif ()
Buatlah algoritma untuk mencetak kata “Positif”, “Nol”, atau “Negatif”
berdasarkan jenis bilangan yang diinput oleh user.
Analisis:
input : sebuah bilangan (x)
Langkah pengerjaan:
1. input bilangan x
2. tentukan apakah x positif, jika benar maka cetak “Positif”
3. Jika tidak, maka tentu x mungkin nol atau negatif.
4. Tentukan apakah x sama dengan nol, jika benar maka cetak “Nol”
5. jika tidak, maka cetaklah “Negatif”
01| Algoritma Menentukan_Positif_Nol_Negatif
02| {Mencetak positif, nol, atau negatif sesuai dengan jenis bilangan
yang diinputkan oleh user}
03| Deklarasi:
04| x : real
05| Deskripsi
06| read(x)
07| if x > 0 then
08| write(„Positif‟)
09| else
10| if x = 0 then
11| write(„Nol‟)
12| else
13| write(„Negatif‟)
14| end if
15| end if

36
3. Algoritma Gaji Berdasarkan Golongan ()
Suatu perusahaan menentukan gaji pokok karyawannya menurut golongannya.
Besarnya gaji pokok berdasarkan golongannya dapat dilihat pada tabel berikut.
Golongan Gaji Pokok
A Rp400.000,00
B Rp500.000,00
C Rp750.000,00
D Rp900.000,00
Buatlah algoritma untuk menentukan gaji pokok berdasarkan golongan yang
diinput user.
Analisis:
input: Golongan (gol) bertipe char.
Langkah pengerjaan:
1. Anggap kasus terdiri dari 2 pilihan, yaitu bergolongan A atau bukan. Apabila
bukan, maka kasus tereduksi menjadi 3 pilihan, yaitu bergolongan B, C, atau D.
2. Anggap kasus terdiri dari 2 pilihan, yaitu bergolongan B atau bukan. Apabila
bukan, maka kasus tereduksi menjadi 2 pilihan, yaitu bergolongan C atau D.
01| Algoritma Penentuan_Gaji_Pokok
02| {Menentukan gaji pokok berdasarkan golongan. Golongan A mendapat
400 ribu, golongan B mendapat 500 ribu, golongan C mendapat 750
ribu, dan golongan D mendapat 900 ribu.}
03| Deklarasi:
04| gol : char
05| gaji : integer
06| Deskripsi
07| read(gol)
08| if gol = „A‟ then
09| gaji  400000
10| else
11| if gol = „B‟ then
12| gaji  500000
13| else
14| if gol = „C‟ then
15| gaji  750000
16| else
17| gaji  900000
18| end if
19| end if
20| end if
21| write(gaji)

37
4. Algoritma Penentuan Nomor Kuadran Titik Koordinat ()
Suatu titik dalam sistem sumbu koordinat dapat digolongan menjadi kuadran ke-1
hingga kuadran ke-4 berdasarkan letaknya dapat diperhatikan pada gambar berikut.

Ingat, bahwa apabila titik terletak pada sumbu (x maupun y) maka titik tersebut tidak
terletak pada kuadran manapun.
Buatlah algoritma untuk menentukan jenis kuadran berdasarkan suatu titik yang
diinput oleh user.
Analisis:
Anda dapat memakai cara sebelumnya, yaitu memandangnya sebagai kasus dengan 5
pilihan, yaitu kuadran ke-1 hingga kuadran ke-4, ditambah “tidak di kuadran”.
Berdasarkan gambar di atas, maka syarat untuk masing-masing kuadran adalah
Kuadran Syarat
I (x > 0) and (y > 0)
II (x < 0) and (y > 0)
III (x < 0) and (y < 0)
IV (x > 0) and (y < 0)
Kemudian dengan teknik reduksi, kasus dengan 5 pilihan tersebut akan tereduksi
menjadi 4 pilihan, dan seterusnya.
01| Algoritma Penentuan_Kuadran
02| {Menentukan jenis kuadran dari suatu titik koordinat}
03| Deklarasi:
04| x, y, kuadran : integer
05| Deskripsi
06| read(x,y)
07| if (x>0) and (y>0) then
08| kuadran  1
09| else
10| if (x<0) and (y>0) then

38
11| kuadran  2
12| else
13| if (x<0) and (y<0) then
14| kuadran  3
15| else
16| if (x>0) and (y<0) then
17| kuadran  4
18| else
19| kuadran  0
20| end if
21| end if
22| end if
23| end if
24| Write(kuadran)
Apabila Anda perhatikan algoritma di atas, terlalu banyak syarat yang berulang.
Perhatikan bahwa syarat (x>0) terdapat pada baris ke-07 dan baris ke-16. Hal ini
mengisyaratkan bahwa syarat penentuan kuadran tersebut kurang terarah dan
terstruktur.
Maka kita dapat mengatur kembali sudut pandang kita terhadap kasus ini. Urutan
pengklasifikasian pilihan yang lebih terstruktur untuk kasus ini adalah
1. Anggap kasus terdiri dari 2 pilihan, yaitu titik terletak di salah satu kuadran, atau
titik terletak di sumbu. Apabila terletak di sumbu, maka titik sudah pasti tidak
terletak di salah satu kuadran. Syarat suatu titik terletak di salah satu sumbu adalah
(x = 0) or (y = 0).
2. Jika tidak terletak di sumbu, maka tinggal 4 pilihan, yaitu terletak di kuadran ke-1,
kuadran ke-2, kuadran ke-3, atau kuadran ke-4.
3. Kasus dengan 4 pilihan bisa kita kelompokkan menjadi 2 pilihan saja, yaitu apakah
titik terletak di sebelah kanan sumbu-y (x>0) atau terletak di kiri sumbu-y (x<0).
4. Jika terletak di sebelah kanan sumbu-y maka tinggal 2 pilihan saja, yaitu titik
terletak di kuadran ke-1 atau di kuadran ke-4, bergantung pada nilai y.
5. Jika tidak (terletak di sebelah kiri sumbu-y), maka tinggal 2 pilihan pula, yaitu titik
terletak di kuadran ke-2 atau di kuadran ke-3 bergantung pada nilai y pula.
Untuk lebih jelasnya, bisa Anda perhatikan flowchart berikut ini.

39
Titik terletak di
sumbu?
Tidak terletak pada
kuadran manapun.
(Kuadran 0)
YA
X > 0 ?
TIDAK
Terdapat 4 pilihan:
kuadran 1
kuadran 2
kuadran 3
kuadran 4
Tersisa 2 pilihan:
kuadran 1
kuadran 4
Tersisa 2 pilihan:
kuadran 2
kuadran 3
YA TIDAK
Y > 0 ? Y > 0 ? Kuadran 1
Kuadran 3
Kuadran 2
Kuadran 4
END
END
END
END
END
END
SELESAI
A
A
MULAI

01| Algoritma Menentukan_Kuadran
02| {Menentukan kuadran dari suatu titik koordinat}
03| Deklarasi:
04| x, y, kuadran : integer
05| Deskripsi
06| read(x,y)
07| if (x = 0) or (y = 0) then {terletak di salah satu sumbu}
08| kuadran  0
09| else
10| if x > 0 then {di sebelah kanan sumbu-y}

40
11| if y > 0 then
12| kuadran  1
13| else
14| kuadran  4
15| end if
16| else {x < 0, yaitu di sebelah kiri sumbu-y}
17| if y > 0 then
18| kuadran  2
19| else
20| kuadran  3
21| end if
22| end if
23| end if
24| write(kuadran)
5. Algoritma Tahun Kabisat ()
Mari kita analisa kembali syarat tahun kabisat, yaitu:
1. Tahun habis dibagi 400
2. Tahun tidak habis dibagi 100
3. Tahun habis dibagi 4
Perhatikan, bahwa syarat ke-2 lebih lemah dari syarat pertama, yaitu bahwa
walaupun tahun habis dibagi 100, namun apabila tahun habis dibagi 400 maka tahun
tersebut merupakan tahun kabisat. Apabila tahun habis dibagi 400 maka tahun jelas
habis dibagi 4. Kesimpulan kita adalah bahwa apabila tahun habis dibagi 400, maka
secara pasti tahun tersebut merupakan kabisat.
Apabila tidak habis dibagi 400, maka ada 2 kemungkinan, yaitu habis dibagi 100
atau tidak. Bila habis dibagi 100, maka secara pasti tahun tersebut bukan kabisat.
Apabila tidak habis dibagi 100, maka ada 2 kemungkinan, yaitu habis dibagi 4
atau tidak. Bila habis dibagi 4, maka secara pasti tahun tersebut adalah tahun kabisat.
Jika tidak habis dibagi 4, maka secara pasti tahun tersebut bukan kabisat.
Untuk lebih jelasnya, perhatikanlah flowchart berikut ini.

Habis dibagi
400?
Habis dibagi
100?
Habis dibagi
4?
Kabisat Kabisat
Bukan
Kabisat
Bukan
Kabisat
YA
TIDAK
YA
TIDAK TIDAK
YA


41
01| Algoritma Penentuan_Kabisat
02| {Menentukan suatu tahun yang diinput oleh user merupakan tahun
kabisat atau bukan}
03| Deklarasi:
04| n : integer {Tahun}
05| kabisat : boolean {true bila kabisat, false bila bukan}
06| Deskripsi
07| read(n)
08| if n mod 400 = 0 then
09| kabisat  true
10| else
11| if n mod 100 = 0 then
12| kabisat  false
13| else
14| if n mod 4 = 0 then
15| kabisat  true
16| else
17| kabisat  false
18| end if
19| end if
20| end if
21| if kabisat then
22| write(„kabisat‟)
23| else
24| write(„bukan kabisat‟)
25| end if
6. Algoritma Menentukan Grade Nilai Akhir ()
Buatlah algoritma untuk menentukan grade berdasarkan nilai akhir. Grade dapat
dilihat pada tabel berikut.
NILAI AKHIR GRADE
80 – 100 A
70 – <80 B
60 – <70 C
40 – <60 D
0 – <40 E
Selain di atas K


42
Analisis:
Kita perhatikan bahwa nilai yang valid dimulai dari 0 hingga 100. Diluar itu, nilai
tidak valid dan diberi grade “K”. Maka langkah pertama adalah menganggap kasus
dengan 6 pilihan tersebut sebagai kasus dengan 2 pilihan, yaitu apakah nilai valid
(terletak pada range 0–100) atau tidak valid.
Apabila tidak valid, maka grade bernilai “K”. Jika valid, maka tersisa 5 pilihan grade.
Syarat untuk mendapatkan grade A adalah lebih dari sama dengan 80. Tidak perlu
mengecek apakah nilai kurang dari sama dengan 100 (mengapa?). Bila tidak,
maka tersisa 4 pilihan, yaitu grade B hingga grade E. Dengan teknik reduksi, maka
akan tersisa 3 pilihan, dan seterusnya.
01| Algoritma Penentuan_Grade
02| {Menentukan grade berdasarkan nilai akhir. Grade A (80-100); grade
B (70-80); grade C (60-70); grade D (40-60); grade E (0-40);
selain itu diberi grade K}
03| Deklarasi:
04| nilai : real
05| grade : char
06| Deskripsi
07| read(nilai)
08| if not ((nilai>=0) and (nilai<=100)) then {nilai tidak valid}
09| grade  „K‟
10| else
11| if nilai >= 80 then
12| grade  „A‟
13| else
14| if nilai >= 70 then
15| grade  „B‟
16| else
17| if nilai >= 60 then
18| grade  „C‟
19| else
20| if nilai >= 40 then
21| grade  „D‟
22| else
23| grade  „E‟
24| end if
25| end if
26| end if
27| end if

43
28| end if
29| write(grade)
7. Algoritma Penambahan 1 Detik Pada Waktu ()
Diberikan suatu data waktu dalam bentuk hh:mm:ss, dengan hh adalah jam, mm
adalah menit, dan ss adalah detik. Buatlah algoritma untuk menampilkan data waktu
tersebut setelah ditambahkan 1 detik.
Analisis:
Misalkan data waktunya adalah 02:13:23, maka algoritma menghasilkan 02:13:24.
Sepintas terlihat sederhana. Namun ada beberapa data waktu yang rumit bila ditambah
1 detik. Perhatikan tabel berikut.

Data Waktu Setelah penambahan 1 detik
02:13:23 02:13:24
02:13:59 02:14:00
02:59:59 03:00:00
23:59:59 00:00:00

Maka sebelum detik ditambahkan, kita perlu mengecek apakah bisa ditambahkan
secara langsung seperti tabel baris ke-1, yaitu dengan syarat ss + 1 < 60. Jika tidak,
maka berarti ss bernilai 0, kemudian nilai mm ditambahkan 1. Akan tetapi, sebelum
menambahkan 1 ke mm, kita perlu mengecek apakah mm bisa ditambahkan secara
langsung seperti tabel baris ke-2, yaitu dengan syarat mm + 1 < 60. Jika tidak, maka
berarti mm bernilai 0, kemudian nilai hh ditambahkan 1. Akan tetapi, sebelum
menambahkan 1 ke hh, kita perlu mengecek apakah hh bisa ditambahkan secara
langsung seperti tabel baris ke-3, yaitu dengan syarat hh + 1 < 24. Jika tidak, maka
berarti hh bernilai 0 seperti tabel baris ke-4.

ss+1 < 60?
ss + 1
YA
ss  0 mm+1 < 60? mm + 1
mm  0
hh+1 < 24?
hh + 1
hh  0
TIDAK
TIDAK
YA
TIDAK
YA


44
01| Algoritma Penambahan_Waktu_1_Detik
02| {Menambah 1 detik ke data waktu dalam hh:mm:ss yang diinputkan
oleh user}
03| Deklarasi:
04| hh, mm, ss: integer
05| Deskripsi
06| read(hh,mm,ss)
07| if ss + 1 < 60 then
08| ss  ss + 1
09| else
10| ss  0
11| if mm + 1 < 60 then
12| mm  mm + 1
13| else
14| mm  0
15| if hh + 1 < 24 then
16| hh  hh + 1
17| else
18| hh  0
19| end if
20| end if
21| end if
22| write(hh,mm,ss)
8. Algoritma Terbesar dari 3 Bilangan (Bandingkan Satu-Satu) ()
Buatlah algoritma untuk menentukan yang terbesar dari 3 bilangan.
Analisis:
Langkah pengerjaan:
Misalkan bilangan tersebut adalah bilangan a, b, dan c.
1. bandingkan a dengan b dan c. Bila a lebih besar dari b maupun c, maka a terbesar.
2. Jika tidak, maka tersisa 2 kemungkinan, b terbesar atau c terbesar.
3. Bandingkan b dengan c. Bila b lebih besar dari c, maka b terbesar. Jika tidak maka
c yang terbesar.

45
(a>=b)
and
(a>=c)?
terbesar  a
(b>=c)?
terbesar  b
terbesar  c
YA YA
TIDAK TIDAK

01| Algoritma Terbesar_dari_3_Bilangan_A
02| {Menentukan terbesar dari 3 bilangan dengan menggunakan metode
compare each to all}
03| Deklarasi:
04| a, b, c, terbesar : real
05| Deskripsi
06| read(a,b,c)
07| if (a>=b) and (a>=c) then
08| terbesar  a
09| else
10| if b >= c then
11| terbesar  b
12| else
13| terbesar  c
14| end if
15| end if
16| write(terbesar)
9. Algoritma Terbesar dari 3 Bilangan (Pohon Keputusan) ()
Buatlah algoritma untuk menentukan terbesar dari 3 bilangan.
Langkah Pengerjaan:
Misalnya bilangan tersebut adalah a, b, dan c.
1. Apabila a>b, maka b sudah dipastikan bukan terbesar. Tersisa 2 pilihan, yaitu a
yang terbesar atau c yang terbesar. Bandingkan a dan c untuk mengetahui yang
mana yang terbesar.
2. Jika tidak (a ≤ b), maka a sudah dipastikan bukan terbesar. Tersisa 2 pilihan, yaitu
b yang terbesar atau c yang terbesar. Bandingkan b dengan c untuk mengetahui
yang mana yang terbesar.

46
(a>b)?
(b>c)? (a>c)?
terbesar  a terbesar  c
YA TIDAK
YA
TIDAK
terbesar  c terbesar  b
YA
TIDAK

01| Algoritma Terbesar_Dari_3_Bilangan_B
02| {Menentukan terbesar dari 3 bilangan menggunakan metode pohon
keputusan}
03| Deklarasi:
04| a, b, c, terbesar: real
05| Deskripsi
06| read(a,b,c)
07| if a>b then
08| if a>c then
09| terbesar  a
10| else
11| terbesar  c
12| end if
13| else
14| if b>c then
15| terbesar  b
16| else
17| terbesar  c
18| end if
19| end if
20| write(terbesar)
10. Algoritma Terbesar Dari 3 Bilangan (Sekuensial) ()
Buatlah algoritma untuk menentukan terbesar dari 3 bilangan.
Analisis:
Misalkan 3 bilangan tersebut adalah a, b, c.
1. Asumsi bahwa bilangan a yang terbesar.
2. Bandingkan asumsi dengan bilangan berikutnya, yaitu b. Jika b lebih besar, maka
asumsikan terbesar adalah b. Jika tidak, maka asumsi kita bahwa a yang terbesar
tidak berubah.

47
3. Bandingkan asumsi dengan bilangan berikutnya, yaitu c. Jika c lebih besar, maka c
adalah yang terbesar. Jika tidak, maka asumsi tidak berubah, dan asumsi itulah
yang benar terbesar.

(b > terbesar)?
terbesar  a
terbesar  b
(c > terbesar)?
terbesar  c
YA
YA


01| Algoritma Terbesar_Dari_3_Bilangan_C
02| {Menentukan terbesar dari 3 bilangan menggunakan metode
sekuensial}
03| Deklarasi:
04| a, b, c, terbesar : real
05| Deskripsi
06| read(a,b,c)
07| terbesar  a
08| if b > terbesar then
09| terbesar  b
10| end if
11| if c > terbesar then
12| terbesar  c
13| end if
14| write(terbesar)

48
E. Latihan
1. Algoritma pembulatan seratusan di BAB III : nomor 6. sebelumnya, algoritma
menghasilkan output yang salah apabila harga yang diberikan merupakan kelipatan
seratus. Buatlah algoritma perbaikannya dengan memperhatikan petunjuk bahwa
harga hanya akan dibulatkan apabila bukan kelipatan seratus.
2. Diketahui bahwa cuaca dikatakan panas apabila temperatur lebih dari 30
0
C dan
cuaca dikatakan dingin apabila temperatur kurang dari 25
0
C. Buatlah algoritma
untuk mencetak kata “Panas”, “Dingin”, atau “Normal” sesuai dengan temperatur
yang diinputkan user. Temperatur yang diinputkan oleh user adalah dalam
satuan derajat Fahrenheit.
3. Diberikan suatu persamaan kuadrat ax
2
+ bx + c = 0 dengan a ≠ 0. Persamaan
tersebut dapat diselesaikan dengan menggunakan rumus ABC, yaitu
a
D b
x
2
2 , 1
± ÷
= dengan ac b D 4
2
÷ = . Penyelesaian tersebut dapat digolongkan
menjadi 3 jenis, yaitu “mempunyai 2 penyelesaian real yang berbeda”,
“mempunyai penyelesaian kembar”, dan “tidak mempunyai penyelesaian real”
berdasarkan nilai D seperti pada tabel berikut.
Syarat Jenis Penyelesaian
D > 0 Mempunyai 2 penyelesaian real yang berbeda
D = 0 Mempunyai penyelesaian kembar
D < 0 Tidak mempunyai penyelesaian real
Buatlah algoritma untuk menentukan jenis penyelesaian dari suatu persamaan
kuadrat berdasarkan nilai a, b, dan c yang diinput user.
4. Berdasarkan teori pada soal nomor 3, buatlah algoritma untuk menghitung
penyelesaian dari persamaan kuadrat apabila persamaan mempunyai penyelesaian
real. (D ≥ 0). Petunjuk: untuk menghitung nilai akar digunakan fungsi SQRT().
Contoh: x  (-b + sqrt(d)) / (2*a). Ingat, hasil dari pengakaran suatu bilangan
selalu bertipe real. Perintah sqrt(-1) akan menghasilkan kesalahan.
5. Buatlah algoritma untuk menentukan terbesar dari 4 bilangan dengan
menggunakan 3 metode seperti pada algoritma nomor 8. , 9. , dan 10. .
6. Sebuah perusahaan memberikan kode pegawai dengan suatu bilangan yang terdiri
dari 11 digit, dengan format gddmmyyyynn, yaitu g adalah nomor golongan (dari 1
hingga 4); dd-mm-yyyy adalah tanggal lahir dengan dd = tgl, mm=bulan,
yyyy=tahun; dan nn adalah kode identitas yang menyatakan nomor urut. Misalnya
22505197803 adalah seorang pegawai bergolongan 2, lahir pada tanggal 25 Mei
1978 dan bernomor urut 3. Buatlah algoritma untuk mencetak nomor golongan,
tanggal lahir, dan nomor urut pegawainya. Bulan kelahiran dicetak dalam format
nama bulan, misalnya bulan ke-5 dicetak “MEI”.
7. Berdasarkan kode pegawai pada soal nomor 6 di atas, buatlah algoritma untuk
menghitung gaji pegawainya. Ketentuannya adalah pajak sebesar 5% dari total
gaji, besarnya gaji pokok dan tunjangan dapat dilihat pada tabel berikut.
Golongan Gaji Pokok Tunjangan
1 Rp400.000,00 Rp150.000,00
2 Rp600.000,00 Rp250.000,00
3 Rp900.000,00 Rp400.000,00
4 Rp1400.000,00 Rp700.000,00

49
BAB V : PENGULANGAN
A. Pengertian
Dalam algoritma terkadang suatu proses tidak hanya dikerjakan satu kali, namun
hendak dikerjakan berulang kali. Dalam hal ini, kita dapat menggunakan struktur
algoritma pengulangan.
Pengulangan dalam algoritma pada dasarnya dapat digolongkan ke dalam 2 jenis,
yaitu:
1. Pengulangan yang diketahui banyaknya pengulangan (definite loop)
2. Pengulangan yang tidak diketahui banyaknya pengulangan (indefinite loop)
Definite loop digunakan apabila banyaknya pengulangan diketahui secara pasti.
Sedangkan indefinite loop digunakan apabila hanya diketahui syarat melakukan
pengulangan atau syarat pengulangan berhenti. Dalam algoritma yang kita pelajari,
definite loop menggunakan perintah FOR, sedangkan indefinite loop menggunakan
perintah WHILE dan REPEAT.
Beberapa hal yang harus diperhatikan dalam pengulangan adalah:
Pengulangan harus dapat mengulang proses yang hendak diulang.
Pengulangan harus dapat berhenti (banyaknya pengulangan berhingga)
Dengan kata lain, proses yang hendak diulang harus diperhatikan 2 kemungkinan yang
mungkin terjadi, yaitu proses tidak pernah dikerjakan atau proses dikerjakan terus
menerus tanpa henti.
B. Definite Loop
Dalam algoritma, definite loop menggunakan perintah FOR. Struktur
pengulangan FOR adalah
FOR pencacah  nilai_awal TO nilai_akhir DO
proses_1
proses_2
...
proses_n
END FOR
atau
FOR pencacah  nilai_akhir DOWNTO nilai_awal DO
proses_1
proses_2
...
proses_n
END FOR
Pencacah dalam struktur FOR di atas merupakan suatu variabel bertipe ordinal.
Tipe ordinal yaitu tipe data yang dapat diketahui secara pasti data sebelum dan data
sesudahnya. Dalam hal ini, tipe ordinal adalah tipe integer, char, dan boolean. Tipe

50
real bukan ordinal. Ambil suatu data real, misalnya data 1.5; berapakah data real
sesudah 1.5? Apakah 1.51 atau 1.511 ataukah 1.5111? Oleh karena tidak dapat
ditentukan data berikutnya secara pasti, maka tipe real dikatakan bukan tipe data
ordinal.
Nilai_awal dan nilai_akhir merupakan suatu nilai yang bertipe yang sama
dengan tipe variabel pencacah. Pengulangan bentuk I dan II akan mengulang
mengerjakan proses_1 hingga proses_n sebanyak (nilai_akhir – nilai_awal + 1).
Bedanya adalah bentuk I adalah bentuk menaik yaitu nilai dari pencacah akan
berubah dari nilai_awal ke nilai_akhir dengan kenaikan satu-satu. Sedangkan
bentuk II adalah bentuk menurun yaitu nilai dari pencacah akan berubah dari
nilai_akhir ke nilai_awal dengan penurunan satu-satu.
Dalam penggunaan bentuk FOR ini, ada hal-hal yang harus diperhatikan. Apabila
nilai_awal = nilai_akhir, maka proses hanya akan dikerjakan 1 kali. Apabila
nilai_awal > nilai_akhir, maka proses sama sekali tidak akan dikerjakan. Hal lainnya
adalah bahwa proses dalam FOR tidak boleh mengubah nilai variabel pencacah.
1. Contoh-contoh
Perhatikan penggalan algoritma berikut ini.
01| Deskripsi
02| write(„Stmik Pontianak‟)
03| write(„Stmik Pontianak‟)
04| write(„Stmik Pontianak‟)
05| write(„Stmik Pontianak‟)
06| write(„Stmik Pontianak‟)
Bentuk di atas dapat kita sederhanakan dengan menggunakan struktur
pengulangan FOR.
01| Deklarasi:
02| k : integer
03| Deskripsi
04| for k  1 to 5 do
05| write(„Stmik Pontianak‟)
06| end for

Misalkan Anda diminta untuk membuat algoritma yang mencetak kalimat “Stmik
Pontianak” sebanyak n kali, dengan nilai n ditentukan oleh user. Maka Anda tidak
dapat menggunakan cara pertama, karena Anda tidak dapat mengetahui secara pasti
berapa nilai n yang akan diinputkan oleh user. Oleh karena itu, Anda dapat
menggunakan struktur FOR.
01| Deklarasi:
02| k, {sebagai variabel pencacah}
03| n : integer {sebagai input banyaknya pengulangan}

51
04| Deskripsi
05| read(n)
06| for k  1 to n do
07| write(„Stmik Pontianak‟)
08| end for
Perhatikan penggalan algoritma berikut ini
01| Deskripsi
02| write(1)
03| write(2)
04| write(3)
05| write(4)
06| write(5)
Algoritma di atas dapat disederhanakan menggunakan struktur FOR.
01| Deklarasi:
02| k : integer
03| Deskripsi
04| for k  1 to 5 do
05| write(k)
06| end for
Algoritma berikut ini tidak boleh dilakukan.
01| Deklarasi:
02| k : integer
03| Deskripsi
04| for k  1 to 5 do
05| write(k)
06| k  k + 1 {tidak boleh karena mengubah nilai pencacah}
07| end for
2. Algoritma Mencetak Barisan ()
Buatlah algoritma untuk mencetak barisan “2 4 6 8 10 ... “ sebanyak n buah suku.
Analisis:
Buatlah sebuah variabel pencacah misalkan k yang berjalan dari 1 hingga n.
Perhatikan tabel berikut:
k Output
1 2
2 4
3 6
Dan seterusnya

52
Dengan demikian dapat disimpulkan bahwa algoritma mencetak nilai “2 x k” dengan
nilai k berjalan dari 1 sampai n.
01| Algoritma Mencetak_Barisan
02| {mencetak barisan “2 4 6 8 ...” sebanyak n suku}
03| deklarasi:
04| k,n : integer
05| Deskripsi
06| read(n)
07| for k  1 to n do
08| write(2*k)
09| end for
3. Algoritma Penjumlahan Deret ()
Buatlah algoritma untuk menghitung jumlahan deret 1 + 2 + ... + n dengan nilai n
diinput dari user.
Analisis:
Misalkan nilai n adalah 5. Maka hendak dihitung nilai 1 + 2 + 3 + 4 + 5.
Misalkan pula hasil dari perhitungan dimasukkan ke variabel jumlah. Maka hasil akhir
yang diharapkan adalah variabel jumlah berisi nilai sebesar 15.
Misalkan kita mendeklarasikan suatu variabel k sebagai pencacah yang akan diberi
nilai awal sebesar 1 hingga 5, maka perhatikan tabel berikut:

k Deret Jumlah
0
1 0 + 1 = jumlah sebelumnya + 1 1
2 1+2 = jumlah sebelumnya + 2 3
3 1+2+3 = 3+3 = jumlah sebelumnya + 3 6
4 1+2+3+4 = 6+4 = jumlah sebelumnya + 4 10
5 1+2+3+4+5 = 10 + 5 = jumlah sebelumnya + 5 15
Dengan demikian, diperoleh rumus jumlah = jumlah sebelumnya + k dengan k bernilai
dari 1 hingga 5.
Maka langkah pengerjaannya adalah:
1. isikan nilai awal 0 untuk variabel jumlah.
2. lakukan pengulangan dengan variabel pencacah k dari 1 hingga 5:
jumlah = jumlah sebelumnya + k
01| Algoritma Menghitung_Deret
02| {menghitung jumlah deret 1 + 2 + ... + n}
03| Deklarasi:
04| k, n : integer
05| jumlah : integer

53
06| Deskripsi
07| read(n)
08| jumlah  0 {inisialisasi}
09| for k  1 to n do
10| jumlah  jumlah + k
11| end for
12| write(jumlah)
4. Algoritma Hitung Rata-rata dari n Data ()
Buatlah algoritma yang meminta input n buah data bilangan dari user kemudian
menghitung rata-ratanya.
Analisis:
Tekniknya sama dengan algoritma nomor 3. di atas, hanya saja yang dijumlahkan
adalah data yang diinputkan oleh user. Oleh karena itu, kita harus mengulang perintah
read(data) sebanyak n kali.
Kemudian rumus penjumlahannya adalah jumlah  jumlah + data.
Setelah memperoleh jumlah, mencari rata-rata dapat menggunakan rumus jumlah/n.
01| Algoritma Hitung_Rata_rata_dari_n_data
02| {meminta input n buah data dari user kemudian menghitung rata-
ratanya.}
03| Deklarasi:
04| data, jumlah : real {karena soal hanya menyebut bilangan}
05| k, n : integer {harus integer karena pencacah}
06| rata : real {untuk menampung hasil perhitungan rata-rata}
07| Deskripsi
08| read(n)
09| jumlah  0
10| for k  1 to n do
11| read(data)
12| jumlah  jumlah + data
13| end for
14| rata  jumlah / n
15| write(rata)
5. Algoritma Perhitungan Banyaknya yang Lulus ()
Buatlah algoritma untuk meminta input n buah data nilai mahasiswa kemudian
menghitung banyaknya mahasiswa yang lulus. Syarat untuk lulus adalah nilai yang
diperoleh adalah minimal 60.

54
Analisis:
Soal ini menggunakan teknik yang sama dengan algoritma nomor 4. di atas. Tetapi,
ingat bahwa yang dijumlah bukanlah nilainya, tetapi angka 1, yaitu menggunakan
rumus banyak  banyak + 1. Rumus ini hanya dikerjakan apabila mahasiswa lulus,
dengan kata lain nilai mahasiswa lebih besar atau sama dengan 60.
01| Algoritma Hitung_Banyaknya_Lulus
02| {menginput n buah data nilai, lalu menghitung banyaknya mahasiswa
yang lulus}
03| Deklarasi:
04| banyak : integer
05| k, n : integer
06| nilai : real
07| Deskripsi
08| read(n)
09| banyak  0
10| for k  1 to n do
11| read(nilai)
12| if nilai >= 60 then
13| banyak  banyak + 1
14| end if
15| end for
16| write(banyak)
6. Algoritma Terbesar dari n Data Bilangan ()
Buatlah algoritma untuk menginput n buah data bilangan, kemudian mencetak
bilangan yang merupakan terbesar dari data tersebut.
Analisis:
Untuk menginput n buah data, kita menggunakan teknik seperti pada algoritma-
algoritma sebelumnya. Sedangkan untuk menentukan yang terbesar, kita
menggunakan teknik seperti pada algoritma BAB IV :D. nomor 10. Jika diperhatikan,
maka algoritma tersebut pertama-tama adalah memasukkan nilai data ke variabel
terbesar. Kemudian algoritma hanya mengulang membandingkan terbesar dengan
data. Bila data > terbesar maka kita memasukkan nilai data ke variabel terbesar.
01| Algoritma Terbesar_dari_n_data
02| {Menginput n buah data bilangan kemudian mencetak yang terbesar}
03| Deklarasi:
04| k, n : integer
05| data, terbesar : real

55
06| Deskripsi
07| read(n) {asumsi n tidak nol}
08| {menginput data pertama}
09| read(data)
10| {asumsi data pertama adalah yang terbesar}
11| terbesar  data
12| {membandingkan terbesar dengan data berikutnya secara berulang}
13| for k  2 to n do {nilai awal = 2 karena data kedua}
14| read(data) {input data berikut}
15| if data > terbesar then
16| terbesar  data
17| end if
18| end for
19| write(terbesar)
7. Algoritma Nilai Tertinggi ()
Buatlah algoritma untuk menampilkan nilai tertinggi dari sekumpulan n buah nilai
ujian mahasiswa. Nilai tersebut berkisar dari 0 hingga 100.
Analisis:
Kita dapat menerapkan algoritma nomor 6. di atas, tetapi karena batas nilai diketahui,
maka kita dapat menggunakan metode lain yang merupakan modifikasi dari algoritma
tersebut.
Untuk menentukan nilai tertinggi, algoritma nomor 6. mengasumsikan nilai tertinggi
adalah nilai mahasiswa pertama. Apabila batas algoritma diketahui, maka kita dapat
mengasumsikan bahwa nilai tertinggi adalah nilai terendah yang mungkin diperoleh
mahasiswa, yaitu nilai 0. Kemudian lakukan perbandingan dari nilai pertama hingga
nilai ke-n.
01| Algoritma Nilai_Tertinggi_dari_n_Mahasiswa
02| {Menampilkan nilai tertinggi dari sekumpulan n nilai mahasiswa.
Nilai berkisar dari 0 hingga 100}
03| Deklarasi:
04| k, n : integer
05| tertinggi, nilai : real
06| Deskripsi
07| Read(n)
08| {asumsikan nilai tertinggi serendah mungkin}
09| tertinggi  0.0 {boleh memakai nilai negatif}
10| For k  1 to n do
11| read(nilai)

56
12| {bandingkan asumsi dengan nilai ke-1 hingga ke-n}
13| if nilai >= tertinggi then {pakai = karena asumsi 0.0}
14| tertinggi  nilai
15| end if
16| end for
17| write(tertinggi)
8. Algoritma Faktorial ()
Buatlah algoritma untuk menghitung nilai n faktorial.
Analisis:
Ingat bahwa 0! = 1; 1! = 1; dan n! = 1 x 2 x ... x n
Tekniknya sama dengan algoritma penjumlahan deret 1+2+...+n. Hanya saja operator
yang dipakai berbeda, yaitu faktorial memakai perkalian. Oleh karena itu, pemberian
nilai awal (inisialisasi) diberikan nilai 1 yang merupakan identitas perkalian.
01| Algoritma Hitung_Faktorial
02| {menghitung besarnya n!}
03| Deklarasi:
04| k, n : integer
05| fak : integer {untuk menampung hasil dari n!}
06| Deskripsi
07| read(n)
08| fak  1 {inisialisasi}
09| for k  2 to n do {mengapa mulai dari 2?}
10| fak  fak * k
11| end for
12| write(fak)
9. Algoritma Pangkat Bulat ()
Buatlah algoritma untuk menghitung nilai
n
a dengan a R e dan n Z e .
Analisis:
Secara normal, . ...
n
a a a a = sebanyak n faktor. Maka algoritmanya adalah
01| Algoritma a_pangkat_n
02| {menghitung nilai dari a pangkat n}
03| Deklarasi:
04| k : integer
05| a,n, pangkat : integer
06| Deskripsi
07| read(a,n)
08| pangkat  1

57
09| for k  1 to n do
10| pangkat  pangkat * a
11| end for
12| write(pangkat)

Tetapi algoritma di atas mempunyai banyak kelemahan. Perhatikan tabel berikut:
n
a hasil
0
0 Tak terdefinisi
3
0
÷
Tak terdefinisi
3
0 0
0
( 2) ÷ 1
3
( 2) ÷ (-2)(-2)(-2)
3
( 2)
÷
÷
1 1 1
2 2 2
| || || |
÷ ÷ ÷
| | |
\ .\ .\ .

0
2
1
3
2
2.2.2
3
2
÷

1 1 1
2 2 2
| || || |
| | |
\ .\ .\ .


Algoritma di atas hanya berlaku untuk baris yang diarsir. Oleh karena itu, algoritma
kita harus dapat mengenali situasi selain yang diarsir.
Situasi tersebut dapat dibagi menjadi beberapa pilihan seperti pada tabel berikut:

a n Hasil dari
n
a
a=0
n≤0 Tak terdefinisi
n>0 0
a<0
a>0
n=0 1
n>0 a.a...a
n<0
1 1 1 1
. . ...
a a a a


01| Algoritma Menghitung_a_Pangkat_n
02| {menghitung nilai a pangkat n dengan a real dan n integer}
03| Deklarasi:
04| a : real
05| k, n : integer
06| pangkat : real {karena salah satu hasilnya menggunakan 1/a}
07| valid:boolean {false bila tak terdefinisi, true bila sebaliknya}
08| Deskripsi
09| read(a,n)

58
10| valid  true {asumsi valid}
11| if a = 0 then
12| if n <= 0 then
13| valid  false
14| else
15| pangkat  0
16| end if
17| else
18| pangkat  1
19| if n > 0 then
20| for k  1 to n do
21| pangkat  pangkat * a
22| end for
23| else
24| for k  1 to (-n) do {-n karena n negatif}
25| pangkat  pangkat * 1/a
26| end for
27| end if
28| end if
29| if not valid then
30| write(„tak terdefinisi‟)
31| else
32| write(pangkat)
33| end if
10. Algoritma Menentukan Prima ()
Buatlah algoritma untuk menentukan apakah suatu bilangan bulat yang diinputkan
user adalah bilangan prima atau komposit.
Analisis:
Bilangan n adalah bilangan prima apabila bilangan n hanya mempunyai faktor 1 dan n.
Dengan kata lain, bilangan n adalah bilangan prima apabila bilangan 2 hingga n–1
tidak ada satupun yang merupakan faktor dari n.
Bilangan a dikatakan faktor dari n apabila n habis dibagi oleh a.
Dari teori di atas, maka untuk menentukan prima atau tidak, dapat dilakukan langkah:
1. Asumsikan bahwa bilangan n adalah bilangan prima.
2. Bagilah bilangan n dengan bilangan mulai dari 2 hingga n–1.
3. Apabila ada satu saja yang habis dibagi, maka n bukanlah bilangan prima.

59
01| Algoritma Menentukan_prima
02| {Menentukan apakah bilangan bulat yang diinput user adalah
bilangan prima atau komposit}
03| Deklarasi:
04| Prima : boolean {true bila prima, false bila bukan}
05| K , n : integer
06| Deskripsi
07| read(n)
08| prima  TRUE
09| for k  2 to n-1 do
10| if n mod k = 0 then
11| prima  FALSE
12| end if
13| end for
14| if prima then
15| write(„PRIMA‟)
16| else
17| write(„KOMPOSIT‟)
18| end if
C. Indefinite Loop
Dalam algoritma, indefinite loop dapat menggunakan struktur Repeat ataupun
struktur While. Perhatikan struktur penulisan Repeat dan While berikut ini:
...
REPEAT
proses1
...
prosesn
UNTIL kondisi1
...
...
WHILE kondisi2 DO
proses1
...
prosesn
END WHILE
...

60
Langkah-langkah yang dikerjakan algoritma struktur repeat, yaitu:
1. Kerjakan proses1 hingga prosesn secara berurutan
2. Bila kondisi1 bernilai TRUE, maka struktur repeat berakhir, dan bila kondisi1
bernilai FALSE, maka mengulangi mengerjakan langkah 1.

Langkah-langkah yang dikerjakan algoritma struktur while, yaitu:
1. Cek nilai dari kondisi2.
2. Bila bernilai TRUE, maka proses1 hingga prosesn akan dikerjakan, kemudian
kembali ke langkah 1.
3. Bila bernilai FALSE, maka struktur while berakhir.

Berdasarkan penjelasan di atas, maka dapat disimpulkan perbedaan antara
penggunaan struktur repeat dan while, yaitu:

Struktur Repeat Struktur While
1. kondisi dicek setelah proses dikerjakan 1. kondisi dicek sebelum proses dikerjakan
2. proses dikerjakan minimal 1x 2. proses ada kemungkinan tak dikerjakan
3. kondisi merupakan syarat untuk
mengakhiri pengulangan
3. kondisi merupakan syarat untuk
mengulangi proses

Hal-hal yang harus diperhatikan dalam struktur repeat dan while, yaitu:
1. kondisi dalam repeat dan while dapat berupa ekspresi yang menghasilkan nilai
boolean, maupun variabel bertipe boolean.
2. kondisi harus memiliki kemungkinan untuk berubah nilai. Oleh karena itu, harus
ada suatu proses dalam struktur repeat dan while yang dapat mengubah nilai
kondisi.

Contoh-contoh di bawah ini memperlihatkan bagaimana langkah kerja struktur
repeat dan struktur while.
01| Algoritma Contoh_Repeat
02| {Memakai struktur repeat untuk mencetak bilangan 1,2,3}
03| Deklarasi:
04| k : integer
05| Deskripsi
06| k  1
07| repeat
08| write(k)
09| k  k + 1 {baris ini yang mengubah nilai kondisi}
10| until k > 3
11| write(„selesai‟)


61
Langkah kerja algoritma di atas adalah:
1. variabel k diisikan nilai 1
2. mencetak nilai k yaitu 1
3. variabel k diisikan nilai 1 + 1 = 2, sehingga k bernilai 2
4. karena k > 3 bernilai FALSE, maka mengulangi baris ke-08 pada algoritma
5. mencetak nilai k yaitu 2
6. variabel k diisikan nilai 2 + 1 = 3, sehingga k bernilai 3
7. karena k > 3 bernilai FALSE, maka mengulangi baris ke-08 pada algoritma
8. mencetak nilai k yaitu 3
9. variabel k diisikan nilai 3 + 1 = 4, sehingga k bernilai 4
10. karena k > 3 bernilai TRUE, maka lanjut ke baris-11
11. mencetak nilai string ‘selesai’

01| Algoritma Contoh_While
02| {Memakai struktur while untuk mencetak bilangan 1,2,3}
03| Deklarasi:
04| k : integer
05| Deskripsi
06| k  1
07| while k <= 3 do
08| write(k)
09| k  k + 1
10| end while
11| write(„selesai‟)

Langkah kerja algoritma di atas adalah:
1. variabel k diisikan nilai 1
2. karena k <= 3 bernilai TRUE, maka algoritma mengerjakan baris ke-08 (apabila
false, maka langsung loncat ke baris ke-11)
3. mencetak nilai k yaitu 1
4. variabel k diisikan nilai 1 + 1 = 2, sehingga k bernilai 2
5. kembali ke baris ke-07
6. karena k <= 3 bernilai TRUE, maka algoritma mengerjakan baris ke-08
7. mencetak nilai k yaitu 2
8. variabel k diisikan nilai 2 + 1 = 3, sehingga k bernilai 3
9. kembali ke baris ke-07
10. karena k <= 3 bernilai TRUE, maka algoritma mengerjakan baris ke-08
11. mencetak nilai k yaitu 3
12. variabel k diisikan nilai 3 + 1 = 4, sehingga k bernilai 4
13. kembali ke baris ke-07
14. karena k <= 3 bernilai FALSE, maka algoritma loncat ke baris ke-11
15. mencetak string ‘selesai’


62
Dari dua algoritma di atas, dapat kita simpulkan bahwa pada dasarnya struktur
repeat dan while dapat digunakan untuk memecahkan masalah yang sama, hanya saja
kondisi (syarat) mereka adalah saling berlawanan. Pada algoritma di atas, struktur
repeat mempunyai kondisi “k > 3”, sedangkan struktur while mempunyai kondisi
“k <= 3”. Akan tetapi tidak semua masalah yang diselesaikan oleh repeat dapat secara
langsung dikonversi menjadi bentuk struktur while.
Perhatikan dua penggalan algoritma berikut ini:
01| deklarasi:
02| k, n : integer
03| Deskripsi
04| read(n)
05| k  1
06| repeat
07| write(k)
08| k  k + 1
09| until k > n

01| deklarasi:
02| k, n : integer
03| Deskripsi
04| read(n)
05| k  1
06| while k <= n do
07| write(k)
08| k  k + 1
09| end while

Apabila nilai n ≥ 1, maka algoritma di atas menghasilkan output yang sama, yaitu
bilangan dari 1 hingga n. Akan tetapi apabila n < 1, maka algoritma dengan struktur
repeat akan menghasilkan output angka 1, sedangkan algoritma dengan struktur while
tidak menghasilkan output apapun.
Berikut ini adalah contoh-contoh penerapan pembuatan algoritma dengan
menggunakan struktur repeat maupun while.
1. Algoritma Menghitung Jumlahan Data
Buatlah algoritma untuk meminta input data bilangan secara terus-menerus dari
user hingga user menyudahi pengisian data. Algoritma menghasilkan output berupa
hasil jumlahan data dari user tersebut.

63
Analisis:
Masalah menjumlahkan data sudah pernah kita bahas dalam bagian struktur FOR.
Permasalahan di algoritma ini adalah bahwa banyaknya data tidak diketahui. Kita
hanya mendapat petunjuk bahwa syarat menghentikan input data adalah saat user
menyudahi pengisian data.
Masalahnya adalah bagaimana cara kita mengetahui bahwa user hendak menyudahi
pengisian data. Ada dua cara yang dapat ditempuh, yaitu menanyakan apakah user
hendak menyudahi pengisian data setiap kali user selesai menginput sebuah data, atau
meminta user untuk memasukkan suatu nilai tertentu (nilai tersebut tidak boleh
berkemungkinan untuk menjadi data) sebagai tanda untuk mengakhiri pengisian data.
Untuk cara pertama, langkah pengerjaannya adalah:
1. Minta input data
2. Tanyakan apakah masih mempunyai data, jika YA maka lakukan langkah 1.
3. Jika TIDAK, maka cetak hasil jumlahnya.
01| Algoritma Penjumlahan_Data_Cara_Pertama
02| {Meminta input data secara terus menerus. Setiap kali selesai
menginput sebuah data, user ditanyakan apakah masih mempunyai
data. User diharapkan menjawab huruf „T‟ untuk menyudahi
pengisian. Outputnya adalah jumlahan datanya. Algoritma ini
menggunakan struktur REPEAT}
03| Deklarasi:
04| jumlah, data : real
05| tanya : char
06| Deskripsi
07| jumlah  0
08| repeat
09| read(data)
10| jumlah  jumlah + data
11| read(tanya)
12| until (tanya = „T‟) or (tanya = „t‟)
13| write(jumlah)

Untuk cara kedua, langkah pengerjaannya adalah:
1. Minta input data
2. bila data bukan negatif (dalam hal ini misalkan ketentuan menyudahi pengisian
adalah mengisikan data negatif) maka ulangi langkah 1
3. cetak jumlahnya

64
01| Algoritma Penjumlahan_data_cara_kedua
02| {Meminta input data bilangan dari user secara terus menerus. Bila
user ingin menyudahi pengisian data, maka user diharapkan untuk
menginput data negatif. Outputnya adalah jumlahan datanya.
Algoritma ini menggunakan struktur REPEAT.}
03| Deklarasi:
04| jumlah, data : real
05| Deskripsi
06| jumlah  0
07| repeat
08| read(data)
09| jumlah  jumlah + data
10| until data < 0
11| jumlah  jumlah – data {mengapa demikian?}
12| write(jumlah)

Berikut ini merupakan cara pertama dan cara kedua menggunakan struktur while
01| Algoritma Penjumlahan_data_cara_pertama_while
02| {Meminta input data secara terus menerus. Setiap kali selesai
menginput sebuah data, user ditanyakan apakah masih mempunyai
data. User diharapkan menjawab huruf „T‟ untuk menyudahi
pengisian. Algoritma ini menggunakan struktur WHILE}
03| Deklarasi:
04| data, jumlah : real
05| tanya : char
06| Deskripsi
07| jumlah  0
08| read(data)
09| jumlah  jumlah + data
10| read(tanya)
11| while (tanya <> „T) and (tanya <> „t‟) do
12| read(data)
13| jumlah  jumlah + data
14| read(tanya)
15| end while
16| write(jumlah)


65
01| Algoritma Penjumlahan_data_cara_kedua_while
02| {Meminta input data bilangan dari user secara terus menerus. Bila
user ingin menyudahi pengisian data, maka user diharapkan untuk
menginput data negatif. Outputnya adalah jumlahan datanya.
Algoritma ini menggunakan struktur WHILE.}
03| Deklarasi:
04| jumlah, data : real
05| Deskripsi
06| jumlah  0
07| read(data)
08| while data >= 0 do
09| jumlah  jumlah + data
10| read(data)
11| end while
12| write(jumlah)
2. Algoritma Pemasukkan Password
Buatlah algoritma yang meminta user memasukkan password (kata sandi) yang
berupa sebuah data string. Kata sandi tersebut disimpan dalam suatu konstanta. Jika
user melakukan 3 kali kesalahan pemasukkan, maka user dianggap gagal dan tidak
boleh memasukkan lagi.
Analisis:
Oleh karena kita tidak dapat menentukan berapa kali user memasukkan password
hingga berhasil, maka dalam hal ini tidak bisa menggunakan struktur FOR. Pilihan
ada pada penggunaan struktur repeat atau while.
Dalam hal ini, dapat disimpulkan bahwa user berhenti menginput password apabila
user sudah memasukkan password yang benar, atau user telah melakukan 3 kali
kesalahan. Inilah syarat atau kondisi pemberhentian untuk struktur repeat.
Atau dengan kata lain, user mengulangi menginput password apabila user belum
memasukkan password yang benar, dan user belum melakukan 3 kali kesalahan.
Inilah syarat atau kondisi pengulangan untuk struktur while.
01| Algoritma Input_Password_Repeat
02| {Menginput password dengan menggunakan struktur repeat. Tiga
kesalahan berarti gagal.}
03| Deklarasi:
04| const password = „StMiK‟ {kata sandinya adalah StMiK}
05| benar : boolean {TRUE bila password benar, FALSE bila salah}
06| k : integer {untuk menampung banyaknya kesalahan}
07| pw : string {untuk menampung input password dari user}
08| Deskripsi
09| k  0 {belum ada kesalahan}

66
10| benar  FALSE {user belum memasukkan password yang benar}
11|
12| repeat
13| read(pw) {meminta input password dari user}
14| if pw = password then {user input password yang benar}
15| benar  TRUE
16| else {user memasukkan password yang salah}
17| k  k + 1 {banyaknya kesalahan ditambah 1}
18| end if
19| until benar or (k = 3)
20|
21| {mencetak pesan sesuai kondisi}
22| if benar then
23| write(„Selamat, password anda benar‟)
24| else
25| write(„Sudah 3 kali kesalahan. Anda gagal!‟)
26| end if

01| Algoritma Input_Password_While
02| {Menginput password dengan menggunakan struktur while. Tiga
kesalahan berarti gagal.}
03| Deklarasi:
04| const password = „StMiK‟ {kata sandinya adalah StMiK}
05| benar : boolean {TRUE bila password benar, FALSE bila salah}
06| k : integer {untuk menampung banyaknya kesalahan}
07| pw : string {untuk menampung input password dari user}
08| Deskripsi
09| k  0
10| benar  FALSE
11| while not benar and (k < 3) do
12| read(pw)
13| if pw = password then
14| benar  TRUE
15| else
16| k  k + 1
17| end if
18| end while

67
19| if benar then
20| write(„Selamat, password anda benar‟)
21| else
22| write(„Sudah 3 kali kesalahan. Anda gagal!‟)
23| end if
3. Algoritma Estimasi Nilai Akar Kuadrat
Nilai y n = dapat diperoleh dengan langkah-langkah berikut:
1. Tentukan nilai kesalahan yang diperbolehkan, misalnya error = 0,001
2. Dapat dibuktikan bahwa berlaku 0 y n s s . Dengan demikian, nilai yang hendak
kita hitung terletak di antara 0 hingga n. Dalam hal ini, dikatakan bahwa batas atas
= n, dan batas bawah = 0.
3. Ambil nilai tengah = (atas + bawah)/2.
4. Nilai tengah inilah yang merupakan nilai perkiraan (kandidat nilai y).
5. Permasalahannya adalah apakah nilai perkiraan tersebut terlalu besar dibandingkan
nilai yang sebenarnya, ataukah terlalu kecil?
6. Ambil
2
( ) z tengah = . Apabila z n < berarti nilai perkiraan kita lebih kecil dari nilai
yang sebenarnya. Apabila z n > berarti nilai perkiraan kita lebih besar dari nilai
yang sebenarnya.
7. Bila nilai perkiraan kita lebih kecil dari nilai yang sebenarnya, berarti nilai y
terletak antara tengah hingga batas atas, yaitu tengah y atas s s . Hal ini berarti
bahwa batas bawah = tengah dan batas atasnya tetap.
8. Bila nilai perkiraan kita lebih besar dari nilai yang sebenarnya, berarti nilai y
terletak antara batas bawah hingga tengah, yaitu bawah y tengah s s . Hal ini
berarti bahwa batas bawahnya tetap dan batas atas = tengah.
9. Setelah diperoleh batas bawah dan batas atas yang baru, ulangi langkah ke-3,
hingga diperoleh
2
( ) z n error ÷ s , yaitu bahwa selisih antara nilai perkiraan
dengan nilai sebenarnya tidaklah lebih besar dari besarnya kesalahan yang
diperbolehkan (dalam hal ini adalah ketelitian).
10. Nilai tengah inilah yang merupakan nilai perkiraan untuk y dengan nilai
kesalahan maksimumnya adalah sebesar error.
Dari teori di atas, buatlah algoritma untuk mengestimasi nilai y n = dengan
tingkat kesalahan sebesar error. Nilai n dan error diinput dari user.
Analisis:
Input: nilai n dan besarnya error. (dalam hal ini, n haruslah tidak negatif!)
output: nilai perkiraan n , yaitu tengah
Langkah pengerjaan: pelajarilah flowchart berikut ini.

68

START
Input
N, ERROR
Atas  n
Bawah  0
Tengah  (atas + bawah) / 2
z < n ? Bawah  tengah Atas  tengah
Abs(z – n) <= error*error
Z  tengah * tengah
TRUE FALSE
FALSE
Output
tengah
TRUE
END


69
01| Algoritma Estimasi_Nilai_Akar
02| {Diberikan nilai n dan besarnya error. Algoritma menghitung nilai
perkiraan dari akar kuadrat n dengan tingkat kesalahan tidak
melebihi besarnya error.}
03| Deklarasi:
04| n, error : real
05| atas, bawah, tengah : real
06| z : real
07| Deskripsi
08| read(n, error)
09| atas  n
10| bawah  0
11| repeat
12| tengah  (atas + bawah)/2
13| z  tengah * tengah
14| if z < n then {nilai perkiraan terlalu kecil}
15| bawah  tengah
16| else {nilai perkiraan terlalu besar}
17| atas  tengah
18| end if
19| until abs(z-n) <= error*error
20| write(tengah)
4. Algoritma Menentukan Prima (Perbaikan)
Perhatikan potongan algoritma berikut ini:
01| Prima  TRUE
02| For k  2 to n-1 do
03| If n mod k = 0 then
04| Prima  FALSE
05| End if
06| End for
Potongan algoritma di atas menggambarkan cara menentukan apakah bilangan n
adalah prima atau bukan. Tekniknya adalah dengan mencari apakah bilangan n
mempunyai faktor yang terletak mulai dari 2 hingga n-1.
Namun teknik yang dipakai di atas mempunyai 2 kelemahan, yaitu (1) algoritma
terus memproses mencari faktor berikutnya walaupun sudah ditemukan suatu faktor
(bila ditemukan faktor, bilangan n sudah pasti bukanlah prima) dan (2) batas
penentuan faktor hingga n-1 dapat digantikan menjadi n (karena suatu faktor dari n

70
yang terletak mulai dari 1 hingga n selalu mempunyai pasangan faktor dari n yang
terletak mulai dari 1 n + hingga n. Itulah sebabnya bila n tidak mempunyai faktor
yang terletak mulai dari 2 hingga n , maka dapat disimpulkan n tidak mempunyai
faktor pula yang terletak mulai dari 1 n + hingga n-1).
Berdasarkan penjelasan di atas, maka potongan algoritma di atas harus
mempunyai 2 perbaikan, yaitu (1) algoritma harus bisa berhenti mencari faktor apabila
sudah didapatkan bahwa n bukan bilangan prima, dan (2) batas pencarian hanya mulai
dari 2 hingga n .
01| Algoritma Prima_Perbaikan
02| {Menentukan apakah bilangan n yang diinputkan user merupakan
bilangan prima atau bukan}
03| Deklarasi:
04| Prima : boolean
05| k,n : integer
06| Deskripsi
07| read(n)
08| x  sqrt(n) {x = akar kuadrat dari n}
09| k  2
10| prima  TRUE
11| While prima and (k <= x) do
12| if n mod k = 0 then
13| prima  FALSE
14| else
15| k  k + 1
16| end if
17| end while
18| if prima then
19| write(„PRIMA‟)
20| else
21| write(„Bukan PRIMA‟)
22| end if

71
D. Latihan
1. Buatlah algoritma untuk menghitung banyaknya bilangan prima yang kurang dari
sama dengan bilangan bulat n dengan bilangan n diinput oleh user.
2. Menurut anda, dapatkan algoritma menentukan bilangan prima tersebut di atas
dirubah sehingga menggunakan struktur REPEAT? Mana yang lebih cocok,
menggunakan struktur REPEAT atau menggunakan struktur WHILE?
3. Buatlah algoritma untuk mencetak pola bilangan-bilangan berikut:
a. 1, 3, 5, 7, 9, ... sebanyak n suku, yaitu barisan bilangan ganjil
b. 1, 1, 2, 3, 5, 8, ... sebanyak n suku, yaitu barisan fibonacci.
c. barisan fibonacci yang kurang dari sama dengan n
d. 1
1, 2
1, 2, 3
...
1, 2, 3, ..., n
e. 1, 2, 3, ..., n-1, n
1, 2, 3, ..., n-1
...
1, 2, 3
1, 2
1
f. 1, 2
1, 2, 1, 3
1, 2, 1, 3, 1, 4
...
1, 2, 1, 3, 1, 4, ... 1, n+1
4. Diberikan dua buah bilangan bulat a dan b. Bilangan a dan b dikatakan saling
prima apabila faktor persekutuan terbesar (FPB)-nya adalah 1. Sebagai contoh,
bilangan 4 dan 6 tidak saling prima karena FPB-nya adalah 2. Bilangan 4 dan 9
saling prima karena FPB-nya adalah 1. Buatlah algoritma untuk menentukan
apakah bilangan bulat a dan b yang diinput oleh user tersebut saling prima atau
tidak saling prima. (Catatan: bahasa Inggris dari FPB adalah GCD, yaitu Greatest
Common Divisor).
5. Buatlah algoritma untuk mencetak bilangan prima terkecil yang lebih besar atau
sama dengan bilangan bulat n yang diinput oleh user.
6. Buatlah algoritma untuk menentukan estimasi akar pangkat tiga dari bilangan
bulat n yang diinput oleh user dengan menggunakan metode seperti pada algoritma
BAB V : bagian C. nomor 3. halaman 67 di atas.
7. Buatlah algoritma untuk meminta user menginputkan banyaknya barang dan harga
secara terus menerus hingga user menginputkan nol untuk banyaknya barang,
kemudian algoritma akan mencetak total harga dari barang-barang tersebut.


72
BAB VI : ARRAY (LARIK)
A. Pendahuluan
1. Pengertian
Array atau larik (bahasa Indonesia) yaitu suatu tipe data terstruktur yang dapat
menyimpan lebih dari satu data yang bertipe sama. Selama ini, tipe data yang kita
pelajari merupakan tipe data sederhana, yaitu tipe data yang hanya dapat menyimpan
satu data dalam satu variabel. Tipe-tipe sederhana yang telah kita pelajari yaitu
integer, real, char, string, dan boolean (keterangan: tipe data string pada beberapa
bahasa pemrograman tidak termasuk tipe data sederhana. Antara suatu bahasa
pemrograman dengan bahasa pemrograman lainnya mendefinisikan tipe string dengan
caranya tersendiri).
Dengan menggunakan array, kita dapat menyimpan sekumpulan data yang bertipe
sama hanya dalam satu variabel. Kelebihannya adalah sekumpulan data tersebut akan
lebih mudah diolah maupun dimanipulasi. Kelebihan lainnya adalah algoritma
maupun program komputer yang dihasilkan akan lebih terstruktur dan memudahkan
untuk dikembangkan.
2. Cara Pendeklarasian
Bentuk Penulisan Umumnya adalah
ARRAY[indeks] OF tipe_elemen
Contoh Pendeklarasian:
Deklarasi:
data : array[1..10] of real

Deklarasi:
const max = 10
type Tdata = real
type Tlarik = array[1..max] of Tdata
data : Tlarik
Pendeklarasian variabel data di atas adalah sama, hanya saja bentuk
pendeklarasian yang ke-dua walaupun lebih panjang, namun lebih terstruktur. Dalam
hal ini, variabel data dikatakan mempunyai indeks dari 1 sampai 10, sehingga
variabel data dapat menyimpan maksimal 10 data bertipe real.
Variabel data tersebut dapat digambarkan sebagai berikut:


73
Masing-masing dari kotak tersebut dapat digunakan untuk menyimpan data bertipe
real.
Contoh lain pendeklarasian variabel array:
Deklarasi:
const max = 10
type Tdata = integer
type Tlarik = array[‘A’..’E’] of Tdata
data : Tlarik
Variabel data di atas dapat digambarkan sebagai berikut:

Masing-masing dari kotak tersebut dapat digunakan untuk menyimpan data bertipe
integer. Perhatikan bahwa indeksnya sekarang bertipe char.
Hal yang harus diperhatikan dalam mendeklarasikan variabel array:
1. Indeks hanya boleh bertipe integer, char, atau boolean. Untuk indeks bertipe char
dan boolean jarang digunakan. Namun nantinya kita akan melihat contoh
pemakaian variabel array berindeks char maupun boolean.
2. Indeks harus berupa jangkauan dari kecil ke besar, misalnya jangkauan 5..1
tidaklah diperbolehkan. Bila berupa char, maka urutan indeks berdasarkan pada
tabel ASCII. Apabila bertipe boolean, maka urutannya adalah FALSE..TRUE.
3. Besarnya variabel array (jangkauannya) harus sudah ditentukan secara pasti dalam
bagian deklarasi. Dengan demikian, jangkauan indeks tidak boleh mengandung
variabel, namun pemakaian konstanta (const) diperbolehkan. Dalam
pemrograman, array yang besarnya telah ditentukan dinamakan array statis.
Beberapa bahasa pemrograman modern mengijinkan pendeklarasian array dengan
besar (panjang) array yang bebas, yang dapat ditentukan saat program atau
algoritma berjalan. Array yang demikian dinamakan array dinamis. Mengenai
array dinamis tidak akan dipelajari dalam algoritma ini karena pada dasarnya
mempunyai teknik (cara) yang sama dengan array statis.
4. Tipe elemen dapat bertipe apapun, termasuk bertipe array pula. Apabila elemen
bertipe array, maka array dikatakan berdimensi dua atau lebih. Mengenai array
berdimensi n akan dipelajari dalam pembahasan mendatang.
5. Jangan mendeklarasikan array yang terlalu besar yang melebihi keperluan, karena
memori komputer terbatas.
3. Cara Pemakaian Array
Misalkan dideklarasikan variabel data seperti berikut:
Deklarasi:
const max = 5
type Tdata = integer
type Tlarik = array[1..max] of Tdata
data : Tlarik

74
Maka cara mengisikan nilai ke dalam variabel data adalah:
Deskripsi
data[1]  5 {mengisikan nilai 5 ke data berindeks 1}
data[2]  3 {mengisikan nilai 3 ke data berindeks 2}
data[6]  7 {tidak boleh karena tidak ada indeks 6}
write(data[3]) {tidak boleh karena data indeks 3 belum ada nilai}
read(data[3]) {meminta user input data integer ke indeks 3}
write(data) {salah, karena tidak menyebutkan indeks}
read(data) {salah, karena tidak menyebutkan indeks}
data[4]data[1]+data[2] {jumlah indeks 1&2 dimasukkan ke indeks 4}
Kelebihan penggunaan array dibanding tipe data sederhana:
Deklarasi:
a1,a2,a3,a4,a5 : integer
Deskripsi
a1  0
a2  0
a3  0
a4  0
a5  0

Deklarasi:
a : array[1..5] of integer
k : integer
Deskripsi
for k  1 to 5 do
a[k]  0
end for
Perhatikan bahwa penggunaan tipe array akan lebih membuat algoritma nampak
terstruktur dan memudahkan kita untuk mengembangkan algoritma. Misalkan contoh
di atas hendak dikembangkan untuk 100 data integer, bagaimana algoritmanya
menggunakan tipe data sederhana? Tentu akan menjadi sangat panjang dan tidak
terstruktur.
B. Array 1 Dimensi
1. Algoritma Menghitung Rata-rata
Buatlah algoritma untuk menginput n buah data integer, kemudian algoritma akan
menghitung rata-ratanya.

75
Analisis:
Kali ini kita akan memakai variabel array untuk menyimpan n buah data yang diinput
kemudian perhitungan rata-ratanya dihitung secara terpisah.
Masalahnya adalah, berapa besar variabel array harus kita alokasikan (sediakan)?
Berdasarkan penjelasan mengenai array, besarnya array sudah harus ditentukan
sebelum algoritma berjalan. Maka dari itu, kita (pembuat algoritma) menyediakan
tempat yang secukupnya agar algoritma dapat mengakomodir sebagian besar masalah.
01| Algoritma Hitung_Rata_Rata
02| {Menginput n buah data integer ke dalam array, kemudian menghitung
rata-ratanya secara terpisah}
03| Deklarasi:
04| const max = 30
05| type Tdata = integer
06| type Tlarik = array[1..max] of Tdata
07| data : Tlarik
08| k, n : integer {mengapa bukan Tdata?}
09| jumlah : Tdata {mengapa bukan integer?}
10| rata : real
11| Deskripsi
12| read(n) {input banyaknya data, maksimal max}
13| {input n buah data ke dalam array}
14| for k  1 to n do
15| read(data[k])
16| end for
17| {menghitung jumlah}
18| jumlah  0
19| for k  1 to n do
20| jumlah  jumlah + data[k]
21| end for
22| {menghitung rata-rata}
23| rata  jumlah / n
24| write(rata)
2. Algoritma Menentukan Terbesar
Buatlah algoritma untuk menentukan terbesar dari n buah data integer yang
diinput user.
Analisis:
Dalam hal ini, algoritma sama dengan algoritma sebelumnya, hanya saja kali ini bukan
menghitung rata-rata, tetapi menentukan terbesar dari n data. Oleh karena itu, hanya

76
bagian menghitung jumlah dan rata-rata yang kita ganti karena tidak diperlukan dalam
menentukan terbesar.
Untuk menentukan terbesar, kita memakai teknik yang sudah pernah kita pelajari,
yaitu mengasumsikan data pertama merupakan yang terbesar, kemudian
membandingkannya satu-persatu dengan data berikut hingga data terakhir.
01| Algoritma Menentukan_Terbesar
02| Deklarasi:
03| const max = 30
04| type Tdata = integer
05| type Tlarik = array[1..max] of Tdata
06| data : TLarik
07| k,n : integer
08| terbesar : Tdata
09| Deskripsi
10| read(n)
11| for k  1 to n do
12| read(data[k])
13| end for
14| {menentukan terbesar}
15| terbesar  data[1] {asumsi data pertama adalah yg terbesar}
16| {membandingkan dengan data berikut hingga data terakhir}
17| for k  2 to n do
18| if data[k] > terbesar then
19| terbesar  data[k]
20| end if
21| end for
22| write(Terbesar)

Dalam hal ini, kita menyimpan nilai terbesarnya. Teknik ini memiliki kelemahan,
karena algoritma tidak dapat memberikan informasi data indeks ke berapakah yang
terbesar itu? Oleh karena itu, kita dapat menggunakan teknik lain, yaitu tidak
menyimpan nilai terbesarnya, tetapi menyimpan indeks dari data yang terbesar.

77
01| Algoritma Menentukan_Terbesar_Indeks
02| {Menginput n buah data integer, kemudian mencari indeks data
terbesarnya. algoritma tetap menampilkan nilai terbesarnya}
03| Deklarasi:
04| const max = 30
05| type Tdata = integer
06| type Tlarik = array[1..max] of Tdata
07| data : Tlarik
08| k, n : integer
09| t : integer {menyimpan indeks data terbesar}
10| Deskripsi
11| read(n)
12| for k  1 to n do
13| read(data[k])
14| end for
15| {asumsi data pertama yg terbesar, maka simpan indeks 1}
16| t  1
17| {membandingkan data ke-t dengan data berikut hingga terakhir}
18| for k  2 to n do
19| if data[k] > data[t] then
20| t  k
21| end if
22| end for
23| {mencetak nilai terbesar berarti mencetak data ke-t}
24| write(data[t])
3. Algoritma Menentukan Nama Mahasiswa Nilai Tertinggi
Buatlah algoritma untuk menginputkan n buah nama dan nilai mahasiswa.
Kemudian algoritma akan menampilkan nama dan nilai mahasiswa tertinggi.
Analisis:
Kita dapat memakai teknik menyimpan nama sekaligus nilai tertinggi seperti berikut:
01| Algoritma Menentukan_Nilai_Tertinggi
02| {menginput n data nama dan nilai, cetak nama dan nilai tertinggi}
03| Deklarasi
04| const max = 30
05| type TNama = string
06| type TNilai = real
07| type TLarikNama = array[1..max] of TNama

78
08| type TLarikNilai = array[1..max] of TNilai
09| nama : TLarikNama
10| nilai : TLarikNilai
11| k, n : integer
12| namat : TNama {menyimpan nama yg tertinggi}
13| nilait : TNilai {menyimpan nilai yg tertinggi}
14| Deskripsi
15| read(n)
16| for k  1 to n do
17| read(nama[k], nilai[k])
18| end for
19| {asumsi data pertama adalah yg tertinggi}
20| namat  nama[1]
21| nilait  nilai[1]
22| {bandingkan nilait dengan nilai berikut hingga terakhir}
23| for k  2 to n do
24| if nilai[k] > nilait then
25| namat  nama[k]
26| nilait  nilai[k]
27| end if
28| end for
29| Write(namat, nilait)
Namun algoritma di atas memerlukan 2 variabel untuk menyimpan tertingginya.
Algoritma berikut hanya memerlukan 1 variabel yang digunakan untuk menyimpan
indeks nilai tertingginya.
01| Algoritma Menentukan_Nilai_Tertinggi
02| {menginput n data nama dan nilai, cetak nama dan nilai tertinggi}
03| Deklarasi
04| const max = 30
05| type TNama = string
06| type TNilai = real
07| type TLarikNama = array[1..max] of TNama
08| type TLarikNilai = array[1..max] of TNilai
09| nama : TLarikNama
10| nilai : TLarikNilai
11| k, n : integer
12| t : integer {menyimpan indeks nilai yg tertinggi}

79
13| Deskripsi
14| read(n)
15| for k  1 to n do
16| read(nama[k], nilai[k])
17| end for
18| {asumsi data pertama adalah yg tertinggi}
19| t  1
20| {Bandingkan nilai ke-t dengan nilai berikut hingga terakhir}
21| for k  2 to n do
22| if nilai[k] > nilai[t] then
23| t  k
24| end if
25| end for
26| {mencetak nama dan nilai tertinggi}
27| write(nama[t], nilai[t])
Nah, manakah teknik yang lebih baik menurut anda?
4. Algoritma Menghitung Jumlah Kelulusan
Diinputkan n buah data nilai mahasiswa. Apabila nilai minimum kelulusan adalah
60.00, buatlah algoritma untuk menampilkan banyaknya yang lulus dan yang tidak
lulus.
Analisis:
Algoritma ini termasuk mudah. Kita deklarasikan 2 variabel bertipe integer untuk
menyimpan banyaknya mahasiswa yang lulus dan yang tidak lulus, kemudian
tambahkanlah angka 1 ke variabel yang berkesesuaian dengan nilai yang diperoleh
mahasiswa.
01| Algoritma Jumlah_Kelulusan
02| {menginputkan n buah data nilai mahasiswa, kemudian menghitung
banyaknya yang lulus dan yang tidak lulus}
03| Deklarasi:
04| const max = 50
05| type TNilai = real
06| type TLarik = array[1..max] of TNilai
07| nilai : TLarik
08| k,n : integer
09| nLulus, nTLulus : integer {menyimpan jumlah kelulusan}
10| Deskripsi
11| read(n)
12| for k  1 to n do

80
13| read(nilai[k])
14| end for
15| {memberikan nilai awal}
16| nLulus  0
17| nTLulus  0
18| for k  1 to n do
19| if nilai[k] >= 60.00 then
20| nLulus  nLulus + 1
21| else
22| nTLulus  nTLulus + 1
23| end if
24| end for
25| write(nLulus, nTLulus)
Algoritma di atas juga dapat diselesaikan dengan menggunakan array dengan
indeks bertipe boolean. Deklarasikan sebuah variabel bertipe array dengan indeks
bertipe boolean (true atau false) dan tipe elemennya adalah integer untuk menyimpan
jumlah kelulusan. Bagian berindeks false untuk menyimpan jumlah mahasiswa yang
tidak lulus, sedangkan bagian berindeks true untuk menyimpan jumlah mahasiswa
yang lulus.
01| Algoritma Jumlah_Kelulusan
02| {menginputkan n buah data nilai mahasiswa kemudian menghitung
jumlah mahasiswa yang lulus maupun yang tidak lulus}
03| Deklarasi:
04| const max = 50
05| type TNilai = real
06| type TLarik = array[1..max] of TNilai
07| nilai : TLarik
08| nLulus : array[False..True] of integer
09| k,n : integer
10| Deskripsi
11| read(n)
12| for k  1 to n do
13| read(nilai[k])
14| end for
15| {memberikan nilai awal}
16| nLulus[True]  0
17| nLulus[False]  0
18| {menghitung banyaknya kelulusan}

81
19| for k  1 to n do
20| if nilai[k] >= 60 then
21| nLulus[True]  nLulus[True] + 1
22| else
23| nLulus[False]  nLulus[False] + 1
24| end if
25| end for
26| write(nLulus[True],nLulus[False])
Perhatikan baris ke-21 dan baris ke-23. Baris ke-21 hanya dikerjakan apabila
kondisi “nilai[k] >= 60” bernilai TRUE. Baris ke-23 hanya dikerjakan apabila kondisi
“nilai[k] >= 60” bernilai FALSE. Dengan kata lain, nilai dari indeks nLulus bernilai
yang sama dengan kondisi if baris ke-20. Oleh karena itu, masuk akal apabila kita
mengganti baris ke-20 hingga baris ke-24 dengan potongan algoritma berikut
nLulus[nilai[k] >= 60]  nLulus[nilai[k] >= 60] + 1
Mungkin anda mengalami kebingungan. Ide dasar dari teknik ini adalah substitusi
nilai TRUE atau FALSE yang dihasilkan oleh kondisi “nilai[k] >= 60” ke dalam
indeks dari variabel nLulus sehingga yang bertambah adalah nilai variabel nLulus
yang indeksnya bersesuaian dengan kondisi. Untuk lebih jelasnya kita akan memakai
sekali lagi teknik ini dalam algoritma berikutnya.
5. Algoritma Rekapitulasi Grade
Buat algoritma menginput n buah nilai mahasiswa. Kemudian algoritma
menentukan grade (A sampai E) masing-masing mahasiswa, lalu algoritma mampu
mencetak banyaknya mahasiswa untuk masing-masing grade.
Analisis:
Tekniknya sama dengan algoritma sebelumnya, yaitu mendeklarasikan lima buah
variabel untuk menyimpan banyaknya mahasiswa untuk masing-masing grade,
kemudian menambahkan angka 1 sesuai dengan grade yang diperoleh mahasiswa.
01| Algoritma Rekapitulasi_Grade
02| {menginput n buah nilai, menentukan grade, kemudian menghitung
banyaknya mahasiswa untuk masing-masing grade}
03| Deklarasi:
04| const max = 50
05| type TNilai = real
06| type TGrade = char
07| type TLarikNilai = array[1..max] of TNilai
08| type TLarikGrade = array[1..max] of TGrade
09| nilai : TLarikNilai
10| grade : TLarikGrade
11| na, nb, nc, nd, ne : integer {menyimpan masing2 grade}

82
12| k, n : integer
13| Deskripsi
14| read(n)
15| for k  1 to n do
16| read(nilai[k])
17| end for
18| {menentukan grade untuk masing-masing mahasiswa}
19| for k  1 to n do
20| if nilai[k] >= 80.0 then
21| grade[k]  „A‟
22| else
23| if nilai[k] >= 70.0 then
24| grade[k]  „B‟
25| else
26| if nilai[k] >= 60.0 then
27| grade[k]  „C‟
28| else
29| if nilai[k] >= 40.0 then
30| grade[k]  „D‟
31| else
32| grade[k]  „E‟
33| end if
34| end if
35| end if
36| end if
37| end for
38| {memberikan nilai awal}
39| na  0
40| nb  0
41| nc  0
42| nd  0
43| ne  0
44| {Menentukan banyaknya mhs untuk masing2 grade}
45| for k  1 to n do
46| if grade[k] = ‘A’ then
47| na  na + 1
48| else

83
49| if grade[k] = ‘B’ then
50| nb  nb + 1
51| else
52| if grade[k] = ‘C’ then
53| nc  nc + 1
54| else
55| if grade[k] = ‘D’ then
56| nd  nd + 1
57| else
58| ne  ne + 1
59| end if
60| end if
61| end if
62| end if
63| end for
64| write(na,nb,nc,nd,ne)

Bandingkan algoritma di atas dengan algoritma di bawah ini:
01| Algoritma Rekapitulasi_Grade
02| {menginput n buah nilai, menentukan grade, kemudian menghitung
banyaknya mahasiswa untuk masing-masing grade}
03| Deklarasi:
04| const max = 50
05| type TNilai = real
06| type TGrade = char
07| type TLarikNilai = array[1..max] of TNilai
08| type TLarikGrade = array[1..max] of TGrade
09| nilai : TLarikNilai
10| grade : TLarikGrade
11| nGrade : array[„A‟..‟E‟] of integer {menyimpan masing2 grade}
12| k, n : integer
13| m : char {pencacah bertipe char}
14| Deskripsi
15| read(n)
16| for k  1 to n do
17| read(nilai[k])
18| end for

84
19| {menentukan grade untuk masing-masing mahasiswa}
20| for k  1 to n do
21| if nilai[k] >= 80.0 then
22| grade[k]  „A‟
23| else
24| if nilai[k] >= 70.0 then
25| grade[k]  „B‟
26| else
27| if nilai[k] >= 60.0 then
28| grade[k]  „C‟
29| else
30| if nilai[k] >= 40.0 then
31| grade[k]  „D‟
32| else
33| grade[k]  „E‟
34| end if
35| end if
36| end if
37| end if
38| end for
39| {memberikan nilai awal}
40| for m  ‘A’ to ‘E’ do
41| nGrade[m]  0
42| end for
43| {menentukan banyaknya mahasiswa untuk masing2 grade}
44| for k  1 to n do
45| nGrade[grade[k]]  nGrade[grade[k]] + 1
46| end for
47| for m  „A‟ to „E‟ do
48| write(nGrade[m])
49| end for
Manakah yang lebih baik menurut anda?
C. Metode Pencarian
Diberikan sekumpulan data dalam suatu variabel array. Andaikan user hendak
menemukan suatu data tertentu dari sekumpulan data tersebut. Informasi yang
diinginkan user yaitu pada indeks ke berapakah data ditemukan bila ada, dan informasi
bahwa data tidak ditemukan bila data yang dicari tidak terdapat dalam sekumpulan

85
data tersebut. Terdapat beberapa metode yang bisa dipakai untuk memecahkan
masalah tersebut, diantaranya adalah metode sekuensial dan metode biner.
1. Metode Sekuensial
Metode ini adalah membandingkan data yang hendak dicari dengan data pertama
hingga data ditemukan atau data terakhir. Bila sudah membandingkan dengan data
terakhir dan masih belum sama dengan yang hendak dicari, berarti data sudah tidak
mungkin ditemukan.
Dalam algoritma yang kita buat, dideklarasikan suatu variabel boolean yang
bernilai true bila data ditemukan dan bernilai false bila data tidak ditemukan.
Langkah-langkah pengerjaan:
Misalkan data yang hendak dicari adalah x
1. bandingkan x dengan data ke-1
2. ulangi langkah pertama untuk data berikutnya hingga data terakhir atau data sudah
ditemukan.
01| Algoritma Pencarian_Metode_Sekuensial
02| {Diinputkan n buah data bilangan bulat, kemudian user menginputkan
data yang hendak dicari. Algoritma mencetak indeks data jika
ditemukan, atau mencetak informasi bila data tidak ditemukan}
03| Deklarasi:
04| const max = 50
05| type TData = integer
06| type TLarik = array[1..max] of TData
07| data : TLarik
08| x : TData {menyimpan data yang hendak dicari}
09| k, n : integer
10| ketemu : booelan {menyimpan apakah data ditemukan atau tidak}
11| Deskripsi
12| read(n)
13| for k  1 to n do
14| read(data[k])
15| end for
16| {meminta input dari user data yang hendak dicari}
17| read(x)
18| {pemberian nilai awal}
19| ketemu  FALSE
20| k  1 {mulai dari data ke-1}
21| {secara berulang, bandingkan dengan data yg hendak dicari}
22| repeat
23| if x = data[k] then {jika sama, berarti sudah ditemukan}

86
24| ketemu  TRUE
25| else
26| k  k + 1 {cari untuk data berikutnya}
27| end if
28| until ketemu or (k>n) {hingga data ditemukan atau data habis}
29| {mencetak informasi}
30| if ketemu then
31| write(k) {mencetak posisi data ditemukan}
32| else
33| write(„Data tidak ditemukan‟)
34| end if

Sebenarnya algoritma di atas dapat diperbaiki, yaitu dengan menghilangkan
variabel ketemu. Tekniknya adalah menggunakan nilai k sebagai acuan. Bila nilai
k n > berarti data tidak ditemukan karena variabel k merupakan penunjuk posisi data
ditemukan. Algoritma selengkapnya disajikan berikut ini.
01| Algoritma Pencarian_Metode_Sekuensial
02| {Diinputkan n buah data bilangan bulat, kemudian user menginputkan
data yang hendak dicari. Algoritma mencetak indeks data jika
ditemukan, atau mencetak informasi bila data tidak ditemukan}
03| Deklarasi:
04| const max = 50
05| type TData = integer
06| type TLarik = array[1..max] of TData
07| data : TLarik
08| x : TData {menyimpan data yang hendak dicari}
09| k, n : integer
10| Deskripsi
11| read(n)
12| for k  1 to n do
13| read(data[k])
14| end for
15| {meminta input dari user data yang hendak dicari}
16| read(x)
17| {pemberian nilai awal}
18| k  0 {mengapa kali ini diberi nilai awal 0?}
19| repeat
20| k  k + 1

87
21| until (k > n) or (x = data[k])
22| {mencetak informasi}
23| if k > n then
24| write(„data tidak ditemukan‟)
25| else
26| write(k) {mencetak posisi indeks data ditemukan}
27| end if
Menurut anda, manakah yang lebih baik? Manakah yang lebih mudah dipahami?
2. Metode Biner
Metode ini memerlukan syarat bahwa data hanya bisa dicari pada sekumpulan
data yang terurut. Oleh karena itu, sebelum dilakukan pencarian, data sudah harus
dalam keadaan terurut.
Dalam algoritma ini, setelah user melakukan pengisian n buah data, data
kemudian diurutkan dengan menggunakan metode bubble (gelembung) secara
ascending (dari kecil ke besar). Mengenai metode pengurutan akan dibahas secara
tersendiri dalam sub bab berikutnya.
Perlu diketahui bahwa apabila data terurut secara descending (dari besar ke
kecil), maka metode perlu dirubah sedikit. Hal ini akan menjadi soal latihan buat anda.
Ide dasarnya adalah seperti seseorang mencari suatu kata dalam kamus. Pertama-
tama, orang akan membuka pertengahan dari kamus, kemudian melihat apakah ada
kata yang dicari di pertengahan tersebut. Apabila tidak ditemukan, maka orang akan
mencari ke belakang, atau ke depan, sesuai dengan kondisi apakah kata yang dicari
berada di urutan yang lebih kecil atau yang lebih besar dari kata yang ada di tengah
kamus tersebut. Orang tersebut akan mengulangi membuka pertengahan sisanya,
kemudian mencari di pertengahan tersebut, dan seterusnya hingga kata ditemukan atau
mungkin saja kata tersebut tidak berada dalam kamus tersebut.
Berdasarkan hal di atas, dalam algoritma, kita mendeklarasikan 2 variabel, yaitu
awal dan akhir, yang berfungsi sebagai penyimpan indeks batas pencarian, serta
sebuah variabel tengah, yang berfungsi sebagai indeks yang hendak dibandingkan
dengan data cari.
Langkah-langkah pencariannya adalah sebagai berikut:
Misalkan n adalah banyaknya data, x adalah data yang hendak dicari.
1. Tentukan batas awal dan batas akhir pencarian, yaitu dari data 1 s/d n
awal  1 dan akhir  n
2. Hitung nilai tengah yaitu
tengah  (awal + akhir) div 2
Terdapat 3 partisi, yaitu data (awal s/d tengah-1); (tengah); (tengah+1 s/d akhir)
3. Bandingkan x dengan data[tengah].
Bila sama, berarti data ditemukan. Algoritma selesai.
Bila x < data[tengah] berarti pencarian dilakukan untuk data awal s/d tengah–1,
yaitu batas akhir pencarian diubah menjadi tengah-1
akhir  tengah – 1
Bila x > data[tengah] berarti pencarian dilakukan untuk data tengah+1 s/d akhir,

88
yaitu batas awal pencarian diubah menjadi tengah+1
awal  tengah + 1
4. Ulangi mengerjakan langkah 2 hingga data ditemukan atau batas awal lebih
besar dari batas akhir.
01| Algoritma Pencarian_Metode_Biner
02| {Menginputkan n data integer, lalu mengurutkannya menggunakan
metode bubble secara ascending. Kemudian algoritma menanyakan user
data yang hendak dicari, lalu menerapkan metode biner untuk
melakukan pencarian. Bila ditemukan, maka algoritma mencetak
posisi indeks data ditemukan}
03| Deklarasi:
04| const max = 50
05| type TData = integer
06| type TLarik = array[1..max] of TData
07| data : TLarik
08| k, n, m : integer
09| x : TData {menyimpan data yang hendak di cari}
10| awal, akhir, tengah : integer {menyimpan indeks}
11| ketemu : boolean
12| temp : TData
13| Deskripsi
14| read(n)
15| for k  1 to n do
16| read(data[k])
17| end for
18| {mengurutkan data secara ascending metode bubble}
19| for k  1 to n-1 do
20| for m  k + 1 to n do
21| if data[m] > data[k] then
22| temp  data[m]
23| data[m]  data[k]
24| data[k]  temp
25| end if
26| end for
27| end for
28| {menanyakan user data yang hendak dicari}
29| read(x)
30| {memberikan nilai awal}
31| ketemu  False

89
32| awal  1
33| akhir  n
34| {menerapkan langkah 2 hingga 4}
35| repeat
36| tengah  (awal + akhir) div 2
37| if x = data[tengah] then
38| ketemu  True
39| else
40| if x < data[tengah] then
41| akhir  tengah – 1
42| else
43| awal  tengah + 1
44| end if
45| end if
46| until ketemu or (awal > akhir)
47| {mencetak informasi}
48| if ketemu then
49| write(tengah) {mencetak indeks posisi data ditemukan}
50| else
51| write(„data tidak ditemukan‟)
52| end if
D. Metode Pengurutan
Pengurutan adalah menyusun kembali sekumpulan data yang ada sehingga data
tersebut menjadi urut. Berdasarkan urutannya, maka pengurutan ada 2 jenis, yaitu
pengurutan ascending, yaitu urutan menaik dari kecil ke besar; dan pengurutan
descending, yaitu urutan menurun dari besar ke kecil.
Metode yang digunakan untuk mengurutkan data disebut metode pengurutan.
Terdapat banyak sekali metode pengurutan, namun dalam tulisan ini hanya
dibicarakan 3 metode, yaitu metode bubble (gelembung), selection (seleksi), dan
insertion (penyisipan). Metode ini yang kita pelajari karena metode ini merupakan
metode yang mudah dipelajari dan mendasar. Dalam tulisan ini, semua metode yang
disajikan adalah metode pengurutan secara ascending. Mengenai metode
pengurutan descending diserahkan pada pembaca sebagai latihan.

90
1. Metode Pengurutan Bubble (Bubble Sort)
Ide dasar dari metode ini adalah
1. membawa data terkecil dari data ke-1 s/d ke-n menjadi data[1]
2. membawa data terkecil dari data ke-2 s/d ke-n menjadi data[2]
3. ...
4. membawa data terkecil dari data ke-(n-1) s/d ke-n menjadi data[n-1]

Untuk melakukan langkah pertama dilakukan dengan cara berikut:
1. bandingkan data ke-1 dengan data ke-2, jika data[1] > data[2], maka tukar.
2. bandingkan data ke-1 dengan data ke-3, jika data[1] > data[3], maka tukar.
3. ...
4. bandingkan data ke-1 dengan data ke-n, jika data[1] > data[n], maka tukar.
Setelah melakukan langkah ini, maka data[1] merupakan data terkecil dari data
ke-1 s/d data ke-n.

Untuk melakukan langkah ke-2 dilakukan dengan cara berikut:
1. bandingkan data ke-2 dengan data ke-3, jika data[2] > data[3], maka tukar.
2. bandingkan data ke-2 dengan data ke-4, jika data[2] > data[4], maka tukar.
3. ...
4. bandingkan data ke-2 dengan data ke-n, jika data[2] > data[n], maka tukar.
Setelah melakukan langkah ini, maka data[2] merupakan data terkecil dari data
ke-2 s/d data ke-n.

Lakukan langkah ke-3 dengan pola yang sama hingga langkah ke-(n-1). Maka
data akan terurut secara ascending

Perhatikan bahwa langkah-langkah di atas dapat disimpulkan menjadi berikut:
1. Untuk k = 1, lakukan
a. jika data[1] > data[2], maka tukar
b. jika data[1] > data[3], maka tukar
c. ...
d. jika data[1] > data[n], maka tukar
2. Untuk k = 2, lakukan
a. Jika data[2] > data[3], maka tukar
b. Jika data[2] > data[4], maka tukar
c. ...
d. Jika data[2] > data[n], maka tukar
3. ...
4. Untuk k = n-1, lakukan
a. Jika data[n-1] > data[n], maka tukar

Perhatikan bahwa untuk masing-masing nilai k, kita melakukan proses
perbandingan data[k] dengan data[m] dengan nilai m adalah dari k+1 s/d n.

91
Perhatikan contoh berikut ini:
Misalkan kita mempunyai data berikut: 2, 7, 3, 1, 5, 4
Keterangan | data ke- 1 2 3 4 5 6
Data awal 3 1 5 4
Tukar data[1], data[2] 2 1 5 4
Tukar data[1], data[3] 2 7 5 4
Tukar data[1], data[4] 2 7 3 4
Tetap 2 7 3 5
Tetap 2 7 3 5 4
Data ke-1 s/d ke-1
sudah urut.

Untuk sisanya 7 3 5 4
Data ke-1 s/d ke-2
sudah urut

Untuk sisanya 5 4
Tukar data[3], data[4] 7 4
Tetap 7 5
Tetap 7 5 4
Data ke-1 s/d ke-3
sudah urut

Untuk sisanya 4
Tukar data[4], data[5] 7
Tukar data[4], data[6] 7 5
Data ke-1 s/d ke-4
sudah urut

Untuk sisanya
Tukar data[5],data[6]
Data sudah urut

Algoritmanya adalah sebagai berikut:
01| Algoritma Pengurutan_Bubble
02| {menginput n buah data kemudian mengurutkannya secara ascending
menggunakan metode bubble}
03| Deklarasi:
04| const max = 50
05| type Tdata = integer
06| type TLarik = array[1..max] of TData
07| data : TLarik
08| temp : TData {Temporary untuk menyimpan data yg hendak ditukar}
09| k, m, n : integer
10| Deskripsi
11| read(n)
12| for k  1 to n do

92
13| read(data[k])
14| end for
15| {mengurutkan ascending metode bubble}
16| for k  1 to n-1 do
17| for m  k+1 to n do
18| if data[k] > data[m] then
19| {tukar data[k] dengan data[m]}
20| temp  data[k]
21| data[k]  data[m]
22| data[m]  temp
23| end if
24| end for
25| end for
26| {mencetak data yang telah diurutkan}
27| for k  1 to n do
28| write(data[k])
29| end for
2. Metode Seleksi (Selection Sort)
Berdasarkan metode Bubble Sort, idenya adalah membawa yang terkecil ke
sebelah paling kiri. Akan tetapi, metode Bubble tidak efisien karena algoritma
melakukan proses penukaran yang cukup banyak hanya untuk membawa yang terkecil
ke sebelah paling kiri. Algoritma Bubble akan lebih efisien apabila kita hanya
melakukan penukaran untuk data yang benar-benar terkecil. Algoritma inilah yang
dikenal dengan nama Selection Sort.
Langkah-langkahnya adalah:
1. cari data terkecil dari data ke-1 s/d n, tukar dengan data[1]
2. cari data terkecil dari data ke-2 s/d n, tukar dengan data[2]
3. ...
4. cari data terkecil dari data ke-(n-1) s/d n, tukar dengan data[n-1]
Perhatikan contoh berikut ini:
Misalkan kita mempunyai data berikut: 2, 7, 3, 1, 5, 4
Keterangan | data ke- 1 2 3 4 5 6
Data awal 2 7 3 1 5 4
Tukar data[1], data[4] 1 2
Tukar data[2], data[4] 2 7
Tetap 3
Tukar data[4], data[6] 4 7
tetap 5
Data sudah urut 1 2 3 4 5 7
Algoritmanya adalah sebagai berikut:

93
01| Algoritma Pengurutan_Selection
02| {menginput n buah data kemudian mengurutkannya secara ascending
menggunakan metode Seleksi}
03| Deklarasi:
04| const max = 50
05| type Tdata = integer
06| type TLarik = array[1..max] of TData
07| data : TLarik
08| temp : TData {Temporary untuk menyimpan data yg hendak ditukar}
09| k, m, t, n : integer
10| Deskripsi
11| read(n)
12| for k  1 to n do
13| read(data[k])
14| end for
15| {mengurutkan ascending metode seleksi}
16| for k  1 to n-1 do
17| {cari indeks data terkecil dari data ke-k s/d data ke-n}
18| t  k
19| for m  k + 1 to n do
20| if data[m] < data[t] then
21| t  m
22| end if
23| end for
24| {tukar data ke-t dengan data ke-k bila tidak sama}
25| if t <> k then
26| temp  data[t]
27| data[t]  data[k]
28| data[k]  temp
29| end if
30| end for
31| {mencetak data yang telah diurutkan}
32| for k  1 to n do
33| write(data[k])
34| end for

94
3. Metode Penyisipan (Insertion Sort)
Metode ini adalah seperti saat mengurutkan setumpukan kartu. Ambil kartu ke-2,
sisipkan apakah di atas kartu ke-1 atau tetap di bawah kartu ke-1. Berarti kartu ke-1
s/d ke-2 sudah urut. Ambil kartu ke-3, sisipkan apakah tetap di bawah kartu ke-2, atau
di antara kartu ke-1 dan ke-2, atau di atas kartu ke-1. Berarti kartu ke-1 s/d ke-3 sudah
urut. Langkah ini dilakukan terus menerus hingga penyisipan kartu terakhir.
Sebagai gambarannya, perhatikan contoh berikut ini:
Misalkan kita mempunyai data berikut:
i 1 2 3 4 5 6 7 8
Data[i] 3 2 1 5 4 6 9 7
Maka ilustrasinya adalah sebagai berikut:
1. Untuk nilai k = 2, maka

2. Untuk nilai k = 3, maka


95
3. Untuk nilai k = 4, maka

4. Untuk nilai k = 5, maka

5. Untuk nilai k = 6 maka

6. Untuk nilai k = 7

7. Untuk nilai k = 8 (terakhir), maka

Perhatikan bahwa datanya telah terurutkan.

96
Secara sederhana, maka langkah-langkah pengurutannya adalah sebagai berikut:
Untuk nilai k=2 s/d k=n, lakukanlah langkah berikut:
a. Ambil kartu ke-k (temp  data[k])
b. Cari posisi j yaitu posisi dimana kartu yang diambil (temp) hendak
disisipkan dikanannya..
c. Sambil mencari posisi j, geser kartu ke-j ke kanan hingga ditemukan
posisi j yang tepat. (data[j+1]  data[j])
d. Setelah mendapatkan posisi j, copykan data yang ada di temp ke sebelah
kanan dari j (data[j+1]  temp)
Algoritmanya secara lengkap adalah tersaji di bawah ini.
01| Algoritma Pengurutan_Insertion
02| {menginput n buah data kemudian mengurutkannya secara ascending
menggunakan metode Insertion}
03| Deklarasi:
04| const max = 50
05| type Tdata = integer
06| type TLarik = array[1..max] of TData
07| data : TLarik
08| temp : TData {Temporary untuk menyimpan data yg hendak ditukar}
09| k, j, n : integer
10| Deskripsi
11| read(n)
12| for k  1 to n do
13| read(data[k])
14| end for
15| {mengurutkan ascending metode insertion}
16| for k  2 to n do
17| j  k – 1
18| temp  data[k]
19| while (j>0) and (data[j]>temp) do
20| data[j+1]  data[j]
21| j  j – 1
22| end while
23| data[j+1]  temp
24| end for
25| for k  1 to n do
26| write(data[k])
27| end for


97
E. Array Multi Dimensi
Apabila elemen dari suatu array bertipe array pula, maka array tersebut disebut
array multi dimensi. Perhatikan deklarasi array berikut:
Type TArray1 = ARRAY[1..5] of ARRAY[1..3] of integer
Atau disingkat menjadi
Type TArray1 = ARRAY[1..5,1..3] of integer
Pendeklarasian di atas mempunyai makna bahwa tipe TArray1 merupakan array
yang berindeks 1 s/d 5 dengan tiap-tiap elemennya merupakan array yang berindeks 1
s/d 3 dengan tipe elemen integer.
Misalkan kita mempunyai variabel data bertipe TArray1, maka variabel data
dapat divisualisasikan sebagai berikut:

Jadi bisa dimisalkan bahwa data adalah suatu kotak yang di dalamnya berisikan 5
buah kotak besar dengan masing-masing kotak besar berisikan 3 buah kotak kecil.
Untuk mengisikan data ke dalam variabel data, maka harus disebutkan indeksnya.
Misalnya hendak dimasukkan data bilangan bulat 7 ke variabel data dalam kotak besar
ke-2 dan kotak kecil ke-1, maka perintahnya adalah:
data[2][1]  7
atau bisa juga disingkat menjadi
data[2,1]  7
Tipe indeks tidak harus sama, boleh berlainan, asalkan merupakan salah satu dari
tipe integer, char, atau boolean.
Perhatikan contoh-contoh berikut:
01| Algoritma Contoh_Array_2D
02| {Hanya untuk menunjukkan apa yang boleh dan tidak boleh dilakukan
dalam menggunakan variabel Array 2D.}
03| Deklarasi
04| Type TArray1 = Array[1..3,‟a‟..‟d‟] of integer
05| Type TArray2 = Array[1..4] of real
06| Type TArray3 = Array[1..3] of TArray2
07| data1 : TArray1

98
08| data2 : TArray2
09| data3 : TArray3
10| Deskripsi
11| {memasukan data 5 ke data1 indeks (1,‟a) }
12| data1[1,‟a‟]  5
13| {memasukan data yg terdapat pada data1[1,‟a‟] ke data1[2,‟b‟] }
14| data1[2,‟b‟]  data1[1,‟a‟]
15| {salah karena 5 bukan bertipe array}
16| data1[2]  5
17| {benar karena sama2 bertipe array[„a‟..‟d‟] of integer}
18| data1[2]  data1[1]
19| {memasukkan data 3,4 ke data3[1,4] }
20| data3[1,4]  3.4
21| {Salah karena tidak ada indeks 4,3}
22| data3[4,3]  1.32
23| {Memasukkan 5,3 ke data2[2]}
24| data2[2]  5.3
25| {Benar karena sama2 bertipe array[1..4] of real}
26| data3[1]  data2

Secara umum, pendeklarasian array berdimensi banyak adalah sebagai berikut:
TYPE namatipe = ARRAY[indeks1,indeks2,...,indeksn] of tipe_element
Sebagai contohnya, array berdimensi-3 dengan indeks masing-masing bertipe
integer dan tipe elemennya adalah karakter, dapat dituliskan sebagai berikut:
const max = 50
type TArray = Array[1..max,1..max,1..max] of char
Cara penggunaan array berdimensi banyak adalah dengan menyebutkan nama
variabel diikuti dengan indeksnya yang dipisahkan tanda baca koma. Sebagai
contohnya adalah:
01| Deklarasi
02| type TArray = array[1..4,‟a‟..‟e,‟A‟..‟E‟] of integer
03| data : TArray
04| Deskripsi
05| data[2,‟c‟,‟B‟]  4

99
Berikut ini merupakan contoh penggunaan array multi-dimensi.
1. Algoritma Pengolahan Data Nilai per Kelas
Diketahui Sekolah Dasar Santun Penerus terdiri dari kelas 1 SD sampai dengan
kelas 6 SD. Masing-masing kelas terdiri dari kelas A hingga E, dan setiap kelas
memiliki jumlah murid 40 siswa.
Buatlah algoritma untuk meminta input nilai ujian matematika dari kelas 1 SD
hingga kelas 6 SD untuk masing-masing kelas A hingga E, kemudian algoritma akan
menghitung nilai rata-rata untuk tiap kelas 1A hingga kelas 6E.
Analisis:
Kita memerlukan suatu variabel nilai yang bertipe array 3 dimensi, dengan dimensi
pertama adalah menunjukkan kelas 1 s/d 6, dimensi kedua adalah menunjukkan kelas
A s/d E, dan dimensi ketiga adalah nomor urut siswa (hingga 40 siswa) dengan tipe
elemennya adalah real.
Setelah meminta input data nilai yang diperlukan ke dalam variabel nilai, akan
dihitung jumlah nilai untuk masing-masing kelas kemudian menghitung nilai rata-
ratanya. Nilai rata-rata akan disimpan dalam array berdimensi-2 dengan dimensi
pertama menunjukkan kelas 1 s/d 6 dan dimensi kedua menunjukkan kelas A s/d E.
Algoritmanya secara lengkapnya adalah sebagai berikut:
01| Algoritma Pengolahan_Data_SD_Santun_Penerus
02| {meminta input data nilai ujian matematika untuk kelas 1A hingga
kelas 6E, kemudian menghitung nilai rata-rata per kelas.}
03| Deklarasi
04| const max = 40 {karena masing-masing kelas 40 siswa}
05| type TData = real
06| type TNilai = Array[1..6,‟A‟..‟E‟,1..max] of TData
07| type TRata = Array[1..6,‟A‟..‟E‟] of real
08| nilai : TNilai
09| rata : TRata
10| k,j : integer
11| m : char
12| Jumlah : TData
13| Deskripsi
14| {menginput nilai seluruh kelas}
15| for k  1 to 6 do {kelas 1 s/d 6}
16| for m  „A‟ to „E‟ do {kelas A s/d E}
17| for j  1 to max do {murid ke-1 s/d 40}
18| read(nilai[k,m,j])
19| end for
20| end for
21| end for

100
22| {menghitung jumlah nilai dan rata-rata masing2 kelas}
23| for k  1 to 6 do {kelas 1 s/d 6}
24| for m  „A‟ to „E‟ do {kelas A s/d E}
25| {hitung jumlah nilai}
26| jumlah  0
27| for j  1 to 40 do
28| jumlah  jumlah + nilai[k,m,j]
29| end for
30| rata[k,m]  jumlah / max
31| end for
32| end for
33| {mencetak nilai rata-rata masing-masing kelas}
34| for k  1 to 6 do
35| for m  „A‟ to „E‟ do
36| write(rata[k,m])
37| end for
38| end for
F. Matriks
1. Pengertian
a. Teori Matematika
Matriks merupakan kumpulan bilangan (unsur) yang disusun menurut baris dan
kolom. Bilangan-bilangan yang disusun tersebut disebut elemen-elemen atau
komponen-komponen matriks. Nama sebuah matriks dinyatakan dengan huruf
kapital. Banyaknya baris dan kolom dari suatu matriks disebut ordo atau ukuran
matriks.
Perhatikan contoh matriks berikut:

Matriks A terdiri dari 3 baris dan 4 kolom, maka matriks A berordo 3x4.
Secara umum matriks dapat ditulis dengan

101
11 12 1
21 22 2
1 2
( )
n
n
ij m x n
m m mn
a a a
a a a
A a
a a a
(
(
(
= =
(
(
¸ ¸


   


dan dalam hal ini
ij
a disebut elemen matriks pada baris ke-i dan kolom ke-j
Elemen diagonal utama adalah elemen yang indeksnya sama, misalnya
22
a
Beberapa jenis matriks:
1. Matriks Nol:matriks yang semua elemennya nol
2. Matriks Bujursangkar:matriks berordo n x n
3. Matriks Diagonal:matriks bujursangkar yang semua elemen di luar elemen
diagonal utamanya bernilai nol.
4. Matriks Skalar:matriks bujursangkar yang elemen-elemen diagonal
utamanya bernilai sama.
5. Matriks Identitas:matriks bujursangkar yang elemen-elemen diagonal
utamanya bernilai 1.
6. Matriks segitiga atas:matriks bujursangkar yang elemen-elemen dibawah
diagonal utamanya bernilai nol.
7. Matriks segitiga bawah:matriks bujursangkar yang elemen-elemen di atas
diagonal utamannya bernilai nol.

b. Teori Algoritma dan Pemrograman
Matriks merupakan suatu tipe data array berdimensi-2 dengan tipe elemen sesuai
dengan tipe elemen matriks.
Misalkan hendak dideklarasikan suatu variabel A bertipe matriks berordo 3x4
dengan elemen bertipe real.
Type Tmatriks = Array[1..3,1..4] of real
A : Tmatriks
Dalam prakteknya, kita akan membuat tipe matriks berukuran yang cukup besar,
misalnya 15x15 sehingga bisa dipakai untuk matriks yang berukuran hingga
maksimum 15x15. Contohnya adalah sebagai berikut:
Const max = 15
Type Tmatriks = Array[1..max,1..max] of real
2. Pengisian Matriks
Variabel matriks dapat diisi oleh user, atau oleh programer (misalnya untuk
beberapa matriks khusus seperti matriks identitas, matriks nol, dsb).
a. Pengisian Oleh User
Berikut ini contoh pengisian matriks berukuran m x n dengan ukuran matriks
ditentukan oleh user (maksimum 15 x 15).

102
01| Algoritma Pengisian_Matriks_Oleh_User
02| {user menginputkan ukuran matriks, kemudian mengisikan matriks
tersebut}
03| Deklarasi
04| Const max = 15
05| Type TElemen = integer
06| Type TMatriks = array[1..max,1..max] of TElemen
07| A : TMatriks
08| m,n : integer {ukuran matriks}
09| i,j : integer {pencacah}
10| Deskripsi
11| {Meminta user menginput ukuran matriks}
12| read(m,n)
13| {meminta user menginput elemen-elemen matriks}
14| for i  1 to m do
15| for j  1 to n do
16| read(A[m,n])
17| end for
18| end for

b. Pengisian Oleh Programmer
1. Deklarasikan suatu variabel bertipe matriks, kemudian buatlah agar variabel
tersebut mewakili matriks nol berukuran n x n.
Analisis:
Matriks nol adalah matriks yang semua elemennya adalah nol. Jadi, tekniknya
sama dengan pengisian matriks sebelumnya, hanya saja elemennya tidak di
read dari user, melainkan langsung di assignment oleh programmer dengan
bilangan nol.

01| Algoritma Pengisian_Matriks_Nol
02| {Mendeklarasikan variabel matriks, lalu isikan matriks nol ukuran
n x n}
03| Deklarasi
04| const max = 15
05| Type TElemen = integer
06| Type TMatriks = Array[1..max,1..max] of TElemen
07| Nol : TMatriks {matriks nol ukuran n x n}
08| n : integer {ukuran matriks}
09| i,j : integer {pencacah}

103
10| Deskripsi
11| read(n)
12| for i  1 to n do
13| for j  1 to n do
14| nol[i,j]  0
15| end for
16| end for

2. Deklarasikan suatu variabel bertipe matriks, kemudian buatlah agar variabel
tersebut mewakili matriks identitas berukuran n x n.
Analisis:
Matriks identitas adalah matriks yang semua elemen utamanya adalah 1. Jadi,
tekniknya sama dengan pengisian matriks nol sebelumnya, hanya saja
elemennya diisikan nol atau satu bergantung pada syarat bahwa indeks i sama
dengan indeks j atau tidak.
01| Algoritma Pengisian_Matriks_Identitas
02| {Mendeklarasikan variabel matriks, lalu isikan matriks nol ukuran
n x n}
03| Deklarasi
04| const max = 15
05| Type TElemen = integer
06| Type TMatriks = Array[1..max,1..max] of TElemen
07| satu : TMatriks {matriks identitas ukuran n x n}
08| n : integer {ukuran matriks}
09| i,j : integer {pencacah}
10| Deskripsi
11| read(n)
12| for i  1 to n do
13| for j  1 to n do
14| if i = j then
15| satu[i,j]  1
16| else
17| satu[i,j]  0
18| end if
19| end for
20| end for


104
3. Algoritma Pengecekan Matriks
Semua algoritma dibawah ini hanya merupakan potongan algoritma. Diasumsikan
bahwa terdapat deklarasi seperti berikut
Deklarasi
const max = 15
Type TElemen = integer
Type TMatriks = Array[1..max,1..max] of TElemen
A : TMatriks
n : integer {ukuran matriks n x n}
i,j : integer {pencacah}
Kemudian diasumsikan pula variabel matriks A mempunyai isi. Kemudian dengan
menggunakan algoritma, hendak dilakukan pengecekan matriks A termasuk jenis
matriks apa.
a. Pengecekan Matriks Nol
Strategi: asumsi matriks nol. Jika ditemukan suatu elemen bukan nol, maka bukan
matriks nol.
01| Nol  True {asumsi benar matriks nol}
02| for i  1 to n do
03| for j  1 to n do
04| if A[i,j] <> 0 then
05| nol  false
06| end if
07| end for
08| end for
09| if nol then
10| write(„Matriks nol‟)
11| else
12| write(„BUKAN matriks nol‟)
13| end if

b. Pengecekan Matriks Identitas
Strateginya sama dengan matriks nol, hanya saja ada 2 hal, yaitu apabila i j =
maka cek apakah elemen = 0, dan apabila i j = maka cek apakah elemen = 1.
01| identitas  true {asumsi benar matriks identitas}
02| for i  1 to n do
03| for j  1 to n do
04| if i = j then
05| if A[i,j] <> 1 then

105
06| identitas  false
07| end if
08| else {i <> j}
09| if A[i,j] <> 0 then
10| identitas  false
11| end if
12| end if
13| end for
14| end for

c. Pengecekan Matriks Skalar
Strateginya adalah ambil elemen a(1,1) simpan di x, lalu terapkan algoritma
pengecekan matriks identitas dengan pengecekan apabila i j = maka cek apakah
elemen = x
01| skalar  true {asumsi benar matriks skalar}
02| x  a[1,1] {simpan elemen a(1,1) }
03| for i  1 to n do
04| for j  1 to n do
05| if i = j then
06| if A[i,j] <> x then
07| skalar  false
08| end if
09| else {i <> j}
10| if A[i,j] <> 0 then
11| skalar  false
12| end if
13| end if
14| end for
15| end for

4. Algoritma Penjumlahan Matriks
Diberikan dua buah matriks A dan B berukuran m x n. Maka penjumlahan A + B
didefinisikan sebagai

106
11 12 1 11 12 1
21 22 2 21 22 2
1 2 1 2
11 11 12 12 1 1
21 21 22 22 2 2
1 1 2 2
n n
n n
m m mn m m mn
n n
n n
m m m m mn mn
a a a b b b
a a a b b b
A B
a a a b b b
a b a b a b
a b a b a b
a b a b a b
( (
( (
( (
+ = +
( (
( (
¸ ¸ ¸ ¸
+ + + (
(
+ + +
(
=
(
(
+ + +
¸ ¸
 
 
       
 


   


Buatlah algoritma untuk meminta input ukuran matriks m x n, kemudian
menginputkan matriks A dan B, lalu menghitung C = A + B, kemudian mencetak isi
matriks C.
16| Algoritma Penjumlahan_Matriks
17| {input m dan n, lalu input matriks A dan B, hitung C = A + B, lalu
mencetak isi C.}
18| Deklarasi
19| const max = 15
20| Type TElemen = integer
21| Type TMatriks = [1..max,1..max] of TElemen
22| A, B, C : TMatriks
23| m,n : integer
24| i,j : integer
25| Deskripsi
26| {input ukuran matriks}
27| read(m,n)
28| {input matriks A}
29| for i  1 to m do
30| for j  1 to n do
31| read(A[i,j])
32| end for
33| end for
34| {input matriks B}
35| for i  1 to m do
36| for j  1 to n do
37| read(B[i,j])
38| end for
39| end for
40| {hitung C = A + B}

107
41| for i  1 to m do
42| for j  1 to n do
43| C[i,j]  A[i,j] + B[i,j]
44| end for
45| end for
46| {Cetak isi C}
47| for i  1 to m do
48| for j  1 to n do
49| write(C[i,j])
50| end for
51| end for
5. Algoritma Perkalian Matriks
Matriks A dapat dikalikan dengan matriks B jika banyak kolom A = Banyak baris B.
Misalnya
m n
A
×
dan
n k
B
×
, maka
m k
A B C
×
× = dengan elemen-elemen C merupakan
penjumlahan dari hasil kali elemen baris A dengan elemen kolom B yang bersesuaian.
Jika ( )
ij m n
A a
×
= dan ( )
ij n k
B b
×
= maka ( )
ij m k
A B c
×
× = dengan:
1
; 1 dan 1
n
ij ip pj
p
c a b i m j k
=
= · = =
¿
 
Buatlah algoritma untuk meminta input ukuran matriks m x n, kemudian
menginputkan matriks A dan B, lalu menghitung C A B = × , kemudian mencetak isi
matriks C.
01| Algoritma Penjumlahan_Matriks
02| {input m dan n, lalu input matriks A dan B, hitung C = A x B, lalu
mencetak isi C.}
03| Deklarasi
04| const max = 15
05| Type TElemen = integer
06| Type TMatriks = [1..max,1..max] of TElemen
07| A, B, C : TMatriks
08| m,n,k : integer
09| i,j,p : integer
10| Deskripsi
11| {input ukuran matriks A(mxn) dan B(nxk)}
12| read(m,n,k)
13|

108
14| {input matriks A ordo mxn}
15| for i  1 to m do
16| for j  1 to n do
17| read(A[i,j])
18| end for
19| end for
20| {input matriks B ordo nxk}
21| for i  1 to n do
22| for j  1 to k do
23| read(B[i,j])
24| end for
25| end for
26| {hitung C = A x B}
27| for i  1 to m do
28| for j  1 to k do
29| C[i,j]  0 {inisialisasi}
30| for p  1 to n do
31| C[i,j]  C[i,j] + A[i,p]*B[p,j]
32| end for
33| end for
34| end for
35| {Cetak isi C ordo mxk}
36| for i  1 to m do
37| for j  1 to k do
38| write(C[i,j])
39| end for
40| end for

G. Latihan
1. Ubahlah semua algoritma pengurutan data seperti contoh pada metode bubble,
selection, dan insertion menjadi dalam mode descending.
2. Diketahui metode pengurutan bubble sebagai berikut:
Misalnya terdapat data berikut: 3 2 5 1 4
Keterangan \ data ke- 1 2 3 4 5
Data awal 3 2 5 1 4
Langkah 1
1.Bandingkan data ke-1 dan 2, tukar (3>2) 2 3 5 1 4

109
Keterangan \ data ke- 1 2 3 4 5
2.Bandingkan data ke-2 dan 3, tetap (3<5) 2 3 5 1 4
3.Bandingkan data ke-3 dan 4, tukar (5>1) 2 3 1 5 4
4.Bandingkan data ke-4 dan 5, tukar (5>4) 2 3 1 4 5
Langkah 2
1.Bandingkan data ke-1 dan 2, tetap (2<3) 2 3 1 4 5
2.Bandingkan data ke-2 dan 3, tukar (3>1) 2 1 3 4 5
3.Bandingkan data ke-3 dan 4, tetap (3<4) 2 1 3 4 5
Langkah 3
1. Bandingkan data ke-1 dan 2, tukar (2>1) 1 2 3 4 5
2. Bandingkan data ke-2 dan 3, tetap (2<3) 1 2 3 4 5
Langkah 4
1. Bandingkan data ke-1 dan 2, tetap (1<2) 1 2 3 4 5
Selesai, data sudah terurut Ascending.

Buatlah algoritma pengurutan data seperti yang diterangkan di atas.

3. Buatlah algoritma untuk mengecek apakah suatu matriks A berukuran n x n
merupakan matriks:
a. diagonal
b. segitiga atas
c. segitiga bawah
4. Buatlah algoritma yang meminta input matriks
m n
A
×
,
m n
B
×
, dan
m n
C
×
kemudian
hitung dan cetaklah matriks 4 3 D A B C = + ÷
5. Buatlah algoritma untuk mengecek apakah kedua matriks A dan B yang berukuran
mxn adalah sama atau tidak.
6. Suatu matriks A dikatakan kelipatan skalar dari matriks B apabila dapat ditemukan
ì sedemikian sehingga B A ì = . Contoh:
1 3 2
5 1 7
A
(
=
(
¸ ¸
dan
3 9 6
15 3 21
B
(
=
(
¸ ¸
, maka diperoleh 3 B A = .
Buatlah algoritma untuk menginput matriks A dan B berordo mxn, kemudian
tentukan apakah matriks A merupakan kelipatan skalar dari matriks B atau tidak. Jika
ya, maka cetaklah nilai ì , jika tidak, maka cetak keterangan yang sesuai.
7. Semua algoritma pengecekan matriks pada contoh-contoh di atas tidak
menghentikan proses pengecekan walaupun sudah ditemukan bahwa bukan
matriks yang dimaksudkan. Ubahlah algoritma-algoritma tersebut agar algoritma
menghentikan proses pengecekan apabila sudah ditemukan bukan tergolong matriks
yang dimaksudkan.

110
BAB VII : RECORD (REKAMAN)
A. Pendahuluan
1. Pengertian
Record atau rekaman (bahasa Indonesia) yaitu suatu tipe data terstruktur yang
dapat menyimpan lebih dari satu data yang bertipe berlainan. Tipe data terstruktur
yang dipelajari pada bab sebelumnya, yaitu array, hanya bisa menampung data yang
bertipe sama. Itulah perbedaan mendasar dari tipe data terstruktur array dan record.
Satu kumpulan data bertipe berlainan tersebut disebut satu record. Sedangkan
masing-masing data yang berlainan tersebut selanjutnya disebut data atau anggota atau
elemen dari suatu field.
Dalam dunia database (basis data), satu data dapat terdiri dari beberapa data yang
bertipe berlainan, namun merupakan satu kesatuan, misalnya sebuah data pelanggan,
dapat terdiri dari nomor pelanggan (string), nama pelanggan (string), jenis kelamin
(char), umur (integer). dan sebagainya. Satu kesatuan data ini dinamakan satu record
dan dapat disimpan dalam suatu variabel yang bertipe record.
2. Cara Pendeklarasian
Bentuk penulisan umumnya adalah
RECORD <field1 : tipe_field,
field2 : tipe_field,
...,
fieldn : tipe_field >
Contoh pendeklarasian:
Deklarasi:
Data : record <nim,
nama : string,
nilai : real,
grade : char >

Deklarasi:
Type Tnilai = real
Type Trecord = Record < nim, nama : string,
Nilai : Tnilai, grade : char >
Data : Trecord

111
Pendeklarasian variabel data di atas adalah sama, hanya saja bentuk
pendeklarasian yang ke-2 walaupun lebih panjang, namun lebih terstruktur. Dalam hal
ini, tipe Trecord dikatakan tipe data record dengan 4 field, yaitu field nim, nama,
nilai, dan grade. Akibatnya dalam hal ini, variabel data yang bertipe Trecord dapat
menyimpan 4 buah data yang berlainan tipe.
Variabel data tersebut dapat digambarkan sebagai berikut:

Kotak nim dan nama dapat digunakan untuk menyimpan data bertipe string, kota
nilai dapat digunakan untuk menyimpan data bertipe Tnilai, dan kotak grade dapat
digunakan untuk menyimpan data bertipe char.
3. Cara Pemakaian Record
Misalkan dideklarasikan variabel data seperti berikut:
Deklarasi
Type Trecord = Record < nim, nama : string,
Nilai : real,
Grade : char >
Data : Trecord
Maka cara mengisikan nilai ke dalam variabel data adalah:
Deskripsi
Data.nim  ‘061101234’ {mengisikan nilai string ke field nim}
Data.nama  ‘Budiani’ {mengisikan nilai string ke field nama}
Data.nilai  84.78 {mengisikan nilai real ke field nilai}
{mengisikan grade sesuai dengan nilai}
If data.nilai >= 80.0 then
Data.grade  ‘A’
Else
If data.nilai >= 70.0 then
Data.grade  ‘B’
Else
If data.nilai >= 60.0 then
Data.grade  ‘C’
Else

112
If data.nilai >= 40.0 then
Data.grade  ‘D’
Else
Data.grade  ‘E’
End if
End if
End if
End if
Contoh lainnya adalah
Deklarasi
Data.nama  ‘Budi’
Write(data.nama) {tercetak Budi}
Data.nama  ‘Tono’
Write(data.nama) {tercetak Tono}
Data.nilai  60.0
Data.nilai  data.nilai + 2
Write(data.nilai) {tercetak 62.0}
Read(data.nim) {meminta user memasukkan nim}
Read(data) {SALAH, karena tidak menyebutkan field}
Write(data) {SALAH, Karena tidak menyebutkan field}

B. Contoh Penggunaan Record
1. Algoritma Perhitungan Selisih Waktu
Buatlah algoritma untuk menghitung selisih waktu (jam, menit, detik) dari 2 data
waktu yang diinputkan user.
Analisis:
Pada bab terdahulu, kita sudah pernah membuat algoritmanya, namun data disimpan
dalam masing-masing variabel bertipe integer. Untuk 1 buah data waktu dibutuhkan 3
buah variabel integer, yaitu j, m, dan d.
Kali ini, kita akan menggunakan variabel bertipe record dengan 3 bauh field, yaitu
field j, m, dan d. Akan dideklarasikan 3 variabel bertipe record dengan field yang
demikian, 2 menampung input, 1 menampung hasil selisih waktunya.
01| Algoritma Menghitung_Selisih_Waktu
02| {Menghitung selisih waktu dengan cara meminta input 2 data waktu
(awal dan akhir), kemudian mengubahnya menjadi total detik,
setelah itu mencari selisih total detik, lalu mengubah selisih
total detik tersebut menjadi dalam format waktu (jam, menit,
detik) kembali.}

113
03| Deklarasi
04| Type Twaktu = record <j,m,d : integer>
05| W1,w2,w3 : Twaktu
06| T1,t2,t3 : integer
07| S : integer
08| Deskripsi
09| {menginput waktu awal}
10| Read(w1.j, w1.m, w1.d)
11| {menginput waktu akhir}
12| Read(w2.j, w2.m, w2.d)
13| {mengubah waktu awal dan waktu akhir menjadi total detik}
14| T1  w1.j*3600 + w1.m*60 + w1.d
15| T2  w2.j*3600 + w2.m*60 + w2.d
16| {menghitung selisih waktu}
17| T3  t2 – t1
18| {mengubah selisih waktu menjadi jam, menit, detik}
19| W3.j  t3 div 3600
20| S  t3 mod 3600
21| W3.m  s div 60
22| W3.d  s mod 60
23| {mencetak selisih waktunya}
24| Write(w3.j, w3.m, w3.d)

2. Algoritma Perhitungan Bilangan Kompleks Sederhana
Bilangan kompleks di dalam matematika adalah bilangan yang terdiri dari 2
bagian yaitu bagian real dan bagian imajiner. Bentuk umumnya adalah x yi + dengan
x merupakan bagian real dan y merupakan bagian imajinernya. Sedangkan i adalah
suatu nilai yang sama dengan 1 ÷ . Contoh, bilangan
kompleks 3 8 3 4.2.( 1) 3 2 2. 1 3 2 2 3 2,83 i i + ÷ = + ÷ = + ÷ = + = + . Jadi dapat
disimpulkan bahwa nilai 3 x = dan 2,83 y = .
Operasi pada dua bilangan kompleks dapat berupa penjumlahan (pengurangan)
dan perkalian. Penjumlahan dua bilangan kompleks didefinisikan sebagai berikut:
1 1 2 2 1 2 1 2
( ) ( ) ( ) ( ) x y i x y i x x y y i + + + = + + +
dan perkalian dua bilangan kompleks didefinisikan sebagai berikut:

114
1 1 2 2
1 2 2 1 2 2
1 2 1 2 2 1 1 2
1 2 1 2 2 1 1 2
1 2 1 2 1 2 2 1
( )( )
( ) ( )
.
( ) ( . 1)
( ) ( )
x y i x y i
x x y i y i x y i
x x x y i x y i y y i i
x x x y x y i y y karena i i
x x y y x y x y i
+ +
= + + +
= + + +
= + + ÷ = ÷
= ÷ + +

Berdasarkan teori di atas, buatlah algoritma yang meminta input 2 bilangan kompleks,
kemudian hitunglah hasil penjumlahan dan perkaliannya.
Analisis:
Untuk bilangan kompleks, karena terdiri dari 2 bagian, yaitu bagian real dan imajiner,
maka kita membuat tipe kompleks yang merupakan record dengan 2 field, yaitu field x
untuk bagian real dan field y untuk bagian imajiner.
01| Algoritma Hitung_Bilangan_Kompleks
02| {menginput 2 bilangan kompleks, kemudian mencetak hasil jumlah dan
perkaliannya}
03| Deklarasi
04| Type TKompleks = record <x,y : real>
05| z1,z2 : TKompleks {bilangan kompleks input dari user}
06| h1, h2 : TKompleks {hasil jumlah dan kalinya}
07| Deskripsi
08| {input 2 bilangan kompleks}
09| Read(z1.x, z1.y)
10| Read(z2.x, z2.y)
11| {hitung hasil jumlah}
12| h1.x  z1.x + z2.x
13| h1.y  z1.y + z2.y
14| {hitung hasil perkalian}
15| h2.x  z1.x*z2.x – z1.y*z2.y
16| h2.y  z1.x*z2.y + z2.x*z1.y
17| {mencetak hasil jumlah dan kalinya}
18| write(h1.x, h1.y)
19| write(h2.x, h2.y)

C. Array of Record
1. Pengertian
Pada bab terdahulu kita telah membicarakan mengenai tipe data array. Apabila
tipe elemen dari suatu array adalah bertipe array, maka dikatakan array multidimensi.
Apabila tipe elemen dari suatu array adalah record, maka disebut array of record.

115
Apabila suatu variabel bertipe record, maka variabel tersebut dikatakan hanya
dapat menampung 1 record. Agar dapat menampung lebih dari 1 record, maka kita
dapat membuat tipe data terstruktur array dengan tipe elemennya adalah record.
2. Contoh Pendeklarasian
Berikut ini merupakan contoh cara mendeklarasikan array of record.
Deklarasi
data : array[1..50] of record <nim, nama : string,
nilai : real,
grade : char>
atau dapat pula dengan cara berikut:
Deklarasi
const max = 50
type TNilai = real
type TData = Record <nim,nama : string,
nilai : TNilai,
grade : char>
type TArray = Array[1..max] of TData
data : TArray
Deklarasi yang pertama dan kedua adalah sama, namun yang kedua lebih
terstruktur. Oleh karena itu, untuk seterusnya, diharapkan anda memakai teknik kotak
ke dua.
3. Cara Pengisian Data ke Variabel Array of Record
Misalkan diberikan deklarasi variabel data seperti pada contoh di atas, maka
beberapa contoh pengisian data sebagai berikut
Deskripsi
{mengisikan data pertama, yaitu mahasiswa yang memupunyai nim
061101234, namanya Rudi Susanto, mendapat nilai 75.0}
data[1].nim  ‘061101234’
data[1].nama  ‘Rudi Susanto’
data[1].nilai  75.0
data[1].grade  ‘B’

{Mengcopy seluruh data pertama ke data ke dua}
data[2]  data[1] {boleh karena sama2 bertipe TData}

116
D. Contoh Penggunaan Array of Record
1. Algoritma Perhitungan Nilai Siswa
Buatlah algoritma untuk menginput n buah data nim, nama, nilai dari mahasiswa,
kemudian tentukanlah grade untuk masing-masing mahasiswa.
01| Algoritma Pengolahan_Data_Mahasiswa
02| {Menginput data nim, nama, dan nilai dari mahasiwa, kemudian
menentukan grade untuk masing-masing mahasiwa}
03| Deklarasi
04| const max = 50
05| type TNilai = real
06| type TData = Record <nim,nama : string,
07| nilai : TNilai,
08| grade : char>
09| type TArray = Array[1..max] of TData
10| data : TArray
11| k, n : integer
12| Deskripsi
13| read(n) {meminta input berapa data nilai yang diolah}
14| for k  1 to n do
15| read(data[k].nim, data[k].nama, data[k].nilai)
16| end for
17| {menentukan grade}
18| for k  1 to n do
19| if data[k].nilai >= 80 then
20| data[k].grade  „A‟
21| else
22| if data[k].nilai >= 70 then
23| data[k].grade  „B‟
24| else
25| if data[k].nilai >=60 then
26| data[k].grade  „C‟
27| else
28| if data[k].nilai >= 40 then
29| data[k].grade  „D‟
30| else
31| data[k].grade  „E‟
32| end if

117
33| end if
34| end if
35| end if
36| end for
37| {mencetak grade masing-masing mhs}
38| for k  1 to n do
39| write(data[k].grade)
40| end for
2. Algoritma Pengurutan Pada Data Array of Record
Berdasarkan algoritma di atas, tambahkanlah bagian pengurutan data mhs,
diurutkan berdasarkan nilai secara ascending.
Analisis:
Kita akan mengurutkan menggunakan metode bubble sort. Pembaca harus berlatih
untuk metode lainnya seperti selection dan insertion.
Pada bagian deklarasi, tambahkanlah
m : integer
temp : TData
Pada bagian deskripsi, sambunglah bagian berikut
41| {mengurutkan data berdasarkan nilai secara ascending menggunakan
metode bubble sort}
42| for k  1 to n-1 do
43| for m  k+1 to n do
44| if data[k].nilai > data[m].nilai then
45| {tukar data}
46| temp  data[k]
47| data[k]  data[m]
48| data[m]  temp
49| end if
50| end for
51| end for
3. Algoritma Pencarian Pada Data Array of Record
Asumsi diberikan algoritma seperti di atas, maka data mhs sudah dipastikan
terurut secara ascending berdasarkan nilai. Buatlah algoritma untuk meminta user
menginput suatu data nim, kemudian lakukan pencarian nim dengan metode biner.
Apabila ketemu, maka cetaklah nama, nilai dan gradenya. Jika tidak ditemukan,
cetaklah keterangan yang sesuai.
Analisis:

118
Walaupun metode biner memerlukan data terurut, namun karena yang diurutkan
adalah data nilai, sedangkan yang hendak dicari adalah data nim, maka kita harus
mengurutkan terlebih dahulu nimnya.
Pada bagian deklarasi, tambahkanlah hal berikut
cari : string {karena field nim bertipe string}
awal,akhir,tengah : integer
ketemu : boolean
Pada bagian deskripsi, sambungkan hal berikut.
52| {Mengurutkan berdasarkan nim metode bubble ascending}
53| for k  1 to n-1 do
54| for m  k+1 to n do
55| if data[k].nim > data[m].nim then
56| {tukar data}
57| temp  data[k]
58| data[k]  data[m]
59| data[m]  temp
60| end if
61| end for
62| end for
63| {mencari menggunakan metode biner}
64| read(cari) {menanyakan user nim apa yang mau dicari}
65| awal  1
66| akhir  n
67| ketemu  FALSE
68| repeat
69| tengah  (awal + akhir) div 2
70| if cari = data[tengah].nim then
71| ketemu  TRUE
72| else
73| if cari < data[tengah].nim then
74| akhir  tengah – 1
75| else
76| awal  tengah + 1
77| end if
78| end if
79| until ketemu or (awal > akhir)
80| if ketemu then

119
81| write(data[tengah].nama,
82| write(data[tengah].nilai, data[tengah].grade)
83| else
84| write(„Data tidak ditemukan‟)
85| end if

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->