Algoritma Tugas Pengurutan

{ Algoritma Utama }
ProgramDaftarGajiPegawai
{I.S. : pengguna memasukkan bulan, tahun, NIP, Nama dan Gol (Golongan)}
{F.S. : menampilkan daftar gaji pegawai}
Kamus : { kamus global }
Const
MAKSBARIS = 20
Type
ArrayString = array[1..MAKSBARIS] of string
Bulan, Tahun, N, Menu : integer
Nip, Nip2, NamaPegawai, NamaPegawai2, Golongan, Golongan2 : ArrayString
{ prototype subrutin }
Function TentukanGajiPokok(Input Golongan: string)
Function TentukanTunjangan(Input Golongan: string)
Procedure TentukanBulan(Output Bulan : string)
Procedure Penciptaan(Output DataArray : ArrayString)
Procedure TampilData(Input Bulan, Tahun, N : integer, Input Nip, NamaPegawai, Golongan :
ArrayString)
Procedure IsiData(I/O Nip, NamaPegawai, Golongan : ArrayString, Output N : integer)
Procedure MenuPilihan(Output Menu : integer)
Procedure Nip_BubbleSortAsc(I/O Nip, NamaPegawai, Golongan: ArrayString, Input N : integer)
Procedure Nama_BubbleSortDsc(I/O Nip, NamaPegawai, Golongan: ArrayString, Input N : integer)
Procedure Tunjangan_MinSortAsc(I/O Nip, NamaPegawai, Golongan: ArrayString, Input N : integer)
Procedure GatotMaxSortDsc(I/O Nip, NamaPegawai, Golongan: ArrayString, Input N : integer)
Algoritma :
{ pengguna memasukkan bulan dan tahun }
TentukanBulan(Bulan)
Input(Tahun)

{ penciptaan }
Penciptaan(Nip)
Penciptaan(Nip 2)
Penciptaan(NamaPegawai)
Penciptaan(NamaPegawai2)
Penciptaan(Golongan)
Penciptaan(Golongan2)
Output(‘<<< Hasil >>>’)
TampilData(Bulan, Tahun, Nip, NamaPegawai, Golongan, MAKSBARIS)

{ banyak data pegawai }

Input(N)
While (N < 0) or (N > MAKS_PEGAWAI) do
Output(‘Banyak Data Pegawai tidak boleh kurang dari 0 atau lebih dari’,MAKSBARIS)
Input(N)
EndWhile

{ isi pegawai }
IsiData(Nip, NamaPegawai, Golongan, N)

{ tampil data pegawai }

TampilData(Bulan, Tahun, Nip, NamaPegawai, Golongan,N)

{ menu pilihan }
MenuPilihan(Menu)
While (Menu ≠ 0) do
If (Menu = 1) { bubble sort ascending }
Then
Output(‘<<< NIP Terurut Ascending (Bubble Sort) >>>’)
Nip2  Nip
NamaPegawai 2  NamaPegawai
Golongan2  Golongan
Nip_BubbleSortAsc(Nip2, NamaPegawai2, Golongan2, N)
TampilPegawai(Bulan, Tahun, Nip2, NamaPegawai2, Golongan2, N)
Else
If(Menu = 2) { bubble sort descending }
 Then
Output(‘<<< Golongan Pegawai Terurut Descending (Bubble Sort) >>>’)
Nip2  Nip
NamaPegawai 2  NamaPegawai
Golongan2  Golongan
Nama_BubbleSortDsc(Nip2, NamaPegawai2, Golongan2, N)
TampilPegawai(Bulan, Tahun, Nip2, NamaPegawai2, Golongan2, N)
Else
If(Menu = 3) { minimum sort ascending }
Then
Output(‘<<< Tunjangan Pegawai Terurut Ascending (Minimum Sort) >>>’)
Nip2  Nip
NamaPegawai 2  NamaPegawai
Golongan2  Golongan
TunjanganMinSortAsc(Nip2, NamaPegawai2, Golongan2, N)
TampilData(Bulan, Tahun, Nip2, NamaPegawai2, Golongan2, N)
Else
If(Menu = 4) { maximum sort ascending }
Then
Output(‘<<< Gaji Total Pegawai Terurut Descending (Maximum Sort) >>>’)
Nip2  Nip
NamaPegawai 2  NamaPegawai
Golongan2  Golongan
GatotMaxSortDsc(Nip2, NamaPegawai2, Golongan2)
TampilData(Nip2, NamaPegawai2, Golongan2)
EndIf
EndIf
EndIf
EndIf
EndWhile

{ Subrutin HitungGajiPokok }
Function HitungGajiPokok (Input Gol : string)
{I.S. : pengguna memasukkan Gol(Golongan)}
{F.S. : menghasilkan gaji pokok berdasarkan Gol(Golongan) }
Kamus : { kamus lokal }
{ tidak ada }
Algoritma :
If(Gol = ‘I’)
Then
HitungGajiPokok 1250000
Else
If(Gol = ‘II’)
Then
HitungGajiPokok  1350000
Else
If(Gol = ‘III’)
Then
HitungGajiPokok  1500000
Else
If(Gol = ‘IV’)
Then
HitungGajiPokok  1750000
Else
HitungGajiPokok  0
Endif
Endif
Endif
Endif
EndFunction

