i

DAFTAR ISI

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

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

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

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

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





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

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

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


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


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

digunakan untuk menunjukkan awal dan akhir algoritma


Simbol persiapan (preparation)

digunakan untuk memberikan nilai awal suatu variabel atau suatu
counter

Simbol proses (process)

digunakan untuk proses perhitungan aritmatika atau proses
pemindahan data


Simbol Data (data)

digunakan untuk menunjukkan proses input maupun output
data.


Simbol Keputusan (decision)

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

Simbol Penghubung (on-page reference)

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

Simbol Penghubung Halaman Lain (off-page reference)

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


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

Pemilihan/Percabangan IF (Selection Structure)
TRUE FALSE


Pengulangan FOR (FOR Loop Structure)

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

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





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

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

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

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

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

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

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

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

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

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


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

Integer
Real

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

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


13
a not a
True
False
False
True

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

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

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


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

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

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

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

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

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

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

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

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

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

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



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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

0
2
1
3
2
2.2.2
3
2
÷

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


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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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


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

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

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

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

68

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


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

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

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


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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2. Untuk nilai k = 3, maka


95
3. Untuk nilai k = 4, maka

4. Untuk nilai k = 5, maka

5. Untuk nilai k = 6 maka

6. Untuk nilai k = 7

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

Perhatikan bahwa datanya telah terurutkan.

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


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

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

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

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

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

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

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

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



= =





   


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

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

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

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

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

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

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


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

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

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

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

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

106
11 12 1 11 12 1
21 22 2 21 22 2
1 2 1 2
11 11 12 12 1 1
21 21 22 22 2 2
1 1 2 2
n n
n n
m m mn m m mn
n n
n n
m m m m mn mn
a a a b b b
a a a b b b
A B
a a a b b b
a b a b a b
a b a b a b
a b a b a b



+ = +



+ + +

+ + +

=


+ + +

 
 
       
 


   


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

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

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

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

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

Buatlah algoritma pengurutan data seperti yang diterangkan di atas.

3. Buatlah algoritma untuk mengecek apakah suatu matriks A berukuran n x n
merupakan matriks:
a. diagonal
b. segitiga atas
c. segitiga bawah
4. Buatlah algoritma yang meminta input matriks
m n
A
×
,
m n
B
×
, dan
m n
C
×
kemudian
hitung dan cetaklah matriks 4 3 D A B C = + ÷
5. Buatlah algoritma untuk mengecek apakah kedua matriks A dan B yang berukuran
mxn adalah sama atau tidak.
6. Suatu matriks A dikatakan kelipatan skalar dari matriks B apabila dapat ditemukan
ì sedemikian sehingga B A ì = . Contoh:
1 3 2
5 1 7
A

=


dan
3 9 6
15 3 21
B

=


, maka diperoleh 3 B A = .
Buatlah algoritma untuk menginput matriks A dan B berordo mxn, kemudian
tentukan apakah matriks A merupakan kelipatan skalar dari matriks B atau tidak. Jika
ya, maka cetaklah nilai ì , jika tidak, maka cetak keterangan yang sesuai.
7. Semua algoritma pengecekan matriks pada contoh-contoh di atas tidak
menghentikan proses pengecekan walaupun sudah ditemukan bahwa bukan
matriks yang dimaksudkan. Ubahlah algoritma-algoritma tersebut agar algoritma
menghentikan proses pengecekan apabila sudah ditemukan bukan tergolong matriks
yang dimaksudkan.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1. operator aritmatika ............................................................................................................ 11 2. operator perbandingan ....................................................................................................... 12 3. operator string ................................................................................................................... 12 4. Logika .............................................................................................................................. 12 5. Tingkatan-tingkatan dalam operator .................................................................................. 13

H. Penugasan (Assigment) ..................................................13 I. Input dan Output ........................................................14
1. Input ................................................................................................................................. 15 2. Output............................................................................................................................... 16

BAB III : RUNTUNAN............................................ 17
A. Pengertian ...............................................................17 B. Contoh-contoh ...........................................................18
1. Algoritma Luas Segitiga () ........................................................................................... 18 2. Algoritma Komisi Salesman ()...................................................................................... 18 3. Algoritma Gaji Karyawan () ...................................................................................... 19 4. Algoritma Konversi Waktu ke Total Detik () ............................................................. 20 5. Algoritma Konversi Total Detik ke Waktu ().......................................................... 20 6. Algoritma Pembulatan Seratusan () ................................................................ 21 7. Algoritma Pertukaran Data () ................................................................................ 22 8. Algoritma Menghitung Selisih Waktu () ......................................................... 23

C. Latihan ...................................................................25

BAB IV : PEMILIHAN ........................................... 26
A. Pengertian ...............................................................26 B. Pemilihan 1 Kasus ........................................................27
1. Pendahuluan...................................................................................................................... 27 2. Algoritma Pengecekan Negatif () ................................................................................... 27 3. Algoritma Pemberian Diskon () ................................................................................. 27

C. Pemilihan 2 Kasus ........................................................29
1. Pendahuluan...................................................................................................................... 29 2. Algoritma Ganjil Genap () ......................................................................................... 29 3. Algoritma Terbesar dari 2 Bilangan () ........................................................................... 31 4. Algoritma Menghitung Uang Lembur () ............................................................. 31 5. Algoritma Tahun Kabisat ()............................................................................ 32 6. Algoritma Syarat Keanggotaan Suatu Jangkauan/Range () ..................................... 33 7. Algoritma Syarat Keanggotaan Diluar Range () ..................................................... 34

D. Pemilihan Lebih dari 2 Kasus ...........................................34 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

BAB V : PENGULANGAN ...................................... 49
A. Pengertian ...............................................................49 B. Definite Loop ............................................................49
1. Contoh-contoh .................................................................................................................. 50 2. Algoritma Mencetak Barisan () ...................................................................................... 51 3. Algoritma Penjumlahan Deret () ................................................................................ 52 4. Algoritma Hitung Rata-rata dari n Data () .............................................................. 53 5. Algoritma Perhitungan Banyaknya yang Lulus () ................................................... 53 6. Algoritma Terbesar dari n Data Bilangan () ............................................................ 54 7. Algoritma Nilai Tertinggi () ................................................................................... 55 8. Algoritma Faktorial () ............................................................................................ 56 9. Algoritma Pangkat Bulat ()............................................................................. 56 10. Algoritma Menentukan Prima () ....................................................................... 58

C. Indefinite Loop ..........................................................59
1. Algoritma Menghitung Jumlahan Data .............................................................................. 62 2. Algoritma Pemasukkan Password ...................................................................................... 65 3. Algoritma Estimasi Nilai Akar Kuadrat ............................................................................. 67 4. Algoritma Menentukan Prima (Perbaikan) ......................................................................... 69

D. Latihan ...................................................................71

BAB VI : ARRAY (LARIK) ...................................... 72
A. Pendahuluan ..............................................................72
1. Pengertian ......................................................................................................................... 72 2. Cara Pendeklarasian .......................................................................................................... 72 3. Cara Pemakaian Array....................................................................................................... 73

B. Array 1 Dimensi .........................................................74

iii

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

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

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

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

Contoh algoritma menentukan bilangan terbesar dari tiga bilangan yang ditulis dalam bentuk pseudocode bergaya buku ini. terbesar : integer 3 . maka pseudocode berarti tiruan atau imitasi dari kode bahasa pemrograman.b. 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.b. Pada dasarnya.3. Apabila diterjemahkan secara bebas. Pseudocode Pseudo berarti imitasi dan code berarti kode yang dihubungkan dengan instruksi yang ditulis dalam bahasa komputer (kode bahasa pemrograman). Pseudocode yang ditulis di dalam buku ini akan menyerupai (meniru) syntaxsyntax dalam bahasa Pascal. 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| Endif Write(terbesar) Deskripsi: Read(a. Walaupun pseudocode tidak ada aturan penulisan syntax. 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. Jadi pseudocode digunakan untuk menggambarkan logika urut-urutan dari program tanpa memandang bagaimana bahasa pemrogramannya.c) If (a>b) and (a>c) then Terbesar  a Else If b>c then Terbesar  b Else Terbesar  c Endif ALGORITMA Menentukan_terbesar_dari_3_bilangan Deklarasi: a.c. 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.

Simbol Keputusan (decision) digunakan untuk pengambilan keputusan dua jalur atau lebih dalam flow chart. 4 . 2.C . 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. Flow C ha r t (Dia gr a m Alir ) 1. tetapi masih dalam halaman yang sama. Simbol-simbol Flow Chart Simbol terminal (terminator) digunakan untuk menunjukkan awal dan akhir algoritma Simbol persiapan (preparation) digunakan untuk memberikan nilai awal suatu variabel atau suatu counter Simbol proses (process) digunakan untuk proses perhitungan aritmatika atau proses pemindahan data Simbol Data (data) digunakan untuk menunjukkan proses input maupun output data. Simbol Penghubung Halaman Lain (off-page reference) digunakan untuk menunjukkan hubungan arus flow chart yang terputus yang berada di halaman lain. Simbol Penghubung (on-page reference) digunakan untuk menunjukkan hubungan arus flow chart yang terputus. 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.

