E. Variabel ..................................................................11
F. Konstanta ................................................................11
G. Ekspresi ..................................................................11
i
1. operator aritmatika ............................................................................................................ 11
2. operator perbandingan ....................................................................................................... 12
3. operator string ................................................................................................................... 12
4. Logika .............................................................................................................................. 12
5. Tingkatan-tingkatan dalam operator .................................................................................. 13
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
ii
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
D. Latihan ...................................................................71
iii
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
iv
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
v
BAB I : PENGANTAR
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.
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.
1
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.
START
INPUT
a, b, c
OUTPUT a
TRUE (b>c)? FALSE
OUTPUT b OUTPUT c
END
2
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)
3
C . Flow C ha r t (Dia gr a m 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.
4
3. Bentuk-bentuk Dasar Struktur Logika Flow Chart
Runtunan (Sequence Structure)
TRUE FALSE
5
Pengulangan WHILE-DO Pengulangan REPEAT-UNTIL
(WHILE-DO Structure) (REPEAT-UNTIL Structure)
TRUE FALSE
FALSE
TRUE
6
BAB II : DASAR-DASAR ALGORITMA
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}
7
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.
8
yang disertai komentar-komentar yang tepat akan memudahkan pembaca lainnya
untuk mengerti algoritma yang Anda buat.
C . Pe na m a a n/ Pe nge na l (I de nt if ie r )
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 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
D. T ipe Da ta
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.
9
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.
10
True
tRuE
Boolean
FALse
False
E. Va r i a be l
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. Kons ta n ta
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. Eks pr e s i
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
Jenis Tipe Operand1 Tipe Operand2 Tipe Hasil
Operator
Integer Integer
+, – unary
Real Real
11
Integer Integer Integer
Integer Real Real
+, –, * Binary
Real Integer Real
Real Real Real
2. operator perbandingan
Lambang Jenis Tipe Operand1 Tipe Operand2 Tipe Hasil
Operator
< Binary Integer Integer Boolean
<= Binary Integer Real Boolean
> Binary Real Real Boolean
>= Binary Char Char Boolean
= Binary Char String Boolean
<> Binary String String Boolean
Binary 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
Jenis Tipe Operand1 Tipe Operand2 Tipe Hasil
Operator
not Unary Boolean Boolean
12
a not a
True False
False True
a b a and b a or b a xor b
true true true true false
true false false true true
false true false true true
false false false false false
13
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 . I nput da n O utp ut
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.
14
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}
15
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}
16
BAB III : RUNTUNAN
A. Pe nge r tia n
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}
17
B . C onto h -c on toh
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)
18
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)
19
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)
20
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)
21
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)
22
dapat dipindah ke variabel data2 Kemudian informasi data2 yang tersimpan di variabel
temp dapat dipindahkan ke variabel data1.
Untuk lebih jelasnya, perhatikan ilustrasi berikut:
23
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)
24
C . La tiha n
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.
25
BAB IV : PEMILIHAN
A. Pe nge r tia n
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.
26
B . Pe m iliha n 1 Ka s us
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.
27
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)
28
C . Pe m iliha n 2 Ka s us
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.
29
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
30
dapat diganti menjadi
...
if not genap then
...
31
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)
32
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
33
10| write(„Penyelesaian‟)
11| else
12| write(„Bukan Penyelesaian‟)
13| end if
D. Pe m iliha n Le bih da r i 2 K a s us
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).
34
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.
35
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)
36
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
37
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.
38
Tidak terletak pada
YA kuadran manapun. END
(Kuadran 0)
END
Titik terletak di
A
sumbu? SELESAI
MULAI
Terdapat 4 pilihan:
kuadran 1
TIDAK kuadran 2 A
kuadran 3
kuadran 4
END END
Kuadran 3 Kuadran 4
END END
39
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)
YA YA YA
Bukan
Kabisat Kabisat
Kabisat
40
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
41
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
42
28| end if
29| write(grade)
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.
YA TIDAK
ss + 1 mm 0
YA
hh + 1
43
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)
44
(a>=b)
and TIDAK (b>=c)? TIDAK terbesar c
(a>=c)?
YA YA
terbesar a terbesar b
45
YA (a>b)? TIDAK
46
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.
terbesar a
(b > terbesar)? YA
terbesar b
(c > terbesar)? YA
terbesar c
47
E. La tiha n
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 300C dan
cuaca dikatakan dingin apabila temperatur kurang dari 25 0C. 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 ax2 + bx + c = 0 dengan a ≠ 0. Persamaan
tersebut dapat diselesaikan dengan menggunakan rumus ABC, yaitu
b D
x1, 2 dengan D b 2 4ac . Penyelesaian tersebut dapat digolongkan
2a
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
48
BAB V : PENGULANGAN
A. Pe nge r tia n
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 . De f inite Lo op
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
49
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}
50
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
51
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
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
52
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)
53
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)
54
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)
55
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)
56
09| for k 1 to n do
10| pangkat pangkat * a
11| end for
12| write(pangkat)
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 a n
n≤0 Tak terdefinisi
a=0
n>0 0
n=0 1
a<0 n>0 a.a...a
a>0 1 1 1 1
n<0 . . ...
a a a a
57
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
58
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 . I nde f inite Lo op
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
...
59
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.
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.
60
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’
61
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.
62
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)
63
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)
64
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)
65
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
66
19| if benar then
20| write(„Selamat, password anda benar‟)
21| else
22| write(„Sudah 3 kali kesalahan. Anda gagal!‟)
23| end if
67
Input Atas n
START
N, ERROR Bawah 0
Z tengah * tengah
FALSE
Bawah tengah TRUE z<n? FALSE Atas tengah
TRUE
Output
tengah
END
68
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)
69
yang terletak mulai dari 1 hingga n selalu mempunyai pasangan faktor dari n yang
terletak mulai dari n 1 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 n 1 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
70
D. La tiha n
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.
71
BAB VI : ARRAY (LARIK)
A. Pe nda hu lua n
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
72
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
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.
73
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}
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 . Ar r a y 1 Dim e ns i
1. Algoritma Menghitung Rata-rata
Buatlah algoritma untuk menginput n buah data integer, kemudian algoritma akan
menghitung rata-ratanya.
74
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)
75
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.
76
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])
77
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}
78
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?
79
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}
80
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.
81
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
82
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)
83
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 . M e tode Pe nc a r ia n
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
84
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}
85
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
86
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,
87
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
88
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
89
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]
Lakukan langkah ke-3 dengan pola yang sama hingga langkah ke-(n-1). Maka
data akan terurut secara ascending
90
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
91
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
92
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
93
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
94
3. Untuk nilai k = 4, maka
6. Untuk nilai k = 7
95
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
96
E. Ar r a y M ulti Dim e ns i
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
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
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
97
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
98
Berikut ini merupakan contoh penggunaan array multi-dimensi.
99
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. M a tr iks
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
100
a11 a12 a1n
a a22 a2 n
A 21 (aij ) m x n
am1 am 2 amn
dan dalam hal ini aij disebut elemen matriks pada baris ke-i dan kolom ke-j
Elemen diagonal utama adalah elemen yang indeksnya sama, misalnya a22
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.
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).
101
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
102
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
103
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}
104
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
105
a11 a12 a1n b11 b12 b1n
a a22 a2 n b21 b22 b2 n
A B 21
am1 am 2 amn bm1 bm 2 bmn
a11 b11 a12 b12 a1n b1n
a b a22 b22 a2 n b2 n
21 21
am1 bm1 am 2 bm 2 amn bmn
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}
106
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
107
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. La tiha n
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
108
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.
109
BAB VII : RECORD (REKAMAN)
A. Pe nda hu lua n
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
110
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.
111
If data.nilai >= 40.0 then
Data.grade ‘D’
Else
Data.grade ‘E’
End if
End if
End if
End if
B . C onto h Pe ng guna a n R e c or d
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.}
112
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)
113
( x1 y1i )( x2 y2i )
x1 ( x2 y2i ) y1i ( x2 y2i )
x1 x2 x1 y2i x2 y1i y1 y2i.i
x1 x2 ( x1 y2 x2 y1 )i y1 y2 (karena i.i 1)
( x1 x2 y1 y2 ) ( x1 y2 x2 y1 )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 . Ar r a y of R e c or d
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.
114
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>
Deklarasi yang pertama dan kedua adalah sama, namun yang kedua lebih
terstruktur. Oleh karena itu, untuk seterusnya, diharapkan anda memakai teknik kotak
ke dua.
115
D. C onto h Pe ng guna a n Ar r a y of Re c or d
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
116
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
117
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
118
81| write(data[tengah].nama,
82| write(data[tengah].nilai, data[tengah].grade)
83| else
84| write(„Data tidak ditemukan‟)
85| end if
119