MODUL II

FUNGSI DAN REKURSI

2.1 Tujuan
Tujuan modul II ini, adalah:
• Praktikan bisa membuat program sederhana berdasarkan algoritma dengan
memakai fungsi
• Praktikan bisa membuat program sederhana berdasarkan algoritma dengan
menggunakan fungsi rekursi
• Praktikan dapat membiasakan diri untuk membuat program secara terstruktur.
• Praktikan memahami algoritma fungsi dan rekursi

2.2 Teori
Modularisasi program (yang disebut juga rutin, prosedur atau fungsi)
memberikan dua keuntungan, yaitu: untuk aktivitas yang harus dilakukan lebih
dari satu kali, modularisasi menghindari penulisan teks program yang sama secara
berulangkali. Disini penggunaan modul program dapat mengurangi panjang
program. Keuntungan kedua adalah kemudahan menulis dan menemukan
kesalahan program. Kemudahan menulis akan sangat berguna pada masalah besar
yang dikerjakan oleh satu tim pemrogram yang beranggotakan beberapa orang.
Bahasa C tidak mengenal istilah prosedur seperti bahasa pascal. Dalam pascal
sendiri, prosedur didefinisikan sebagai suatu proses yang tidak mengembalikan
nilai. Untuk melakukan hal ini di dalam c, maka kita harus membuat suatu fungsi
dengan tipe void, yang berarti tidak memiliki nilai balik (return value).

2.2.1 Fungsi Tanpa Nilai Balik

Notasi algoritma yang digunakan untuk mendefinisikan struktur prosedur
atau fungsi ini adalah:
Procedure nama_prosedur
{spesifikasi prosedur, berisi penjelasan tentang apa yang dilakukan oleh
prosedur ini}
k.awal : keadaan sebelum prosedur dilaksanakan}

II-1
 II-2

k.akhir : keadaan setelah prosedur dilaksanakan}

Deklarasi
{Semua nama yang dipakai dalam prosedur dan hanya berlaku local dalam
prosedur didefnisikan disini}

Deskripsi
{badan prosedur, berisi kumpulan instruksi}

Contoh Algoritma 1:
Procedure HitungLuasSegitiga
{Menghitung luas segitiga dengan rumus Luas = (alas x tinggi)/2}
{k.awal : sembarang}
{k.akhir : Luas dicetak ke piranti masukan keluaran}

Deklarasi
Alas : real {panjang alas segitiga, dalam cm}
Tinggi : real {tinggi segitiga, dalam cm}
Luas : real {luas segitiga, dalam cm}

Deskripsi
Read(Alas, Tinggi)
Luas ← (Alas * Tinggi) / 2
Write(Luas)
Algoritma luassegitiga
{program utama untuk menghitung luas segitiga}

Deklarasi
Procedure HitungLuasSegitiga
{menghitung luas segitiga dengan rumus luas = (alas x tinggi)/2}

Deskripsi
Write(‘menghitung luas sebuah segitiga’)
HitungLuasSegitiga
Write(‘selesai’)

Program Algoritma 1:
//program utama untuk menghitung luas segitiga
#include "stdio.h"

int Alas;
int Tinggi;
void HitungLuasSegitiga();
 II-3

main(){
printf("Menghitung luas sebuah segitiga\n");
HitungLuasSegitiga();
printf("\nselesai");
}

void HitungLuasSegitiga()
{
float Luas;
printf("Alas : ");scanf("%d",&Alas);
printf("Tinggi : ");scanf("%d",&Tinggi);
luas = (Alas * Tinggi)/2;
printf("%4.2f",Luas);
}

2.2.1.1 Nama Global dan Lokal

Nama-nama (konstanta, peubah, tipe dan lain-lain) yang dideklarasikan di
dalam deklarasi prosedur hanya “dikenal” di dalam badan prosedur yang
bersangkutan (bersifat lokal). Sedangkan nama-nama yang dideklarasikan di
dalam program utama dikatakan bersifat global (nama-nama global dapat
digunakan di bagian manapun di dalam program, baik di dalam program utama
maupun di dalam prosedur).

