{ ======================================================= }

{ PEMINJAMAN BUKU
}
{ ======================================================= }
{ pembuat : Team 2-C : }
{ Widodo Muda Saputra J2F007050
Nur Imanullah J2F007036
Pramudita Eka H. J2F007039
Havit Choirul R. J2F007016
Candra S. A. J2F007006
M. Shoffa Al Arofat J2F007030
M. Abdur Rohman J2F005278 }
{ ======================================================= }
{ tanggal : 21-12-2008 }

Program ini dibuat pada sebuah perpustakaan untuk mendata member yang meminjam buku dan buku
yang dipinjam.

Pembagian tugas dan prosedur – prosedur yang digunakan dalam program ini:

1. DisplayPeminjaman ==> M. Shoffa Al Arofat

2. AddPeminjaman ==> Nur Imanullah
3. Pengembalian ==> Candra S. A.
4. SavePinjam ==> Widodo Muda Saputra
5. LoadPinjam ==> Pramudita Eka H.
6. MemberAktif ==> Havit Choirul Rovik
7. BukuAktif ==> M. Abdur Rohman

Solusi:
Sebelum penjelasan mengenai solusi akan dikemukakan terlebih dahulu asumsi yang digunakan:
1. Pada member aktif, jika semua member pada list hanya meminjam sekali maka yang ditampilkan
“tidak ada member aktif”.
2. Jika ada lebih dari dua member dengan jumlah peminjaman yang sama maka akan ditampilkan
semua.
3. Analog dengan member aktif, pada buku aktif yang ditampilkan bukan idBuku, melainkan
judulnya.
4. IdMember hanya menerima inputan integer.

Penjelasan Solusi:
Solusi yang digunakan kelompok kami adalah:
1. Untuk DisplayPeminjaman menggunakan algoritma dari PrintList dengan sedikit modifikasi.
2. Untuk AddPeminjaman menggunakan algoritma dari InsertLast dengan sedikit modifikasi,
mengurangi nilai stok buku yang dipinjam.
3. Untuk Pengembalian menggunakan algoritma dari DeleteCurrent (menghapus pointer yang
mengandung nilai sama) dengan sedikit modifikasi, menambah nilai stok buku yang
dikembalikan.
4. Untuk SavePinjam menggunakan file eksternal untuk menyimpan pointer yang dibuat.
5. Untuk LoadPinjam menggunakan algoritma dari Mesin Karakter dengan sedikit modifikasi,
membaca angka dan string secara bersamaan.
 6. Untuk MemberAktif mencari ID Member yang melakukan paling banyak peminjaman pada list
menggunakan sequensial search dan menampilkan ID Member nya.
7. Untuk BukuAktif mencari ID Buku yang melakukan paling banyak peminjaman pada list
menggunakan sequensial search dan menampilkan Judul Buku nya

Dokumentasi :
Pertemuan 1 : 7 Desember 2008 : Pembagian Kerja dan Pembahasan Solusi tiap subrutin yang dibuat.
Pertemuan 2 : 14 Desember 2008 : Pembahasan Solusi yang tidak berhasil dipecahkan dan mencari solusi
baru.
Pertemuan 3 : 20 Desember 2008 : Pengumpulan tiap subrutin dan menggabungkannya.
Pertemuan 4 : 21 Desember 2008 : Pengumpulan dan penggabungan semua program dari kelompok lain
dan menggabungkannya.
Pertemuan 5 : 01 Januari 2009 : Revisi program dan penambalan Bug.

ALGORITMA

{ KAMUS GLOBAL }
Peminjaman : < IdMember : integer
IdBuku : integer >
Addr_Peminjaman : pointer to Node_Peminjaman
Node_Peminjaman : < info : Peminjaman
next : Addr_Peminjaman >
List_Peminjaman : < Addr_Peminjaman first >

{ PROSEDUR & FUNGSI }

{ Subrutin List }
Function EOP boolean
{ true jika CC == MARK }
 (retval≠EOF)

Procedure createListP(output P: List_Peminjaman)

{ I.S. : List_Peminjaman belum terbentuk }
{ F.S. : List_Peminjaman P terdefinisi }
{ Proses : membuat List_Peminjaman P baru }
firstP(P)=NIL

Procedure insertFirstP(input/output P:List_Peminjaman, input idM:integer ,

idB:integer)
{ I.S. : elemen idM dan idB terpisah dari List_Peminjaman P }
{ F.S. : elemen idM dan idB berada dalam List_Peminjaman P di awal}
{ Proses : memasukkan elemen idM dan idB ke dalam List_Peminjaman P pada awal
List_Peminjaman }
{ kamus lokal }
AP : Addr_Peminjaman

