08 faktorial
TRANSCRIPT
Rancangan Analisa Algoritma
Program Faktorial dengan Metode
Brute Force
Oleh:
Nurdiah Okvitasari 09.04.111.00109
Okie Maria A. 09.04.111.00123
Umy Fatmawati 09.04.111.00128
JURUSAN TEKNIK INFORMATIKA
FAKULTAS TEKNIK
UNIVERSITAS TRUNOJOYO
2011
A. Brute Force
Brute force adalah sebuah pendekatan yang lempang (straightforward)
untuk memecahkan suatu masalah, biasanya didasarkan pada pernyataan masalah
(problem statement) dan definisi konsep yang dilibatkan.
Algoritma brute force memecahkan masalah dengan sangat sederhana,
langsung dan dengan cara yang jelas (obvious way).
B. Perhitungan Kompleksitas Waktu untuk Algoritma Rekursif
Untuk bentuk rekursif, digunakan teknik perhitungan kompleksitas dengan
relasi rekurens. Pada program perpangkatan, kompleksitas waktunya yaitu:
a. untuk kasus basis, kompleksitas waktu algoritma berdasarkan operasi yang
dilakukan. Jika tidak ada operasi → (0)
b. untuk kasus rekurens, kompleksitas waktu diukur dari jumlah operasi
ditambah kompleksitas waktu fungsi.
C. Source Code Program (Bahasa Pascal)
Program macam_Faktorial;Uses Wincrt;Var i,n,k,pil:integer;x: real;ulang : char;
procedure faktorial;var i, n : integer;beginWriteln('Program Faktorial');Writeln('=================');Writeln;Write('Masukkan Nilai Faktorial: ');Readln(n);Writeln;Beginx:= 1;For i := 1 to n dox:=x*i;Writeln('Hasil Faktorial: ',x:0:0);end;end;
procedure kombinasi;var fn,fk, fn_k, kombinasi: real;beginWriteln('Program Kombinasi');writeln('Kombinasi = n!/k!(n-k)!');Writeln('=================');Writeln;Write('Masukkan Nilai n: ');Readln(n);Write('Masukkan Nilai k: ');Readln(k);Writeln;beginfn:=1;for i:=1 to n dofn:=fn*i;end;beginfk:=1;for i:=1 to k dofk:=fk*i;end;beginfn_k:=1;for i:=1 to (n-k) dofn_k:=fn_k*i;end;beginkombinasi :=fn/(fk*fn_k);writeln(n,' Kombinasi ',k,' = ',kombinasi:0:0);end;end;
procedure permutasi;var fn, fn_k, permutasi: real;beginWriteln('Program Permutasi');writeln('Permutasi= n!/(n-k)!');Writeln('=================');Writeln;Write('Masukkan Nilai n: ');Readln(n);Write('Masukkan Nilai k: ');Readln(k);Writeln;beginfn:=1;for i:=1 to n dofn:=fn*i;end;beginfn_k:=1;for i:=1 to (n-k) do
fn_k:=fn_k*i;end;beginpermutasi :=fn/fn_k;writeln(n,' Permutasi ',k,' = ',permutasi:0:0);end;end;
beginrepeatclrscr;writeln('selamat mencoba program operasi faktorial');writeln('1. Faktorial ');writeln('2. Kombinasi ');writeln('3. Permutasi ');writeln('silahkan tentukan pilihan anda:');readln(pil);clrscr;case pil of1 :begin
faktorial; end;2 :begin kombinasi; end;3 :begin permutasi; end;
end;writeln;writeln;write ('Anda Ingin mengulang Lagi? [Y/N] : ');readln(ulang);ulang := Upcase(ulang);until (ulang <> 'Y');Donewincrt ;end.
D. Penjelasan Source Code
Dalam program yang kami kerjakan terbagi menjadi 4 bagian, yaitu
1. Procedure faktorial
Di dalam procedure ini menunjukkan bagaimana cara menghitung
factorial, dimana x=1 sebagai angka acuan atau patokan dalam memulai
menghitung. Di ikuti dengan i yang mengalami perulangan hingga n.
Beginx:= 1;For i := 1 to n dox:=x*i;
2. Procedure kombinasi
Di dalam procedure ini menunjukkan bagaimana cara menhitung kombinasi dengan cara C= n!/k!(n-k)!.Di mulai dengan menghitung n! : begin
fn:=1;for i:=1 to n dofn:=fn*i;end;
k! : beginfk:=1;for i:=1 to k dofk:=fk*i;end;
(n-k)! : beginfn_k:=1;for i:=1 to (n-k) dofn_k:=fn_k*i;end;
dalam ketiga rumus diatas memiliki metode yang sama dengan procedure faktorial no.1.
Terakhir kita menghitung rumus kombinasi beginkombinasi :=fn/(fk*fn_k);dalam rumus diatas menunjukkan rumus kombinasi n!/k!(n-k)!
3. Procedure PermutasiDalam procedure yang ketiga ini, kami menghitung permutasi faktorial dengan menggunakan cara yang tidak jauh beda dengan cara procedure kombinasi pada no.2, rumus permutasi P= n!/(n-k)!
beginfn:=1;for i:=1 to n dofn:=fn*i;end;beginfn_k:=1;for i:=1 to (n-k) dofn_k:=fn_k*i;end;beginpermutasi :=fn/fn_k;
Dalam rumus di atas menjelaskan bagaimana factorial dihitung
menggunakan acuan fn=1 dengan i sebagai perulangan hingga n. Diikuti
dengan fn_k=1 dimana fn_k mengangtikan rumus (n-k)!. Terakhir rumus
permutasi= fn/fn_k.
4. Main (program utama)
Source code dari program utama yaitu algoritma utama yang akan
dijalankan program. Program utama akan memanggil Procedure factorial,
kombinasi, dan permutasi sebagai hasil. Sehingga, untuk menghitung
kompleksitas waktu asimptotik dapat dengan mengitung kompleksitas
waktu procedure.
E. Kompleksitas Waktu
1. Operasi Pengisian
- Prosedur faktorial
x 1for i 1 to n dox x*i
- Prosedur kombinasi
fn 1for 1 to n dofn fn*i
fk 1for i 1 to k dofk fk*i
fn_k 1for i 1 to (n-k) dofn_k fn_k*i
kombinasi fn/(fk*fn_k)
- Prosedur permutasi
fn 1 for i 1 to n dofn fn*i
fn_k 1for i 1 to (n-k) dofn_k fn_k*i
permutasi fn/fn_k
t1 = 6 (2n +1) + 1 + 1 = 12n + 6 + 2 = 12n + 8
2. Operasi perkalian- Prosedur factorial
x*i
1 kali2n + 1n kali
n kali
1 kali2n + 1n kali
n kali
1 kali2n + 1n kali
n kali
1 kali2n + 1n kali
n kali
1 kali 1
1 kali2n + 1n kali
n kali
1 kali2n + 1n kali
n kali
1 kali 1
n kali n
- Prosedur kombinasi
fn*ifk*ifn_k*i(fk*fn_k)
- Prosedur permutasi
fn*ifn_k*i
t2 = n + 3n + 1 + n + n = 6n + 1
3. Operasi pembagian
kombinasi fn/(fk*fn_k)permutasi fn/fn_k
t3 = 1 + 1 = 2
T(n) = t1 + t2 + t3 = 12n + 8 + 6n + 1 + 2 = 18n + 11
F. Kompleksitas Waktu Asimptotik1. Prosedur factorial
read (n)x 1for i 1 to n dox x*iwrite (x)endfor
Kompleksitas waktu asimptotik untuk prosedur factorial := O(1)+O(1)+O(n)+O(1)= Max (O(1,1))+O(n)+O(1)= O(1)+O(n)+O(1)= Max (O(1,n))+O(1)= O(n)+O(1)= O(n)
n kali
3n + 1 n kalin kali1 kali
n kali nn kali n
1 kali 11 kali 1
O (1) O (1)O (1) O (1)
nn . O(1) = O(n) . O(1) = O (n)
O (1)O (1) O (1)
2. Prosedur kombinasi
beginread (n)read (k)fn 1for 1 to n dofn fn*i
endfor
kompleksitas waktu asimptotik algoritma (K1) := O(1)+O(1)+O(1)+O(n)= Max (O(1,1,1))+O(n)= O(1)+O(n)= O(n)
fk 1for i 1 to k dofk fk*i
endfor
kompleksitas waktu asimptotik algoritma (K2) := O(1)+O(n)= O(n)
fn_k 1for i1 to (n-k) do
fn_k fn_k*iendfor
kompleksitas waktu asimptotik algoritma (K3) := O(1)+O(n)= O(n)
kombinasi fn/(fk*fn_k)write (kombinasi)end
kompleksitas waktu asimptotik algoritma (K4) := O(1)+O(1)= O(1)
O (1) O(1)O (1) O (1)O (1) O (1)
nn . O(1) = O(n) . O(1) = O (n)
O (1)
O (1) O(1)n
n . O(1) = O(n) . O(1) = O (n)O (1)
O (1) O(1)n
n . O(1) = O(n) . O(1) = O(n)O (1)
O(1)O(1)
Penjumlahan dari setiap komplesitas waktu di atas := K1+K2+K3+K4= O(n)+O(n)+O(n)+O(1)= Max (O(n,n,n))+O(1)= O(n)+O(1)= O(n)
3. Prosedur permutasi
read (n)read (k)fn 1 for i 1 to n dofn fn*i
kompleksitas waktu asimptotik algoritma (K1) := O(1)+O(1)+O(1)+O(n)= Max (O(1,1,1))+O(n)= O(1)+O(n)= O(n)
fn_k 1for i1 to (n-k) do
fn_k fn_k*i
kompleksitas waktu asimptotik algoritma (K2) := O(1)+O(n)= O(n)
permutasi fn/fn_kwrite (permutasi)
kompleksitas waktu asimptotik algoritma (K3) := O(1)+O(1)= O(1)
Penjumlahan dari setiap komplesitas waktu di atas := K1+K2+K3= O(n)+O(n)+O(1)= Max (O(n,n))+O(1)= O(n)+O(1)= O(n)
O (1) O(1)O (1) O(1)O (1) O(1)
nn . O(1) = O(n) . O(1) = O (n)
O (1)
O (1) O(1)n
n . O(1) = O(n) . O(1) = O (n)O (1)
O(1)O(1)
kompleksitas waktu asimptotik
= Prosedur factorial+Prosedur kombinasi+Prosedur permutasi
= O(n)+ O(n)+ O(n)
= Max (O(n,n,n))
= O(n)
Kompleksitas waktu asimptotik program faktorial, dapat berupa :
T(n) = 18n + 11
18n + 11 ≤ 18n + 11n = 29n untuk n ≥ 1
18n + 11 = O(n)
T(n) = 18n + 11
18n + 11 ≥ 18n untuk n ≥ 1
18n + 11 = Ω(n)
Karena 18n + 11 = O (n) dan 18n + 11 = Ω (n) maka 18n + 11 = ϴ (n)
Jadi, kompleksitas waktu asimptotik dan kompleksitas waktu program
faktorial yaitu:
T(n) = O(n) dan T(n)= 18n+11
tampilan awal
Hasil output factorial
Hasil output kombinasi
Hasil Output Permutasi