2.2.1.2 Parameter
Parameter aktual adalah parameter yang disertakan pada waktu
pemanggilan, sedangkan parameter formal adalah parameter yang dideklarasikan
di dalam bagian header prosedur itu sendiri. Ketika prosedur dipanggil, parameter
actual menggantikan parameter formal. Tiap-tiap parameter aktual berpasangan
dengan parameter formal yang bersesuaian.
Berdasarkan penggunaannya terdapat 3 jenis parameter formal, yaitu :
• Parameter masukan (input parameter) : parameter yang nilainya berlaku
sebagai masukan untuk prosedur (sering disebut parameter nilai – parameter
by value).
• Parameter keluaran (output parameter) : parameter yang menampung keluaran
yang dihasilkan oleh prosedur.
 II-4

• Parameter masukan/keluaran (input/output parameter) : parameter yang

berfungsi sebagai masukan sekaligus keluaran bagi prosedur tersebut
(parameter keluaran dan parameter masukan/keluaran sering dinamakan
parameter acuan – parameter by reference).
Contoh algoritma parameter masukan:
Procedure Satu(input X, Y : integer)
{contoh prosedur dengan parameter formal berjenis parameter masukan
k.awal : nilai x dan y sudah terdefinisi
k.akhir : nilai x dan y masing-masing dinaikkan satu lalu dicetak ke piranti
keluaran}

Deklarasi
{tidak ada}

Deskripsi
X ← X +1
Y ← Y -1
Write(X, Y)
Algoritma PQR
{contoh program utama yang memanggil prosedur satu}

Deklarasi
A, B : real

Procedure Satu(input X, Y : integer)

{contoh prosedur dengan parameter formal berjenis parameter masukan}

Deskripsi
Satu(4,10) {pemanggilan satu yang pertama kali}
Read(a,b)
Satu(a,b) {pemanggilan satu yang kedua kalinya}
Satu(a+5,17) {pemanggilan satu yang ketiga kalinya}

Pada program PQR diatas: x dan y adalah parameter formal; 4 dan 10, a dan b,
a+5 dan 17 adalah parameter aktual.
Contoh algoritma parameter Keluaran:
Procedure Tiga(input X : integer, output Y : real)
{contoh prosedur dengan parameter formal berjenis parameter keluaran
k.awal : nilai x sudah terdefinisi
k.akhir : di dalam prosedur, nilai x ditambah satu, lalu hasilnya dikalikan 3,
disimpan ke dalam y}
 II-5

Deklarasi
{tidak ada}

Deskripsi
X←X+1
Y←X*3
Algoritma PQR
Deklarasi
A, B : integer

Procedure Tiga(input X : integer, output Y : integer)

{contoh prosedur dengan parameter formal berjenis parameter keluaran}

Deskripsi
Tiga(4, B) {pemanggilan tiga yang pertama kali}
Write(B)
Read (A)
Tiga(A, B) {pemanggilan tiga yang kedua kali}
Write(B)
Tiga(A+5, B) {pemanggilan tiga yang ketiga kali}
Write(B)

Contoh Algoritma Parameter Masukan/Keluaran:

Procedure Empat(input/output X, Y : integer)
{contoh prosedur dengan parameter formal parameter masukan/keluaran}
{menambahkan nilai x dan y masing-masing dengan 4}
{k.awal : X dan Y sudah berisi nilai}
{k.akhir : nilai X dan Y bertambah masing-masing 4, lalu dicatat ke piranti
keluaran }

Deklarasi
{tidak ada}

Deskripsi
X←X+4
Y←Y+4
Write(‘nilai X dan Y di akhir prosedur empat’)
Write(‘X : ’,X)
Write(‘Y : ‘,Y)
Algoritma PQR
{program yang memperlihatkan efek penggunakan parameter masukan/
keluaran}

Deklarasi
A, B : integer
 II-6

procedure Empat(input/output X, Y : integer)

{menambahkan nilai X dan Y masing-masing dengan 4}

Deskripsi
A ← 15
B ← 10
write(‘nilai A dan B sebelum pemanggilan’)
write(‘A : ’,A)
write(‘B : “, B)
empat(A, B)
write(‘nilai A dan B setelah pemanggilan’)
write(‘A : ’,A)
write(‘B : “, B)

