Alprog Modul 1

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-tipe 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 cOUTPUT b

END

FALSETRUE

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. Struktur Penulisan 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) Algoritm a

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 (Identif ier)

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. Variabel

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

}33|{ xxHP . Diinputkan suatu bilangan x. Buatlah algoritma untuk mencetak

“Penyelesaian” bila HPx dan mencetak “Bukan Penyelesaian” bila HPx .

Analisis:

Persyaratan -3 x 3 tidak memenuhi bentuk penulisan eksresi perbandingan yang

benar. Maka persyaratan tersebut harus dipisah menjadi 2 bagian, yaitu x≥-3 dan x3.

Kedua persyaratan tersebut harus digabung dengan menggunakan operator boolean

AND (Mengapa?). Oleh karena itu, persyaratan keanggotaan x secara lengkap adalah

)3()3( xANDx

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|{ xxxxHP . Diinputkan suatu bilangan x.

Buatlah algoritma untuk mencetak “Penyelesaian” bila HPx dan mencetak

“Bukan Penyelesaian” bila HPx .

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( xORx

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 K asus

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

YATIDAK

Y > 0 ? Y > 0 ? Kuadran 1

Kuadran 3

Kuadran 2

Kuadran 4

END

END

END

END

END

END

SELESAIA

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 KabisatBukan

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)


09| kabisat true

10| else


12| kabisat false

13| else


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


15| grade „B‟

16| else


18| grade „C‟

19| else


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 cterbesar 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 300C dan

cuaca dikatakan dingin apabila temperatur kurang dari 250C. Buatlah algoritma

untuk mencetak kata “Panas”, “Dingin”, atau “Normal” sesuai dengan temperatur

yang diinputkan user. Temperatur yang diinputkan oleh user adalah dalam

satuan derajat Fahrenheit.

3. Diberikan suatu persamaan kuadrat ax2 + bx + c = 0 dengan a ≠ 0. Persamaan

tersebut dapat diselesaikan dengan menggunakan rumus ABC, yaitu

a

Dbx

22,1

dengan acbD 42 . 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‟)





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


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


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)


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 na dengan a R dan n Z .

Analisis:

Secara normal, . ...na 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: na hasil 00 Tak terdefinisi 30 Tak terdefinisi

30 0 0( 2) 1 3( 2) (-2)(-2)(-2)

3( 2) 1 1 1

2 2 2

02 1 32 2.2.2

32 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 na

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



7. karena k > 3 bernilai FALSE, maka mengulangi baris ke-08 pada algoritma



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)



5. kembali ke baris ke-07

6. karena k <= 3 bernilai TRUE, maka algoritma mengerjakan baris ke-08




10. karena k <= 3 bernilai TRUE, maka algoritma mengerjakan baris ke-08




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)


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:


05| Deskripsi

06| jumlah 0

07| repeat

08| read(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)


10| read(tanya)

11| while (tanya <> „T) and (tanya <> „t‟) do

12| read(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:


05| Deskripsi

06| jumlah 0

07| read(data)

08| while data >= 0 do


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 . 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 . 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 . 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 , 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

STARTInput

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 1n 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 1n 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



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



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


07| type TLarikNama = array[1..max] of TNama


09| nama : TLarikNama


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


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


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


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


06| type TGrade = char


08| type TLarikGrade = array[1..max] of TGrade


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


21| grade[k] „A‟

22| else


24| grade[k] „B‟

25| else


27| grade[k] „C‟

28| else


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


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


06| type TGrade = char


08| type TLarikGrade = array[1..max] of TGrade


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


22| grade[k] „A‟

23| else


25| grade[k] „B‟

26| else


28| grade[k] „C‟

29| else


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


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



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])


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



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}


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)


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)


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.


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:



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



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


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



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}


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



Tetap 3


tetap 5

Data sudah urut 1 2 3 4 5 7

Algoritmanya adalah sebagai berikut:

93

01| Algoritma Pengurutan_Selection


menggunakan metode Seleksi}

03| Deklarasi:

04| const max = 50



07| data : TLarik


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}


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


95



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


menggunakan metode Insertion}

03| Deklarasi:

04| const max = 50



07| data : TLarik


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 aA a

a a a

dan dalam hal ini ija disebut elemen matriks pada baris ke-i dan kolom ke-j

Elemen diagonal utama adalah elemen yang indeksnya sama, misalnya 22a

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


06| Type TMatriks = Array[1..max,1..max] of TElemen

07| Nol : TMatriks {matriks nol ukuran n x n}

08| n : integer {ukuran matriks}


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


06| Type TMatriks = Array[1..max,1..max] of TElemen

07| satu : TMatriks {matriks identitas ukuran n x n}

08| n : integer {ukuran matriks}


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 bA 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


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 nA

dan n kB

, maka m kA B C dengan elemen-elemen C merupakan

penjumlahan dari hasil kali elemen baris A dengan elemen kolom B yang bersesuaian.

Jika ( )ij m nA a dan ( )ij n kB b maka ( )ij m kA B c dengan:

1

; 1 dan 1n

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


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



Langkah 2




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 nA , m nB , dan m nC kemudian

hitung dan cetaklah matriks 4 3D 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 7A

dan 3 9 6

15 3 21B

, maka diperoleh 3B 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


Data.grade ‘B’

Else


Data.grade ‘C’

Else

112


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,83i i . Jadi dapat

disimpulkan bahwa nilai 3x dan 2,83y .

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


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


23| data[k].grade „B‟

24| else

25| if data[k].nilai >=60 then

26| data[k].grade „C‟

27| else


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}



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}



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

Alprog Modul 1

Documents

Transcript of Alprog Modul 1