PROGRAM MenghitungLuasDanKelilingLingkaran;

{Program Ini Untuk Membaca Nilai Diameter Sebuah Lingkaran Untuk

Dicari Nilai Luas Dan Kelilingnya}
{* DEKLARASI *}
uses crt;
var
D:real; {Menyatakan Diameter Lingkaran Dalam Meter}
L:real; {Menyatakan Luasan Lingkaran}
K:real; {Menyatakan Keliling Lingkaran}
const phi=3.14; {Menyatakan Ketetapan Nilai phi}
{* ALGORITMA *}
begin;
writeln('PROGRAM MENGHITUNG LUAS DAN KELILING LINGKARAN DIMULAI');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
write('Masukan Diameter Lingkaran D = ');
readln(D);
L:=0.25*phi*sqr(D);
writeln('Maka Luas Lingkaran = ',L,'m^2');
K:=phi*D;
writeln('Dan Keliling Lingkaran = ',K,'m^2');
writeln('===PROGRAM INI TELAH SELESAI, SILA LANJUTKAN PROGRAM
BARU===');
end.

PROGRAM PenjumlahanDasarSederhana;
{Program Ini Merupakan Program Penjumlahan Sederhana 2 Bilangan}
{* DEKLARASI *}
uses crt;
var
a:real;
b:real;
S:real;
{* ALGORITMA *}
begin;
writeln('PROGRAM PENJUMLAHAN 2 BUAH BILANGAN RIIL');
write('masukan nilai a= ');
readln(a);
write('masukan nilai b= ');
readln(b);
S:=a+b;
writeln(S);
writeln('===PROGRAM SELESAI SILA MEMULAI PROGRAM KEMBALI===');
end.

PROGRAM ModifikasiOutputHelloWorld;
{Program Ini Bentuk Lain Algoritma Hello World}
{* DEKLARASI *}
uses crt;
const pesan='Hello World';
{* ALGORITMA *}
begin
write(pesan);
end.

PROGRAM Pertukaran;
{Program Mempertukarkan Nilai A Dengan B Dan Sebaliknya}
{* DEKLARASI *}
uses crt;
var
A:integer;
B:integer;
C:integer;
Abaru:integer;
Bbaru:integer;
{* ALGORITMA *}
begin;
writeln('PROGRAM SALING MEMPERTUKARKAN NILAI A DAN B, DIMULAI');
writeln('OLEH: NGAKAN PUTU PURNADITYA');
write('Masukkan Nilai A, A-awal = ');
readln(A);
write('Masukkan Nilai B, B-awal = ');
readln(B);
C:=A;
Abaru:=B;
writeln('Hasil Pertukaran Nilai');
writeln('Sehingga Nilai A Yang Baru Adalah, A-baru = ',Abaru);
Bbaru:=C;
writeln('Sedangkan Nilai B Yang Baru Adalah, B-baru = ',Bbaru);
writeln('===PROGRAM PERTUKARAN NILAI A DAN B SELESAI===');
end.

PROGRAM PerhitunganGajiKaryawan;
{Program Menghitung Gaji Karyawan, Program Sederhana}
{* DEKLARASI *}
uses crt;
var
PersenTunjangan:real;
PersenPajak:real;
GajiBersih:real;
GajiPokok:real;
Tunjangan:real;
Pajak:real;
NamaKaryawan:string;
{* ALGORITMA *}
begin;
writeln('PROGRAM PERHITUNGAN GAJI KARYAWAN, DIMULAI');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
write('Nama Karyawan : ');
readln(NamaKaryawan);
write('Gaji Pokok Yang Diterima : ');
readln(GajiPokok);
write('Persen Tunjangan Yang Diterima : ');
readln(PersenTunjangan);
write('Persen Potongan Pajak Yang Dibebankan : ');
readln(PersenPajak);
writeln('HASIL RINCIAN PERHITUNGAN GAJI ADALAH SEBAGAI BERIKUT
INI :');
Tunjangan:=PersenTunjangan*GajiPokok;
writeln('Tunjangan Yang Diterima Adalah : ',Tunjangan);
Pajak:=PersenPajak*GajiPokok;
writeln('Potongan Pajak Adalah : ',Pajak);
GajiBersih:=GajiPokok+Tunjangan-Pajak;
writeln('Sehingga Gaji Bersih Yang Diterima Oleh Karyawan Atas Nama
',NamaKaryawan,' Adalah : ',GajiBersih);
writeln('=====PROGRAM PERHITUNGAN GAJI KARYAWAN, SELESAI=====');
end.

PROGRAM TitikTengah;
{Program Untuk Menghitung Titik Tengah Dari Dua Buah Titik}
{* DEKLARASI *}
uses crt;
type titik=record
x:real;
y:real;
end;
var
P1:titik;
P2:titik;
P3:titik;
{* ALGORITMA *}
begin;
writeln('PROGRAM MENCARI TITIK TENGAH DARI 2 KOORDINAT, DIMULAI');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
write('Masukkan Titik P1.x : ');
readln(P1.x);
write('Masukkan Titik P1.y : ');
readln(P1.y);
write('Masukkan Titik P2.x : ');
readln(P2.x);
write('Masukkan Titik P2.y : ');
readln(P2.y);
P3.x:=(P1.x+P2.x)/2;
P3.y:=(P1.y+P2.y)/2;
writeln('Maka Titik Tengah Antara Koordinat P1 Dan P2 Adalah P3 :
',P3.x,' , ',P3.y);
writeln('=====PROGRAM MENCARI TITIK TENGAH DARI 2 KOORDINAT,
SELESAI=====');
end.

PROGRAM KonversiWaktuKeDetik;
{Program Untuk Mengubah Satuan Jam Menjadi Detik}
{* DEKLARASI *}
uses crt;
type Jam=record
hh:longint;
mm:longint;
ss:longint;
end;
var
J:Jam;
TotalDetik:longint;
{* ALGORITMA *}
begin;
writeln('PROGRAM KONVERSI JAM KE DETIK, DIMULAI');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
write('Input Jam : ');
readln([Link]);
write('Input Menit : ');
readln([Link]);
write('Input Detik : ');
readln([Link]);
writeln('Waktu Yang Akan Dikonversi Dalam hh:mm:ss, Adalah,
',[Link],':',[Link],':',[Link]);
TotalDetik:=[Link]*3600+[Link]*60+[Link]*1;
writeln('Hasil Konversi Dari ',[Link],':',[Link],':',[Link], ' Adalah
',TotalDetik,' Detik');
writeln('=====PROGRAM KONVERSI JAM KE DETIK, SELESAI=====');
end.

PROGRAM KonversiDetikKeJam;
{Program Yang Mengkonversi Detik Ke Satuan Jam}
{* DEKLARASI *}
uses crt;
type Jam=record
hh:longint;
mm:longint;
ss:longint;
end;
var
J:Jam;
TotalDetik:longint;
SisaDetik:longint;
{* ALGORITMA *}
begin;
writeln('PROGRAM KONVERSI DETIK MENJADI JAM, DIMULAI');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
write('Masukkan Nilai Detik Yang Akan Dikonversi, Detik : ');
readln(TotalDetik);
[Link]:=TotalDetik div 3600;
SisaDetik:= TotalDetik mod 3600;
[Link]:=SisaDetik div 60;
[Link]:=SisaDetik mod 60;
writeln('Jadi, Nilai ',TotalDetik,' Detik Dapat Dikonversi Dalam
Satuan Jam hh:mm:ss Berikut : ',[Link],':',[Link],':',[Link]);
end.

PROGRAM DurasiWaktu;
{Program Untuk Menghitung Durasi Dari Perpindahan 2 Waktu}
{* DEKLARASI *}
uses crt;
type Jam=record
hh:longint;
mm:longint;
ss:longint;
end;
var
DurasiDetik1:longint;
DurasiDetik2:longint;
DurasiDetik3:longint;
SisaDetik:longint;
J1,J2,J3:jam;
{* ALGORITMA *}
begin;
writeln('PROGRAM MENGHITUNG DURASI WAKTU, DIMULAI');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('PERTAMA, TENTUKAN VARIABEL JAM PERTAMA (J1)');
write('Input [Link] : '); readln([Link]);
write('Input [Link] : '); readln([Link]);
write('Input [Link] : '); readln([Link]);
DurasiDetik1:=[Link]*3600+[Link]*60+[Link]*1;
Writeln('Durasi Detik Untuk Waktu ',[Link],':',[Link],':',[Link],' Adalah
',DurasiDetik1,' Detik');
writeln('KEDUA, TENTUKAN VARIABEL JAM KEDUA (J2)');
write('Input [Link] : '); readln([Link]);
write('Input [Link] : '); readln([Link]);
write('Input [Link] : '); readln([Link]);
DurasiDetik2:=[Link]*3600+[Link]*60+[Link]*1;
Writeln('Durasi Detik Untuk Waktu ',[Link],':',[Link],':',[Link],' Adalah
',DurasiDetik2,' Detik');
DurasiDetik3:=abs(DurasiDetik1-DurasiDetik2);
[Link]:=DurasiDetik3 div 3600;
SisaDetik:=DurasiDetik3 mod 3600;
[Link]:=SisaDetik div 60;
[Link]:=SisaDetik mod 60;
writeln('Selisih Waktu Yang Didapat Antara Jam Pertama Dan Jam Kedua
Adalah ',DurasiDetik3,' Detik Atau ',[Link],' Jam ',[Link],' Menit
',[Link],' Detik ');
writeln('=====PROGRAM DURASI ANTAR 2 WAKTU, SELESAI=====');
end.

PROGRAM TambahWaktu;
{Membaca Waktu Jika Ditambah Sekian Detik}
{* DEKLARASI *}
uses crt;
type jam=record
hh:integer;
mm:integer;
ss:integer;
end;
var
J:jam;
X:integer; {Selisih Penambahan Waktu}
Ts:integer; {Total Detik}
Tm:integer; {Total Menit}
Th:integer; {Total Jam}
{* ALGORITMA *}
begin;
writeln('PROGRAM PENAMBAHAN WAKTU, DIMULAI');
writeln('OLEH : PURNADITYA');
writeln('===========================');
write('Masukkan Jam : '); readln([Link]);
write('Masukkan Menit : '); readln([Link]);
write('Masukkan Detik : '); readln([Link]);
write('Masukkan Tambahan Waktu (Detik), X : '); readln(X);
writeln('===========================');
writeln('Jadi Komponen Waktu ',[Link],':',[Link],':',[Link],' Akan
Ditambahkan ',X,' Detik');
Ts:=[Link]+X;
{Menentukan nilai total detik Ts
setelah ditambah X}
if Ts<60 then
{Kasus 1 Jika Ts TIDAK MELEBIHI 60
detik, maka}
begin
[Link]:=Ts;
{Nilai Detik tidak berubah yaitu Ts}
end
{Selesai Kasus 1}
else
{Jika yang terjadi bukan kasus 1 atau
Ts MELEBIHI 60 detik, maka}
begin
[Link]:=Ts mod 60;
{Nilai detik yang dipakai adalah sisa
terkecil dari Ts dibagi 60 detik}
Tm:=[Link]+Ts div 60;
{Sehingga nilai total menit Tm adalah
jumlah nilai menit dengan hasil bagi bulat Ts dengan 60}
if Tm<60 then
{Kasus 2 Jika Tm TIDAK MELEBIHI 60
menit, maka}
begin
[Link]:=Tm;
{Nilai menit tidak berubah yaitu Tm}
end
{Selesai kasus 2}
else
{Jika yang terjadi bukan kasus 2 atau
Tm MELEBIHI 60 menit, maka}

begin
[Link]:=Tm mod 60;
{Nilai menit yang dipakai sisa terkecil
dari Tm dibagi 60}
Th:=[Link]+Tm div 60;
{Sehingga nilai total jam Th adalah
jumlah nilai jam dengan hasil bagi bulat Tm dengan 60}
if Th<24 then
{Kasus 3 Jika Th TIDAK MELEBIHI 24 jam,
maka}
begin
[Link]:=Th;
{Nilai Jam tidak berubah yaitu Th}
end
{Selesai kasus 3}
else
{Jika yang terjadi bukan kasus 3 atau Th
MELEBIHI 24 jam, maka}
begin
[Link]:=Th-24;
{Nilai jam yang dipakai adalah nilai Th
yang dikurangi 24}
end
end;
end;
writeln('===========================');
writeln('Maka Jam Yang Baru Menunjukkan Pukul
',[Link],':',[Link],':',[Link]);
end.

PROGRAM PerhitunganUpahLembur;
{Perhitungan Upah Lembur Tenaga Honorer Mingguan}
{* DEKLARASI *}
uses crt;
type JamHari=record
Sn:longint;
Sl:longint;
Rb:longint;
Km:longint;
Jm:longint;
end;
var
JH:JamHari;
JTmingguan:longint;
UpahPerJam:longint;
UpahLemburPerJam:longint;
UpahTotal:longint;
NamaKaryawan:string;
Bulan:string;
MingguKe:char;
{* ALGORITMA *}
begin;
writeln('PROGRAM PERHITUNGAN UPAH HONORER, DIMULAI');

writeln('OLEH : PURNADITYA');
write('Nama Pegawai : ' ); readln(NamaKaryawan);
write('Upah Per Jam Normal : '); readln(UpahPerJam);
write('Upah Per Jam Lembur : '); readln(UpahLemburPerJam);
write('Bulan : '); readln(Bulan);
write('Minggu Ke- '); readln(MingguKe);
writeln('Berikut Ini Adalah Rincian Jam Kerja Karyawan Tersebut : ');
write('Masukkan Jam Kerja Hari Senin, : '); readln([Link]);
write('Masukkan Jam Kerja Hari Selasa, : '); readln([Link]);
write('Masukkan Jam Kerja Hari Rabu, : '); readln([Link]);
write('Masukkan Jam Kerja Hari Kamis, : '); readln([Link]);
write('Masukkan Jam Kerja Hari Jumat, : '); readln([Link]);
JTmingguan:=[Link]+[Link]+[Link]+[Link]+[Link];
if JTmingguan >= 48 then
begin
writeln('KARYAWAN MELAKUKAN LEMBUR');
UpahTotal:=JTmingguan*UpahPerJam+(JTmingguan-48)*UpahLemburPerJam;
writeln('SEHINGGA UPAH YANG DITERIMA ADALAH SEBESAR ',UpahTotal,'
Rupiah');
end
else
begin
writeln('KARYAWAN TIDAK MELAKUKAN LEMBUR');
UpahTotal:=JTmingguan*UpahPerJam;
writeln('SEHINGGA UPAH YANG DITERIMA ADALAH SEBESAR ',UpahTotal,'
Rupiah');
end;
end.

PROGRAM BilanganGenap;
{Program Bacaan Bilangan Genap}
{* DEKLARASI *}
uses crt;
var
x:integer;
{* ALGORITMA *}
begin;
writeln('Program Membaca Bilangan Genap, Dimulai');
writeln('Oleh : Purnaditya');
write('Masukkan Nilai Bilangan, X = ');
readln(x);
if x mod 2 = 0 then
begin;
writeln('X Adalah Bilangan Genap');
end;
end.

PROGRAM DurasiWaktuSelection;
{Menghitung DUrasi Waktu Dengan Tipe Algoritma Selection}
{* DEKLARASI *}
type Jam = record
hh:integer;
mm:integer;
ss:integer;
end;
var
J1,J2,J3:jam;
NomorTipe:integer;
JmlhMalam:integer;
TotalJamMalam:integer;
{* ALGORITMA *}
begin
writeln('PROGRAM MENGHITUNG DURASI WAKTU, DIMULAI');
writeln('OLEH : PURNADITYA');
writeln('MAGISTER TEKNIK SIPIL UNIVERSITAS INDONESIA');
writeln('===========================================');
writeln('1. Tipe 1 : Lewat Tengah Malam');
writeln('2. Tipe 2 : Tidak Lewat Tengah Malam');
write('Masukkan Pilihan Tipe Durasi (1 Atau 2)
: '); readln(NomorTipe);
write('Masukkan Jumlah Malam Yang Dilewati (Tulis 0 Jika Tidak
Melewati Tengah Malam) : '); readln(JmlhMalam);
TotalJamMalam:=24*JmlhMalam;
writeln('===========================================');
writeln('Tentukan Komponen Jam Awal: ');
write('Masukkan Jam Awal
: '); readln([Link]);
write('Masukkan Menit Awal : '); readln([Link]);
write('Masukkan Detik Awal : '); readln([Link]);
writeln('Jam Awal Dimulai Adalah ',[Link],':',[Link],':',[Link]);
writeln('===========================================');
writeln('Sekarang Tentukan Komponen Jam Akhir: ');
write('Masukkan Jam Akhir
: '); readln([Link]);
write('Masukkan Menit Akhir : '); readln([Link]);
write('Masukkan Detik Akhir : '); readln([Link]);
writeln('Jam Akhir Dimulai Adalah ',[Link],':',[Link],':',[Link]);
writeln('===========================================');
if [Link]>=[Link] then
begin
[Link]:=[Link];
[Link]:=[Link];
end
else
begin
[Link]:=[Link]+[Link];

[Link]:=[Link]-1;
[Link]:=[Link];
end;
[Link]:=[Link];
if [Link]>=0 then
begin
[Link]:=[Link];
end
else
begin
[Link]:=[Link]+[Link];
[Link]:=[Link]-1;
end;
[Link]:=[Link];
if [Link]>=0then
begin
[Link]:=[Link]+TotalJamMalam;
end
else
begin
[Link]:=[Link]+TotalJamMalam;
end;
writeln('===========================================');
writeln('Maka Durasi Waktu Yang Terjadi Adalah, ',[Link],' Jam
',[Link],' Menit ',[Link],' Detik ');
end.

PROGRAM KonstruksiCasePersegiPanjang;
{Konstruksi Case Untuk Menu Hitungan Persegi Panjang}
{* DEKLARASI *}
var
NomorMenu:integer;
Panjang,Lebar:real;
Luas,Keliling,Diagonal:real;
{* ALGORITMA *}
begin;
writeln('PROGRAM MENU PERSEGI PANJANG, DIMULAI');
writeln('OLEH : PURNADITYA');
writeln('=== BERIKUT INI ADALAH DAFTAR MENU PERSEGI PANJANG ===');
writeln('1. Hitung Luas');
writeln('2. Hitung Keliling');
writeln('3. Hitung Panjang Diagonal');
writeln('4. Keluar Program');
write('Masukkan Nomor Pilihan Anda : '); readln(NomorMenu);
case NomorMenu of
1:begin
write('Panjang : '); readln(Panjang);
write('Lebar
: '); readln(Lebar);
Luas:=Panjang*Lebar;
writeln('Luas Persegi Panjang : ',Luas);
end;
2:begin
write('Panjang : '); readln(Panjang);
write('Lebar
: '); readln(Lebar);
Keliling:=2*(Panjang+Lebar);
writeln('Keliling Persegi Panjang : ',Keliling);
end;
3:begin
write('Panjang : '); readln(Panjang);
write('Lebar
: '); readln(Lebar);
Diagonal:=sqrt(exp(2*ln (Panjang))+exp(2*ln (Lebar)));
writeln('Diagonal Persegi Panjang : ',Diagonal);
end;
4:writeln('Keluar Program');
end;
end.

PROGRAM PerhitunganBagunDatarSederhana;
{Pembuatan Menu Bangun Datar Sederhana}
{* DEKLARASI *}
type Persegi = record
S:real;
end;
type PersegiPanjang = record
P:real;
Lb:real;
end;
type Segitiga = record
A:real;
B:real;
T:real;
end;
type Lingkaran = record
D:real;
end;
type JajarGenjang = record
A:real;
B:real;
T:real;
end;
type Trapesium= record
A:real;
B:real;
C:real;
D:real;
T:real;
end;
type BelahKetupatAtauLayangLayang= record
A:real;
B:real;
C:real;
end;
var
NomorMenu:integer;
Ls:real;
Kl:real;
Dg:real;
Als:real;
D1:real;

D2:real;
S1:real;
S2:real;
PP:PersegiPanjang;
BJ:Persegi;
SG:Segitiga;
LK:Lingkaran;
JJG:JajarGenjang;
TP:Trapesium;
BKL:BelahKetupatAtauLayangLayang;
const phi = 3.14;
const satL = 'M2';
const satP = 'M';
{* ALGORITMA *}
begin
writeln('PROGRAM MENU BANGUN DATAR SEDERHANA, DIMULAI');
writeln('OLEH : PURNADITYA');
writeln('MAGISTER TEKNIK SIPIL UNIVERSITAS INDONESIA');
writeln('====================');
writeln('SILAKAN PILIH DAFTAR MENU BANGUN DATAR DI BAWAH INI : ');
writeln('1. Persegi/Bujur Sangkar');
writeln('2. Persegi Panjang');
writeln('3. Segitiga');
writeln('4. Lingkaran');
writeln('5. Jajar Genjang');
writeln('6. Trapesium');
writeln('7. Belah Ketupat/Layang-Layang');
writeln('====================');
write('SILAKAN MASUKKAN NOMOR PILIHAN ANDA : '); readln(NomorMenu);
case NomorMenu of
1:begin
write('Panjang Sisi, S : '); readln(BJ.S);
writeln('=================');
writeln('Berikut Hasil Properti Bangun Tersebut : ');
Ls:=exp(2*ln(BJ.S));
Kl:=4*BJ.S;
Dg:=exp(0.5*ln(BJ.S));
writeln('Luas
: ',Ls,'',satL);
writeln('Keliling : ',Kl,'',satP);
writeln('Diagonal : ',Dg,'',satP);
end;
2:begin
write('Panjang, P : '); readln(PP.P);
write('Lebar,
L : '); readln([Link]);
writeln('=================');
writeln('Berikut Hasil Properti Bangun Tersebut : ');
Ls:=PP.P*[Link];
Kl:=2*PP.P+[Link];
Dg:=sqrt(exp(2*ln(PP.P))+exp(2*ln([Link])));

writeln('Luas
: ',Ls,'',satL);
writeln('Keliling : ',Kl,'',satP);
writeln('Diagonal : ',Dg,'',satP);
end;
3:begin
write('Panjang Alas Bag 1 : '); readln(SG.A);
write('Panjang Alas Bag 2 : '); readln(SG.B);
write('Tinggi Segitiga
: '); readln(SG.T);
writeln('=================');
writeln('Berikut Hasil Properti Bangun Tersebut : ');
Als:=SG.A+SG.B;
D1:=sqrt(exp(2*ln(SG.A))+exp(2*ln(SG.T)));
D2:=sqrt(exp(2*ln(SG.T))+exp(2*ln(SG.B)));
Ls:=0.5*Als*SG.T;
Kl:=Als+D1+D2;
writeln('Luas
: ',Ls,'',satL);
writeln('Keliling : ',Kl,'',satP);
end;
4:begin
write('Panjang Diameter : '); readln(LK.D);
writeln('=================');
writeln('Berikut Hasil Properti Bangun Tersebut : ');
Ls:=0.25*phi*exp(2*ln(LK.D));
Kl:=phi*LK.D;
writeln('Luas
: ',Ls,'',satL);
writeln('Keliling : ',Kl,'',satP);
end;
5:begin
write('Panjang Alas Sejajar Bag 1: '); readln(JJG.A);
write('Panjang Alas Sejajar Bag 2: '); readln(JJG.B);
write('Tinggi Jajar Genjang
: '); readln(JJG.T);
writeln('=================');
writeln('Berikut Hasil Properti Bangun Tersebut : ');
Als:=JJG.A+JJG.B;
D1:=sqrt(exp(2*ln(JJG.A))+exp(2*ln(JJG.T)));
D2:=D1;
Ls:=Als*JJG.T;
Kl:=2*Als+D1+D2;
writeln('Luas
: ',Ls,'',satL);
writeln('Keliling : ',Kl,'',satP);
end;
6:begin
write('Panjang Alas Bag 1 : '); readln(TP.A);
write('Panjang Alas Bag 2 : '); readln(TP.B);
write('Panjang Alas Bag 3 : '); readln(TP.C);
write('Panjang Sisi Atas : '); readln(TP.D);
write('Tinggi Trapesium
: '); readln(TP.T);
writeln('=================');
writeln('Berikut Hasil Properti Bangun Tersebut : ');
Als:=TP.A+TP.B+TP.C;
D1:=sqrt(exp(2*ln(TP.A))+exp(2*ln(TP.T)));
D2:=sqrt(exp(2*ln(TP.C))+exp(2*ln(TP.T)));

Ls:=(Als+TP.D)*TP.T*0.5;
Kl:=Als+TP.D+D1+D2;
writeln('Luas
: ',Ls,'',satL);
writeln('Keliling : ',Kl,'',satP);
end;
7:begin
write('Panjang Diagonal 1
: '); readln(BKL.A);
write('Panjang Diagonal 2 Bag Min : '); readln(BKL.B);
write('Panjang Diagonal 2 Bag Max : '); readln(BKL.C);
writeln('=================');
writeln('Berikut Hasil Properti Bangun Tersebut : ');
D1:=BKL.A;
D2:=BKL.B+BKL.C;
S1:=sqrt(exp(2*ln(0.5*BKL.A))+exp(2*ln(0.5*BKL.B)));
S2:=sqrt(exp(2*ln(0.5*BKL.A))+exp(2*ln(0.5*BKL.C)));
Ls:=0.5*D1*D2;
Kl:=2*(S1+S2);
writeln('Luas
: ',Ls,'',satL);
writeln('Keliling : ',Kl,'',satP);
end;
end;
end.

PROGRAM KonstruksiForHelloWorld;
{Menuliskan Kalimat Hello World Berulang Kali}
{* DEKLARASI *}
uses crt;
var
i:longint;
N:longint;
const pesan='Hello World ';
{* ALGORITMA *}
begin;
writeln('PROGRAM PENULISAN HELLO WORLD BERULANG, DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK UNIVERSITAS INDONESIA');
write('Masukkan Jumlah Pengulangan, N : '); readln(N);
for i:=1 to N do
begin
writeln(pesan);
end;
end.

PROGRAM KonstruksiForDeretAritmatika;
{Menghitung Deret Aritmatika}
{* DEKLARASI *}
uses crt;
var
N:longint;
i:longint;
Sn:longint;
b:longint;
a:longint;
{* ALGORITMA *}
begin;
writeln('PROGRAM MENGHITUNG DERET ARITMATIKA, DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK SIPIL UNIVERSITAS
INDONESIA');
writeln('=============================================================
=');
write('Masukkan Jumlah Suku,
N : '); readln(N);
write('Masukkan Beda Nilai Antar Suku, b : '); readln(b);
write('Masukkan Nilai Awal,
a : '); readln(a);
Sn:=0;
for i:= 1 to N do
begin
Sn:=Sn+i*b+a-b;
end;

writeln('=============================================================
=');
writeln('Maka Jumlah Deret Aritmatika Tersebut Adalah, Sn : ',Sn);
end.

PROGRAM PeluncuranRoket;
{Program Hitung Mundur Waktu}
{* DEKLARASI *}
var
i:integer;
N:integer;
{* ALGORITMA *}
begin;
writeln('PROGRAM HITUNG MUNDUR, DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK SIPIL UNIVERSITAS
INDONESIA');
writeln('=============================================================
=');
write('Masukkan Detik Awal, i : '); readln(i);
write('Masukkan Detik Akhir, N : '); readln(N);
writeln('HITUNG MUNDUR DIMULAI');
writeln('=============================================================
=');
for i:=i downto N do
begin
writeln(i);
end;
writeln('HITUNG MUNDUR, SELESAI, SELAMAT MENCOBA KEMBALI');
end.

PROGRAM KonstuksiWhileHelloWorld;
{Menuliskan Hello World Dengan Konstruksi While}
{* DEKLARASI *}
var
N:integer;
i:integer;
const pesan='Hello World';
{* ALGORITMA*}
begin;
write('Masukkan Nilai N, N : '); readln(N);
i:=1;
while i<=N do
begin
writeln(pesan);
i:=i+1;
end;
end.

PROGRAM WhilePenjumlahanDeretAritmatika;
{Menjumlahkan Deret Aritmatika Dengan Konstruksi While}
{* DEKLARASI *}
var
i:integer;
N:integer;
a:integer;
b:integer;
Sn:integer;

{* ALGORITMA *}
begin;
writeln('PROGRAM JUMLAH DERET ARITMATIKA DENGAN KONSTRUKSI WHILE,
DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK SIPIL UNIVERSITAS
INDONESIA');
writeln('=============================================================
===');
write('Masukkan Jumlah Deret, N : '); readln(N);
write('Masukkan Nilai Awal,
a : '); readln(a);
write('Masukkan Beda Nilai,
b : '); readln(b);
writeln('=============================================================
===');
Sn:=0;
i:=1;
while i<= N do

begin
Sn:=Sn+i*b+a-b;
i:=i+1;
end;
writeln('=============================================================
===');
writeln('Maka Jumlah Deret Aritmatika Tersebut Adalah, Sn : ',Sn);
end.

PROGRAM RataRataNBilanganDenganWhile;
{Menghitung Rata-Rata N Bilangan Bulat Dengan Konstruksi While}
{* DEKLARASI *}
var
N:real;
X:real;
i:real;
Sx:real;
Rataan:real;
a:integer;
{* ALGORITMA *}
begin;
writeln('PROGRAM RATA-RATA SEJUMLAH N BILANGAN, DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK UNIVERSITAS INDONESIA');
writeln('========================================================');
write('Masukkan Jumlah Angka Yang AKan Dihitung, N : '); readln(N);
Sx:=0;
i:=0;
a:=0;
while i<>N do
begin
write('Masukkan Nilai X, X',a+1,' : '); readln(X);
Sx:=Sx+X;
i:=i+1;
a:=a+1;
end;
Rataan:=Sx/N;
writeln('========================================================');
writeln('Jadi Rata-Rata Angka Tersebut Adalah, ',Rataan);
writeln('========================================================');
end.

PROGRAM StatistikNBilanganDenganWhile;
{Menghitung Rata-Rata, Varian Dan Standar Deviasi N Bilangan Bulat
Dengan Konstruksi While}
{* DEKLARASI *}
uses crt;
var
N:real;
X:real;
i:real;
Sx:real;
Rataan:real;
a:integer;
Skw:real;
DeviasiSTD:real;
Varian:real;
Sxx:real;
Label ulangi;
{* ALGORITMA *}
begin;
clrscr;
writeln('PROGRAM RATA-RATA, VARIAN DAN DEVIASI STANDAR SEJUMLAH N
BILANGAN, DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK UNIVERSITAS INDONESIA');
writeln('========================================================');
write('Masukkan Jumlah Angka Yang AKan Dihitung, N : '); readln(N);
Sx:=0;
i:=0;
a:=0;
while i<>N do
begin
write('Masukkan Nilai X, X',a+1,' : '); readln(X);
Sx:=Sx+X;
i:=i+1;
a:=a+1;
end;
Rataan:=Sx/N;
writeln('========================================================');
writeln('Jadi Rata-Rata Data Tersebut Adalah, ',Rataan);
writeln('========================================================');
ulangi:
Sx:=Sx;
Rataan:=Rataan;
Sxx:=0;
Skw:=0;
i:=0;
a:=0;
while i<>N do
begin
write('Masukkan Kembali Nilai X (Sama Dengan X Sebelumnya, X',a+1,' :
'); readln(X);

Sxx:=Sxx+X;
Skw:=Skw+sqr(X-Rataan);
i:=i+1;
a:=a+1;
end;
if Sxx<>Sx then
begin
writeln('========================================================');
writeln('Ada Data Yang Tidak Sama, Perbaiki !');
writeln('========================================================');
end;
else
Varian:=Skw/(N-1);
DeviasiSTD:=sqrt(Varian);
writeln('========================================================');
writeln('Jadi Varian Data Tersebut Adalah, ',Varian);
writeln('========================================================');
writeln('========================================================');
writeln('Jadi Deviasi Standar Data Tersebut Adalah, ',DeviasiSTD);
writeln('========================================================');
end.

PROGRAM RepeatDeretAritmatika;
{Menghitung Jumlah Deret Aritmatika Dengan Konstruksi Repeat}
{* DEKLARASI *}
uses crt;
var
Sn:integer;
N:integer;
i:integer;
a:integer;
b:integer;
{* ALGORITMA *}
begin;
clrscr;
writeln('PROGRAM MENGHITUNG DERET ARITMATIKA DENGAN KONSTRUKSI REPEAT,
DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK SIPIL UNIVERSITAS
INDONESIA');
writeln('=============================================================
=');
write('Masukkan Jumlah Deret, N : '); readln(N);
write('Masukkan Nilai Awal,
a : '); readln(a);
write('Masukkan Beda Nilai,
b : '); readln(b);
Sn:=0;
i:=1;
repeat

Sn:=Sn+i*b+a-b;
i:=i+1;
until i>N;
writeln('Jadi Sn : ',Sn);
end.

PROGRAM RepeatHelloWorld;
{Mengulang Kalimat Hello World Dengan Konstruksi Repeat}
{* DEKLARASI *}
uses crt;
var
i:integer;
N:integer;
{* ALGORITMA *}
begin;
clrscr;
writeln('PROGRAM HELLO WORLD DENGAN KONSTRUKSI REPEAT, DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK UNIVERSITAS INDONESIA');
writeln('========================================================');
write('Masukkan Jumlah Pengulangan, N : '); readln(N);
i:=0;
repeat
writeln('Hello World');
i:=i+1;
until i=N;
end.

PROGRAM MenghitungNilaiRataanVarianSTDDev;
{Rataan, Varian, Standar Deviasi Dengan Konstruksi Repeat}
{* DEKLARASI *}
uses crt;
var
a:integer;
i:real;
N:real;
X:real;
Sx:real;
Skw:real;
Sxx:real;
rataan:real;
varian:real;
stdev:real;
Label ulangi;

{* ALGORITMA *}
begin;
clrscr;
writeln('PROGRAM MENGHITUNG RATAAN, VARIAN, DEVIASI STD DENGAN
KONSTRUKSI REPEAT, DIMULAI');
writeln('OLEH : PURNADITYA, MAGISTER TEKNIK SIPIL UNIVERSITAS
INDONESIA');
writeln('=============================================================
=');
write('Masukkan Jumlah Data, N : '); readln(N);
Sx:=0;
i:=0;
a:=0;
repeat
write('Masukkan Nilai X, X',a+1,' : '); readln(X);
Sx:=Sx+X;
a:=a+1;
i:=i+1;
until i=N;
rataan:=Sx/N;
writeln('=============================================================
');
writeln('Rata-Rata Data Adalah
: ',rataan);
writeln('=============================================================
');
ulangi: {Label}
Sx:=Sx;
rataan:=rataan;
Sxx:=0;
Skw:=0;
a:=0;
i:=0;
repeat
write('Masukkan Nilai X Sama Seperti Sebelumnya, X',a+1,' : ');
readln(X);
Sxx:=Sxx+X;
Skw:=Skw+sqr(X-rataan);
a:=a+1;
i:=i+1;
until i=N;
if Sxx<>Sx then
begin
writeln('Ada Data Yang Tidak Sama, Perbaiki !!');
goto ulangi;
end
else
varian:=Skw/(N-1);
stdev:=sqrt(varian);
writeln('=============================================================
');
writeln('Varian Data Adalah
: ',varian);

writeln('=============================================================
');
writeln('Standar Deviasi Data Adalah : ',stdev);
writeln('=============================================================
');
end.

PROGRAM ModularLuasNSegitiga;
{Menghitung Luas N Segitiga Dengan Konstruksi Modular}
{* DEKLARASI UTAMA *}
uses crt;
var
i:integer;
N:integer;
procedure HitungLuasSegitiga;
{Prosedur Memanggil Algoritma Hitung Luas Segitiga}
{Deklarasi}
var
alas
:real;
tinggi :real;
L
:real;
{Algoritma}
begin
write('Masukkan Panjang Alas Segitiga a, a : '); readln(alas);
write('Masukkan Tinggi Segitiga t,
t : '); readln(tinggi);
L:=0.5*alas*tinggi;
writeln('======================================');
writeln('Maka Luas Segitiga Adalah, L : ',L);
end;
{* ALGORITMA UTAMA *}
begin
clrscr;
write('Masukkan Jumlah N Segitiga, N : '); readln(N);
for i:=1 to N do
begin
writeln('Segitiga Yang Ke-',i);
HitungLuasSegitiga;
end;
end.

PROGRAM ModularHitungRataanNilaiUjian;
{Menghitung Nilai Rata-Rata N Nilai Dengan Program Modular}
{* DEKLARASI UTAMA *}
uses crt;
var
i:integer;
N:integer;
rataan:real;
procedure HitungRataRata(N : integer; var rataan : real);
{Prosedur Memanggil Algoritma Menghitung Rata-Rata Nilai}
{Deklarasi}
var
X
:real;
Jml
:real;
{Algoritma}
begin
Jml:=0;
for i:=1 to N do
begin
write('Nilai Ujian Ke-',i,' : '); readln(X);
Jml:=Jml+X;
end;
writeln('Jumlah Nilai Adalah, Jmlh : ',Jml);
rataan:=Jml/N;
end;
{* ALGORITMA UTAMA *}
begin
clrscr;
write('Masukkan Jumlah Peserta Ujian, N : '); readln(N);
HitungRataRata(N,rataan);
writeln('Rata-Rata Nilai Peserta Adalah : ',rataan);
if rataan>=60 then
begin
writeln('Rata-Rata Nilai Cukup Baik');
end
else
begin
writeln('Rata-Rata Nilai Tidak Baik');
end;
end.

PROGRAM ProsedurModularStDeviasi;
{Program Modular Untuk Perhitungan Standar Deviasi}
{* DEKLARASI UTAMA *}
uses crt;
var
i
:real;
N
:real;
a
:integer;
X
:real;
Y
:real;
Sx
:real;
Sy
:real;
rataan :real;
Skw
:real;
varian :real;
stdev
:real;
label ulangi;
procedure HitungJumlahNilai(X : real; Var Sx: real); {PROSEDUR JUMLAH
NILAI DATA X}
{Deklarasi}
{Algoritma}
begin
write('Masukkan Nilai Xn, X',a,' : '); readln(X);
Sx:=Sx+X;
a:=a+1;
i:=i+1;
end;
procedure HitungRataanData(Sx,N : real; var rataan : real);
PERHITUNGAN NILAI RATA-RATA}
{Deklarasi}

{PROSEDUR

{Algoritma}
begin
rataan:=Sx/N;
end;
procedure HitungSelisihDataRataan(Y,rataan : real ; var Skw : real);
{PROSEDUR PERHITUNGAN NILAI SELISIH DATA RATAAN}
{Deklarasi}
{Algoritma}
begin
write('Masukkan Nilai Yn, Y',a,' : '); readln(Y);
Skw:=Skw+sqr(Y-rataan);
Sy:=Sy+Y;
a:=a+1;
i:=i+1;
end;

procedure HitungVarian(Skw,N : real ; var varian : real); {PROSEDUR

PERHITUNGAN NILAI VARIAN}
{Deklarasi}
{Algoritma}
begin
varian:=Skw/(N-1);
end;
procedure HitungStDev(varian : real ; var stdev : real); {PROSEDUR
PERHITUNGAN NILAI DEVIASI STANDAR}
{Deklarasi}
{Algoritma}
begin
stdev:=sqrt(varian);
end;
{* ALGORITMA UTAMA *}
begin;
clrscr;
write('Masukkan Jumlah Data, N : '); readln(N);
Sx:=0;
i:=0;
a:=1;
while i<>N do
HitungJumlahNilai(X,Sx);
writeln('=============================================================
=====');
writeln('Jumlah Nilai Dari Data-Data Tersebut,
Sx :
',Sx);
writeln('=============================================================
=====');
HitungRataanData(Sx,N,Rataan);
writeln('Nilai Rerata Dari Data-Data Tersebut,
Rataan :
',Rataan);
ulangi: {LABEL ULANGI}
Sx:=Sx;
Sy:=0;
Skw:=0;
rataan:=rataan;
i:=0;
a:=1;
while i<> N do
HitungSelisihDataRataan(Y,rataan,Skw);
if Sx<>Sy then
begin
writeln('ADA DATA YANG TIDAK SAMA, PERBAIKI !!!!!');
goto ulangi;
end
else

writeln('=============================================================
=====');
writeln('Nilai Jumlah Kuadrat Selisih Tiap Data Dengan Rataan, Skw:
',Skw);
HitungVarian(Skw,N,varian);
writeln('=============================================================
=====');
writeln('Nilai Varian Data Tersebut,
Varian:
',varian);
HitungStDev(varian,stdev);
writeln('=============================================================
=====');
writeln('Nilai Deviasi STandar Data Tersebut,
Std Deviasi:
',stdev);
end.

PROGRAM TabelFungsi;
{Program Membuat Tabel Fungsi}
{* DEKLARASI UTAMA *}
uses crt;
var
x:real;
function f(x:real):real;
{Deklarasi}
{Algoritma}
begin
f:=2*exp(2*ln(x))+5*x-8;
end;
{* ALGORITMA UTAMA *}
begin
clrscr;
writeln('-------------------------------------');
writeln(' x
f(x)
');
writeln('-------------------------------------');
x:=10.0;
while x<=15.0 do
begin
writeln(x:2:2,'',f(x):4:2);
x:=x+0.2;
end;
writeln('-------------------------------------');
end.b

PROGRAM IntegralNumerikTrapezoidalMultiPias;
{DEKLARASI}
uses crt;
var
a,c : real; {Batas Bawah}
b,d : real; {Batas Atas}
h
: real; {Lebar Pias}
n
: real; {Jumlah Pias}
S
: real; {Jumlah Pias Dalam}
J
: real; {Hasil Integral}
x
: real; {Nilai Pias}
function f(x:real):real;
begin
f:=1*exp(0.63*ln(x))*exp(-x);
end;
function g(c:real):real;
begin
g:=1*exp(0.63*ln(c))*exp(-c);
end;
function z(d:real):real;
begin
z:=1*exp(0.63*ln(d))*exp(-d);
end;
{ALGORITMA}
begin
clrscr;
writeln('=======================================================');
writeln('PROGRAM INTEGRAL NUMERIK, METODE TRAPEZOIDAL MULTI PIAS');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606843905');
writeln('=======================================================');
write('Masukkan Nilai Batas Bawah, a : '); readln(a);
write('Masukkan Nilai Batas Atas, b : '); readln(b);
write('Masukkan Jumlah Pias,
n : '); readln(n);
h:=abs(b-a)/n;
S:=0;
x:=a+h;
while x<b do
begin
f(x);
S:=S+f(x);
x:=x+h;
end;
c:=a;
d:=b;
J:=h*(0.5*g(c)+S+0.5*z(d));
writeln('=======================================================');
writeln('Hasil Integral Fungsi Tersebut Adalah, J : ',J:4:5);
end.

PROGRAM AkarPersamaanMetodeBisection;
{DEKLARASI}
uses crt;
var
E,xi,xu,xr,x,i
label ulangi;

: real;

function fi(xi:real):real;
begin
fi:=sin(22.5*xi*3.14/180)+exp(-xi*ln(exp(1)))-0.4;
end;
function fu(xu:real):real;
begin
fu:=sin(22.5*xu*3.14/180)+exp(-xu*ln(exp(1)))-0.4 ;
end;
function fr(xr:real):real;
begin
fr:=sin(22.5*xr*3.14/180)+exp(-xr*ln(exp(1)))-0.4 ;
end;
{ALGORITMA}
begin
clrscr;
writeln('========================================');
writeln('PROGRAM AKAR PERSAMAAN, METODE BISECTION');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606943905');
writeln('========================================');
ulangi:
write('Masukkan Nilai Xi Awal, Xi : '); readln(xi);
write('Masukkan Nilai Xu Awal, Xu : '); readln(xu);
fi(xi);
fu(xu);
if fi(xi)*fu(xu) > 0 then
begin
writeln('Ulangi Masukan Nilai Xi dan Xu Awal');
goto ulangi;
end;
x:=(xi+xu)*0.5;
xr:=(xi+xu)*0.5;
fr(xr);
i:=0;
E:=1;
writeln('-----------------------------------------------------------')
;
writeln('
iterasi
xi
xu
xr
E(%)
fr
');
writeln('-----------------------------------------------------------')
;

while E>0.0001 do
begin
writeln('
',i:2:2,'
',xi:2:4,'
',xu:2:4,'
',xr:2:5,'
',E:2:5,'
',fr(xr):2:4);
if fi(xi)*fr(xr) < 0 then
begin
xu:=xr;
xr:=(xi+xu)*0.5;
E:=(abs((xr-x)/xr))*100;
x:=xr;
end
else
begin
xi:=xr;
xr:=(xi+xu)*0.5;
E:=(abs((xr-x)/xr))*100;
x:=xr;
end;
i:=i+1;
end;
writeln('-----------------------------------------------------------')
;
writeln('Akar Persamaan Yang Dihasilkan Adalah,
Xr : ',xr:4:5);
writeln('Nilai Kesalahan Atau Error (Dalam %) Adalah, E : ',E:2:5);
writeln('Hitungan Hingga Iterasi Kei : ',i:2:0+1);
writeln('-----------------------------------------------------------')
;
end.

PROGRAM AkarPersamaanMetodeIterasi;
{DEKLARASI}
uses crt;
var
E,i,ir,a
: real;
{ALGORITMA}
begin
clrscr;
writeln('========================================');
writeln('PROGRAM AKAR PERSAMAAN, METODE ITERASI');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606943905');
writeln('========================================');
write('Masukkan Nilai i Awal (i Tidak Sama Dengan -1, i : ');
readln(i);
ir:=-2.5-(1/i);
E:=(abs((ir-i)/ir))*100;
a:=1;
writeln('-----------------------------------------');
writeln('
iterasi
i
ir
E(%)
');
writeln('-----------------------------------------');
while E>0.0001 do
begin
writeln('
',a:2:2,'
',i:2:4,'
',ir:2:4,'
',E:2:5);
ir:=-2.5-(1/i);
E:=(abs((ir-i)/ir))*100;
i:=ir;
a:=a+1;
end;
writeln('-----------------------------------------------------------')
;
writeln('Akar Persamaan Yang Dihasilkan Adalah,
ir : ',ir:4:5);
writeln('Nilai Kesalahan Atau Error (Dalam %) Adalah, E : ',E:2:5);
writeln('Hitungan Hingga Iterasi Kei : ',a:2:0+1);
writeln('-----------------------------------------------------------')
;
end.

PROGRAM AkarPersamaanMetodeFalsePosition;
{DEKLARASI}
uses crt;
var
E,ts,tub,tr,t,i,Rsub,ti,tu
label ulangi;

: real;

function pub(tub:real):real;
begin
pub:=75000*exp(-0.045*tub*ln(exp(1)))+100000;
end;
function ps(ts:real):real;
begin
ps:=300000/(1+29*exp(-0.08*ts*ln(exp(1))));
end;
function psub(tr:real):real;
begin
psub:=(300000/(1+29*exp(-0.08*tr*ln(exp(1)))))-90000*exp(0.045*tr*ln(exp(1)))-120000;
end;
function pu(tu:real):real;
begin
pu:=(300000/(1+29*exp(-0.08*tu*ln(exp(1)))))-90000*exp(0.045*tu*ln(exp(1)))-120000;
end;
function pi(ti:real):real;
begin
pi:=(300000/(1+29*exp(-0.08*ti*ln(exp(1)))))-90000*exp(0.045*ti*ln(exp(1)))-120000;
end;
{ALGORITMA}
begin
clrscr;
writeln('=============================================');
writeln('PROGRAM AKAR PERSAMAAN, METODE FALSE POSITION');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606943905');
writeln('=============================================');
ulangi:
write('Masukkan Nilai Ti Awal, Ti : '); readln(ti);
write('Masukkan Nilai Tu Awal, Tu : '); readln(tu);
pi(ti);
pu(tu);
if pi(ti)*pu(tu) > 0 then
begin
writeln('Ulangi Masukan Nilai Ti dan Tu Awal');

goto ulangi;
end;
t:=tu-((ti-tu)/(pi(ti)-pu(tu)))*pu(tu) ;
tr:=tu-((ti-tu)/(pi(ti)-pu(tu)))*pu(tu) ;
psub(tr);
i:=0;
E:=1;
writeln('------------------------------------------------------------');
writeln('
iterasi
ti
tu
tr
E(%)
psub
');
writeln('------------------------------------------------------------');
while E>0.0001 do
begin
writeln('
',i:2:2,'
',ti:2:4,'
',tu:2:4,'
',tr:2:5,'
',E:2:4,'
',psub(tr):2:4);
if pi(ti)*psub(tr) < 0 then
begin
tu:=tr;
tr:=(ti+tu)*0.5;
E:=(abs((tr-t)/tr))*100;
t:=tr;
end
else
begin
ti:=tr;
tr:=(ti+tu)*0.5;
E:=(abs((tr-t)/tr))*100;
t:=tr;
end;
i:=i+1;
end;
writeln('---------------------------------------------------------------------');
writeln('Nilai T Yang Memenuhi Adalah,
tr : ',tr:4:5);
writeln('Dengan Nilai Kesalahan,
E(%) : ',E:4:6);
writeln('Hitungan Hingga Iterasi Kei : ',i:2:0+1);
writeln('---------------------------------------------------------------------');
tub:=tr*1;
ts:=tr*1;
pub(tub);
ps(ts);
Rsub:=ps(ts)/pub(tub);
writeln('Jumlah Populasi Pada Urban Adalah,
Pu
:
',pub(tub):4:5);
writeln('Jumlah Populasi Pada SubUrban Adalah,
Ps
:
',ps(ts):4:5);
writeln('Rasio Populasi Suburban Terhadap Urban Adalah,
Rsub :
',Rsub:4:2);

writeln('---------------------------------------------------------------------');
end.

PROGRAM AkarPersamaanMetodeSecant;
{DEKLARASI}
uses crt;
var
E,ts,tub,tr,t,i,Rsub,ti,ti_1
label ulangi;

: real;

function pub(tub:real):real;
begin
pub:=75000*exp(-0.045*tub*ln(exp(1)))+100000;
end;
function ps(ts:real):real;
begin
ps:=300000/(1+29*exp(-0.08*ts*ln(exp(1))));
end;
function psub(tr:real):real;
begin
psub:=(300000/(1+29*exp(-0.08*tr*ln(exp(1)))))-90000*exp(0.045*tr*ln(exp(1)))-120000;
end;
function pu(ti_1:real):real;
begin
pu:=(300000/(1+29*exp(-0.08*ti_1*ln(exp(1)))))-90000*exp(0.045*ti_1*ln(exp(1)))-120000;
end;
function pi(ti:real):real;
begin
pi:=(300000/(1+29*exp(-0.08*ti*ln(exp(1)))))-90000*exp(0.045*ti*ln(exp(1)))-120000;
end;
{ALGORITMA}
begin
clrscr;
writeln('=============================================');
writeln('PROGRAM AKAR PERSAMAAN, METODE SECANT');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606943905');
writeln('=============================================');
write('Masukkan Nilai Ti Awal,
Ti : '); readln(ti);
write('Masukkan Nilai Ti-1 Awal, Ti-1 : '); readln(ti_1);

pi(ti);
pu(ti_1);
t:=ti-((ti_1-ti)/(pu(ti_1)-pi(ti)))*pi(ti);
tr:=ti-((ti_1-ti)/(pu(ti_1)-pi(ti)))*pi(ti);
psub(tr);
i:=0;
E:=1;
writeln('------------------------------------------------------------');
writeln('
iterasi
ti
ti-1
tr
E(%)
psub
');
writeln('------------------------------------------------------------');
while E>0.0001 do
begin
writeln('
',i:2:2,'
',ti:2:4,'
',ti_1:2:4,'
',tr:2:5,'
',E:2:4,'
',psub(tr):2:4);
ti_1:=ti;
ti:=tr;
tr:=ti-((ti_1-ti)/(pu(ti_1)-pi(ti)))*pi(ti);
E:=(abs((tr-t)/tr))*100;
t:=tr;
i:=i+1;
end;
writeln('---------------------------------------------------------------------');
writeln('Nilai T Yang Memenuhi Adalah,
tr : ',tr:4:5);
writeln('Dengan Nilai Kesalahan,
E(%) : ',E:4:6);
writeln('Hitungan Hingga Iterasi Kei : ',i:2:0+1);
writeln('---------------------------------------------------------------------');
tub:=tr*1;
ts:=tr*1;
pub(tub);
ps(ts);
Rsub:=ps(ts)/pub(tub);
writeln('Jumlah Populasi Pada Urban Adalah,
Pu
:
',pub(tub):4:5);
writeln('Jumlah Populasi Pada SubUrban Adalah,
Ps
:
',ps(ts):4:5);
writeln('Rasio Populasi Suburban Terhadap Urban Adalah,
Rsub :
',Rsub:4:2);
writeln('---------------------------------------------------------------------');
end.

PROGRAM IntegralNumerikSimpson;
{DEKLARASI}
uses crt;
var
a
: real;
b
: real;
h
: real;
n
: real;
m
: real;
S,T : real;
J
: real;
x,y : real;
i,k : real;
O
: real;

{Batas Bawah}
{Batas Atas}
{Lebar Pias}
{Jumlah Pias}
{Sub-Pias}
{Jumlah Pias Dalam Ganjil-Genap}
{Hasil Integral}
{Nilai Pias Ganjil-Genap}
{Iterasi Pias Ganjil-Genap}

function f(x:real):real;
begin
f:=1/x;
end;

{Fungsi Untuk i Ganjil}

function u(y:real):real;
begin
u:=1/y;
end;

{Fungsi Untuk k Genap}

function g(a:real):real;
begin
g:=1/a;
end;
function z(b:real):real;
begin
z:=1/b;
end;
{ALGORITMA}
begin
clrscr;
writeln('===================================================');
writeln('PROGRAM INTEGRAL NUMERIK, METODE SIMPSON MULTI PIAS');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606843905');
writeln('===================================================');
write('Masukkan Nilai Batas Bawah, a : '); readln(a);
write('Masukkan Nilai Batas Atas, b : '); readln(b);
write('Masukkan Jumlah Pias Kecil, m : '); readln(m);
n:=2*m;
h:=abs(b-a)/n;
i:=1;
S:=0;
k:=1;

T:=0;
x:=a+h*i;
y:=a+h*k*2;
while x<b do
begin
f(x);
S:=S+f(x);
i:=2;
x:=x+h*i;
end;
while y<b do
begin
u(y);
T:=T+u(y);
k:=2;
y:=y+h*k;
end;
J:=(h/3)*(g(a)+z(b)+4*S+2*T);
O:=cos(J);
writeln('===================================================');
writeln('Hasil Integral Fungsi Tersebut Adalah J : ',J:4:6);
writeln(O);
end.

PROGRAM ModelGreenAmpt;
{DEKLARASI}
uses crt;
var
psi,K,t
DTeta0,DTeta20,DTeta40,DTeta60,DTeta80,DTeta100
F,E
F0,F20,F40,F60,F80,F100

:
:
:
:

real;
real;
real;
real;

{ALGORITMA}
begin
clrscr;
writeln('=======================================');
writeln('PROGRAM MODEL INFILTRASI AIR GREEN-AMPT');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606843095');
writeln('=======================================');
write('Masukkan Nilai K,
K : '); readln(K);
write('Masukkan Nilai t,
t : '); readln(t);
write('Masukkan Nilai DTeta, DTeta0 : '); readln(DTeta0);
write('
DTeta20 : '); readln(DTeta20);
write('
DTeta40 : '); readln(DTeta40);
write('
DTeta60 : '); readln(DTeta60);

write('
DTeta80 : '); readln(DTeta80);
write('
DTeta100 : '); readln(DTeta100);
write('Masukkan Nilai Psi,
Psi : '); readln(psi);
F:=K*t;
E:=1;
while E>0.0001 do
begin
F0:=K*t+psi*DTeta0*ln(1+(F/(psi*DTeta0)));
E:=(abs((F0-F)/F0))*100;
F:=F0;
end;
F:=K*t;
E:=1;
while E>0.0001 do
begin
F20:=K*t+psi*DTeta20*ln(1+(F/(psi*DTeta20)));
E:=(abs((F20-F)/F20))*100;
F:=F20;
end;
F:=K*t;
E:=1;
while E>0.0001 do
begin
F40:=K*t+psi*DTeta40*ln(1+(F/(psi*DTeta40)));
E:=(abs((F40-F)/F40))*100;
F:=F40;
end;
F:=K*t;
E:=1;
while E>0.0001 do
begin
F60:=K*t+psi*DTeta60*ln(1+(F/(psi*DTeta60)));
E:=(abs((F60-F)/F60))*100;
F:=F60;
end;
F:=K*t;
E:=1;
while E>0.0001 do
begin
F80:=K*t+psi*DTeta80*ln(1+(F/(psi*DTeta80)));
E:=(abs((F80-F)/F80))*100;
F:=F80;
end;
F:=K*t;
E:=1;
while E>0.0001 do
begin

F100:=K*t+psi*DTeta100*ln(1+(F/(psi*DTeta100)));
E:=(abs((F100-F)/F100))*100;
F:=F100;
end;
writeln('Berikut Adalah Hasil-Hasil Dari Nilai F : ');
writeln('------------------------------------------');
writeln('
DTeta
F
');
writeln('------------------------------------------');
writeln('
',DTeta0:4:4,'
',F0:4:4);
writeln('
',DTeta20:4:4,'
',F20:4:4);
writeln('
',DTeta40:4:4,'
',F40:4:4);
writeln('
',DTeta60:4:4,'
',F60:4:4);
writeln('
',DTeta80:4:4,'
',F80:4:4);
writeln('
',DTeta100:4:4,'
',F100:4:4);
end.

PROGRAM ModelPondingGreenAmpt;
{DEKLARASI}
uses crt;
var
psi,K,t,tp
DTeta,i
Fp,E,F
Fi
fii

:
:
:
:
:

real;
real;
real;
real;
real;

{ALGORITMA}
begin
clrscr;
writeln('=======================================');
writeln('PROGRAM MODEL INFILTRASI AIR GREEN-AMPT');
writeln('OLEH : NGAKAN PUTU PURNADITYA');
writeln('NPM : 1606843095');
writeln('=======================================');
write('Masukkan Nilai K,
K : '); readln(K);
write('Masukkan Nilai t,
t : '); readln(t);
write('Masukkan Nilai tp,
tp : '); readln(tp);
write('Masukkan Nilai i,
i : '); readln(i);
write('Masukkan Nilai DTeta, DTeta : '); readln(DTeta);
write('Masukkan Nilai Psi,
Psi : '); readln(psi);
Fp:=i*tp;
F:=K*t;
E:=1;
while E>0.0001 do
begin
Fi:=K*(t-tp)+Fp+psi*DTeta*ln((psi*DTeta+F)/(psi*DTeta+Fp));
E:=(abs((Fi-F)/Fi))*100;
F:=Fi;

end;
fii:=K*((psi*DTeta/Fi)+1);
writeln('Berikut Adalah Hasil-Hasil Dari Nilai F dan f : ');
writeln('------------------------------------------');
writeln('
F(cm)
f(cm/h)
');
writeln('------------------------------------------');
writeln('
',Fi:4:4,'
',fii:4:4);
end.