Contoh Algoritma 2:
Procedure tukar(input/output X, Y : integer)
{mempertukarkan nilai x dan y
k.awal : nilai X dan Y sudah terdefinisi
k.akhir : X berisi nilai Y yang lama, Y berisi nilai X yang lama}

Deklarasi
Temp : integer {peubah bantu}

Deskripsi
Temp ← X {simpan nilai X ke dalam Temp}
X←Y {isikan nilai Y ke dalam X}
Y ← Temp {isikan nilai Temp ke dalam Y}
Algoritma tukar
{program utama untuk mempertukarkan nilai A dan B, nilai A dan B dibaca
dari piranti masukan}

Deklarasi
A, B : integer

Procedure Tukar(input/output X, Y : integer)

{mempertukarkan nilai x dan y}

Deskripsi
read(A, B) {baca nilai A dan B terlebih dahulu}
write(A, B) {cetak nilai A dan B sebelum pertukaran}
Tukar(A, B) {pertukaran nilai A dan B dengan memanggil prosedur Tukar}
write(A, B) {cetak nilai A dan B setelah pertukaran}
 II-7

Program Algoritma 2:
//program tukar
#include "stdio.h"

void tukar(int *a, int *b);

main(){
int A, B;

printf("A : ");scanf("%d",&A);
printf("\nB : ");scanf("%d",&B);
printf("\nA : %d",A);
printf("\nB : %d",B);
tukar(&A, &B);
printf("\nA : %d",A);
printf("\nB : %d",B);
}

void Tukar(int *A, int *B) {

int Temp;
Temp = *A;
*A = *B;
*B = Temp;
}

Contoh Algoritma 3:
Procedure HitungRatarata(input N : integer , output U : real)
{menghitung nilai rata-rata N buah bilangan bulat yang dibaca dari piranti
masukan. Nilai N diasumsikan selalu positif}
{k.awal : N sudah berisi banyaknya data (N>0)}
{k.akhir : U berisi rata-rata seluruh bilangan }

Deklarasi
X : integer {data bilangan bulat yang dibaca dari papan kunci}
K : integer {pencacah banyak bilangan}
Jumlah : integer {jumlah seluruh bilangan}

Deskripsi
Jumlah ← 0 {inisialisasi}
For K ← 1 to N do
Read(X)
Jumlah ← Jumlah + X
Endfor
U ← Jumlah/N
 II-8

Algoritma Rataratabilanganbulat
{program utama untuk menghitung nilai rata-rata N buah bilangan bulat yang
dibaca dari piranti masukan}

Deklarasi
N : integer {banyaknya data bilangan bulat. N positif}
U : real {nilai rata-rata seluruh bilangan}

Procedure HitungRatarata(input N : integer , output U : real)

{menghitung nilai rata-rata N buah bilangan bulat yang dibaca dari piranti
kunci}

Deskripsi
Read(N)
Write(‘menghitung rata-rata N buah bilangan bulat’)
HitungRatarata(N, U)
Write(U)

Program Algoritma 3:
//program utama untuk menghitung luas segitiga
#include "stdio.h"

int N;
float U;

void HitungRatarata(int N, float *U);

main(){
printf("Jumlah data : ");scanf("%d", &N);
printf("menghitung rata-rata N buah bilangan bulat\n");
HitungRatarata(N, &U);
printf("%f", U);
}

void HitungRatarata(int N, float *U) {

int K, Jumlah, X;

Jumlah = 0;
for (K=1; K<=N; K++) {
printf("data ke-%d : ",K);scanf("%d", &X);
Jumlah = Jumlah + X;
}
*U = Jumlah/N;
}
 II-9

2.2.2 Fungsi Dengan Nilai Balik

Fungsi adalah modul program yang memberikan/mengembalikan (return)
sebuah nilai dari tipe tertentu (tipe dasar atau tipe bentukan). Sebagaimana halnya
prosedur, fungsi diakses dengan memanggil namanya. Selain itu, fungsi juga dapat
mengandung daftar parameter formal. Parameter pada fungsi selalu merupakan
parameter masukan. Hal ini disebabkan oleh kenyataan bahwa parameter pada fungsi
merupakan masukan yang digunakan oleh fungsi tersebut untuk menghasilkan nilai.
Notasi algoritma untuk fungsi :
Function namafungsi(input daftar parameter formal) → tipe hasil
{spesifikasi fungsi, menjelaskan apa yang dilakukan dan yang dikembalikan oleh
fungsi}

