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