Algoritma merupakan runtunan (sequance) satau atau lebih instruksi, yang berarti bahwa :
- Tiap instruksi dikerjakan satu per satu
- Tiap instruksi dilaksanakan tepat sekali; tidak ada instruksi yang diulang
- Urutan instruksi yang dilaksanakan pemroses sama dengan urutan instruksi sebagaimana yang bertulis didalam teks algoritmanya
- Akhir dari instruksi terakhir merupakan akhir algoritma
Contoh-contoh Runtunan :
1). Mempertukarkan nilai dari 2 peubah. Diketahui A = 8, B = 5. Maka hasil setelah pertukaran A = 5 dan B = 8
ALGORITMIK
Program pertukaran
DEKLARASI
A, B, temp : integer
ALGORITMA
read (A, B)
{Proses pertukaran}
temp <– A
A <– B
B <– Temp
write (A, B)
Translasi ke PASCAL
(*DEKLARASI*)
var
A, B, temp : integer;
(*ALGORITMA*)
begin
write(‘A = ’); readln(A);
write(‘B = ’); readln(B);
(*Proses Pertukaran*)
temp := A;
A := B;
B := temp;
writeln(‘A = ’, A);
writeln(‘B = ’, B);
end
TRANSLASI ke C
/* Program Pertukaran*/
#include
main()
{
/*DEKLARASI*/
int A, B, temp;
/*ALGORITMA*/
printf(“A = ”); scanf(“%d”, &A);
printf(“B = ”); scanf(“%d”, &B);
/*Proses Pertukaran*/
temp = A;
A = B;
B = temp;
printf(“A = %d \n”, A);
printf(“A = %d \n”, B);
}
2). Mempertukarkan nilai A dan B, tanpa menggunakan variabel pembantu
Program Tukar
DEKLARASI
A, B : integer
ALGORITMA
read(A, B);
write(“Sebelum pertukaran A, B adalah ”, A, B);
A <– A + B
B <– A – B
A <– A – B
write(“Sesudah p’tukaran A,B adalah ”, A,B);
3). Tulis algoritma dan translasi ke C dan Pascal untuk membaca panjang dan lebar persegi panjang, dan hitung luasnya, kemudian tampilkan luas ke layar
ALGORITMIK
DEKLARASI
Panjang : real;
lebar : real;
luas : real;
ALGORITMA
read(panjang, lebar)
Luas <– Panjang * lebar
write(luas)
PASCAL
Program hitungLuas;
var
panjang : real;
lebar : real;
luas : real;
begin
writeln(‘Masukkan panjang : ’); readln(panjang);
writeln(‘Masukkan lebar : ’); readln(lebar);
luas := panjang * lebar;
write(‘Luas persegi empat : ’, luas);
C :
/*Program luas persegi panjang*/
#include
main()
{
float panjang;
foat lebar;
float luas;
printf(“Masukkan panjang : \n”); scanf(“%f”, panjang);
printf(“Masukkan luas : \n”); scanf(“%f”, luas);
luas = panjang * lebar;
printf(“luas = %f \n“, luas);
}
4). Buat algoritma untuk menghitung komisi yang diterima salesman berdasarkan nilai penjualan yang dicapainya dan sales tersebut mendapat komisi 5% dari penjualannya.
ALGORITMIK
DEKLARASI
NamaSalesman : string
nilai_penjualan : real
komisi : real
ALGORITMA
read(NamaSalesman, nilai_penjualan)
komisi <– 0.05 * nilai_penjualan
write(komisi)
5). Tuliskan algoritma yang membaca nama karyawan dan gaji pokok bulanannya dan menghitung gaji bersihnya dengan rumus “ GajiBersih = gajipokok + tunjangan – pajak “ Untuk tunjungan 20% dari gaji pokok, sedangkan pajak 15%. Nama dan gaji bersih karyawan dicetak dioutput.
ALGORITMIK
Program GajiBersihKaryawan
DEKLARASI
const persen_tunjangan = 0.2
const persen_pajak = 0.15
NamaKaryawan = string
GajiPokok, tunjangan, pajak, Gaji_Bersih = real
ALGORITMA
read(NamaKaryawan, GajiPokok)
tunjangan <– persen_tunjangan * GajiPokok
pajak <– persenpajak * (GajiPokok + Tunjangan)
GajiBersih <– GajiPokok + tunjangan – pajak
write(NamaKaryawan, GajiBersih)
6). Tuliskan Algoritma yang membaca 2 buah titik P1=(x1, y1) dan P2=(x2, y2) menghitung titik dari tengah dari p1 dan p2. Variabel titik tengah adalah p3 dengan menggunakan rumus :
x3 = x1 + x2 dan y3 = y1 + y2
2 2
ALGORITMIK
Program Titik_Tengah
DEKLARASI
type Titik : record < x : real,
y : real
>
P1, P2, P3 : Titik
ALGORITMA
read(P1.x, P1. y)
read(P2.x, P2.y)
P3.x <– (P1.x + P2.y) / 2
P3.y <– (P1.y + P2.y) / 2
write(P3.x, P3.y)
7). Tulislah algoritma yang membaca waktu tempuh seorang pelari maraton lalu mengkonversi yaitu waktu tempuh tersebut kedalam detik.
ALGORITMIK
DEKLARASI
type Jam : record < hh : integer
mm : integer
ss : integer
>
J : Jam
TotalDetik : integer
ALGORITMA
read(J.hh, J.mm, J.ss)
TotalDetik <– (J.hh * 3600) + (J.mm * 60) + J.ss
write(TotalDetik);
PASCAL:
(*DEKLARASI*)
type Jam = record
hh : longint;
mm : longint;
ss : longint;
end;
var
J : Jam;
TotalDetik : longint;
(*ALGORITMA*)
begin
write(‘Jam : ’); readln(J.hh);
write(‘Menit : ’); readln(J.mm);
write(‘Detik: ’); readln(J.ss);
TotalDetik := (J.hh * 3600) + (J.mm * 60) + J.ss;
writeln(‘TotalDetik = ’, TotalDetik);
end.
C:
/*Program konversi_ke_detik*/
#include
main()
{
/*DEKLARASI*/
typedef struct { longint hh;
longint mm;
longint ss;
}Jam;
Jam J;
longint TotalDetik;
/* ALGORITMA */
printf(“Jam : ”); scanf(“%d”, &J.hh);
printf(“Menit : ”); scanf(“%d”, &J.mm);
printf(“Detik : ”); scanf(“%d”, &J.ss);
TotalDetik = (J.hh * 3600) + (J.mm * 60) + J.ss;
printf(“TotalDetik = %d”, TotalDetik);
}
8). Tulislah algoritma yang membaca lama sebuah percakapan telepon dalam satuan detik, lalu mengkonversi kedalam jam, menit dan detik.
ALGORITMIK
Program Konvers_detik_ke_JamMenitDetik
DEKLARASI
type Jam : record < hh : integer
mm : integer
ss : integer
>
J : Jam
TotalDetik : integer
Sisa : integer
ALGORITMA
read(TotalDetik)
J.hh <– TotalDetik div 3600 {Mendapatkan jam}
sisa <– TotalDetik mod 3600
J.mm <– sisa div 60
J.ss <– sisa mod 60
write (J.hh, J.mm, J.ss)
9). Tulislah algoritma yang membaca dua buah jam, yang pertama J1(hh:mm:ss) dan waktu kedua J2(hh:mm:ss) dengan syarat J2 > J1, lalu menghitung selisih jam (durasi) dari J1 sampai J2
Program SelisihWaktu
DEKLARASI
type Jam : record < hh : integer
mm : integer
ss : integer
>
J1, J2, J3 : Jam
TotalDetik1, TotalDetik2, SelisihDetik : integer
sisa : integer
ALGORITMA
read(J1.hh, J1.mm, J1.ss)
read(J2.hh, J2.mm, J2.ss)
TotalDetik1 <– (J1.hh * 3600) + (J1.mm * 60) + J1.ss
TotaDetik2 <– (J2.hh * 3600) + (J2.mm * 60) + J2.ss
SelisihDetik <– TotalDetik2 – TotalDetik1
{Mengkonversi Detik ke JamMenitDetik}
J3.hh <– SelisihDetik div 3600
Sisa <– SelisihDetik mod 3600
J3.mm <– Sisa div 60
J3.ss <– Sisa mod 60
write(J3.hh, J3.mm, J3.ss)
10). Tulislah Algoritma untuk menghitung lama percakapan kedalam JAm-Menit-Detik dan biaya yang harus dibayar penelpon. Untuk menyederhanakan masalah, andaikan wartel itu tutup tepat pukul 00:00 malam
Program Wartel
DEKLARASI
const BiayaPerPulsa = 150
const LamaPulsa = 5
type Jam : record < hh : integer,
mm : integer,
ss : integer >
J1, J2, J3 : Jam
sisa, durasi : integer
pulsa, biaya : real
ALGORITMA
read(J1.hh, J1.mm, J1.ss)
read(J2.hh, J2,mm, J2,ss)
TotalDetik1 <– (J1.hh * 3600) + (J1.mm * 60) + J1.ss
TotalDetik2 <– (J2.hh * 3600) + (J2.mm * 60) + J2.ss
durasi <– TotalDetik2 – TotalDetik1
Pulsa <–durasi/LamaPulsa
biaya <– pulsa * BiayaPerPulsa
J3.hh <– durasi div 3600
sisa <– durasi mod 3600
J3.mm <– sisa div 60
J3.ss <– sisa mod 60
write(J3.hh, J3.mm, J3.ss)
Membaca/Menulis dari/ke Arsip
Data yang dimasukkan (input) ke dalam program dibaca dari keyboard dan begitu juga data yang dikeluarkan dicetak ke layer ataupun output peripheral. Tetapi, adakalanya data masukkan dibaca dari arsip (file) atau keluaran ditulis ke arsip (file). Pembacaan data dari arsip bergantung pada format data didalam arsip misalnya arsip text. Antara satu data dengan data yang lain dipisahkan oleh separator spasi, kemudian tipe data tersebut harus sama dengan tipe peubah didalam program. Selama data dibaca atau ditulis, arsip tersebut terlebih dahulu dibuka, begitu juga sebaliknya.
Contoh membuka arsip untuk dibaca dengan memasukkan data arsip yang bernama data.txt.
PASCAL :
var
Fin : text; {Nama peubah arsip}
begin
assign(Fin, ‘data.txt);
reset(Fin);
… {Instruksi Selanjutnya}
end
C :
main()
{
FILE *Fin /* Nama Peubah Arsip*/
Fin = fopen(“data.txt”. “r”); /*r adalah argument mode, yang berarti file dibuka untuk dibaca*/
…. /*Instruksi Selanjutnya*/
}
Ket : Beberapa kompilator bahasa C membedakan antara arsip teks dan arsip biner. Untuk biner ditambahkan “b” pada argument menjadi “rb” atau “r+b”, sdangkan untuk teks ditambahkan “t” misalnya “rt” atau “r + t”.
Contoh membuka arsip untuk ditulis dengan keluaran arsip bernama hasil.txt
PASCAL :
var
Fout : text;
begin
assign(Fout, ‘hasil.txt’);
rewrite(FOut);
….. {Instruksi selanjutnya}
End
C:
main()
{
FILE *Fout /* Nama peubah arsip */
Fout = fopen(“hasil.txt”, “w”);
….. Instruksi Selanjutnya
}
Menutup arsip yang sudah selesai dibaca dengan nama arsip data.txt
PASCAL :
Close(Fin);
C :
flose(Fin);
Pernyataan untuk membaca data dari arsip (contoh data.txt yang telah disimpan) maka untuk membaca kemudian menyimpan hasil pembacaan di dalam peubah x, adalah :
PASCAL :
read(Fin);
C:
fread(x, sizeof(x), 1, Fin); /* Membaca nilai untuk x dengan ukuran (sizeof) sebesar ukuran tipe x sebanyak 1 elemen dari arsip Fin*/
Pernyataan untuk menulis data ke arsip
PASCAL :
write(Fout, x);
C :
fwrite(x, sizeof(x), 1, Fout);
Contoh untuk pembaca/penulisan data dari/ke arsip. Misalkan data yang didapat dari data.txt dengan isi : 15 20 kemudian keluaran program yaitu luas ditulis ke arsip hasil.txt;
PASCAL :
Program Luas_Empat_persegi_panjang;
(*DEKLARASI*)
var
panjang : real;
lebar : real;
luas : real;
Fin, Fout : text;
(*ALGORITMA)
begin
{Buka arsip masukkan}
assign(Fin, ‘data.txt’);
reset(Fin);
{buka arsip keluaran}
assign(Fout, ‘hasil.txt’);
rewrite(Fout);
{baca panjang dan lebar dari arsip Fin}
read(Fin, panjang, lebar);
luas := panjang * lebar;
{Tulis luas empat persegi ke arsip Fout}
writeln(Fout, ‘Luas segiempat = ’, luas)
{Tutup arsip}
close(Fin);
close(Fout);
end.
C :
/* Program luas segiempat*/
#include
main()
{
/*DEKLARASI*/
float panjang;
float lebar;
float luas;
FILE *Fin, *Fout
/* ALGORITMA */
/* buka arsip masukan */
Fin = fopen(“data.txt”, “r”);
/* buka arsip keluaran*/
Fout = fopen(“hasil.txt”, “w”);
/*buka panjang dan lebar dari arsip Fin*/
fscanf(Fin, “%f %f”, &panjang, &lebar);
luas = panjang*lebar;
/* tulis luas empat persegi ke arsip fout */
fprintf(Fout, “Luas segiempat = %f \n”, luas);
/* tutup arsip */
fclose(Fin);
fclose(Fout);
}
Contoh pembacaan data masukkan dari arsip dengan memodifikasi dari contoh diatas, sehingga nama arsip masukkan dan keluaran merupakan masukkan dari pengguna program.
PASCAL :
program Luas_Empat_Persegi_Panjang;
(* DEKLARASI *)
var
panjang : real;
lebar : real;
luas : real;
Fin, Fout : text;
NamaArsip1, NamaArsip2 : string[12];
(* ALGORITMA *)
begin
write(‘Nama arsip masukan : ’); readln(NamaArsip1);
write(‘Nama arsip masukan : ’); readln(NamaArsip2);
{Buka arsip masukkan}
assign(Fin, NamaArsip1);
reset(Fin);
{buka arsip keluaran}
assign(Fout, NamaArsip2);
rewrite(Fout);
{baca panjang dan lebar dari arsip Fin}
read(Fin, panjang, lebar);
luas := panjang * lebar;
{Tulis luas empat persegi ke arsip Fout}
writeln(Fout, ‘Luas segiempat = ’, luas)
{Tutup arsip}
close(Fin);
close(Fout);
end.
C :
/* Program luas segiempat*/
#include
main()
{
/*DEKLARASI*/
float panjang;
float lebar;
float luas;
char NamaArsip1[12], NamaArsip2[12];
FILE *Fin, *Fout;
/* ALGORITMA */
printf(“Nama arsip masukan : ”); scanf(“%s”, NamaArsip1);
printf(“Nama arsip keluaran : ”); scanf(“%s”, NamaArsip2);
/* buka arsip masukan */
Fin = fopen(NamaArsip1, “r”);
/* buka arsip keluaran */
Fout = fopen(NamaArsip2, “w”);
/*buka panjang dan lebar dari arsip Fin*/
fscanf(Fin, “%f %f”, &panjang, &lebar);
luas = panjang*lebar;
/* tulis luas empat persegi ke arsip fout */
fprintf(Fout, “Luas segiempat = %f \n”, luas);
/* tutup arsip */
fclose(Fin);
fclose(Fout);
}
karya buatan sendiri
algoritma dan pemrograman
teknik informatika
Runtunan (Sequance) Dalam Algoritma Pemograman
Subscribe to:
Post Comments (Atom)
EmoticonEmoticon