Deklarasi
{semua nama yang dipakai di dalam algoritma fungsi dideklarasikan disini. Nama
yang didefinisikan di dalam deklarasi lokal hanya dikenal dan dipakai di dalam
fungsi ini saja}

Deskripsi
{badan fungsi, berisi instruksi-isntruksi untuk menghasilkan nilai yang akan
dikembalikan oleh fungsi}
return hasil {pengembalian nilai yang dihasilkan fungsi}

Contoh Algoritma 4 :
Function F(input X : real) → real
{mengembalikan nilai f(x) = 2x2 + 5x – 8, x ȏ R)

Deklarasi
{tidak ada}

Deskripsi
Return 2*X*X + 5*X – 8
ATAU,
Function F(input X : real) → real
{mengembalikan nilai f(x) = 2x2 + 5x – 8, x ȏ R)

Deklarasi
Y : real {penampung hasil fungsi F}

Deskripsi
Y ← 2*X*X + 5*X – 8
Return Y
Algoritma fungsiF
{program utama pemanggilan fungsiF}
 II-10

Deklarasi
X : integer

Function F(input X : real) → real

Deskripsi
Read(X)
Write(‘F(X) = ’, F(X))

Program Algoritma 4 :
//program fungsi f(x)=2x2+5x-8
#include "stdio.h"

float F(float X);

main(){
int X;
printf("X : ");scanf("%d",&X);
printf("\nF(X) : %f",F(X));
}

float F(float X){

float Y;
Y = 2*X*X + 5*X - 8;
return Y;
}

Contoh Algoritma 5 :
Function Genap(input N : integer)→boolean
{mengembalikan nilai true jika N adalah bilangan genap, false jika sebaliknya}

Deklarasi
Y : integer

Deskripsi
Y ← (N mod 2 = 0)
Return Y
Algoritma GenapGanjil
{program utama yang memanggil fungsi genap}

Deklarasi
Bil : integer

Function Genap(input N : integer) → boolean

{mengembalikan nilai true jika N adalah bilangan genap, false jika sebaliknya}
 II-11

Deskripsi
Read(Bil)
If Genap(Bil) then
Write(Bil, ‘adalah bilangan genap’)
Else
Write(Bil, ‘adalah bilangan ganjil’)
Endif

Program Algoritma 5 :
//program fungsi f(x)=2x2+5x-8
#include "stdio.h"

bool Genap(int Bil);

main(){
int Bil;
printf("Bil : ");scanf("%d",&Bil);
if (Genap(Bil))
printf("\n%d adalah bilangan genap", Bil);
else
printf("\n%d adalah bilangan ganjil", Bil);
}

bool Genap(int Bil){

bool Y;
Y = (Bil % 2 == 0);
return Y;
}

2.2.3 Rekursi
Suatu obyek disebut sebagai rekursif apabila sebagian berisi atau
didefinisikan sebagai dirinya sendiri. Dengan demikian rekursif adalah suatu
proses berupa pemanggilan diri berupa statement perulangan. Proses rekursif juga
memungkinkan terjadinya komputasi yang tidak berkesudahan sampai memory
yang digunakan tidak dapat menampung lagi, sehingga perlu diperhatikan akan
adanya kondisi untuk menghentikan proses eksekusi program .
Sebagai contoh sederhana mengenai proses rekursif adalah proses menghitung
nilai faktorial dari bilangan bulat positif dan mencari deret fibonnaci dari suatu
bilangan bulat, permainan menara hanoi dan sebagainya.
 II-12

Contoh Algoritma 6:
Function Fak(input N : integer) → integer
{mengembalikan nilai N!. algoritma rekursif. basis : jika N = 0, maka 0!=1
rekurens : jika N>0, maka N! = N x (N-1)!}

Deklarasi
{tidak ada}