{ algoritma }
Alokasi(AP)
if (AP≠NIL) then
infoIdmP(AP)idM
infoIdb(AP)idB
nextP(AP)firstP(P)
firstP(P)AP
Procedure insertLastP(input/output P:List_Peminjaman, input : idM:integer,
idB:integer)
{ I.S. : elemen idM dan idB terpisah dari List_Peminjaman P }
{ F.S. : elemen idM dan idB berada dalam List_Peminjaman P di akhir}
{ Proses : memasukkan elemen idM dan idB ke dalam List_Peminjaman P pada
akhir List_Peminjaman }
{ kamus lokal }
AP1, AP2 : Addr_Peminjaman

{ algoritma }
Alokasi(AP1)
infoIdmP(AP1)  idM
infoIdb(AP1) idB
nextP(AP1)  NIL
AP2 firstP(P)
if (AP1≠NIL) then

if (firstP(P)=NIL)
firstP(P)=AP1
else
while (nextP(AP2) ≠ NIL) do
AP2=nextP(AP2)

nextP(AP2)=AP1

{Subrutin yang harus dibuat}

Procedure DisplayPeminjaman(input P:list_Peminjaman)
{ I.S. : table Peminjaman terdefinisi }
{ F.S. : table Peminjaman tercetak di layar }
{ Proses : menampilkan isi table Peminjaman }
{ kamus lokal }
AP: Addr_Peminjaman

{ algoritma }

AP firstP(P)
if(isListEmpty(P)) then

while (AP≠NIL) do
output(infoIdmP(AP), infoIdb(AP))
AP=nextP(AP)

Procedure AddPeminjaman(input/output P:list_Peminjaman, output J:integer,

A:integer)
{ I.S : J dan A belum masuk ke List_Peminjaman }
{ F.S : J dan A merupakan elemen List_Peminjaman }
{ Proses : menambahkan J (idBuku) dan A (idMember) sebagai elemen terakhir P
jika J anggota list_Buku dan A anggota list_member dan stok buku J masih ada,
stok buku J di list_buku berkurang satu }
{ kamus lokal }
AP1, AP2: Addr_Peminjaman
AB, AB1: Addr_Buku
Ketemu: boolean

{ algoritma }
if((first(B) ≠NIL) AND (firstM(M) ≠NIL))
 if((IsMemberBuku(B, J)=true) AND (IsMember(M, A)=true))
Ketemufalse
ABfirst(B)
while(AB≠NIL && Ketemu!=true)
AB1 AB
if(infoIdB(AB)=J)
Ketemutrue

AB next(AB)

if((Ketemu=true) AND (infoSt(AB1)>0))

Alokasi(AP1)
infoIdmP(AP1)  A
infoIdb(AP1)  J
nextP(AP1)  NIL
AP2 firstP(P)
if (AP1≠NIL)
if (firstP(P)=NIL)
firstP(P)AP1
else
while (nextP(AP2) ≠ NIL)
AP2nextP(AP2)

nextP(AP2)AP1
infoSt(AB1)infoSt(AB1)-1

Procedure Pengembalian(input/output P:list_Peminjaman, input J:integer,

A:integer)
{ I.S : J dan A belum dihapus dari List_Peminjaman }
{ F.S : J dan A terhapus dari elemen List_Peminjaman }
{ Proses : menghapus elemen list Peminjaman dengan idbuku J dan idmember A,
stok buku J di list_buku bertambah satu }
{ kamus lokal }
AP1, AP2: Addr_Peminjaman
AB, AB1: Addr_Buku
Ketemu: boolean

{ algoritma }
AP1firstP(*P)
if(AP1≠NIL)
while(AP1≠NIL)
if(infoIdmP(AP1)=A AND infoIdb(AP1)=J)
if(AP1=firstP(P))
firstP(P)nextP(AP1)
nextP(AP1)NIL
else
nextP(AP2)nextP(AP1)
nextP(AP1)NIL

Dealokasi (AP1)
Ketemu false
AB first(B)
while(AB≠NIL AND Ketemu≠true)
AB1 AB
if(infoIdB(AB)=J)
Ketemutrue
 ABnext(AB)

infoSt(AB1)infoSt(AB1)+1

AP2AP1
AP1 nextP(AP1)

Procedure SavePinjam(input P:list_Peminjaman, output F:file)

{ I.S. : List_Peminjaman terdefinisi }
{ F.S. : pinjam.dat berisi List_Peminjaman }
{ Proses : menyimpan List_Peminjaman ke pinjam.dat }
{ kamus lokal }
AP: Addr_Peminjaman

