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 POHON
PROGRAM A
SUBPROGRAM A1
SUBPROGRAM A2
SUBPROGRAM A3
SUBPROGRAM A21
SUBPROGRAM A22
ILUSTRASI
DEKLARASI 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 subprogram
DEKLARASI 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)
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
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)
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 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)
DEKLARASI
{semua nama yg dipakai di dalam prosedur dan hanya berlaku lokal di dalam prosedur ini}
ALGORITMA
{badan prosedur, berisi urutan instruksi}
DEKLARASI
Alas, tinggi, luas : real
ALGORITMA
Read(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
Alas, tinggi, luas : real
ALGORITMA
Read(alas, tinggi) Luas (alas * tinggi) / 2 Write(luas)
ALGORITMA HitungLuasSegitiga
KUIS
BUATLAH NOTASI ALGORITMA UNTUK MELAKUKAN PEMANGGILAN PROSEDUR LUASSEGITIGA SEBANYAK 3 X
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
luas : real
ALGORITMA
Luas (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)
Parameter - next
Ketika prosedur dipanggil, parameter aktual berkoresponden satu-satu dengan parameter formal (parameter yg dideklarasikan pada bagian header prosedur)
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
DEKLARASI
luas : real
ALGORITMA
Luas (alas * tinggi) / 2 Write(luas)
Program utama yg memanggil nama prosedur: harus mendeklarasikan nama prosedur dan memanggilnya dg parameter aktual yg sesuai
PROGRAM 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}
DEKLARASI
luas : real
ALGORITMA
Luas (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 nilainya
PROGRAM Segitiga
{menghitung luas N buah segitiga}
DEKLARASI
luas : real
ALGORITMA
Luas (alas * tinggi) / 2 Write(luas)
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.
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}
ALGORITMA
Luas (alas * tinggi) / 2
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
Parameter masukan
parameter masukan/keluaran
PROGRAM 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)
Notasi Algoritma : mencetak perjalan waktu terus menerus dg prosedur paramater masukan/keluaran
Program JamHidup
{membuat jam hidup yg selalu bertambah 1 detik terus menerus sampai jam 00:00:00. Masukan jam dibaca dari piranti masukan (keyboard). Setiap pertambahan 1 detik, jam yg baru ditampilkan sebagai keluaran}
Deklarasi Type jam : record <hh:integer {0..23} mm:integer {0..59} ss : integer {0..59} J :jam Procedure JamBerikutnya(input/output J : Jam)
{Menaikkan jam J dengan satu detik }
ALGORITMA Read(J.hh, J.mm, J.ss) {baca jam awal} Repeat write(J.hh, J.mm, J.ss) {cetak jam sekarang} JamBerikutnya(J) Until (J.hh = 0) and (J.mm =0) and (J.ss = 0) write(J.hh, J.mm, J.ss) {cetak jam 00:00:00}
FUNGSI
Sub Program yg mempunyai tujuan/tugas spesifik Fungsi dan prosedur adalah merupakan sub program yang ekivalen Dalam beberapa masalah penggunaan salah satunya adalah hal yg lebih tepat.
FUNGSI-next
Adalah sub program yg memberikan/mengembalikan (return) sebuah nilai dari tipe tertentu (tipe dasar atau tipe bentukan) Fungsi di dalam program bersesuain dengan definisi fungsi di dalam matematika
Contoh : a.f(x) = 2X2 + 5X 8 b. h(x,y) = 3x y +xy Dimana: f dan h adalah nama fungsi, sedangkan x dan y adalah parameter fungsi yg bersangkutan. Nilai yg diberikan oleh fungsi bergantung pada masukan parameter Misal : x=2, maka f(2) = 2*22 + 5*2 = 10 x=1, y=2, maka h(1,2) = 3*1 2+1*2=3 Nilai 10 dan 3 adalah nilai yang diberikan (return) oleh masing fungsi f dan fungsi h.
FUNGSI - next
Parameter pada fungsi disebut juga dengan parameter formal Parameter pada fungsi selalu merupakan sebagai parameter masukan yg digunakan oleh fungsi tsb untuk menghasilkan nilai. Fungsi tidak mempunyai parameter keluaran atau parameter masukan/ keluaran
FUNGSI - next
Struktur fungsi sama dengan Struktur prosedur (Header(judul), deklarasi, algoritma(badan fungsi)) Fungsi diakses dengan memanggil nama fungsi tsb.dari program yg memanggilnya. (sama dengan prosedur).
Struktur fungsi
Function NamaFungsi(input deklarasi parameter, jika ada) tipe ( tipe nilai yg diberikan oleh fungsi)
{spesifikasi fungsi, menjelaskan apa yang dilakukan dan yang dikembalikan oleh fungsi}
DEKLARASI
{semua yg dipakai di dalam fungsi dan hanya berlaku di dalam fungsi didefinisikan di sini}
ALGORITMA
{badan fungsi, berisi instruksi-instruksi untuk menghasilkan nilai yg akan dikembalikan oleh fungsi}
return ekspresi
Catatan : parameter formal selalu berjenis parameter masukan, sehingga parameter formal selalu diawal dengan keyword INPUT Ekspresi : dapat berupa konstanta, peubah(variabel) atau sebuah rumus
Struktur fungsi
Fungsi untuk menghasilkan nilai f(x)=2x2+5x-8, x R
Function f(input x : real) real {mengembalikan nilai f(x) = 2x2+5x-8, x R Deklarasi { tidak ada } Algoritma return 2*x*x + 5*x 8
______________________________________________
Catatan : f adalah nama fungsi dengan tipe real x adalah paramater formal dengan tipe real 2*x*x + 5*x 8 : nilai yg dihasilkan oleh fungsi Return : mengembalikan hasil dari ekspresi 2*x*x + 5*x 8
Kuis
Buatlah contoh fungsi untuk meghitung nilai dengan dua parameter formal dengan tipe bilangan bulat
Fungsii untuk menentukan bilangan genap atau ganjil Function Genap(input n : integer) boolean
{ true jika n adalah bilangan genap, atau false jika tidak genap }
Deklarasi
{ tidak ada }
{ ekspresi BOOLEAN }
tanpa peubah
Function NamaHari(input har : integer) string { mengembalikan nama hari berdasarkan nomor har} DEKLARASI { tidak ada } Algoritma: case har 1: return Senin 2: return Selasa 3: return Rabu 4: return Kamis 5: return Jumat 6: return Sabtu 7: return Minggu endcase
{ sandi-lewat yg benar }
Pemanggilan FUNGSI
Fungsi di akses dengan cara memanggil namanya diikuti dengan parameter aktual (kalau ada)
Peubah NamaFungsi(parameter aktual, jika ada)
Nilai yang dikembalikan oleh fungsi dapat langsung dimanipulasi. Contoh : write(F(5)) If Genap(m) then
output : ----------------------------x f(x) ----------------------------10.0 242.0 10.2 251.08 10.4 14.8 15.0 ------------------------------
Deklarasi
{ tidak ada }
write(------------------------------) write( x f(x) ) write(------------------------------) x 10.0 while x < 15.0 do write(x, ,f(x)) x x + 0.2 endwhile
{buat garis penutup}
write(----------------------------)
Deklarasi Sandi : string { kata sandi yg dibaca dari keyboard } sah : boolean { true jika password benar, false jika password salah} i : integer { pencatat jumlah pembacaan sandi } function valid(input p : string) boolean { true jika password p benar, atau false jika salah } Deklarasi const password = abc123 { sandi-lewat yg benar } Algoritma: return (p=password) Algoritma: i1 sah < false repeat read(sandi) if valid(sandi) then sah true else ii+1 endif until (sah) or ( i > 3) if not sah then write(password salah, anda tidak punya hak mengakses sistem) endif
Prosedur
Function TentukanMaks(input a,b:integer, output maks :integer) Deklarasi Algoritma if a b then maks a else maks b endif
Procedure hitungrata2(input ndata:integer, output u: real) Deklarasi x: integer I : integer jumlah : integer Algoritma: jumlah 0 for I 1 to Ndata do read (x) jumlah jumlah + x endfor U jumlah/Ndata
Procedure Rata2(input ndata:integer) real Deklarasi x: integer I : integer jumlah : integer Algoritma: jumlah 0 for I 1 to Ndata do read (x) jumlah jumlah + x endfor return jumlah/Ndata
Rekursif
Fungsi Rekursif Fungsi rekursif adalah fungsi yang memanggil dirinya sendiri. Fungsi ini akan terus berjalan sampai kondisi berhenti terpenuhi. oleh karena itu dalam sebuah fungsi rekursif perlu terdapat 2 blok penting :
BASIS : yaitu blok yang menjadi titik berhenti dari sebuah proses rekursi (memberi nilai yang terdefinisi pada fungsi rekursif) REKURENT: yaitu blok yang memanggil dirinya sendiri.
Pengertian REKURSIF
Suatu proses dari suatu subprogram (prosedur atau fungsi) yang memanggil dirinya sendiri
Proses rekursif
Suatu algoritma yg baik dan dapat membuat pemecahan masalah menjadi lebih mudah. Proses rekursif pengggunaan memori akan sangat besar, karena setiap kali suatu subprogram dipanggil, maka akan diperlukan sejumlah memori tambahan
Kondisi pengakhiran suatu proses rekursif dapat dilakukan dengan memberikan konstruksi penyeleksian kondisi sehingga proses rekursif akan berhenti jika kondisi yg ditetapkan telah terpenuhi Contoh: Procedur rekursif Deklarasi Algoritma: If batas < 7 then Write (Informatika UHAMKA) Batas batas + 1 Rekursif endif
Notasi algoritma :
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
Contoh: untuk menampilkan suatu deret bilangan bulat positif N dari 0 sd. 10
Prosedur deret(input n word) Deklarasi Algoritma: Write(N:3) If N < 10 then Deret(N+1) endif 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)
Ide dasar dalam memecahkan suatu masalah dengan rekursif adalah sebagai berikut: 1. Tentukan kasus penyetop atau kasus dasar di mana pemanggilan rekursif tidak lagi diperlukan (karena solusinya sudah diperoleh) 2. Terapkan suatu langkah untuk menggiring kasus kompleks ke kasus penyetopnya dengan metode yang mencerminkan fungsinya
contoh : Masalah yang akan dipecahkan adalah memotong roti tawar tipistipis sampai habis. Jika masalah ini akan dipecahkan secara rekursif, maka solusinya adalah:
1. Jika roti sudah habis atau potongannya sudah paling tipis, pemotongan roti selesai 2. Jika roti masih bisa dipotong, potong tipis dari tepi roti tersebut, lalu
lakukan prosedur 1 dan 2 untuk sisa potongannya.
Contoh fungsi rekursif misalnya adalah fungsi pangkat, faktorial, dan barisan fibonacci. Dalam fungsi pangkat xy , kita tahu bahwa semua bilangan selain 0, jika dipangkatkan dengan 0 nilainya sama dengan 1. Jika x dipangkatkan dengan y, dengan y lebih dari 0, maka hasilnya sama dengan x dikalikan dengan x dipangkatkan y 1. Jika dituliskan dalam notasi matematika definisinya adalah sebagai berikut: xy = 1, jika y=0 xy = x * xy-1, jika y > 0 Kita lihat di atas pada definisi y > 0, bentuk pemangkatan muncul kembali di sisi kanan. Itulah yang disebut rekursif
Definisi rekursif selalu dimulai dengan kasus penyetop, penghenti, atau kasus dasar dari suatu permasalahan, dalam hal ini terjadi ketika nilai y = 0. Definisi rekursif yang lebih kompleks mengandung inti dari permasalahan yang akan dipecahkan, namun lebih sederhana. Dalam hal ini yang tadinya x dipangkatkan dengan y, kini bentuk pemangkatan menjadi lebih sederhana, yaitu y 1. Hal ini dimaksudkan untuk menggiring masalah kompleks ke kasus dasar atau penyetop rekursinya
Untuk x = 10 dan y = 0, hasil dari xy adalah 1. Untuk x = 10 dan y = 3 hasilnya dapat digambarkan sebagai berikut:
Algoritma Pangkat
Fungsi PangkatRekursif(input x, y: integer): integer
{mengembalikan nilai xy, y > 0 basis : xy = 1 jika y = 0 rekurens : xy = a x xy-1 }
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.
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)
ALGORITMA: if nilai <= 0 then return 1 else return nilai*faktorial (nilai-1) endif
Menghitung nilai FAKTORIAL-dalam bahasa PAscal function faktorial (nilai : integer) : integer; begin if nilai <= 0 then faktorial := 1 else faktorial := nilai * faktorial (nilai-1) end;
Var N : integer; Begin Write(Berapa faktorial ? ); Readln(N); Writeln(N, faktorial = ,faktorial(N)); End.
Pseudo-code
function faktorial (input nilai : integer) : integer DEKLARASI ALGORITMA: if nilai <= 0 then return 1 else return nilai*faktorial (nilai-1) endif
- Bahasa Pascal
function faktorial (nilai : integer) : integer; begin if nilai <= 0 then faktorial := 1 else faktorial := nilai*faktorial (nilai-1) end;
if n <= 1 then hasil:=1 else begin faktorial(n-1, hasil); hasil:= N*hasil; end; end; begin write('Faktorial yg dihitung ?'); readln(N); faktorial(N,f); writeln('faktorial ',N,' adalah:', f); end.
Fungsi
function faktorial (nilai : integer) : integer; begin if nilai <= 0 then faktorial := 1 else faktorial := nilai * faktorial (nilai-1) end; Var N : integer; Begin Write(Berapa faktorial ? ); Readln(N); Writeln(N, faktorial = ,faktorial(N)); End.
- Prosedur
procedure faktorial(N:byte; var hasil:longint); begin if n <= 1 then hasil:=1 else begin faktorial(n-1, hasil); hasil:= N*hasil; end; end; begin write('Faktorial yg dihitung ?'); readln(N); faktorial(N,f); writeln('faktorial ',N,' adalah:', f); end.
Barisan FIBONANCI
Barisan Fibonanci: F (0) = 0
F (1) = 1 F (n) = F ( n-1 ) + F (n-2); untuk n >1 ____________________________________________ Function fibonacci ( input n : integer ) : integer Deklarasi Algoritma: If n 0 then return 0 Else If n 1 then return 1 Else return fibonacci (n-1) + fibonacci (n-2) Endif endif
Bahasa pascal
Function fibonacci ( n : integer ) : integer; Begin If n = 0 then fibonacci := 0 Else If n := 1 then fibonacci := 1 Else fibonacci := fibonacci (n-1) + fibonacci (n-2); End;
Pseudo-code
Function fibonacci ( input n : integer ) : integer Deklarasi Algoritma: If n 0 then return 0 Else If n 1 then return 1 Else return fibonacci (n-1) + fibonacci (n-2) Endif endif
- Bahasa Pascal
Function fibonacci ( n : integer ) : integer;
Begin If n = 0 then fibonacci := 0 Else If n := 1 then fibonacci := 1 Else fibonacci := fibonacci (n-1) + fibonacci (n-2); End;
Latihan
1. Buat Algoritma untuk menghitung deret S = 1+2+3+4+5+...+n menggunakan function rekursif 2. Buatkanlah program dengan bahasa pascal lengkap untuk Algoritma di atas.
Array (Larik)
Array yaitu yang berbaris-baris atau berderet-deret. Dalam pemrograman : deretan data yang mempunyai jenis atau tipe data yang sama. Nama Array mewakili deret data dia miliki.
Contoh: A:array[1..5] of integer
A adalah nama array
Definisi Array
Adalah sebuah peubah (variabel) yang mempunyai struktur data yang dapat menyimpan lebih dari satu nilai yang sejenis (tipe data yang sama), setiap elemen diacu melalui indeksnya. Elemen array tersusun di memori secara berurutan (sekuensial), oleh sebab itu indeks array(larik) haruslah tipe data yang menyatakan keterurutan, misalnya integer atau karakter.
Elemen Array
I n d e k s I n d e k s
1 2 3 4 5
Elemen Array kosong
Deklarasi Array
Sesuatu yang akan digunakan/dipakai dalam suatu program terlebih harus dideklarasikan Array (Larik) adalah struktur(susunan) data yg statis, artinya elemen larik harus sudah diketahui sebelum program dieksekusi. Jumlah elemen larik tidak dapat diubah (ditambah/dikurangi) selama pelaksanaan program (program running). Mendeklarasikan larik di dalam bagian deklarasi berarti :
mendefinisikan banyaknya elemen larik (memesan tempat di memori) mendefinisikan tipe elemen larik (menetapkan tipe nilai yg dapat disimpan oleh larik (array).--> tipe data dapat berupa : tipe dasar/sederhana (integer, real, char, string, Boolean), tipe bentukan (tipe terstruktur :record)
ALGORITMA :
For i:=1 to max do read(n[i]) Endfor
Pengsian Nilai per field : Mhs[i].NIM 102131002 Mhs{i].NAMA BUDI UTOMO Mhs[i].IPK 3.6
Menampilkan hasil per field : Output([Mhs[i].NIM, Mhs[i].NAMA, Mhs[i].IPK)
{indeks Array}
ALGORITMA :
For i:=1 to max do pemrosesan terhadap A[i]) Endfor
Procedure BacaLarik2(Output A: Larikint, Output n: integer) {K. Awal : sembarang} {K. Akhir : sebanyak n buah elemen larik A berisi nilai-nilai yang dibaca; n berisi jumlah elemen larik yang diisi} DEKLARASI Jawab : char ALGORITMA N0 Repeat nn+1 Read(A[n]) Write(Lagi? (y/t)) Read(jawab) Until jawab = t
Jumlah elemen efektif baru diketahui di akhir pembacaan (variasi dari versi 2)
Proses pembacaan dianggap selesai jika nilai yang dibaca adalah suatu tanda, misalnya 9999.
DEKLARASI x : integer {menyimpan sementara nilai yang di baca} ALGORITMA n0 read(x) while x 9999 do n n +1 A[n] x read(x) endwhile
{x = 9999}
ALGORITMA
I 1 {dimulai dari elemen pertama} Jumlah 0 {jumlah total nilai mula mula} For i 1 to n do jumlah jumlah + A[i] Endfor U jumlah/n
ALGORITMA read(n) {tentukan jumlah elemen larik yang akan digunakan } BacaLarik1(A, n) HitungRataRata(A, n, u) write(u)
latihan
Buatlah algoritma tanpa menggunakan prosedur (sub program) untuk menghitung nilai-nilai rata-rata dari data yang tersimpan pada elemen array(larik) yang bertipe integer. Konversikan algoritma tersebut ke dalam bahasa pascal.
ARRAY KONSTAN :
Nilai yang terkandung di dalam sebuah array dapat bernilai konstan, artinya nilai-nilai tersebut tidak dapat diubah. mendeklarasikan array bersangkutan dengan kata kunci CONST. Bentuk umumnya adalah sbb: Const NamaArray : array[IndekAwal..IndekAkhir] of tipe_data = (nilai1, nilai2, ...);
Array A di atas bersifat konstan, maka nilai yang ada tidak digantikan dengan nilai lainnya. Contoh : A[1] V { SALAH, Karena elemen A[1] selalu bernilai A} A[2] W {SALAH, Karena elemen A[2] selalu bernilai B} A[3] X { SALAH, Karena elemen A[3] selalu bernilai C} A[4] Y {SALAH, Karena elemen A[4] selalu bernilai D} A[5] Z { SALAH, Karena elemen A[5] selalu bernilai E}
Kalau elemen larik sudah terurut baik secara ascending maupun descending, maka nilai maksimum langsung bisa diperoleh : Ascending pada elemen terakhir, Descending pada elemen pertama
Permasalahan muncul bila nilai elemen array tesusun secara acak, maka untuk mencari nilai maksimumnya harus mengunjungi seluruh elemen array.
Asumsi : maks = -9999 (nilai maksimum sementara) A[1] > maks? Ya 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 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 : Maks -9999 {nilai maksimum sementara} For i 1 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)
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 : Maks A[1] {nilai maksimum sementara} For i 2 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)
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
158
157
162
169
172
155
170
163
A `
B `
160
180
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.
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
Algoritmanya : N 1 I1 While (i<=3) J 1 While ( j<= 4) A[i, j] N N++ J++ Endwhile I++ Endwhile
Algoritmanya : X 1 NX J1 While (J <= 4) i 1 While ( i <= 3) A[i, j] N N+4 i++ Endwhile X++ NX J++ Endwhile
Mengisi Elemen Array Dua Dimensi, dengan Nilai yang diinput dari Keyboard :
Misalnya Array Dua Dimensi dengan Matrik 3 x 5. isikan nilai kedalam elemen matrik tersebut.
Algoritmanya : I1 While (i<=3) J 1 While ( j<= 5) Read(nilai) A[i, j] nilai J++ Endwhile I++ endwhile
Latihan 1:
diketahui matriks 3 x4 untuk array dua dimensi, Buatlah algoritma untuk melakukan inisialisasi nilai (nilai konstan) pada array dua dimensi tersebut dengan tipe data integer. Dan cetak/tampilkanlah nilai dari masing-masing elemen dari matriks tersebut di atas. Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.
Latihan 2:
diketahui matriks 3 x4 untuk array dua dimensi, Buatlah algoritma dengan menginputkan nilai dari inputan eksternal (keyboard) ke dalam masing elemen matriks di atas dengan tipe data integer. Dan cetak/tampilkanlah nilai dari masingmasing elemen dari matriks tersebut. Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.
Algoritmanya : For i=1 to i<= 3 do For j=1 to j <=4 do B[i,j] A[i,j] Endfor Endfor
MENGHITUNG TOTAL ISI ARRAY DUA DIMENSI Algoritmanya : TOT 0 I1 While (i<=3) do J1 While (J <= 4) do TOT TOT + A[i,j] J++ Endwhile I++ Endwhile Write (TOT )
Algoritmanya : I 1 While (i <= 3 ) do J 1 While ( J <= 4 ) do C[i,j] A[i,j] + B[i,j] J++ Endwhile I++ Endwhile
Catatan : Syarat dua buah matriks dapat dikalikan adalah : Jumlah kolom matriks ke 1 harus sama dengan jumlah baris matriks ke 2. Sedangkan hasilnya adalah matriks ke 3, yaitu jumlah baris matriks ke 3 (matriks hasil) sama dengan jumlah baris matriks ke 1, dan jumlah kolomnya (matriks 3) sama dengan jumlah kolom matriks ke 2.
Secara umum 8 persamaan di atas, dapat ditulis sebagai berikut : C[i,j] = (A[i,k] * b[k,j] ) Dimana : K dipakai untuk : COL pada array A dan ROW pada array B, dan untuk suatu nilai i dan j, nilai k bergerak 1 sd. 3
Latihan 1:
diketahui matriks 3 x4 untuk array dua dimensi, Buatlah algoritma untuk menghitung nilai total dari matriks tersebut sedang nilai didapat dengan melakukan inisialisasi nilai (nilai konstan) pada array dua dimensi tersebut dengan tipe data integer. Dan cetak/tampilkanlah nilai total dari matriks di atas. Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.
Latihan 2:
diketahui matriks A=2 x3 dan matrisk B=3x4, Buatlah algoritma untuk menghitung hasil perkalian dua buah matriks. Sedang nilai dari dua buah matriks tersebut didapat dengan melakukan inisialisasi nilai (nilai konstan) pada dua matriks tersebut dengan tipe data integer. Dan cetak/tampilkanlah hasil perkalian dua matriks tersebut. Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.
TUGAS
Algoritma Pencarian
Proses pencarian adalah menemukan nilai (data) tertentu dalam sekumpulan data yang bertipe sama (tipe dasar atau tipe bentukan) larik (array) Pencarian (searching) merupakan proses yg mendasar dalam pengelohana data.
Contoh: UPDATE, INSERT.
Larik A mempunyai dua buah nilai 42, maka algoritma selesai ketika nilai 42 pertama ditemukan, yaitu pada elemen ke-6, dan hasilnya adalah idx = 6, atau ketemu = true. Nilai 42 lainnya tidak dipertimbangkan lagi dalam pencarian.
Misalkan nilai yang dicari adalah 42 Pemeriksaaan dilakukan terhadap elemen 60, 12, 76, 23, 11, 42 (ditemukan) Ternyata nilai ditemukan pada elemen ke 6 : Indek larik yang dikembalikan : idx 6 Proses pencarian dihentikan. Misalkan nilai yang dicari adalah 20 Pemeriksaan dilakukan terhadap elemen 60, 12, 76, 23, 11, 42, 18, 42 (tidak ditemukan) Ternyata nilai tidak ditemukan di dalam array, Indeks larik yang dikembalikan : idx -1 Proses pencarian dihentikan.
Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output ketemu:boolean) Deklarasi : I : integer Algoritma : I1 While(i<n) and (A[i] x) do I I +1 Endwhile If A[i] = x then ketemu true {x ditemukan} Else ketemu false {x tidak ada dalam larik A} endif
Function cariberuntun(input A:Larikint, input n:integer, input x :integer) boolean Deklarasi: I : integer Algoritma: I1 While(i<n) and (A[i] x) do I I +1 Endwhile If A[i] = x then return true {x ditemukan} Else return false {x tidak ada dalam larik A} endif
n:integer)
Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output ketemu:boolean) Deklarasi : I : integer Algoritma : I1 While(i<n) and (A[i] x) do I I +1 Endwhile If A[i] = x then ketemu true {x ditemukan} Else ketemu false {x tidak ada dalam larik A} Endif ALGORITMA : read(n) bacaLarik(A,, n) read (x) cariberuntun(A, n, x, found) if found = true then write(x, ditemukan) else write(x, tidak ditemukan) endif
Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output idx: integer) Deklarasi : I : integer Algoritma : I1 While(i<n) and (A[i] x) do I I +1 Endwhile If A[i] = x then idx i {x ditemukan} Else idx -1 {x tidak ada dalam larik A} endif
Function cariberuntun(input A:Larikint, input n:integer, input x :integer) integer Deklarasi: I : integer Algoritma: I1 While(i<n) and (A[i] x) do I I +1 Endwhile If A[i] = x then return i {x ditemukan} Else return -1 {x tidak ada dalam larik A} endif
Kasus : versi 1
menambah (append) nilai/data ke dalam larik (array)
Tentukan atau lakukan pencarian apakah data/nilai tersebut sudah ada dalam array. Jika belum ada, maka nilai/data tersebut ditambahkan pada elemen ke n+1. Penambahan satu elemen baru tidak melampaui ukuran maksimal larik(array) (Nmaks). Setelah penambahan elemen baru, ukuran larik(array) efektif menjadi n+1.
Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output idx:integer) Deklarasi : I : integer Algoritma : I1 While(i<n) and (A[i] x) do I I +1 Endwhile If A[i] = x then idx i {x ditemukan} Else idx -1 {x tidak ada dalam larik A} Endif ALGORITMA : read(n) bacaLarik(A,, n) read (x) cariberuntun(A, n, x, idx) if idx -1 then write(x, sudah terdapat di dalam larik) else n n + 1 { naikkan ukuran larik } A[n] x { tambahkan nilai x} endif
Hasil pencarian yg diinginkan: sebuah peubah boolean yg bernilai true bila nilai ditemukan atau bernilai false bila data/nilai tidak ditemukan Algoritma : Diperlukan sebuah peubah boolean untuk menyatakan apakah nilai sudah ditemukan. Peubah boolean (misal. Ketemu) diinisialisasi dg nilai false. Setiap elemen array dibandingkan dengan nilai/data yg dicari mulai dari elemen pertama Jika A[i] = nilai/data yang dicari, peubah Ketemu diisi dengan nilai true, pengulangan dihentikan. Sebaliknya, jika A[i] nilai yg dicari, pembandingan dilanjutkan untuk elemen berikutnya. Keluaran yg dihasilkan adalah nilai yg disimpan di peubah(variabel) ketemu.
Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output ketemu:boolean) Deklarasi : I : integer Algoritma : Ketemu false I1 While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I I +1 endif Endwhile { I > n or ketemu }
Function cariberuntun(input A:Larikint, input n:integer, input x :integer) boolean Deklarasi: I : integer Algoritma: Ketemu false I1 While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I I +1 endif Endwhile { I > n or ketemu } return ketemu
Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output idx: integer) Deklarasi : I : integer ketemu : boolean Algoritma : Ketemu false I1 While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I I +1 endif Endwhile { I > n or ketemu } if ketemu true then idx 1 else idx -1 endif
Function cariberuntun(input A:Larikint, input n:integer, input x :integer) integer Deklarasi: I : integer ketemu : boolean Algoritma: Ketemu false I1 While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I i +1 endif Endwhile { I > n or ketemu } if ketemu true then return 1 else return -1 endif
3. Ulangi langkah 1
Sequential Search
Binary Search
1. Dapat digunakan baik untuk data yg belum terurut maupun data terurut 2. Kinerja lebih lambat
Semua algoritma pengurutan selalu melakukan operasi perbandingan elemen larik untuk mendapatkan urutan yg tepat.
Klasifikasi pengurutan :
Pengurutan internal :
Pengurutan untuk data yg disimpan di dalam memori komputer ( pengurutan Array / larik )
Pengurutan eksternal :
Pengurutan untuk data yg disimpan di dalam disk storage ( pengurutan arsip / file )
{pertukaran maks dengan A[i]} temp := A[i]; A[i] := maks; A[imaks] := temp; end; {menampilkan data setelah proses pengurutan} Writeln; Writeln('Data setelah diurutkan'); For i := 1 to N do begin Writeln('A[', i, '] = ', A[i]); End; End.
Deklarasi : I : integer { pencacah pass (melewati 1 kali larik) } J : integer { pencacah untuk penelusuran/penyisiran larik } Y : integer { peubah bantu agar A[k] sebagai posisi yg tepat untuk disisipkan tidak ditimpa selama pergeseran} Ketemu : boolean { untuk menyatakan posisi penyisipan ditemukan } Algoritma : { elemen A[1] dianggap sudah terurut} For I 2 to n do { mulai dari pass 2 sampai pass N } y A[i] { cari posisi yg tepat untuk y di dalam A[1..i-1] sambil menggeser } j j -1 ketemu false while ( j 1 ) and (not ketemu) do if y < A[j] then A[ j + 1] A [ j ] { geser } jj1 else ketemu true endif endwhile { J < 1 or ketemu } A[ j + 1 ] y { sisipkan y pada tempat yang sesuai } endfor
Contoh :
Diketahui Larik dengan n=5 dibawah ini yg belum terurut, larik (array) ini akan diurut menaik (Ascending) dengan metode pengurutan sisip (insertion sort) :
Pass 3 : ( I = 3) Y = 10 (angka yg akan disisipkan) J = i-1 (mulai penyisiran) J = 3-1= 2 Y < A[J] (bandingkan) 10 < 29 yes A[J+1] = A[j] (geser) A[3] = A[2] A[3] = 29 J = J 1 ( penyisiran ) J = 2-1 = 1 Y < A[j] (bandingkan) 10 < A[1] 10 < 27 yes A[j+1] = A[j] A[2] =A[1] A[2] = 27 J = j 1 (penyisiran) J = 1 1 = 0 (batas penyisiran) A[j+1] = y A[1] = 10 (menempatkan angka yg akan disisipkan di tempat yg sesuai)
Pass 4 : ( I = 4) Y = 8 (angka yg akan disisipkan) J = i-1 (mulai penyisiran) J = 4-1= 3 Y < A[J] (bandingkan) 8 < 29 yes A[J+1] = A[j] (geser) A[4] = A[3] A[4] = 29 J = J 1 ( penyisiran ) J = 3-1 = 2 Y < A[j] (bandingkan) 8 < A[2] 8 < 27 yes A[2+1] = A[2] A[3] =A[2] A[2] = 27 J = j 1 (penyisiran) J=21=1 Y < A[j] (bandingkan) 8 < A[1] 8 < 10 yes A[J+1] = A[j] (geser) A[2] = A[1] A[2] = 10 J = j 1 (penyisiran) J = 1 1 = 0 (batas penyisiran) A[j+1] = y A[1] = 8 (menempatkan angka yg akan disisipkan di tempat yg sesuai)
Pass 5 : ( I = 5)
Y = 76 (angka yg akan disisipkan) J = i-1 (mulai penyisiran) J = 5-1= 4 Y < A[J] (bandingkan) 76 < 29 no Ketemu = true (posisi penyisipan ditemukan) L[j+1] = y A[5] = 76 (menempatkan angka yg akan disisipkan di tempat yg sesuai)
Contoh :
Gambar di atas ada tiga buah rekaman yg memiliki kolom nim, nama, dan nilai Sebuah baris dari setiap kolom disebut dg rekaman (record). Dalam sebuah arsip beruntun (sequential file) biasanya terdiri dari banyak rekaman. Sebuah rekaman (record) dapat terdiri dari beberapa kolom data tergantung dari kebutuhan.
Contoh :
EOF (end of file) : akhir dari sebuah file (contoh : xxxxxxx xxx x). Merupakan akhir dari sebuah arsip (File). Rekaman penanda akhir file disebut dg dummy artinya elemen data yg ditambahkan tapi sebenarnya bukan bagian dari data. Dummy biasa digunakan untuk memudahkan suatu proses.
DEKLARASI type nama tipe arsip : file of tipe rkaman arsip : nama tipe arsip
Arsip (file) Bil yg berisi sekumpulan bilangan bulat. Setiap rekaman adalah bilangan bulat DEKLARASI Bil : file of integer
DEKLARASI { tipe rekaman} Type Datamhs : record < nim : integer nama : string nilai : char > { arsip } Mhs : file of Datamhs
Fungsi Pustaka untuk arsip beruntun Untuk pemrosesan arsip perlu mendefinisikan beberapa intruksi baku (fungsi yg sudah tersedia). Instruksi baku itu dinyatakan sebagai fungsi/prosedur pustaka (library function). Sejumlah intruksi baku untuk pemrosesan arsip beruntun adalah: open, fread, fwrite, close, eof.
open
Fungsi : Membuka asip beruntun untuk siap dibaca/ ditulis. Setelah memanggil fungsi ini, penunjuk arsip (file pointer) akan menunjuk ke karakter pertama di awal arsip Sebuah arsip beruntn yg dibuka (open) hanya bisa untuk masukan (dibaca) saja atau sebagai keluaran (ditulis) saja, tidak sekaligus keduanya (dibaca dan ditulis). Contoh : open(Mhs, 1) { arsip Mhs dibuka untuk dibaca } open(Bil, 2) { arsip Bil dibuka untuk ditulis } open(Kar, 1) { arsip Kar dibuka untuk dibaca }
Fread
Fungsi : Membaca rekaman yang sekarang sedang ditunjuk oleh pointer. Contoh : Fread(Mhs, RekMhs) { RekMhs bertipe DataMhs } Fread(Bil, I) { I bertipe integer }
Andai pointer pembacaan sekarang sedang menunjuk ke awal rekaman ke-2, maka hasil perintah Fread adalah : RekMhs berisi <004,Shalahudin,B> Selanjutnya, pointer akan menunjuk ke awal rekaman ke-3, dan siap untuk membaca rekaman tersebut.
Fwrite
Fungsi : Menulis rekaman ke dalam arsip beruntun. Contoh : RekMhs.Nim 456087 RekMhs.Nama Andi RekMhs.Nilai A Fwrite(Mhs, RekMhs) {simpan RekMhs ke arsip Mhs}
Fwrite(Bil, 765) {menuliskan nilai 765 ke arsip Bil} Fwrite(Kar, B) { menuliskan karakter B ke arsip Kar }
Close
Fungsi : Menutup Arsip yang sudah dibuka. Contoh : close(Mhs) { menutup arsip Mhs } close(Bil) close(Kar) Arsip sudah ditutup, tidak dapat diproses lagi.
if RekMhs.IP > 2.0 then Jumlah Jumlah + 1 endif endwhile { EOF (Mhs) } Close(Mhs) { tutup arsip Mhs}
Menyalin sebagian data dari arsip (menyalin data mahasiswa yang IP-nya di atas 2.0
ALGORITMA : Open (Mhs1, 1) { buka arsip Mhs1 untuk pembacaan } Open (Mhs2, 2) { buka arsip Mhs2 untuk penulisan } While not EOF(Mhs1) do fread(Mhs1, RekMhs) { baca rekaman dari arsip Mhs1 } if RekMhs.IP > 2.0 then Fwrite(Mhs2, RekMhs) { salin Rekmhs dg IP > 2.0 ke arsip Mhs2} endif Endwhile Close(Mhs1) Close(Mhs2)
Contoh :
Tugas
dikumpulkan minggu depan (29 Juni 2011)
Buatlah Algoritma lengkap untuk penggabungan 2 buah Arsip (File) data Mahasiswa dengan ketentuan :
Arsip (File) pertama berisi 5 Rekaman (record). Arsip (File) kedua berisi 3 rekaman (record) Data Mahasiswa tersebut terdiri dari NIM, NAMA dan IPK Arsip (File) Gabungan disimpan pada Arsip (File) ketiga