Deskripsi
If N = 0 then
Return 1 {basis}
Else
Return N*Fak(N-1) {rekurens}
Endif
Algoritma faktorial
{program utama yang memanggil fungsi faktorial}

Deklarasi
Bil : integer

Function Fak(input Bil : integer) → integer

{mengembalikan nilai N!}

Deskripsi
Read(Bil)
Write(Bil, ‘ ! adalah :’,Fak(Bil))

Program Algoritma 6:
//program fungsi rekursif faktorial
#include "stdio.h"

int Fak(int N);

main(){
int N;
printf("N! : ");scanf("%d",&N);
printf("\n%d! adalah %d", N, Fak(N)); }

int Fak(int N){

if (N == 0)
return 1;
else
return N*Fak(N-1);
}
 II-13

2.3 Kasus
2.3.1 Kasus 1
1. Tuliskan prosedur untuk menghitung jumlah N buah bilangan genap pertama
(bilangan genap dimulai dari 0). Prosedur menerima (parameter) masukan N
dan memberikan (parameter) keluaran jumlah N buah bilangan genap pertama.
Dari algoritma tersebut, buatlah program dan cantumkan output/hasilnya.
2. Buatlah algoritma prosedur yang menerima dua buah tanggal (dd-mm-yyy) :
tanggal-1 dan tanggal-2 lalu menghitung berapa hari jarak tanggal-1 ke
tanggal-2 tersebut. Dari algoritma tersebut, buatlah program dan cantumkan
output/hasilnya.

2.3.2 Kasus 2
1. Buatlah sebuah algoritma fungsi yang memberikan durasi antara dua buah jam
(dengan format hh:mm:ss) lebih dari 1 jam. Dari algoritma tersebut, buatlah
program dan cantumkan output/hasilnya.
2. Misalkan panit(n,k) menyatakan jumlah panitia yang terdiri dari k orang yang
dapat dibentuk dari n orang. Sebagai contoh, panit(4,3)=4, karenadiberikan
empat orang A, B, C, dan D, maka terdapat empat kemungkinan panitia, yaitu
ABC, ABD, ACD dan BCD. Buktikan kesamaan berikut:
Panit(n,k) = panit(n-1,k) + panit(n-1,k-1)
Buatlah fungsi rekursifnya untuk n, k ≥ 1.

2.4 Tugas – Tugas Pendahuluan

Tugas pendahuluan akan dikerjakan selama 30 menit di awal jam
praktikum dengan menggunakan software Self Assessment
 II-14

2.5 Latihan Praktikum III dan IV

2.5.1 Latihan Praktikum III (Pertemuan Ketiga)
Buatlah program berdasarkan algoritma di bawah ini:
Algoritma 1:
Procedure TambahSatuDetik(input/output J : Jam)
{menaikkan jam j dengan satu detik}
{k.awal : j sudah berisi nilai jam (hh:mm:ss)}
{k.akhir: j berisi jam yang harus setelah ditambah 1 detik}

Deklarasi
{tidak ada}

Deskripsi
If J.SS+1 < 60 then {tidak ada masalah penambahan 1 detik}
J.SS ← J.SS + 1
else {j.ss + 1 = 60}
J.SS←0 {detik kembali menjadi nol, menit bertambah 1, tapi
periksa dulu apakah menit +1 <60}
if J.MM + 1 < 60 then {tidak ada masalah penambahan 1 menit}
J.MM ← J.MM + 1
else {J.MM + 1 = 60}
J.MM ← 0 {menit menjadi nol, jam berambah 1, tapi periksa
dulu apakah jam + 1 <24}
if J.HH + 1 < 24 {tidak ada masalah penambahan 1 jam}
J.HH ← J.HH + 1
else { J.HH + 1 = 24}
J.HH ← 0
endif
endif
endif
Algoritma Jam_Hidup
{membuat jam ‘hidup’ yang selalu bertambah 1 detik terus menerus sampai
jam 00:00:00. masukan jam dibaca dari piranti masukan. Setiap pertambahan
1 detik, jam yang baru ditampilkan sebagai keluaran}

Deklarasi
Type Jam : record<HH : integer, (0≤HH≤59)
MM : integer, (0≤HH≤59)
SS : integer, (0≤HH≤23)
>
J : Jam