{ algoritma }
open(F,”pinjam.dat”,”w”)
APfirstP(P)
while(AP≠NIL) do
output(F, infoIdmP(AP), infoIdb(AP))
AP nextP(AP)
}
close(F)

Procedure LoadPinjam(F:file, P:list_Peminjaman)

{ I.S. : List_Peminjaman masih kosong }
{ F.S. : List_Peminjaman terisi idMember dan idBuku }
{ Proses : meLoad isi pinjam.dat ke List_Peminjaman }
{ kamus lokal }
CC: char { CC merupakan variabel untuk menampung karakter pembacaan
dari file eksternal }
retvalInt,
idM, { id member peminjam }
idB : integer { id buku yang dimiliki }

{ algoritma }
open(F,"pinjam.dat", "r")
input(F, CC)
if(NOT(EOP))
while(CC≠10 && retval≠EOF)
input(F, CC)

createListP(P)
input(F, &idM, &idB)
while(retvalInt≠EOF)
insertLastP(P, idM, idB)
input(F, idM, idB)

close(F)

Procedure MemberAktif(P:list_Peminjaman)
{ I.S. : MemberAktif belum diketahui }
{ F.S. : MemberAktif didapatkan }
{ Proses : mencari frekuensi kemunculan idMember terbanyak }
{ kamus lokal }
AP1, AP2: Addr_Peminjaman
Tab : < id : integer
sum:integer >
i,
maxi,
max,
j,
k,
l,
m,n : integer
T : pointer to integer
Tab: pointer to tab

{ algoritma }
AP1 firstP(P)
if(AP1≠NIL) {
Alokasi(T)
Alokasi(Tab)
max infoIdmP(AP1)
maxi 1
j0
k 0
l0
n0
T[l]1
Tab[k].id max
while(AP1≠NIL) do
AP2=AP1

AP2nextP(AP2)
if(T[l]=1) then
i 1
ml
while(AP2≠NIL) do
m m+1
if(AP1=firstP(P)) then
jj+1
T[j]1

if(infoIdmP(AP2)=infoIdmP(AP1))
maxinfoIdmP(AP1)
ii+1
T[m]0

AP2 nextP(AP2)

if(i=maxi) then
maxi i
max infoIdmP(AP1)
Tab[k].idmax
Tab[k].summaxi
kk+1
else if(i>maxi)
maxii
maxinfoIdmP(AP1)
Dealokasi(Tab)
k0
Tab[k].id max
 Tab[k].sum maxi
kk+1

n n+1

l l+1;
AP1=nextP(AP1)

if(maxi>1)
output (k)
i traversal [0..k]
output(Tab[i].id, Tab[i].sum)

Procedure BukuAktif(P:list_Peminjaman)
{ I.S. : BukuAktif belum diketahui }
{ F.S. : BukuAktif didapatkan }
{ Proses : mencari frekuensi kemunculan idBuku terbanyak }
/* kamus lokal */
AP1, AP2: Addr_Peminjaman
AB1: Addr_Buku
tab :<int id
char Jdl[30]
int sum >
i,
maxi,
max,
j,
k,
l,
m,n : integer
T : pointer to integer
Tab : pointer to tab

/* algoritma */
AP1 firstP(P);
if(AP1≠NIL) {
Alokasi(T)
Alokasi(Tab)
Max infoIdb(AP1)
Maxi 1
j 0
k 0
l 0
n 0
T[l] 1
Tab[k].id max
while(AP1≠NIL) do
AP2 AP1
AP2 nextP(AP2)
if(T[l]=1) then
i 1
m l
while(AP2≠ NIL) do
mm+1
if(AP1= firstP(P))
j=j+1
 T[j] 1

if(infoIdb(AP2)=infoIdb(AP1))
max infoIdb(AP1)
i=i+1
T[m] 0

AP2 nextP(AP2)

if(i= maxi)
maxi i
max infoIdb(AP1)
Tab[k].id max
Tab[k].sum maxi
kk+1
else if(i>maxi)then
maxi i
max infoIdb(AP1)
Dealokasi(Tab)
k 0
Tab[k].id max
Tab[k].sum maxi
kk+1

nn+1

l l+1
AP1 nextP(AP1)

if(maxi≠1) then

i traversal [0..k]
AB1 first(B)
while((AB1≠NIL) AND (infoIdB(AB1) ≠Tab[i].id))
AB1<-- next(AB1)

Tab[i].Jdl infoJdl(AB1)
Output(Tab[i].Jdl, Tab[i].sum)