3. Bentuk-bentuk Dasar Struktur Logika Flow Chart Runtunan (Sequence Structure) Pemilihan/Percabangan IF (Selection Structure) TRUE FALSE Pengulangan FOR (FOR Loop Structure) 5 .

Pengulangan WHILE-DO (WHILE-DO Structure) Pengulangan REPEAT-UNTIL (REPEAT-UNTIL Structure) TRUE FALSE FALSE TRUE 6 .

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

Pada bagian kepala algoritma. namun algoritma 8 . nama peubah (variabel). dan nama fungsi. y : integer {tipe koordinat bidang kartesius} {jumlah pegawai} {nilai phi} ketemu : boolean 3. Contohnya dapat dilihat di bawah ini. Nama tersebut dapat berupa nama tetapan (konstanta).14 {nama tipe} type TTitik : record < x. Deskripsi Bagian deskripsi merupakan inti dari algoritma. Contoh lainnya dapat Anda lihat dalam contoh bagian deklarasi di atas. Langkah-langkah ini dituliskan dengan notasi-notasi yang akan dijelaskan pada bab-bab selanjutnya. Komentar ditulis di antara tanda baca kurung kurawal buka dan kurung kurawal tutup.2. 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| procedure Tukar(input/output a. atau false bila x adalah komposit} {nama peubah} c : char Q : TTitik {karakter yang dibaca} {titik dalam koordinat kartesius} {keadaan hasil pencarian} > DEKLARASI {nama tetapan} const Npeg = 100 const phi = 3.b : integer) {mempertukarkan isi variabel a dan b} function IsPrima(input x:integer)  boolean {mengembalikan nilai true bila x adalah prima. Kom e nta r (C om m e nt) Algor itm a Penulisan algoritma yang baik selalu disertai pemberian komentar. penjelasan algoritma merupakan suatu komentar. nama prosedur. nama tipe. Komentar merupakan suatu penjelasan mengenai suatu hal yang tertulis dalam algoritma dan komentar bukanlah merupakan bagian dari langkah-langkah penyelesaian suatu algoritma. Deklarasi Bagian deklarasi berisikan semua nama pengenal yang dipakai di dalam algoritma. Bagian ini berisi uraian langkahlangkah penyelesaian masalah. B . “ { } “. Pemberian komentar bukanlah suatu keharusan.

Dalam algoritma. pemisah antar-kata menggunakan huruf kapital Contoh: LuasSegitiga Beberapa contoh penamaan yang valid maupun tidak valid: 01| 02| 03| 04| 05| Nama_4_Pegawai 2_luas ^LuasSegitiga Luas_Segitiga_&_Lingk Hati2 {valid} {salah. 2. nama tipe. karena diawali angka} {salah. karena terdapat tanda ^} {salah. maka data dibedakan menjadi beberapa tipe. nama peubah (variabel). nol. T ipe Da ta Dalam dunia pemrograman komputer selalu melibatkan data. C . baik yang negatif. nama prosedur. karena terdapat tanda &} {valid} D. Beberapa tipe data tersebut adalah: 1. pemisah antar-kata menggunakan tanda garis bawah. Contoh: Luas_Segitiga 2. atau garis bawah tidak boleh dimulai dengan angka tidak membedakan huruf kapital maupun huruf kecil (non case-sensitive) panjang tidak dibatasi harus unik. semua bilangan bulat termasuk dalam tipe ini. karena pemrograman tidak bisa terlepas dari kegiatan mengolah data menjadi informasi yang diperlukan. 4. maupun bilangan positif. Pemberian nama harus mengikuti aturan-aturan sebagai berikut: hanya boleh terdiri dari huruf. 3. Integer Merupakan tipe data bilangan bulat. 5. artinya tidak boleh ada nama pengenal yang sama untuk hal yang berbeda 6.yang disertai komentar-komentar yang tepat akan memudahkan pembaca lainnya untuk mengerti algoritma yang Anda buat. Hal-hal tersebut meliputi: nama algoritma. angka. tanpa ada batasan. Untuk menjamin konsistensi data dan efisiensi penggunaan memori komputer. Pe na m a a n/ Pe nge na l (I de nt if ie r ) Dalam algoritma. Pemberian nama pengenal ini biasanya mengikuti salah satu dari 2 gaya berikut: 1. hendaknya mencerminkan kegunaannya 1. tipe data yang ada lebih sedikit dibanding bahasa pemrograman dikarenakan algoritma hanya menekankan pada penyelesaian masalah. 9 . nama tetapan (konstanta). ada beberapa hal yang harus diberi nama atau pengenal. Dalam algoritma. dan nama fungsi.

misalnya 2. Char Merupakan tipe data karakter. Hanya saja penulisannya tidak boleh disingkat menjadi huruf T atau huruf F saja.5.64E-2 artinya 2..2E-4 0. Misalnya data jenis kelamin yang hanya diisikan huruf L atau P. Real Merupakan tipe data bilangan pecahan. 3.2. Berikut ini merupakan tabel contoh-contoh data berbagai tipe. 4. Semua data yang terdiri dari 1 karakter atau lebih dapat digolongkan ke dalam tipe ini. bukan tanda koma. Tipe ini juga mendukung penulisan dalam bentuk ilmiah.5 3E2 Real 3.. yaitu harus diapit oleh tanda petik tunggal. nilai 0. Karakter-karakter yang diperbolehkan terdefinisi dalam tabel ASCII. Tanda desimal yang dipakai adalah tanda titik.. Syaratnya sama dengan tipe char. Penulisan TRUE ataupun FALSE tidak membedakan huruf kapital ataupun non-kapital. Boolean Merupakan tipe data yang hanya mempunyai nilai TRUE atau FALSE..64 x 10-2. String Merupakan tipe data kalimat. Sebagai contohnya. Nama Tipe Nilai yang diizinkan 8 Integer -74 0 7. Semua data yang hanya terdiri dari 1 karakter tergolong dalam tipe ini.‟ „pergi!‟ „i‟‟l love you 4ever‟ 10 . Penulisan data tipe char harus diapit oleh tanda petik tunggal.5 „a‟ „!‟ „3‟ Char „.‟ „?‟ „‟‟‟ {yaitu 1 buah karakter tanda petik tunggal} „mahasiswa‟ „a‟ „7483‟ „?w?‟ String „. Semua bilangan yang mengandung tanda desimal tergolong dalam tipe ini.0 0.5 (nol koma lima) ditulis menjadi 0. 5.

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

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

Tipe integer dapat ditampung oleh tipe real. ekspresi. maupun nilai yang dihasilkan oleh fungsi. peubah. Nilai yang dapat diberikan adalah tetapan. Apabila tipenya tidak sama. Pe nu ga s a n (As s igm e nt) Penugasan atau Assignment merupakan pemberian nilai ke variabel secara langsung. Tingkatan-tingkatan dalam operator Precedence First (High) Second Third Fourth (Low) operator NOT + – * / div mod AND + – OR XOR = <> < > >= <= Keterangan Unary operator Perkalian dan pembagian Boolean Penjumlahan Boolean Relasional H. Begitu pula dengan string dan char. char dapat diberikan ke string. 13 . namun tidak sebaliknya.a True False a true true false false b true false true false not a False True a and b true false false false a or b true true true false a xor b false true true false 5. Notasi yang digunakan adalah  . maka berlaku tipe yang lebih luas dapat menampung tipe yang lebih sempit. sebaliknya tipe real tidak dapat ditampung oleh tipe integer. Syarat penugasan adalah nilai yang diberikan harus sesuai dengan tipe variabel.

p4-6). Knuth (1973.b : integer c. 2.d : real nama1. nama2 : string huruf : char ketemu : boolean {boleh} {tidak boleh karena a tidak dapat menampung real} {tidak boleh karena b+c bertipe real} {boleh}  {boleh} {boleh} a  b + c huruf  „?‟ nama1  „Ani‟ nama1  „a‟ huruf  nama1 ketemu  true nama2  nama1 + huruf {boleh} {tidak boleh karena nama1 bertipe string} {boleh} ketemu  „true‟ {tidak boleh karena „true‟ bertipe string} I . Definiteness Setiap langkah dari suatu algoritma harus terdefinisi secara tepat (logis). Finiteness Algoritma harus selalu berakhir setelah melakukan sejumlah langkah berhingga. ataupun memiliki satu atau lebih dari satu input. Output Suatu algoritma harus memiliki paling sedikit satu output. 5. algoritma memiliki 5 ciri pokok. 3.5 {boleh} {boleh} b  a + 4 Deklarasi: a. 4. 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. yaitu: 1. I nput da n O utp ut Menurut Donald E.Contohnya: 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| Deskripsi: a  3 c  3 a  0. Effectiveness Algoritma yang dibuat diharapkan efektif. Input Suatu algoritma dapat tidak memiliki input. 14 .

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

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| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| Algoritma ContohPengoutputan {berisi contoh-contoh penggunaan write untuk mencetak data} deklarasi: const k = 0.5 a : integer b : real c : char d : string e : boolean deskripsi read(a) {menginput sebuah data integer} write(a) {mencetak data hasil input tadi} write(b) {tidak boleh, karena variabel b belum ada isinya} c  „y‟ d  „stmik‟ write(c,d) {mencetak isi variabel c dan d} {mencetak Susi kuliah di stmik} {mencetak bilangan 11, yaitu hasil dari 5+6} write(„Susi kuliah di „,d) write(5 + 6) e  2 = 1 + 3 write(e) {mencetak FALSE karena e berisikan false} 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| 02| 03| 04| 05| 06| 07| 08| Algoritma Contoh_Runtunan_1 Deklarasi: a, b : integer Deskripsi a  10 a  2*a b  a write(b) {mencetak nilai 20}

01| 02| 03| 04| 05| 06| 07| 08|

Algoritma Contoh_Runtunan_2 Deklarasi: a, b : integer Deskripsi a  10 b  a a  2*a write(b) {mencetak nilai 10}

Dalam contoh di atas, instruksi ke-2 dan ke-3 dipertukarkan, ternyata menghasilkan output atau keluaran yang berbeda. Hal ini menunjukkan bahwa urutan instruksi merupakan hal yang sangat penting karena sangat mempengaruhi hasil output.

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| 02| Algoritma Menghitung_Luas_Segitiga {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} Deklarasi: a, t, L Deskripsi read(a,t) L  0.5 * a * t write(L) : real

03| 04| 05| 06| 07| 08|

2. Algoritma Komisi Salesman () Buatlah algoritma untuk menghitung komisi yang diterima salesman berdasarkan jumlah penjualan yang dicapainya. Salesman tersebut mendapat komisi 10% dari hasil penjualannya. Input algoritma ini adalah nama salesman dan jumlah penjualan yang dicapainya. Sedangkan outputnya adalah nama salesman dan besar komisi yang diperolehnya. Analisis: input: nama salesman (nama) dan jumlah penjualan (j) output: nama salesman (nama) dan besar komisi (komisi) rumus: komisi = 10% x jumlah penjualan Langkah pengerjaan: 1. menginput data nama salesman dan jumlah penjualan 2. menghitung komisi menggunakan rumus 3. mencetak nama dan komisi

18

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

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

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

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

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

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

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

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

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. 2. Algoritma Pengecekan Negatif () Buatlah algoritma untuk mencetak kata “negatif” apabila user menginputkan suatu bilangan negatif. Analisis: Suatu bilangan dikatakan negatif apabila bilangan tersebut kurang daripada nol. Langkah pengerjaan: 1. Input suatu bilangan, misalkan n 2. Cek kondisi n<0. Apabila bernilai true, cetaklah kata “negatif”.
01| 02| 03| 04| 05| 06| 07| 08| 09| Algoritma Pengecekan_Negatif {Diinput suatu “negatif”} Deklarasi: n : real Deskripsi Read(n) If n<0 then write(„negatif‟) end if bilangan, apabila negatif, maka cetaklah kata

3. Algoritma Pemberian Diskon () Sebuah toko yang sedang melakukan promosi memberikan diskon sebesar 10% untuk pembeli yang melakukan transaksi minimal Rp100.000,00. Buatlah algoritma untuk menampilkan diskon dan total yang harus dibayar pembeli. Analisis: input: Total belanja pembeli (belanja) output: besarnya diskon (diskon) dan total pembayaran (total) Langkah pengerjaan: 1. input total belanja pembeli 2. cek kondisi belanja ≥ Rp100.000,00. Apabila bernilai true maka menghitung diskon dengan rumus diskon = 10% x belanja.

27

3. Hitung total pembayaran dengan rumus total = belanja – diskon 4. Cetak nilai diskon dan total pembayaran.
01| 02| Algoritma Pemberian_Diskon {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.} Deklarasi: belanja : integer diskon, total : real Deskripsi read(belanja) if belanja >= 100000 then diskon  0.1 * belanja end if total  belanja – diskon write(diskon, total)

03| 04| 05| 06| 07| 08| 09| 10| 11| 12|

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| 02| Algoritma Pemberian_Diskon {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.} Deklarasi: belanja : integer diskon, total : real Deskripsi read(belanja) diskon  0 {inisialisasi} if belanja >= 100000 then diskon  0.1 * belanja end if total  belanja – diskon write(diskon, total)

03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13|

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. 2. Algoritma Ganjil Genap () Buatlah algoritma untuk mencetak kata “GENAP” apabila bilangan bulat yang diinputkan user adalah bilangan genap, dan mencetak kata “GANJIL” apabila bilangan bulat yang diinputkan user adalah bilangan ganjil. Analisis: input: suatu bilangan bulat (n) Kita tahu bahwa suatu bilangan bulat apabila bukan genap, pastilah merupakan bilangan ganjil. Jadi, kasus ganjil dan genap merupakan sesuatu yang berlawanan. Hal ini tergolong ke dalam struktur pemilihan 2 kasus. Syarat suatu bilangan dikatakan genap adalah bilangan tersebut habis dibagi 2. Dengan kata lain, bilangan n dibagi dengan 2 bersisa 0. Operator untuk menghitung sisa hasil bagi adalah MOD. Jadi syarat bahwa n bilangan genap adalah n mod 2 = 0.
01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| Algoritma Menentukan_Genap_Ganjil {Mencetak “Genap” bila bilangan yang diinput user adalah genap, dan “Ganjil” bila ganjil} Deklarasi: n : integer Deskripsi read(n) if n mod 2 = 0 then write(„GENAP‟) else write(„GANJIL‟) end if

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

29

03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| Deklarasi: n : integer genap : boolean Deskripsi read(n) genap  n mod 2 = 0 if genap = TRUE then write(„Genap‟) else write(„Ganjil‟) 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. Diperoleh 4 mod 2 = 0 adalah bernilai TRUE. Maka .... isi variabel genap dibandingkan dengan nilai boolean TRUE. Maka n berisikan bilangan bulat 4. Karena TRUE = TRUE adalah TRUE.. Berdasarkan pengamatan ini. Selanjutnya dalam baris ke-09. yaitu syaratnya diganti menjadi genap = FALSE. if genap then . 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.. maka algoritma menghasilkan output “GENAP”. maka baris ke-09 pada algoritma di atas dapat diganti menjadi if genap then. Kemudian nilai TRUE tersebut akan diisikan ke variabel genap. Algoritma di atas juga dapat ditulis dari sudut pandang GANJIL.. Misalnya user menginput bilangan 4. . if genap = FALSE then write(‘GANJIL’) else write(‘GENAP’) end if 30 .

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

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

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

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

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

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

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

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

YA Tidak terletak pada kuadran manapun.y) if (x = 0) or (y = 0) then kuadran  0 else if x > 0 then {di sebelah kanan sumbu-y} {terletak di salah satu sumbu} 39 . y. (Kuadran 0) END END A Titik terletak di sumbu? MULAI Terdapat 4 pilihan: kuadran 1 kuadran 2 kuadran 3 kuadran 4 SELESAI TIDAK A Tersisa 2 pilihan: kuadran 2 kuadran 3 TIDAK X>0? YA Tersisa 2 pilihan: kuadran 1 kuadran 4 Y>0? Kuadran 2 Y>0? Kuadran 1 END Kuadran 3 Kuadran 4 END END END 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| Algoritma Menentukan_Kuadran {Menentukan kuadran dari suatu titik koordinat} Deklarasi: x. kuadran : integer Deskripsi read(x.

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

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

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

sebelum menambahkan 1 ke hh. kemudian nilai mm ditambahkan 1. dengan hh adalah jam. kemudian nilai hh ditambahkan 1. maka berarti mm bernilai 0. maka algoritma menghasilkan 02:13:24. Buatlah algoritma untuk menampilkan data waktu tersebut setelah ditambahkan 1 detik.28| 29| end if write(grade) 7. yaitu dengan syarat mm + 1 < 60. Akan tetapi. Jika tidak. Jika tidak. dan ss adalah detik. Perhatikan tabel berikut. yaitu dengan syarat ss + 1 < 60. Namun ada beberapa data waktu yang rumit bila ditambah 1 detik. Sepintas terlihat sederhana. kita perlu mengecek apakah bisa ditambahkan secara langsung seperti tabel baris ke-1. kita perlu mengecek apakah mm bisa ditambahkan secara langsung seperti tabel baris ke-2. Data Waktu 02:13:23 02:13:59 02:59:59 23:59:59 Setelah penambahan 1 detik 02:13:24 02:14:00 03:00:00 00:00:00 Maka sebelum detik ditambahkan. maka berarti ss bernilai 0. kita perlu mengecek apakah hh bisa ditambahkan secara langsung seperti tabel baris ke-3. Akan tetapi. Analisis: Misalkan data waktunya adalah 02:13:23. sebelum menambahkan 1 ke mm. Jika tidak. ss+1 < 60? TIDAK ss  0 mm+1 < 60? YA mm + 1 YA TIDAK ss + 1 mm  0 hh+1 < 24? TIDAK hh  0 YA hh + 1 43 . Algoritma Penambahan 1 Detik Pada Waktu () Diberikan suatu data waktu dalam bentuk hh:mm:ss. yaitu dengan syarat hh + 1 < 24. mm adalah menit. maka berarti hh bernilai 0 seperti tabel baris ke-4.

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

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

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

yaitu c.b. terbesar : real Deskripsi read(a. b. terbesar  a (b > terbesar)? YA terbesar  b (c > terbesar)? YA terbesar  c 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| Algoritma Terbesar_Dari_3_Bilangan_C {Menentukan sekuensial} Deklarasi: a. dan asumsi itulah yang benar terbesar. Jika tidak. Bandingkan asumsi dengan bilangan berikutnya. maka c adalah yang terbesar.3. maka asumsi tidak berubah. c.c) terbesar  a if b > terbesar then terbesar  b end if if c > terbesar then terbesar  c end if write(terbesar) terbesar dari 3 bilangan menggunakan metode 47 . Jika c lebih besar.

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

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

01| 02| 03| 04| 05| 06| Deklarasi: k : integer Deskripsi for k  1 to 5 do write(„Stmik Pontianak‟) end for Misalkan Anda diminta untuk membuat algoritma yang mencetak kalimat “Stmik Pontianak” sebanyak n kali. Ambil suatu data real. Sedangkan bentuk II adalah bentuk menurun yaitu nilai dari pencacah akan berubah dari nilai_akhir ke nilai_awal dengan penurunan satu-satu.51 atau 1. dengan nilai n ditentukan oleh user. Nilai_awal dan nilai_akhir merupakan suatu nilai yang bertipe yang sama dengan tipe variabel pencacah. Bedanya adalah bentuk I adalah bentuk menaik yaitu nilai dari pencacah akan berubah dari nilai_awal ke nilai_akhir dengan kenaikan satu-satu. maka proses sama sekali tidak akan dikerjakan.511 ataukah 1. 01| 02| 03| Deklarasi: k. maka proses hanya akan dikerjakan 1 kali. Hal lainnya adalah bahwa proses dalam FOR tidak boleh mengubah nilai variabel pencacah. misalnya data 1. Apabila nilai_awal > nilai_akhir. Contoh-contoh Perhatikan penggalan algoritma berikut ini. Apabila nilai_awal = nilai_akhir. karena Anda tidak dapat mengetahui secara pasti berapa nilai n yang akan diinputkan oleh user.5111? Oleh karena tidak dapat ditentukan data berikutnya secara pasti.5? Apakah 1. Pengulangan bentuk I dan II akan mengulang mengerjakan proses_1 hingga proses_n sebanyak (nilai_akhir – nilai_awal + 1). 1. maka tipe real dikatakan bukan tipe data ordinal.5. berapakah data real sesudah 1. Oleh karena itu. 01| 02| 03| 04| 05| 06| Deskripsi write(„Stmik Pontianak‟) write(„Stmik Pontianak‟) write(„Stmik Pontianak‟) write(„Stmik Pontianak‟) write(„Stmik Pontianak‟) Bentuk di atas dapat kita sederhanakan dengan menggunakan struktur pengulangan FOR. ada hal-hal yang harus diperhatikan. Anda dapat menggunakan struktur FOR. n : integer {sebagai variabel pencacah} {sebagai input banyaknya pengulangan} 50 . Dalam penggunaan bentuk FOR ini. Maka Anda tidak dapat menggunakan cara pertama.real bukan ordinal.

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

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

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

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

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

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

2... a a a a 01| 02| 03| 04| 05| 06| 07| 08| 09| Algoritma Menghitung_a_Pangkat_n {menghitung nilai a pangkat n dengan a real dan n integer} Deklarasi: a : real k. Situasi tersebut dapat dibagi menjadi beberapa pilihan seperti pada tabel berikut: a a=0 a<0 a>0 n n≤0 n>0 n=0 n>0 n<0 Hasil dari a n Tak terdefinisi 0 1 a.2  1  1  1       2  2  2  Algoritma di atas hanya berlaku untuk baris yang diarsir..a.. true bila sebaliknya} Deskripsi read(a. Perhatikan tabel berikut: hasil an 0 Tak terdefinisi 0 3 Tak terdefinisi 0 3 0 0 0 1 (2) (2)3 (2) 3 20 23 23 (-2)(-2)(-2)  1  1  1          2  2  2  1 2. n : integer pangkat : real {karena salah satu hasilnya menggunakan 1/a} valid:boolean {false bila tak terdefinisi.a 1 1 1 1 .09| 10| 11| 12| for k  1 to n do pangkat  pangkat * a end for write(pangkat) Tetapi algoritma di atas mempunyai banyak kelemahan. .n) 57 . Oleh karena itu. . algoritma kita harus dapat mengenali situasi selain yang diarsir.

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

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

Cek nilai dari kondisi2. kondisi dalam repeat dan while dapat berupa ekspresi yang menghasilkan nilai boolean. 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| Algoritma Contoh_Repeat {Memakai struktur repeat untuk mencetak bilangan 1. maka dapat disimpulkan perbedaan antara penggunaan struktur repeat dan while. kemudian kembali ke langkah 1.Langkah-langkah yang dikerjakan algoritma struktur repeat. dan bila kondisi1 bernilai FALSE. maka proses1 hingga prosesn akan dikerjakan. yaitu: 1. kondisi dicek sebelum proses dikerjakan 2. 2. Contoh-contoh di bawah ini memperlihatkan bagaimana langkah kerja struktur repeat dan struktur while. maka struktur while berakhir. 2. Langkah-langkah yang dikerjakan algoritma struktur while. yaitu: Struktur Repeat Struktur While 1. proses ada kemungkinan tak dikerjakan 3. 3. Bila bernilai FALSE. Oleh karena itu. kondisi merupakan syarat untuk mengakhiri pengulangan mengulangi proses Hal-hal yang harus diperhatikan dalam struktur repeat dan while. maupun variabel bertipe boolean. harus ada suatu proses dalam struktur repeat dan while yang dapat mengubah nilai kondisi. proses dikerjakan minimal 1x 2. kondisi dicek setelah proses dikerjakan 1. yaitu: 1. maka mengulangi mengerjakan langkah 1. kondisi merupakan syarat untuk 3. Bila bernilai TRUE. Bila kondisi1 bernilai TRUE. yaitu: 1. maka struktur repeat berakhir. Kerjakan proses1 hingga prosesn secara berurutan 2.3} Deklarasi: k : integer Deskripsi k  1 repeat write(k) k  k + 1 until k > 3 write(„selesai‟) {baris ini yang mengubah nilai kondisi} 60 . kondisi harus memiliki kemungkinan untuk berubah nilai. Berdasarkan penjelasan di atas.2.

variabel k diisikan nilai 3 + 1 = 4. sehingga k bernilai 4 13. kembali ke baris ke-07 10. mencetak nilai k yaitu 1 4. karena k <= 3 bernilai TRUE. karena k > 3 bernilai TRUE. variabel k diisikan nilai 2 + 1 = 3. mencetak nilai string ‘selesai’ 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| Algoritma Contoh_While {Memakai struktur while untuk mencetak bilangan 1. sehingga k bernilai 4 10. kembali ke baris ke-07 6. mencetak string ‘selesai’ 61 .Langkah kerja algoritma di atas adalah: 1. sehingga k bernilai 2 4. karena k > 3 bernilai FALSE. maka algoritma mengerjakan baris ke-08 7. mencetak nilai k yaitu 3 12. maka mengulangi baris ke-08 pada algoritma 5. sehingga k bernilai 2 5. variabel k diisikan nilai 1 2.2.3} Deklarasi: k : integer Deskripsi k  1 while k <= 3 do write(k) k  k + 1 end while write(„selesai‟) Langkah kerja algoritma di atas adalah: 1. variabel k diisikan nilai 1 + 1 = 2. maka algoritma loncat ke baris ke-11 15. sehingga k bernilai 3 9. kembali ke baris ke-07 14. karena k <= 3 bernilai TRUE. maka algoritma mengerjakan baris ke-08 (apabila false. sehingga k bernilai 3 7. maka algoritma mengerjakan baris ke-08 11. maka langsung loncat ke baris ke-11) 3. karena k > 3 bernilai FALSE. karena k <= 3 bernilai FALSE. variabel k diisikan nilai 3 + 1 = 4. karena k <= 3 bernilai TRUE. mencetak nilai k yaitu 2 8. variabel k diisikan nilai 1 + 1 = 2. variabel k diisikan nilai 2 + 1 = 3. mencetak nilai k yaitu 2 6. variabel k diisikan nilai 1 2. maka mengulangi baris ke-08 pada algoritma 8. maka lanjut ke baris-11 11. mencetak nilai k yaitu 3 9. mencetak nilai k yaitu 1 3.

Perhatikan dua penggalan algoritma berikut ini: 01| 02| 03| 04| 05| 06| 07| 08| 09| deklarasi: k. Akan tetapi tidak semua masalah yang diselesaikan oleh repeat dapat secara langsung dikonversi menjadi bentuk struktur while. maka algoritma dengan struktur repeat akan menghasilkan output angka 1. maka algoritma di atas menghasilkan output yang sama. yaitu bilangan dari 1 hingga n. Pada algoritma di atas. Algoritma menghasilkan output berupa hasil jumlahan data dari user tersebut. Berikut ini adalah contoh-contoh penerapan pembuatan algoritma dengan menggunakan struktur repeat maupun while. sedangkan algoritma dengan struktur while tidak menghasilkan output apapun. struktur repeat mempunyai kondisi “k > 3”. hanya saja kondisi (syarat) mereka adalah saling berlawanan. n : integer Deskripsi read(n) k  1 repeat write(k) k  k + 1 until k > n 01| 02| 03| 04| 05| 06| 07| 08| 09| deklarasi: k. n : integer Deskripsi read(n) k  1 while k <= n do write(k) k  k + 1 end while Apabila nilai n ≥ 1. sedangkan struktur while mempunyai kondisi “k <= 3”. 62 . Akan tetapi apabila n < 1.Dari dua algoritma di atas. dapat kita simpulkan bahwa pada dasarnya struktur repeat dan while dapat digunakan untuk memecahkan masalah yang sama. Algoritma Menghitung Jumlahan Data Buatlah algoritma untuk meminta input data bilangan secara terus-menerus dari user hingga user menyudahi pengisian data. 1.

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

data : real Deskripsi jumlah  0 repeat read(data) jumlah  jumlah + data until data < 0 jumlah  jumlah – data write(jumlah) {mengapa demikian?} 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| Berikut ini merupakan cara pertama dan cara kedua menggunakan struktur while 01| 02| Algoritma Penjumlahan_data_cara_pertama_while {Meminta input data secara terus menerus.01| 02| Algoritma Penjumlahan_data_cara_kedua {Meminta input data bilangan dari user secara terus menerus. Setiap kali selesai menginput sebuah data. Algoritma ini menggunakan struktur REPEAT. Outputnya adalah jumlahan datanya. User diharapkan menjawab huruf „T‟ untuk menyudahi pengisian. jumlah : real tanya : char Deskripsi jumlah  0 read(data) jumlah  jumlah + data read(tanya) while (tanya <> „T) and (tanya <> „t‟) do read(data) jumlah  jumlah + data read(tanya) end while write(jumlah) 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 64 . user ditanyakan apakah masih mempunyai data.} Deklarasi: jumlah. Bila user ingin menyudahi pengisian data. Algoritma ini menggunakan struktur WHILE} Deklarasi: data. maka user diharapkan untuk menginput data negatif.

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

password anda benar‟) else write(„Sudah 3 kali kesalahan.10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| benar  FALSE {user belum memasukkan password yang benar} repeat read(pw) {meminta input password dari user} {user input password yang benar} if pw = password then benar  TRUE else end if until benar or (k = 3) {mencetak pesan sesuai kondisi} if benar then write(„Selamat. Tiga {untuk menampung banyaknya kesalahan} pw : string {untuk menampung input password dari user} 66 . Anda gagal!‟) end if {user memasukkan password yang salah} {banyaknya kesalahan ditambah 1} k  k + 1 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| Algoritma Input_Password_While {Menginput password dengan kesalahan berarti gagal.} Deklarasi: const password = „StMiK‟ benar : boolean k : integer Deskripsi k  0 benar  FALSE while not benar and (k < 3) do read(pw) if pw = password then benar  TRUE else k  k + 1 end if end while {kata sandinya adalah StMiK} {TRUE bila password benar. FALSE bila salah} menggunakan struktur while.

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

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

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

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

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

Antara suatu bahasa pemrograman dengan bahasa pemrograman lainnya mendefinisikan tipe string dengan caranya tersendiri). 2. char. yaitu tipe data yang hanya dapat menyimpan satu data dalam satu variabel. variabel data dikatakan mempunyai indeks dari 1 sampai 10. Variabel data tersebut dapat digambarkan sebagai berikut: 72 . Tipe-tipe sederhana yang telah kita pelajari yaitu integer. Dalam hal ini. hanya saja bentuk pendeklarasian yang ke-dua walaupun lebih panjang. Selama ini. tipe data yang kita pelajari merupakan tipe data sederhana. Dengan menggunakan array. kita dapat menyimpan sekumpulan data yang bertipe sama hanya dalam satu variabel. string. Pe nda hu lua n 1. dan boolean (keterangan: tipe data string pada beberapa bahasa pemrograman tidak termasuk tipe data sederhana. Pengertian Array atau larik (bahasa Indonesia) yaitu suatu tipe data terstruktur yang dapat menyimpan lebih dari satu data yang bertipe sama. 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. 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. real. sehingga variabel data dapat menyimpan maksimal 10 data bertipe real.max] of Tdata data : Tlarik Pendeklarasian variabel data di atas adalah sama. namun lebih terstruktur..BAB VI : ARRAY (LARIK) A.

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