Procedure TambahSatuDetik(input/output J : Jam)

{menaikkan jam J dengan satu detik}
 II-15

Deskripsi
Read(J.HH, J.MM, J.SS)
Write(J.HH, J.MM, J.SS)
Repeat
Tambahsatudetik(J)
Write(J.HH, J.MM, J.SS)
Until (J.HH=0) and (J.MM=0) and (J.SS=0)

Algoritma 2:
Procedure HitungPBT(input M : integer, input N : integer, output PBT :
integer)
{menghitung pembagi bersama terbesar dari dua buah bilangan bulat tak
negative M dan N}
{k.awal : M dan N sudah terdefinisi harganya, M≥N dan M, N ≥0}
{k.akhir : PBT berisi pembagi bersama terbesar dari M dan N}

Deklarasi
R : integer {sisa pembagian M dengan N}

Deskripsi
While N ≠ 0 do
R ← M mod N
M←N
N←R
endwhile {N = 0, maka PBT = M}
PBT ← M
Procedure Tukar(input/output A, B : integer)
{mempertukarkan nilai A dan B}
{k.awal : nilai A dan B sudah terdefinisi}
{k.akhir : A berisi nilai B yang lama, B berisi nilai A yang lama}

Deklarasi
Temp : integer {peubah bantu}

Deskripsi
Temp ← A {simpan nilai A ke dalam Temp}
A←B {isikan nilai B ke dalam A}
B ← Temp {isikan nilai Temp ke dalam B}
Algoritma Euclidean
{program utama untuk menghitung pembagi bersama terbesar dari dua buah
bilangan bulat positif m dan n. harga m dan n dibaca dari piranti masukan}

Deskripsi
M, N : integer {>0}
PBT : integer {pembagi bersama terbesar M dan N}
 II-16

Procedure HitungPBT(input M : integer, input N : integer, output PBT :

integer)
{menghitung pembagi bersama terbesar dari dua buah bilangan bulat tak
negative M dan N}

Procedure Tukar(input/output A, B : integer)

{mempertukarkan nilai A dan B}

Deskripsi
Read(M, N)
If M<N then
Tukar(M, N) {pertukarkan M dan N}
endif
HitungPBT(M, N, PBT)
write(PBT)

Algoritma 3:
Procedure HitungSelisihJam(input J1, J2 : Jam, output J3 : Jam)
{menghitung selisih dua buah jam, J3 = J2 – J1}
{k.awal: J1 dan J2 sudah berisi nilai jam (HH:MM:SS) dan J2.HH > J1.HH}
{k.akhir: J3 berisi selisih jam J2 dengan J1}

Deklarasi
{tidak ada}

Deskripsi
{kurangi mulai dari detik dulu}
if J2.SS ≥ J1.SS then {tidak ada masalah pengurangan detik}
J3.SS ←J2.SS – J1.SS
else {J2.SS < J1.SS, lakukan peminjaman 1 menit = 60 detik dari
J2.MM}
J3.SS ← (J2.SS + 60) – J1.SS
J2.MM ← J2.MM – 1 {J2.MM berkurang 1 karena dipinjam 1 menit}
endif

{kurangi menit}
if J2.MM ≥ J1.MM then {tidak ada masalah pengurangan menit}
J3.MM ← j2.MM – J1.MM
else {J2.MM < J1.MM, lakukan peminjaman 1 jam = 60 menit dari J2.HH}
J3.MM ← (J2.MM + 60) – J1.MM
J2.HH ← J2.HH – 1 {J2.HH berkurang 1 karena dipinjam 1 menit}
endif

{kurangi jam}
J3.HH ← J2.HH – J1.HH
 II-17

Algoritma HitungSelisihDuaBuahJam
{menghitung selisih dua buah jam. Data jam dibaca dari piranti masukan}

Deklarasi
Type Jam : record<HH : integer, (0..59)
MM : integer, (0..59)
SS : integer, (0..23)
>
J1, J2, J3 : Jam

Procedure HitungSelisihJam(input J1,J2 : Jam, output J3 : Jam)

{menghitung selisih dua buah jam, J3 = J2 – J1}