{ Subrutin HitungTunjangan}
Function HitungTunjangan (Input Gol : string)
{I.S. : pengguna memasukkan Gol(Golongan)}
{F.S. : menghasilkan tunjangan berdasarkan Gol(Golongan) }
Kamus : { kamus lokal }
{ tidak ada }
Algoritma :
If(Gol = ‘I’)
Then
HitungTunjangan 1250000 * 0.1
Else
If(Gol = ‘II’)
Then
HitungTunjangan  1350000 * 0.125
Else
If(Gol = ‘III’)
Then
HitungTunjangan  1500000 *0.15
Else
If(Gol = ‘IV’)
Then
HitungTunjangan  1750000 * 0.2
Else
HitungTunjangan  0
Endif
Endif
Endif
Endif
EndFunction

{ Subrutin PilihBulan }
Procedure PilihBulan(Output Bulan : string)
{I.S. : pengguna memasukkan bulan antara 01-12 }
{F.S. : menghasilkan bulan}
Kamus : { kamus lokal }
 { tidak ada }
Algoritma :
Input(Bulan)
{ validasi bulan }
While (Bulan < 1) or (Bulan > 12)
Then
Output(‘Bulan harus diantara 01-12, ulangi!’)
Input(Bulan)
Endwhile
EndProcedure

{ Subrutin Penciptaan }
Procedure Penciptaan(Output DataArray : ArrayString)
{I.S. : elemen DataArray diberi harga awal agar siap digunakan}
{F.S. : menghasilkan DataArray yang siap digunakan}
Kamus : { kamus lokal }
i : integer
Algoritma :
For i  1 to MAKS_PEGAWAI do
DataArray(i)  ‘/’
EndFor
EndProcedure

{ Subrutin TampilPegawai }
Procedure TampilPegawai(Input Bulan, Tahun, N : integer, Input NIP, Nama, Gol : ArrayString)
{I.S. : bulan, tahun, N(BanyakData), NIP,Nama, dan Gol(Golongan) sudah terdefinisi}
{F.S. : menampilkan data pegawai dalam bentuk tabel}
Kamus: { kamus lokal }
i, GajiPokok: integer
Tunjangan, PPN, GajiTotal : real
{ prototype subrutin }
 Function HitungGajiPokok(Input Gol : string)
Function HitungTunjangan(Input Gol : string)
Algoritma :
Output(‘ DAFTAR GAJI PEGAWAI’)
Output(Bulan,Tahun)

Output(‘-------------------------------------------------------------------------------------------------------------------------------
------------------------‘)
Output(‘| No | NIP | Nama Pegawai | Gol. | Gaji Pokok | Tunjangan | PPN
| Gaji Total |’)

Output(‘-------------------------------------------------------------------------------------------------------------------------------
------------------------‘)
For i  1 to N do
GajiPokok  HitungGajiPokok(Gol(i))
Tunjangan  HitungTunjangan(Gol(i))
GajiTotal  GajiPokok + Tunjangan
PPN  0.1 * GajiTotal
GajiTotal  GajiTotal – PPN
Output(i, NIP(i), Nama(i), Gol(i), GajiPokok, Tunjangan, PPN, GajiTotal)
Endfor

Output(‘-------------------------------------------------------------------------------------------------------------------------------
------------------------‘)
EndProcedure

{ Subrutin IsiPegawai }
Procedure IsiPegawai(I/O NIP, Nama, Gol : ArrayString, Output N : integer)
{I.S. : pengguna memasukkan NIP, Nama, Gol(Golongan)}
{F.S. : menghasilkan NIP, Nama, Gol(Golongan)}
Kamus : { kamus lokal }
i : integer
Algoritma :
Output(‘<<< Memasukkan Data Pegawai Sebanyak’, N, ‘Pegawai’)
For i  1 to N do
 Output(‘Data Pegawai Ke-‘, i)
Output(‘----------------------------‘)
Input(NIP(i), Nama(i), Gol(i))
{ validasi golongan }
While (Gol(i) ≠ ‘I’) and (Gol(i) ≠ ‘II’) and (Gol(i) ≠ ‘III’) and (Gol(i) ≠ ‘IV’)
Output(‘Golongan harus antara I-IV, ulangi!’)
Input(Gol(i))
EndWhile
EndFor
EndProcedure

