Upload
rha-tag-inginn-dcintailagii
View
980
Download
0
Embed Size (px)
Citation preview
PEMROGRAMAN MODULAR adalah suatu teknik pemrograman di mana program yang biasanya cukup besar dibagi-bagi menjadi beberapa bagian program yang lebih kecil . Dalam beberapa bahasa pemrograman disebut : sub-rutin, modul, prosedur, atau fungsi.
STRUKTUR POHONPROGRAM A
SUBPROGRAM A1
SUBPROGRAM A2
SUBPROGRAM A3
SUBPROGRAM A21
SUBPROGRAM A22
ILUSTRASIDEKLARASI A, B, Temp : integer ALGORITMA{ baca nilai A dan B}
read(A) read(B){proses pertukaran}
temp A AB B temp{ tulis nilai A dan B setelah pertukaran }
output(A) output(B)
Dipecah subprogramDEKLARASI A, B : integer Baca(A,B:Integer) ALGORITMA: read(A) read(B) Tukar(A, B:integer) DEKLARASI temp : integer {peubah bantu} ALGORITMA temp A AB B temp Tulis(A,B : integer) ALGORITMA output(A) output(B) ALGORITMA Baca(A,B) Tukar(A,B) Tulis(A,B)
KEUNTUNGAN Pemrogram Modular
1. Program lebih pendek 2. Mudah menulis (banyak programer) 3. Mudah dibaca dan dimengerti (bandingkan dg nonmodular dg banyak instruksi) 4. Mudah didokumentasi 5. Mengurangi kesalahan dan mudah mencari kesalahan(debug) program 6. Kesalahan yang terjadi bersifat lokal
Dua bentuk pemrogram modular : PROSEDUR dan FUNGSI Struktur setiap subprogram tersebut pada hakekatnya sama , yaitu : Nama modul (subprogram) Bagian deklarasi Algoritma (intruksi yg akan dilaksanakan)
Perbedaan penggunaannya dalam bahasa pemrograman Pascal : Prosedur merupakan modul(subprogram) yg melakukan aktifitas tertentu tanpa adanya pengembalian nilai Fungsi terdapat pengembalian nilai
PROSEDUR Dalam bahasa pemrograman Prosedur adalah modul program yang mengerjakan tugas/aktifitas yg spesifik dan menghasilkan suatu efek netto(membandingkan keadaan awal dan keadaan akhir dari suatu aktifitas prosedur)
Setiap prosedur perlu mendefinisikan keadaan awal sebelum rangkaian instruksi di dalam prosedur dilaksanakan, dan keadaan akhir yg diharapkan setelah instruksi di dalam prosedur dilaksanakan
STRUKTUR PROSEDUR JUDUL (header) nama prosedur dan deklarasi parameter(kalau ada) DEKLARASI mengumumkan namanama dan tipe data ALGORITMA badan prosedur (instruksi)
*sama dengan struktur ALGORITMA
Nama Prosedur Nama yang unik Sebaiknya diawali dengan kata kerja karena prosedur berisi suatu aktifitas Misalnya: HitungLuas, Tukar, CariMaks, Tulis, dll.
Parameter Adalah nama-nama peubah (variabel) yang dikdeklarasikan pada bagian header (judul) prosedur dan titik dimana dia dipanggil. Penggunaan parameter menawarkan mekanisme pertukaran informasi (antara yg memanggil (program/algoritma utama) dg prosedur itu sendiri)
Parameter dibedakan menjadi dua : Parameter aktual (argumen) : Parameter yg disertakan pada waktu pemanggilan prosedur (parameter yg ada pada program/algoritma utama).
Parameter formal : Parameter yg dideklarasikan di dalam bagian header prosedur itu sendiri.
Ketika prosedur dipanggil, parameter aktual menggantikan parameter formal. Tiap-tiap parameter aktual berpasangan dengan parameter formal yg bersesuain (berkorespondasi satu satu)
Notasi algoritma untuk PROSEDURProcedure NamaProsedur(deklarasi parameter, jika ada){spesifikasi prosedur, berisi penjelasan tentang apa yg dilakukan oleh prosedur ini. K.awal : keadaan sebelum prosedur dilaksanakan. K. akhir : keadaan setelah prosedur dilaksanakan}
DEKLARASI{semua nama yg dipakai di dalam prosedur dan hanya berlaku lokal di dalam prosedur ini}
ALGORITMA{badan prosedur, berisi urutan instruksi}
Pendeklarasian Parameter dalam prosedur bukanlah keharusanContoh : Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak}
DEKLARASIAlas, tinggi, luas : real
ALGORITMARead(alas, tinggi) Luas (alas * tingg) / 2 Write(luas)
Pemanggilan Prosedur Prosedur bukan program yg beridiri sendiri Prosedur tidak dapat dieksekusi secara langsung. Instruksi-instruksi di dalam prosedur dapat dilaksanakan bila prosedur itu diakses. Prosedur diakses dg cara memanggil namanya dari program pemanggil (misalnya dari program utama atau modul program lainnya) Jika prosedur tanpa parameter, maka pemanggilannya cukup dg nama prosedurnya saja, contoh : HitungLuasSegitiga
Notasi Algoritma :PROGRAM Segitiga{menghitung luas segitiga}
DEKLARASI Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak}
DEKLARASIAlas, tinggi, luas : real
ALGORITMARead(alas, tinggi) Luas (alas * tinggi) / 2 Write(luas)
ALGORITMA HitungLuasSegitiga
KUIS BUATLAH NOTASI ALGORITMA UNTUK MELAKUKAN PEMANGGILAN PROSEDUR LUASSEGITIGA SEBANYAK 3 X
Nama Global dan Nama Lokal Nama Lokal :Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam prosedur (termasuk parameter, jika ada). (hanya dikenal/digunakan dalam lingkup (scope) prosedur tersebut
Nama Global :Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam program utama. (dapat dikenal/digunakan dibagian manapun dalam program (progam utama maupun prosedur).
PROGRAM Segitiga{menghitung luas N buah segitiga}
DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak}
DEKLARASIluas : real
ALGORITMALuas (alas * tinggi) / 2 Write(luas)
ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(alas, tinggi HitungLuasSegitiga endfor _______________________________________________________________ Nama Peubah (variabel) I, N, alas, tinggi variabel GLOBAL Nama Peubah (variabel) luas variabel LOKAl
Menggunakan variabel Global atau variabel Lokal Bila suatu peubah (variabel) digunakan di seluruh bagian program (baik program utama maupun prosedur), maka deklarasikanlah peubah tsb secara Global. Bila suatu peubah (variabel) hanya digunakan di dalam prosedur, maka deklarasikanlah peubah tsb secara Lokal. Gunakan peubah global sedikit mungkin Penggunaan variabel lokal membuat program lebih elegan Penggunaan variabel lokal dapat meminimumkan usaha pencarian kesalahan yg disebabkan oleh nama-nama tsb.
Parameter Prosedur yg baik adalah prosedur yg independen dari program utama/ program yg memanggilnya. Prosedur yg baik tidak menggunakan peubah-peubah global di dalam prosedur. Jika program utama perlu mengomunikasikan nilai peubah Global ke dalam prosedur, maka gunakanlah PARAMETER.
Parameter - next Penggunaan parameter adalah mekanisme pertukaran informasi antara prosedur dengan yang memaggilnya (program utama maupun subprogram lainnya). Prosedur dengan parameternya (Parameter Formal) dapat diakses dg cara memanggil namanya dari program yg memanggilnya yg disertai dg parameter dari program yg memanggil tsb (Parameter Aktual). Contoh: NamaProsedur(parameter aktual)
Tiap parameter aktual berpasangan dg paramater formal yg bersesuaian
Parameter - next Ketika prosedur dipanggil, parameter aktual berkoresponden satu-satu dengan parameter formal (parameter yg dideklarasikan pada bagian header prosedur)
Aturan korespondensi satu satu Jumlah parameter aktual harus sama dengan jumlah parameter formal. Tiap parameter aktual harus bertipe sama dengan tipe parameter formal yg sesuai. Tiap parameter aktual harus diekspresikan dalam cara yg taat azas dg parameter formal yg bersesuaian, bergantung pada jenis parameter formal.
Jenis parameter formal yg disertakan di dalam prosedur : Parameter Masukan (input parameter) :Parameter yg nilainya berlaku sebagai masukan untuk prosedur.
Parameter Keluaran (Output parameter):Parameter menampung keluaran yg dihasilkan oleh prosedur.
Parameter masukan/keluaran (input/output parameter) :Parameter yg berfungsi sebagai masukan sekaligus keluaran bagi prosedur tsb.
Parameter masukan Nilai parameter aktual diisikan ke dalam parameter formal yg sesuai. Perubahan nilai parameter di dalam badan prosedur tidak mengubah nilai parameter aktual. Nama parameter aktual boleh berbeda dg nama parameter formal yg sesuai
Contoh : paramater masukanProcedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya} {K.akhir : luas segitiga tercetak}
DEKLARASIluas : real
ALGORITMALuas (alas * tinggi) / 2 Write(luas)
Program utama yg memanggil nama prosedur: harus mendeklarasikan nama prosedur dan memanggilnya dg parameter aktual yg sesuaiPROGRAM Segitiga{menghitung luas N buah segitiga}
DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak}
DEKLARASIluas : real
ALGORITMALuas (alas * tinggi) / 2 Write(luas)
ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(alas, tinggi HitungLuasSegitiga(alas,tinggi) endfor
nama parameter aktual tidak harus sama dengan nama parameter formal : yg dipentingkan adalah nilainyaPROGRAM Segitiga{menghitung luas N buah segitiga}
DEKLARASI I, N : integer a, t : real Procedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak}
DEKLARASIluas : real
ALGORITMALuas (alas * tinggi) / 2 Write(luas)
ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(a, t) HitungLuasSegitiga(a,t) endfor
Parameter aktual boleh berupa ekspresi atau konstantaContoh : HitungLuasSegitiga(a*0.2, t*0.1) HitungLuasSegitiga(12, 6)
Parameter keluaran Parameter keluaran dideklarasikan di dalam header prosedur, sebagaimana parameter masukan Parameter keluaran dideklarasikan dengan keyword OUTPUT. Ketika prosedur yg mengandung parameter keluaran dipanggil, maka nama parameter aktual menggantikan (substitute) nama parameter formal yg bersesuaian.
Contoh : parameter keluaran-nextPROGRAM Segitiga{menghitung luas N buah segitiga}
DEKLARASI I, N : integer a, t, L : real Procedure HitungLuasSegitiga(input alas, tinggi : real, output luas:real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak}
ALGORITMALuas (alas * tinggi) / 2
ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(a, t) HitungLuasSegitiga(a, t, L)Write(L)
endfor
Parameter masukan/keluaran Prosedur harus dapat mengakomodasi baik masukan dari dan keluaran ke blok program pemanggil Maka gunakan parameter masukan/ keluaran Bila parameter aktual diubah nilainya di dalam badan prosedur, maka sesudah pemanggilan prosedur nilai parameter aktual di titik pemanggilan juga berubah Parameter masukan/keluaran dideklarasikan di dalam header prosedur dengan keyword INPUT/OUTPUT Parameter aktual harus berupa peubah, tidak boleh berupa ekspresi atau konstanta
Contoh : parameter masukan/keluaranPROGRAM Cetak0Sampai10 { mencetak nilai dari 0 sampai 10 }DEKLARASI x : integer procedure Inc(input/output x : integer) {menaikan nilai x sebesar 1} {K.Awal : x sudah terdefinisi nilainya} {K.Akhir : nilai x bertambah 1} DEKLARASI ALGORITMA xx+1 ALGORITMA X0 repeat write(x) inc(x) until x > 10
Parameter masukan
-
parameter masukan/keluaranPROGRAM xyz DEKLARASI a, b : integer Procedure tambah(input/output x,y:integer) Deklarasi Algoritma xx+4 Y y +4 write(nilai x dan y di akhir prosedur tambah:) Write( x=, x) Write( y=, y) ALGORITMA a 15 B 10 Write(nilai a dan b sebelum panggil prosedur tambah:) Write( a=, a) Write( b=, b) Tambah(a,b) Write(nilai a dan b sesudah panggil prosedur tambah:) Write( a=, a) Write( b=, b)
PROGRAM xyz DEKLARASI a, b : integer Procedure tambah(input x,y:integer) Deklarasi Algoritma xx+4 Y y +4 write(nilai x dan y di akhir prosedur tambah:) Write( x=, x) Write( y=, y) ALGORITMA a 15 B 10 Write(nilai a dan b sebelum panggil prosedur tambah:) Write( a=, a) Write( b=, b) Tambah(a,b) Write(nilai a dan b sesudah panggil prosedur tambah:) Write( a=, a) Write( b=, b)
Program dg prosedur atau tanpa prosedur Dianjurkan menulis program yg modular Program yg dipecah menjadi beberapa prosedur menunjukkan teknik pemrograman yg baik dan terstruktur
Prosedur dg parameter atau tanpa parameter Dianjurkan menulis prosedur dg parameter Parameter dapat mengurangi kebutuhan penggunaan peubah (variabel) global
Parameter masukan atau parameter keluaran Bila prosedur menghasilkan keluaran yg digunakan oleh program pemanggil, gunakan parameter keluaran untuk menampung keluaran tsb. Bila prosedur tidak menghasilkan keluaran, atau kalaupun menghasilkan keluaran tapi keluaran tsb hanya digunakan di dalam prosedur itu saja, maka gunakan parameter masukan. Bila prosedur menerima masukan sekaligus keluaran pada parameter yg sama, gunakan parameter masukan/keluaran.
Analisa kasus :menentukan jam berikutnya setelah ditambah satu detik1. Tambah detik dengan 1, jika jumlah detik 0 basis : xy = 1 jika y = 0 rekurens : xy = a x xy-1 }
Deklarasi Algoritma: if y = 0 then return 1 else return x*PangkatRekursif(x, y-1) endif
Pangkat dalam Bahasa Pascalprogram pangkatrekursif; uses wincrt;
var a, n: integer;Function pangkat(a, n : integer ) : integer; Begin If n = 0 then pangkat:= 1 Else pangkat:=a*pangkat(a,n-1); End; begin a:=10; write('masukan pangkat:'); readln(n); writeln(a, pangkat ',n,' adalah: ',pangkat(a,n):10); end.
Procedure rekursif Deklarasi Algoritma: Write(Informatika UHAMKA) rekursif
Program rekursi Deklarasi Batas : word Prosedur rekursif Deklarasi Algoritma: If batas < 7 then Write(Informatika UHAMKA) Batas batas + 1 Rekursif Endif Algoritma: Batas 0 Rekursif
Program urut Deklarasi N:word Prosedur deret(input n word) Deklarasi Algoritma: Write(N:3) If N < 10 then Deret(N+1) endif Algoritma: N0 Deret(N)
Menghitung nilai FAKTORIALFaktorial (0) = 1 : Nilai awal Faktorial (n) = n * faktorial(n-1) : Rekurent faktorial (4) = 4 * faktorial (3) 3 * faktorial (2) 2 * faktorial (1) 1 * faktorial (0) 1 =4*3*2*1*1 = 24 __________________________________________________ function faktorial (input nilai : integer) : integer DEKLARASI
ALGORITMA: if nilai maks? Ya A[5] >maks? Ya A[6] > maks? tidak A[7] > maks? tidak A[8] >maks? Tidak maks A[1] (maks=158) maks tidak berubah maks A[3] (maks=162) maks A[4] (maks=169) maks A[5] (maks=172) maks tidak berubah maks tidak berubah maks tidak berubah
(proses pembandingan selesai) Didapat : maks = 172 (nilai maksimum array yang ditemukan)
Algoritma untuk maks = -999Program NilaiMaksimum DEKLARASI : Const N = 8 A : array[1..N] of integer = (158, 157, 162, 169, 172, 155, 170, 163) I, maks : integer
ALGORITMA : Maks -9999 {nilai maksimum sementara} For i 1 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)
Cara 2: Mencari nilai Maksimal1. Nilai maksimum sementara diinisialisasikan dengan elemen pertama array. 2. selanjutnya, arrray dikunjungi mulai dari elemen kedua 3. setiap kali mengunjungi elemen array, bandingkan elemen tersebut dengan nilai maksimum sementara. 4. jika elemen array yang sedang dintinjau lebih besar dari nilai maksimum sementara, maka (maks) diganti dengan elemen tersebut. 5. pada akhir kunjungan (setelah seluruh elemen array dikunjungi), nilai maksimum sementara menjadi nilai maksimum sebenarnya.
Ilustrasi untuk maks : elemen pertamaA `158 157 162 169 172 155 170 163
1
2
3
4
5
6
7
8
Asumsi : maks = A[1] (nilai maksimum sementara, maks=158) A[2] >maks? Tidak A[3] > maks? Ya A[4] > maks? Ya A[5] >maks? Ya A[6] > maks? tidak A[7] > maks? tidak A[8] >maks? Tidak maks tidak berubah maks A[3] (maks=162) maks A[4] (maks=169) maks A[5] (maks=172) maks tidak berubah maks tidak berubah maks tidak berubah
(proses pembandingan selesai) Didapat : maks = 172 (nilai maksimum array yang ditemukan)
Algoritma untuk maks = Elemen pertamaProgram NilaiMaksumum DEKLARASI : Const N = 8 A : array[1..N] of integer = (158, 157, 162, 169, 172, 155, 170, 163) I, maks : integer
ALGORITMA : Maks A[1] {nilai maksimum sementara} For i 2 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)
Cara 3: Mencari nilai Maksimal Mencari nilai maksimal berdasarkan nomor indeks array. Algoritma : idxMaks 1 for I 2 to n do if A[i] > A[idxMaks] then idxMak I endif endfor
Mencari Nilai Minimum Array (Larik) Mencari elemen larik yang mempunyai nilai terkecil di antara elemen larik lainnya. Konsepnya sama dengan Mencari nilai maksimum array
Latihan Buatlah algoritma untuk mencari nilai terbesar dari data yang sudah tersimpan pada elemen array, dimana nilai yang tersimpan pada elemen array tersebut di baca dari inputan eksternal (keyboard). Konversikan algoritma di atas ke dalam Bahasa Pascal
Menyalin Larik (Array)A ` B `1 2 3 4 5 6 7 8
158
157
162
169
172
155
170
163
1
2
3
4
5
6
7
8
Algoritma Menyalin LarikProgram Salin DEKLARASI: Const maks=100 A:array[1..maks] of integer B:array[1..maks] of integer I,n : integer ALGORITMA: Read(n) {menentukan jumlah elemen yang akan digunakan} {membaca nilai dari inputan eksternal (keyboard)} For I 1 to n do read(A[i]) Endfor {menyalin Larik A ke Larik B} for I 1 to n do B[i] A[i] endfor {Menampilkan nilai elemen array B setelah dilakukan penaylinan dari elemen array A} For I 1 to n do write(B[i]) endfor
Menguji kesamaan dua buah Larik Dilakukan dengan membandingkan setiap elemen yang berpadanan pada ke dua larik tersebut Jika ditemukan satu saja elemen yang tidak sama, maka dapat dipastikan dua buah larik tersebut tidak sama. Apabila semua elemen dari larik itu sama, maka dapat dikatakan dua buah larik itu sama.
Menguji kesamaan dua buah Larik - next123 130 140 160 180
A `
1
2
3
4
5
B `
123 130 140
160
180
1
2
3
4
5
Algoritma menguji kesamaan larikProgram uji DEKLARASI Const maks=5 A:array[1..maks] of integer=(123,130,140,160,180) B:array[1..maks] of integer=(123,130,140,160,180) I : integer Sama : boolean ALGORITMA: I 1 Sama true While (I maks) and (sama) do if A[i] = B[i] then I I + 1 {tinjau elemen berikutnya} else sama false endif Endwhile { I > maks or sama=false } {tampilkan hasil} If sama true then write(dua larik sama) Else write(dua larik berbeda) endif
ARRAY DUA DIMENSI (MATRIKS) Pengertian array dua dimensi : Array dua dimensi dapat dipandang sebagai gabungan array satu dimensi. Ilustrasi :Pandanglah tiga buah array satu dimensi yang dibuat dengan: A1[4], A2[4], A3[4] : dengan tipe data yang sama
ARRAY DUA DIMENSI (MATRIKS)-next Ketiga buah array satu dimensi di atas, dapat digabung menjadi satu, sehingga terbentuk sebuah array yang disebut array dua dimensi, yang dapat diilustrasikan sebagai berikut :
Dari ilustrasi diatas, terlihat array tersebut terdiri dari 3 baris, dan 4 kolom, dan jumlah elemennya = 3 x 4 = 12 elemen, karena terdiri dari baris (row) dan kolom (column) maka arrray dua dimensi sering disebut MATRIX. Karena sudah menjadi satu buah array, maka nama array hanya satu buah, Misalnya A[3] [4] yang maksudnya adalah terdiri barisnya ada 3, dan kolomnya ada 4.
Bentuk Umum Array Dua Dimensi
Array konstan untuk array dua dimensi (matriks) Cotoh: Array Dua Dimensi dengan matriks : 3 x 5, dengan tipe data integer dan char :
Mengisi Elemen Array Dua Dimensi (MATRIKS) Diketahui array dua dimensi : A : array[1..3, 1..4] of integer
Untuk keperluan praktis dan keragaman, indeks untuk baris dan kolom menggunakan variabel. Misal : i untuk baris dan J untuk kolom
Algoritmanya : I 2 J3 A[i, j] 17
Isi Elemen Matriks per baris atau per kolom
Pengisian semua elemen Matriks secara baris perbaris :
Algoritmanya : N 1 I1 While (i