Deskripsi
Read(J1.HH, J1.MM, J1.SS)
Read(J2.HH, J2.MM, J2.SS)
HitungSelisihJam(J1, J2, J3)
Write(J3.HH, J3.MM, J3.SS)

Algoritma 4:
Procedure Masukan(input/output Panjang, Lebar : real)
{memasukan nilai panjang dan lebar}

Deklarasi
{tidak ada}

Deskripsi
Read(Panjang, Lebar)
Procedure HitungLuassegiempat(input Panjang, Lebar : real)
{menghitung luas segiempat persegipanjang. Luas segiempat dicetak sebagai
keluaran}
{k.awal: panjang dan lebar sudah terdefinisi nilainya}
{k.akhir: luas segiempat tercetak di piranti keluaran}

Deklarasi
Luas : real

Deskripsi:
Masukan(Panjang, Lebar)
Luas ← Panjang * Lebar
Write(Luas)
Procedure HitungKelilingsegiempat(input Panjang, Lebar : real)
{menghitung keliling segiempat. keliling segiempat dicetak sebagai keluaran}
{k.awal: panjang dan lebar sudah terdefinisi nilainya}
{k.akhir: keliling segiempat tercetak di piranti keluaran}
 II-18

Deklarasi
Keliling : real

Deskripsi:
Masukan(Panjang, Lebar)
Keliling ← 2*Panjang + 2*Lebar
Write(Keliling)
Procedure HitungPanjangdiagonal(input Panjang, Lebar : real)
{menghitung panjang diagonal. keliling segiempat dicetak sebagai keluaran}
{k.awal: panjang dan lebar sudah terdefinisi nilainya}
{k.akhir: panjang diagonal segiempat tercetak di piranti keluaran}

Deklarasi
Diagonal : real

Deskripsi:
Masukan(Panjang, Lebar)
Diagonal ← SQRT(Panjang*Panjang + Lebar*Lebar)
Write(Diagonal)
Algoritma Segiempat
{program untuk menampilkan menu perhitungan segiempat (luas, keliling dan
panjang)}

Deklarasi
Panjang, Lebar :real
Nomormenu : integer

Procedure Masukan(input/output Panjang, Lebar : real)

{memasukan nilai panjang dan lebar}

Procedure HitungLuassegiempat(input Panjang, Lebar : real)

{menghitung luas segiempat persegi panjang. Luas segiempat dicetak sebagai
keluaran}

Procedure HitungKelilingsegiempat(input Panjang, Lebar : real)

{menghitung keliling segiempat. keliling segiempat dicetak sebagai keluaran}

Procedure HitungPanjangdiagonal(input Panjang, Lebar : real)

{menghitung panjang diagonal segiempat. Panjang diagonal segiempat dicetak
sebagai keluaran}

Deskripsi
Read(Panjang, Lebar)
Repeat {cetak menu ke layar}
Write(’ MENU SEGIEMPAT ’)
Write(’ 1. hitung luas ’)
 II-19

Write(’ 2. hitung keliling ’)

Write(’ 3. hitung panjang diagonal ’)
Write(’ 4. Keluar program ’)
Write(’ Masukan nomor pilihan menu [1/2/3/4]: ’)
Read(Nomormenu)
Case Nomormenu
1 : HitungLuassegiempat(Panjang, Lebar)
2 : HitungKelilingsegiempat(Panjang, Lebar)
3 : HitungPanjangdiagonal(Panjang, Lebar)
4 : write(’keluar program...’)
endcase
until Nomormenu = 4

2.5.2 Latihan Praktikum IV (Pertemuan Keempat)

Buatlah program berdasarkan algoritma di bawah ini:
Algoritma 1
Function Valid(input P : string) → boolean
{bernilai true jika password P benar, false jika tidak}

Deklarasi
Const Password = ’abc123’

Deskripsi
return (P = Password)
Algoritma Pemeriksaan_password
{program pemeriksaan kebenaran password, password dibaca dari papan
kunci. Bila password salah, pemasukan password dapat diulang maksimal 3
kali}

