Diktat BuInge AlgoSD
Diktat BuInge AlgoSD
Dasar Pemrograman
(Bagian Pemrograman Prosedural)
Oleh :
Inggriani Liem
Kelompok Keahlian
Rekayasa Perangkat Lunak & Data (DSE)
STEI - ITB
Edisi April 2007
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 2 dr 217
PRAKATA
Diktat ini disusun secara khusus untuk keperluan pengajaran kuliah Algoritma dan
Pemrograman di lingkungan Departemen Teknik Informatika ITB. Diktat ini
merupakan revisi dari diktat yang pernah disusun untuk perkuliahan algoritma dan
Pemrograman sejak tahun 1990. Diktat ini tidak dapat dipisahkan dari Seri Catatan
Singkat dan Program Kecil, yaitu tulisan ringkas mengenai pemrograman dalam
bahasa Pascal, C, dan Ada yang dipakai secara paralel. Diktat ini juga sangat erat
hubungannya dengan matakuliah terkait yaitu diktat Pemrograman Fungsional, diktat
Struktur Data, dan diktat Pemrograman Berorentasi Objek.
Pada matakuliah Algoritma Pemrograman bagian Prosedural, mahasiswa dibekali
dengan metodologi pemrograman prosedural, dengan notasi algoritmik yang
terstruktur serta implementasinya dalam bahasa tingkat tinggi prosedural.
Mahasiswa dianjurkan untuk menuliskan solusi mereka sebelum membaca solusi pada
diktat ini, dan kemudian segera menerjemahkan solusi algoritmik pada diktat ini
menjadi program yang dapat dieksekusi mesin dalam salah satu bahasa tingkat tinggi
yang diajarkan. Pertanyaan-pertanyaan yang sengaja tidak dijawab pada beberapa
solusi dimaksudkan untuk didiskusikan di luar kuliah. Biasanya pertanyaanpertanyaan tersebut mengandung ide pedagogik yang jawabannya perlu mendapatkan
kupasan yang matang dari pengajar.
Bagi pengajar yang ingin memanfaatkan buku ini, tersedia buku lain yang merupakan
buku pegangan mengajar dan perancangan dari perkuliahan secara keseluruhan.
Dikat ini dapat diwujudkan berkat diktat pengajaran IF221 (kurikulum lama ITB)
yang pernah ditulis pada tahun 1981, kemudian diperbarui pada tahun 1996 dan
pengajaran algoritmik yang pernah diberikan oleh staf pengajar laboratorium
pemrograman di Universitas Grenoble I - Perancis (Prof. Scholl, Peyrin dan Cagnat).
Terima kasih kepada :
- Anita Burhan, asisten dosen yang sudah melakukan konversi dari file lama
menjadi yang terbaca di lingkungan DOS pada tahun 1990.
- Mahasiswa IF221 Semester I-90/91yang telah mengoreksi draft dan cikal bakal
diktat ini, telah memberikan banyak inspirasi untuk perbaikan pengajaran.
Demikian pula mahasiswa Semester I - 91/92 dan 92/93
- Ruth Kurniawati, asisten perkuliahan semester I - 91/92 dan Semester I - 92/93,
yang telah membantu dengan penuh semangat untuk mengkoreksi dan mengedit
versi awal buku ini, serta melengkapi dan men-test program-program terkait.
- Fazat Nur Azizah, salah satu staf pengajar IF1282 yang telah bersedia mencermati
ulang sebelum diktat ini diterbitkan untuk mahasiswa TPB-STEI angkatan 2006.
Kritik, saran dan koreksi sangat diharapkan untuk perbaikan diktat ini pada cetakan
yang akan datang. Kesalahan ketik yang mengakibatkan kesalahan algoritmik pada
diktat ini tak mungkin dikoreksi oleh kompilator.
Bandung, tahun ajaran 2004/2005
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 3 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 4 dr 217
DAFTAR ISI
PRAKATA...................................................................................................................................................3
DAFTAR ISI................................................................................................................................................5
PENDAHULUAN .......................................................................................................................................8
Paradigma Pemrograman........................................................................................................................8
Bahasa Pemrograman ...........................................................................................................................10
Belajar Pemrograman Tidak Sama Dengan Belajar Bahasa Pemrograman. .......................................11
Program : Produk versus Proses ...........................................................................................................12
Program Skala Kecil dan Program Skala Besar ...................................................................................12
Pemrogram Individu dan Pemrogram dalam Tim................................................................................13
Aktifitas Mahasiswa..............................................................................................................................13
Tujuan Kuliah Pemrograman Prosedural .............................................................................................15
Rujukan .................................................................................................................................................16
PENGERTIAN DASAR............................................................................................................................17
Latihan Soal ..........................................................................................................................................25
NOTASI ALGORITMIK ..........................................................................................................................28
TYPE..........................................................................................................................................................32
Type Dasar ............................................................................................................................................32
1. Bilangan Logika/boolean.............................................................................................................32
2. Bilangan Bulat..............................................................................................................................33
3. Bilangan Riil ................................................................................................................................34
4. Karakter........................................................................................................................................34
String .....................................................................................................................................................35
Type Enumerasi ....................................................................................................................................35
Type Bentukan ......................................................................................................................................36
Nilai, Ekspresi, Input & Output.................................................................................................................40
Nilai (Harga) .........................................................................................................................................40
Pengisian Nilai ......................................................................................................................................40
Assignment............................................................................................................................................40
Input ......................................................................................................................................................41
Output....................................................................................................................................................41
Ekspresi .................................................................................................................................................42
Contoh Ekspresi Boolean.................................................................................................................43
Contoh Ekspresi Numerik................................................................................................................44
Contoh Ekspresi Karakter dan String ..............................................................................................44
Latihan Soal ..........................................................................................................................................45
AKSI SEKUENSIAL ................................................................................................................................46
Latihan Soal ..........................................................................................................................................53
ANALISIS KASUS ...................................................................................................................................55
Latihan soal ...........................................................................................................................................60
FUNGSI .....................................................................................................................................................63
Notasi Algoritmik Untuk Fungsi .........................................................................................................63
Contoh Penulisan Algoritmik ...............................................................................................................66
Pendefinisian Fungsi ........................................................................................................................66
Pemanggilan Fungsi.........................................................................................................................67
Latihan Soal Fungsi ..............................................................................................................................74
PROSEDUR...............................................................................................................................................77
Parameter Prosedur ...............................................................................................................................77
Pemanggilan Prosedur ..........................................................................................................................78
Notasi Algoritmik Untuk Prosedur.......................................................................................................79
Pendefinisian/Spesifikasi Prosedur..................................................................................................79
Pemanggilan Prosedur .....................................................................................................................80
Contoh ...................................................................................................................................................80
Latihan Soal ..........................................................................................................................................83
PENGULANGAN .....................................................................................................................................84
Pengulangan Berdasarkan Banyaknya Pengulangan ...........................................................................84
Pengulangan Berdasarkan Kondisi Berhenti........................................................................................85
Pengulangan Berdasarkan Kondisi Ulang............................................................................................85
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 5 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 6 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 7 dr 217
PENDAHULUAN
Komputer digunakan sebagai alat bantu penyelesaian suatu persoalan. Masalahnya,
problematika itu tidak dapat "disodorkan" begitu saja ke depan komputer, dan
komputer akan memberikan jawabannya. Ada "jarak" antara persoalan dengan
komputer. Strategi pemecahan masalah masih harus ditanamkan ke komputer oleh
manusia dalam bentuk program. Untuk menghasilkan suatu program, seseorang dapat
memakai berbagai pendekatan yang dalam bidang pemrograman disebut sebagai
paradigma. Namun demikian, semua pemrograman mempunyai dasar yang sama.
Karena itu pada kuliah Dasar pemrograman, diajarkan semua komponen yang perlu
dalam pemrograman apapun, walaupun implementasi dan cara konstruksinya akan
sangat tergantung kepada paradigma dan bahasa pemrogramannya.
Paradigma Pemrograman
Paradigma adalah sudut pandang atau "sudut serang" tertentu yang diprioritaskan,
terhadap kelompok problema, realitas, keadaan, dan sebagainya. Paradigma
membatasi
dan mengkondisikan jalan berpikir kita, mengarahkan kita terhadap
beberapa atribut dan membuat kita mengabaikan atribut yang lain. Karena itu, jelas
bahwa sebuah paradigma hanya memberikan pandangan yang terbatas terhadap
sebuah realitas, karena itu fanatisme terhadap sebuah paradigma, mempersempit
wawasan dan kadang berbahaya.
Dalam pemrograman pun ada beberapa paradigma, masing-masing mempunyai
priotas strategi analisis yang khusus untuk memecahkan persoalan, masing-masing
menggiring kita ke suatu pendekatan khusus dari problematika keseluruhan.
Beberapa jenis persoalan dapat dipecahkan dengan baik dengan menggunakan sebuah
paradigma, sedangkan yang lain tidak cocok. Mngharuskan seseorang memecahkan
persoalan hanya dengan melalui sebuah paradigma, berarti membatasi strateginya
dalam pemrograman. Satu paradigma tidak akan cocok untuk semua kelas persoalan.
"Ilmu" pemrograman berkembang, menggantikan "seni" memprogram atau
memprogram secara coba-coba ("trial and error"). Program harus dihasilkan dari
proses pemahaman permasalahan, analisis, sintesis dan dituangkan menjadi kode
dalam bahasa komputer secara sistematis dan metodologis.
Karena terbatasnya waktu, tentu saja tidak mungkin semua paradigma disatukan
dalam sebuah mata kuliah. Mahasiswa akan mulai belajar dengan paradigma
prosedural.
Beberapa paradigma dalam pemrograman :
1. Paradigma Prosedural atau imperatif
Paradigma ini didasari oleh konsep mesin Von Newmann (stored program concept) :
sekelompok tempat penyimpanan (memori), yang dibedakan menjadi memori
instruksi dan memori data; masing-masing dapat diberi nama dan harga. Instruksi
akan dieksekusi satu per satu secara sekuensial oleh sebuah pemroses tunggal.
Beberapa instruksi menentukan instruksi berikutnya yang akan dieksekusi
(percabangan kondisional). Data diperiksa dan dimodifikasi secara sekuensial pula.
Program dalam paradigma ini didasari pada strukturasi informasi di dalam memori
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 8 dr 217
dan manipulasi dari informasi yang disimpan tersebut. Kata kunci yang sering
didengungkan dalam pendekatan ini adalah :
Algoritma + Struktur Data = Program.
Pemrograman dengan paradigma ini sangat tidak "manusiawi" dan tidak
"alamiah", karena harus berpikir dalam batasan mesin (komputer), bahkan
kadang-kadang batasan ini lebih mengikat daripada batasan problematikanya
sendiri.
Keuntungan pemrograman dengan paradigma ini adalah efisiensi eksekusi,
karena dekat dengan mesin.
2. Paradigma Fungsional
Paradigma fungsional didasari oleh konsep pemetaaan dan fungsi pada matematika.
Fungsi dapat berbentuk sebagai fungsi "primitif", atau komposisi dari fungsi-fungsi
lain yang telah terdefinisi. Pemrogram mengasumsikan bahwa ada fungsi-fungsi dasar
yang dapat dilakukan. Penyelesaian masalah didasari atas aplikasi dari fungsi-fungsi
tersebut. Jadi dasar pemecahan persoalan adalah transformasional. Semua kelakuan
program adalah suatu rantai transformasi dari sebuah keadaan awal menuju ke suatu
rantai keadaan akhir, yang mungkin melalui keadaan antara.
Paradigma fungsional tidak lagi mempernasalahkan memorisasi dan struktur data,
tidak ada pemilahan antara data dan program, tidak ada lagi pengertian tentang
"variabel". Pemrogram tidak perlu lagi mengetahui bagaimana mesin mengeksekusi
atau bagaimana informasi disimpan dalam memori, setiap fungsi adalah "kotak
hitam", yang menjadi perhatiannya hanya keadaan awal dan akhir. Dengan merakit
kotak hitam ini, pemrogram akan menghasilkan program besar.
Berlainan sekali dengan paradigma prosedural, program fungsional harus diolah lebih
dari program prosedural (oleh pemroses bahasanya), karena itu salah satu keberatan
adalah kinerja dan efisiensinya.
3. Paradigma Deklaratif, predikatif atau lojik
Paradigma ini didasari oleh pendefinisian relasi antar individu yang dinyatakan
sebagai predikat. Sebuah program lojik adalah kumpulan aksioma (fakta dan aturan
deduksi).
Pada paradigma ini, pemrogram menguraikan sekumpulan fakta dan aturan-aturan
(inference rules). Ketika program dieksekusi, pemakai mengajukan pertanyaan
(Query), dan program akan menjawab apakah pernyataan itu dapat dideduksi dari
aturan dan fakta yang ada. Program akan memakai aturan deduksi dan mencocokkan
pertanyaan dengan fakta-fakta yang ada untuk menjawab pertanyaan.
4. Paradigma Berorientasi Objek (Object Oriented)
Paradigma ini didasari oleh objek. Sebuah objek mempunyai atribut
(kumpulan sifat), dan mempunyai kelakuan (kumpulan reaksi, metoda). Objek yang
satu dapat berkomunikasi dengan objek yang lain lewat "pesan", dengan tetap terjaga
integritasnya. Kelas adalah objek mempunyai atribut yang sama dan diturunkan ke
semua pbjek yang berada dalam kelas yang sama. Kelas-kelas mempunyai hirarki,
anggota dari sebuah kelas juga mendapatkan turunan atribut dari kelas di atasnya.
Paradigma ini menawarkan konsep class, generic, inheritance, polymorphism dan
menenkankan pentingnya pendefinisian statik kelas untuk melahirkan (menciptakan)
objek pada saat runtime, yang kemudian dimanipulasi atau saling berinterasi. Definisi
kelas memungkinkan adanya penurunan kelas dengan objek pada saat run time yang
dapat berubah bentuk dengan kelakuan yang disesuaikan,
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 9 dr 217
Bahasa Pemrograman
Ada banyak sekali bahasa pemrograman, mulai dari bahasa tingkat rendah (bahasa
mesin dalam biner), bahasa asembler (dalam kode mnemonik), bahasa tingkat tinggi,
sampai bahasa generasi ke empat (4GL).
Bahasa Pemrograman berkembang dengan cepat sejak tahun enampuluhan, seringkali
dianalogikan dengan menara Babel yang berakibat manusia menjadi tidak lagi saling
mengerti bahasa masing-masing. Untuk setiap paradigma, tersedia bahasa
pemrograman yang mempermudah implementasi rancangan penyelesaian
masalahnya. Contoh bahasa-bahasa pemrograman yang ada :
1. Prosedural : Algol, Pascal, Fortran, Basic, Cobol, C ...
2. Fungsional : LOGO, APL, LISP
3. Deklaratif/Lojik : Prolog
4. Object oriented murni: Smalltalk, Eifel, Jaca, C++..
5. Konkuren : OCCAM, Ada, Java
6. Relasional: SQL pada basisdata relasional
Paradigma Objek mulai ditambahkan pada bahasa-bahasa yang ada. Pemroses bahasa
Pascal dan C versi terbaru dilengkapi dengan fasilitas terorientasi objek, misalnya
Turbo Pascal (mulai versi 5.5) pada komputer pribadi (PC) dan C++. Ada beberapa
versi LISP dan Prolog yang juga memasukkan aspek OO.
Suatu program dalam bahasa pemrograman tertentu akan diproses oleh pemroses
bahasanya. Ada dua kategori pemroses bahasa, yaitu kompilator dan interpreter.
Dalam melakukan implementasi program, tersedia bahasa pemrograman visual atau
tekstual.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 10 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 11 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 12 dr 217
Aktifitas Mahasiswa
Beberapa kalangan berpendapat bahwa memprogram adalah menghasilkan
program. Ini dapat dianalogikan dengan melihat seorang penyanyi, maka tugasnya
adalah hanya bernyanyi. Atau seorang olahragawan yang fokusnya adalah bertanding
di lapangan untuk cabang olahraga tertentu. Kalau diperhatikan, seorang penyanyi
yang baik tidak hanya berlatih untuk menyanyi, namun harus melakukan secara
disiplin banyak latihan yang lain, misalnya: latihan pernafasan, menguasai beberapa
alat musik, menjiwai suatu peran ketika menyanyi di panggung, dsb. Seorang
olahragawan harus melakukan latihan-latihan rutin misalnya lari pagi, angkat barbel,
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 13 dr 217
senam atau olah raga lain yang menunjang olahraga utamanya. Demikian pula dengan
pemrogram.
Aktivitas mahasiswa yang perlu dilakukan mahasiswa yang sedang belajar
memprogram dapat digolongkan dalam kelompok sebagai berikut :
-
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 14 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 15 dr 217
Rujukan
Diktat ini dan diktat program kecil yang ditulis khusus untuk melengkapi diktat
konsep, merupakan buku pegangan wajib dalam perkuliahan algoritma dan
pemrograman di Departemen Teknik Informatika ITB.
Buku-buku teks [urut abjad]
1. Aho, Hopcroft, Ullman : "Data Structures and Algorithms", Prentice Hall,
1987.
2. Horowitz, E & Sahni, S : "Fundamentals of Data Structures in Pascal", Pitman
Publishing Limited, 1984.
3. [Knuth-68] Knuth, D.E : "The Art of Computer Programming", Vol. 1 :
"Fundamentals Algoritms", Addison Wisley, 1968.
4. [Knuth-71] Knuth, D.E : "The Art of Computer Programming", Vol. 3 :
"Sorting and Searching", Addison Wisley, 1971
5. Meyer and Baudoin : "Methodes de Programmation", Eyrolles, 1980.
6. [Scholl-88] Scholl P.C and Peyrin, J.P : "Schemas Algorithmiques
Fondamentaux", Masson, 1988.
7. Sedgewick R. : "Algorithms", Addison Wisley, 1984.
8. Wirth, N. : "Systematic programming", Prentice Hall,1975
9. [Wirth-86] Wirth, N. : "Algorithms & Data Stuctures", Prentice Hall,1986.
Beberapa Artikel Yang Perlu Dibaca:
1. Djikstra, E. : "On the Cruelty of Really Teaching Computer Science", The
SIGCSE Award Lecturer, SIGCSE Bulletin, vol.21, no.1, Feb 1989, pp xxiv xxxix
2. [Hoare-84] Hoare, C.A.R. "Programming: Sorcery or Science ?", IEEE Software,
April 1984, pp 6 - 16
3. Knuth, D. E. : "Programming As an Art", Communication of the ACM, Vol. 17,
No. 12, Dec. 74, pp 667 673
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 16 dr 217
PENGERTIAN DASAR
Dalam Pemrograman Prosedural
Pada bagian ini akan dijelaskan definisi beberapa pengertian dasar yang penting
sehubungan dengan algoritma dan pemrograman, yang akan diberikan dalam contoh
pada kehidupan sehari-hari. Mungkin pengertian-pengertian tersebut mula-mula terasa
abstrak bagi beberapa pembaca, tapi baiklah coba dipahami.
Pengertian pertama yang akan dijelaskan adalah aksi. Suatu aksi adalah kejadian yang
terjadi pada suatu selang waktu terbatas dan menghasilkan efek neto yang telah
terdefinisi dengan baik dan memang direncanakan. Pada deskripsi tersebut,
ditekankan benar efek tersebut harus direncanakan, maka berarti dititikberatkan
pada kegunaannya. Jika seseorang tertarik pada suatu aksi, maka jelas bahwa
minatnya adalah pada efek netonya.
Suatu aksi harus terjadi pada selang waktu yang terbatas, dimulai pada saat T0 dan
berakhir pada saat T1. Maka efek neto dari aksi dapat dijelaskan dengan
membandingkan keadaan pada saat T0 dan keadaan pada saat T1.
Contoh dari suatu aksi adalah Ibu Tati yang MENGUPAS KENTANG untuk
mempersiapkan makan malam. Pernyataan ini mencakup hal yang luas ruang
lingkupnya, misalnya :
Apakah kentangnya harus dibeli dulu atau sudah ada di dapur ?
Apakah yang dimaksud dengan mengupas kentang untuk makan malam
berarti sampai dengan kentang terhidang ?
Ketika kentangnya terhidang, jadi sup, digoreng atau direbus saja ?
Maka kita harus membatasi dengan jelas keadaan awal yang menjadi titik tolak
mengupas kentang dan keadaan akhir yang ingin dicapai supaya dapat
merencanakan efek neto yang diinginkan.
Untuk itu ditentukan :
Initial state (I.S. keadaan awal), T0, adalah kentang sudah ada di kantong
kentang, yang ditaruh di rak di dapur, di mana ibu Tati akan mengupasnya
Final state (F.S. keadaan akhir), T1, kentang dalan keadaan terkupas di
panci, siap untuk dimasak dan kantong kentangnya harus dikembalikan ke
rak lagi.
Pengandaian yang lain adalah bahwa persediaan kentang di ibu selalu cukup untuk
makan malam. Penambahan kentang ke dapur di luar tinjauan masalah ini. Ini adalah
contoh bagaimana kita menentukan batasan dari persoalan yang akan diprogram.
Suatu kejadian dapat dipandang sebagai urut-urutan dari beberapa kejadian, berarti
dapat diuraikan dalan beberapa (sub) aksi yang terjadi secara sekuensial. Dengan
sudut pandang ini makan efek kumulatifnya sama dengan efek neto dari seluruh
kejadian. Dikatakan bahwa kejadian tersebut dianggap sebagai sequential process atau
disingkat proses.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 17 dr 217
Penggolongan suatu kejadian sebagai proses atau aksi adalah relatif. Kejadian yang
sama daoat dianggap sebagai aksi ataupun sebagai proses. Kalau lebih dititik beratkan
efek netonya, yaitu keadaan sebelum dan sesudah maka kejadian tersebut dianggap
sebagai berarti kejadian tersebut dianggap sebagai proses. Dengan anggapan kejadian
tersebut suatu proses, maka T0 adalah awal dari sebuah sub-aksi dan setiap akhir dari
suatu sub-aksi akan merupakan awal dari sub-aksi berikutnya, dengan suatu
keistimewaan, akhir dari sub-aksi yang terakhir adalah T1 yaitu akhir dari seluruh
kejadian.
Penggolongan suatu kejadian menjadi proses atau aksi tidak ada hubungannya dengan
sifat dari kejadian itu sendiri melainkan tergantung dari cara peninjauan. Jika cara
peninjauan dilakukan dari sudut pandang yang berbeda, maka biasanya hasil antara
yang ingin diperhatikan juga berbeda.
Misalkan kejadian tentang ibu Tati mengupas kentang, dapat dijelaskan oleh uruturutan sub-aksi yang dilakukan oleh ibu tersebut, yaitu :
Pada contoh tersebut, kejadian dijelaskan sebagai urut-urutan dari empat sub-aksi
yang diungkapkan berdasarkan suatu pengamatan. Jika dari hasil pengamatan tidak
dipandang perlu untuk menjelaskan bahwa kantong kentang diambil dari rak
sebelum panci diambil dari almari, maka cukup dituliskan :
Ada kejadian yang mempunyai suatu pola tingkah laku, atau disingkat pola.
Kejadian tersebut akan terjadi jika pola ini diikuti. Efek neto dari kejadian ditentukan
sepenuhnya oleh pola tersebut dan (mungkin) oleh keadaan awal (yaitu keadaan pada
saat T0). Kejadian yang lain mungkin mengikuti pola yang sama. Jika dua kejadian
dengan pola yang sama menghasilkan efek neto yang berbeda, maka efek neto
tersebut pasti tergantung pada keadaan awal, dan dapat dipastikan pula bahhwa
keadaan awal dari keduanya berbeda.
Bagaimana cara mengamati pola yang sama dari berbagai kejadian, tidak dapat
dijelaskan disini. Jika kita berjumpa dengan seorang teman, kita pasti segera dapat
mengenalinya, apapun ekspresi yang sedang ditampilkannya. Mungkin ia sedang
gembira, tertawa, menangis, atau bahkan ekspresi lain yang belum pernak
ditampilkannya. Kita dapat mengenali teman tersebut karena kita kenal akan pola nya.
Demikian juga dengan jejadian yang berbeda, dapat pula dikenal pola-pola yang
sama, walaupun disarikan dari keadaan awal dan efek neto yang mungkin berbeda.
Mengenali pola ini sama halnya nanti dengan mengenali pola-pola solusi algoritmik
untuk kelas persoalan tertentu yang akan dipelajari, menjadi bagian dari belajar
memprogam.
Kembali ke contoh ibu Tati yang mengupas kentang. pada suatu hari ibu Tati
mengupas kentang untuk malam dan kejadian tersebut kita amati. Keesokan harinya,
ia mengupas kentang lagi untuk makan malam juga. Pada pengamatan yang kedua,
kita amati hal-hal yang sama dengan hari sebelumnya. Dapatlah kita katakan: Jelas,
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 18 dr 217
pengamatan tentang kedua kejadian akan sama karena ibu itu mengerjakan hal-hal
sama?
Pernyataan terakhir tersebut dapat benar atau salah, tergantung pada apa yang
dimaksud dengan mengerjakan hal yang sama. Untuk menyatakan hal yang sama
harus hati-hati. Tinjaulah murid-murid sekolah dasar yang berpakaian sama, karena
mereka memakai seragam. Apa yang ingin dinyatakan sebagai sama adalah bahwa
baju dari setiap murid terbuat dari bahan yang sama dan modelnya sama pula; tanpa
memperhitungkan kemungkinan adanya perbedaan ukuran tergantung dari perawakan
setiap murid. Demikian pula bahwa seorang murid dapat mempunyai lebih dari satu
stel seragam yang sama.
Kedua dari aksi ibu Tati mengupas kentang pada dua hari yang berlainan tersebut juga
dapat dipandang berbeda, seperti halnya baju murid sekolah dasar tersebut. Kejadian
yang satu terjadi pada hari Sabtu dan yang lain pada hari Minggu. Karena setiap
kentang hanya dapat dikupas satu kali, maka kentang yang terlibat pada kedua
kejadian tersebut berbeda pula. Pada hari Minggu, mungkin kantong kentangnya
berisi lebih sedikit dari kemarinnya, dan sebagainya.
Tetapi, kedua kejadian mengupas kentang pada hari Sabtu dan Minggu dapat pula
dikatakan sama karena kemiripannya, dan sepakati untuk memberi nama yang sama
untuk kedua aksi tersebut, misalnya MENGUPAS KENTANG UNTUK MAKAN
MALAM.
Algoritma adalah deskripsi dapat terdiri dari suatu pola tingkah laku, dinyatakan
dalam primitif, yaitu aksi-aksi yang didefinisikan sebelumnya dan diberi nama, dan
diasumsikan sebelumnya bahwa aksi-aksi tersebut dapat dikerjakan sehingga dapat
menyebabkan kejadian yang dapat diamati.
Suatu algoritma dapat terdiri dari beberapa subalgoritma, jika setiap sub-aksi juga
dapat diuraikan dalam urut-urutan yang dapat dimengerti dengan baik dan terbatas.
Pengertian algoritma, yaitu sebagai suatu petunjuk untuk mewujudkan suatu efek
neto, telah sangat dikenal dalam kehidupan sehari-hari. Petunjuk untuk merajut,
resep-resep kue, aturan pakai suatu peralatan elektronik, adalah algoritma, yaitu
deskripsi dari pola tingkah laku yang jika dikerjakan akan membawa ke tujuannya.
Aksi primitif harus dapat dikerjakan. Pergi ke seberang jalan! adalah aksi yang
dapat dikerjakan, sedangkan Pergi ke Neraka! bukan algoritma, karena tidak dapat
dikerjakan.
Urut-urutan langkah harus dapat dimengerti dengan baik, oleh pembuat algoritma
maupun oleh yang akan mengerjakan. Tidak boleh ada sedikitpun salah pengertian di
antara keduanya supaya dapat dihasilkan efek yang diinginkan.
Jika pada suatu resep kue dituliskan Panaskan dulu oven maka instruksi tersebut
tidak jelas, karena berapa lama dan sampai temperatur oven mencapai berapa derajat
hal tersebut harus dilakukan, tidak ditentukan dengan pasti.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 19 dr 217
Sekarang perhatikanlah laporan pengamatan tentang kejadian ibu Tati yang mengupas
kentang :
Jika teks algoritma tersebut diberikan kepada pembantunya yang bernama Ina, maka
jika dilaksanakan akan menghasilkan pengamatan kejadian :
Atau jika putri sulung Ibu Tati yang bernama Aida pada suatu hari dengan senang hati
mengerjakan pengupasan kentang, maka akan dihasilkan pengamatan kejadian :
atau pada suatu hari yang lain, dihasilkan laporan pengamatan yang tidak sama
dengan sebelumnya :
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 20 dr 217
Sekarang, masalahnya adalah bagaimana menuliskan teks pengamatan yang sama dari
kedua laporan pengamatan yang berbeda tersebut, misalnya :
Ibu Tati melihat bahwa bajunya tidak berwarna muda karena itu ia tidak memakai
celemek (berarti tidak ada aksi memakai celemek)
Ibu Tati melihat bahwa bajunya berwarna muda karena itu ia memakai celemek
Pada derajat yang rinci tidak mungkin kedua kejadian ini dilaporkan dalam satu
laporan pengamatan, karena terperinci, kedua kejadian tersebut berbeda.
Inilah algoritma, yaitu menyatakan pola tingkah laku yang sama untuk dua, bahkan
tak berhingga kejadian yang berbeda dan dengan menjelaskan pola tersebut
memberikan sesuatu yang daoat terjadi pada suasana lingkungan apapun (dalam
contoh tersebut, baju warna gelap ataupun muda). Apa yang sebenarnya terjadi jika
suatu pola tingkah laku diikuti dapat ditentukan pola oleh keadaan yang berlaku
ketika aksi tersebut mulai.
Ada dua hal yang penting. Pertama, pengamatan apakah baju si ibu berwarna muda,
dan kedua berdasarkan pengamatan tersebut aksi memakai celemek bisa terjadi atau
tidak (berarti aksi tersebut kondisional). Maka notasi untuk aksi kondisional
dinyatakan oleh kondisi dan aksi).
Maka aksi kondisional mengandung dua aksi, aksi pertama harus suatu pengamatan.
Hasil dari pengamatan ini adalah suatu keadaan benar (true) atau salah (false).
Aksi kedua menghasilkan kejadian berlangsung sesuai dengan hasil pengamatan. Jika
pengamatan memberikan hasil true maka aksi terjadi, jika pengamatan memberikan
hasil false maka aksi tidak dilakukan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 21 dr 217
Selain notasi untuk aksi kondisional, kita perlukan lagi beberapa notasi yang
menunjukkan bahwa algoritma lebih tinggi tingkatannya dan menyangkut abstraksi
dari pengamatan, yaitu notasi yang mewakili proses pengulangan. Misalnya kita
ingin menyatakan bahwa mengupas kentang adalah suatu proses mengerjakan satu
buah kentang pada suatu saat, maka aksi primitif kita adalah kupas 1 kentang. Jika
jumlah kentang yang ingin dikupas selalu sama setiap hari, misalnya 25 maka sebagai
ganti kupas kentang dapat dituliskan 25 kali kupas 1 kentang, masing-masing
pernyataan dituliskan per baris sehingga keseluruhannya dituliskan dalam 25 baris
sekuensial. Tetapi jika kentang yang dikupas tidak selalu sama (dan hal ini lebih
sering terjadi dalam kenyataan) sedangkan kita tetap menginginkan pola kelakuan
yang sama apa yang harus dilakukan ? Setiap kali kita harus mengganti teks, satu
jenis teks untuk satu kali pengamatan. Ini bukan tujuan dari penulisan algoritma yang
mampu menghasilkan pengamatan yang berbeda-beda. Dianggap bahwa si ibu
mampu untuk melongok ke panci dan dengan demikian mengamati apakah kentang
yang dibutuhkan telah cukup.
Jika diketahui bahwa kasus yang ekstrem adalah mengupas 500 kentang (karena
kentangnya sangat kecil-kecil dan ada pesta), artinya ibu Tati tidak mungkin
mengupas lebih dari 500 kentang, kita dapat menuliskan algoritma umum untuk
mengupas kentang dengan menuliskan 500 (lima ratus) kali secara sekuensial
pernyataan berikut :
Siapapun pasti merasa keberatan dengan cara penulisan semacam itu, yaitu harus
menuliskan hal yang sama 500 kali. Dengan asumsi dasar bahwa sebelumnya harus
diketahui berapa jumlah kentang yang harus dikupas, batas seperti itu terlalu besar
untuk rata-rata yang terjadi. Jika sebenarnya hanya diinginkan mengupas 25 buah
kentang, maka pengamatan ke 26 akan memberikan hasil false yang pertama, dan
474 pengamatan berikutnya tidak akan memberikan hasil pengamatan yang baru.
Sekali si ibu telah tahu bahwa kentang yang dikupasnya cukup, tidak perlu lagi
memaksa dia melongok ke panci 474 lagi untuk meyakinkan dirinya sendiri.
Untuk mengatasi hal ini, diperkenalkan suatu notasi yang menjelaskan tentang suatu
proses pengulangan sampai dijumpai keadaan tertentu, dan dituliskan sebagai :
while (kondisi......) do
Aksi........
Dengan notasi ini algoritma mengupas kentang dapat dituliskan :
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 22 dr 217
Contoh berikut, akan dijelaskan pola kelakuan dari ibu Tati yang menggunakan
primitif sama, yang karena alasan tertentu selalu mengupas kentang dengan jumlah
genap untuk masakannya. Maka dapat dituliskan algoritma sebagai berikut :
Contoh di atas menunjukkan bahwa aksi primitif yang sama dapat menggambarkan
pola kelakuan yang berbeda.
Berikut ini diandaikan bahwa ibu Tati dalah penggemar kentang sehingga ia selalu
mempunyai beberapa kantong kentang di raknya. Kantong kentangnya kemungkinan
ada yang berisi ataupun kosong.
Jika pengupasan kentang dapat dilakukan dari beberapa kantong, dapat dituliskan
algoritma untuk mengupas sejumlah tertentu kentang sebagai berikut :
Dari contoh yang terakhir dapat pula ditarik kesimpulan bahwa suatu algoritma dapat
dibangun dari aksi primitif dan gabungan dari notasi standard yang telah kita kenal.
Satu algoritma mewakili beberapa kejadian yang berdasarkan pengamatan berbeda.
Algoritma adalah suatu sebuah teks yang tidak tergantung waktu, konsepnya statik. Di
pihak lain ada realisasi kejadian yang dicakup oleh algoritma tersebut, yaitu suatu
eksekusi yang dinamik, terjadi tergantung pada waktu, yang dijelaskan sebagai hasil
dari pengamatan.
Telah dikatakan bahwa aksi harus terjadi dalam selang waktu yang terbatas, maka
algoritma yang menjelaskan tentang aksi tersebut harus mencakup hal tersebut.
Kita tidak boleh menuliskan :
Karena pengupasan kentang tidak mempengaruhi warna pakaian, hanya ada duia
kemungkinan: pakaian tidak berwarna muda dan pengupasan kentang tidak pernah
dilakukan atau pakaian berwarna muda dan proses pengupasan kentang akan
dilakukan terus menerus, yang berarti bahwa jika kebetulan pakaian berwarna
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 23 dr 217
muda, maka pengamatan akan menghasilkan sesuatu yang tidak pernah berhenti
(looping). Contoh ini adalah sebuah algoritma yang salah karena dapat
mengakibatkan pengulangan yang tidak pernah berhenti.
Tidak mudah untuk menentukan apakah suatu teks yang tampak seperti sebuah
algoritma adalah memang algoritma yang benar. Bahkan tidak mungkin untuk
membuat sebuah algoritma yang mamapu memeriksa suatu teks dan menentukan
apakah teks tersebut suatu algoritma yang benar. Maka adalah tanggung jawab moral
orang-orang yang profesinya membuat algoritma untuk mempersiapkan bukti bahwa
algoritma yang dibuatnya adalah sebuat algoritma yang benar.
Pengertian dasar yang lain adalah tentang mesin. Suatu mesin adalah sebuah
mekanisme yang dapat menyebabkan suatu aksi terjadi mengikuti suatu pola tingkah
laku yang dijelaskan oleh algoritma yang urut-urutan pelaksanaannya dinyatakan
dalan aksi primitif mesin tersebut.
Pada contoh-contoh di atas, diberikan beberapa algoritma tentang mengupas kentang.
Semua algoritma dinyatakan dalam primitif yang sama yang kemudian melahirkan
teks yang dinyatakan sebagai pengamatan kejadian. Siapapun yang mampu untuk:
- Mengerjakan aksi primitif tersebut
- Menerima algoritma yang dinyatakan dengan primitif tersebut dan akan
melaksanakan langkah-langkah dengan patuh,disebut sebagai mesin.
Jika saya dapat membuat teman saya, pembantu saya, tetangga kiri saya, atau tetangga
kanan saya mengerjakan pengupasan kentang tersebut tergantung algoritma yang saya
berikan, maka teman, pembantu, tetangga kiri maupun tetangga kanan saya adalah
sebuah mesin.
Suatu mekanisme yang hanya dapat mengerjakan satu hal yang selalu sama (misalnya
toilet flusher) tidak dapat disebut suatu mesin. Hal penting yang dapat dikerjakan oleh
mesin adalah aksi-aksi yang sekuensial, kemampuan menerima suatu pola tingkah
laku dan berkelakuan berdasarkan pola tersebut. Mesin adalah pengeksekusi atau
pelaku dari algoritma.
Algoritma yang mengontrol pola tingkah laku suatu mesin disebut program. Dengan
perkataan lain, program adalah algoritma yang dimaksudkan untuk dieksekusi oleh
mesin. Dalam pengertian algoritma yang harus dapat dimengerti dengan baik, tanpa
menghiraukan bagaimana pengertian tersebut diwujudkan. Mesin terdiri dari
sekumpulan peralatan. Berkat konstruksinya, mesin hanya dapat mengerjakan
sekumpulan instruksi-instruksi tertentu yang terbatas jumlahnya yang telah terdefinisi.
Jika kita berikan suatu program kepada mesin, maka dengan patuh ia akan
mengerjakan persis seperti yang dinyatakan dalam algoritma. Mesin sangat patuh
terhadap instruksi yang kita berikan, dengan resiko kita harus mendefinisikan
instruksi tersebut dengan rinci. Untuk seorang pemrogram yang belum
berpengalaman, hal ini sering menimbulkan keluhan, tetapi dengan bertambahnya
pengalamn, ia akan menyadari bahwa mesin akan selalu mengerjakan hal-hal yang
dianggap tidak umum tanpa membantah. Bandingkanlah dengan pembantu yang
seringkali mengadakan penafsiran sendiri terhadap instruksi kita supaya ia lebih enak,
tetapi sering malahan menjengkelkan dan menyulitkan kita karena interpretasi dan
tingkah lakunya yang tak terkontrol oleh kita.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 24 dr 217
Program yang mengontrol mesin harus disusun sedemikian rupa jika ingin dipakai
sesuai keinginan. Misalnya kita ingin menyuruh mesin tersebut untuk memecahkan
masalah yang kita hadapi, maka kita jarus membuat program yang sesuai untuk
masalah tersebut dan mesin akan mengerjakan program sesuai dengan algoritma yang
ditulis. Dalam hal ini mesin tersebut adalah alat bantu untuk memecahkan dari sudut
pandang ini.
Pada bagian berikutnya akan dijelaskan, apakah pemrograman itu, dan mesin
pengeksekusi program yang selanjutnya disebut sebagai komputer. Primitif-primitif
yang akan diuraikan pada bab-bab selanjutnya adalah primitif yang dapat dilakukan
oleh komputer. Aksi primitif komputer terlalu detil untuk jalan pikiran manusia,
sehingga terlalu sulit untuk menguraikan algoritma dalam primitif langsung komputer.
Karena itu diperlukan mesin abstrak, yaitu mekanisme yang diasumsikan dapat
dilakukan oleh sekumpulan primitif yang diberikan. Berangsur-angsur, secara
bertahap, mesin abstrak akan dijabarkan menjadi mesin riil, yaitu sampai primitif
yang dapat dilakukan oleh komputer. Keadaan awal dan keadaan akhir yang
diceritakan di atas pada kejadian nyata, juga akan diwakili oleh keadaan komputer,
dalam hal ini keadaan isi memori. Efek neto yang akan dihasilkan dinyatakan dalam
spesifikasi program, yang menjadi bahan mentah dalam menuliskan programnya. Dari
kejadian sehari-hari yang diuraikan pada bab ini, kita akan berbicara dalam notasi
algoritmik. Notasi kondisional dan pengulangan di atas baru sebagian dari notasi
algoritmik yang akan dipelajari secara bertahap (karena itu dituliskan dalam bahasa
Inggris), untuk membedakan dengan kalimat-kalimat ibu Tati dalam bahasa manusia.
Latihan Soal
I. Periksalah apakah masing-masing algoritma mengupas kentang berikut benar.
Pada algoritma ini kita hanya tertarik pada aksi mengambil kentang dan kantong
dan mengupas kentang.
1. While jumlah kentang terkupas belum cukup do
depend on kantong
kantong berisi 1 kentang : Kupas 1 kentang
2. While kantong tidak kosong do
Kupas 1 kentang
Kupas 1 kentang
3. While kantong tidak kosong do
While jumlah kentang terkupas belum cukup do
Kupas 1 kentang
4. While (kantong tidak kosong) dan (jumlah kentang terkupas belum cukup) do
Kupas 1 kentang
5. While jumlah kentang terkupas belum cukup do
Depend on kantong
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 25 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 26 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 27 dr 217
NOTASI ALGORITMIK
Dalam perkuliahan ini, akan dipakai sebuah notasi yang akan dipakai sebagai
standard dalam menuliskan teks algoritma. Dalam kuliah ini dibedakan antara
algoritma dan program. Algoritma adalah solusi detail secara prosedural dari suatu
persoalan dalam notasi algoritmik. Program adalah program komputer dalam suatu
bahasa pemrograman yang tersedia di dunia nyata. Bahasa komputer mempunyai
pemroses sehingga dapat dieksekusi mesin, sehingga teks program dibuat untuk
dieksekusi mesin (dan untuk kepentingan pemeliharaan program sebaiknya dapat
dibaca dengan mudah oleh manusia). Notasi algoritmik yang dipakai di kuliah ini
diadaptasi dari [Scholl-88], merupakan notasi yang sengaja dikembangkan untuk
kepentingan pengajaran di lingkungan Program Studi Teknik Informatika ITB, dan
tidak mempunyai mesin pengeksekusi. Notasi ini dianggap perlu untuk menjembatani
keragaman dan kompleksitas bahasa sehingga mahasiswa mampu melakukan
abstraksi. Notasi ini akan merangkum semua konsep pemrograman prosedural yang
harus dapat dengan mudah dituliskan di atas kertas. Notasi ini lebih berorientasi
kepada detail design dibandingkan coding. Notasi ini hanyalah alat untuk
menuangkan rancangan secara prosedural yang selanjutnya dengan mudah dapat
ditranslasi menjadi salah satu program dalam bahasa tertentu. Suatu saat, jika
permogram menghadapi dunia profesional yang membutuhkan hasil yang siap pakai,
notasi dapat disesuaikan dan dibuat lebih dekat dengan bahasa pemrograman yang
dipakai.
Teks algoritma selalu terdiri dari tiga bagian, yaitu :
- Judul (Header)
- Kamus
- Algoritma
Pada setiap bagian tersebut, akan didefinisikan dan dipakai nama, atau dituliskan
komentar dalam bahasa Indonesia. Komentar dalam bahasa Indonesia dituliskan di
antara tanda kurung kurawal. Teks yang tidak dituliskan di antara kurung kurawal
buka dan tutup adalah teks dalam notasi algoritmik.
Contoh teks algoritmik
JUDUL
{ Ini adalah teks dalam bahasa Indonesia untuk memudahkan pembacaan
teks algoritma }
{ Spesifikasi teks algoritmik secara umum }
KAMUS
{Pada bagian ini, dilakukan pendefinisian nama konstanta, nama variabel,
spesifikasi prosedur, spesifikasi fungsi}
ALGORITMA
{ Pada bagian ini, semua teks yang tidak dituliskan di antara tanda kurung
kurawal buka dan kurung kurawal tutup harus dianggap sebagai notasi
algoritmik }
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 28 dr 217
NAMA
dalam sebuah teks algoritmik adalah sesuatu yang dipakai sebagai identifikasi :
- modul program, algoritma, skema program dsb.
- fungsi
- prosedur
- type
- tempat penyimpanan, supaya harga yang disimpan dapat diacu isinya. Dalam
beberapa bahasa pemrograman, nama tempat penyimpanan ini seringkali
disebut sebagai nama variabel karena isinya dapat diubah-ubah lewat
instruksi program.
- konstanta, yaitu suatu harga yang tetap dan tidak boleh diubah nilainya
Karena adanya bermacam-macam nama tersebut, maka dalam suatu teks algoritma
dikenal nama program, nama skema, nama fungsi, nama prosedur, nama type, nama
variabel dan nama konstanta. Semua nama dalam program harus unik, artinya suatu
nama hanya didefinisikan satu kali (dipakai sebagai salah satu nama tersebut) satu kali
saja. Namun sebuah nama, misalnya nama variabel boleh dipakai berkali-kali dalam
beberapa instruksi.
Semua nama yang dipakai dalam suatu teks algoritma harus sudah didefinisikan pada
salah satu bagian teks algoritma.
Tatacara penamaan yang dipakai dalam notasi algoritmik tidak seketat dalam bahasa
pemrogaman yang misalnya membatasi jumlah dan jenis karakter serta case sensitive,
(huruf kecil dan kapital dibedakan). Namun sebaiknya nama yang dipakai tidak
membingungkan, misalnya, dalam teks algoritmik, nama tidak dibedakan dari
penulisan dengan huruf kecil/kapital (tidak case sensitive) atau memakai simbol
operator sebagai bagian dari nama.
JUDUL (HEADER)
Judul adalah bagian teks algoritma tempat mendefinisikan apakah teks tersebut
adalah program, prosedur, fungsi, modul atau sebuah skema program. Setelah judul
disarankan untuk menuliskan spesifikasi singkat dari teks algoritma tersebut. Pada
bagian judul dan spesifikasi, pembaca dapat mengetahui isi dari teks tanpa membaca
secara detil Bagian judul berisi judul teks algoritmik secara keseluruhan dan intisari
sebuah teks algoritmik tersebut.
Bagian judul ini identik dengan judul buku dan intisari pada sebuah teks ilmiah dalam
suatu makalah berbahasa Indonesia.
KAMUS
Kamus adalah bagian teks algoritma tempat mendefinisikan:
- nama type,
- nama konstanta,
- nama informasi (nama variabel),
- nama fungsi, sekaligus spesifikasinya
- nama prosedur, sekaligus spesifikasinya
Semua nama tersebut baru dapat dipakai jika didefinisikan dalam kamus. Penulisan
sekumpulan nama dalam kamus sebaiknya dikelompokkan menurut jenis nama
tersebut.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 29 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 30 dr 217
KAMUS
{Nama Type, hanya untuk type yang bukan type dasar }
type Point : <X:real,Y:real>
{ koordinat pada sumbu
kartesian }
{Nama Konstanta, harus menyebutkan type dan nilai }
constant PI: real = 3.14159
constant Ka: character = 'K'
constant Faktor: integer = 3
constant Benar: boolean = true
{Nama Informasi, menyebutkan type}
NMax : integer {jumlah maksimum elemen tabel}
Found : boolean { Hasil pencarian, true jika ketemu }
P : Point
{ Posisi pena pada bidang kartesian }
CC : character { Current character }
{Spesifikasi Fungsi, menyebutkan nama fungsi, domain dan range}
Function RealToInt
(i:real) integer
{Mengkonversi harga i yang bertype real menjadi harga ekivalen
yang bertype integer }
{Spesifikasi Prosedur, menyebutkan Nama, parameter, Initial State
(I.S.) , Final State (F.S.) dan Proses}
procedure INISIALISASI
{I.S. Sembarang
F.S. Semua nama global dalam kamus terdefinisi nilainya
Proses : Menginisialisasi semua nama informasi global}
procedure Tulis (Input Pesan: string)
{I.S. sembarang
F.S. Pesan tertulis di layar
Proses : Menulis isi Pesan ke layar }
procedure TUKAR(Input/Output : A,B:real)
{I.S. A dan B terdefinisi, A=a dan B=b
F.S. A=b dan B=a
Proses : Menukar isi nama informasi A dan B}
ALGORITMA
Algoritma adalah bagian teks algoritmik yang berisi instruksi atau pemanggilan aksi
yang telah didefinisikan. Komponen teks algoritmik dalam pemrograman prosedural
dapat berupa:
- instruksi dasar seperti input/output, assignmnet
- sequential statement
- analisis kasus
- pengulangan
Contoh suatu teks algoritma yang lengkap dapat dilihat pada bab-bab berikutnya.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 31 dr 217
TYPE
Type adalah pola representasi suatu data dalam komputer. Gunanya untuk
mendefinisikan objek yang akan diprogram. Ada type dasar (yang diasumsikan ada)
dan type bentukan, biasanya type bentukan dibentuk dari type dasar. Type tidak
menentukan alokasi memori di komputer, tetapi hanya mendefinisikan pola struktur
informasi.
Mendefinisikan TYPE berarti :
menentukan nama type dalam kamus
definisi domain harga yang dapat dipunyai oleh nama tsb.
konvensi atau perjanjian tentang penulisan konstanta bertype tsb.
operator yang dapat dioperasikan terhadap objek bertype tsb.
Ada type dasar yang sudah diberikan dan dan siap dipakai, ada type bentukan yang
dibentuk dari type dasar atau dari type bentukan/komposisi yang sudah dibuat.
Type Dasar
Type dasar yang tersedia dalam suatu bahasa adalah type yang sudah didefinisikan
oleh pemroses bahasa. Karena sudah didefinisikan, maka pemrogram dapat memakai
nama type dan semua operator yang tersedia, dan mentaati domain nilai yang
disimpan dalam type tersebut.
Type dasar yang dianggap biasanya tersedia dalam suatu bahasa tingkat tinggi (dan
merupakan type dasar dalam notasi algoritmik) adalah type-type dasar berikut:
bilangan logika/boolean
bilangan bulat
bilangan riil
karakter
Implementasi type tersebut dalam berbagai bahasa dapat sedikit berbeda. Akan
dipelajari ketika dijelaskan pada bahasa yang bersangkutan.
1. Bilangan Logika/boolean
Nama : boolean
Domain : [true, false]
Konstanta : true
Operator :
KELOMPOK
Operator logika
false
Op
and
or
Xor
not
EQ
nEQ
ARTI
dan
atau
ekslusive OR
negasi
ekivalensi
Negasi dari ekivalensi
HASIL
boolean
boolean
boolean
boolean
boolean
boolean
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 32 dr 217
Hasil operasi operator boolean tersebut diberikan oleh tabel kebenaran sebagai
berikut:
Operasi
Hasil
Operasi
Hasil
true
true or true
true
false
true or false
true
false
false or true
true
false
false or false
false
not false
true
not true
false
true EQ true
true
false
true EQ false
false
true
false EQ true
false
true
false EQ false
true
false
2. Bilangan Bulat
Nama : integer
Domain : Z (hati-hati dengan representasi komputer)
Konstanta :
0
3
123 -89
56
999
Bilangan integer mempunyai keterurutan. Keterurutan ini didefinisikan dengan :
suksesor x adalah x + 1
predesesor x adalah x - 1
Contoh:
suksesor 0 adalah 1
predesesor -1 adalah -2
suksesor -1 adalah 0
predesesor 3 adalah 2
suksesor 5 adalah 6
Operator
KELOMPOK
Operator
aritmatika
Op
*
+
/
div
mod
abs
ARTI
Kali
Tambah
Kurang
Bagi
Bagi
Sisa pembagian bulat
Nilai absolut
Hasil
integer
integer
integer
real
integer
integer
integer >0
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 33 dr 217
KELOMPOK
Operator
relasional/
perbandingan
Op
^
<
>
ARTI
Pangkat
Lebih kecil
Lebih kecil atau sama dengan
Lebih besar
Lebih besar atau sama dengan
Sama dengan
Tidak sama dengan
Hasil
integer
boolean
boolean
boolean
boolean
boolean
boolean
3. Bilangan Riil
Nama : real
Domain : R (hati-hati dengan representasi komputer)
Konstanta : angka mengandung '.'. Dapat dituliskan dengan notasi E yang
berarti pangkat sepuluh.
Contoh konstanta :
0.
0.2
3.233 123.
KELOMPOK
Operator
aritmatika
Operator
relasional/
perbandingan
-89.0 56.
Op
*
+
/
^
<
>
999.
12.E-2
1.5E1
ARTI
Kali
Tambah
Kurang
Bagi
Pangkat
Lebih kecil
Lebih kecil atau sama dengan
Lebih besar
Lebih besar atau sama dengan
Tidak Sama dengan
Hasil
real
real
real
real
real
boolean
boolean
boolean
boolean
boolean
Catatan :
1. Bilangan riil yang mengandung E berati pangkat sepuluh. Contoh: 1.5E2
berarti 1.5 * 102
2. Dalam notasi algoritmik, operator relasional kesamaan tidak berlaku untuk
bilangan riil, untuk harga riil harus didefinisikan suatu bilangan kecil yang
menyatakan ketelitian perhitungan, termasuk yang disebut dengan
"kesamaan".
3. Pada bahasa pemrograman yang nyata, operator kesamaan bilangan riil
mungkin dapat dipakai dengan baik, namun harus hati-hati dan sangat
spesifik untuk implementasi bahasa tertentu. Dengan alasan ini, pada notasi
algoritmik operator kesamaan bilangan riil dianggap tidak ada.
4. Karakter
Nama : character
Domain : Himpunan yang terdefinisi oleh suatu enumerasi, misalnya :
['0'..'9','a'..'z','A'..'Z',, RETURN, SPACE, EOL]
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 34 dr 217
Ada karakter yang kelihatan dan tidak kelihatan (maka dituliskan dengan nama
seperti pada contoh (RETURN, SPACE, EOL),
Ada keterurutan (suksesor dan predesesor), yang ditentukan oleh representasi di
dalam komputer, misalnya pengkodean ASCII.
Konstanta : dituliskan di antara tanda petik atau suatu nama
'A'
'P'
'K'
RETURN
'M'
Operator:
KELOMPOK
Operator
perbandingan
Op
=
ARTI
Sama dengan
Tidak sama dengan
Hasil
boolean
boolean
String
Ada sebuah type yang sangat diperlukan di hampir semua sistem, yang pada akhirnya
dapat dianggap setengah type dasar karena sudah tersedia, yaitu String. Untuk
selanjutnya, type string dapat dianggap type primitif.
Untuk membedakan string dengan karakter, sebagai pembatas digunakan tanda petik
ganda ()
Contoh :
Type: string
Domain : untaian karakter yang didefinisikan pada Domain character
Konstanta :
KU Anak hilang Pisang
K
Operator:
KELOMPOK
Operator
perbandingan
Konstruksi
Op
=
o
&
ARTI
Sama dengan
Tidak sama dengan
Tambah satu karakter di akhir
string
string x character string
Tambah satu karakter di awal
string
character x string string
konkatenasi
string x string string
Hasil
boolean
boolean
string
string
string
Type Enumerasi
TYPE enumerasi adalah type yang tidak definisi domainnya tidak dilakukan menurut
suatu aturan (by definition) melainkan dengan melakukan enumerasi atau
menyebutkan satu per satu nilai anggotanya. Type enumerasi mewakili himpunan
nilai yang diberi nama.
Karena disebutkan satu per satu, maka dalam suatu type enumerasi biasanya dikenal
cara akses suatu nilai anggota enumerasi lewat katakunci sebagai berikut :
- First, yaitu anggota nilai yang pertama
- Last, yaitu anggota nilai yang terakhir
- Successor (elemen) yaitu anggota nilai yang berikutnya dari elemen
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 35 dr 217
Type ini seringkali tersedia dalam bahasa tingkat tinggi, gunanya untuk
mendefinisikan dengan lebih jelas suatu himpunan nilai yang pasti, misalnya :
type hari : (senin, selasa, rabu, kamis, jumat, sabtu, minggu)
type warna : (merah,kuning, hijau, biru, nila, ungu)
Contoh : Type hari
{Type hari menyatakan enumerasi nama hari dalam minggu }
type hari : (senin, selasa, rabu, kamis, jumat, sabtu, minggu)
Jika dideklarasi NAMA variabel H sebagai berikut :
H : hari { artinya : H adalah nama bertype hari }
Maka cara mengacu/mengakses nilai elemen yang tersimpan pada P yang telah
terdefinisi adalah:
First (H)
{menghasilkan nilai: senin}
Last (H)
{menghasilkan nilai: minggu}
Succ (selasa) {menghasilkan nilai: rabu}
Prec (selasa) {menghasilkan nilai: senin}
Domain : nilai yang dienumerasi yaitu (senin, selasa, rabu, kamis, jumat, sabtu,
minggu)
Konstanta : senin sabtu
Type Bentukan
Type bentukan adalah suatu TYPE yang dirancang/dibentuk (dan diberi nama) dari
beberapa komponen bertype tertentu, jadi merupakan sekumpulan elemen bertype
dasar atau bertype yang sudah dikenal. Type bentukan dibuat/didefinisikan karena
perancang program memutuskan bahwa keseluruhan (hasil komposisi) komponen
type tersebut mempunyai sebuah makna semantik Ada relasi yang persis antara satu
elemen dengan yang lain. Operasi terhadap komponen (elemen) bertipe dasar
dilakukan seperti yang didefinisikan pada tipe dasar. Operasi terhadap keseluruhan
tipe mungkin didefinisikan atau tidak.
Type bentukan seringkali disebut sebagai type komposisi, agregat. Implementasinya
dalam suatu bahasa sangat bervariasi satu sama lain. Dalam notasi algoritmik, sebuah
type bentukan berupa agregasi elemen dituliskan dengan notasi :
type nama type < elemen1: type1,
elemen2: type2,
elemen2: type2,
.>
Perhatikan dalam pengertian sebagai type bentukan, maka ada kesleuruhan type yang
harus dibentuk menurut pembentuk tertentu yaitu Konstruktor pada perkuliahan
terkait), atau adanya komponen type yang harus dapat diacu oleh Selektor. Operator
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 36 dr 217
terhadap type tersebut harus dibuat. Hal ini akan dibahas lebih mendalam dan
terstruktur dalam kuliah Struktur Data karena pada hakekatnya, membentuk sebuah
type berarti menentukan Struktur Data.
Pada bagian ini, hanya diberikan contoh-contoh dan yang diutamakan adalah notasi
tentang bagaimana mengakses elemen type oleh notasi akses yang tersedia.
Contoh-1: Type Point
{Type point menyatakan absis dan koordinat real pada sumbu kartesian}
type Point : < X:real,
{ absis}
{ ordinat }
Y:real
>
Jika dideklarasi NAMA variabel P sebagai berikut :
P : Point { artinya : P adalah sebuah Point}
Maka cara mengacu/mengakses nilai elemen yang tersimpan pada P yang telah
terdefinisi adalah:
P.X {menghasilkan nilai absis bertype real}
P.Y { menghasilkan nilai ordinat bertype real}
Domain : <real, real>
Konstanta :
<5.0,6.0>
<6.0,100.0>
Operator :
- operator terhadap Point harus dibuat.
- operasi real terhadap P.X dan Point.Y
Contoh-2 : Type JAM (versi 1)
{Type JAM menyatakan representasi jam dalam notasi HH:MM:SS dengan HH
bernilai [0..23]; MM bernilai [0..59] dan SS bernilai [0..59] }
type Date : < HH : integer [0..23], { jam}
MM : integer [0..59] , { menit }
SS : integer [0..59], { detik }
>
Jika dideklarasi NAMA variabel J sebagai berikut :
J : Jam { artinya : J adalah sebuah JAM }
Maka cara mengacu/mengakses nilai elemen yang tersimpan pada P yang telah
terdefinisi adalah:
J.HH {menghasilkan nilai bagian jam bertype integer [0..23]}
J.MM { menghasilkan nilai bagian menit bertype integer [0..59]}
J.SS { menghasilkan nilai bagian detik bertype integer [0..59]}
Domain : < integer , integer , integer >
Konstanta :
<0,0,0>
<15,20,30>
Operator :
- operator terhadap JAM harus dibuat.
- operasi integer terhadap komponen HH, MM, SS
Contoh-3 : Type JAM (versi 2)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 37 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 38 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 39 dr 217
Pengisian Nilai
Suatu nama konstanta secara otomatis akan mempunyai harga tetap yang terdefinisi
pada saat nama konstanta tersebut didefinisikan dalam kamus. Jadi menyebutkan
nama konstanta secara otomatis akan memakai harga yang didefinisikan pada kamus
tersebut. Tidak demikian halnya dengan nama informasi. Suatu nama informasi dapat
dipakai dalam ekspresi jika harganya telah terdefinisi. Ada dua cara untuk mengisi
suatu nama informasi dengan harga, yaitu dengan:
- assignment, atau
- dibaca dari suatu piranti masukan
Assignment
Assignment adalah instruksi primitif algoritmik untuk menyimpan harga pada suatu
nama informasi yang isinya boleh bervariasi (variabel), dengan perkataan lain
adalah memberikan harga pada suatu nama variabel. Dengan pemberian harga ini,
harga lama yang disimpan tidak lagi berlaku, yang berlaku adalah harga paling akhir
yang diberikan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 40 dr 217
<nama> <konstanta>
<nama> <ekspresi>
harga
konstanta
diisikan
ke
nama
dengan syarat :
- bagian kiri dan bagian kanan tanda pemberian harga ( ) bertype sama
- <nama> dan <nama1> (bagian kiri tanda ) harus merupakan nama
informasi, tidak boleh nama konstanta, type, fungsi atau prosedur
- nama yang tertulis di bagian kanan tanda (misalnya nama2 atau nama
konstanta atau nama yang dipakai dalam ekspresi) boleh berupa nama
informasi, nama fungsi, nama konstanta
- semua nama yang dipakai dalam assignment tidak boleh berupa nama type
atau nama prosedur.
Input
Selain dengan assignment, suatu harga dapat diisikan ke suatu nama informasi melalui
pembacaan harga tersebut dari piranti masukan (keyboard, mouse, scanner, dsb).
Disebut dibaca, karena arah dari pengisian harga yaitu seakan-akan komputer
membaca harga yang diberikan pengguna. Pemberian harga dari piranti masukan ini
mencakup konsep menerima nilai dari piranti masukan apapun, misalnya menerima
nilai besaran temperatur dari sebuah sensor temperatur yang dihhubungkan dengan
komputer di suatu ruangan.
Algoritma
input(list-nama)
dengan syarat :
- list nama adalah satu atau lebih nama informasi
- nama yang muncul pada list-nama hanya boleh berupa nama informasi, dan
tidak boleh nama lain (nama konstanta, type, fungsi atau prosedur)
Output
Suatu harga yang disimpan dalam memori komputer (diacu berkat definisi nama
informasi (variabel), nama konstanta atau konstanta) harus dapat dikomunikasikan ke
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 41 dr 217
dunia luar untuk diinterpretasikan oleh pemakai program. Dalam hal ini, harga harus
dapat dituliskan ke suatu piranti keluaran, misalnya layar, printer.
Instruksi algortimik yang disediakan untuk menuliskan nama informasi adalah
instruksi penulisan atau output. Instruksi output tidak mengubah nilai yang disimpan.
Algoritma
output(<list-nama>) { semua harga yang tersimpan dalam setiap nama
yang ada pada list-nama akan dituliskan
pada piranti keluaran sesuai dengan urutan
penulisan nama. Perhatikan bahwa yang
dituliskan ke piranti keluaran hanya harga
yang disimpan saja. Lihat contoh }
output(<konstanta>) { harga konstanta dituliskan
ke piranti keluaran }
output(<ekspresi>)
dengan syarat :
- list nama adalah satu atau lebih nama : boleh nama informasi, nama
konstanta atau hasil pemanggilan/aplikasi fungsi. Khusus untuk pemanggilan
Fungsi, lihat pemakaian fungsi.
- nama-nama dalam list-nama tidak boleh berupa nama type atau prosedur
- nama yang akan dituliskan sudah terdefinisi harganya. Jika suatu nama
informasi, didefinisikan dengan assignment atau instruksi input
Ekspresi
Ekspresi suatu rumus perhitungan", yang terdiri dari operan dan operator. Operator
yang dituliskan harus didefinisikan untuk mengoperasikan operan bertype tertentu.
Hasil perhitungan adalah harga dengan domain yang memenuhi type operator yang
bersangkutan.
Operan harus mempunyai harga, karena itu dapat berupa konstanta, nama (dalam
hal ini yang dipakai dalam perhitungan adalah harga yang dikandung nama ybs.),
hasil pengiriman suatu fungsi atau merupakan suatu ekspresi.
Ekspresi uner adalah ekspresi dengan operator uner, yaitu operator yang hanya
membutuhkan satu operan.
Ekspresi biner adalah ekspresi dengan operator biner (membutuhkan dua operan)
dapat dituliskan dalam 3 macam notasi, yaitu :
a. Notasi infix : operator di tengah
operan1 operator operan2
Contoh :
13 * 5
((3 * 5) + (4 div 7) )- (a * b)
b. Notasi prefix : operator di awal
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 42 dr 217
boolean
= true
{Nama Informasi }
Found : boolean
Flag : boolean
Algoritma :
{ Pada bagian ini telah didefinisikan sehingga nilai berikut:
Harga Found adalah true dan Flag adalah false }
Ekspresi boolean
true and false
true or false
Hasil
Keterangan
false
true
false
Flag
false
Flag = false
not Found
false
Found =
false
true
true
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 43 dr 217
1 + 3 * 5
16
1 / 3
0.333
11 > 3
true
11 > 21
false
10 mod 3
10 div 3
1+7 div 3
1./3.
0.333
10./2.
5.
i + 1
i + j
x * PI
0.0
i + x
??
x + y
0.0
Ekspresi integer
Ekspresi integer
Ekspresi integer, hasil riil
Ekspresi relasional untuk integer
Ekspresi relasional untuk integer
Ekspresi integer
Ekspresi integer
Ekspresi integer
Ekspresi real
Ekspresi real
i = 5, Ekspresi integer
i=5 dan j=0, Ekspresi integer
x=0.0 dan PI= 3.1415, Ekspresi riil
operan tidak sejenis
x = 0.0 dan y = 7.5, Ekspresi riil
character
{Nama Informasi }
CC : character
str1, str2 : string
Algoritma :
{ Pada bagian ini telah didefinisikan sehingga nilai berikut:
Harga CC adalah A, str1 adalah AKU dan str1 adalah X }
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 44 dr 217
Ekspresi
CC = X
blank
Hasil
false
Keterangan
Ekspresi pembandingan
Nilai dari konstanta
AKUX
Konkatenasi
CC o str1
AAKU
str1 CC
AKUA
Latihan Soal
Didefinisikan nama dalam kamus sebagai berikut :
KAMUS
constant
Pi : real = 3.1714
GajiTotal, GajiPokok, Tunjangan, PotGaji : real
MID1, MID2 : integer
Urutan, ranking : integer
CC1, CC2 : character
S1, Message : string
Found : boolean
function
AddXY (X,Y: integer)
integer
{ Menghasilkan penjumlahan X+ Y }
Berikut ini adalah contoh ekspresi dalam notasi infix untuk kamus dia atas. Periksalah
apakah ekspresi yang dituliskan benar. Jika benar tentukan jenis hasilnya, jika salah
koreksilah.
Ekspresi
Jenis hasil dan komentar
Urutan 1
CC1 or CC2
Found and (Urutan>100)
(Urutan ^ 2) +GajiTotal+ADDXY(MID1,MID2)
GajiPokok + Tunjangan - PotGaji
Urutan * 2 /ranking
Message & S1
Message = HELLO
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 45 dr 217
AKSI SEKUENSIAL
Aksi sekuensial (Sequential statement) adalah struktur kontrol algoritmik yang paling
sederhana. Sequential statement adalah sederetan instruksi primitif dan/atau aksi yang
akan dilaksanakan (dieksekusi) oleh komputer berdasarkan urutan penulisannya. Jadi,
jika dituliskan sebuah sequential statements yang terdiri dari deretan instruksi/aksi ke
1,2,3,4,.........n maka setiap instruksi/aksi akan dilaksanakan secara sekuensial mulai
dari yang ke 1, kemudian k-2, ke-3,.... s/d ke-n. Program paling sederhana tentunya
hanya mengandung satu satu instruksi saja.
Initial State dari sequential statement adalah state awal yang harus dipenuhi dan
Final state dari sequential statement adalah final state setelah instruksi/aksi terakhir.
Final state dari sebuah instruksi/aksi yang ada pada urutan instruksi/aksi ke-i akan
menjadi Initial state dari instruksi/aksi ke-i+1. Dengan kata lain, urut-urutan
penulisan instruksi/aksi pada suatu sequential statement sangat penting.
Notasi algoritmik untuk instruksi sekuaential
Urutan penulisan instruksi/aksi pada sequential statement adalah sesuai dengan
penulisannya per baris. Aksi sekuensial dapat juga dituliskan menjadi satu baris
program dengan cara memisahkan penulisan setiap instruksi/aksi dengan tanda titik
koma. Penulisan aksi sekuensial dengan dipisahkan titik koma sebaiknya hanya
dilakukan untuk aksi sekuensial yang jika urutan penulisannya diubah tidak
berpengaruh kepada program
Program SEQ1
{ Contoh penulisan aksi sekuensial per baris }
Kamus :
i : integer
x : real
flag : boolean
Algoritma :
input (i)
x
0.0
flag true
output (x)
output (i*2, flag)
Program SEQ2
{ Contoh penulisan aksi sekuensial dengan tanda titik koma}
Kamus :
i : integer
x : real
flag : boolean
Algoritma :
input (i); x 0.0; flag true
output (x) ; output (i*2, flag)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 46 dr 217
Ada aksi sekuensial yang jika diubah urutan instruksi/aksinya akan mempengaruhi
eksekusi program. Ada sequence yang jika diubah urutan instruksi/aksinya akan
menghasilkan efek neto yang sama (tidak berpengaruh).
Contoh aksi sekuensial yang berpengaruh jika diubah urutannya
Program SEQ3
{ aksi sekuensial yang berpengaruh jika diubah urutannya }
Kamus :
i : integer
Algoritma :
{ Jika urut-urutan dua buah instruksi pada program dengan dua buah instruksi
sekuensial sebagai berikut diubah, maka akan menghasilkan kesalahan fatal
karena syarat untuk dapat menuliskan harga yang tersimpan di suatu nama
adalah bahwa nama tersebut sudah terdefinisi harganya}
{State : i belum terdefinisi }
input (i)
{State : i terdefinisi akibat instruksi input}
output (i)
{State : i tertulis di piranti keluaran }
Pada bagian ini akan diberikan beberapa contoh program yang hanya mengandung
aksi sekuensial, dan hanya mempergunakan instruksi yang pernah dipelajari
sebelumnya yaitu manipulasi nama dan harga.
Jika bagian prosedur, analisis kasus dan pengulangan serta yang lain telah dipelajari,
maka aksi sekuensial boleh mengandung analisis kasus dan pengulangan serta aksi
yang yang dinyatakan dengan nama prosedur.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 47 dr 217
Contoh-1 : HELLO
Persoalan :
Tuliskanlah algoritma untuk menulis "HELLO" ke piranti keluaran yang disediakan.
Berikut ini diberikan 2 solusi. Pikirkanlah, mana yang lebih "baik".
Spesifikasi
Input :
Output : HELLO
Proses :
menulis HELLO
Program HELLO1
{ menulis "HELLO" ke piranti keluaran }
Kamus
Algoritma :
output (HELLO)
Program HELLO2
{ menulis "HELLO" ke piranti keluaran }
Kamus
pesan : string
Algoritma :
pesan HELLO
output (pesan)
Contoh-2 : HELLOX
Persoalan:
Tuliskanlah algoritma untuk membaca sebuah nama, dan menulis "HELLO" yang
diikuti dengan nama yang diketikkan. Contoh :
jika dibaca ALI, maka keluaran adalah : HELLO ALI
jika dibaca SINTA, maka keluaran adalah : HELLO SINTA
Spesifikasi
Input : nama
Output : HELLO <nama>
Proses :
menulis HELLO diikuti nama yang dibaca
Program HELLOX
{ menulis "HELLO" berikut nama yang diberikan dari piranti masukan ke
piranti keluaran }
Kamus
name : string { nama informasi yang dituliskan pesannya }
Algoritma :
input (name)
output (HELLO , name)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 48 dr 217
Contoh-3 : JARAK
Persoalan :
Dibaca dua buah harga v (kecepatan, m/detik) dan t (waktu, detik), yang mewakili
koefisien persamaan gerak lurus beraturan. Harus dihitung dan dituliskan hasilnya,
jarak yang ditempuh benda yang bergerak lurus beraturan dengan kecepatan v
tersebut dalam waktu t.
Spesifikasi:
Input : v (kecepatan, m/detik), integer dan t (waktu, detik), integer
Proses : menghitung S = v * t
Output : S (jarak yang ditempuh dalam meter ), integer
Program JARAK1
{ Dibaca v dan t, Menghitung S = v * t dan menuliskan hasilnya, }
{ dengan memakai nama antara }
Kamus
v : integer {kecepatan, m/detik
}
t : integer {waktu, detik
}
S : integer { jarak (m) yang ditempuh dalam waktu t,
dengan kecepatan v, pada gerak lurus beraturan}
Algoritma :
input (v,t)
S v * t
output (S)
Program JARAK2
{Dibaca v dan t, menghitung jarak = v * t
{ Tanpa memakai nama antara }
Kamus
v : integer {kecepatan, m/detik)
t : integer {waktu, detik)
Algoritma :
input (v,t)
output (v*t)
Catatan :
1. Mengenai input yang dibaca oleh program : dalam kehidupan sehari-hari, akan
sangat sulit untuk memasukkan input nilai v dan t di atas, karena jika pemakai
program salah memasukkan urutan, harga yang tersimpan akan salah. Untuk
contoh di atas, karena rumusnya hanya perkalian dua buah nilai integer mungkin
tidak fatal. Jika rumus misalnya adalah v-t maka pemasukan data dengan urutan
yang lain akan fatal akibatnya.
2. Mengenai output : output program di atas sangat sulit diinterpretasi karena yang
dihasilkan oleh program hanya sebuah angka yang tidak jelas interpretasinya.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 49 dr 217
Program JARAK3
{Dibaca v dan t, menghitung jarak = v * t
{ tanpa memakai nama antara }
Kamus
v : integer {kecepatan, m/detik)
t : integer {waktu, detik)
Algoritma :
output (Input nilai kecepatan : )
input (v)
output (Input nilai waktu : )
input (t)
output (Jarak yang dihitung = , v*t)
Catatan :
1. Dengan menuliskan semacam ini, program akan dapat dioperasikan dengan lebih
mudah, namun algoritma menjadi sangat rinci. Lebih rinci lagi, dapat dibuat layar
yang indah dengan warna-warni dan posisi penulisan yang enak dibaca.
2. Tujuan dari menuliskan algoritma adalah untuk menuliskan sketsa solusi dari
program, jadi hanya mengandung hal yang esensial.
3. Sebaiknya instruksi yang sudah sangat rinci dan tidak mengandung hal esensial
dikode secara langsung dalam bahasa pemrograman pada saat impelementasi.
Jadi, teks algoritma JARAK1 dan JARAK2 yang hanya mengandung hal yang
esensial adalah produk dari design program, sedangkan teks rinci semacam
JARAK3 langsung pada bahasa pemrogramannya.
4. Untuk selanjutnya, teks algoritma dituliskan dengan hanya mengandung hal yang
esensial saja karena pusat perhatian kita adalah untuk menghasilkan sketsa solusi
saja.
Contoh-4 : JAMMENITDETIK
Persoalan :
Dibaca sebuah harga berupa bilangan bulat, positif dan lebih kecil dari 1 juta, yang
mewakili besaran dalam detik. Harus dihitung ekivalensinya, berapa hari, jam berapa
menit dan berapa detik. Contoh : data 309639 akan menghasilkan 3, 14, 0, 39, yang
artinya 3 hari, 14 jam, 0 menit dan 9 detik
Spesifikasi:
Input : n (detik), integer
Proses : menghitung hari, jam, menit, detik ekivalen dengan n
Output : HARI, JAM, MENIT, DETIK
Analisis : nama-nama informasi yang akan dibutuhkan adalah :
n : bilangan yang dibaca sebagai data, integer antara 0 dan 999999
H : HARI, bilangan bulat positif, HARI
J : JAM, bilangan bulat positif antara 0 - 23
M : MENIT, bilangan bulat antara 0 -59
D : DETIK, bilangan bulat antara 0 - 59
Rumus : 1 hari = 86400 detik; 1 jam = 3600 detik dan 1 menit = 60 detik.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 50 dr 217
Program JAMMENITDETIK
{ Dibaca n (integer), besaran dalam detik}
{ Harus dihitung J (Jam) dan M(Menit) dan D(Detik sisanya), dan
dituliskan hasilnya }
Kamus
n : integer [0..999999] { data yang dibaca }
H : integer
0 {HARI, bilangan bulat positif}
J :
integer [0..23] {JAM, bilangan bulat positif antara 0 - 23 }
M : integer [0..59] {MENIT, bilangan bulat antara 0 -59 }
D : integer [0..59] {DETIK, bilangan bulat antara 0 - 59 }
rH : integer [0..86399] { sisa detik dalam perhitungan HARI }
rJ : integer [0..3599] { Sisa detik dalam perhitungan JAM }
Algoritma :
input (n) { 0 n 999999 }
H n div 86400; rH n mod 86400;
{ n = 86400*H + rH and 0 rH < 86400 }
J rH div 3600; rJ rH mod 3600;
{n = 86400*H + 3600*J + rJ and 0 rH < 86400 and 0 rJ < 3600 }
M rJ div 60; D rJ mod 60;
{ n = 86400*H + 3600*J + 60*M + D and
0 rH < 86400 and 0 rJ < 3600 and 0 M < 60 and 0 D < 60}
output (H,J,M,D)
Catatan :
1. Ini adalah contoh program dengan asersi yang lengkap, yang merupakan
pembuktian kebenaran program. Namun setiap baris mengandung asersi. Untuk
selanjutnya, asersi dituliskan secukupnya, dan pelajaran mengenai asersi yang
lengkap akan dicakup pada matakuliah Analisis algoritma.
2. Program tersebut adalah pola solusi untuk menguraikan sebuah besaran (detik)
menjadi besaran lain (hari, jam, menit, detik) berdasarkan rumus konversi besaran.
Pemilihan nama informasi pada program tersebut kurang mengandung artinya, maka
disertakan definisi nama singkat sebagai komentar. Jika pemilihan nama sudah
interpretatif, tidak perlu lagi deskripsi nama seperti pada contoh.
merepresentasi 1/2
merepresentasi -4/2
merepresentasi 1/1
merepresentasi 0/2
bukan pecahan, karena di luar definisi pecahan
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 51 dr 217
Program PECAHAN1
{Input : P1, P2 bertype pecahan;
Output : hasil perkalian P1 dan P2 }
{ membaca dua buah pecahan, mengalikan serta menuliskan hasilnya }
{ tanpa nama antara }
Kamus
Type Pecahan : < Pembilang : integer, Penyebut : integer >0 >
P1 : Pecahan
P2 : Pecahan
Algoritma :
input (P1,P2)
output ( < P1.Pembilang*P2.Pembilang, P1.Penyebut*P2.Penyebut > )
Program PECAHAN2
{ Input : P1, P2 bertype pecahan;
Output : hasil perkalian P1 dan P2 }
{ Proses: membaca dua buah pecahan,
mengalikan serta menuliskan hasilnya }
{ dengan memakai nama antara }
Kamus
Type Pecahan : < Pembilang : integer, Penyebut : integer >
P1 : Pecahan
P2 : Pecahan
Pkali : Pecahan
Algoritma :
input (P1,P2)
PKali.Pembilang P1.Pembilang *P2.Pembilang
PKali.Penyebut P1.Penyebut*P2.Penyebut
output (Pkali)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 52 dr 217
Program DURASI
{ Input :
JamAwal, JamAKhir bertype Jam (HH:MM:DD);
dan JamAkhir SELALU JamAwal
Output : selisih waktu dalam detik antara JamAwal dan JamAkhir
Kamus
Type
Algoritma :
input (JamAwal, JamAkhir)
Durasi (JamAkhir.HH * 3600 + JamAkhir.MM * 60 + JamAkhir.DD) (JamAwal.HH * 3600 + JamAwal.MM * 60 + JamAwal.DD)
output ( Durasi )
Catatan :
1. Ini adalah pola program, yang menunjukan cara perhitungan dengan komputer
yang berbeda dengan cara manual sebagai berikut :
13 10 50
13 10 10
12 05 10 12 50 30 01 05 40
00 19 40
Cara manual akan membutuhkan algoritma yang lebih rumit !
Seringkali komputasi dengan cara konversi ke nilai absolut semacam ini
dilakukan dengan komputer.
Latihan Soal
1. Apa komentar anda mengenai pemilihan NAMA-NAMA pada algoritma
JAMMENITDETIK di atas ?
2. Seorang programmer menuliskan pernyataan sebagai berikut, setelah
mendefinisikan semua nama yang dipakai sebagai real:
DUA=TUJUH + LIMA
Cinta = Toto + Tita
Apa komentar anda ?
3. Jika type jam diubah sehingga aturan penulisannya bukan lagi dalam domain
00:00:00 sampai dengan 23:59:59 melainkan menjadi dari 00:00:00 am sampai
dengan 11:59:59 pm, apa yang harus dilakukan dengan program DURASI ?
4. Tuliskanlah minimal 20 rumus dalam bidang fisika dan matematika yang dapat
diprogram dengan program JARAK sebagai pola program.
Buatlah spesifikasi dan algoritma untuk persoalan-persoalan berikut :
1. Dibaca dua buah harga yang dihasilkan dari pengukuran Arus (Ampere) dan
Tahanan (Ohm), harus dihitung tegangan yang dihasilkan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 53 dr 217
2. Dibaca sebuah bilangan bulat (rupiah) yang positif, harus dihitung ekivalensinya
dalam dollar ($) dan dituliskan hasilnya. Bagaimana dengan perubahan kurs yang
sering terjadi ?
3. Apa yang harus diubah jika misalnya selain menghitung ekivalensi dalam $ juga
harus dihitung ekivalensi dalam Yen, DM dan FF ?
4. Dibaca sebuah besaran riil, yang mewakili hasil pengukuran temperatur dalam
derajat Celcius. Hitung ekivalensinya dalam derajat Fahrenheit, Rheamur dan
Kelvin.
5. Dibaca nama dan jam kerja pegawai, harus dihitung honor pegawai tersebut jika
upahnya perjam adalah Rp. 5000,- Perhatikan bahwa upah perjam setiap pegawai
tidak sama, dan perubahan upah tidak sesering perubahan kurs.
6. Dibaca tiga buah bilangan bulat yang mewakili tiga buah tahanan dalam Ohm : R1,
R2 dan R3, harus dihitung dan dituliskan tahanan total yang dihasilkan jika
ketiganya dipasang seri / paralel.
7. Dibaca lima buah bilangan bulat A1, A2, A3, A4 dan A5, harus dihitung
jumlahnya dan dituliskan hasilnya. Bagaimana jika yang dibaca adalah 1000 buah
bilangan ?.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 54 dr 217
ANALISIS KASUS
Analisis kasus, yang melahirkan instruksi kondisional, adalah elemen primitif
pembangun algoritma, yaitu memungkinkan kita untuk membuat teks yang sama
namun menghasilkan eksekusi yang berbeda-beda.
Mendefinisikan analisis kasus adalah mendefinisikan :
- kondisi, yang berupa suatu ekspresi yang menghasilkan true atau false
- aksi yang akan dilaksanakan jika kondisi yang dipasangkan dengan aksi ybs.
dipenuhi
Konstruksi dari suatu analisis kasus dapat dimulai dari menentukan semua kondisi
yang mungkin (dengan melakukan partisi domain), atau dimulai dari menentukan
variasi aksi. Tidak ada rumus yang baku tentang bagaimana memulai menuliskan
analisis kasus. Pada contoh-contoh yang diberikan, ada yang berangkat dari kondisi,
dan ada yang dimulai dari menentukan aksi.
Notasi algoritmik secara umum untuk analisis kasus yang umum (banyak kasus)
depend on (nama-nama)
<kondisi-1> : <aksi-1>
<kondisi-2 > :<aksi-2>
<kondisi-3> : <aksi-3>
.
.
kondisi-N : aksi-N
dengan syarat :
kondisi-1,kondisi-2,kondisi-3 ... .,kondisi-N domain harganya [true,false]
kondisi-1,kondisi-2,kondisi-3 ... .,kondisi-N adalah ekspresi lojik/boolean yang
mengandung nama-nama sebagai operan.
kondisi-1 kondisi-2 kondisi-3 ... . kondisi-N = . Berarti semua
kondisi disjoint, tidak ada kasus yang sama tercakup pada dua buah kondisi.
kondisi-1 kondisi-2 kondisi-3 kondisi-N berarti kondisi mencakup
semua kemungkinan
Jika hanya ada satu kasus yang mengakibatkan aksi, atau dua kasus komplementer,
dapat dipakai notasi sebagai berikut :
SATU KASUS:
if (kondisi) then
aksi
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 55 dr 217
Jika kondisi benar, maka aksi dilakukan. Jika kondisi tidak benar, maka tidak terjadi
apa-apa (efek neto kosong)
DUA KASUS KOMPLEMENTER:
if (kondisi) then
aksi-1
else { not
kondisi}
aksi-2
Catatan:
1. Perhatikan "indentasi" penulisan. Pada diktat ini, "end" sengaja tidak dituliskan
supaya mahasiswa memperhatikan indentasi penulisan
2. Hati-hati dalam memakai else yang berarti kondisi implisit yang merupakan
negasi dari kondisi. Penulisan kondisi else secara eksplisit sangat disarankan
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 56 dr 217
Contoh-2 : WUJUDAIR
Persoalan :
Dibaca sebuah harga berupa bilangan bulat, yang mewakili pengukuran suhu air
(dalam oC) pada tekanan atmosfir, harus dituliskan wujud air pada temperatur dan
tekanan itu.
Spesifikasi:
Input : T (integer)
Proses :
menuliskan wujud air sesuai dengan nilai T
Output :
Beku jika T 0
Cair jika 0 < T 100
Uap jika T > 100
Program WUJUDAIR1
{Dibaca T(integer), temperatur air (dalam oC) pada tekanan atmosfir}
{ Harus dituliskan wujud air pada temperatur T: Beku, Cair atau Uap }
Kamus
T : integer
Algoritma :
input (T)
depend on (T)
T 0
0 < T 100
T > 100
: output (Beku)
: output (Cair)
: output (Uap)
Program WUJUDAIR2
{Dibaca T(integer), temperatur air (dalam oC) pada tekanan atmosfir}
{ akan dituliskan wujud air pada temperatur T, dengan memisahkan
kasus peralihan sebagai kasus khusus }
Kamus
T : integer
Algoritma :
input (T)
depend on (T)
T < 0
: output (Beku)
T = 0
: output (Beku-Cair)
0 < T < 100 : output (Cair)
T > 100
: output (Uap)
T = 100
: output (Cair-Uap)
Catatan :
1. Solusi pada versi-1 berbeda dengan versi-2. Ini menyangkut spesifikasi dan
batasan program yang harus dijabarkan dan disetujui bersama dengan pemesan
program
2. Solusi versi-1 akan dapat dipakai untuk Temperatur yang bertype riil, namun
solusi versi-2 akan menimbulkan masalah karena operator kesamaan tidak dapat
dipakai untuk bilangan riil. Sebagai latihan, disarankan untuk menuliskan solusi
versi-2 jika Temperatur direpresentasi sebagai bilangan riil.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 57 dr 217
Contoh- 3: RANKING
Persoalan :
Dibaca tiga buah harga a,b dan c, harus dituliskan secara terurut, mulai dari yang
terkecil sampai dengan yang terbesar. Ketiga bilangan yang dibaca selalu berlainan
harganya.
Spesifikasi:
Input : a,b,c, tiga besaran integer
Proses : menuliskan harga yang dibaca mulai dari yang terkecil s/d yang
terbesar
Output :
a,b,c jika a < b dan b < c
a,c,b jika a < c dan c < b
b,a,c jika b < a dan a < c
b,c,a jika b < c dan c < a
c,a,b jika c < a dan a < b
c,b,a jika c < b dan b < a
Program RANKING1
{ dibaca tiga harga a, b dan c, a
b dan b
c dan a c}
{ harus dituliskan dari yang terkecil sampai dengan yang terbesar}
Kamus
a, b, c : integer
Algoritma :
input (a,b,c)
depend on (a,b,c)
a < b < c : output
a < c < b : output
b < a < c : output
b < c < a : output
c < a < b : output
c < b < a : output
(a,b,c)
(a,c,b)
(b,a,c)
(b,c,a)
(c,a,b)
(c,b,a)
Program RANKING2
{ dibaca tiga harga a, b dan c, a b, b
c, a c }
{ harus dituliskan dari yang terkecil sampai dengan yang terbesar}
Kamus
a, b, c : integer
Algoritma :
input (a,b,c)
depend on (a,b)
a < b : depend on (b,c)
b < c : output (a,b,c)
b > c : depend on (a,c)
c > a : output (a,c,b)
c < a : output (c,a,b)
a > b : depend on (a,c)
a < c : output (b,a,c)
a > c : depend on (b,c)
b < c : output (b,c,a)
b > c : output (c,b,a)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 58 dr 217
Catatan:
1. Pemeriksaan data semacam itu akan menambah robustness dari program. Jika
pemeriksaan data tidak dilakukan, maka kriteria data yang valid harus ditampilkan
secara eksplisit sehingga pemakai program dapat mengetahui spesifikasi data
benar dan tidak menyebabkan program abort.
2. Selanjutnya, algoritma-algoritma yang diberikan tidak akan mengandung
pemeriksaan kesalahan.
3. Berikut ini diberikan skema pemrosesan data yang dibaca dengan pemeriksaan
kesalahan yang dapat dipakai untuk beberapa kasus sederhana. Untuk kasus yang
lebih kompleks, pemeriksaan tidak dapat dilakukan dengan cara sederhana dan
pada awal program. Lihat latihan soal.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 59 dr 217
SKEMA PROSES_VALIDASI
{ skema program yang menerima input data, hanya melakukan proses jika
data valid }
Kamus
{ deklarasi data input }
Algoritma :
input (data)
if (data_valid) then {data_valid adalah Predikat,ekspresi boolean
yg menyatakan validitas dari data }
{ Lakukan proses }
else {data tidak valid }
output (Data salah, tidak sesuai spesifikasi)
Latihan soal
1. Data macam apa yang harus diberikan untuk "mencoba" semua contoh program
analisis kasus di atas ? Buatlah semua kemungkinan yang harus dicoba untuk
melakukan test terhadap program-program contoh.
2. Bagaimana jika dalam persoalan RANKING ternyata ada bilangan yang sama ?
3. Akar persamaan kuadrat :
Dibaca 3 buah bilangan integer A,B,C yang mewakili koefisien persamaan kuadrat:
AX2 + BX + C
Buatlah algoritma untuk menghitung akar-akar dari persamaan kuadrat tersebut.
Tentukan data test untuk program anda.
4. Bonus Pegawai :
Tuliskanlah algoritma untuk menentukan bonus pegawai, berdasarkan ketentuan
yang diberikan oleh bagian personalia dan keuangan sebagai berikut :
Pegawai perusahaan digolongkan menjadi dua golongan, yaitu staf dan bukan staf.
Staf akan mendapatkan bonus sebesar 1 juta rupiah dengan syarat bahwa ia telah
bekerja paling tidak 5 tahun dan umurnya sudah mencapai 50 tahun; staf yang
bekerja kurang dari 5 tahun berapapun umurnya, hanya mendapat bonus sebesar
Rp. 500.000,-. Pegawai non-staf yang telah bekerja lebih dari 5 tahun akan
mendapat bonus sebesar Rp. 400.000,- jika berumur lebih dari 50 tahun sedangkan
pegawai non staf yang berumur kurang dari 50 tahun hanya akan mendapat bonus
Rp. 250.000,-. Pegawai staf yang umurnya kurang dari 50 tahun akan mendapat
bonus Rp. 300.000,-
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 60 dr 217
Apa komentar anda tentang ketentuan dari bagian personalia dan keuangan
tersebut? Ingat bahwa anda seringkali harus membuat program berdasarkan
spesifikasi" semacam itu dari pemakai (user).
5. SEGITIGA:
Dibaca 3 buah bilangan riil sebagai data, yang mewakili panjang segmen garis
dalam centimeter. Buatlah algoritma untuk menentukan apakah ketiga segment
garis tersebut dapat membentuk sebuah segitiga. Output yang diharapkan adalah :
"Dapat membentuk segitiga", jika ya atau "Tidak mungkin membentuk segitiga"
jika tidak. Apa komentar anda ? Banyak persoalan yang harus diprogram,
diformulasikan sejenis ini.
6. TAHANAN :
a. Dibaca tiga buah bilangan bulat yang mewakili tiga buah tahanan dalam Ohm :
R1, R2 dan R3, dan sambungan yang akan dipilih SERI atau PARALEL,
harus dihitung dan dituliskan tahanan total yang dihasilkan sesuai dengan
sambungan yang ditentukan.
b. Bagaimana jika sambungan tersebut dikode ? Jika dikehendaki untuk dilakukan
pemeriksaan data, dan data yang valid untuk paralel berbeda dengan data valid
untuk seri (sebab untuk tahanan paralel tidak diperbolehkan adanya data tahanan
nol yang mengakibatkan pembagian dengan nol), maka skema
PROSES&VALIDASI tidak dapat dipakai begitu saja, melainkan harus sedikit
dimodifikasi. Tuliskanlah algoritmanya.
c. Ubahlah deklarasi nama R1, R2, R3 menjadi bertype bilangan riil. Apa
dampaknya ?
7. GAJI :
Pada suatu perusahaan, terdapat 5 golongan karyawan. Gaji karyawan ditentukan
berdasarkan gaji tetap dan juga dari lamanya bekerja. Gaji tetap dan gaji per jam
tersebut tergantung kepada golongan karyawan sesuai dengan tabel berikut
Golongan
Gaji tetap
Gaji per jam
1
Rp. 500.000,Rp. 5000,2
Rp. 300.000,Rp. 3000,3
Rp. 250.000,Rp. 2000,4
Rp. 100.000,Rp. 1500,5
Rp. 50.000,Rp. 1000,Jika karyawan bekerja lebih dari 150 jam,kelebihan dari 150 jam tersebut dihitung
sebagai lembur, dengan gaji per jam 1.5 kali gaji biasa.
Dibaca data: golongan karyawan, nama karyawan, jam masuk/pulang kerja; harus
dihitung gaji yang dibayar. Tentukan spesifikasi lembur dengan lebih persis.
8. Diberikan deretan analisis kasus sebagai berikut, untuk melakukan analisis
terhadap nilai D (determinan) suatu persamaan kuadrat
Berikan komentar mengenai analisis kasus yang dituliskan dalam teks algoritma
sebagai berikut.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 61 dr 217
Program Determinan
{ Dibaca a,b dan c yaitu nilai koefisien sebuah persamaan kuadrat,
harus dituliskan type determinannya: negatif, nol atau positif }
Kamus
{ Koefisien PK: }
a : real
b : real
c : real
D : real { determinan }
Algoritma :
input (a, b,c)
D b*b 4.0 * a * c
if (D<0) then
output (Determinan Negatif)
if (D=0) then
output (Determinan Nol )
if (D>0) then
output (Determinan Positif)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 62 dr 217
FUNGSI
Definisi :
Fungsi adalah pemetaan suatu domain ke range berdomain tertentu.
Fungsi adalah sebuah transformasi akibat pemetaan suatu nilai (dari domain)
ke nilai lain (dalam range). Secara algoritmik, sebuah fungsi akan menerima
suatu harga yang diberikan lewat parameter formal bertype tertentu (jika ada) dan
menghasilkan suatu nilai sesuai dengan domain yang didefinisikan dalam spesifikasi
fungsi.
Dalam penulisannya, fungsi diberi nama, dan parameter formal yaitu harga
masukan yang juga diberi nama dan dijelaskan typenya. Fungsi harus didefinisikan
dalam kamus.
Fungsi yang didefinisikan dapat dipanggil untuk dieksekusi lewat namanya,
dan dengan diberikan parameter aktualnya.
Penjelasan lebih rinci tentang parameter akan diberikan pada bagian Prosedur.
Contoh Fungsi:
Fungsi f(x) dengan satu parameter x dalam matematika yang didefinisikan sebagai :
f(x) = x2 + 3x 5
jika x = 4 maka f(x) akan menghasilkan 23
jika x = 1 maka f(x) akan menghasilkan -1
f(x,y) = x2 + 3xy - 5y 1 adalah fungsi dengan dua parameter x dan y
jika diberi harga x = 0 dan y = 0 maka f(x,y) akan menghasilkan -1
jika diberi harga x = 1 dan y=0 maka f(x,y) akan menghasilkan 0
Notasi Algoritmik Untuk Fungsi
1. Pendefinisian/Spesifikasi fungsi
function NAMAF (<list-parameter input>) <type hasil>
{Spesifikasi fungsi: diberikan .. menghasilkan ..}
Kamus lokal:
{ semua NAMA yang dipakai dalam algoritma/realisasi fungsi}
Algoritma :
{deretan instruksi algoritmik :
pemberian harga, input, output, analisis kasus, pengulangan)
dengan syarat :
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 63 dr 217
- list parameter input boleh tidak ada (kosong), dalam hal ini di fungsi tidak
membutuhkan apa-apa dari pemakainya untuk menghasilkan harga.
- jika list parameter input (parameter formal) tidak kosong, minimal
mengandung satu nama, maka nama tersebut harus berupa nama informasi
beserta typenya.
- instruksi terakhir yang harus ada pada fungsi harus merupakan pengiriman
harga yang dihasilkan oleh fungsi (dituliskan seperti pada notasi di atas,
dengan type hasil boleh type dasar atau type terstruktur). Type hasil boleh
dinyatakan oleh suatu nama type. Dengan catatan, bahwa instruksi terakhir
belum tentu dituliskan pada baris terakhir, misalnya jika hasil merupakan
sebuah nilai yang dikirimkan berdasarkan analisis kasus.
2. Pemanggilan Fungsi
Program POKOKPERSOALAN
{Spesifikasi : Input, Proses, Output}
Kamus :
{ semua NAMA yang dipakai dalam algoritma }
function NAMAF (<list nama parameter formal/input>) <type
hasil>
{Spesifikasi fungsi}
Algoritma :
{ deretan instruksi pemberian harga, input, output, analisis kasus,
pengulangan yg memakai fungsi }
{ Harga yang dihasilkan fungsi juga dapat dipakai dalam ekspresi )
nama NAMAF (<list parameter aktual>)
output(NAMAF (<list parameter aktual>))
{ Harga yang dihasilkan fungsi juga dapat dipakai dalam ekspresi )
Catatan :
1. Pada waktu pemanggilan terjadilah asosiasi antara parameter formal/input dengan
parameter aktual sesuai dengan urutan penulisan dalam list-nama parameter input.
2. List parameter input dapat berupa nama informasi atau nama konstanta yang telah
terdefinisi dalam kamus atau konstanta; dapat juga berupa harga konstanta, atau
harga yang dihasilkan oleh suatu ekspresi atau fungsi.
3. List parameter aktual harus sama jumlah, urutan dan typenya dengan list parameter
formal pada pendefinisian fungsinya.
4. Harga yang dihasilkan oleh fungsi dapat didefinisikan domainnya dengan lebih
rinci.
5. Pada akhir dari eksekusi fungsi, harga yang dihasilkan oleh fungsi dikirimkan ke
pemakainya.
6. Fungsi boleh dipakai oleh program utama, prosedur atau fungsi lain.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 64 dr 217
Fungsi Terdefinisi:
adalah fungsi yang sudah diberikan oleh sistem, dan tinggal dipakai (dipanggil).
Fungsi terdefinisi selalu diberikan daftar dan spesifikasinya (domain + range).
Fungsi terdefinisi untuk melakukan konversi tipe.
Seringkali, dibutuhkan konversi dari bilangan riil menjadi integer atau sebaliknya.
Maka didefinisikan duabuah fungsi konversi bilangan numerik sebagai berikut:
function RealToInteger (x:real) integer
{ mengkonversi harga x yang bertype real menjadi harga lain yang
betype integer dengan pemotongan, yaitu menghilangkan bagian di
belakang titik desimalnya}
function IntToReal (i:integer) real
{ mengkonversi harga i yang bertype integer menjadi harga ekivalen
yang betype real }
pertama}
character
function LASTCHAR
(S: string, tidak kosong)
{ Menghasilkan Karakter terakhir string S}
character
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 65 dr 217
Fungsi matematik
function Sin
(x: real) real
{Menghasilkan sinus(x), x dalam radian}
function Cos
(x: real) real
{Menghasilkan cosinus(x), x dalam radian}
function Abs
{Menghasilkan
(x: integer)
|x|}
integer
Pendefinisian Fungsi
function FX_KUADRAT (x:integer) integer
{Diberikan x, integer, menghitung f(x) = x2 + 3x - 5 }
Kamus lokal :
Algoritma :
(x * x + 3 * x - 5)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 66 dr 217
Pemanggilan Fungsi
Program CONTOHF1
{ dibaca x dan y, menghitung :
}
2
{ f(x,y) = x + 3xy - 5y 1; f(x) = x2 + 3x - 5
{ dan menuliskan hasil perhitungan
Kamus :
x : integer
y : real
{ data }
{data }
f(x) = x2 + 3x - 5}
(x:integer) integer
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 67 dr 217
Contoh1-Fungsi : KONVERSI
Persoalan:
Tuliskanlah sebuah fungsi, yang mengkonversikan harga karakter angka (nol sampai
dengan 9) menjadi harga numerik sesuai dengan karakter yang tertulis.
Contoh :
'0' 0
'8' 8
Spesifikasi :
Fungsi KarakterToInteger :
Domain : x :character ['0'..'9'] )
Range : integer [0..9]
Proses : analisis kasus terhadap x, untuk setiap harga x diasosiasikan integer yang
sesuai.
function KarakterToInteger (x:character ['0'..'9']) integer [0..9]
{diberikan x berupa karakter, menghasilkan harga integer yang sesuai
dengan penulisan pada karakter }
Kamus lokal :
Algoritma :
depend
x =
x =
x =
x =
x =
x =
x =
x =
x =
x =
on
'0'
'1'
'2'
'3'
'4'
'5'
'6'
'7'
'8'
'9'
(x)
: 0
: 1
: 2
: 3
: 4
: 5
: 6
: 7
: 8
: 9
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 68 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 69 dr 217
{ meter}
{ sisa cm}
Algoritma :
meter Cm div 100
sisaCm Cm mod 100
<meter, sisaCm>
Catatan:
1. Terjemahan teks fungsi pada contoh ini ke dalam beberapa bahasa pemrograman
tidak sederhana, bahkan tidak mungkin dapat dilakukan secara langsung.
2. Cobalah menterjemahkan funsgi di atas ke dalam bahasa Pascal, C dan Ada. Akan
terlihat perbedaan yang sangat besar di antara ketiganya.
Contoh4-Fungsi : UbahdanPeriksaKar
Persoalan :
Tuliskanlah algoritma yang membaca sebuah karakter dan mengubahnya menjadi
integer yang sesuai dengan karakter itu jika karakter yang dibaca adalah antara '0' dan
'9' dengan memanfaatkan funsgi KarakterToInteger yang pernah dibuat. . Jika bukan
di dalam daerah harga nol dan sembilan, maka harus dituliskan pesan yang berbunyi :
'Bukan angka' .
Spesifikasi
Input : CC karakter
Output : menuliskan integer [0..9] sesuai dengan karakter yang dibaca, jika karakter
['0'..'9'], atau Bukan angka jika CC bukan angka
Proses :
Konversi dari karakter ke integer, jika CC ['0'..'9']
Dengan catatan fungsi konversi adalah seperti terdefinisi pada contoh1
Catatan :
1. Test yang dilakukan sebelum pemanggilan fungsi KarakterToInteger membuat
fungsi KarakterToInteger cukup mengembalikan nilai yang terdefinisi. Jika
domain dari nilai masukan fungsi tidak hanya mencakup karakter angka, maka di
dalam fungsi harus didefinisikan suatu nilai yang diluar definisi angka.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 70 dr 217
Program UbahdanPeriksaKar
{Program membaca sebuah karakter, dan melakukan konversi ke nilai
integer serta menuliskannya, jika karakter mewakili angka, bernilai
['0'..'9'. Pogram menulis bukan angka, jika yang diketik bukan
bernilai ['0'..'9']}
Kamus
CC : character
{data, karakter yang dibaca}
Function KarakterToInteger (x : character ['0'..'9']) integer
[0..9]
{Diberikan x berupa karakter '0'..'9', menghasilkan harga integer
yang sesuai dengan penulisan pada karakter }
Algoritma :
input (cc)
depend on
CC
(CC)
['0'..'9']: output (KarakterToInteger (CC))
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 71 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 72 dr 217
Catatan :
1. Bagi yang sudah mengikuti kuliah Pemrograman Fungsional, dapat dilihat bahwa
teks program di atas sangat selaras dengan ekspresi fungsional yang pernah
dipelajari.
2. Pemanggilan fungsi pada konteks prosedural adalah aplikasi fungsi pada konteks
fungsional.
NEXTDAY(HariIni)
depend on KodeBahasa
KodeBahasa = 1 : output Esok.MM,'/', Esok.DD,'/',Esok.YY)
KodeBahasa = 2 : output (Esok.DD,'-',Esok.MM,'-',Esok.YY)
KodeBahasa = 3 : output (Esok.DD,'/',Esok.MM,'/',Esok.YY)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 73 dr 217
< 28 : <Now.DD+1,Now.MM,Now.YY>
Now.DD = 28 :
depend on Now.YY :
not Kabisat(Now.YY) : <1,Now.MM+1,Now.YY>
Kabisat(Now.YY): <Now.D+1,Now.MM,Now.YY>
Now.DD = 29 : <1,Now.MM+1,Now.YY>
Now.MM = 12 : { Mungkin Pergantian tahun}
depend on Now.DD :
Now.DD
< 31 : <Now.DD+1,Now.MM,Now.YY>
Now.DD
= 31 : <1,1,Now.YY + 1>
< 31 : <Now.DD+1,Now.MM,Now.YY>
Now.DD
= 31 : <1,Now.MM+1,Now.YY>
< 30 : <Now.DD+1,Now.MM,Now.YY>
Now.DD
= 30 : <1,Now.MM+1,Now.YY>
RANGE
type dasar
type bentukan
type dasar
type bentukan
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 74 dr 217
3,3
0,0
2,0
-3,2
5. Pecahan
1. Definisikan sebuah type pecahan yang terdiri dari pembilang dan penyebut
bilangan integer, dan sekumpulan fungsi yang merupakan realisasi dari
operator pecahan :
a. JumlahP : menerima dua buah pecahan, menghasilkan jumlah berupa
pecahan
b. KurangP : menerima dua buah pecahan, menghasilkan selisih berupa
pecahan
c. KaliP : menerima dua buah pecahan, menghasilkan hasil kali berupa
pecahan
d. BagiP : menerima dua buah pecahan, menghasilkan hasil bagi berupa
pecahan
2. Buat soal di atas jika pecahan terdiri dari bilangan bulat, pembilang dan
penyebut, dengan syarat bahwa pembilang harus lebih kecil dari penyebut
3. Bagi yang sudah mengikuti kuliah pemrograman fungsional dengan
menggunakan Diktat Pemrograman Fungsional oleh penulis yang sama, lihat
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 75 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 76 dr 217
PROSEDUR
Definisi
Prosedur adalah sederetan instruksi algoritmik yang diberi nama, dan akan
menghasilkan efek neto yang terdefinisi. Prosedur menyatakan suatu aksi dalam
konsep algoritma yang dibicarakan pada cerita Mengupas kentang.
Mendefinisikan (membuat spesifikasi) prosedur berarti menentukan nama prosedur
serta parameternya (jika ada), dan mendefinisikan keadaan awal (Initial State, I.S.)
dan keadaan akhir (Final State, F.S.) dari prosedur tersebut. Prosedur didefinisikan
(dituliskan spesifikasinya) dalam kamus. Cara penulisan spesifikasi : prosedur diberi
nama, dan parameter formal (jika ada) yang juga diberi nama dan dijelaskan
typenya.
Secara sederhana, dapat diartikan bahwa sebuah prosedur yang terdefinisi disimpan
di tempat lain, dan ketika dipanggil dengan menyebutkan namanya seakan-akan
teks yang tersimpan di tempat lain itu menggantikan teks pemanggilan. Pada saat itu
terjadi asosiasi parameter (jika ada). Dengan konsep ini, maka I.S dan F.S dari
prosedurlah yang menjamin bahwa eksekusi program akan menghasilkan efek neto
yang diharapkan.
Jadi, setiap prosedur harus :
- didefinisikan (dibuat spesifikasinya) dan dituliskan kode programnya
- dipanggil, pada saat eksekusi oleh prosedur lain atau oleh program utama.
Parameter Prosedur
Prosedur tanpa parameter memanfaatkan nilai dari nama-nama yang terdefinisi
pada kamus global. Pemakaiannya biasanya harus hati-hati, apalagi jika teks
program sudah sangat besar dan implementasinya menjadi banyak file.
Prosedur berparameter dirancang, agar sepotong kode yang sama ketika eksekusi
dilakukan, dapat dipakai untuk nama parameter yang bebeda-beda.
Nama parameter yang dituliskan pada definisi/spesifikasi prosedur disebut sebagai
parameter formal. Sedangkan parameter yang dituliskan pada pemanggilan prosedur
disebut sebagai parameter aktual.
Parameter formal adalah nama-nama variabel (list nama) yang dipakai dalam
mendefinisikan prosedur, dan membuat prosedur tersebut dapat dieksekusi dengan
nama-nama yang berbeda ketika dipanggil. Parameter formal adalah list nama yang
akan dipakai pada prosedur, yang nantinya akan diasosiasikan terhadap nama
variabel lain pada saat pemanggilan. Sesuai dengan ketentuan nilainya, ada tiga type
parameter formal:
- parameter Input, yaitu parameter yang diperlukan prosedur sebagai masukan
untuk melakukan aksi yang efektif.
- parameter Output, yaitu parameter yang nilainya akan dihasilkan oleh
prosedur. Hasil nilai akan disimpan pada nama parameter Output ini.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 77 dr 217
Pemanggilan Prosedur
Memakai, atau "memanggil" prosedur adalah menuliskan nama prosedur yang pernah
didefinisikan, dan memberikan harga-harga yang dibutuhkan oleh prosedur itu untuk
dapat melaksanakan suatu aksi terdefinisi. Sebuah prosedur juga boleh "memakai"
atau memanggil prosedur. Pada saat pemanggilan terjadi passing parameter.
Parameter aktual adalah nama-nama informasi yang dipakai ketika prosedur itu
dipakai ("dipanggil"). Parameter aktual dapat berupa nama atau harga, tetapi harus
berupa nama jika parameter tersebut adalah parameter Output (karena hasilnya akan
disimpan dalam nama tersebut). Sesuai dengan jenis parameter formal, parameter
aktual pada saat pemanggilan :
- parameter input harus terdefinisi nilainya (karena dibutuhkan oleh prosedur untuk
menghasilkan nilai). Karena yang dibutuhkan untuk eksekusi hanya nilai, maka
parameter input dapat digantikan dengan suatu nilai tanpa menggunakan nama.
- parameter output tidak perlu terdefinisi nilainya, tetapi justru setelah pemanggilan
prosedur akan dimanfaatkan oleh deretan instruksi berikutnya, karena nilainya
akan dihasilkan oleh prosedur. Karena parameter output menampung hasil, maka
harus berupa nama, dan tidak boleh diberikan nilai saja.
- parameter input/output harus terdefinisi nilainya dan nilai baru yang diperoleh
karena eksekusi prosedur akan dimanfaatkan oleh deretan instruksi berikutnya.
Seperti halnya parameter output, maka paramteter aktual harus berupa nama.
Pada saat eksekusi, terjadi asosiasi nama parameter formal dengan nama parameter
aktual. Pada notasi algoritmik, asosiasi dilakukan dengan cara by position. urutan
nama pada parameter aktual akan diasosiasikan sesuai dengan urutan parameter
formal. Karena itu, type harus kompatibel.
Beberapa bahasa pemrograman, dapat dilakukan asosiasi dengan nama dan
memperbolehkan adanya nilai default. Beberapa bahasa pemrograman (Ada, C) juga
memperbolehkan nama prosedur yang sama tetapi parameternya berbeda
(overloading).
Prosedur dapat mempunyai kamus lokal, yaitu pendefinisan nama yang dipakai dan
hanya berlaku dalam ruang lingkup prosedur tersebut. Jika nama yang dipakai di
dalam prosedur tidak terdefinisi dalam list parameter formal atau dalam kamus lokal,
maka nama tersebut harus sudah terdefinisi pada prosedur yang memakainya.
Penulisan kamus lokal sama dengan kamus global, yang berbeda adalah lingkup
berlakunya nama yang didefinisikan:
- pada kamus "global", nama berlaku untuk program dan semua prosedur/fungsi
yang didefinisikan.
- pada kamus lokal, nama berlaku untuk prosedur/fungsi yang bersangkutan dan
prosedur / fungsi yang didefinisikan di dalamnya.
- nilai yang disimpan dalam nama yang didefinisikan pada kamus lokal, hanya
akan terdefinisi selama eksekusi prosedur, dan tidak dikenal lagi oleh
pemanggilnya.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 78 dr 217
Program yang moduler adalah program yang dibagi-bagi menjadi modul-modul yang
terdefinisi dengan baik dalam bentuk prosedur-prosedur. Setiap prosedur harus jelas
definisi dan ruang lingkupnya, supaya
dapat dipanggil secara independent.
Pembagian program besar dalam prosedur-prosedur akan mempermudah pembagian
kerja di antara beberapa pemrogram. Penulisan prosedur juga akan memudahkan
program untuk dibaca oleh "manusia" karena kita tidak perlu terpaku pada detil kode
prosedur untuk mengerti efek neto yang dihasilkannya. Bahkan dalam beberapa hal,
pemrogram tidak perlu tahu sama sekali "isi" atau kode dari prosedur dengan
mengetahui spesifikasinya, beberapa bahasa pemrograman bahkan menyediakan
prosedur terdefinisi yang sering dipakai dalam memrogram sehingga pemrogram
tidak perlu lagi menuliskan kodenya.
Prosedur berlaku untuk ruang lingkup (universe) tertentu, terutama untuk prosedur
yang tidak mempunyai parameter. Dalam dua bab berikut, yaitu Mesin Gambar dan
Mesin Karakter, akan diberikan gambaran lebih jelas dan lengkap tentang
pendefinisian dan pemakaian prosedur karena keduanya adalah mesin abstrak yang
tertentu.
Notasi Algoritmik Untuk Prosedur
Pada bagian ini diberikan skema pendefinisian dan pemanggilan prosedur.
Pendefinisian/Spesifikasi Prosedur
procedure NAMAPROSEDUR ( [list nama parameter formal: type])
{Spesifikasi , Initial State, Final State}
Kamus lokal:
{ semua NAMA yang dipakai dalam BADAN PROSEDUR}
Algoritma :
{ BADAN PROSEDUR }
{deretan instruksi pemberian harga, input, output, analisis kasus,
pengulangan atau prosedur)
dengan syarat :
- nama prosedur dan prameternya harus disebutkan dalam kamus pemanggil.
- list parameter formal boleh tidak ada (kosong), dalam hal ini di dalam prosedur
akan dipakai nama lokal dan nama-nama yang telah terdefinisi dalam kamus
"pemakai"nya.
- jika list parameter formal ada (tidak kosong, minimal satu nama), maka harus
berupa satu atau beberapa nama INFORMASI beserta typenya.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 79 dr 217
Pemanggilan Prosedur
Program POKOKPERSOALAN
{Spesifikasi , Input, Proses, Output}
Kamus :
{ semua NAMA yang dipakai dalam algoritma }
procedure NAMAPROSEDUR (Input/Output : <list-nama parameter formal>)
{Spesifikasi : Initial State, Final State}
Algoritma :
{Deretan instruksi assignment/pemberian harga, input, output, analisis
kasus, pengulangan )
NAMAPROSEDUR
dengan syarat :
- pada waktu pemanggilan terjadilah asosiasi antara parameter formal dengan
parameter aktual sesuai dengan urutan penulisan dalam list-nama parameter
formal.
- list parameter aktual harus sama jumlah, urutan dan typenya dengan list
parameter formal.
- list parameter aktual yang berupa Input dapat berupa nama informasi atau
nama konstanta/ekspresi yang telah terdefinisi dalam kamus atau konstanta;
dapat juga berupa harga konstanta, atau harga yang dihasilkan oleh suatu
ekspresi atau fungsi.
- list parameter aktual yang berupa Input/Output atau Output harus berupa
nama informasi. Jika didefinisikan sebagai Input, walaupun pernah diubah
dalam badan prosedur, isi dari nama yang dipakai pada parameter aktual tidak
pernah berubah. Jika didefinisikan sebagai parameter Output dan parameter
aktual yang diasosiasikan terhadapnya pernah diubah harganya dalam badan
prosedur, isinya akan berubah.
Contoh
Contoh 1-Prosedur: VOLTAGE
Tuliskanlah program yang membaca tahanan (Ohm) dan arus (Ampere), kemudian
menghitung tegangan yang dihasilkan dan menuliskan hasilnya. Perhitungan tegangan
harus dituliskan menjadi suatu prosedur bernama PROSES, supaya struktur program
jelas : Input - Proses - Output.
Input : R : integer, tahanan (Ohm) dan A : integer, arus (Ampere)
Proses : menghitung V= R * A
Output :
V : integer, tegangan (Volt)
Pelajarilah dua buah solusi yang diberikan berikut ini, dan berikan komentar anda.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 80 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 81 dr 217
Catatan :
1. Prosedur dengan parameter lebih menjamin modularitas program. Sedapat
mungkin semua prosedur diparametrisasi dengan baik.
2. Prosedur tanpa parameter bekerja dengan nama global. Hanya boleh dipakai untuk
kasus yang sangat khusus, yaitu jika nama global merupakan universe (dunia,
lingkungan) dari program, misalnya pada contoh mesin abstrak.
3. Prosedur tanpa parameter tidak boleh dipakai jika alasannya hanya karena
pemrogram malas menuliskan parameter .
Contoh 2-Prosedur: TUKAR
Prosedur untuk menukar dua harga yang disimpan dalam dua nama a dan b
I.S. : diberikan a=A dan b=B
F.S. : a=B dan b=A
Program TUKAR
{Program yang membaca dua buah harga x dan y, menuliskan,
menyimpannya, kemudian menukarnya, dan menuliskan nilai setelah
pertukaran}
Kamus :
x,y : integer
procedure PROCTUKAR (Input/Output : a,b : integer)
{ Prosedur untuk menukar dua buah harga yang tersimpan dalam dua
nama integer}
{ I.S : diberikan a=A dan b=B, }
{ F.S : a=B dan b=A}
Algoritma :
input ( x.,y)
PROCTUKAR ( x,y)
output (x,y)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 82 dr 217
Contoh3-Prosedur : PUTAR3BIL
Contoh pemanfaatn prosedur yang pernah dipakai
Gunakan prosedur TUKAR untuk menulis prosedur yang "memutar" 3 buah nama
integer
Contoh : jika a berisi 1, b berisi 2 dan c berisi 3, maka hasilnya :
a berisi 3, b berisi 1 dan c berisi 2.
procedure PUTAR3BIL (Input/Output
{ I.S : a=A dan b=B, dan c=C}
{ F.S : a=C, b=A, c=B }
Kamus lokal :
a,b,c
: integer)
Algoritma :
{ I.S. a= A, b=B, c=C}
PROCTUKAR (a,c)
{a = C; b= B, c=A }
PROCTUKAR (b,c)
{a = C; b= A, c=B }
Contoh di atas adalah contoh sebuah prosedur yang memakai sebuah prosedur lain.
Catatan:
Contoh-contoh di atas tidak terlalu mewakili daya guna penulisan prosedur dengan
nyata, pada bagian-bagian berikutnya akan terlihat lebih nyata manfaat penulisan
prosedur, yang membuat :
- program mudah dibaca
- prosedur yang sama dipakai berkali-kali sehingga mengurangi penulisan yang
berulang
- pengkodean yang independen
Latihan Soal
1. Kerjakanlah kembali soal-soal pada bagian sebelumnya, dengan mendefinisikan
prosedur, jika memang sesuai.
2. Apa beda prosedur dan fungsi ?
3. Pada bahasa C, hanya ada "fungsi". Prosedur direalisasi dengan menuliskannya
sebagai fungsi yang tidak menghasilkan harga. Apa pendapat Anda ?
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 83 dr 217
PENGULANGAN
Salah satu kemampuan komputer yang dapat dimanfaatkan adalah mengulang suatu
instruksi, bahkan aksi, secara berulang-ulang dengan peformansi yang sama. Berbeda
dengan manusia yang cenderung melakukan kesalahan jika melakukan hal yang sama
(karena lelah atau bosan), komputer akan melakukan pengulangan dengan setia sesuai
dengan perintah yang diberikan.
Pengulangan terdiri dari dua bagian :
- kondisi yang mengakibatkan pengulangan suatu saat berhenti, yang dinyatakan
oleh sebuah ekspresi logik baik secara eksplisit maupun implisit
- badan pengulangan, yaitu aksi yang harus diulang selama kondisi yang ditentukan
untuk pengulangan masih dipenuhi
Pengulangan harus berhenti, ini yang harus dijamin oleh pemrogram. Pada bab
tentang "mengupas kentang"m telah diberikan suatu contoh di mana pengulangan
mungkin dilakukan terus menerus dan salah satu karena sifat algoritma yang harus
dipenuhi adalah terjadi dalam selang waktu terbatas maka pengulangan yang terus
menerus (looping) adalah algoritma yang salah.
Pengulangan yang terus menerus harus dapat dideteksi pemrogram bahkan sebelum
program dieksekusi oleh mesin, berdasarkan invariansi dari badan pengulangan
tersebut.
Notasi pengulangan adalah salah satu notasi dasar dalam penulisan algoritma selain
analisis kasus. Namun notasi tersebut hanya akan ada artinya jika dikenakan terhadap
skema tertentu. Notasi pengulangan yang berdiri sendiri tidak ada artinya, bahkan
menyesatkan karena pada hakekatnya notasi pengulangan hanyalah merupakan
sebagian dari skema pengulangan yang akan dibahas pada bab-bab berikutnya.
Ada lima macam notasi pengulangan:
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 84 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 85 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 86 dr 217
Contoh :
Jika N = 3 maka outputnya adalah
1
2
3
Program TULISBIL1
{Dibaca N 0, Menuliskan 1,2,3... N berderet ke bawah, dengan
bentuk repeat..N times }
Kamus:
i : integer {bilangan yang akan ditulis }
Algoritma :
input (N)
i 1
repeat N times
Output (i)
i i + 1
Catatan :
1. Sebenarnya untuk persoalan ini, bentuk pengulangan repeat N times kurang
sesuai. Pemakaian yang sesuai misalnya jika harus menggambar segi empat, maka
kita harus menggambarkan 4 sisi. Penggambaran setiap sisi inilah yang diulang 4
kali.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 87 dr 217
Program TULISBIL2
{Dibaca N 0, Menuliskan 1,2,3... N berderet ke bawah, dengan
bentuk repeat..until.... }
Kamus:
i : integer {bilangan yang akan ditulis }
Algoritma :
input (N)
i 1
repeat
Output (i)
i i + 1
until (i>N)
Penjelasan :
1. Dengan bentuk ini, harus dijamin bahwa nilai N yang dibaca sesuai dengan
spesifikasi, yaitu N 0. Jika nilai yang diberikan tidak sesuai dengan spesifikasi,
maka akan tertulis angka 1. Untuk mengatasi hal ini dapat dilakukan misalnya
bahwa nilai N yang dibaca diulang sehingga memenuhi persyaratan N 0.
2. Nama yang didefinisikan sebagai i akan bernilai 1..N+1.
3. Anda dapat mendefinisikan i sebagai bilangan yang sudah ditulis dan memulai i
dengan 0. Dalam hal ini nilai i adalah 0..N
Program TULISBIL3
{Dibaca N 0, Menuliskan 1,2,3... N berderet ke bawah, dengan
bentuk while... do....... }
Kamus:
i : integer {bilangan yang akan ditulis }
Algoritma :
input (N)
i 1
while i N do
Output (i)
i i + 1
{ i > N )
Penjelasan :
1. Dengan bentuk ini, nilai 1 belum tentu ditulis. Jika ternyata pengguna
memberikan nilai N yang negatif, program tidak menuliskan apa-apa karena
kondisi yang diperiksa pertama kali (i N) menghasilkan false.
2. Nama yang didefinisikan sebagai i akan bernilai 1..N+1.
3. Anda dapat mendefinisikan i sebagai bilangan yang sudah ditulis dan memulai i
dengan 0. Dalam hal ini domain nilai i adalah 0..N
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 88 dr 217
Program TULISBIL4
{Dibaca N 0, Menuliskan 1,2,3... N berderet ke bawah, dengan
bentuk iterate }
Kamus:
i : integer
Algoritma :
input (N)
i 1
iterate
Output (i)
stop (i = N)
i
i + 1
{ i = N}
Penjelasan :
1. Dengan bentuk ini, nilai 1 pasti ditulis. Jika ternyata pengguna memberikan nilai
N yang negatif, program akan menuliskan 1 kemudian berhenti
2. Nama yang didefinisikan sebagai i akan bernilai 1..N , jika N positif
3. Anda dapat mendefinisikan i sebagai bilangan yang sudah ditulis dan memulai i
dengan 0. Dalam hal ini aksi di antara iterate... stop adalah penambahan nilai i,
sedangkan aksi sesudah kata stop adalah aksi penulisan.
Program TULISBIL5
{Dibaca N 0, Menuliskan 1,2,3... N berderet ke bawah, dengan
bentuk iterate }
Kamus:
i : integer
Algoritma :
input (N)
i traversal [1..N]
Output (i)
Penjelasan :
1. Bentuk ini ekivalen dengan bentuk iterate, untuk i [1..N], namun pertambahan
nilai i ditangani secara implisit oleh pemroses bahasa.
2. Jika N yang diberikan oleh pengguna bernilai negatif, maka tidak terjadi aksi
penulisan karena nilai i di luar domain [1..N]
Penutup
Ada bermacam-macam pengulangan, sebenarnya satu bentuk pengulangan dapat
"diterjemahkan" menjadi bentuk yang lain dengan notasi algoritmik yang tersedia.
Contohnya untuk persoalan menuliskan nilai 1...N di atas.
Instruksi pengulangan tidak dapat berdiri sendiri, melainkan harus disertai dengan
instruksi-instruksi lain sebelum dan sesudah pengulangan.
Persoalannya adalah memilih bentuk pengulangan yang benar dan tepat untuk
kelas persoalan tertentu. Pada kuliah algoritma dan pemrograman ini, pemilihan
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 89 dr 217
bentuk pengulangan yang tepat merupakan salah satu objektif dari pelajaran dan
merupakan inti dari "desain" algoritmik.
Tidak semua bahasa pemrograman yang ada menyediakan semua bentuk pengulangan
di atas. Hal ini dapat dianalogikan dengan satu set pisau dapur yang terdiri dari
puluhan macam pisau misalnya untuk memotong daging, sayur, buah. bahkan ada
yang dirancang dengan sangat khusus untuk buah tertentu (grape fruit) karena
mempermudah operasi pemotongan atau pengupasan yang dilakukan. Namun dalam
keadaan darurat, ketika tidak semua pisau tersedia kita dapat memakai misalnya pisau
sayur untuk memotong daging walaupun tidak semudah menggunakan pisau daging.
Hal yang sama terjadi dengan pemilihan bentuk pengulangan jika bahasa
pemrograman yang dipakai tidak menyediakan. Sebaiknya dalam hal ini yang
dilakukan adalah memilih bentuk pengulangan yang tepat dan menterjemahkannya
dalam instruksi yang tersedia pada bahasa eksekusi. Ini merupakan terjemahan desain
algoritmik menjadi kode program.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 90 dr 217
Definisi
Pemrosesan sekuensial adalah pemrosesan secara satu-persatu, dari sekumpulan
informasi sejenis yang setiap elemennya dapat diakses dengan keterurutan tertentu
(ada suksesor), jadi seakan-akan kumpulan elemen merupakan "Deret" elemen.
Elemen yang akan diproses dapat bertype dasar (integer, real, character, boolean),
tetapi dapat juga bertype komposisi (misalnya Point <x: real, y : real> ).
Deret Elemen dapat merupakan elemen yang dibaca satu per satu dari input device,
nilai elemen suatu tabel atau matriks, disimpan dalam media penyimpanan sekunder
(file), atau merupakan elemen list, dsb.
Kumpulan informasi itu disimpan sedemikian rupa, sehingga selalu dikenali melalui
primitif yang mampu untuk memberikan:
- Elemen pertama (First_Elmt)
- Elemen yang siap diproses (Current_Elmt)
- Elemen yang diakses setelah Current_Elmt (Next_Elmt)
- Tanda akhir proses EOP
Skema sekuensial ini dibangun untuk mendapatkan suatu pola umum, sebab instruksi
pengulangan seperti yang telah dibahas di bab sebelumnya hanya berfokus kepada
bentuk pengulangan, belum mencakup semua abstraksi yang dibutuhkan untuk suatu
proses sekuensial.
Spesifikasi Primitif
Primitif untuk skema sekuensial diterjemahkan menjadi prosedur dan nilai variabel
sebagai berikut
procedure First_Elmt
{Aksi yang memberikan elemen pertama yang akan diproses secara
sekuensial.
I.S. : sembarang
F.S : Current_Elmt berisi sebuah elemen yang akan diproses
}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 91 dr 217
procedure Next_Elmt
{ Aksi yang memberikan elemen berikutnya dari Current_Elmt sesuai
dengan aturan akses dari pengaturan deret elemen :
- untuk elemen yang disimpan dalam memori internal secara kontigu
(array), akses ke elemen berikutnya dapat dilakukan melalui
indeks: indeks dari next element adalah suksesor dari Currentelement.
- untuk elemen yang disimpan dalam media sekunder memori
eksternal, akses ke elemen berikutnya dilakukan lewat suatu aksi
yang tersedia (Contoh : mesin karakter)
- untuk elemen yang diatur sesuai dengan aturan lain, harus
ditentukan fungsi yang memungkinkan teraksesnya elemen yang
berikutnya.
Realisasi dari aksi ini tergantung dari bagaimana informasi itu
disimpan dalam memori :
I.S. : Current_Elmt
F.S : Current_Elmt = Next_Elmt (Current-Elmt)
}
EOP: boolean
{ Bernilai true jika proses sekuensial harus dihentikan. Dapat
diimplementasi sebagai fungsi element
Bagaimana EOP ini bernilai true ?
Ada dua macam model :
1. Model dengan MARK. Elemen terakhir adalah elemen "fiktif",
sebetulnya bukan anggota elemen yang diproses, informasinya lain
dari pada elemen yang diproses secara lumrah. Model dengan Mark
justru lebih banyak dipakai dalam pemrograman praktis.
2. Model tanpa MARK : elemen terakhir mengandung informasi yang
memberitahukan bahwa elemen tsb. adalah elemen yang terakhir
}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 92 dr 217
MHSNILAI yang dapat diakses secara sekuensial (tersimpan dalam tabel, atau dari
sebuah sequential file) , dan misalnya data yang tersimpan adalah :
<8689001,IF221, 'A'>, <8689002,IF221, 'A'>, <8689007,IF221, 'B'>,
<8690001,IF223, 'E'>, <8690001,IF222, 'C'>, <9999999,XXXXX, 'A'>,
Setiap elemen bertype MHSNILAI
First_Elmt akan mengakibatkan Current_Elmt = <8689001,'IF221', 'A'>
Next_Elmt akan mengakibatkan harga Current_Elmt yang baru
= <8689007,IF221, 'B'>
jika Current_Elmt = <8689002,IF221, 'A'>
EOP akan bernilai true untuk Current_Elmt = <9999999,XXXXX, 'A'>
Perhatikanlah bahwa elemen-elemen berkarakteristik seperti ini harus disimpan atau
dibaca satu per satu dari piranti masukan, sebab dari sebuah Current_Elmt, nilai
Next_Elmt nya tidak ada rumusnya.
Untuk semua teks algoritma yang merupakan skema pemrosesan sekuensial pada bab
ini, dipakai prosedur-prosedur dan fungsi terdefinisi seperti yang dituliskan pada
kamus sebagai berikut yang lebih ringkas daripada spesifikasi yang disertai catatan
pada awal bab ini:
Kamus:
procedure
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 93 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 94 dr 217
Skema :
Inisialisasi
repeat
Next_Elmt
Proses_Current-Elmt
until ( EOP )
Terminasi
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 95 dr 217
Versi-1
Program SUMNBil1
{Menjumlahkan 1+2+3+...N, dengan N yang dibaca }
{Model tanpa mark, tanpa penanganan kasus kosong}
Kamus:
i : integer
{ bilangan yang akan diproses }
N : integer >0
{ banyaknya bilangan yang dijumlahkan }
Sum : integer { jumlah}
Algoritma :
input (N); Sum 0
{ Inisialisasi }
i 1
{First_Elmt: mulai dari 1: akan diproses}
iterate
Output (i)
Sum Sum + i
stop( i=N ) {EOP}
i
i + 1
{Next_Elmt}
Output (Sum)
{Terminasi}
Penjelasan :
1. Pengontrol pengulangan adalah bilangan integer i
2. Analisis : pemrosesan sekuensial dari deret bilangan 1,2,3, ..N
Model tanpa MARK,
jika i adalah deret yang diproses, i adalah Current element, i bernilai 1,2,3..N
EOP adalah jika i=N; First_Elmt : 1; Next_Elmt : i +1
Proses : menulis setiap bilangan, dan pada akhir proses menulis jumlah
2. Program benar, dengan tambahan spesifikasi : N 1, sesuai dengan definisi
domain i = 1..N
3. Nilai i mentaati definisi domain 1..N
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 96 dr 217
Versi-2
Program SUMNBil2
{Menjumlahkan 1+2+3+...N, dengan N yang dibaca }
{Model dengan mark, tanpa penanganan kasus kosong}
Kamus:
i : integer
{bilangan yang akan dijumlahkan }
N : integer >0
{ banyaknya bilangan yang dijumlahkan }
Sum : integer { jumlah}
Algoritma :
input (N); Sum 0
{ Inisialisasi }
i 1
{First_Elmt}
while (i N) do
Output (i)
Sum Sum + i
i
i + 1
{Next_Elmt}
{ i > N, I = N+1, Sum = 1 + 2+ 3+ ...+N }
Output (Sum) {Terminasi}
Penjelasan :
1. Pengontrol pengulangan adalah bilangan integer i
2. Analisis : pemrosesan sekuensial dari deret bilangan 1,2,3, ..N
Model dengan MARK,
jika i adalah deret yang diproses, nilai i adalah Next element,
i bernilai 1,2,3..N
EOP adalah jika i > N, yaitu i = N+1
First_Elmt : 1;
Next_Elmt : i +1
Proses : menulis setiap bilangan, dan pada akhir proses menulis jumlah
3.Program benar, tanpa batasan nilai N. Jika N 0, terjadi kasus kosong
4. Nilai i menjadi di luar domain, jika didefinisikan 1 .. N
Versi-3
Program SUMNBil3
{Menjumlahkan 1+2+3+...N, dengan N yang dibaca }
{Model dengan mark, dengan penanganan kasus kosong}
Kamus:
i : integer
{bilangan yang akan dijumlahkan }
N : integer >0
{ banyaknya bilangan yang dijumlahkan }
Sum : integer { jumlah}
Algoritma :
input (N); SUM 0
{ Inisialisasi }
i 1
{First_Elmt}
repeat
Output (i)
Sum Sum + i
i
i + 1
{Next_Elmt}
until ( i > N)
{ i > N i = N+1, Sum = 1 + 2+ 3+ ...+N }
Output (Sum) {Terminasi}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 97 dr 217
Penjelasan :
1. Pengontrol pengulangan adalah bilangan integer i
2. Analisis : pemrosesan sekuensial dari deret bilangan 1,2,3, ..N
Model dengan MARK (???)
jika i adalah deret yang diproses, i adalah Next element, i bernilai 1,2,3..N
EOP adalah jika Ii= N + 1; First_Elmt : 1; Next_Elmt : i +1
Proses : menulis setiap bilangan, dan pada akhir proses menulis jumlah
2. Program benar, dengan tambahan spesifikasi : N 1, sesuai dengan definisi
domain i = 1..N
3. Nilai i di luar definisi domain 1..N
4. Pemilihan skema tidak konsisten (bukan skema penanganan dengan kasus
kosong!)
Versi-4
Program SUMNBil4
{Menjumlahkan 1+2+3+...N, dengan N yang dibaca }
{Model tanpa mark}
Kamus:
i : integer
{ bilangan yang akan dijumlahkan }
N : integer >0
{ banyaknya bilangan yang dijumlahkan }
Sum : integer { jumlah}
Algoritma :
input (N); SUM 0
{ Inisialisasi }
i traversal [1..N]
Output (i)
Sum Sum + i
{ i = ? , Sum = 1 + 2+ 3+ ...+N }
Output (Sum) {Terminasi}
Penjelasan :
1. Pengontrol pengulangan adalah bilangan integer i
2. Analisis : pemrosesan sekuensial dari deret bilangan 1,2,3, ..N
Model tanpa MARK
Jika i adalah nilai suku deret yang diproses, i adalah Current element, i bernilai
1,2,3..N
EOP adalah jika i = N ; First_Elmt : 1; Next_Elmt : i +1
Proses : menulis setiap bilangan, dan pada akhir proses menulis jumlah
2. Program benar, dengan tambahan spesifikasi : N 1, sesuai dengan definisi
domain i = 1..N
3. Nilai i sesuai definisi domain 1..N, namun setelah traversal tidak terdefinisi. Maka
tidak boleh menggunakan nilai i setelah traversal berakhir
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 98 dr 217
Algoritma :
SUM 0
{ Inisialisasi }
input (X)
{First_Elmt}
while (X 9999) do
Output (X)
Sum Sum + X
input (X)
{Next_Elmt}
{ Sum = X1 +
X2 +
....
s+
... Xi-1 . }
Output (Sum) {Terminasi}
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
2. Program ini memakai skema yang benar, tapi tidak menangani kasus kosong
3. Program tersebut benar untuk kasus kosong ataupun tidak kosong. Jika nilai yang
diketikkan langsung 9999 (kasus kosong), mark tidak diproses.
4. Program tidak salah jika tidak pernah terjadi kasus kosong (nilai yang diketikkan
minimal dilakukan satu kali)
5. Konklusi : program tersebut benar, dengan tambahan spesifikasi bahwa : jumlah
bilangan untuk kasus kosong = 0
6. Konklusi : Skema yang dipilih cukup baik
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 99 dr 217
CACAH BILANGAN:
Tuliskanlah sebuah program yang membaca nilai-nilai integer yang dibaca dari
piranti masukan, dan mencacah banyaknya nilai integer yang diketikkan.
Pemasukan nilai integer diakhiri dengan 9999.
Berikut ini adalah beberapa program solusinya, dengan penjelasannya.
Program CACAHBilX1
{Mencacah (melakukan counting)
9999 }
{Model dengan mark}
Kamus:
i : integer
X : integer
Algoritma :
i 0
{ Inisialisasi }
input (X)
{First_Elmt}
while (X 9999) do
Output (X)
i i + 1
input (X)
{Next_Elmt}
{ X= 9999 , i adalah banyaknya bilangan yang sudah dibaca }
Output (i)
{Terminasi}
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X yang dibaca.
2. Program ini memakai skema yang benar, tapi tidak menangani kasus kosong
3. Program tersebut benar untuk kasus kosong ataupun tidak kosong. Jika nilai yang
diketikkan langsung 9999 (kasus kosong), mark tidak diproses.
4. Program tidak salah jika tidak pernah terjadi kasus kosong (nilai yang diketikkan
minimal dilakukan satu kali)
5. Hasil pencetakan i benar, inisialisasi sesuai dengan definisi.
6. Konklusi : program tersebut benar, dengan tambahan spesifikasi bahwa :
banyaknya bilangan yang diketikkan adalah 0 untuk kasus kosong
7. Konklusi : Skema yang dipilih baik, definisi i tepat
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 100 dr 217
Program CACAHBilX2
{Mencacah (melakukan counting)
9999 }
{Model dengan mark}
Kamus:
i : integer
X : integer
Algoritma :
i 1
{ Inisialisasi }
input (X)
{First_Elmt}
while (X 9999) do
Output (X)
i i + 1
input (X)
{Next_Elmt}
{ X= 9999, i adalah banyaknya bilangan yang AKAN dibaca }
Output (i-1) {Terminasi}
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
2. Program ini memakai skema yang benar, tapi tidak menangani kasus kosong
3. Program tersebut benar untuk kasus kosong ataupun tidak kosong. Jika nilai yang
diketikkan langsung 9999 (kasus kosong), mark tidak diproses.
4. Program tidak salah jika tidak pernah terjadi kasus kosong (nilai yang diketikkan
minimal dilakukan satu kali)
5. Hasil pencetakan i benar, inisialisasi sesuai dengan definisi. Namun tidak natural
karena pada inisialisasi, bilangan yang akan dibaca adalah 1
6. Konklusi : program tersebut benar, dengan tambahan spesifikasi bahwa :
banyaknya bilangan yang diketikkan adalah 0 untuk kasus kosong
7. Konklusi : Skema yang dipilih baik, tapi definisi i kurang tepat
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 101 dr 217
Program CACAHBilX3
{Mencacah (melakukan counting)
9999 }
{Model dengan mark}
Kamus:
i : integer
X : integer
Algoritma :
i 1
{ Inisialisasi }
input (X)
{First_Elmt}
while (X 9999) do
Output (X)
input (X)
{Next_Elmt}
i i + 1
{ X= 9999, i adalah banyaknya bilangan yang AKAN dibaca }
Output (i-1) {Terminasi}
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
2. Program ini memakai skema yang benar, tapi tidak menangani kasus kosong
3. Program tersebut benar untuk kasus kosong ataupun tidak kosong. Jika nilai yang
diketikkan langsung 9999 (kasus kosong), mark tidak diproses.
4. Program tidak salah jika tidak pernah terjadi kasus kosong (nilai yang diketikkan
minimal dilakukan satu kali)
5. Hasil pencetakan i benar, inisialisasi sesuai dengan definisi. Namun tidak natural
karena pada inisialisasi, bilangan yang akan dibaca adalah 1
6. Konklusi : program tersebut benar, dengan tambahan spesifikasi bahwa :
banyaknya bilangan yang diketikkan adalah 0 untuk kasus kosong
7. Konklusi : Skema yang dipilih baik, tapi definisi i kurang tepat dan
penambahan nilainya tidak pada skema yang benar (sesudah Next-Element)
Latihan soal :
- Coba implementasikan skema di atas dengan repeat dan iterate, berikan komentar.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 102 dr 217
nilai-nilai X yang
integer
{banyaknya nilai integer yang akan dibaca }
integer{sekumpulan bilangan integer yang dibaca, diakhiri dg 9999}
integer >0
{ banyaknya bilangan yang dijumlahkan }
: integer { jumlah}
Algoritma :
i 1; SUM 0
{ Inisialisasi }
input (X)
{First_Elmt}
while (X
9999) do
Output (X)
Sum Sum + X
i
i + 1
input (X)
{Next_Elmt}
{ i = bilangan ke... yang akan di baca,
Sum = X1 +
X2 +
....
+
... Xi-1 . }
Output (Jumlah : , Sum)
{Terminasi}
Output (Banyaknya bilangan : , i - 1)
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
2. Program ini memakai skema yang benar, tapi tidak menangani kasus kosong
3. Program tersebut benar untuk kasus kosong ataupun tidak kosong. Jika nilai yang
diketikkan langsung 9999 (kasus kosong), mark tidak diproses.
4. Program tidak salah jika tidak pernah terjadi kasus kosong (nilai yang diketikkan
minimal dilakukan satu kali)
5. Hasil pencetakan i benar, inisialisasi sesuai dengan definisi. Namun tidak natural
karena pada inisialisasi, bilangan yang akan dibaca adalah 1
6. Konklusi : program tersebut benar, dengan tambahan spesifikasi bahwa :
- banyaknya bilangan yang diketikkan adalah 0 untuk kasus kosong
- jumlah bilangan untuk kasus kosong = 0
7. Konklusi : Skema yang dipilih baik, tapi definisi i kurang tepat
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 103 dr 217
Program SUMNBilX2
{Menjumlahkan dan mencacah (melakukan counting)
dibaca. Mark = 9999 }
nilai-nilai X yang
Kamus:
i : integer
{banyaknya nilai integer sudah dibaca }
X : integer{sekumpulan bilangan integer yang dibaca, diakhiri dg 9999}
N : integer >0
{ banyaknya bilangan yang dijumlahkan }
Sum : integer { jumlah}
Algoritma :
i 0; SUM 0
{ Inisialisasi }
input (X)
{First_Elmt}
while (X
9999) do
Output (X)
Sum Sum + X
i
i + 1
input (X)
{Next_Elmt}
{ i = bilangan ke... yang sudah di baca,
Sum = X1 +
X2 +
....
+
... Xi-1 . }
Output (Jumlah : , Sum)
{Terminasi}
Output (Banyaknya bilangan : , i )
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
2. Program ini memakai skema yang benar, tapi tidak menangani kasus kosong
3. Program tersebutbenar baik untuk kasus kosong ataupun tidak kosong. Jika nilai
yang diketikkan langsung 9999 (kasus kosong), mark tidak diproses.
4. Program tidak salah jika tidak pernah terjadi kasus kosong (nilai yang diketikkan
minimal dilakukan satu kali)
5. Konklusi : program tersebut benar, dengan tambahan spesifikasi bahwa :
- banyaknya bilangan yang diketikkan adalah 0 untuk kasus kosong
- jumlah bilangan untuk kasus kosong = 0
Program SUMNBilX3
{Menjumlahkan dan mencacah (melakukan counting)
dibaca. Mark = 9999 }
nilai-nilai X yang
Kamus:
i : integer
{banyaknya nilai integer sudah dibaca }
X : integer{sekumpulan bilangan integer yang dibaca, diakhiri dg 9999}
Sum : integer { jumlah}
Algoritma :
i 0; SUM 0
{ Inisialisasi }
input (X)
{First_Elmt}
repeat
Output (X)
Sum Sum + X
i
i + 1
input (X)
{Next_Elmt}
until (X=9999)
{ i = banyaknya bilangan
yang sudah di baca,
Sum = X1 +
X2 +
... Xi .
}
Output (Jumlah : , Sum)
{Terminasi}
Output (Banyaknya bilangan : , i )
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 104 dr 217
2. Program ini memakai skema yang salah, bukan salah satu dari skema yang
diberikan. Bentuk pengulangan repeat mengharuskan badan pengulangan
dilakukan minimal satu kali
3. Program tersebut salah untuk kasus kosong. Jika nilai yang diketikkan langsung
9999 (kasus kosong), mark akan diproses sehingga program menjadi salah.
4. Program tidak salah jika tidak pernah terjadi kasus kosong (nilai yang diketikkan
minimal dilakukan satu kali) .
5. Konklusi : program tersebut salah.
Program SUMNBilX4
{Menjumlahkan dan mencacah (melakukan counting) nilai-nilai X yang
dibaca. Mark = 9999 . Dengan penanganan kasus kosong}
Kamus:
i :
X :
N :
Sum
integer
{banyaknya nilai integer sudah dibaca }
integer{sekumpulan bilangan integer yang dibaca, diakhiri dg 9999}
integer >0
{ banyaknya bilangan yang dijumlahkan }
: integer { jumlah}
Algoritma :
input (X)
{First_Elmt}
if (X 9999)
then
Output (Kasus kosong: yg diketik langsung 9999 )
else
i 0; SUM 0
{ Inisialisasi }
repeat
Output (X)
Sum Sum + X
i
i + 1
input (X)
{Next_Elmt}
until (X=9999)
{ i = banyaknya bilangan
yang sudah di baca,
Sum = X1 +
X2 +
... Xi .
}
Output (Jumlah : , Sum) {Terminasi}
Output (Banyaknya bilangan : , i )
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
2. Program ini memakai skema yang tepat, dengan penanganan kasus kosong
3. Jika nilai yang diketikkan langsung 9999, kasus kosong, jika bukan berarti
minimal ada satu nilai yang dibaca.
4. Semua invarian dipenuhi. Definisi dan inisialisasi i tepat artinya.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 105 dr 217
Program SUMNBilX5
{Menjumlahkan dan mencacah (melakukan counting) nilai-nilai X yang
dibaca. Mark = 9999. Perhatikan bahwa model ini tanpa Mark }
Kamus:
i : integer
{banyaknya nilai integer sudah dibaca }
X : integer{sekumpulan bilangan integer yang dibaca, diakhiri dg 9999}
Sum : integer { jumlah}
Algoritma :
i 1; SUM 0
{ Inisialisasi }
iterate
input (X)
{First_Elmt, juga Next_Elmt}
Output (X)
Sum Sum + X
stop (X=9999)
i
i + 1
until (X=9999)
{ I = banyaknya bilangan k yang sudah di baca,
Sum = X1 +
X2 +
... Xi .
}
Output (Sum) {Terminasi}
Penjelasan :
1. Pengontrol pengulangan (Current element) adalah nilai X.
2. Program ini salah, jika nilai yang diketikkan langsung 9999 (kasus kosong),
karena Mark diproses (dijumlahkan).
3. Skema yang dipakai adalah skema tanpa mark, jadi bukan skema yang tepat untuk
persoalan ini.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 106 dr 217
HUBUNGAN BERULANG
(Reccurence Relation)
Bagian ini menyajikan contoh-contoh dan pola pemakaian skema pengulangan untuk
persoalan deret yang rumusnya dapat dinyatakan dalam suatu hubungan berulang
(reccurence relation). Bagian ini sekaligus menunjukkan keterbatasan analisis dan
penulisan algoritma, yaitu yang menyangkut masalah ketelitian representasi bilangan
riil pada komputer. Untuk melihat efek tersebut, harus dilakukan eksekusi pada mesin.
Contoh 1:
Hitunglah S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/1000
Ide pertama yang muncul adalah menyatakan suku ke-i sebagai:
Si = (-1)i+1/i
Berikut ini adalah beberapa versi solusi, dengan penjelasannya
Program HITUNGDERET1
{Menghitung deret S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/1000}
Kamus
constant N : integer = 1000
i : integer { indeks suku berikut
S : real 0.0 {Jumlah deret}
Algoritma
S 0 { i=0, S= 0 }
i 1 { suku berikutnya yang akan
while (i N) do
{ S = 1 - 1/2 + 1/3 - 1/4 + ... +
S S + (-1)^(i+1)/i
i i + 1
{ i = N+1 and S = 1 - 1/2 + 1/3 output(S)
dihitung }
(-1)^i/(i-1)}
Penjelasan :
1. Pengontrol pengulangan adalah sebuah bilangan integer i, i adalah next element
2. Perhatikan inisialisasi. Invarian dari i dan S.
3. Program menghasilkan nilai jumlah deret Nol, jika konstanta N bernilai negatif,
N 0, dengan tambahan spesifikasi : Jumlah deret adalah 0 untuk N 0
4. Jika diimplementasikan dalam salah satu bahasa pemrograman, harus diperhatikan
konversi type sebab misalnya 1/2 adalah ekspresi integer, yang hasilnya adalah
integer.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 107 dr 217
Program HITUNGDERET2
{Menghitung deret S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/1000}
Kamus
constant N : integer = 1000
i : integer { indeks suku berikut yang akan dihitung }
S : real 0.0 {Jumlah deret}
Algoritma
S 1{ i=1, S= 1 }
i 2 { suku berikutnya yang akan dihitung }
while (i N ) do
{ S = 1 - 1/2 + 1/3 - 1/4 + ... + (-1)^i/(i-1)}
S S + (-1)^(i+1)/i
i i + 1
{ i = N+1 and S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/N, N=1000}
output(S)
Penjelasan :
1. Pengontrol pengulangan adalah sebuah bilangan integer i, i adalah next element
2. Perhatikan inisialisasi. Invarian dari i dan S. Program benar dengan tambahan
spesifikasi : N 1
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 108 dr 217
Program HITUNGDERET3
{Menghitung deret S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/1000}
Kamus
constant N : integer = 1000
i : integer { indeks suku berikut yang akan dihitung }
TANDA : [-1,1] { tanda suku deret}
S : real 0.0 {Jumlah deret}
Algoritma
TANDA 1
S 1 { i=1, TANDA =1, S = 1 }
i 2 { suku berikutnya yang akan dihitung }
while (i N) do
{ S = 1 - 1/2 + 1/3 - 1/4 + ... + tanda/(i-1)}
TANDA -TANDA
S S + TANDA/i
i i + 1
{ i = N+1 and S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/N, N=1000}
output(S)
Penjelasan :
1. Merupakan modifikasi dari versi 2. Tampaknya, algoritma versi 1 sederhana,
tetapi sebenarnya tidak efisien karena mengandung proses pemangkatan yaitu
perhitungan (-1)^(i + 1). Karena proses pemangkatan ini gunanya hanya untuk
mengubah tanda dari satu suku ke suku berikutnya, maka harus dipikirkan cara
lain yang lebih bagus untuk mengatur perubahan tanda ini. Pada algoritma versi-2
ini, dipakai sebuah variabel tambahan TANDA yang harganya berubah-ubah,
yaitu +1 atau -1.
2. Sebuah loop while di atas, merupakan penggabungan dari dua loop yang
dijalankan secara bersamaan, yaitu loop dengan elemen pengontrol I dan tanda.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 109 dr 217
Program HITUNGDERET4
{Menghitung deret S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/1000}
Kamus
constant N : integer = 1000
i : integer { indeks suku terakhir yang sudah ditambahkan ke S}
TANDA : [-1,1] { tanda suku deret}
S : real 0.0 {Jumlah deret}
Algoritma
TANDA -1
S 1/2 { i=2, TANDA = -1, S = 1 - 1/2}
i 2 { suku terakhir yang sudah ditambahkan ke S }
while (i < N) do
{ Kondisi untuk mengakhiri iterasi, suku 1/1000 sudah terhitung}
{ S = 1 - 1/2 + 1/3 - 1/4 + ... + tanda/i }
i i + 1
TANDA -TANDA
S S + TANDA/i
{ i = N and S = 1 - 1/2 + 1/3 - 1/4 + ... + 1/999 - 1/N, N=1000}
output(S)
Penjelasan :
1. Pengontrol pengulangan adalah sebuah bilangan integer i, i adalah current element
2. Perhatikan inisialisasi: Invarian dari i dan S.
3. Program benar dengan tambahan spesifikasi N 2
LATIHAN:
1. Carilah algoritma-algoritma lain untuk soal ini (paling tidak, ada empat solusi lain).
2. Buatlah program komputer, untuk masalah ini berdasarkan algoritma-algoritma
yang berbeda. Bandingkan hasilnya. Pakailah ketelitian yang berbeda-beda pula
untuk setiap algoritma. Apa yang terjadi jika algortima di atas diterjemahkan secara
naif dan diprogram dalam bahasa pemrograman yang dapat dieksekusi ? Cobalah
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 110 dr 217
Contoh 2: FAKTORIAL
Hitunglah n!
Dari definisi,
0! = 1
1! = 1
2! = 2 x 1! = 2 x 1 = 2
3! = 3 x 2! = 3 x 2 = 6
4! = 4 x 3! = 4 x 6 = 24
:
n! = n x (n-1)! = n x (n-1) x ... x 3 x 2 x 1
Hubungan berulang:
Fo = 1
Fi = i * Fi-1
Solusi 1:
Program FAKTORIAL1
{Diberikan n, dihitung n!}
Kamus
i : integer 1 { indeks F berikut yang akan dihitung}
n : integer 0 { bilangan yang dihitung faktorialnya }
F : integer 1 { harga faktorial yang dihitung }
Algoritma
input(n)
F 1 {1=0, Fo=1}
i 1 {indeks F berikutnya yang akan dihitung}
while (i n) do
{ F = (i-1)! }
F i * F
i i + 1
{ i = n+1 and F = n!}
output(F)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 111 dr 217
Solusi 2:
Program FAKTORIAL2
{Diberikan n, dihitung n!, kondisi berhenti berdasarkan loop
invariant}
Kamus
i : integer
0 { indeks F terakhir dihitung}
n : integer 0 { bilangan yang dihitung faktorialnya }
F : integer 1 { harga faktorial yang dihitung }
Algoritma
input(n)
F 1 {Fo}
i 0 {indeks F, untuk nilai F yang telah dihitung}
while (i < n) do
{ F = i! }
i i + 1
F i * F
{ i = n and F = n!}
output(F)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 112 dr 217
Kamus
T : real {Suku terakhir dihitung}
S : real {Jumlah deret }
i : integer _ 0 { indeks suku yang terakhir dihitung}
{ P adalah sebuah Predikat, dengan parameter S, T, dan i)
Algoritma
T 1 {T0}
S T
i 0
while not P(S, T, i) do
{Kondisi berhenti P(S, T, i) akan diperinci lebih lanjut}
i i + 1
T x^i / FACT (i) {FACT(n) adalah fungsi untuk menghitung n!}
S S + T
output(S)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 113 dr 217
- ... }
Kamus
T : real {Suku terakhir dihitung}
S : real {Jumlah deret }
i : integer 0 { indeks suku yang terakhir dihitung}
Algoritma
i x {T1}
S T
i 1
while not P(S, T, I) do
{Kondisi berhenti P(S, T, i) akan diperinci lebih lanjut}
i i + 1
T (-1) ** (i-1)*(x^ (2* i-1) )/FACT (2*i-1)
{FACT (n) adalah fungsi untuk menghitung n!}
S S +T
{deret aditif}
output(S)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 114 dr 217
Program HITUNGDERET1
{Menghitung deret S = t 0 + t 1 +t
t 2 * ... * tn }
Kamus
T : real
S : real
2 +... + tn
atau
S = t 0 * t 1*
Algoritma
T t 0
S T
while not P (S,T) do
T f(T)
{f(T) adalah fungsi yang menghitung harga T baru berdasarkan T yang
lama }
S g(S , T)
{g(S , T) adalah fungsi yang mengubah harga S berdasarkan S yang lama
dan T}
{ S adalah hasil yang diinginkan}
Skema umum 2:
Program HITUNGDERET2
{Menghitung deret S = t 0 + t 1 + t 2 +... +tn
t 2 * ... * tn }
atau
S = t 0 * t 1*
Kamus
T : real {Suku/faktor terakhir dihitung}
S : real {Jumlah deret aditif/multiplikatif}
i : integer 0 { indeks suku/faktor yang terakhir dihitung}
Algoritma
T t 0
S T
i 0
while not P (S,T) do
{loop invariant: S = t 0 + t 1 + t 2,+... +ti
atau
S = t 0 * t 1* t 2 * ... * ti}
{ i adalah indeks suku terakhir yang sudah termasuk dalam S }
i i + 1
T f(T, i)
{f(T) adalah fungsi yang menghitung harga T yang baru
berdasarkan T yang lama dan i}
S g(S , T, i)
{g(S , T, i) adalah fungsi yang mengubah harga S
berdasarkan S yang lama, T dan i}
{ S adalah hasil yang diinginkan}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 115 dr 217
Program HITUNGEXP2
{Menghitung exp (x) 1 + x + x2/2! + x3/3! + ..... xn/n!
Kamus
T : real {Suku terakhir dihitung}
S : real {Jumlah deret }
i : integer 0 { indeks suku yang terakhir dihitung}
Algoritma
T 1 {T0}
S T
i 0
while abs(T) > do
i i + 1
T T *x/i
S S +T
output(S)
- ... }
Kamus
T : real {Suku terakhir dihitung}
S : real {Jumlah deret }
k : [1,3,5,...] { indeks suku yang terakhir dihitung}
Algoritma
k 1
T x {T1}
S T
while ( abs(T) > * abs(S) ) do
k k + 2
T -T * x * x/ (k*(k-1))
S S +T
{deret aditif}
{ abs(T) * abs(S) suku berikutnya sudah dapat diabaikan :
output(S)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 116 dr 217
Latihan Soal
1. Hitung cos(x) dengan pendekatan:
S = 1 - x2/2! + x4/4! - ... + (-1)n x2n /(2n )! , n _ 0
dan kondisi berhenti: |T| * |S|
2. Buat suatu algoritma untuk menghitung cos(x) maupun sin(x) tergantung pada
sebuah parameter p, p = 1 untuk cos(x) atau p = 2 utnuk sin(x) dengan
memperhatikan bahwa kedua rumus untuk menghitung sin(x) dan cos(x)
sangat mirip.
3. Hitung pendekatan nexp(-x2) dx dengan pendekatan:
x - x3/3*1!+ x5/5*2! -x7/7*3! ...
4. Hitunglah konversi string 12345 menjadi nilai integer basis 10, atau sebuah
string dengan basis bukan sepuluh, misalnya biner yaitu 000011111001
menjadi nilai integer basis 10 tanpa mengetahui posisinya, yaitu dengan
memanfaatkan nilai sebelumnya yang sudah dihitung.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 117 dr 217
[1..7] of string
TabJumlahHari : array
[1..12]
of integer
type
type
Indeks : integer
[1..10]
TabTitikSurvey :
array
[Indeks] of
TabFREK : array
['A'..'Z'] of integer
Point
Domain :
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 118 dr 217
TabelNamaHari :
procedure IsiTabHari
HariKe : integer [1..7]
Algoritma :
IsiTabHari
{ Contoh pemanfaatan setelah Tabel TabNamaHari terdefinisi isinya }
Input (HariKe)
Output ( TabelNamaHariHariKe)
procedure IsiTabHari
{ mengisi tabel nama hari }
{ I.S : TabNamaHari tak terdefinisi }
{ F.S. : TabNamaHari siap dipakai, semua elemennya [1..7] sudah diisi
}
Kamus lokal :
Algoritma :
TabelNamaHari 1
TabelNamaHari 2
TabelNamaHari 3
TabelNamaHari 4
TabelNamaHari 5
TabelNamaHari 6
TabelNamaHari 7
Senin
Selasa
Rabu
Kamis
Jumat
Sabtu
Minggu
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 119 dr 217
[1..MaxKata] of character
{definisi kata }
{panjang kata }
Berikut ini adalah prosedur untuk membaca sebuah kata dari keyboard, dan
menuliskan kata yang dibaca serta panjangnya ke layar dengan menggunakan kamus
umum di atas:
Procedure BacaTulisKata
{I.S. sembarang; F.S : sebuah kata dibaca dan dituliskan kembali di
layar. Jika karakter yang diketikkan melebihi panjang kata maksimum,
pembacaan dihentikan dan pada akhir proses dituliskan pesan. Jika
program terus menerus membaca tanpa menghentikan pembacaan ketika
ukuran array dilampaui, program akan abort. Maka jika pengguna
mengetikkan sejumlah karakter yang melebihi kapasitas pendefinisian
tabel TabKata, pembacaan dihentikan. }
Kamus lokal :
K : Kata
cc : character
i : integer
Algoritma :
{ Baca kata huruf demi huruf, pembacaan diakhiri dengan huruf @}
{ skema pemrosesan sekuensial dengan mark, dengan kasus kosong }
input (cc ) {First-Elmt}
K.Length 0 {Inisialisasi, harus di sini spy kata kosong terdefinisi}
if (cc @)then
output (tidak ada kata yang dibaca) {Proses-Kasus-Kosong}
else
repeat
K.Length K.Length + 1
K.TabKatai cc
{Proses-Current-Elmt }
input (cc )
{Next-Elmt }
until (cc = @ or K.Length = Maxkata)
{Terminasi }
depend on TabKatai :
cc @ : output (Pembacaan kata dihentikan)
cc = @ : output (Kata yang dibaca adalah : )
{ Penulisan kata }
i traversal [1..K.Length]
output (K.TabKatai)
output (Panjang kata : , K.Length)
Latihan soal
1. Tuliskanlah kembali prosedur IsiTabHari pada contoh program NamHari
dengan parameter formal nama Tabel yang menyimpan nama hari. Tuliskanlah
pula program NamaHari sesudah prosedur IsiTabHari mempunyai parameter.
Bandingkanlah ke dua solusi ini.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 120 dr 217
[1..MaxKata] of character
{definisi kata }
Maka :
Kata hanya akan disimpan definisinya sebab panjang kata dapat dikalkulasi dari
kata yang disimpan.
Karakter terakhir kata dapat dikenali yaitu :
- karakter pada tabel Kata dengan indeks i, i = MaxKata, akhir tabel (jika tabel
penuh), atau
- karakter pada indeks tabel ke-i, dengan i < MaxKata dan Katai+1 = Blank,
Tuliskanlah prosedur membaca dan menulis kata seperti pada kasus-2 untuk kamus
ini.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 121 dr 217
i : integer [Nmin..Nmax]
T : array [Nmin..Nmax] of ElType
{tabel yang didefinisikan atas indeks i,
dengan elemen bertype ElType}
procedure Inisialisasi
procedure Proses(Input
procedure Terminasi
X:integer )
Karena pemrosesan sekuensial terhadap semua elemen tabel sering dipakai, maka
skema di atas dipersingkat cara penulisannya sbb :
SKEMA PEMROSESAN TABEL T untuk indeks [1..N]
{Traversal Tabel T untuk Indeks bernilai Nmin..NMax}
Skema :
Inisialisasi
i traversal [NMin..NMax]
Proses (Ti)
Terminasi
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 122 dr 217
= 1
T : array[NMin..Nmax] of integer
Algoritma :
i NMin {Inisialisasi }
input (x) {First element }
while (x 9999) and (i<=Nmax) do
Ti x
{ Proses }
i i+ 1
input (x) { Next element }
{x =9999 or i >Nmax }
if (i>Nmax) then
output (Tabel sudah penuh )
Contoh-3 :
Menuliskan isi tabel secara "mundur" (mulai dari elemen dengan indeks yang
terbesar yang terakhir sampai dengan yang pertama )
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 123 dr 217
Program TULISTABELMundur
{ Menuliskan isi tabel dari indkes terbesar ke indeks terkecil }
Kamus:
constant
NMin : integer
constant
NMax :
TabelInt :
integer
array
= 1
= 100
[Nmin..Nmax] of integer
Algoritma :
{ di titik ini: tabel T [1..N] sudah diisi, algoritma berikut hanya
menuliskan mundur }
i traversal [N..1]
output (Ti)
Nmax : integer
type TabInt :
array
= 100
[1..Nmax] of integer
{ jika diperlukan sebuah tabel, maka akan dibuat deklarasi sebagai berikut }
T : TabInt { tabel integer }
N : integer {indeks efektif, 1 N Nmax+1}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 124 dr 217
Contoh-2
Output : IX = 3
N = 4, T berisi : { 11, 3, 5, 8} X = 100
Pemeriksaan dilakukan terhadap {11,3,5,8}
Output : IX = 0
[1..Nmax]
Algoritma :
i 1
while (i < N) and (T i
X) do
i i + 1
{ maju, jika belum di ujung }
{ i = N or Ti = X }
if (T i = X ) then
IX i
else
{ T i X }
IX
Catatan :
1. Pada versi ini, elemen tabel yang terakhir diperiksa secara khusus.
2. Proses pada badan pengulangan hanya berisi maju. Pencarian dihentikan karena
ketemu, atau karena sudah tidak dapat maju. Yang menentukan apakah
pencarian ketemu atau tidak adalah kesamaan nilai elemen tabel ketika pencarian
dihentikan.
3. Pada versi ini tidak diperlukan nama boolean seperti pada versi-2, namun jika
dikehendaki bahwa hasilnya adalah sebuah nilai boolean (ketemu atau tidak
ketemu), maka dapat dituliskan versi-1a sebagai berikut:
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 125 dr 217
X) do
Catatan :
1. Pada versi ini, semua elemen tabel diperiksa dalam badan pengulangan dengan
instruksi yang sama.
2. Nilai tabel yang diperiksa indeksnya adalah dalam definisi tabel tersebut.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 126 dr 217
X)
do
i i + 1
{ I = N+1 or T i
X }
if ( i N ) then
Found true; IX i
else { I > N }
Found false; IX 0
Catatan :
1. Pada versi ke-3 ini, semua elemen tabel diperiksa dalam badan pengulangan
dengan instruksi yang sama.
2. Algoritma ini salah karena ada nilai tabel dengan indeks TIDAK TERDEFINISI
yang diperiksa pada instruksi pengetesan kondisi while. tabel tersebut. Beberapa
pemroses bahasa akan melakukan optimasa dalam melakukan evaluasi ekspresi
boolean and. Jika operan pertama salah, maka pemroses bahasa tidak
melakukan evaluasi lebih lanjut terhadap operan2. Jika optimasi ini dilakukan,
maka program akan selamat (benar), jika tidak ada optimasi maka akan terjadi
index out of bound. Namun operator semacam ini dalam evaluasi and dengan
optimasi semacam ini bukan disebut sebagai operator boolean and, melainkan and
then. Jadi secara konseptual algoritmik, versi ini salah .
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 127 dr 217
X)
IX i
{ T i X T i > X }
IX 0
Catatan :
1. Algoritma tersebut adalah modifikasi dari algoritma pencarian versi-1. Tentunya
dapat pula dituliskan algoritma berdasarkan versi-2 yang memakai nilai boolean.
Tuliskanlah sebagai latihan.
2. Algoritma tergantung kepada keterurutan nilai pada tabel: membesar atau
mengecil.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 128 dr 217
Nmax : integer
type TabInt :
N
array
: integer
= 100
[1..Nmax+1] of integer
1 N Nmax+1}
{ jika diperlukan sebuah tabel, maka akan dibuat deklarasi sebagai berikut }
T : TabInt { tabel integer }
N : integer {indeks , 1 N Nmax+1}
{pasang sentinel }
i 1
while (T i X) do
{tidak perlu test terhadap batas i, karena pasti berhenti}
i i + 1
{ T i = X; harus diperiksa apakah ketemunya di sentinel }
if
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 129 dr 217
Binary Search
Persoalan: Diketahui sebuah tabel bilangan integer T [1..N], yang telah diisi dan
isinya terurut menaik. Tuliskanlah sebuah prosedur BINSEARCHX, yang jika
diberikan sebuah X bernilai integer akan mencari apakah harga X ada dalam
T.secara dikhotomik, yaitu setiap saat pemeriksaan dilakukan dengan mereduksi
elemen tabel, yaitu terhadap separuh dari elemen tabel:
- bandingkan harga yang dicari dengan harga elemen tengah
- jika sama, berarti ketemu
- jika yang dicari lebih kecil, berarti pencarian dengan cara yang sama harus
dilakukan terhadap elemen-elemen pada belahan atas.
- jika harga yang dicari lebih besar, berarti pencarian dengan cara yang sama
harus dilakukan terhadap elemen-elemen pada belahan bawah.
Pencarian dengan cara ini akan mengurangi waktu pencarian karena pembandingan
harga direduksi secara logaritmik (dengan basis 2). Kecepatan pencarian sebanding
dengan ln (N). Namun cara pencarian ini hanya dapat dilakukan jika elemen tabel
sudah terurut. Cara ini tidak mungkin dilakukan jika elemen tabel tidak terurut.
Algoritma pencarian secara dikhotomik berikut akan menghasilkan sebuah harga
boolean FOUND, yangbernilai true jika X ada dalam tabel, false jika tidak. Selain
itu, harga indeks IX dimana X diketemukan pertama kalinya juga disimpan.
Pencarian segera dihentikan begitu harga pertama diketemukan
Contoh
N = 8, T berisi : { 1, 3, 5, 8, 12, 90, 113, 500} X = 5
Pemeriksaan dilakukan terhadap {8,3,5}, Output : Found = true, IX = 3
N = 5, T berisi : { 11, 37, 51, 80,90} X = 100
Pemeriksaan dilakukan terhadap {51,80,90}, Output : Found = false, IX = 0
Solusi-1: Versi dengan boolean
Procedure BinSearch1
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 130 dr 217
Catatan :
1. Semua pemeriksaan dilakukan dengan cara yang sama di dalam badan
pengulangan.
2. Algoritma tersebut berlaku untuk elemen tabel yang terurut membesar, dan harus
dimodifikasi untuk elemen tabel yang terurut mengecil. Tuliskanlah sebagai
latihan.
Solusi-2: Versi tanpa boolean
Procedure BinSearch1
Catatan :
1. Pemeriksaan elemen terakhir dilakukan secara khusus di luar badan pengulangan.
Perhatikan bagaimana indeks Tengah didefinisikan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 131 dr 217
i : integer
Algoritma :
MAX T 1
i 2
while i N do
if (MAX < T i ) then
MAX T i
i i + 1
{ i > N : semua elemen sudah selesai diperiksa }
Catatan :
1. Pada algoritma maksimum versi-1 ini, elemen pertama tabel diproses secara
khusus (bukan di dalam pengulangan)
2. Algoritma tersebut menghasilkan nilai maksimum, namun tidak diketahui posisi
(indeks) di mana nilai maksimum tersebut berada.
3. Seringkali dalam suatu proses, kita membutuhkan indeks di mana nilai maksimum
tersebut berada (terutama jika nilai maksimum muncul beberapa kali).
Algoritmanya dituliskan pada versi-2
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 132 dr 217
Catatan :
1. Pada algoritma maksimum versi-2 ini, elemen pertama tabel diproses secara
khusus (bukan di dalam pengulangan)
2. Algoritma tersebut TIDAK menghasilkan nilai maksimum, namun karena indeks
di mana nilai maksimum tersebut berada diketahui maka nilai maksimum dapat
diakses.
3. Jika bekerja dengan tabel, lebih disukai bekerja dengan indeks karena berkat
indeks nilai dari elemen dapat diakses secara langsung. Sebaliknya, hanya
mengetahui suatu nilai, tidak sederhana untuk mengetahui indeks dimana nilai
tersebut berada, yaitu harus dilakukan dengan proses pencarian
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 133 dr 217
Catatan :
1. Semua elemen tabel diproses dengan cara yang sama, sehingga nilai maksimum
sebelum elemen pertama diperiksa harus didefinisikan. Algoritma tersebut
memakai suatu nilai yang didefinisikan oleh pemrogram di luar nilai tabel (max =
-9999), yang pasti digantikan oleh salah satu elemen tabel. Algoritma ini hanya
berlaku jika semua elemen tabel positif sesuai dengan spesifikasi. Nilai yang
dipilih untuk inisialisasi nilai maksimum harus merupakan nilai yang tepat
tergantung kondisi tabel.
2. Versi-versi sebelumnya lebih baik, bersifat umum dan tidak memakai suatu nilai
di luar nilai tabel
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 134 dr 217
Internal Sorting
Sorting atau pengurutan data adalah proses yang sering harus dilakukan dalam
pengolahan data. Bahkan mesin otomatik yang pertama kali lahir adalah mesin
pengurut, dan masih dipakai sampai saat ini misalnya untuk menyortir surat berkode
pos di kantor pos dengan mesin terotomatisasi. Dibedakan dua macam pengurutan :
- pengurutan internal, yaitu pengurutan terhadap sekumpulan data yang disimpan
dalam media internal komputer yang dapat diakses setiap elemennya secara langsung.
Maka dapat dikatakan sebagai pengurutan tabel.
- pengurutan eksternal, yaitu pengurutan data yang disimpan dalam memori
sekunder, biasanya data bervolume besar sehingga tidak mampu untuk dimuat
semuanya dalam memori.
Algoritma pengurutan adalah salah satu contoh solusi algoritmik yang kaya : satu
macam persoalan (pengurutan), dapat dilakukan dengan puluhan macam algoritma.
Algoritma pengurutan internal yang utama antara lain :
- Counting Sort
- Maximum Sort
- Insertion Sort
- Bubble sort
- Shaker sort
- Heap Sort
- Shell sort
- Quick Sort
- Radix sort
- ...
Berikut ini hanya akan dibahas pengurutan internal, itupun hanya 4 metoda yang
pertama, yang paling sederhana.Metoda pengurutan lain lebih canggih (ditinjau dari
analisis maupun dari struktur datanya tidak dibahas di sini, akan dipelajari pada mata
kuliah yang lain). Algoritmanya dapat dipelajari dari buku-buku [Knuth 73], [Wirth
86]. Buku [Knuth 73] adalah sebuah buku yang khusus membahas tentang "Sorting
and Searching", setiap algoritma dan performansinya dibahas lebih mendalam. Buku
[Wirth 86] sifatnya lebih metodologis dan pedagogis, versi yang ditampilkan bukan
versi yang optimum.
Performansi pengurutan data sangat menentukan performansi sistem, karena itu
pemilihan metoda pengurutan yang cocok akan berperan dalam.suatu aplikasi.
Biasanya selain ditentukan peformansi rata-rata, juga ditentukan performansi terjelek
dan performansi terbagus. Untuk beberapa aplikasi, performansi yang "stabil" (tidak
terlalu mencolok bedanya antara kasus terjelek dan terbagus) perlu juga
dipertimbangkan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 135 dr 217
constant
Nmax :integer
type TabInt :
N : integer
array
= 100
[1..Nmax] of
integer
{ jika diperlukan sebuah tabel, maka akan dibuat deklarasi sebagai berikut }
T : TabInt { tabel integer }
N : integer {indeks efektif, 1 N Nmax+1}
TabCount
TabInt
TabCount
TabInt
1
1
4
1
1
2
2
3
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 136 dr 217
TabCountT
TabCountT
i
i
{ Pengisian kembali : T
T
... T }
1
2
N
K 0
i traversal [ValMin..ValMax]
if (TabCount
0) then
i
repeat TabCounti times
K K + 1
T i
K
Catatan :
TabCountTi dituliskan untuk menunjukkan bahwa indeks T adalah i, dan Ti
i
merupakan indeks dari TabCount.
.
.
N-1 Tentukan IMAX [N-1..N], TImax adalah maksimum dari T[N-1..N]
Tukar T
dengan T
Imax
N-1
T [1..N] sudah terurut : T T T ...... T
1 2
3
N
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 137 dr 217
T
TPass
Imax
T
Temp
Pass
{ T[1..Pass] terurut: T T T .. T
}
1 2 3
Pass
{Seluruh tabel terurut, T T T ...... T }
1
2
3
N
3.
.
N-1 .TN-1 harus dicarikan tempat yang tepat pada T[1..N-1], yaitu i
Sisipkan T
pada T ..T [1..N-1] terurut membesar
N-1
i
N
T [1..N] sudah terurut : T T T ...... T
2
3
N
1
Pada setiap Pass, tabel "terdiri dari" dua bagian : yang sudah terurut yaitu [1..Pass - 1]
dan sisanya [Pass..Nmax] yang belum terurut. Ambil elemen TPass, sisipkan ke
dalam T[1..Pass-1] dengan tetap menjaga keterurutan.. Untuk menyisipkan TPass ke
Ti, harus terjadi "pergeseran" elemen tabel T [i..Pass]. Pergeseran ini dapat dilakukan
sekaligus dengan pencarian i. Pencarian dapat dihentikan segera dengan
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 138 dr 217
3
10
2
5
6
7
1
2
3
10
5
6
7
1
2
3
5
10
6
7
1
2
3
5
6
10
7
1
2
3
5
6
7
10
1
1
2
3
5
6
7
10
Sebelum
loop
Pass=[2..7]
Cermati ulang kebenaran algoritma di atas, dan gantilah search dengan boolean
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 139 dr 217
Pencarian dengan sentinel dapat dimanfaatkan pada Insertion Sort. Pada kasus ini,
sentinel ditaruh pada T0 karena pada tahapan ke Pass, pencarian sekuensial dilakukan
pada T [pass-1..1]. Berikut ini adalah algoritma untuk Insertion sort dengan sentinel :
procedure InsertionSORTWithSentinel(Input/Output T: TabInt,
Input N : integer)
{ mengurut tabel integer [1..N] dgn insertion sort, pencarian dengan
sentinel}
Kamus :
i : integer {indeks untuk traversal tabel }
Pass : integer
{ tahapan pengurutan }
Temp : integer { Menyimpan harga Tab
spy tidak tertimpa krn
Pass
pergeseran }
Algoritma :
{ T adalah terurut}
1
Pass traversal [2..N]
{Simpan dulu harga T(Pass) spy tidak tertimpa krn pergeseran }
Temp T
Pass
T Temp
0
{ Sisipkan elemen ke Pass dalam T[1..Pass-1] sambil menggeser }
i Pass-1
{ Cari i, T Temp and i > 1 }
I
while (Temp < T ) do
i
T
T
{ Geser}
i+1
i
i
i - 1
{ Berikutnya }
{Temp T }
i
T
Temp
{ Sisipkan }
i+1
{ T[1..Pass] terurut: T T T ..... T
}
1
2
3
Pass
{Seluruh tabel terurut, karena Pass = N : T T T .... T }
1 2
3
N
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 140 dr 217
TK-1 TK, dengan demikian TK harus ditukar dengan TK-1 jika sifat
di
.
N-1 .Untuk setiap dua elemen suksesif TK dan TK-1, K [N-1..N],
TK-1 < T K, dengan demikian TK harus ditukar dengan TK-1
jika sifat di atas tidak dipenuhi
Karena dilakukan secara sekuensial, T[1..N-1] terurut
T [1..N] sudah terurut : T1 T2 T3 ...... TN
Procedure BubbleSort (Input/Output T: TabInt, Input N : integer)
{ mengurut tabel integer [1..N] dengan bubble sort }
Kamus :
i,K: integer {indeks untuk traversal tabel }
Pass : integer
{ tahapan pengurutan }
Temp : integer { Memorisasi untuk pertukaran harga }
Algoritma :
Pass traversal [1..N-1]
K traversal [N..Pass+1]
if (T < T
) then
K
K-1
Temp T
K
T T
K
K-1
T
Temp
K-1
{ T[1..Pass] terurut :T T T ... T
}
1
2
3
Pass
{Seluruh tabel terurut, karena Pass = N T T T ... T }
1
2
3
N
Sebetulnya proses dapat dihentikan jika tidak terjadi lagi pertukaran. Manfaatkan sifat
ini dengan memakai sebuah besaran boolean, dan tuliskanlah algoritmanya untuk
memperoleh versi yang optimum.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 141 dr 217
Versi asli metoda ini biasanya paling diingat karena prinsipnya yang "alamiah", tapi
performansinya tidak bagus (kecuali versi yang sudah dibuat efisien), maka tidak
direkomendasikan untuk dipakai.
Procedure BubleSortPlus
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 142 dr 217
Pemrosesan Sekuensial
1. Tuliskanlah algoritma yang masukannya adalah harga-harga integer antara 0 s/d
100 yang disimpan dalam tabel bilangan integer TABNILAI [1..100] dan
melakukan proses sebagai berikut :
- menghitung nilai rata-rata dari harga yang disimpan dalam tabel tsb.
- mengkonversi setiap angka ke dalam skala 'A' s/d 'E' dengan kriteria :
80 : 'A'
70 : 'B'
55 : 'C'
40 : 'D'
< 40 'E'
dan menyimpan hasil konversi setiap elemen tersebut ke dalam sebuah tabel
lain
- menghitung frekuensi relatif setiap nilai 'A', 'B', 'C', 'D' dan 'E' pada tabel
yang dihasilkan
Searching
1.
Jika elemen dari tabel terurut, maka kondisi berhenti pada sequential search
dengan sentinel juga dapat dibuat lebih efisien. Tuliskan algoritma Sequential search
dengan sentinel, jika elemen tabel teurut mengecil, untuk setiap i [1..N], dan Ti
Ti+1
2. Diberikan sebuah tabel TABMK yang setiap elemennya berisi kode matakuliah
(integer), dengan catatan bahwa maksimum matakuliah yang mungkin ada adalah
100. Banyaknya matakuliah yang sudah ada dalam tabel adalah NMK. Tuliskanlah
sebuah algoritma yang menambahkan sebuah kode mata kuliah MKX, jika dan hanya
jika MKX belum ada dalam tabel:
penambahan selalu dilakukan sebagai elemen terakhir tabel matakuliah.
elemen tabel TABMK [1..NMK] diurut membesar dan penambahan MKX
harus tetap menjaga keterurutan kode matakuliah.
3. Tabel Kode
Diberikan suatu tabel yang setiap elemennya bertype bentukan :
<kode:integer, deskripsi:string>
Tabel terdefinisi dengan indeks [1..Nmax], namun isi efektif tabel adalah
NELMT. Kode yang muncul pada tabel tersebut harus unik (hanya muncul satu kali
saja). Tuliskanlah sebuah prosedur untuk melakukan penambahan kode baru dan
deskripsinya, yang tetap membuat kode dalam tabel unik (artinya, sebelum melakukan
penambahan elemn tabel, harus dilakukan pemeriksaan terlebih dulu). Pemeriksaan
yang harus dilakukan adalah terhadap keunikan kode dan juga apakah masih ada
tempat kosong dalam tabel. Implementasikan prosedur dengan cara pencarian
dengan sentinel, sebab cara ini merupakan cara yang paling efisien untuk persoalan
ini.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 143 dr 217
Ticketing
Tempat duduk pada suatu type pesawat penumpang dinomori dengan angka
dan abjad A..J (misalnya 1A, 10F, 3D,....). Status tempat duduk disimpan sebagai
suatu nilai boolean (true jika isi, false jika kosong) dalam suatu tabel dengan indeks
[1..Nmax], dan tempat duduk yang tersedia adalah Nseat.
Buatlah kamus yang sesuai untuk pencarian tempat duduk kosong dalam
pesawat, dan tuliskanlah prosedur-prosedur dengan deskripsi sebagai berikut:
prosedur untuk mencari sebuah tempat duduk yang kosong dalam pesawat.
prosedur untuk mencari N buah tempat duduk dalam pesawat yang kosong
prosedur untuk mencari N buah tempat duduk (2 N 4) yang masih kosong
dan berdampingan dalam pesawat.
Tempat duduk dalam pesawat adalah berdampingan jika bernomor :
A ,B (untuk N=2)
C , D (untuk N=2)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 144 dr 217
E ,F (untuk N=2)
G,H,I ,J (untuk N = 3 atau 4 )
6.
PASSWORD
Suatu jaringan komputer hanya mampu menangani maksimum 100 orang user.
Informasi pengguna suatu jaringan komputer disimpan dalam suatu tabel, dengan
informasi:
<
User_id : string,
Nama : string,
Prioritas : integer,
Password : array [1..20] of character >
User_id dalam tabel tersebut adalah unik, dan password disimpan dalam bentuk
rahasia, dengan rumus transformasi huruf yang diberikan dalam sebuah tabel,
misalnya untuk beberapa huruf diberikan dalam tabel sebagai berikut :
Huruf yang
diketikkan
A
B
C
D
E
F
G
1
2
@
#
Disimpan sebagai
Z
Y
X
W
V
U
T
%
#
$
@
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 145 dr 217
7. BINARY SEARCH
Bacalah baik-baik algoritma di bawah ini, dan carilah kasus dimana algoritma
tersebut salah.
Procedure BinSearchX
{ Binary search}
{ Mencari harga X dalam Tabel T [1..N] secara dikhotomik }
{ Hasilnya adalah indeks IX dimana Ti = X IX = 0 jika tidak ketemu.}
{Nilai elemen tabel terurut membesar:
T1 X T2 T3
...
TN }
Kamus :
i : integer [1..Nmax]
{indeks untuk pencarian }
Atas,Bawah, Tengah : integer
{indeks atas,bawah,tengah: batas pemeriksaan}
Algoritma :
Atas 1;
Bawah N; {Batas atas dan bawah seluruh tabel}
Found false ; IX 0
{Mula-mula belum ketemu }
while (Atas Bawah) and (not Found ) do
Tengah (Atas+Bawah) div 2
depend on T, Tengah, X
X= TTengah : Found true; IX Tengah
X < TTengah : Bawah Tengah - 1
X > TTengah : Atas Tengah + 1
{ Atas > Bawah or Found }
{ Harga Found menentukan hasil pencarian }
Nilai Ekstrem
1.
Tuliskanlah algoritma yang menentukan nilai maksimum dan indeks tebesar
pada suatu tabel jika nilai maksimum tersebut muncul lebih dari satu kali.
Contoh: jika isi tabel adalah
1
1
33
2
2
3
4
4
1
5
10
6
33
7
4
8
6
9
7
10
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 146 dr 217
5. Tuliskanlah algoritma yang hasilnya adalah semua posisi di mana nilai maksimum
muncul.
6. Tuliskanlah sebuah prosedur EKTREM, yang diparametrisasi sehingga prosedur
yang sama dapat dipakai untuk mencari harga maksimum maupun nilai minimum.
Berikan contoh pemanggilannya.
7. KarcisKA
Buatlah program untuk mengalokasikan tempat dan mencetak karcis kereta api,
jika sebuah nomor kereta api dari kota X ke kota Y terdiri dari N buah gerbong
kelas executive berkeapasitas NEX tempat duduk dan M gerbong kelas bisnis
berkapasitas MBI tempat duduk. Tempat duduk di kereta api diatur sehingga setiap
nomor terdiri dari A,B,C,D, dengan catatan bahwa A berdampingan dengan B, C
dengan D. Peminta karcis maksimum boleh membeli 4 karcis dan prioritas tempat
adalah harus diusahakan berdampingan, dalam satu gerbong. Formulasikan
persoalan ini dengan lebih persis, dan rancanglah struktur data yang sesuai untuk
persoalan ini sehingga alokasi tempat adalah optimal dan cepat. Bagaimana jika
orang bisa memilih Jendela dan Gang ?
8. Parkir Mobil
Parkir mobil di suatu Plaza ingin dikomputerisasi. Tempat parkir tersebut
menampung 300 mobil (maksimal) yang mempunyai identitas 1 s/d 300. Jumlah
mobil yang sudah ada di dalam tempat parkir selalu dipasang pada layar besar di
depan gerbang masuk. Aturan parkir adalah Rp. 300,- untuk satu jam pertama, dan
Rp. 200 untuk jam berikutnya. Parkir yang kurang dari 1 jam pembayarannya
dibulatkan ke atas (dihitung sebagai satu jam).
Sebuah mobil hanya boleh masuk jika dan hanya jika masih ada tempat parkir yang
kosong. Tuliskanlah algoritma yang program utamanya adalah
untuk
mengendalikan empat buah proredur: INISIALISASI, MOBIL-IN, MOBIL-OUT
dan TERMINASI.
Prosedur INISIALISASI adalah prosedur yang harus diaktifkan ketika tempat
parkir mulai dibuka.
Prosedur MOBIL-IN harus mampu untuk mencatat jam mulai parkir,
mengalokasikan mobil pada salah satu tempat kosong dan meng-update layar besar
pada gerbang masuk yang menunjukkan jumlah mobil yang sudah ada di dalam
tempat parkir. Alokasi tempat kosong yang mungkin adalah: identitas paling kecil,
paling dekat pintu masuk eskalator plaza, tempat sebelah "tetangganya" lebar,
random, dsb... Paling masuk akal adalah bahwa alokasi ini ditentukan sendiri oleh
pemakai, dan program menerima input (dari sensor yang dipasang pada setiap
tempat parkir), yang harus mengupdate tabel keberadaan setiap mobil.
Prosedur MOBIL-OUT harus mampu untuk mencetak slip pembayaran jam parkir
mobil yang keluar, membebaskan tempat yang dialokasi, dan meng-update layar
besar pada gerbang masuk yang menunjukkan jumlah mobil yang sudah ada.
Prosedur TERMINASI mencetak resume pendapatan parkir hari itu dan occupancy
rate (pemakaian tempat rata-rata : jumlah mobil parkir dibagi jumlah tempat parkir
yang tersedia).
Andaikata untuk pencatatan jam disediakan sensor yang dapat mengambil current
clock, tentukan di mana saja harus dipasang, supaya key-in petugas seminimal
mungkin, bahkan kalau perlu tidak usah key-in sama sekali.
Tentukan prosedur manual yang menyertai program komputer tempat parkir ini,
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 147 dr 217
karena program ini hanya dapat berfungsi baik jika prosedur manual nya dijalankan
dengan patuh (misalnya pemberian tanda parkir, pembayara, pencatatan jam dan
bukti parkir...).
Jika setiap tempat tidak diberi identitas, artinya tempat parkir dipandang sebagai
satu tempat yang menampung 300 mobil tanpa peduli identitas masing-masing
tempat; apa yang berubah pada program ini ? Tuliskanlah kembali algoritmanya.
Sorting
1. Untuk setiap metoda sort, coba analisis secara kualitatif apa yang dikerjakan jika :
- Elemen tabel sudah terurut
- Elemen tabel terurut terbalik
- Elemen tabel bernilai sama.
2. Carilah performansi ke empat algoritma pengurutan yang dibahas, dan sebutkan
kasus terbaik dan kasus terjeleknya.
3. Bagaimana jika pada Insertion sort diterapkan pencarian biner untuk mencari
tempat penyisipan?
4. Loncat Indah
Penilaian suatu lomba loncat indah ingin ditayangkan melalui layar besar, yang
setiap kali mencetak ranking, nama-nama peloncat dan score akhirnya secara
terurut mulai dari yang paling tinggi s/d yang paling rendah.
Layar besar tersebut harus di-update setiap kali seorang peloncat selesai melakukan
1 kali loncatan. Seorang peloncat berhak untuk melakukan 3 kali loncatan, dan
nilai yang diambil adalah nilai terbesar. Untuk mempercepat pertandingan, 3 kali
loncatan tersebut tidak dilakukan berturut-turut, tetapi peloncat yang siap boleh
langsung melakukan gerakan. Untuk mempercepat proses (?), pada setiap nama
peloncat diberikan nomor peserta.
Tuliskanlah algoritma untuk menerima nomor peserta dan nilai loncatan, serta
meng-update layar. Algoritma harus mendeteksi apakah loncatan seseorang masih
dalam batasan yang diperbolehkan (maksimal 3 kali); seorang peloncat yang
mencoba untuk meloncat lebih dari 3 kali harus di-diskualifikasi. daftar peserta
yang terkena diskualifikasi juga harus ditayangkan (di layar lain).
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 148 dr 217
Nmax : integer
type TabInt :
array
= 100
[1..Nmax+1] of integer
{ jika diperlukan sebuah tabel, maka akan dibuat deklarasi sebagai berikut }
T : TabInt { tabel integer }
N : integer {indeks efektif, 1 N Nmax+1}
Jika prosedur diparametrisasi seperti pada spesifikasi yang diberikan, maka T dan N
menjadi dua buah parameter. Padahal, nilai T dan N sebanrnya erat kaitannya satu
sama lain. Deklarasi TabInt akan lebih baik jika dibungkus menjadi sebuah type
komposisi sebagai berikut :
KAMUS UMUM
constant
Nmax : integer
array
N : integer
= 100
[1..Nmax+1] of integer,
{indeks efektif, }
Sebagai latihan, tuliskan ulang semua prosedur yang pernah didefinisikan dengan
deklarasi type komposisi ini.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 149 dr 217
MESIN ABSTRAK
Mesin adalah mekanisme yang terdefinisi dan mengerti serta mampu untuk
mengeksekusi aksi-aksi primitif yang terdefinisi untuk mesin tersebut.
Mesin abstrak adalah mesin yang dianggap ada, dan diasumsikan mampu melakukan
mekanisme yang didefinisikan untuk mesin tersebut. Mesin abstrak memodelkan
suatu semesta (universe) tertentu.
Dalam pemrograman, seringkali pemrogram harus mendefinisikan mesin-mesin
abstrak sebelum menuliskan kode program karena mesin abstrak memungkinkan
pemrogram untuk melakukan pemecahan masalah secara bertahap. Mesin abstrak
yang diciptakan pada tahap konseptual bahkan memungkinkan pemrogram untuk
berpikir tahap demi tahap, sampai akhirnya dijabarkan dalam terminologi mesin riil.
Mesin Riil
Mesin Abstrak
Mesin Abstrak
Sebetulnya, bahasa tingkat tinggi adalah "mesin abstrak" bagi assembler, dan lebih
abstrak bagi mesin riil yaitu komputer.
Mendefinisikan mesin abstrak, berarti mendefinisikan:
- sekumpulan state yang mungkin
- sekumpulan aksi primitif yang diasumsikan dapat dimengerti dan dieksekusi
mesin yang bersangkutan.
Pada diktat ini, akan diberikan contoh-contoh macam-macam mesin abstrak, yaitu:
- mesin gambar
- mesin karakter
- mesin integer
- mesin rekam.
Setiap mesin abstrak tersebut akan memberikan gambaran penyelesaian persoalan dari
yang sederhana sampai yang rumit melalui satu atau beberapa tahapan abstraksi.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 150 dr 217
MESIN GAMBAR
Model State
Definisi
Mesin gambar adalah mesin abstrak yang terdiri dari : bidang gambar dan pena.
Keduanya menyatakan keadaan (State) dari mesin.
Bidang gambar :
yaitu sekumpulan titik yang membentuk sebuah permukaan terbatas yang posisinya
dikenali melalui koordinat kartesian dengan (0.0,0.0) di kiri atas bidang gambar.
Keadaan bidang gambar dinyatakan oleh titik-titik koordinat yang hitam atau putih
Setiap titik koordinat (x,y) pada bidang gambar dapat berada dalam keadaan hitam
atau putih.
(500.0,500.0)
(0.0,0.0)
(-500.0,-500.0)
(500.0,-500.0)
Y
Pena :
Pena mempunyai 3 atribut yaitu :
- posisi penulisan (disingkat Pen) : bisa "on" atau "off". Hanya pada posisi
"on", pena dapat menghitamkan titik bidang gambar. Pena tidak pernah bisa
memutihkan titik bidang gambar..
- posisi pada permukaan (disingkat Posxy) : posisinya pada koordinat bidang
gambar, bertype:
type Point : <X:real,Y:real>
{ menyatakan koordinat real pada sumbu
kartesian}
- arah pena (disingkat Dir) : yaitu arah pena terhadap sumbu Ox seperti dalam
goneometri, besarnya dinyatakan dalam derajat [-360.0..+ 360.0] derajat)
Untuk menentukan harga dari keadaan-keadaan pena ini, kita dapat memakai
konstanta atau nama y (yang didefiniskan dalam kamus). Contoh :
Posxy = <10.0,20.0>, pen= off, Dir=-30.0
Posxy = <Px,Py>, pen= CurrentPos, Dir=90.0,
dengan px dan py yang telah didefinisikan dalam kamus
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 151 dr 217
.
procedure
Restart
{ Aksi yang membersihkan bidang gambar, dan menaruh pena pada posisi
(0,0) dan off, Semua titik koordinat diset menjadi putih.
I.S. : Pen= Pospen, PosXy = <x,y>, Dir = d
F.S : Pen= off, PosXy = <0.0,0.0>, Dir = 0.0; dan semua titik bidang
gambar menjadi putih
}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 152 dr 217
360.0
procedure
LEFT (Input d: real [0.0..360.0])
{ Pena dibelokkan berlawanan arah jarum jam sebesar d derajat.
I.S. : Pen= Pospen, PosXy = <x,y>, Dir = d1
F.S : Pen= Pospen, PosXy = <x, y>, Dir = (d1+d) /360.0;
}
real [0.0..360.0])
sebesar d derajat.
<x,y>, Dir = d1
<x, y>, Dir = d
Studi Kasus
I. Topi
1. Buatlah algoritma yang menggambar topi sebagai berikut, mulai dari titik paling
kiri yang berkoordinat (0.0,0.0)
15.0
60.0
(0.0,0.0)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 153 dr 217
Program GambarTOPI
{I.S. : Pen=sembarang, PosXy = sembarang, Dir =sembarang
}
{F.S : Pen=sembarang, PosXy = sembarang, Dir =sembarang }
{Proses:sebuah gambar seperti pd Gambar di atas tergambar di layar }
Kamus
procedure TOPI
{I.S. : Pen=on, PosXy = <x,y>, Dir = 60.0}
{F.S : Pen= on, PosXy = <x+ 15.0,0.0>, Dir = -60.0
tergambar }
Algoritma :
Restart
Down; SetDir (60.0)
Topi
procedure TOPI
{I.S. : Pen=on, PosXy = <x,y>, Dir = 60.0}
{F.S : Pen= on, PosXy = <x+ 15.0,0.0>, Dir = -60.0
Gb. tergambar }
Kamus lokal
Algoritma :
Move(15.0)
Right (120.0)
Move(15.0)
Gambar topi tersebut selalu berarah dan berukuran yang sama. Diinginkan sebuah
prosedur TOPI yang lain, yang dapat menggambarkan topi dengan sisi yang
merupakan masukan sehingga didapatkan topi dengan ukuran yang bermacammacam sesuai dengan suatu nilai yang diberikan pada saat penggambaran. Maka sisi
menjadi parameter dari prosedur TopiBis.
2. BarisanTopi
Buatlah algoritma yang membaca titik awal sebuah topi dan panjang sisi
miringnya, kemudian menggambarkan barisan topi sebagai berikut :
5.0
60.0
60.0
60.0
60.0
60.0
(0.0,0.0)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 154 dr 217
Program BARISANTOPI
{I.S. : Pen=sembarang, PosXy = sembarang, Dir =sembarang
}
{F.S : 5 buah gambar seperti pada Gambar di atas tergambar di layar }
Kamus
Sisi : real > 0.0
{ panjang sisi sebuah topi}
Arah : real
{ arah sisi miring topi}
type point : <X:real , Y:real >
Awal : point { titik awal penggambaran topi yang pertama }
procedure TOPIBIS (Input L:real)
{ I.S. : Pen=on, PosXy = <x,y>, Dir = Arah }
{ F.S : Pen= on, PosXy = <x+ L cos(Arah),y + L sin(arah)>, Dir = Arah120.0}
{
dan sebuah topi spt pada Gb. tergambar }
Algoritma :
Clear
input (Sisi, Awal,Arah)
SetDir(Arah)
ToPos (Awal)
Down
repeat 5 times
TopiBis (Sisi)
Left (120.0)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 155 dr 217
Program GamBarBSangkar
{ Input : sebuah data Bujur Sangkar }
{ Proses :Menggambarkan bujur sangkar }
{ Output : Bujur sangakr dengan awal Point bersisi Sisi berarah Arah
digambarkan }
Kamus
BS : BujurSangkar
procedure DrawSimpleRect (Input
L:real)
{ Menggambarkan bujur sangkar bersisi L }
{ I.S. : Pen=on, PosXy = P, Dir = Arah dari Bujur Sangkar
{ F.S : Pen= on, PosXy = P, Dir = Arah dari Bujur Sangkar
Algoritma :
input (BS)
Restart
SetDir (BS.Arah)
Move(BS.Point)
Down
DrawSimpleRect(BS.Sisi)
}
}
}
}
Kamus
C : BujurSangkar
Algoritma :
Repeat 4 times
Move(L)
Right (90.0)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 156 dr 217
procedure DrawTwoRect
{ Menggambarkan 2 bujur sangkar seperti pada Gb.; I.S. : Pen=on,
PosXy = P, Dir = Arah dari Bujur Sangkar, F.S : Pen= on, PosXy = P,
Dir =Arah dari Bujur Sangkar }
Kamus
Algoritma :
input (BS)
Restart
SetDir (BS.Arah); MoveTo(BS.Point)
Down
DrawSimpleRect(BS.Sisi); DrawSimpleRect(BS.Sisi/2)
N=1
N=2
N=3, dst
Program DrawRectN
{ Menggambarkan bujur sangkar bersisi L, dengan level N }
{I.S. : Pen=on, PosXy = P, Dir = Arah dari Bujur Sangkar data
{ F.S : Pen= on, PosXy =P, Dir = Arah dari Bujur Sangkar data
Kamus
BS : BujurSangkar
N : integer
procedure DrawRect (Input N : integer, L:real)
{ Menggambarkan bujur sangkar bersisi L, dengan level N }
{ I.S. : Pen=on, PosXy = P, Dir = Arah dari Bujur Sangkar data
{ F.S : Pen= on, PosXy = P, Dir =Arah dari Bujur Sangkar data
Algoritma :
input (BS,N)
Restart
SetDir (BS.Arah)
MoveTo(BS.Point)
Down
DrawRect(N, BS.Sisi)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 157 dr 217
}
}
}
}
}
}
MESIN REKAM
Mesin REKAM adalah mesin abstrak yang terdiri dari : pita dan tombol READY,
REG dan sebuah tombol MARKER.
Mesin rekam adalah mesin yang dipakai untuk merekam pita karakter yang akan
dibaca oleh mesin karakter.
READY
MAR
KER
REG
procedure MARKER
{Pita direkami dengan tanda akhir pita (mark).
I.S. : Karakter pada jendela = CC, CC '.'
F.S : CC '.', tombol MARKER diaktifkan. Mesin dimatikan
}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 158 dr 217
MESIN INTEGER
(PENCACAH)
Mesin integer adalah mesin abstrak yang terdiri dari : tombol RESET dan INC.
Seperti halnya mesin karakter, mesin ini sebuah jendela yang menunjukkan sebuah
angka integer yang diingatnya, yang disebut CI (Current Integer). Mesin ini berfungsi
sebagai pencacah bilangan integer.
RESET
RESET
INC
INC
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 159 dr 217
MESIN KARAKTER
(Model akses sekuensial)
Definisi
Mesin karakter adalah mesin abstrak yang terdiri dari :
- pita berisi deret karakter, yang diakhiri dengan '.' (titik); pita yang hanya berisi
'.' disebut sebagai pita kosong.
- tombol START, ADV
- sebuah Lampu EOP (End Of Pita)
- "jendela" yang ukurannya sebesar satu karakter, hanya karakter yang posisinya
sedang pada jendela dapat dikonsultasi (dibaca); karakter lain tidak kelihatan.
Karakter yang sedang pada jendela dinamakan CC (Current Character).
Mesin mempunyai mekanisme untuk mengubah posisi pita dan menyalakan lampu
EOP jika karakter yang ada pada jendela adalah titik. Keadaan (state)dari mesin setiap
saat ditentukan oleh CC dan lampu EOP. Tombol START dan ADV digunakan
untuk mengubah state mesin. Mesin hanya dapat dioperasikan jika EOP tidak
menyala.
CC
I T B
EOF
A D A
Sudah
Dibaca
START
ADV
Belum
Dibaca
CC
ADV
D I
I T B
A D A
D I
Sudah
Dibaca
START
EOF
ADV
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 160 dr 217
Catatan:
EOP diwakili oleh boolean, bernilai true jika menyala; atau false jika tidak menyala.
Jika EOP menyala, mesin sudah tidak dapat dioperasikan lagi.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 161 dr 217
F A I T
B E A U .
T .
.
Deretan aksi (penekanan tombol) pada kedua mesin untuk menghitung banyaknya
huruf pada pita:
1a)
START; RESET
{ CC='I', CI=0}
1b)
START ; RESET
ADV ; INC
{ CC='L', CI=1}
INC ; ADV
ADV ; INC
{ CC=' ', CI=2}
INC ; ADV
ADV ; INC
{ CC='F', CI=3}
INC ; ADV
ADV ; INC
{ CC='A', CI=4}
INC ; ADV
ADV ; INC
{ CC='I', CI=5}
INC ; ADV
ADV ; INC
{ CC='T', CI=6}
INC ; ADV
ADV ; INC
{ CC=' ', CI=7}
INC ; ADV
ADV ; INC
{ CC='B', CI=8}
INC ; ADV
ADV ; INC
{ CC='E', CI=9}
INC ; ADV
ADV ; INC
{ CC='A', CI=10}
INC ; ADV
ADV ; INC
{ CC='U', CI=11}
INC ; ADV
ADV ; INC
{ CC='.', CI=12}
INC ; ADV
2)
START; RESET
ADV ; INC
ADV ; INC
ADV ; INC
ADV ; INC
{ CC='Y', CI=0}
{ CC='A', CI=1}
{ CC=' ', CI=2}
{ CC=' ', CI=3}
{ CC='.', CI=4}
3)
START; RESET
ADV ; INC
{ CC='T', CI=0}
{ CC='.', CI=1}
4)
START; RESET
{ CC='.', CI=0}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 162 dr 217
Diskusi :
- Apa beda antara solusi 1a) dan 1b) ?
- Bagaimana mendeduksi iterasi dari deretan aksi di atas.
- Kesulitan penggunaan repeat n times pada ksus ini dibandingkan dengan kasus
algoritma BUJURSANGKAR, dimana iterasi dideduksi dengan mudah menjadi
repeat 4 times. Sebenarnya repeat N times bisa dipakai pada kasus ini, yaitu
dengan menghitung dulu banyaknya huruf, baru repeat sebanyak banyaknya
huruf. Tapi bodoh sekali!
- pengenalan notasi baru : skema iterasi (ingat : bukan loop sederhana seperti dalam
bhs pemrograman). Cukup diperkenalkan model dengan mark saja.
2.
COUNTHURUF
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong).
Buatlah algoritma untuk menghitung banyaknya huruf yang ada pada pita tsb.
dengan mesin integer. Banyaknya karakter pada pita kosong adalah nol
Program COUNTHURUF
{SKEMA PEMROSESAN DENGAN MARK : menghitung banyaknya huruf pada
pita karakter, memakai mesin pencacah}
Kamus:
Algoritma :
RESET
{ Inisialisasi , CI = 0 }
START
{First_Elmt}
while (CC '.') do
{ not EOP}
INCR
{Proses : CI = CI + 1 }
ADV {Next_Elmt}
{ CC = . }
Output (CI) {Terminasi}
3.
HITUNG-A
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong),
Buatlah algoritma untuk menghitung banyaknya huruf 'A' yang ada pada pita tsb.
dengan mesin integer.
Program COUNT_A
{SKEMA PEMROSESAN DENGAN MARK : menghitung banyaknya huruf A pada
pita karakter, memakai mesin pencacah}
Kamus:
Algoritma :
RESET
{ Inisialisasi , CI = 0 }
START
{First_Elmt}
while (CC '.') do
{ not EOP}
depend on CC
{Proses }
CC = 'A' : INCR
CC 'A' : ADV
{Next_Elmt}
{ CC = . }
Output (CI) {Terminasi}
Penjelasan :
1. Banyaknya karakter A pada pita kosong adalah nol.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 163 dr 217
Program COUNT_A-2
{SKEMA PEMROSESAN dengan penanganan kasus kosong}
{ memakai mesin pencacah }
Kamus:
Algoritma :
START
{First_Elmt}
depend on CC
CC = '.' : output (pita kosong}
CC '.' :
RESET
{ Inisialisasi , CI = 0 }
repeat
if ( CC = 'A' ) then
INCR
else { CC 'A' aksi kosong }
ADV
{Next_Elmt}
until CC ='.'
Output (CI) {Terminasi}
Penjelasan :
1. Banyaknya karakter A pada pita kosong tidak terdefinisi, karena itu pita kosong
ditangani secara khusus.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 164 dr 217
4.
FREKUENSI HURUF A
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong),
Buatlah algoritma untuk menghitung frekuensi relatif huruf 'A' yang ada pada pita
tsb., Frekuensi relatif huruf A adalah banyaknya huruf 'A' dibandingkan banyaknya
seluruh karakter yang ada pada pita karakter.
Program FREKA-1
{SKEMA PEMROSESAN dengan Mark, tanpa penanganan kasus kosong}
{ tidak memakai mesin pencacah, melainkan menyimpan dalam nama }
{ yang didefinisikan pada Kamus }
Kamus:
CPT_KAR : integer
CPTA : integer
Algoritma:
CPT_KAR
0
{ Inisialisasi }
CPTA
0
{ Inisialisasi }
START
{First_Elmt}
while (CC .) do
CPT_KAR CPT_KAR + 1
if (CC = 'A' ) then
CPTA
CPTA + 1
else
{ CC 'A' aksi kosong }
ADV
{Next_Elmt}
{ CC ='.' : semua karakter pada pita sudah dibaca, mungkin CPT_KAR = 0 }
{Terminasi}
if (CPT_KAR 0 ) then
Output (CPTA/CPT_KAR)
else {
CPT_KAR = 0 }
Output (Frekuensi tidak terdefinisi )
Penjelasan :
1. Banyaknya karakter A pada pita kosong tidak terdefinisi.
2. Banyaknya karakter pada pita kosong adalah nol
3. Perhatikan invarian CC, CPTA dan CPT_KAR yang selalu benar
4. Pembagian dengan nol dihindarkan dengan analisis kasus pita kosong atau tidak
pada bagian TERMINASI.
5. Program benar, tapi pemilihan skema kurang tepat
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 165 dr 217
Program FREKA-2
{SKEMA PEMROSESAN dengan Mark, dengan penanganan kasus kosong}
{ tidak memakai mesin pencacah }
Kamus:
CPT_KAR : integer
CPTA : integer
Algoritma:
START
{First_Elmt}
if (CC = '.') then
output (Pita kososng}
else {CC '.' }
CPT_KAR
0
{ Inisialisasi }
CPTA
0
{ Inisialisasi }
repeat
CPT_KAR CPT_KAR + 1
if (CC = 'A' ) then
CPTA
CPTA + 1
{ else {CC '.' =>do nothing }
ADV
{Next_Elmt}
until (CC ='.')
Output (CPTA/CPT_KAR)
Penjelasan :
1. Banyaknya karakter A pada pita kosong tidak terdefinisi.
2. Banyaknya karakter pada pita kosong adalah nol
3. Jika kasus kosong tidak ditangani secara khusus, maka akan terjadi pembagian
dengan nol.
4. Pemilihan skema lebih baik dari pada versi pertama
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 166 dr 217
5.
HITUNG-LE
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong),
Buatlah algoritma untuk menghitung banyaknya pasangan dua huruf 'LE' yang
ada pada pita tsb.
Versi 1:
Realisasi dengan membuat mesin "couple" yaitu mesin yang mampu untuk
menampilkan dua karakter sekaligus berdasarkan mesin karakter. Couple adalah
dua buah karakter berturutan (suksesif) yang meuncul pada pita.
Program COUNTLE-1
{SKEMA PEMROSESAN DENGAN MARK}
{ Solusi 1 : Mesin COUPLE}:
Kamus:
CPTLE : integer { banyaknya 'LE' pada bagian pita yang sudah dibaca }
C1,C2 : character {C1,C2 adalah Couple }
procedure
START-COUPLE
{ mendapatkan couple yang pertama }
{ I.S. : sembarang }
{ F.S. : Couple pertama terbentuk: C1 = ' ', C2 = CC , CC mungkin ='.'}
procedure ADV-COUPLE
{ next-couple }
{ I.S. : C1 dan C2, C2 '.'}
{ F.S. : C1 = C2, C2 = CC , CC mungkin = '.' }
Algoritma :
START-COUPLE
{First_Elmt}
CPTLE
0
while (CC '.') do {not End-Couple}
if (C1 = 'L' and C2 ='E') then
CPTLE
CPTLE + 1 {couple LE}
{else: C1 'L' or C2 'E' : - }
ADV-COUPLE
{Next_Elmt}
Output (CPTLE) {Terminasi}
procedure START-COUPLE
{SKEMA PEMROSESAN DENGAN MARK, Solusi 1: Mesin COUPLE}:
{ I.S. : sembarang }
{ F.S. : Couple pertama terbentuk : C1 = ' ', C2 = CC ,
'.' }
Kamus:
Algoritma :
C1
' '
START
C2
CC mungkin =
CC
procedure ADV-COUPLE
{SKEMA PEMROSESAN DENGAN MARK, Solusi 1: Mesin COUPLE}:
{ I.S. : C1 dan C2, C2 '.'}
{ F.S. : C1 = C2, C2 = CC , CC mungkin = '.' }
Kamus:
Skema :
C1
ADV
C2
C2
CC
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 167 dr 217
Penjelasan :
1. Solusi ini memakai Hitung A sebagai pola solusi. Pada solusi ini, couple LE
analog dengan sebuah huruf A.
2. Banyaknya LE pada pita kosong adalah nol.
3. Banyaknya LE pada pita dengan satu karakter adalah nol.
4. Banyaknya LE pada pita yang tidak mengandung dua huruf suksesif LE adalah
nol. Dalam hal ini tidak dapat dibedakan antara nilai nol pada pita kosong, pita
satu karakter atau untuk pita yang tidak mengandung LE
5. Perhatikan pendefinisian couple yang pertama : C1= Blank dan C2 = huruf
pertama pada pita. Couple pertama ini merupakan couple yang dibuat berdasarkan
definisi pemrogram, bukan merupakan couple yang sesungguhnya muncul pada
pita.
6. Buatlah solusi dengan mengambil couple pertama yang muncul pada pita adalah
benar-benar dua karakter pertama pada pita. Solusi ini mengharuskan akses
terhadap karakter pertama pita. Jika pita kosong atau mengandung hanya satu
karakter, maka pita couple akan merupakan pita kosong (couple pertama tidak
terdefinisi).
7. Solusi dengan pendefinisian couple pertama bukan dari pita bukan solusi yang
ideal, namun praktis. Harap hati-hati dengan pemberian harga yang bukan
berasal dari pita yang diberikan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 168 dr 217
HITUNG-LE, versi 2 :
Idenya adalah mengingat-ingat jika menemukan 'L', dan memeriksa karakter yang
selanjutnya. Di sini tidak dibentuk mesin abstrak lain seperti pada solusi 1.
Program COUNTLE2
{SKEMA PEMROSESAN DENGAN MARK}
{ Solusi 2: Memorisasi satu karakter sebelum karakter yang ada di
jendela}
Kamus:
CPTLE : integer { banyaknya 'LE' pada bagian pita yang sudah dibaca}
Prec-Is-L : boolean
{ true jika karakter sebelum CC adalah 'L'}
Algoritma :
Prec-Is-L
false
{Inisialisasi}
CPTLE
0
{Inisialisasi}
START
{First_Elmt}
while ( CC '.' ) do
Prec-Is-L CC = 'L'
ADV
{Next_Elmt}
if (CC = 'E' and Prec-Is-L) then
CPTLE CPTLE + 1
Output (CPTLE) {Terminasi}
Penjelasan :
1. Solusi ini bukan mengambil pola Hitung A.
2. Banyaknya LE pada pita kosong adalah nol.
3. Banyaknya LE pada pita dengan satu karakter adalah nol.
4. Banyaknya LE pada pita yang tidak mengandung dua huruf suksesif LE adalah
nol. Dalam hal ini tidak dapat dibedakan antara nilai nol pada pita kosong, pita
satu karakter atau untuk pita yang tidak mengandung LE
5. Prec-Is-L adalah sebuah boolean, dapat pula direpresentasi dengan sebuah nama
bertype character, yang setiap saat berisi nilai huruf yang muncul sebelum
karakter pada jendela. Inisialisasi untuk CC = karakter pertama pada pita menjadi
persoalan yang sama dengan versi-1
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 169 dr 217
HITUNG-LE versi- 3 :
Idenya adalah maju terus sampai menemukan 'L', dan memeriksa karakter yang
berikutnya
Program COUNTLE-3
{SKEMA PEMROSESAN DENGAN MARK}
{ Solusi 3: majukan pita sampai ketemu L, periksa karakter
berikutnya.
Proses ini diulang sampai seluruh karakter selesai diproses}:
Kamus:
CPTLE : integer { banyaknya 'LE' pada bagian pita yg sudah dibaca}
Algoritma :
CPTLE
0
{Inisialisasi}
START
{First_Elmt}
while (CC '.') do
{ Cari sampai ketemu L, namun mungkin ketemu . }
while (CC 'L') and (CC
'.') do
ADV
{ CC ='L' or CC='.' }
if( CC = 'L') then
ADV { Boleh ADV, karena CC bukan . }
If (CC='E') then CPTLE
CPTLE + 1
{else: CC 'L' : - }
{ CC = ., seluruh karakter pada pita sudah dibaca }
Output (CPTLE) {Terminasi}
Penjelasan :
1. Solusi ini berdasarkan pencarian karakter L pada pita, dan memeriksa karakter
sesudahnya. Jika karakter pada jendela = L, pasti pita belum berada pada mark;
karena itu boleh ADV
2. Banyaknya LE pada pita kosong adalah nol.
3. Banyaknya LE pada pita dengan satu karakter adalah nol.
4. Banyaknya LE pada pita yang tidak mengandung dua huruf suksesif LE adalah
nol. Dalam hal ini tidak dapat dibedakan antara nilai nol pada pita kosong, pita
satu karakter atau untuk pita yang tidak mengandung LE.
5. Solusi ini bukan merupakan skema sekuensial dengan mark yang murni.
Perhatikan modifikasi yang dilakukan, dan test setiap kali hendak dilakukan ADV.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 170 dr 217
EKSPRESI ARITMATIKA
Diberikan sebuah mesin karakter dengan pita berisi karakter yang hanya terdiri
dari karakter angka '0'..'9', blank dan diakhiri titik. Teks pada pita dapat
diinterpretasikan sebagai sebuah ekspresi aritmatika dalam bentuk notasi infix :
operan1 operator operan2. Antara operan1 dan operator atau antara operator dan
operan2 boleh dipisahkan oleh 1 blank atau lebih dari satu blank. Demikian pula,
sebelum operan1 dan sesudah operan2 boleh ada satu atau beberapa blank.
Operan1 dan operan2 terdiri dari sederetan angka yang dijamin masih dalam batas
perhitungan mesin pengeksekusi algoritma. Operan2 tidak mungkin nol Operator
adalah salah satu dari empat operator aritmatika sebagai berikut : '*', ':', '+', '-' yang
artinya pengali, pembagi, penjumlah, pengurang dua bilangan integer menjadi
bilangan integer. Dijamin bahwa ekspresi pada pita tidak mengandung kesalahan
sintaks dan pita tidak mungkin kosong karena pasti mengandung sebuah ekspresi.
Program EKSPRESIARITMATIKA
{ spesifikasi : lihat persoalan }
Kamus:
constant Blank : character =' '
{karakter "blank" }
constant Mark : character ='.'
{karakter "titik" }
CC : integer
Operan1,Operan2 : integer
Operator : character
Hasil : integer
procedure Getoperand (Output Operan:integer) {mengambil operan}
{ I.S. : CC adalah karakter pertama operan }
{ F.S. : CC bukan angka,
CC adalah Blank atau salah satu karakter berikut :
'.' , '*', '+', '-', ':' }
{
dan operan berisi hasil harga operan integer }
procedure Ignore_Blank {mengabaikan satu atau beberapa Blank}
{ I.S. : CC sembarang }
{ F.S. : CC bukan blank,
CC adalah karakter angka atau salah satu karakter sbb :
'.' , '*', '+', '-', ':' }
Algoritma:
START
{First_Elmt}
{pita tidak mungkin kosong }
Ignore_Blank
{ CC = karakter pertama operan1}
GetOperan(Operan1)
{ CC = karakter Blank sesudah operan1}
Ignore_Blank
{ CC = operator }
Operator CC
ADV
Ignore_Blank
{ CC = karakter pertama operan2}
GetOperan (Operan2)
{ CC = Mark atau Blank, tidak peduli, sisa pita tidak diproses}
{ Hitung ekspresi }
depend on Operator
Operator = '*' : Hasil Operan1 * Operan2
Operator = '+' : Hasil Operan1 + Operan2
Operator = '-' : Hasil Operan1 - Operan2
Operator = ':' : Hasil Operan1 div Operan2
Output (Hasil)
{Terminasi}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 171 dr 217
1. Skema "while" yang dipakai pada prosedur GetOperand kurang tepat. Pelajarilah,
dan usulkan bentuk pengulangan yang lebih baik.
2. Bagaimana jika ekspresi mengandung kesalahan ? Deskripsikan kesalahan yang
mungkin terjadi dan penanganannya. Perhatikan bahwa algoritma akan menjadi
jauh lebih rumit.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 172 dr 217
Versi 1 :
Akhir dari proses adalah sebuah boolean, yang akan berisi true jika kata terakhir
telah diakuisisi dan diproses . Kata diakuisisi mulai dari karakter pertama sesudah
akhir kata (atau karakter pertama pita untuk kata pertama). Akuisisi kata terakhir
menghasilkan 'kata kosong'
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 173 dr 217
Program PANJANGRATAKATA1
{Versi 1 : SKEMA PEMROSESAN tanpa penanganan kasus kosong}:
Kamus:
constant Mark : character = ' .'
constant Blank : character = ' '
LKata : integer { panjang kata terakhir yang susah diakuisis}
NbKata : integer
( banyaknya kata pada pita}
LTotal : integer { akumulasi panjang kata }
EndKata : boolean {true jika kata terakhir sudah diakuisisi }
procedure Ignore_Blank: {mengabaikan satu atau beberapa blank}
{ I.S. : CC adalah sembarang}
{ F.S. : CC Blank, atau CC=mark}
procedure HITUNGPANJANG {menghitung panjang kata}
{ I.S. : CC adalah karakter pertama dari kata }
{ F.S. : CC=blank, atau CC = mark; CC adalah karakter sesudah huruf
terakhir kata yang diakuisisi ;
LKata berisi panjang kata yang sudah diakuisisi }
procedure STARTKATA {mengabaikan satu atau beberapa blank}
{ I.S. : CC sembarang }
{ F.S. : EndKata true, dan CC = mark; }
{
atau EndKata=false, LKata adalah panjang kata yang sudah
diakuisisi, CC karakter pertama sesudah karakter terakhir kata}
procedure ADVKATA {mengabaikan satu atau beberapa blank}
{I.S. : EndKata = false; CC adalah karakter sesudah karakter terakhir
dari kata yg sudah diakuisisi }
{ F.S. : EndKata true, dan CC = mark; }
{
atau EndKata=false, LKata adalah panjang kata yang sudah
diakuisisi, CC karakter pertama sesudah karakter terakhir kata}
Algoritma :
LTotal
0
NbKata 0
STARTKATA
while
not EndKata do
LTotal
LTotal + LKata
NbKata NbKata + 1
ADVKata
{EndKata => semua karakter sudah diakuisisi }
if (NbKata 0 ) then
Output (LTotal/NbKata)
else { NbKata = 0 }
Output ('Pita tidak mengandung kata')
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 174 dr 217
procedure HITUNGPANJANG
{menghitung panjang kata}
{I.S. : CC adalah karakter pertama dari kata,CC Blank dan CC Mark}
{ F.S. : CC=Blank, atau CC = Mark; CC adalah karakter sesudah huruf
terakhir kata yang diakuisisi ;
LKata berisi panjang kata yang
sudah diakuisisi.}
Kamus:
Algoritma :
LKata 1
{karena berada pada karakter pertama pita }
iterate
ADV
stop : (CC=Mark) or (CC= Blank)
LKata LKata + 1
{(CC=Mark)or(CC= Blank): Lkata = banyaknya karakter kata yang diakuisisi}
EndKata
true
EndKata
false
HitungPanjang
EndKata
true
HitungPanjang
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 175 dr 217
Program PANJANGRATAKATA2
Kamus:
constant
Mark :
constant Blank :
LKata : integer {
NbKata : integer
LTotal : integer{
LTotal + LKata;
NbKata NbKata + 1
ADVKata
{ Lkata = 0
==> mark }
depend on NbKata
NbKata
0 : Output (LTotal/NbKata)
NbKata = 0 :
Output ('Pita tidak mengandung kata')
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 176 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 177 dr 217
Initakses
Program PANJANGRATAKATA3
{Versi 3 : SKEMA PEMROSESAN tanpa Mark}
Kamus:
constant
Mark : constant character = ' .'
constant
Blank : constant character = ' '
LKata : integer
{ panjang kata terakhir yang susah diakuisisi}
NbKata : integer
( banyaknya kata pada pita}
LTotal : integer { akumulasi panjang kata }
procedure Ignore_Blank {mengabaikan satu atau beberapa Blank}
{ I.S. : CC adalah sembarang }
{ F.S. : CC Blank, atau CC=Mark}
procedure HITUNGPANJANG {menghitung panjang kata}
{ I.S. : CC adalah karakter pertama dari kata }
{ F.S. : CC=Blank, atau CC = Mark; CC adalah karakter sesudah huruf
terakhir kata yang diakuisisi ;
LKata bebisi panjang kata yang sudah
diakuisisi }
procedure INITAKSES {mengabaikan satu atau beberapa Blank pada awal pita}
{ I.S. : CC sembarang }
{ F.S. : CC = Mark; atau CC = karakter pertama dari kata yang akan
diakuisisi}
procedure ADVKATA {mengabaikan satu atau beberapa Blank}
{ I.S. : CC adalah karakter pertama kata yg akan diakuisisi }
{ F.S. : LKata adalah panjang kata yang sudah diakuisisi, CC karakter }
{
pertama .pertama kata yang berikutnya, mungkin Mark}
Algoritma :
INITAKSES
LTotal
0
NbKata 0
while
( CC Mark) do
ADVKata
LTotal
LTotal + LKata;
NbKata NbKata + 1
depend on NbKata
NbKata 0 : Output (LTotal/NbKata)
NbKata = 0 :
Output ('Pita tidak mengandung kata')
Penjelasan:
Pada skema di atas, yang menggunakan WHILE, ADVKata dilakukan sebelum
proses (bukannya sesudah proses). Hal ini disebabkan karena akuisisi kata
dilakukan di dalam badan pengulangan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 178 dr 217
procedure
Ignore_Blank {mengabaikan satu atau beberapa Blank}
{ I.S. : CC adalah sembarang }
{ F.S. : CC Blank, atau CC=Mark}
Kamus:
Algoritma :
{I.S. : CC sembarang}
while
(CC =Blank) and (CC
Mark) do
ADV
{F.S: CC Blank or CC = Mark }
procedure INITAKSES
{mengabaikan satu atau beberapa Blank pada awal pita}
{ I.S. : CC sembarang }
{ F.S. : CC = Mark; atau CC = karakter pertama dari kata yang akan
diakuisisi}
Kamus:
Algoritma :
START
Ignore_Blank
procedure ADVKATA
{mengabaikan satu atau beberapa Blank}
{ I.S. : CC adalah karakter pertama kata yg akan diakuisisi
{ F.S. : LKata adalah panjang kata yang sudah diakuisisi, CC
karakter pertama kata yang berikutnya, mungkin Mark}
Kamus:
Algoritma :
HitungPanjang
Ignore_Blank
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 179 dr 217
Latihan Soal
HURUF HIDUP
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong),
hitunglah:
- banyaknya kemunculan huruf hidup yang muncul pada pita tersebut.
- frekuensi huruf hidup
- banyaknya kemunculan setiap huruf hidup.
Definisikanlah dengan jelas apa yang dimaksud dengan huruf hidup.
HURUF MATI
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong)
hitunglah:
- banyaknya kemunculan huruf mati yang muncul pada pita tersebut.
- frekuensi huruf mati
- banyaknya kemunculan setiap huruf mati.
Definisikanlah dengan jelas apa yang dimaksud dengan huruf mati.
HURUF HIDUP muncul lebih sedikit dari Huruf MATI
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong)
periksalah apakah banyaknya huruf hidup yang muncul pada pita tersebut lebih
sedikit daripada hurufmati yang muncul. Definisikanlah dengan jelas apa yang
dimaksud dengan huruf hidup
HITUNG-KATA
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong).
Buatlah algoritma untuk menghitung banyaknya KATA yang ada pada pita tsb.
Mula-mula, anda harus mendefinisikan apa itu KATA Definisi : kata adalah
pasangan :
C1,C2, dengan C1 =sembarang huruf and C2 = ' ', atau
C1,C2, dengan C1 =sembarang huruf and C2 = '.'
Selanjutnya, tuliskanlah algoritmanya berdasarkan ide ini dari contoh-contoh di atas
KATABERAKHIRS
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong),
Buatlah algoritma untuk menghitung banyaknya KATA yang diakhiri 'S', yang ada
pada pita tsb.
Definisi : kata yang diakhiri S adalah pasangan yang terdiri dari 3 karakter:
C1,C2,C3 dengan C1 = sembarang, C2 = S dan C3 ' ', atau
C1,C2,C3 dengan C1 = sembarang, C2 = 'S' dan C3 '.'
Selanjutnya, tuliskanlah algoritmanya berdasarkan ide ini dari contoh-contoh di atas.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 180 dr 217
SUPPRESSBLANK
Diberikan sebuah mesin karakter dengan pita berisi karakter (mungkin kosong),
Buatlah algoritma untuk menghilangkan BLANK yang berlebihan. BLANK yang
berlebihan adalah :
- satu atau lebih BLANK sebelum huruf pertama yang bukan BLANK
- satu atau lebih BLANK sesudah huruf terakhir yang bukan BLANK
- lebih dari satu BLANK di antara dua buah kata.
KONVERSI
EKSPRESI ARITMATIKA
a. Pada persoalan ekspresi aritmatika pada contoh di atas, ingin pula disertakan
prosedur penanganan kesalahan. Kesalahan apa saja yang mungkin terjadi, dan
bagaimana program anda menanganinya ? Buatlah spesifikasinya.
b. Pada ekspresi di atas, operator dan operan bukan hanya terdiri dari satu karakter.
Operan boleh berupa NAMA (deretan karakter) dan setiap nama mempunyai nilai.
Ketika perhitungan ekspresi, yang dipakai adalah nilainya. Buatlah spesifikasi dan
modifikasilah program evaluasi ekspresi aritmatika yang diberikan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 181 dr 217
Latihan soal menggunakan mesin karakter dan mesin kata, untuk memroses
teks karakter demi karakter :
1. Buatlah sebuah program yang menghitung banyaknya kemunculan kata ketiga
(jika ada).
2. Buatlah sebuah program yang mencetak kata terpanjang dan yang terpendek serta
kemunculannya.
3. Buatlah sebuah program yang membuat statistik seperti yang dibuat oleh MS
Word : pages, characters (no spaces), characters (including spaces), Words, lines,
paragraph.
4. Buatlah browser sederhana (yang menampilkan teks dan mengolah tag).
Latihan soal menggunakan mesin karakter dan mesin kata, untuk memproses
source code
1. Buatlah sebuah program yang memeriksa apakah blok dalam sebuah program
Pascal seimbang (beres)
2. Buatlah sebuah program yang memeriksa apakah blok dalam sebuah program C
seimbang (beres)
3. Buatlah sebuah program yang mencetak semua nama type, nama konstanta dan
nama variabel yang muncul dalam sebuah program bahasa Pascal yang hanya
mengandung program utama, dan programmernya disiplin untuk menuliskan
semua variabel setelah kata VAR, semua type setelah kata TYPE dan semua
konstanta setelah kata CONST.
4. Prasyarat untuk membuat soal ini : anda harus mempunyai pemahaman yang
sedikit tentang "tag" HTML :
Buatlah sebuah program yang menerima input sebuah file HTML dan
menampilkan teksnya tanpa tag (membuang semua tag).
Buatlah sebuah program yang mencek apakah sebuah file HTML adalah file
HTML yang valid (tagnya seimbang).
Buatlah daftar tag yang muncul dalam sebuah file HTML.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 182 dr 217
HITUNG WHILE
Diberikan suatu pita katakter yang hanya mengandung abjad, blank dan diakhiri
titik, harus dicari kemunculan kata 'while' pada pita tersebut.
Didefinisikan sebuah type :kata : < TabKata : array[1..50] of character ,
Length : integer>
dan sebuah fungsi KataSama yang menerima masukan Kata1 dan Kata2 yang
bertype kata dan mengirimkan 'true' jika kedua kata sama, atau mengirimkan false
jika kedua kata tidak sama.
Solusi yang diberikan di bawah ini memakai model akuisisi kata tanpa mark,
seperti pada Versi 3 soal menghitung panjang kata rata-rata pada bab Mesin
karakter. Prosedur menghitung panjang kata diadaptasi untuk mengakuisisi kata.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 183 dr 217
Program HITUNGWHILE
{Menghitung kemunculan 'WHILE' pada suatu pita karakter}:
Kamus:
constant Mark : character = ' .'
constant Blank : character = ' '
constant NMax :
integer = 50{jumlah maksimum karakter pada satu kata}
type Kata : < TabKata : array [1..NMax] of character ,
Length: integer
>
KataWHILE : Kata{ kata yang menyimpan 'while' }
CurrentKata : Kata { kata terakhir sudah diakuisisi ,
siap dibandingkan dg Kata WHILE}
Nwhile : integer {banyaknya while pada pita }
procedure Ignore_Blank {mengabaikan satu atau beberapa Blank}
{ I.S. : CC adalah sembarang }
{ F.S. : CC Blank, atau CC=Mark}
procedure INITAKSES: {mengabaikan satu atau beberapa Blank pada awal pita}
{ I.S. : CC sembarang }
{ F.S. : CC = Mark; atau CC = karakter pertama dari kata yang akan
diakuisisi}}
procedure ADVKATA (Output CKata : Kata)
{ I.S. : CC adalah karakter pertama kata yg akan diakuisisi }
{ F.S. : CKata adalah kata terakhir yang sudah diakuisisi, CC karakter }
{
pertama dari kata yang berikutnya, mungkin Mark}
function KataSama (Kata1,Kata2:Kata) boolean
{ true jika Kata1 sama dengan Kata2, false jika tidak}
Algoritma :
{ Inisialisasi kata 'while ' }
KataWhile.Length 5
KataWhile.TabKata 1 'w'
KataWhile.TabKata 2 'h'
KataWhile.TabKata 3 'i'
KataWhile.TabKata 4 'l'
KataWhile.TabKata 5 'e'
NWhile
0
INITAKSES
while ( CC Mark) do
ADVKata (CurrentKata)
if ( KataSama(KataWhile,CurrentKata)
NWhile
NWhile + 1
output (Nwhile)
) then
procedure INITAKSES
{mengabaikan satu atau beberapa Blank pada awal pita}
{ I.S. : CC sembarang }
{ F.S. : CC = Mark; atau CC = karakter pertama dari kata yang akan
diakuisisi}
Kamus:
Algoritma :
START
Ignore_Blank
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 184 dr 217
Algoritma :
i 1
iterate
CKata.TabKata i CC
ADV
stop : (CC=Mark) or (CC= Blank)
i i + 1
{ CC = Mark or CC=Blank }
CKata.Length i
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 185 dr 217
Catatan :
Pada solusi di atas, jika panjang kata melebihi ukuran tabel, maka program akan
salah. Untuk menangani hal ini, algoritma harus dikoreksi
procedure SALINKATA1(Output CKata:kata)
{mengakuisisi kata, menyimpan dalam CKata}
{ I.S. : CC adalah karakter pertama dari kata }
{ F.S. : CC=Blank, atau CC = Mark; CC adalah karakter sesudah huruf
terakhir kata yang diakuisisi ; CKata berisi kata yang sudah
diakuisisi, Jika banyaknya karakter melebihi Nmax, sisa kata
dibuang }
Kamus:
i : integer
Algoritma :
i
iterate
CKata.TabKata
CC
ADV
stop : (CC=Mark) or (CC= Blank) or (i=NMax)
i
i + 1
{ CC = Mark or CC=Blank }
{(CC=Mark) or (CC= Blank) or (i=NMax)}
CKata.Length
if (i=NMax) then
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 186 dr 217
Algoritma :
depend on Kata1.Length, Kata2.Length
Kata1.Length Kata2.Length :
false
Kata1.Length =Kata2.Length :
i
+ 1
{ i=Kata1.Length) or (Kata1.TabKatai
(Kata1.TabKatai = Kata2.TabKatai
Kata2.TabKatai}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 187 dr 217
PALINDROM
Tuliskanlah sebuah fungsi yang menerima masukan sebuah kata yang
direpresentasi dalam array, memeriksa apakah kata itu PALINDROM dan
mengirimkan sebuah harga boolean (true jika kata tsb palindrom, false jika tidak.
Palindorm artinya kata yang jika dibaca dari kiri ke kanan atau kanan ke kiri sama
saja.
Contoh Palindrom :
ANA
NABABAN
KASUR RUSAK
KASUR NABABAN RUSAK
boolean
Kamus:
i,j : integer
Algoritma :
i
1
j
K.Length
while (i < j) and (K.TabKatai = K.TabKatai ) do
i
i + 1
j
j - 1
{ i = j or K.TabKatai K.TabKatai
}
(K.TabKatai
K.TabKataj)
Catatan :
1. Perhatikan bahwa persoalan Palindrom dapat diselesaikan dengan yang pernah kita
lakukan: salin kata ke sebuah kata sementara, kemudian pakai fungsi KataSama
untuk memeriksa kata asal dengan kata yang tersimpan pada kata temporer.
2. Solusi yang diambil pada algoritma di atas adalah solusi dengan menggunakan
sebuah kata logik yang mempunyai urutan akses mundur
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 188 dr 217
Latihan Soal
1. SKIPSEPARATOR
Dibaca sebuah pita dari mesin karakter yang diakhiri titik dan maksimum terdiri
dari 50 karakter (termasuk titik). Karakter yang dibaca itu harus dituliskan kembali
dengan urutan terbalik. Tuliskanlah algoritmanya
Contoh : Jika dibaca AKU ANAK DESA. maka akan ditulis ASED KANA UKA
3. FREKUENSI KATA PERTAMA
Dibaca sebuah pita dari mesin karakter yang diakhiri titik. Hitunglah frekuensi
kemunculan kata pertama dalam pita tersebut. Catatan : definisikan dulu apa yang
dimaksud dengan kata. Andaikata teks selalu dalam bahasa Indonesia, dan kata
terpanjang dalam bahasa Indonesia terdiri dari 35 karakter. Contoh : aku pergi
kepasar kemudian aku pulang ke rumah supaya aku dapat mandi. Output :
Frekuensi 'aku' adalah 3/12
4. ANAGRAM
Tuliskanlah sebuah fungsi yang menerima masukan dua buah kata yang
direpresentasi dalam array, memeriksa apakah kedua kata itu ANAGRAM dan
mengirimkan sebuah harga boolean (true jika kedua kata anagram, false jika tidak).
Kata dikatakan Anagram jika terdiri dari huruf yang sama.
Contoh : SEBAB dan BEBAS adalah anagram
BAGUS dan GABUS adalah anagram
SUPER dan PUSER adalah anagram.
5. HITUNG WHILE
Tuliskan kembali algoritma menghitung while jika pita karakter adalah sebuah
sorce program dalam bahasa Pascal yang tidak mengandung kesalahan sintaks
(teks mengandung karakter-karakter lain selain abjad, dan separator antara 'kata'
bukan hanya blank!). Bagaimana jika program mengandung kesalahan sintaks ?
6. TELEGRAM
Diberikan sebuah pita karakter yang diakhiri titik yang berisi telegram, yaitu
deretan abjad berupa kata atau kata yang mewakili tanda baca, dipisahkan blank
dan diakhiri dengan kata STOP, harus dihitung tarif telegram. Tarif telegram
ditentukan oleh banyaknya kata yang muncul, sedangkan kata yang mewakili tanda
baca tidak dihitung.
Contoh :
Teks
Jumlah Kata
SEGERA PULANG KOMA NENEK SAKIT TITIK STOP.
APA KABAR SAYA SENANG STOP.
HAI STOP.
4
4
1
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 189 dr 217
SEQUENTIAL FILE
Definisi
Sequential file (Arsip sekuensial) adalah sekumpulan rekaman yang disimpan dalam
media penyimpanan sekunder komputer, yang dapat diakses secara sekuensial mulai
dari rekaman pertama sampai dengan rekaman yang terakhir, rekaman per
rekaman secara searah. Rekaman terakhir adalah rekaman fiktif, yang menandai
akhir dari arsip. Pada beberapa implementasi, rekaman fiktif ini disebut sebagai EOF
(End Of File). Arsip sekuensial berasal dari hasil perekaman (penulisan) yang juga
dilakukan rekaman per rekaman.
Setiap rekaman boleh berisi type dasar ataupun type terstruktur yang telah
didefinisikan, setiap rekaman strukturnya sama. Elemen dari rekaman disebut sebagai
"field", ada field (atau juga sekumpulan field) rekaman yang disebut sebagai "key"
karena kekhususannya dalam proses. Jika key dari setiap rekaman tidak ada yang
sama (unik), maka key menjadi identitas rekaman, dan disebut "primary key".
Setiap rekaman dapat diakses dan dikonsultasi (dibaca) menurut urutannya dengan
pemanggilan primitif akses yang tersedia. Perekaman dapat dilakukan melalui primitif
penulisan. Perhatikan bahwa suatu arsip sekuensial hanya dapat disiapkan hanya pada
salah satu modus operasi: diakses/dibaca, atau ditulis. Dalam definisi arsip
sekuensial, tidak pernah sebuah arsip diproses untuk kedua modus: dibaca dan
sekaligus ditulis. Primitif-primitif tsb, akan didefinisikan kemudian.
MARK
Rekaman Terakhir
Rekaman Kedua
Urutan Akses
(satu per satu)
Rekaman Pertama
Cara pendefinisian :
type rekaman : <.........> sebuah type terdefinisi untuk setiap rekaman
NamaArsip : SEQFILE of
(*) <nama_rek>: rekaman
(1) <mark>
Dengan catatan bahwa (*) mungkin kosong, 1 rekaman atau lebih.
Domain setiap rekaman : sesuai dengan domain masing-masing rekaman
Konstanta : sebuah rekaman
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 190 dr 217
Catatan:
Pada beberapa pemroses bahasa, primitif ASSIGN diberikan dalam teks algoritma,
dan dalam beberapa pemroses bahasa pemrograman yang lain diberikan di luar
program (pada Job Control Language). Pada teks algoritma di buku ini, perintah
ASSIGN tidak diberikan di dalam teks algoritma
procedure OPEN (Input NamaArsip, <rekaman>)
{ Arsip sekuensial siap dibaca Rekaman pertama yang informasinya ada
pada <rekaman> dapat diakses.
I.S. sembarang
F.S : informasi pada rekaman pertama siap diakses, dengan mengacu
kepada <rekaman>
}
procedure READ (Input NamaArsip, <rekaman>)
{ Rekaman sesudah rekaman yang sedang "Current", yang dapat diakses.
I.S. :
<rekaman> bukan merupakan mark, sebut sebagai
Current_Rekaman
F.S : Arsip dimajukan satu rekaman, <rekaman> berisi informasi yang
disimpan pada rekaman sesudah Current_Rekaman. Mungkin
<rekaman> yang baru adalah mark
}
procedure CLOSE (Input NamaArsip)
{ Arsip sekuensial s"ditutup", tidak dapat diakses maupun ditulisi
lagi.
I.S. : sembarang
F.S : Arsip tidak dapat diproses lagi
}
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 191 dr 217
Contoh1 :
Sebuah arsip sekuensial berisi data mahasiswa, yang setiap rekamannya memuat data
NIM, Nama dan Nilai akhir mahasiswa.. Maka dapat dituliskan :
type rekaman : < NIM:integer, Nama : string, Nilai :integer [0..100]>
ArsipMhs : SEQFILE of
(*) RekMhs : rekaman
(1) <9999999, '',0>
Domain setiap rekaman : sesuai dengan domain masing-masing rekaman
Konstanta : sebuah rekaman, misalnya :
<7473001,'Juliette',95>
<8690022,'Laura',80>
Cara akses rekaman pertama :
OPEN (ArsipMhs, RekMhs)
Cara akses : { NIM 9999999 } READ (ArsipMhs, RekMhs )
Cara menyiapkan untuk direkam : REWRITE (ArsipMhs)
Cara mengisi :
WRITE (ArsipMhs, RekMhs )
{Harga Current }
WRITE(ArsipMhs, <7473002,'Davy Rindt',96>) { konstanta }
WRITE(ArsipMhs, Rek1) { Rek1 bertype rekaman }
Cara mengisi akhir rekaman :
Contoh2 :
Sebuah arsip sekuensial berisi teks, maka setiap rekamannya adalah satu karakter.
Misalnya MARK adalah ' #'
type rekaman : character
Dokumen :SEQFILE of
(*) CC : rekaman
(1) <'#'>
Domain setiap rekaman : character
Konstanta : sebuah rekaman, misalnya :
<'A'>
<'0'>
<'#'>
Cara akses rekaman pertama :
OPEN (Dokumen, CC)
Cara akses : { CC '#' } READ (Dokumen, CC)
Cara menyiapkan untuk direkam : REWRITE (Dokumen>)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 192 dr 217
Cara mengisi :
Program NILAIRATA_RATA
{model proses sekuensial dengan mark,
dengan penanganan kasus kosong}:
Kamus:
type rekaman : < NIM : integer, nilai:integer [0..100] >
ArsipMhs : SEQFILE of
(*) RekMhs : rekaman { setiap mahasiswa punya 1 rekaman }
(1) <9999999, 99>
SumNil : integer { jumlah nilai}
JumMhs: integer { jumlah mahasiswa }
Algoritma :
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 193 dr 217
Algoritma Konsolidasi
Didefinisikan sebuah sequential file yang terurut, arsip tersebut mengandung
kelompok-kelompok data dengan kunci sama yang harus diproses sebagai satu
kesatuan. Ada dua model arsip semacam ini :
1. Tanpa separator, artinya kita mengenali adanya kelompok yang lain karena kunci
berubah,
MARK
Urutan Akses
(satu per satu)
2. Dengan separator, artinya ada rekaman tertentu yang memisahkan satu kelompok
dan kelompok lainnya. Separator ini boleh satu rekaman atau lebih dari satu rekaman.
Pada contoh berikut, separator adalah "kartu putih"
MARK
Urutan Akses
(satu per satu)
Berikut ini diberikan algoritma standar untuk konsolidasi. Dasarnya adalah pemakaian
skema pemrosesan sekuensial dengan mark, yang setiap elemennya adalah satu
kelompok
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 194 dr 217
Algoritma :
Inisialisi_Seluruh_Categ
OPEN(ArsipIn, RekIn)
{First_Elmt}
while not EOP do
{Proses satu kategori }
Init_Categ
Current_Categ RekIn.KeyIn
repeat
Proses_Current_Categ
READ (ArsipIn,RekIn)
until (Current_Categ RekIn.KeyIn)
{ RekIn.KeyIn Current_Categ ,
RekIn.KeyIn adalah elemen pertama dari Next_Categ }
Terminasi_Categ
Terminasi_Seluruh_Categ
CLOSE(ArsipIn)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 195 dr 217
Program KONSOLIDASITanpaSeparator
{ Dengan penanganan kasus kosong }
{ Input : sebuah arsip sequential, terurut}
{ Proses :Mengelompokkan setiap kategori dan memrosesnya}
{ Output : Sesuai hasil proses
}
Kamus
{
Algoritma :
OPEN(ArsipIn, RekIn)
{First_Elmt}
if (EOP) then
Kasus_kosong
else {minimal ada satu kategori}
Inisialisi_Seluruh_Categ
repeat
{Proses satu kategori }
Init_Categ
Current_Categ RekIn.KeyIn
repeat
Proses_Current_Categ
READ (ArsipIn,RekIn)
until (Current_Categ RekIn.KeyIn)
{KeyInCurrent_Categ, RekIn.KeyIn=elemen pertama Next_Categ}
Terminasi_Categ
until (EOP)
Terminasi_Seluruh_Kategori
CLOSE(ArsipIn)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 196 dr 217
Contoh aplikasi 1:
Diketahui sebuah arsip nilai mahasiswa, satu mahasiswa dapat mempunyai beberapa
buah nilai (karena dalam satu semester mengambil beberapa matakuliah dan setiap
mahasiswa tidak sama matakuliahnya). Buat algoritma untuk menghitung nilai ratarata setiap mahasiswa, dan membuat daftar nilai sederhana, yaitu menuliskan NIM
dan nilai rata-rata setiap mahasiswa
Program NILAIMAHASISWA
{ Input : sebuah arsip sekuensial berisi NIM dan nilai mahasiswa}
{ Proses : proses setiap kategori adalah menghitung nilai rata-rata
setiap mahasiswa }
{ Output : NIM dan Nilai rata-rata setiap mahasiswa
}
Kamus
type Keytype : integer
type Valype : integer [0..100]
type rekaman : < NIM: keytype,
{ kunci }
Nilai:valtype
{nilai ujian} >
ArsipMhs : SEQFILE of
{input, terurut menurut kunci }
(*) RekMhs: rekaman
(1) <9999999, 0>
Current_NIM : integer { identifikasi kategori yg sedang diproses}
SumNil : integer
{ Jumlah nilai seluruh matakuliah seorg mhs}
NKuliah : integer
{ Jumlah matakuliah seorang mahasiswa }
Algoritma :
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 197 dr 217
Contoh aplikasi 2:
Idem contoh aplikasi 1, tetapi selain itu juga dikehendaki Nilai rata-rata seluruh
mahasiswa, jumlah nilai rata-rata setiap mahasiswa dibagi jumlah mahasiswa.
Program KONSOLIDASITanpaSeparator
{ dengan penanganan kasus kosong }
{ Input : sebuah arsip sekuensial berisi NIM dan nilai mahasiswa}
{ Proses :Mengelompokkan setiap kategori dan memrosesnya : menghitung
nilai rata-rata}
{ setiap mahasiswa dan nilai rata-rata seluruh populasi mahasiswa
Output : NIM Nilai rata-rata setiap mahasiswa, dan nilai rata-rata
seluruh mahasiswa }
Kamus
type Keytype : integer
type Valype : integer [0..100]
type rekaman : < NIM: keytype, {kunci }
Nilai:valtype { harga lain yang direkam } >
ArsipMhs : SEQFILE of { input, terurut menurut kunci }
(*) RekMhs : rekaman
(1) <9999999, 0>
Current_NIM : integer { identifikasi kategori yg sedang diproses}
SumNil : integer
{ Jumlah nilai seluruh matakuliah seorg mhs}
NKuliah : integer
{ Jumlah matakuliah seorang mahasiswa }
NilRata : integer
{ Nilai rata-rata seorang mahasiswa }
SumNilTot: integer
{ Jumlah nilai seluruh matakuliah seorg mhs}
NMhs : integer
{ Jumlah matakuliah seluruh mahasiswa }
Algoritma :
OPEN(ArsipMhs ,RekMhs)
{First_Elmt}
if (RekMhs.NIM = 9999999)
{ EOP } then
output ('Arsip kosong')
else
repeat
{Proses satu kategori = 1 NIM }
SumNil 0 ; NKuliah 0
{ Init_Categ}
Current_NIM RekMhs.NIM
repeat
SumNil SumNil + RekMhs.Nilai
{Proses}
NKuliah NKuliah + 1
{Proses_Current_Categ}
READ (ArsipMhs,RekMhs)
until (Current_NIM RekMhs.NIM)
{ NIM Current_NIM , RekMhs.NIM=elemen pertama Next_Categ }
NilRata SumNil/NKuliah
SumNilTot SumNilTot + NilRata
NMhs NMhs + 1
output (Current_NIM,NilRata)
{Terminasi_Categ}
until (RekMhs.NIM = 9999999)
output (SumNilTot/NMhs);
{ EOP }
{ terminasi seluruh file }
CLOSE (ArsipMhs)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 198 dr 217
Algoritma :
Inisialisasi_Seluruh_Categ
OPEN(ArsipIn, RekIn)
{First_Elmt}
if EOP then
Kasus_Kosong
else
repeat
{ Skip separator }
while not EOP and Separator(Keyin) do
READ (ArsipIn, RekIn)
{ KeyIn bukan Separator ,
KeyIn adalah elemen pertama dari Next_Categ atau EOP}
{ Tidak dibedakan antara kasus kategori kosong dan tidak }
Init_Categ
while (not EOP) and (not Separator(KeyIn)) do
{Proses satu kategori }
Proses_Current_Categ
READ (ArsipIn, RekIn)
{ Separator atau EOP }
Terminasi_Categ
until EOP
Terminasi_Seluruh_Categ
CLOSE (ArsipIn)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 199 dr 217
Contoh aplikasi
Diberikan sebuah arsip teks yang dapat diakses sequential huruf per huruf. Hendak
dihitung kata yang terpanjang dalam teks tersebut. Diandaikan bahwa teks hanya
mengandung huruf dan "blank". Kata adalah sekumpulan huruf yang dipisahkan oleh
satu atau beberapa blank.
Program KATATERPANJANG
{ Input : sebuah arsip sequential, yang mewakili sebuah teks, }
{ setiap rekaman adalah sebuah katakter}
{ Proses :Menghitung kata terpanjang dalam teks}
{ Output : Panjang kata maksimum
}
Kamus
{Keytype : type dari elemen arsip yg menentukan apakah elemen tsb
separator atau bukan}
{Valtype adalah type dari harga rekaman, di sini tidak ada }
KeyType : character
constant mark : character ='.'
constant blank : character =' '
type rekaman : Keytype
ArsipIn : SEQFILE of {input, terurut menurut kunci }
(*) CC: rekaman
{CC:sebuah karakter yang direkam)
(1) <'.'>
{ mark }
PanjangKata : integer
{ Panjang kata yang sedang dlm proses}
MaxLength : integer
{ Panjang kata maksimum }
procedure Inisialisasi
procedure Init_Categ
{ Inisialisasi untuk satu kategori }
procedure Proses_Current_Categ {Proses thd sebuah elemen kategori}
procedure Terminasi_Categ
{Terminasi sebuah kategori}
function Separator (K : Keytype) boolean
{ true jika K adalah separator, di sini adalah blank : ' '}
Algoritma :
OPEN(ArsipIn, CC)
{First_Elmt}
if (CC=mark) then
output ('Arsip kosong')
else
Maxlength 0 {Diandaikan kata minimum terdiri dari 1 huruf}
repeat
{ Skip separator, jika ada}
while
(CC mark)
and (CC = blank ) do
{not EOP & Separator(Keyin) }
READ (ArsipIn , CC)
{ CC bukan Separator , CC adalah huruf pertama dari
sebuah kata atau Mark}
PanjangKata 0
while (CC mark)
and (CC blank ) do
{not Separator(KeyIn) and not EOP}
PanjangKata PanjangKata + 1
{Proses_Current_Categ}
READ (ArsipIn , CC)
{ CC = blank
or CC = mark}
if (MaxLength < PanjangKata) then
MaxLength Panjang Kata
{Terminasi_Categ}
until (CC = mark)
{ EOP }
{Terminasi proses,Maxlength=0 berarti Arsip hanya berisi blank}
Output (MaxLength)
CLOSE(ArsipIn)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 200 dr 217
Merging
Merging adalah penggabungan dua buah arsip. Yang paling sederhana adalah jika
arsip yang pertama "dikonkatenasi" ke arsip kedua (artinya data dari arsip ke dua
ditambahkan setelah rekaman terakhir arsip pertama dan membentuk arsip yang baru):
File1
10
File2
3
4
1
File3 = File1& File 2
10
Cara di atas tak dapat dipakai jika kedua arsip sudah terurut, dan dikehendaki sebuah
arsip hasil yang tetap terurut. Algoritma untuk penggabungan dua buah arsip terurut
menjadi sebuah arsip yang terurut adalah :
File1
10
File2
3
4
1
File3 = File1& File 2
10
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 201 dr 217
Program MERGING1
{ Input : dua arsip sequential, terurut, sejenis}
{ Proses :Menggabung kedua arsip menjadi sebuah arsip yg terurut}
{
VERSI AND }
{ Output : Sequential file baru yang terurut}
Kamus
{
Algoritma :
OPEN(Arsip1, RekIn1)
{First_Elmt of Arsip1}
OPEN(Arsip2, RekIn2)
{First_Elmt of Arsip2}
REWRITE(ArsipOut)
{Menyiapkan arsip hasil: Arsip3}
while (RekIn1.Key mark) and (RekIn2.Key mark) do
depend on RekIn1.Key,RekIn2.Key:
RekIn1.Key RekIn2.Key : WRITE(ArsipOut, RekIn1)
READ (ArsipIn1, RekIn1)
RekIn1.Key > RekIn2.Key : WRITE(ArsipOut, RekIn2)
READ (ArsipIn2,RekIn2)
{ RekIn1.Key = mark or RekIn2.Key = mark }
while (RekIn1.Key mark) do
WRITE(ArsipOut, RekIn1)
READ (ArsipIn1, RekIn1)
{ Akhir Arsip1, RekIn1.Key = mark }
while (RekIn2.Key mark) do
WRITE(ArsipOut, RekIn2)
READ (ArsipIn2,RekIn2)
{ Akhir Arsip2, RekIn2.Key = mark }
WRITE(ArsipOut,<mark,Val>)
CLOSE(ArsipIn1)
CLOSE(ArsipIn2)
CLOSE(ArsipOut)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 202 dr 217
Program MERGING2
{ Input : dua arsip sequential, terurut menaik menurut kunci,
sejenis, dan semua harga < Mark>}
{ Proses :Menggabung kedua arsip menjadi sebuah arsip yg terurut}
{
VERSI OR }
{ Output : Sequential file baru yang terurut}
Kamus
{
Algoritma :
OPEN(ArsipIn1, RekIn1)
{First_Elmt of Arsip1}
OPEN(ArsipIn2, RekIn2)
{First_Elmt of Arsip2}
REWRITE (ArsipOut) {Menyiapkan arsip hasil: Arsip3}
while (RekIn1.Key mark) or (RekIn2.Key mark) do
depend on RekIn1.Key,RekIn2.Key :
RekIn1.Key RekIn2.Key : WRITE(ArsipOut, RekIn1)
READ (ArsipIn1, RekIn1)
RekIn1.Key > RekIn2.Key : WRITE(ArsipOut, RekIn2)
READ (ArsipIn2,RekIn2)
{ RekIn1.Key = mark or RekIn2.Key = mark }
WRITE(ArsipOut, <mark,Val>)
CLOSE(ArsipIn1)
CLOSE(ArsipIn2)
CLOSE(ArsipOut)
Catatan :
1. Versi-or ini teks algoritmanya lebih singkat daripada versi-and.
2. Algoritma ini hanya benar jika mark adalah suatu nilai khusus yang dipakai untuk
menahan maju ke rekaman berikutnya, sehingga arsip yang belum habis akan
terproses sampai habis
3. Versi ini tidak dapat digunakan secara umum karena kekhusan nilai mark tersebut.
Bahkan tak dapat digunakan sama sekali jika mark adalah suatu nilai EOF yang
ditentukan oleh sistem seperti pada kebanyakan sistem pengarsipan.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 203 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 204 dr 217
Program UPDATING
{ Input : dua arsip sequential (MasterFile dan Transaction File),
terurut menaik menurut kunci yg sama}{ Proses :Meremajakan sebuah
field pada Master file berdasarkan Transaction File }
{ Output : Sequential file baru yang terurut menaik menurut kunci}
{ Seq. processing terhadap Master file , Master File adalah
pengendali pd loop luar }
Kamus
{ Keytype: suatu type dari kunci rekaman, Akhir arsip ditandai oleh mark}
type rekMaster : < KeyM: integer, Saldo:integer>
type rekTrans : < KeyT: integer, TransSaldo:integer>
Master : SEQFILE of {input, terurut menurut kunci }
(*) RekM : rekMaster
(1) <9999,0>
Transaction : SEQFILE of {input, terurut menurut kunci }
(*) RekT : rekTrans
(1) <9999,0>
NewMaster : SEQFILE of { Output, terurut menurut kunci }
{ Master file baru yg telah diremajakan }
(*) rekNM : rekMaster
(1) <9999,0>
Newsaldo : integer
Algoritma :
OPEN(Master, RekM)
{First_Elmt of Arsip Master}
OPEN(Transaction, RekT){First_Elmt of Arsip Transaksi}
REWRITE (NewMaster) {Menyiapkan arsip hasil NewMaster}
while (RekM.Key 9999)
do
while (RekT.Key< RekM.Key) and (RekT.Key 9999) do
{Error, skip transaction file yg tidak ada pada master }
READ (Transaction, RekT)
{RekT.Key RekM.Key or RekT.Key= 9999 }
if (RekT.Key = RekM.Key) then
{ updating }
{ Init Update }
NewSaldo RekM.Saldo
repeat
NewSaldo
ewSaldo + RekT.TransSaldo
READ (Transaction, RekT)
until (RekT.Key RekM.Key) or (RekT.Key =9999)
{ RekT.Key RekM.Key or RekT.Key =9999 }
{ End_upDate }
write(NewMaster, <RekM.Key,NewSaldo>)
else{RekT.Key > RekM.Key,tidak ada update thd MasterFile,salin}
write(NewMaster,<KeyM,Saldo>)
READ (Master, RekM)
{ Next Elmt of Master }
WRITE(NewMaster, <9999,0>)
CLOSE(Master); CLOSE(Transaction)
CLOSE(NewMaster)
Splitting
Splitting adalah pemecahan sebuah arsip menjadi dua atau lebih arsip. Algoritmanya
tergantung pada kriteria pemecahannya.
Contoh :
- Memisahkan sebuah arsip pegawai menjadi beberapa arsip sesuai dengan kode
golongan
- Memisahkan arsip data percobaan sesuai dengan kriteria data (misalnya yang layak
dipakai dan yang harus dibuang)
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 205 dr 217
Latihan Soal
1. Tuliskanlah algoritma umum untuk menggabungkan dua buah arsip yang terurut
menurut kunci tertentu, yang menghasilkan sebuah arsip terurut dengan key unik.
Artinya jika ada kunci yang sama pada kedua arsip input, hanya salah satu rekaman
yang ditulis ke arsip hasil. Rekaman yang "dibuang" karena duplikasi file harus
dituliskan ke keluaran dengan perintah output.
Catatan : Spesifikasikan dengan cermat masalah ini sebelum mulai menuliskan
algoritmanya.
Contoh :
Arsip 1 mempunyai kunci : 1,2,3,5,7,8,9,17, 25,999
Arsip 2 mempunyai kunci : 2,3,15,17,81,90, 999
Arsip 3 mempunyai kunci : 1,2,3,5,7,8,9,15,17, 25,81,90,999
2. Tuliskanlah alaoritma umum untuk membuat "intersection" rekaman dari dua buah
arsip sekuensial yang terurut, yang menghasilkan sebuah arsip terurut dengan
kunci unik. Artinya hanya kunci yang sama pada kedua arsip input yang
rekamannya ditulis ke arsip hasil. Rekaman yang "dibuang" harus dituliskan ke
keluaran dengan perintah output.
Catatan : Spesifikasikan dengan cermat masalah ini sebelum mulai menuliskan
algoritmanya.
Contoh :
Arsip 1 mempunyai kunci : 1,2,3,5,7,8,9,17, 25,999
Arsip 2 mempunyai kunci : 2,3,15,17,81,90, 999
Arsip 3 mempunyai kunci : 2,3,17,999
3. Kadang-kadang updating tidak dilakukan dari file, melainkan langsung dari alat
masukan (misalnya papan kunci), seperti yang terjadi pada pelayanan-pelayanan
umum.
Diberikan sebuah Master file dengan rekaman <key, val>. Buatlah algoritma
untuk:
- membaca sebuah harga key dan val dari papan kunci;
- mencari rekaman dengan <key, ---> dalam Master file, dan mengupdate data
key tersebut jika ada. Lalu, lakukan penambahan rekaman pada transaction
file dengan <key, val>. Jika pencarian tidak ketemu, harus diikuti pesan
kesalahan.
4. Tuliskanlah algoritma umum untuk memecah sebuah arsip menjadi dua buah arsip
dengan kriteria validitas V terhadap beberapa harga dari rekaman.
Contoh : Peremajaan arsip
Rekaman Asli adalah <key:integer, Val1,val2,val3:integer>
Dipecah menjadi :
Rekaman Valid adalah <key:integer, Val1,val2,val3:integer>
dengan Val1, Val2, Val3 memenuhi V(Val1,Val2,Val3)
Rekaman TidakValid adalah <key:integer, Val1,val2,val3:integer>
dengan Val1, Val2, Val 3 tidak memenuhi V(Val1,Val2,Val3)
5. Apa komentar anda tentang algoritma MERGING2 yang teksnya lebih "singkat"
daripada MERGING1?
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 206 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 207 dr 217
Program ContohRekursif
{ Program ini merupakan contoh implementasi faktorial dalam bentuk }
{ prosedur dan fungsi }
Kamus
function Faktorial (n:integer) integer
{Prekondisi : n > 0 }
{Faktorial (n) menghasilkan 1 jika n=1;
menghasilkan n!= n* (n-1)! untuk n>1
procedure Pfaktorial1 (Input n:integer, Output Hsl: integer)
{I.S. n > 0 }
{ F.S. Pfaktorial (n) menghasilkan 1 jika n=1;
menghasilkan n!= n* (n-1)! untuk n>1 }
procedure Pfaktorial2 (Input n:integer, Input/Output Hsltemp: integer)
{I.S. n > 0 }
{ F.S. Pfaktorial (n) menghasilkan 1 jika n=1;
menghasilkan n!= n* (n-1)! untuk n>1, dengan paramater I.O }
{ variabel global program }
Hsl, HslTemp : integer
Algoritma :
Output (Faktorial (5));
Pfaktorial1 (8, Hsl); output (Hsl)
HslTemp 1 {harus diinisialisasi dg invarian sebab parameter I/O }
Pfaktorial1 (8, HslTemp); output (HslTemp)
function
Faktorial (n:integer) integer
{Prekondisi : n> 0 }
{ Faktorial (n) menghasilkan 1 jika n=1;
menghasilkan n!= n* (n-1)! untuk n>1 }
Kamus
Algoritma :
if (n = 1) then {basis-1 }
1
Else {rekurens }
n* Faktorial (n-1)
Procedure
Pfaktorial1 (input n:integer, Output Hsl:integer)
{I.S. n > 0 }
{ F.S. Pfaktorial (n) menghasilkan 1 jika n=1;
menghasilkan n!= n* (n-1)! untuk n>1; }
{ dengan variabel lokal untuk menyimpan hasil sementara }
Kamus
temp: integer;
Algoritma :
if (n=1) then
Hsl 1
else
Pfaktorial2 (n-1, temp)
Hsl n * Temp
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 209 dr 217
function
FaktIter1 (N:integer) integer
{Prekondisi : N > 0 }
{ Faktorial (N) menghasilkan 1 jika n=0 atau n=1;
menghasilkan N!= N * (N -1)! untuk N >1 dengan loop }
{ faktorial adalah perhitungan deret : 1 x 2 x 3 x 4 x x N }
{ sehingga hasil disimpan dalam Hsl, dan elemen pengulangan adalah i}
Kamus
I: integer
Hsl : integer
Algoritma :
Hsl 1; {inisialisasi }
I 1 {invarian : faktorial (1) = 1 }
while (I <= N) then
Hsl Hsl * I
I I+ 1 {next-elemt }
{ I > N : sudah dilakukan 1 x 1 x 2 x 3 xN
Hsl
function
FaktIter2 (N:integer) integer
{Prekondisi : N > 0 }
{ Faktorial (N) menghasilkan 1 jika n=0 atau n=1;
menghasilkan N!= N * (N-1)! untuk n>1 dengan loop }
{ faktorial adalah perhitungan deret : 1 x 2 x 3 x 4 x x n }
{ pada versi ini, elemen pengulangan I pada versi FakIter1
dihilangkan}
{ sehingga hasil disimpan dalam Hsl, dan elemen pengulangan adalah N}
{ merupakan versi yang tidak disarankan karena mengubah nilai N dalam
body fungsi, yang karena dalam konsep fungsi semua parameter harus
input maka setelah eksekusi fungsi, nilai N tidak berubah }
Kamus
Hsl : integer
Algoritma :
Hsl 1; {inisialisasi }
{invarian : faktorial (1) = 1 }
while (N >= 1 ) then
Hsl Hsl * N
N N - 1 {next-elemt }
{N = 0 : sudah dilakukan 1 x N x (N-1) x (N-2) x x 3 x 2 x 1
Hsl
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 210 dr 217
procedure
{
{
{
{
{
{
Kamus
Algoritma :
if (I > N ) then {
{ do nothing }
else
Hsl I * Hsl
I I+ 1
FakIterRek (n,
stop condition }
{ badan loop }
{ next element }
I+1, Hsl)
procedure
Perhatikan bahwa realisasi prosedur FakIterRek1 dan FakIterRek2 di atas sangat tidak
natural, karena merupakan loop yang dieksekusi dengan mekanisme call rekursif.
Pengguna prosedur juga harus mengetahui nilai inisialisasi parameter input/output
agar prosedur dapat dieksekusi dengan benar. Kesalahan menginisialisasi nilai
parameter aktual akan mengakibatkan kesalahan hasil komputasi.
Ini juga bukan merupakan prosedur yang baik, karena dapat mengakibatkan
kesalahan.
Dalam pemrograman prosedural, pengulangan lebih natural jika diimplementasi
menjadi loop. Sebuah Call rekursif atau pemanggilan apapun, menjadi tidak natural
jika pengguna harus memberikan nilai inisialisasi yang tepat untuk suatu parameter
input/output.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 211 dr 217
Realisasi prosedur/fungsi rekursif yang baik selalu didasari oleh definisi rekursif.
Dalam pemrograman yang diberikan untuk Mesin Gambar (lihat bab terkait) dan
pemrograman yang lebih lanjut, anda akan mendapatkan pola-pola program rekursif
yang memang didasari fungsi rekursif
Studi kasus memroses tabel secara rekursif
Pada bagian berikut ini, akan diberikan skema pemrosesan elemen secara rekursif,
dengan melakukan rekurens terhadap rentang nilai (interval) indeks elemen yang
diproses. Dalam kasus ini, array didefinisikan sebagai variabel global, dan tidak
dipassing sebagai parameter karena array merupakan data global yang mencerminkan
state dari sistem. Prosedur print yang direalisasi sebagai contoh tidak direaliasi
sebagai fungsi, sebab mencetak adalah aksional (bukan fungsional). Ini merupakan
contoh situasi dimana prosedur rekursif dibutuhkan, dan sangat dekat dengan bentuk
pengulangan. Beberapa algoritma lanjut yang akan dipelajari pada perkuliahan
selanjutnya akan bekerja pada tabel secara rekursif (misalnya Quick sort).
Kamus Global
T : array [1 .. IdxMax] of integer
Neff : integer {tabel T terisi dari 1 s/d Neff }
{ T dan Neff adalah variabel global yang merupakan state dari sistem}
{ dan hanya ada 1 copy tabel }
procedure
PrintTab (Input Iawal, Iakhir:integer}
{ Prosedur ini mencetak nilai elemen tabel global T untuk indeks}
{ Iaw s/d Iakh }
{ I.S. Iawal <= Iakhir dan berada dalam range [1..Neff] }
{
Tabel T adalah tabel global yang sudah terdefinisi }
Kamus
Algoritma :
if ( Iawal>IAkhir ) then { basis kosong = stop condition }
{ do nothing }
else { Iawal <=Iakhir, rekurens }
output (T[Iawal] ) { current element }
PrintTab (Iawal+1,Iakhir) {Iawal dapat dipassing sebagai ekspresi }
{ karena merupakan parameter input }
Latihan Soal
1. Pelajari kembali mekanisme passing parameter dan nilai variabel lokal dalam
bahasa pemrograman yang dipakai sebagai latihan
2. Pelajarilah kembali semua solusi rekursif untuk persoalan perhitungan nilai
faktorial (N) di atas, dan modifikasilah untuk dapat memenuhi spesifikasi,
bahwa nilai faktorial(0) adalah 1
3. Buatlah prosedur rekursif yang akan menghitung fibonacci (carilah definisi
rekursif dari fungsi Fibonacci)
4. Pelajarilah prosedur memprint tabel yang diberikan pada studi kasus:
a. Apa akibatnya jika parameter prosedur bersifat Input/Output ?
b. Bagaimana jika dikehendaki untuk mengaplikasi basis-1 terhadap tabel
tersebut ?
c. Bagaimana jika tabel bukan merupakan variabel global ?
5. Berdasarkan contoh memprint tabel sehingga :
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 212 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 213 dr 217
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 214 dr 217
Catatan:
Untuk depend-on, nama-var adalah type yang dapat dienumerasi, maka
dapat dipakai statement case:
case (NamaVar) of
konstan-1: Aksi-1;
konstan-2: Aksi-2;
konstan-3: Aksi-3;
else : Aksi-4
end;
+---------------------------------+----------------------------------+
| ALGORITMA
|
Pascal
|
+---------------------------------+----------------------------------+
|3. PENGULANGAN :
|
|
|
|
|
|
while <kondisi-ULANG> do
| while (kondisi-ULANG) do
|
|
| begin
|
|
Aksi
|
Aksi
|
|
| end;
|
+---------------------------------+----------------------------------+
|
repeat
| repeat
|
|
|
|
|
Aksi
|
Aksi
|
|
|
|
|
until<kondisi-STOP>
| until(kondisi-STOP);
|
|
|
|
+---------------------------------+----------------------------------+
|
| (* deklarasi stop:boolean *)
|
|
iterasi
| stop:= false;
|
|
| repeat
|
|
Aksi-A
|
Aksi-A;
|
|
|
|
|
if (kondisi-STOP) then
|
|
stop <kondisi-STOP>
|
|
stop:= true
|
|
|
else
|
|
Aksi-B
|
AKSI-B;
|
|
| until stop;
|
|
|
|
+---------------------------------+----------------------------------+
|
|
|
|
| /* Jika Awal <= Akhir */
|
|
i traversal[Awal..Akhir]
| for(I :=Awal to Akhir) do
|
|
| begin
|
|
Aksi
|
Aksi;
|
| end;
|
|
+----------------------------------+
|
|
|
|
| /* Jika Awal >= Akhir */
|
|
| for(I :=Awal downto Akhir) do
|
|
| begin
|
|
|
Aksi;
|
| end;
|
+---------------------------------+----------------------------------+
|4. INPUT/OUTPUT
|
|
|
|
|
|
read
<nama>
| read (Nama)
|
|
| readln (nama);
|
+---------------------------------+----------------------------------+
| write (nama);
|
|
write <nama>
|
| writeln (nama);
|
+---------------------------------+----------------------------------+
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 215 dr 217
NAMAF
(<list-parameter input>)
<type hasil> *)
Pemanggilan Fungsi
(langsung dituliskan dalam bahasa Pascal)
(* Program POKOKPERSOALAN *)
Program POKOKPERSOALAN;
(* Spesifikasi : Input, Proses, Output *)
(* Kamus : *)
(*
(*
(*
(*
(* Algoritma : *)
begin
{ deretan instruksi pemberian harga, input, output, analisis kasus,
pengulangan yg memakai fungsi }
{ Harga yang dihasilkan fungsi juga dapat dipakai dalam ekspresi )
nama := NAMAF (<list parameter aktual>)
write(NAMAF (<list parameter aktual>))
(* parameter aktual dapat berupa nilai, konstanta, ekspresi *)
(* Harga yang dihasilkan fungsi juga dapat dipakai dalam ekspresi *)
end.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 216 dr 217
Pemanggilan Prosedur
(* Program POKOKPERSOALAN *)
Program POKOKPERSOALAN;
(* Spesifikasi , Input, Proses, Output *)
Kamus :
(* semua NAMA yang dipakai dalam program }
(* semua NAMA yang dipakai dalam program *)
(* TYPE *)
(* CONST *)
(* VAR
*)
(* spesifikasi dan Body prosedur langsung dituliskan di bagian ini *)
(* procedure NAMAPROSEDUR (Input/Output : <list-nama parameter formal>) *)
procedure NAMAPROSEDUR (<list-nama parameter formal Input:type ;
VAR <list-nama parameter formal Input/Output atau output:type>) ;
{Spesifikasi : Initial State, Final State}
{ Boleh mengandung kamus lokal VAR, TYPE, CONST }
begin
end;
(* Algoritma : program utama *)
begin
{Deretan instruksi assignment/pemberian harga, input, output, analisis
kasus, pengulangan )
NAMAPROSEDUR
end.
Inggriani Liem, IF-ITB, Diktat Algoritma dan Pemrograman, Pemrograman Prosedural Hlmn. 217 dr 217