{ Subrutin MenuPilihan }
Procedure MenuPilihan(Output Menu : integer)
{I.S. : pengguna memilih salah satu nomor menu}
{F.S. : menghasilkan nomor menu yang dipilih}
Kamus : { kamus lokal }
{ tidak ada }
Algoritma :
Output(‘MENU PENGURUTAN’)
Output(‘-------------------------------‘)
Output(‘1. NIP’)
Output(‘2. Golongan’)
Output(‘3. Golongan’)
Output(‘4. Gaji Total’)
Output(‘0. Keluar’)
Input(Menu)
{ validasi menu pilihan }
While (Menu < 0) or (Menu > 4) do
Output(‘Pilihan harus diantara 0-4, ulangi!’)
Input(Menu)
EndWhile
EndProcedure
{ Subrutin Bubble Sort Ascending}
Procedure Nip_BubbleSortAsc (I/O NIP, Nama, Gol : ArrayString, Input N : integer)
{I.S.: NIP, Nama, Gol(Golongan), N(BanyakData) sudah terdefinisi }
{F.S.: menghasilkan NIP yang sudah tersusun secara ascending (menaik) }
Kamus : { kamus lokal }
i, j : integer
Temp : string { penampung sementara }
Algoritma :
For i  1 to N-1 do
For j  N downto i+1 do
If(NIP(j) < NIP(j-1))
Then
Temp  NIP(j)
NIP(j)  NIP(j-1)
NIP(j-1)  Temp

Temp  Nama(j)
Nama(j)  Nama(j-1)
Nama (j-1)  Temp

Temp  Gol(j)
Gol(j)  Gol(j-1)
Gol (j-1)  Temp
EndIf
EndFor
EndFor
EndProcedure

{ Subrutin Bubble Sort Descending }

Procedure Nama_BubbleSortDsc (I/O NIP, Nama, Gol : ArrayString, Input N : integer)
{I.S.: NIP, Nama, Gol(Golongan), N(BanyakData) sudah terdefinisi }
{F.S.: menghasilkan Gol(Golongan) yang sudah tersusun secara descending (menurun) }
Kamus : { kamus lokal }
i, j : integer
Temp : string { penampung sementara }
Algoritma :
For i  1 to N-1 do
For j  1 to N-i do
If(Gol(j) < Gol(j+1))
Then
Temp  NIP(j)
NIP(j)  NIP(j+1)
NIP(j+1)  Temp

Temp  Nama(j)
Nama(j)  Nama(j+1)
Nama(j+1)  Temp

Temp  Gol(j)
Gol(j)  Gol(j+1)
Gol(j+1)  Temp
EndIf
EndFor
EndFor
EndProcedure

{ Subrutin Minimum Sort Ascending }

Procedure Tunjangan_MinSortAsc (I/O NIP, Nama, Gol : ArrayString, Input N : integer)
{I.S.: NIP, Nama, Gol(Golongan), N(BanyakData) sudah terdefinisi }
{F.S.: menghasilkan Tunjangan yang sudah tersusun secara minimum ascending }
Kamus : { kamus lokal }
i, j, min : integer
Temp : string { penampung sementara }
 { prototype subrutin }
Function HitungGajiPokok(Input Gol : string)
Function HitungTunjangan(Input Gol : string)
Algoritma :
For i  1 to (N-1) do
min  i
For j  (i+1) to N do
Tunjangan  HitungTunjangan(Gol(j))
TunjanganMin  HitungTunjangan(Gol(min))
If(Tunjangan < TunjanganMin)
Then
min  j
EndIf
EndFor
Temp  NIP(min)
NIP(min)  NIP(i)
NIP(i)  Temp

Temp  Nama(min)
Nama(min)  Nama(i)
Nama(i)  Temp

Temp  Gol(min)
Gol(min)  Gol(i)
Gol(i)  Temp
EndFor
EndProcedure

{ Subrutin Maximum Sort Descending }

Procedure GatotMaxSortDsc (I/O NIP, Nama, Gol : ArrayString, Input N : integer)
{I.S.: NIP, Nama, Gol(Golongan), N(BanyakData) sudah terdefinisi }
{F.S.: menghasilkan Gaji Total yang sudah tersusun secara maximum descending}
Kamus : { kamus lokal }
i, j, max : integer
Temp : string { penampung sementara }
{ prototype subrutin }
Function HitungGajiPokok(Input Gol : string)
Function HitungTunjangan(Input Gol : string)
Algoritma :
For i  1 to (N-1) do
max  i
For j  (i+1) to N do
GajiPokok  HitungGajiPokok(Gol(j))
Tunjangan  HitungTunjangan(Gol(j))

GajiTotal  GajiPokok + Tunjangan

PPN  0.1 * GajiTotal
GajiTotal  GajiTotal - PPN

GajiPokok2  HitungGajiPokok(Gol(max))
Tunjangan2  HitungTunjangan(Gol(max])

GajiTotal2  GajiPokok2 + Tunjangan2

PPN2  0.1 * GajiTotal2
GajiTotal2  GajiTotal2 - PPN2
If(GajiTotal > GajiTotal2)
Then
max  j
EndIf
EndFor
Temp  NIP(max)
NIP(max)  NIP(i)
NIP(i)  Temp
 Temp  Nama(max)
Nama(max)  Nama(i)
Nama(i)  Temp

Temp  Gol(max)
Gol(max)  Gol(i)
Gol(i)  Temp
EndFor
EndProcedure