Algoritma Menghitung Rata-rata Buatlah algoritma untuk menginput n buah data integer. Misalkan contoh di atas hendak dikembangkan untuk 100 data integer.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.a3. karena tidak menyebutkan indeks} read(data) {salah.. B . 74 . Ar r a y 1 Dim e ns i 1.a5 : integer Deskripsi a1  0 a2  0 a3  0 a4  0 a5  0 Deklarasi: a : array[1. kemudian algoritma akan menghitung rata-ratanya. karena tidak menyebutkan indeks} data[4]data[1]+data[2] {jumlah indeks 1&2 dimasukkan ke indeks 4} Kelebihan penggunaan array dibanding tipe data sederhana: Deklarasi: a1.a2.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.a4. bagaimana algoritmanya menggunakan tipe data sederhana? Tentu akan menjadi sangat panjang dan tidak terstruktur.

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

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

01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24|

Algoritma Menentukan_Terbesar_Indeks {Menginput n buah data integer, kemudian mencari indeks terbesarnya. algoritma tetap menampilkan nilai terbesarnya} Deklarasi: const max = 30 type Tdata = integer type Tlarik = array[1..max] of Tdata data : Tlarik k, n : integer t : integer {menyimpan indeks data terbesar} Deskripsi read(n) for k  1 to n do read(data[k]) end for {asumsi data pertama yg terbesar, maka simpan indeks 1} t  1 {membandingkan data ke-t dengan data berikut hingga terakhir} for k  2 to n do if data[k] > data[t] then t  k end if end for {mencetak nilai terbesar berarti mencetak data ke-t} write(data[t]) data

3. Algoritma Menentukan Nama Mahasiswa Nilai Tertinggi Buatlah algoritma untuk menginputkan n buah nama dan nilai mahasiswa. Kemudian algoritma akan menampilkan nama dan nilai mahasiswa tertinggi. Analisis: Kita dapat memakai teknik menyimpan nama sekaligus nilai tertinggi seperti berikut:
01| 02| 03| 04| 05| 06| 07| Algoritma Menentukan_Nilai_Tertinggi {menginput n data nama dan nilai, cetak nama dan nilai tertinggi} Deklarasi const max = 30 type TNama = string type TNilai = real type TLarikNama = array[1..max] of TNama

77

08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29|

type TLarikNilai = array[1..max] of TNilai nama : TLarikNama nilai : TLarikNilai k, n : integer namat : TNama Deskripsi read(n) for k  1 to n do read(nama[k], nilai[k]) end for {asumsi data pertama adalah yg tertinggi} namat  nama[1] nilait  nilai[1] {bandingkan nilait dengan nilai berikut hingga terakhir} for k  2 to n do if nilai[k] > nilait then namat  nama[k] nilait  nilai[k] end if end for Write(namat, nilait) {menyimpan nama yg tertinggi} nilait : TNilai {menyimpan nilai yg tertinggi}

Namun algoritma di atas memerlukan 2 variabel untuk menyimpan tertingginya. Algoritma berikut hanya memerlukan 1 variabel yang digunakan untuk menyimpan indeks nilai tertingginya.
01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| Algoritma Menentukan_Nilai_Tertinggi {menginput n data nama dan nilai, cetak nama dan nilai tertinggi} Deklarasi const max = 30 type TNama = string type TNilai = real type TLarikNama = array[1..max] of TNama type TLarikNilai = array[1..max] of TNilai nama : TLarikNama nilai : TLarikNilai k, n : integer t : integer {menyimpan indeks nilai yg tertinggi}

78

13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27|

Deskripsi read(n) for k  1 to n do read(nama[k], nilai[k]) end for {asumsi data pertama adalah yg tertinggi} t  1 {Bandingkan nilai ke-t dengan nilai berikut hingga terakhir} for k  2 to n do if nilai[k] > nilai[t] then t  k end if end for {mencetak nama dan nilai tertinggi} write(nama[t], nilai[t])

Nah, manakah teknik yang lebih baik menurut anda? 4. Algoritma Menghitung Jumlah Kelulusan Diinputkan n buah data nilai mahasiswa. Apabila nilai minimum kelulusan adalah 60.00, buatlah algoritma untuk menampilkan banyaknya yang lulus dan yang tidak lulus. Analisis: Algoritma ini termasuk mudah. Kita deklarasikan 2 variabel bertipe integer untuk menyimpan banyaknya mahasiswa yang lulus dan yang tidak lulus, kemudian tambahkanlah angka 1 ke variabel yang berkesesuaian dengan nilai yang diperoleh mahasiswa.
01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| Algoritma Jumlah_Kelulusan {menginputkan n buah data nilai mahasiswa, kemudian menghitung banyaknya yang lulus dan yang tidak lulus} Deklarasi: const max = 50 type TNilai = real type TLarik = array[1..max] of TNilai nilai : TLarik k,n : integer nLulus, nTLulus : integer Deskripsi read(n) for k  1 to n do {menyimpan jumlah kelulusan}

79

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

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

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

nc.49| 50| 51| 52| 53| 54| 55| 56| 57| 58| 59| 60| 61| 62| 63| 64| if grade[k] = ‘B’ then nb  nb + 1 else if grade[k] = ‘C’ then nc  nc + 1 else if grade[k] = ‘D’ then nd  nd + 1 else ne  ne + 1 end if end if end if end if end for write(na.ne) Bandingkan algoritma di atas dengan algoritma di bawah ini: 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| Algoritma Rekapitulasi_Grade {menginput n buah nilai.nd.max] of TGrade nilai : TLarikNilai grade : TLarikGrade nGrade : array[„A‟. n : integer m : char {pencacah bertipe char} Deskripsi read(n) for k  1 to n do read(nilai[k]) end for 83 .nb.‟E‟] of integer {menyimpan masing2 grade} k. kemudian menghitung banyaknya mahasiswa untuk masing-masing grade} Deklarasi: const max = 50 type TNilai = real type TGrade = char type TLarikNilai = array[1.. menentukan grade.max] of TNilai type TLarikGrade = array[1...

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

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

atau mencetak informasi bila data tidak ditemukan} Deklarasi: const max = 50 type TData = integer type TLarik = array[1.24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| ketemu  TRUE else k  k + 1 end if until ketemu or (k>n) {mencetak informasi} if ketemu then write(k) else write(„Data tidak ditemukan‟) end if {mencetak posisi data ditemukan} {hingga data ditemukan atau data habis} {cari untuk data berikutnya} Sebenarnya algoritma di atas dapat diperbaiki. Algoritma mencetak indeks data jika ditemukan. yaitu dengan menghilangkan variabel ketemu..max] of TData data : TLarik x : TData Deskripsi read(n) for k  1 to n do read(data[k]) end for {meminta input dari user data yang hendak dicari} read(x) {pemberian nilai awal} k  0 repeat k  k + 1 {mengapa kali ini diberi nilai awal 0?} {menyimpan data yang hendak dicari} k. Algoritma selengkapnya disajikan berikut ini. kemudian user menginputkan data yang hendak dicari. 01| 02| Algoritma Pencarian_Metode_Sekuensial {Diinputkan n buah data bilangan bulat. Bila nilai k  n berarti data tidak ditemukan karena variabel k merupakan penunjuk posisi data ditemukan. Tekniknya adalah menggunakan nilai k sebagai acuan. n : integer 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 86 .

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

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

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

maka tukar b. lakukan a. Metode Pengurutan Bubble (Bubble Sort) Ide dasar dari metode ini adalah 1. 90 . Jika data[2] > data[3].1. maka tukar. 4. bandingkan data ke-1 dengan data ke-2. jika data[1] > data[3]. jika data[2] > data[3]. 2. 4. d. jika data[1] > data[n]. Untuk k = n-1. maka tukar c. Setelah melakukan langkah ini.. bandingkan data ke-2 dengan data ke-3.. 2. . 4. d. maka tukar c... maka tukar. Maka data akan terurut secara ascending Perhatikan bahwa langkah-langkah di atas dapat disimpulkan menjadi berikut: 1. lakukan a. maka tukar. bandingkan data ke-1 dengan data ke-3. maka tukar. membawa data terkecil dari data ke-1 s/d ke-n menjadi data[1] 2. Jika data[n-1] > data[n]. . maka tukar 3. maka tukar. membawa data terkecil dari data ke-(n-1) s/d ke-n menjadi data[n-1] Untuk melakukan langkah pertama dilakukan dengan cara berikut: 1.. Jika data[2] > data[4]. Jika data[2] > data[n]. 3. lakukan a. Setelah melakukan langkah ini. Lakukan langkah ke-3 dengan pola yang sama hingga langkah ke-(n-1). maka tukar.. . maka data[2] merupakan data terkecil dari data ke-2 s/d data ke-n. maka tukar b. jika data[1] > data[3]. jika data[2] > data[n]. . bandingkan data ke-2 dengan data ke-n. Untuk k = 2. jika data[2] > data[4]... kita melakukan proses perbandingan data[k] dengan data[m] dengan nilai m adalah dari k+1 s/d n. jika data[1] > data[2]. bandingkan data ke-1 dengan data ke-n. maka data[1] merupakan data terkecil dari data ke-1 s/d data ke-n. bandingkan data ke-2 dengan data ke-4. .. maka tukar 2. . maka tukar Perhatikan bahwa untuk masing-masing nilai k. Untuk k = 1. 3. Untuk melakukan langkah ke-2 dilakukan dengan cara berikut: 1.. 4... jika data[1] > data[n]. jika data[1] > data[2]. membawa data terkecil dari data ke-2 s/d ke-n menjadi data[2] 3.

data[5] Tukar data[4]. 4 2 3 3 2 2 7 2 7 2 7 2 7 4 1 1 3 3 3 5 5 5 5 5 5 6 4 4 4 4 4 7 3 5 4 5 7 7 7 5 5 4 4 4 4 7 7 5 {menginput n buah data kemudian mengurutkannya secara ascending menggunakan metode bubble} Deklarasi: const max = 50 type Tdata = integer type TLarik = array[1. data[2] Tukar data[1].. 5. data[3] Tukar data[1]. Untuk sisanya Data ke-1 s/d ke-2 sudah urut Untuk sisanya Tukar data[3]. 1. m. data[6] Data ke-1 s/d ke-4 sudah urut Untuk sisanya Tukar data[5].data[6] Data sudah urut Algoritmanya adalah sebagai berikut: 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| Algoritma Pengurutan_Bubble 2. 3.max] of TData data : TLarik temp : TData Deskripsi read(n) for k  1 to n do {Temporary untuk menyimpan data yg hendak ditukar} k. data[4] Tetap Tetap Data ke-1 s/d ke-3 sudah urut Untuk sisanya Tukar data[4]. n : integer 91 .Perhatikan contoh berikut ini: Misalkan kita mempunyai data berikut: 1 Keterangan | data keData awal Tukar data[1]. 7. data[4] Tetap Tetap Data ke-1 s/d ke-1 sudah urut.

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

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

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.3. Untuk nilai k = 3. Berarti kartu ke-1 s/d ke-2 sudah urut. Metode Penyisipan (Insertion Sort) Metode ini adalah seperti saat mengurutkan setumpukan kartu. maka 2. Ambil kartu ke-3. Berarti kartu ke-1 s/d ke-3 sudah urut. maka 94 . Sebagai gambarannya. sisipkan apakah tetap di bawah kartu ke-2. sisipkan apakah di atas kartu ke-1 atau tetap di bawah kartu ke-1. atau di atas kartu ke-1. Ambil kartu ke-2. atau di antara kartu ke-1 dan ke-2. Langkah ini dilakukan terus menerus hingga penyisipan kartu terakhir. Untuk nilai k = 2.

Untuk nilai k = 8 (terakhir). maka 5. 95 . Untuk nilai k = 6 maka 6. maka 4. Untuk nilai k = 5. Untuk nilai k = 4. Untuk nilai k = 7 7.3. maka Perhatikan bahwa datanya telah terurutkan.

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

3. maka perintahnya adalah: data[2][1]  7 atau bisa juga disingkat menjadi data[2.. asalkan merupakan salah satu dari tipe integer.E. boleh berlainan.‟a‟. maka array tersebut disebut array multi dimensi....‟d‟] of integer Type TArray2 = Array[1.1..} Deklarasi Type TArray1 = Array[1. Perhatikan deklarasi array berikut: Type TArray1 = ARRAY[1. atau boolean. maka variabel data dapat divisualisasikan sebagai berikut: Jadi bisa dimisalkan bahwa data adalah suatu kotak yang di dalamnya berisikan 5 buah kotak besar dengan masing-masing kotak besar berisikan 3 buah kotak kecil. Ar r a y M ulti Dim e ns i Apabila elemen dari suatu array bertipe array pula.. maka harus disebutkan indeksnya.1]  7 Tipe indeks tidak harus sama. Perhatikan contoh-contoh berikut: 01| 02| 03| 04| 05| 06| 07| Algoritma Contoh_Array_2D {Hanya untuk menunjukkan apa yang boleh dan tidak boleh dilakukan dalam menggunakan variabel Array 2D..4] of real Type TArray3 = Array[1. Untuk mengisikan data ke dalam variabel data. Misalnya hendak dimasukkan data bilangan bulat 7 ke variabel data dalam kotak besar ke-2 dan kotak kecil ke-1.3] of integer Pendeklarasian di atas mempunyai makna bahwa tipe TArray1 merupakan array yang berindeks 1 s/d 5 dengan tiap-tiap elemennya merupakan array yang berindeks 1 s/d 3 dengan tipe elemen integer.3] of TArray2 data1 : TArray1 97 .5] of ARRAY[1.5.3] of integer Atau disingkat menjadi Type TArray1 = ARRAY[1.. Misalkan kita mempunyai variabel data bertipe TArray1. char.

4] of real} data3[1]  data2 Secara umum.indeksn] of tipe_element Sebagai contohnya..indeks2.32 {Memasukkan 5.1..‟B‟]  4 98 ..3]  1.‟d‟] of integer} data1[2]  data1[1] {memasukkan data 3.08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| data2 : TArray2 data3 : TArray3 Deskripsi {memasukan data 5 ke data1 indeks (1. pendeklarasian array berdimensi banyak adalah sebagai berikut: TYPE namatipe = ARRAY[indeks1.3 {Benar karena sama2 bertipe array[1...‟b‟] } data1[2.‟c‟.‟b‟]  data1[1.4..‟a‟] {salah karena 5 bukan bertipe array} data1[2]  5 {benar karena sama2 bertipe array[„a‟.‟a‟] ke data1[2.4 ke data3[1.4]  3.max..‟A‟.‟a) } data1[1.‟E‟] of integer data : TArray Deskripsi data[2..1. dapat dituliskan sebagai berikut: const max = 50 type TArray = Array[1. Sebagai contohnya adalah: 01| 02| 03| 04| 05| Deklarasi type TArray = array[1..4 {Salah karena tidak ada indeks 4....‟a‟]  5 {memasukan data yg terdapat pada data1[1.4] } data3[1.max] of char Cara penggunaan array berdimensi banyak adalah dengan menyebutkan nama variabel diikuti dengan indeksnya yang dipisahkan tanda baca koma. array berdimensi-3 dengan indeks masing-masing bertipe integer dan tipe elemennya adalah karakter.max.‟e.3 ke data2[2]} data2[2]  5.3} data3[4.‟a‟.

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

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

max. Matriks Nol:matriks yang semua elemennya nol 2. Pengisian Oleh User Berikut ini contoh pengisian matriks berukuran m x n dengan ukuran matriks ditentukan oleh user (maksimum 15 x 15).1. Matriks Bujursangkar:matriks berordo n x n 3. Pengisian Matriks Variabel matriks dapat diisi oleh user... Type Tmatriks = Array[1. Teori Algoritma dan Pemrograman Matriks merupakan suatu tipe data array berdimensi-2 dengan tipe elemen sesuai dengan tipe elemen matriks. atau oleh programer (misalnya untuk beberapa matriks khusus seperti matriks identitas. Matriks segitiga atas:matriks bujursangkar yang elemen-elemen dibawah diagonal utamanya bernilai nol. misalnya a22 Beberapa jenis matriks: 1...1. Matriks Skalar:matriks bujursangkar yang elemen-elemen diagonal utamanya bernilai sama. kita akan membuat tipe matriks berukuran yang cukup besar. Contohnya adalah sebagai berikut: Const max = 15 Type Tmatriks = Array[1.3. 5. Matriks Identitas:matriks bujursangkar yang elemen-elemen diagonal utamanya bernilai 1.4] of real A : Tmatriks  a11 a12 a a22 A   21      am1 am 2 Dalam prakteknya. Matriks segitiga bawah:matriks bujursangkar yang elemen-elemen di atas diagonal utamannya bernilai nol. misalnya 15x15 sehingga bisa dipakai untuk matriks yang berukuran hingga maksimum 15x15.max] of real 2. a. Misalkan hendak dideklarasikan suatu variabel A bertipe matriks berordo 3x4 dengan elemen bertipe real. 101 . dsb). a1n   a2 n    (a ) ij m x n      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. b. matriks nol. 6. 4. 7. Matriks Diagonal:matriks bujursangkar yang semua elemen di luar elemen diagonal utamanya bernilai nol.

j : integer Deskripsi {Meminta user menginput ukuran matriks} read(m. hanya saja elemennya tidak di read dari user. Jadi.. melainkan langsung di assignment oleh programmer dengan bilangan nol.n) {meminta user menginput elemen-elemen matriks} for i  1 to m do for j  1 to n do read(A[m. Analisis: Matriks nol adalah matriks yang semua elemennya adalah nol. lalu isikan matriks nol ukuran n x n} Deklarasi const max = 15 Type TElemen = integer Type TMatriks = Array[1..n]) end for end for {ukuran matriks} {pencacah} ukuran matriks..max.max] of TElemen Nol : TMatriks n : integer {matriks nol ukuran n x n} {ukuran matriks} i.1. tekniknya sama dengan pengisian matriks sebelumnya. 01| 02| 03| 04| 05| 06| 07| 08| 09| Algoritma Pengisian_Matriks_Nol {Mendeklarasikan variabel matriks. kemudian mengisikan matriks b. Pengisian Oleh Programmer 1. kemudian buatlah agar variabel tersebut mewakili matriks nol berukuran n x n.j : integer {pencacah} 102 .n : integer i.01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| Algoritma Pengisian_Matriks_Oleh_User {user menginputkan tersebut} Deklarasi Const max = 15 Type TElemen = integer Type TMatriks = array[1.max.max] of TElemen A : TMatriks m.. Deklarasikan suatu variabel bertipe matriks.1.

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

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

j] <> 0 then 4. lalu terapkan algoritma pengecekan matriks identitas dengan pengecekan apabila i  j maka cek apakah elemen = x 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| end if end for end for else skalar  true x  a[1.1] {asumsi benar matriks skalar} {simpan elemen a(1.06| 07| 08| 09| 10| 11| 12| 13| 14| end if end for end for else identitas  false end if {i <> j} identitas  false end if if A[i. Algoritma Penjumlahan Matriks Diberikan dua buah matriks A dan B berukuran m x n.j] <> 0 then c. Pengecekan Matriks Skalar Strateginya adalah ambil elemen a(1. Maka penjumlahan A + B didefinisikan sebagai 105 .1) simpan di x.1) } for i  1 to n do for j  1 to n do if i = j then if A[i.j] <> x then skalar  false end if {i <> j} skalar  false end if if A[i.

j]) end for end for {input matriks B} for i  1 to m do for j  1 to n do read(B[i.j : integer Deskripsi {input ukuran matriks} read(m. B. lalu mencetak isi C.n) {input matriks A} for i  1 to m do for j  1 to n do read(A[i. hitung C = A + B.n : integer i.. kemudian mencetak isi matriks C. a1n   b11 b12  b1n   a2 n   b21 b22  b2 n                 amn  bm1 bm 2  bmn   a11  b11 a12  b12  a1n  b1n  a b   21 21 a22  b22  a2 n  b2 n            am1  bm1 am 2  bm 2  amn  bmn  Buatlah algoritma untuk meminta input ukuran matriks m x n.max. lalu menghitung C = A + B. lalu input matriks A dan B. a12 a22  am 2 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40| Algoritma Penjumlahan_Matriks {input m dan n..max] of TElemen A. C : TMatriks m. kemudian menginputkan matriks A dan B.j]) end for end for {hitung C = A + B}  a11 a A  B   21     am1 106 .1.} Deklarasi const max = 15 Type TElemen = integer Type TMatriks = [1.

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

Ubahlah semua algoritma pengurutan data seperti contoh pada metode bubble. 2.Bandingkan data ke-1 dan 2.14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| 25| 26| 27| 28| 29| 30| 31| 32| 33| 34| 35| 36| 37| 38| 39| 40| {input matriks A ordo mxn} for i  1 to m do for j  1 to n do read(A[i.j] end for end for end for {Cetak isi C ordo mxk} for i  1 to m do for j  1 to k do write(C[i.p]*B[p.j]) end for end for {input matriks B ordo nxk} for i  1 to n do for j  1 to k do read(B[i.j]) end for end for G.j]) end for end for {hitung C = A x B} for i  1 to m do for j  1 to k do C[i. La tiha n 1.j] + A[i. tukar (3>2) 1 3 2 2 2 3 3 5 5 4 1 1 5 4 4 108 .j]  0 {inisialisasi} for p  1 to n do C[i. dan insertion menjadi dalam mode descending. Diketahui metode pengurutan bubble sebagai berikut: Misalnya terdapat data berikut: 3 2 5 1 4 Keterangan \ data keData awal Langkah 1 1. selection.j]  C[i.

3. Buatlah algoritma untuk mengecek apakah suatu matriks A berukuran n x n merupakan matriks: a.Bandingkan data ke-1 dan 2. Bandingkan data ke-1 dan 2. Bmn . dan Cmn kemudian hitung dan cetaklah matriks D  4 A  3B  C 5. Ubahlah algoritma-algoritma tersebut agar algoritma menghentikan proses pengecekan apabila sudah ditemukan bukan tergolong matriks yang dimaksudkan. Suatu matriks A dikatakan kelipatan skalar dari matriks B apabila dapat ditemukan  sedemikian sehingga B   A . Jika ya. tukar (2>1) 2. 5 1 7    Buatlah algoritma untuk menginput matriks A dan B berordo mxn.Bandingkan data ke-3 dan 4.Bandingkan data ke-2 dan 3.Keterangan \ data ke2. 6.Bandingkan data ke-2 dan 3.Bandingkan data ke-3 dan 4. maka diperoleh B  3 A . tetap (2<3) Langkah 4 1. jika tidak. Buatlah algoritma untuk mengecek apakah kedua matriks A dan B yang berukuran mxn adalah sama atau tidak. tetap (2<3) 2. Buatlah algoritma yang meminta input matriks Amn . maka cetak keterangan yang sesuai. Contoh: 1 3 2  3 9 6 A  dan B  15 3 21 . segitiga atas c. data sudah terurut Ascending. tukar (5>1) 4. 1 2 2 2 2 2 2 1 1 1 2 3 3 3 3 1 1 2 2 2 3 5 1 1 1 3 3 3 3 3 4 1 5 4 4 4 4 4 4 4 5 4 4 5 5 5 5 5 5 5 Buatlah algoritma pengurutan data seperti yang diterangkan di atas. maka cetaklah nilai  . tetap (1<2) Selesai. segitiga bawah 4. 109 . Bandingkan data ke-2 dan 3. 7. Bandingkan data ke-1 dan 2. kemudian tentukan apakah matriks A merupakan kelipatan skalar dari matriks B atau tidak. tukar (5>4) Langkah 2 1.Bandingkan data ke-4 dan 5. tukar (3>1) 3. diagonal b. tetap (3<5) 3. Semua algoritma pengecekan matriks pada contoh-contoh di atas tidak menghentikan proses pengecekan walaupun sudah ditemukan bahwa bukan matriks yang dimaksudkan. tetap (3<4) Langkah 3 1.

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

Cara Pemakaian Record Misalkan dideklarasikan variabel data seperti berikut: Deklarasi Type Trecord = Record < nim. dan kotak grade dapat digunakan untuk menyimpan data bertipe char.nilai  84. Dalam hal ini. 3.Pendeklarasian variabel data di atas adalah sama.grade  ‘B’ Else If data. nama. dan grade.nilai >= 60.0 then Data. Variabel data tersebut dapat digambarkan sebagai berikut: Kotak nim dan nama dapat digunakan untuk menyimpan data bertipe string. yaitu field nim.nilai >= 80.78 {mengisikan nilai string ke field nim} Data.nim  ‘061101234’ Data.0 then Data.grade  ‘C’ Else 111 .0 then Data. Grade : char > Data : Trecord Maka cara mengisikan nilai ke dalam variabel data adalah: Deskripsi Data. Nilai : real. hanya saja bentuk pendeklarasian yang ke-2 walaupun lebih panjang. nilai. tipe Trecord dikatakan tipe data record dengan 4 field. Akibatnya dalam hal ini. nama : string. kota nilai dapat digunakan untuk menyimpan data bertipe Tnilai.nilai >= 70. namun lebih terstruktur.grade  ‘A’ Else If data. variabel data yang bertipe Trecord dapat menyimpan 4 buah data yang berlainan tipe.nama  ‘Budiani’ {mengisikan nilai string ke field nama} {mengisikan nilai real ke field nilai} {mengisikan grade sesuai dengan nilai} If data.

kita sudah pernah membuat algoritmanya.If data.nim) Read(data) Write(data) {tercetak 62. m.nilai) Read(data. lalu mengubah selisih total detik tersebut menjadi dalam format waktu (jam. m. dan d.nilai  data. dan d.0 then Data. detik) kembali. Akan dideklarasikan 3 variabel bertipe record dengan field yang demikian. menit.nama) Data. 1 menampung hasil selisih waktunya. menit. Algoritma Perhitungan Selisih Waktu Buatlah algoritma untuk menghitung selisih waktu (jam. yaitu j.nilai >= 40.nilai + 2 Write(data.nama  ‘Tono’ B . yaitu field j. detik) dari 2 data waktu yang diinputkan user. 2 menampung input.nilai  60.nama  ‘Budi’ Write(data.0} {meminta user memasukkan nim} {SALAH. kita akan menggunakan variabel bertipe record dengan 3 bauh field. namun data disimpan dalam masing-masing variabel bertipe integer.} 112 .grade  ‘D’ Else Data. Untuk 1 buah data waktu dibutuhkan 3 buah variabel integer.grade  ‘E’ End if End if End if End if Contoh lainnya adalah Deklarasi Data. Kali ini. kemudian mengubahnya menjadi total detik.0 Data. Analisis: Pada bab terdahulu. 01| 02| Algoritma Menghitung_Selisih_Waktu {Menghitung selisih waktu dengan cara meminta input 2 data waktu (awal dan akhir).nama) Write(data. karena tidak menyebutkan field} {SALAH. C onto h Pe ng guna a n R e c or d 1. Karena tidak menyebutkan field} {tercetak Budi} {tercetak Tono} Data. setelah itu mencari selisih total detik.

d) {menginput waktu akhir} Read(w2.d) {mengubah waktu awal dan waktu akhir menjadi total detik} T1  w1. Algoritma Perhitungan Bilangan Kompleks Sederhana Bilangan kompleks di dalam matematika adalah bilangan yang terdiri dari 2 bagian yaitu bagian real dan bagian imajiner.m.j*3600 + w2.d {menghitung selisih waktu} T3  t2 – t1 {mengubah selisih waktu menjadi jam. detik} W3.2.t3 : integer S : integer Deskripsi {menginput waktu awal} Read(w1. Penjumlahan dua bilangan kompleks didefinisikan sebagai berikut: ( x1  y1i)  ( x2  y2i )  ( x1  x2 )  ( y1  y2 )i dan perkalian dua bilangan kompleks didefinisikan sebagai berikut: 113 . Jadi dapat disimpulkan bahwa nilai x  3 dan y  2. w1.83 . Sedangkan i adalah suatu nilai yang sama dengan Contoh. bilangan 1 .d) 2.m. w1.83i . w2. menit.03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20| 21| 22| 23| 24| Deklarasi Type Twaktu = record <j. 1  3  2 2i  3  2. w2. w3.m*60 + w2.(1)  3  2 2.m. w3.j  t3 div 3600 S  t3 mod 3600 W3.w2. kompleks 3  8  3  4.m*60 + w1. Bentuk umumnya adalah x  yi dengan x merupakan bagian real dan y merupakan bagian imajinernya.j.w3 : Twaktu T1.j. Operasi pada dua bilangan kompleks dapat berupa penjumlahan (pengurangan) dan perkalian.t2.d T2  w2.d  s mod 60 {mencetak selisih waktunya} Write(w3.j*3600 + w1.d : integer> W1.m.j.m  s div 60 W3.

y  z1. yaitu field x untuk bagian real dan field y untuk bagian imajiner. Apabila tipe elemen dari suatu array adalah record.x. maka dikatakan array multidimensi.y h2. Apabila tipe elemen dari suatu array adalah bertipe array.x + z2.y) {bilangan kompleks input dari user} h1.x. Analisis: Untuk bilangan kompleks. buatlah algoritma yang meminta input 2 bilangan kompleks.x – z1.y {hitung hasil perkalian} h2.x*z2.x  z1.y) write(h2.y : real> z1. kemudian hitunglah hasil penjumlahan dan perkaliannya.x.y + z2.x*z1. z2.( x1  y1i )( x2  y2i )  x1 ( x2  y2i )  y1i ( x2  y2i )  x1 x2  x1 y2i  x2 y1i  y1 y2i.y + z2.i  x1 x2  ( x1 y2  x2 y1 )i  y1 y2 (karena i. z1. 114 .y {mencetak hasil jumlah dan kalinya} write(h1. karena terdiri dari 2 bagian.y  z1. h2.i  1)  ( x1 x2  y1 y2 )  ( x1 y2  x2 y1 )i Berdasarkan teori di atas.x*z2.x  z1. maka disebut array of record.x h1. kemudian mencetak hasil jumlah dan perkaliannya} Deklarasi Type TKompleks = record <x.y) Read(z2. Ar r a y of R e c or d 1.z2 : TKompleks Deskripsi {input 2 bilangan kompleks} Read(z1.y*z2. yaitu bagian real dan imajiner.y) {hitung hasil jumlah} h1. h2 : TKompleks {hasil jumlah dan kalinya} C . maka kita membuat tipe kompleks yang merupakan record dengan 2 field. h1. Pengertian Pada bab terdahulu kita telah membicarakan mengenai tipe data array.x. 01| 02| 03| 04| 05| 06| 07| 08| 09| 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| Algoritma Hitung_Bilangan_Kompleks {menginput 2 bilangan kompleks.

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

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

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

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

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