Daftar isi:
Program NamaProgram
{ Spesifikasi Program: Tuliskan di sini }
KAMUS
{ Deklarasi variabel }
a, b: integer
c : integer >= 0
{ Deklarasi konstanta }
constant PI : real = 3.14
{ Deklarasi tipe bentukan }
type Matriks : array [1..3] of array [1..3] of integer
ALGORITMA
input(a)
input(b)
a ← a + b
output(a)
integer
real
character
boolean
array [firstElmt..lastElmt] of datatype
- Tambah:
+
- Kurang:
-
- Kali:
*
- Bagi:
/
- Hasil bagi:
div
- Modulo:
mod
- Lebih besar dari:
>
- Lebih kecil dari:
<
- Tidak sama dengan:
!=
atau≠
(U+2260) - Tidak kurang dari:
>=
atau≥
(U+2265) - Tidak lebih dari:
<=
atau≤
(U+2264) - Sama dengan:
=
- Boolean and:
and
- Boolean or:
or
- Boolean not:
not
- Boolean xor:
xor
- Assignment:
←
(U+2190) atau<-
- Return:
→
(U+2192) atau->
- Input:
input()
- Output:
output()
Catatan
div
hanya berlaku untuk dua operan integer- Output bisa mengandung new line atau tidak, suka-suka aja
- Return dan
not
operator adalah operator uner - Bedakan antara
x < -2
denganx <- 2
type Struct: < data1: integer, { integer dibolehkan }
data2: integer[0..69], { integer dengan range 0..69 }
data3: real, { tipe data real juga dibolehkan }
data4: array[0..9] of character > { karakter/string juga dibolehkan }
Cara akses variabel: varName.data1
, varName.data2[3]
, dsb.
Contoh:
type Time: < hours: integer[0..23], { 0 ≤ hours ≤ 23 }
minutes: integer[0..59], { 0 ≤ minutes ≤ 59 }
seconds: integer[0..59] > { 0 ≤ seconds ≤ 59 }
Note : biasanya didefinisikan di KAMUS
Sekumpulan rumus perhitungan dari operan dan operator.
Contoh: 2 + 8 * (x mod 4)
Berikut ini adalah nama variabel/konstanta yang dibolehkan
varName
VarName
varname
Var1
PI
(khusus konstanta, contoh:IDX_UNDEF
,VAL_UNDEF
)
Nama variabel yang tidak dibolehkan
1cak
*GWS
kereta-api
NamaArray : array [idMin..idMax] of datatype
Keterangan:
NamaArray
bisa apa sajaidMin
biasanya adalah0
,idMax
terserahidMin
danidMax
harus merupakan tipe integerdatatype
bebas, bisa data bentukan/struct
Contoh:
arrayInt : array[0..8] of integer
arrayJam : array[0..59] of Jam
Cara akses: NamaArray[idx]
dengan idx
harus di dalam range definisi array tersebut
{ Array yang terisi sebagian }
constant NMax : integer = 100 {NMax biar gampang ubahnya}
type TabInt : <Tab : array [1..NMax] of integer,
Neff : integer {1 <= Neff <= NMax} >
T1 : TabInt {T1.Tab[i] untuk akses elemen ke-i dari T1.Tab, T1.Neff untuk akses nilai efektif}
Cara akses : untuk akses array T1
yang merupakan array sebagian dari TabInt, T1.Tab[i]
akses elemen ke-i dari T1.Tab
, T1.Neff
akses nilai efektif
- Dua Kasus Komplementer
if (<kondisi>) then
<aksi-1>
else { kondisi=false }
<aksi-2>
- Banyak Kasus
depend on (<var1>,...)
<kondisi-1> : <aksi-1>
<kondisi-2> : <aksi-2>
...
else { <kondisi-n> }
<aksi-n>
Struktur umum
function NamaFungsi(input param1: type1, input param2: type2, input parametc: typeetc) → output typehasil
{ Mengembalikan fafifu dari wasweswos }
KAMUS LOKAL
{ Nama variabel lokal : tipe data }
ALGORITMA
{ Deretan instruksi }
→ hasil
Pemanggilan
NamaFungsi(param1, param2, parametc)
Catatan: jumlah parameter bebas, bisa juga tanpa parameter
Struktur Umum
procedure NamaProsedur(<input/output> param1: type1, <input/output> param2: type2, <input/output> parametc: typeetc)
{ Spek prosedur }
{ I.S. Initial State }
{ F.S. Final State }
KAMUS LOKAL
{ Nama variabel : type variabel }
ALGORITMA
{ Sederet instruksi, bebas mau apa aja }
Pemanggilan
NamaProsedur(param1, param2, parametc)
Catatan:
- Jumlah parameter bebas, bisa juga tanpa parameter
- Setiap parameter bisa dijadikan input, output, atau keduanya (input/output)
- input : parameter sudah terdefinisi sebelum prosedur dipanggil
- output : parameter akan terdefinisi dalam prosedur
- input/output : sudah terdefinisi sebelum prosedur dipanggil, tetapi nilainya bisa berubah di dalam prosedur
Pengulangan berdasarkan banyak pengulangan
repeat n times
{ n bilangan bulat terdefinisi }
<aksi>
Pengulangan sampai kondisi berhenti, cek kondisi di akhir
repeat
<aksi>
until <kondisi-berhenti>
Pengulangan sampai kondisi berhenti, cek kondisi di awal
while <kondisi-loop> do
<aksi>
Gabungan bentuk repeat-until dan while do, cek kondisi di tengah (di bagian stop)
iterate
<aksi-1>
stop <kondisi-berhenti>
<aksi-2>
<pencacah> traversal [valMin..valMax]
<instruksi>
Note: pencacah biasanya diisi nama i, j, k, atau lainnya.
Contoh:
i traversal [0..8]
output(i)
Daftar Isi :
SKEMA PROSES_VALIDASI
{ Skema program yang menerima input data, hanya melakukan proses jika data valid }
KAMUS
{ deklarasi data_input }
ALGORITMA
input(<data>)
if (<data_valid>) then
<proses>
else
output(<pesan_kesalahan>)
-
Berdasarkan jumlah pengulangan:
- Diketahui secara persis berapa kali aksi harus dilakukan
repeat n times <aksi>
- Diketahui secara persis berapa kali aksi harus dilakukan
-
Berdasarkan kondisi berhenti:
- Aksi minimum dilakukan 1x (karena kondisi berhenti dicek setalah aksi dieksekusi)
repeat <aksi> until <kondisi-berhenti>
- Aksi minimum dilakukan 1x (karena kondisi berhenti dicek setalah aksi dieksekusi)
-
Berdasarkan kondisi mengulang:
- Dimungkinkan aksi tidak pernah dilakukan (karena kondisi mengulang dicek sebelum aksi dilakukan)
while <kondisi-loop> do <aksi>
- Dimungkinkan aksi tidak pernah dilakukan (karena kondisi mengulang dicek sebelum aksi dilakukan)
-
Berdasarkan dua aksi:
- merupakan gabungan dari repeat-until dan while-do
- aksi-1 minimum dilakukan 1x dan aksi-2 bisa tidak dilakukan sama sekali
iterate <aksi-1> stop <kondisi-berhenti> <aksi-2>
-
Berdasarkan pencacah:
- Pencacah harus bertype ordinal (integer)
- Diketahui dengan pasti nilai awal dan akhir pencacah
{ mencacah maju } <pencacah> traversal [<min>..<max>] <aksi> { mencacah mundur } <pencacah> traversal [<max>..<min>] <aksi>
Note :
-
First_Elmt : Elemen pertama
-
Current_ELmt : Elemen yang siap diproses
-
Next_Elmt : Elemen yang diakses setelah Current_Elmt
-
EOP : Tanda akhir proses, Bernilai True jika,
-
Dengan Mark : elemen terakhir adalah elemen fiktif (bukan anggota elemen yang diproses) ex :
SKEMA PEMROSESAN SEKUENSIAL DENGAN MARK { Tanpa penanganan kasus kosong } SKEMA Inisialisasi First_Elmt while not (EOP) do proses_Current_ELmt Next_Elmt {EOP} Terminasi
SKEMA PEMROSESAN SEKUENSIAL DENGAN MARK { Dengan penanganan kasus kosong } SKEMA First_Elmt if (EOP) then proses_Kasus_Kosong else Inisialisasi repeat proses_Current_Elmt Next_Elmt until (EOP) Terminasi
-
Tanpa Mark : elemen terakhir bagian dari elemen yang diproses (tidak mungkin ada kasus kosong) ex :
SKEMA PEMROSESAN SEKUENSIAL TANPA MARK { Tanpa penanganan kasus kosong } { Dengan iterate-stop } SKEMA Inisialisasi First_Elmt iterate proses_Current_Elmt stop (EOP) Next_Elmt Terminasi
SKEMA PEMROSESAN SEKUENSIAL TANPA MARK { Tanpa penanganan kasus kosong } { Dengan repeat-until } SKEMA Inisialisasi First_Elmt repeat proses_Current_Elmt Next_Elmt until (EOP) Terminasi
-
- dengan pesan kesalahan
SKEMA VALIDASI MASUKAN { Data masukan duvalidasi shg didapatkan data yang valid } { Proses tanpa mark, dengan iterate-stop } { Jika data tidak valid, diberikan pesan kesalahan } SKEMA iterate input(<data>) stop(<data_valid>) <pesan_kesalahan> <proses_data_valid>
- tanpa pesan kesalahan
SKEMA VALIDASI MASUKAN { Data masukan duvalidasi shg didapatkan data yang valid } { Proses tanpa mark, dengan repeat-until } { Jika data tidak valid, diberikan pesan kesalahan } SKEMA repeat input(<data>) until (<data_valid>) <proses_data_valid>
Note : Digunakan model akses sekuensial tanpa mark.
- Proses Maju
KAMUS UMUM PEMROSESAN ARRAY constant NMin : integer = 1 constant NMax : integer = 100 type Eltype : ... {type terdefinisi} {Variabel} i : integer{NMin..NMax} T : array[NMin..NMax] of Eltype { Deklarasi Prosedur } procedure Inisialisasi {Persiapan sebelum pemrosesan} procedure Proses (input X : Eltype) {Proses current_elmt} procedure Terminasi {Penutupan setelah pemrosesan selesai}
{ SKEMA PEMROSESAN ARRAY T untuk indekse [NMin..NMax] } { dengan iterate-stop } Inisialisasi iterate Proses(T[i]) stop (i = NMax) i <- i + 1 Terminasi
{ SKEMA PEMROSESAN ARRAY T untuk indekse [NMin..NMax] } { dengan traversal } i traversal[NMin..NMax] Proses(T[i]) Terminasi
- Contoh Proses Mundur
Program TulisTABELMundur {Menuliskan isi tabel dari indeks terbesar ke terkecil} KAMUS constant NMin : integer = 1 constant NMax : integer = 100 T : array[NMin..NMax] of integer i : integer[NMin..NMax] N : integer {ukuran efektif tabel yang terisi 1..N} ALGORITMA {Anggap T[NMin..N] sudah terisi} i traversal [N..NMin] output (T[i])
-
Jumlah Elemen diketahui
KAMUS constant NMax : integer = 1 constant NMin : integer = 100 i : integer[NMin..NMax] T : array[NMin..NMax] of integer N : integer ALGORITMA {inisialisasi} repeat input(N) until (N >= 1) and (N <= 100) i traversal (NMin..N) input(T[i])
-
Jumlah Elemen tidak diketahui
KAMUS constant NMin : integer = 1 constant NMax : integer = 100 i : integer[NMin..NMax] T : array[NMin..NMax] of integer N : integer x : integer {nilai penyimpanan sementara} ALGORITMA i <- NMin input (x) while (x != 9999) and (i <= NMax) do T[i] <- x i <- i + 1 input (x) if (i > NMax) then output ("Tabel sudah penuh") N <- i-1
```
KAMUS UMUM
constant NMax : integer = 100
type TabInt : array [1..NMax] of integer
T : TabInt
N : integer
```
-
Mengembalikan nilai maksimum
procedure MAX (input T : TabInt, input N : integer, output MAX : integer) { I.S. array T tidak kosong, N > 0} { F.S. Menghasilkan nilai maksimum dari array T } KAMUS LOKAL i : integer ALGORITMA MAX <- T[1] i <- 2 while (i <= N) do if (MAX < T[i]) then MAX <- T[i] i <- i + 1 Terminasi
-
Mengembalikan indeks nilai maksimum
procedure IMAX (input T : TabInt, input N : integer, output IMax : integer) { I.S. array T tidak kosong, N > 0} { F.S. Menghasilkan nilai maksimum dari array T } KAMUS LOKAL i : integer ALGORITMA IMax <- 1 i <- 2 while (i <= N) do if (T[IMax] < T[i]) then IMax <- i i <- i+1 Terminasi
```
KASUS UMUM
constant NMax : integer = 100
type TabInt : array [1..NMax] of integer
T : TabInt
N : integer
```
-
Searching tanpa Boolean
procedure SEQSearch (input T : TabInt, input N : Integer, input X : integer, output IX : integer) { I.S. T tidak boleh kosong, N > 0, biar T[i] tidak error } KAMUS LOKAL i : integer ALGORITMA i <- 1 while (i < N) and (T[i] != X) do i <- i + 1 if (T[i] = X) then IX <- i else IX <- 0
-
Searching dengan Boolean
procedure SEQSearchX (input T : TabInt, input N : integer, input X : integer, output IX : integer) { I.S. T boleh kosong karena tidak ada pemeriksaan terhadap T[i]} KAMUS LOKAL i : integer Found : boolean ALGORITMA Found <- false i <- 1 while (i <= N) and (not Found) do if (T[i] = X) then Found <- true else i <- i+1 if (Found) then IX <- i else IX <- 0
-
Searching pada array terurut
procedure SEQSearchSorted (input T : TabInt, input N : integer, input X : integer, output IX : integer) KAMUS LOKAL i : integer ALGORITMA while (i < N) and (T[i] < X) i <- 1 if (T[i] = X) then IX <- i else IX <- 0
-
Searching dengan sentinel (Note : sentinel adalah elemen fiktif yang sengaja dipasang pada akhir array)
procedure SEQSearchwithSent (input T : TabInt, input N : integer, input X : integer, output IX : integer) KAMUS LOKAL i : integer[1..N+1] ALGORITMA T[N+1] = X while (T[i] != X) do i <- i + 1 if i < N+1 then IX <- i else IX <- 0
```
KAMUS UMUM
constant NMax : integer = 100
type TabInt : array [1..NMax] of integer
N : integer
T : TabInt
```
Note : dipakai jika diketahui nilai minmum dan maksimum dari array
procedure CountSORT (input/output T : TabInt, input N : integer)
KAMUS LOKAL
TabCount : array [ValMin..ValMax] of integer
i, j : integer
K : integer
ALGORITMA
if (N > 1) then
{ inisialisasi TabCount }
i traversal [ValMin..ValMax]
TabCount[i] <- 0
{ Counting }
i traversal [1..N]
TabCount[T[i]] <- TabCount[T[i]] + 1
{ pengisian kembali }
K <- 0
i traversal [ValMin..ValMax]
if (TabCount != 0) then
j traversal [1..TabCount[i]]
K <- K+1
T[K] <- i
Note : mengurutkan array [1..N] terurut mengecil degan maksmimum suksesif, atau bisa jgua terurut membasar dengan minimum suksesif
procedure (input/output T : TabInt, input N : integer)
KAMUS LOKAL
i : integer
Pass : integer
Temp : integer {memorisasi untuk penukaran T[pass] dan T[IMax]}
IMax : integer {indeks maks untuk T[Pass..N]}
ALGORITMA
if (N>1) then
Pass traversal (1..N-1)
{Tentukan nilai maksmimum dari T[Pass..N]}
IMax <- Pass
i traversal [Pass+1..N]
if T[IMax] < T[i] then
IMax <- i
{ Tukar nilai T[IMax] dengan T[Pass] }
Temp <- T[IMax]
T[IMax] <- T[Pass]
T[Pass] <- Temp
procedure InsertionSORT (input/output T : TabInt, input N : integer)
{ mengurutkan tabel degan terurut membesar }
KAMUS LOKAL
i : integer
Pass : integer
Temp : integer
ALGORITMA
if (N>1) then
{T[1] adalah elemen yang sudah terurut}
Pass traversal [2..N]
Temp <- T[Pass]
{bandingkan nilai Temp dengan elemen sebelumnya}
i <- Pass-1
while (Temp < T[i]) and (i > 1) do
T[i+1] <- T[i] {geser}
i <- i-1
if (Temp >= T[i]) then
T[i+1] <- Temp
else
T[i+1] <- T[i]
T[i] <- Temp
-
Versi Asli
procedure BubbleShort KAMUS LOKAL i, K : integer Pass : integer Temp : integer ALGORITMA if (N > 1 ) then Pass traversal [1..N-1] K traversal [N..Pass+1] if (T[K] < T[K-1]) then Temp <- T[K] T[K] <- T[K-1] T[K-1] <- Temp
-
Versi Optimum : akan berhenti jika sudah terurut/tidak terjadi penuakaran sama sekali
procedure BubbleSortPlus (input/ouput T : TabInt, input N : integer) KAMUS LOKAL i : integer Pass : integer Temp : integer Tukar : boolean ALGORITMA if (N > 1) then Pass <- 1 Tukar <- true while (Pass <= N-1) and (Tukar) do Tukar <- false K traversal [N..Pass+1] if (T[k] < T[K-1]) then Temp <- T[K] T[K] <- T[K-1] T[K-1] <- Temp Tukar <- true Pass <- Pass + 1
-
Kamus
type rekaman : < var1 : datatype var2 : datatype ... > NamaArsip : SEQFILE of (*) nama_rek : rekaman (1) mark
-
Assign Nama Fisik (nama file di harddisk) ke nama lojik (variabel dalam program)
assign(namaArsip,namaFisik)
-
Membuka File
open(namaArsip, nama_rek)
: mempersiapkan file untuk dibaca (read-only)rewrite(namaArsip)
: mempersiapkan file untuk ditulis
-
Membaca File
read(namaArsip,nama_rek)
-
Menulis File
write(namaArsip, nama_rek_baru)
-
Menutup File : harus berpasangan dengan open/rewrite
close(namaArsip)
-
EOP : tercapainya mark
-
Skema Pembacaan File
KAMUS UMUM f : SEQFILE of (*) cc : character (1) '.'
- Repeat-Until
ALGORITMA assign(f, "dataku.txt") open(f,cc) {First_ELmt} if (cc = '.') then output ("File kosong") else repeat output(CC) {proses_Current_Elmt} read(f,cc) {Next_Elmt} until (cc = '.') close (f)
- while-do
ALGORITMA assign(f, "dataku.txt") open(f,cc) while (cc != '.') do output (cc) read (f,cc) close (f)
- Repeat-Until
-
Skema Penulisan File
KAMUS UMUM f : SEQFILE of (*) x : integer (1) 9999
- While-Do
ALGORITMA assign(f,x) rewrite(f) input(x) {First_ELmt} while (x != 9999) do write(f,x) {Proses_Current_ELmt} input(x) {Next_elmt} write (f, 9999) close (f)
- Repeat-Until
ALGORITMA assign(f,x) rewrite(f) input(x) if (x = 9999) then ouput("File kosong") else repeat write(f,x) input(x) until (x = 9999) write(f,9999) close(f)
- While-Do
Contoh :
-
Menghitung nilai rata-rata
Program NilaiRataRata { Membaca data dalam MHS.dat da menghasilkan nilai rata-rata dari semua mahasiswa } KAMUS type rekamanMHS : <NIM : string, nilai : integer> ArsipMhs : SEQFILE of (*) RekMhs : rekamanMHS (1) <"99999999", 99> SumNil : integer JumMHS : integer ALGORITMA assign(Arsip,"MHS.dat") open(ArsipMHS,RekMHS) if (RekMHS.NIM = "99999999") and (RekMHS.nilai = 99) then output("Arsip kosong") else SumNil <- 0 JumMHS <- 0 repeat SumNil <- SumNil + RekMHS.Nilai JumMHS <- JumMHS + 1 read(ArsipMHS, RekMHS) until (RekMHS.NIM = "99999999") and (RekMHS.nilai = 99) output ("Rata-rata = " (SumNil/JumMHS)) close (ArsipMHS)
-
Menyalin isi file ke array
Program SalinKeArray KAMUS type rekamanMHS : <NIM : string, nilai : integer> ArsipMHS : SEQFILE of (*) RekMHS : rekamanMHS (1) <"99999999", 99> TabelMHS : array [1..100] of rekamanMHS JumMHS : integer ALGORITMA assign(ArsipMHS, MHS.dat) open(ArsipMHS, RekMHS) if (RekMHS.NIM = "99999999") and (RekMHS.nilai = 99) then output("Arsip kosong") else JumMHS <- 1 repeat TabelMHS[JumMHS].NIM <- RekMHS.NIM TabelMHS[JumMHS].nilai <- RekMHS.nilai JumMHS <- JumMHS + 1 read(ArsipMHS, rekMHS) until (RekMHS.NIM = "99999999") and (RekMHS.nilai = 99) JumMHS <- JumMHS - 1 {penyesuaian JumMHS} close (ArsipMHS)
-
Menyalin isi Array ke File
- Repeat-Until
Program SalinKeFile KAMUS type rekamanMHS : <NIM : string, nilai : integer> ArsipMHS : SEQFILE of (*) RekMHS : rekamanMHS (1) <"99999999", 99> TabelMHS : array [1..100] of rekamanMHS JumMHS : integer ALGORITMA { diasumsikan sudah ada bagian program yang mengisi TabelMHS dan JumMHS} assign(ArsipMHS, MHS.dat) rewrite(ArsipMHS) if (JumMHS = 0) then output ("Tabel Kosong") else i <- 1 repeat RekMHS.NIM <- TabelMHS[i].NIM RekMHS.nilai <- TabelMHS[i].nilai write(ArsipMHS, RekMHS) i <- i + 1 until (i > JumMHS) write (ArsipMHS, markMHS) close (ArsipMHS)
- While-Do
... i <- 1 while (i <= JumMHS) do RekMHS.NIM <- TabelMHS[i].NIM RekMHS.nilai <- TabelMHS[i].nilai write(ArsipMHS, RekMHS) i <- i+1 write(ArsipMHS, markMHS) ...
- Repeat-Until
Note :
{Proses-proses}
procedure Inisialisasi_Seluruh_Categ; {Inisialiasi global}
procedure Terminasi_Seluruh_Categ; { Terminasi global}
procedure Kasus_Kosong; {Penanganan kasus kosong}
procedure Init_Categ; {Inisialiasi untuk 1 kategori}
procedure Proses_Current_Categ; {Proses sebuah elemen dalam 1 kategori}
procedure Terminasi_Categ; {Terminasi sebuah kategori}
function EOP (rek : rekaman) -> boolean {true jika rek = mark}
function separator (K : keytype) -> boolean {true jika K adalah separator}
-
Tanpa Separator
- Tanpa Penanganan Kasus Kosong
SKEMA KONSOLIDASI Tanpa Separator { Input : sebuah arsip sekuensial, terurut} { Proses : proses setiap kategori adalah menghitung nilai rata-rata setiap mahasiswa} { Output : NIM dan Nilai rata-rata setiap mahasiswa} KAMUS type keytype : string { kunci rekaman } type valtype : integer { harga rekaman } type rekaman : < NIM : keytype, Nilai : valtype > constant mark : rekaman = <"99999999",0> ArsipMHS : SEQFILE of (*) RekMHS : rekaman (1) mark Current_NIM : keytype { Kategori yang sedang diproses} SUMNil : integer NKuliah : integer { banyaknya harga dari setiap kunci } ALGORITMA assign(ArsipMhs, "dataMhs.dat") open(ArsipMhs, RekMHS) while RekMhs.NIM != "99999999") do SumNIl <- 0; Nkuliah <- 0 Current_NIM <- RekMHS.NIM repeat SumNil <- SumNil + RekMHS.Nilai NKuliah <- NKuliah + 1 read(ArsipMhs, RekMHS) until (Current_NIM != RekMHS.NIM) output(Current_NIM, SumNil/NKuliah) close(ArsipMhs)
- Dengan Penanganan Kasus Kosong
SKEMA KONSOLIDASI Tanpa Separator { Input : sebuah arsip sekuensial, terurut} { Proses : proses setiap kategori adalah menghitung nilai rata-rata setiap mahasiswa} { Output : NIM dan Nilai rata-rata setiap mahasiswa} KAMUS type keytype : string { kunci rekaman } type valtype : integer { harga rekaman } type rekaman : < NIM : keytype, Nilai : valtype > constant mark : rekaman = <"99999999",0> ArsipMHS : SEQFILE of (*) RekMHS : rekaman (1) mark Current_NIM : keytype { Kategori yang sedang diproses} SUMNil : integer NKuliah : integer { banyaknya harga dari setiap kunci } ALGORITMA assign(ArsipMhs, "dataMhs.dat") open(ArsipMhs, RekMHS) if (RekMhs.NIM = "99999999") then output("Arsip Kosong") else repeat SumNIl <- 0; Nkuliah <- 0 Current_NIM <- RekMHS.NIM repeat SumNil <- SumNil + RekMHS.Nilai NKuliah <- NKuliah + 1 read(ArsipMhs, RekMHS) until (Current_NIM != RekMHS.NIM) output(Current_NIM, SumNil/NKuliah) until (RekMhs.NIM = "99999999") close(ArsipMhs)
- Tanpa Penanganan Kasus Kosong
-
Dengan Separator
Note : separator bisa lebih dari 1
Program HitungPanjangKata
{ Input : sebuah arsip sekuensial berisi teks }
{ Proses : menghitung kata terpanjang pada arsip sekuensial }
{ Output : panjang kata maksimum }
KAMUS
type keytype : character {valtype gak ada, soalnya isinya 1 saja}
type rekaman : keytype
constant mark : character = "."
constant blank : character = " " {sebagai separator}
ArsipIn : SEQFILE of
(*) CC : rekaman
(1) mark
PanjangKata : integer {Panjang kata current_categ}
MaxLength : integer {Panjang kata maksimum}
ALGORITMA
assign(ArsipIn, "data.txt")
open(ArsipIn, CC)
while (CC != mark) and (CC = blank) do
read(ArsipIn, CC)
if (CC = mark) then
output("Arsip Kosong")
else
MaxLength <- 0
repeat
PanjangKata <- 0
while (CC != mark) and (CC != blank) do
PanjangKata <- PanjangKata + 1
read(ArsipIn, CC)
if (MaxLength < PanjangKata) then
MaxLength <- PanjangKata
while (CC != mark) and (CC = blank) do
read(ArsipIn, CC)
until(CC = mark)
output("Panjang kata maksimum = ", MaxLength)
close(ArsipIn)
-
Merging - AND
Program Merging - AND { Input : Dua arsip sekuensial } { Proses : Menggabung kedua arsip menjadi arsip baru yang terurut } { Output : Sequential file baru yang terurut } KAMUS type keytype : ... type valtype : ... type rekaman : < KeyIn : keytype ValIn : valtype > constant mark : rekaman = <...,...> ArsipIn1 : SEQFILE of (*) RekIn : rekaman (1) mark ArsipIn2 : SEQFILE of (*) RekIn2 : rekaman (1) mark ArsipOut : SEQFILE of (*) RekOut : rekaman (1) mark ALGORITMA { ini tidak ada valtypenya } assign (ArsipIn1, "data.txt") open (ArsipIn1, RekIn1) assign (ArsipIn2, "data.txt") open (ArsipIn2, RekIn2) assign (ArsipOut "data.txt") open (ArsipOut, RekOut) while (RekIn1.KeyIn != mark.KeyIn) and (RekIn2.KeyIn != mark) do if (RekIn1.KeyIn <= RekIn2.KeyIn) then write(ArsipOut, RekIn1) read(ArsipIn1, RekIn1) else write(ArsipOut, RekIn2) read(ArsipIn2, RekIn2) {RekIn = mark } while (RekIn1.KeyIn != mark) do write(ArsipOut, RekIn1) read(ArsipIn1, RekIn1) while (RekIn2.KeyIn != mark) do write(ArsipOut, RekIn2) read(ArsipIn2, RekIn2) close(ArsipIn1) close(ArsipIn2) close(ArsipOut)
-
Merging - OR (Note : dipakai jika marknya paling besar diantara KeyIn)
Program Merging - AND { Input : Dua arsip sekuensial } { Proses : Menggabung kedua arsip menjadi arsip baru yang terurut } { Output : Sequential file baru yang terurut } KAMUS type keytype : ... type valtype : ... type rekaman : < KeyIn : keytype ValIn : valtype > constant mark : rekaman = <...,...> ArsipIn1 : SEQFILE of (*) RekIn : rekaman (1) mark ArsipIn2 : SEQFILE of (*) RekIn2 : rekaman (1) mark ArsipOut : SEQFILE of (*) RekOut : rekaman (1) mark ALGORITMA assign (ArsipIn1, "data.txt") open (ArsipIn1, RekIn1) assign (ArsipIn2, "data.txt") open (ArsipIn2, RekIn2) assign (ArsipOut "data.txt") open (ArsipOut, RekOut) while (RekIn1.KeyIn != mark) or (RekIn2.KeyIn != mark) do if (RekIn1.KeyIn <= RekIn2.KeyIn) then write(ArsipOut, RekIn1) read(ArsipIn1, RekIn1) else write(ArsipOut, RekIn2) read(ArsipIn2, RekIn2) close(ArsipIn1) close(ArsipIn2) close(ArsipIn3)
------FINISH------