Deklarasi
Sandilewat : string {kata sandi yang dibaca dari piranti masukan}
Sah : boolean {true jika password benar, false jika salah}
K : integer {pencatat jumlah pembacaan sandilewat}

Function Valid(input P : string) → boolean

{bernilai true jika password P benar, false jika tidak}

Deskripsi
K←1
Sah ← false
repeat
read(Sandilewat)
if Valid(Sandilewat) then
Sah←true
 II-20

else {Sandilewat ≠ Password}

K←K + 1
endif
until (Sah) or (K>3)
if not Sah then
write(’anda tidak punya hak mengakses sistem’)
endif

Algoritma 2
Function Prima(input M : integer)→boolean
{mengembalikan true jika M bilangan prima, false jika M bukan bilangan
prima}

Deklarasi
K : integer
Tes : boolean

Deskripsi
K←2
Tes←true {sesuaikan M pada awalnya bilangan prima}
while (K≤M-1) and (not Tes) do
if M mod K = 0 then {M habis dibagi dengan bilangan K ≤ M-1}
Hasil ← false {kesimpulannya : M bukan bilangan prima}
else
K ← K+1 {coba bagi dengan K berikutnya}
endif
endwhile
return Tes
Algoritma Hitungprima
{program utama menghitung bilangan prima}

Deklarasi
M : integer

Function Prima(input M : integer)→boolean

{mengembalikan true jika M bilangan prima, false jika M bukan bilangan
prima}

Deskripsi
Read(M)
If Prima(M) then
Write(M, ‘bilangan prima)
Else
Write(M,’bukan bilangan prima’)
 II-21

Algoritma 3:
Function Balikangka(input N : integer) → integer
{Membalikan urutan bilangan bulat N (misal: 4567 menjadi 7654)
k.awal : nilai N sudah terdefinisi
k.akhir : urutan angka bilangan N dicetak terbalik
basis : jika N < 10, cetak(n)
rekurens : jika N > 10 maks cetak (N mod 10), balikangka(N div 10)}

Deklarasi
{tidak ada}

Deskripsi
If N < 10 then
Write(N) {basis}
Else {rekurens}
Write(N mod 10)
Balikangka(N div 10)
Endif
Algoritma faktorial
{program utama yang memanggil fungsi balikangka}

Deklarasi
N : integer

Function Balikangka(input N : integer) → integer

{Membalikan urutan bilangan bulat N (misal: 4567 menjadi 7654)}

Deskripsi
Read(N)
Write(N, ‘ dibalik menjadi :’,Balikangka(N))

Algoritma 4:
Function Pangkat(input A, N : integer) → integer
{mengembalikan nilai an, n>0
basis : an = 1 jika n = 0
rekurens : an = a x an-1}

Deklarasi
{tidak ada}

Deskripsi
If N = 0 then
return 1
Else
return A*Pangkat(A, N-1)
 II-22

endif
Algoritma Faktorial
{program utama yang memanggil fungsi faktorial}

Deklarasi
Bil : integer

Function Pangkat(input A, N : integer) → integer

{mengembalikan nilai an, n>0}

Deskripsi
Read(A, N)
Write(A, ‘ pangkat ‘, N, ‘ adalah :’,Pangkat(A, N))

Algoritma 5
Formula Deret exp :
x 0 x1 x 2 x 3 xn
ex = + + + + ... +
0! 1! 2! 3! n!
Function exp(input x : real) →real
{mengembalikan nilai exp(x)}

Deklarasi
Const n : integer = 10
S: real
X : integer

Function Fak(input N : integer) →integer

{mengembalikan harga N!, untuk N≥0)

function Pangkat(input X : real, input M:integer) →real

{mengembalikan harga perpangkatan xn}

Deskripsi
S←0
for X→0 to N do
S→S + Pangkat(X, K)/Fak(K)
endfor
return S
Algoritma exponential
{program utama yang memanggil fungsi exp}

Deklarasi
X : integer
 II-23

Function Fak(input N : integer) →integer

{mengembalikan harga N!, untuk N≥0)

function Pangkat(input X : real, input M : integer) →real

{mengembalikan harga perpangkatan xn}

Deskripsi
Read(X)
Write(‘ exponential’,X,’ adalah ‘,Exp(X))