1.

Buatlah algoritma untuk mencari nilai terbesar dari data yang sudah tersimpan pada
elemen array, dimana nilai yang tersimpan pada elemen array tersebut di baca dari
inputan eksternal (keyboard). Konversikan algoritma di atas ke dalam Bahasa Pascal
2. Buatlah Metode pencarian data di dalam array dalam Bahasa Pascal dengan ketentuan
dibawah ini:
• pencarian beruntun (sequantial search)
A 60 12 76 23 11 42 18 42
1 2 3 4 5 6 7 8

Misalkan nilai yang dicari adalah 42

3. diketahui matriks 3 x4 untuk array dua dimensi, Buatlah algoritma untuk menghitung
nilai total dari matriks tersebut sedang nilai didapat dengan melakukan inisialisasi nilai
(nilai konstan) pada array dua dimensi tersebut dengan tipe data integer. Dan
cetak/tampilkanlah nilai total dari matriks di atas.
Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.

4. Diketahui Larik dengan n=5 dibawah ini yg belum terurut

A 29 27 10 8 76
1 2 3 4 5

Buatlah pengurutan dengan metode Bubble Sort , Selection Sort

5. Perhatikan program di bawah ini.

• Apa output program di bawah ini dan jelaskan !
Program uts;
Uses crt;
Procedure Hitung(A,B,C: Integer);
begin
C:=A+B;
writeln;
writeln(' A=',A,' B=',B,' C=',C);
end;

var
X,Y,Z : integer;

begin
X:=6; Y:=9; Z:=0;
hitung(X,Y,Z);
writeln(' X=',X,' Y=',Y, ' Z=',Z);
 end.
Jawab
1. Berikut adalah algoritma dalam Bahasa Pascal untuk mencari nilai terbesar dari data
yang tersimpan dalam elemen array:

pascal
Copy code
program MencariNilaiTerbesar;
const
MAX_SIZE = 100;
var
data: array[1..MAX_SIZE] of integer;
n, i, nilaiTerbesar: integer;
begin
// Membaca jumlah data dari input
write('Masukkan jumlah data: ');
readln(n);

// Membaca data dari input

writeln('Masukkan data:');
for i := 1 to n do
begin
write('Data ke-', i, ': ');
readln(data[i]);
end;

// Menginisialisasi nilai terbesar dengan elemen pertama array

nilaiTerbesar := data[1];

// Mencari nilai terbesar dari data

for i := 2 to n do
begin
if data[i] > nilaiTerbesar then
nilaiTerbesar := data[i];
end;

// Menampilkan nilai terbesar

writeln('Nilai terbesar: ', nilaiTerbesar);

readln;
end.
“Dalam algoritma di atas, pengguna diminta untuk memasukkan jumlah data dan nilai-
nilai data melalui input. Kemudian, algoritma akan mencari nilai terbesar dari data yang
dimasukkan dan menampilkannya sebagai output.“
2. Pilih diantara 2
a. Berikut adalah implementasi metode pencarian data secara beruntun (sequential
search) dalam Bahasa Pascal untuk mencari nilai 42 dalam array:

```pascal
program SequentialSearch;
const
MAX_SIZE = 100;
var
data: array[1..MAX_SIZE] of integer;
n, i, nilaiCari: integer;
found: boolean;
begin
// Mengisi array dengan data
data[1] := 60;
data[2] := 12;
data[3] := 76;
data[4] := 23;
data[5] := 11;
data[6] := 42;
data[7] := 18;
data[8] := 42;

// Menampilkan data dalam array

writeln('Data dalam array:');
for i := 1 to 8 do
write(data[i], ' ');
writeln;

// Nilai yang dicari

nilaiCari := 42;

// Mencari nilai dalam array secara beruntun

found := false;
for i := 1 to 8 do
begin
if data[i] = nilaiCari then
begin
writeln('Nilai ', nilaiCari, ' ditemukan pada indeks ke-', i);
found := true;
end;
end;
 if not found then
writeln('Nilai ', nilaiCari, ' tidak ditemukan dalam array.');

readln;
end.
```

Dalam contoh di atas, array `data` telah diisi dengan nilai-nilai yang diberikan.
Kemudian, dilakukan pencarian nilai 42 dalam array menggunakan metode pencarian
beruntun (sequential search). Jika nilai yang dicari ditemukan, program akan
menampilkan indeks tempat nilai tersebut ditemukan. Jika nilai tidak ditemukan,
program akan memberikan pesan bahwa nilai tidak ada dalam array.

b. Berikut adalah contoh metode pencarian beruntun (sequential search) dalam

Bahasa Pascal untuk mencari data dalam array:

```pascal
program PencarianSequential;
const
MAX_SIZE = 8;
var
data: array[1..MAX_SIZE] of integer;
n, i, nilaiCari: integer;
ditemukan: boolean;
begin
// Mengisi array dengan data
data[1] := 60;
data[2] := 12;
data[3] := 76;
data[4] := 23;
data[5] := 11;
data[6] := 42;
data[7] := 18;
data[8] := 42;

// Mencetak data dalam array

writeln('Data dalam array:');
for i := 1 to MAX_SIZE do
write(data[i], ' ');
writeln;

// Membaca nilai yang dicari dari input

write('Masukkan nilai yang dicari: ');
readln(nilaiCari);
 // Melakukan pencarian sequential
ditemukan := false;
i := 1;
while (i <= MAX_SIZE) and (not ditemukan) do
begin
if data[i] = nilaiCari then
ditemukan := true
else
i := i + 1;
end;

// Menampilkan hasil pencarian

if ditemukan then
writeln('Nilai ', nilaiCari, ' ditemukan pada posisi ', i)
else
writeln('Nilai ', nilaiCari, ' tidak ditemukan dalam array');

readln;
end.
```

Dalam contoh di atas, kita menggunakan array `data` dengan ukuran 8 dan mengisi
elemen array dengan data yang diberikan. Kemudian, pengguna diminta untuk
memasukkan nilai yang dicari. Program akan melakukan pencarian beruntun (sequential
search) dengan membandingkan setiap elemen array dengan nilai yang dicari. Jika nilai
ditemukan, program akan menampilkan posisi elemen tersebut dalam array. Jika tidak
ditemukan, program akan memberikan pesan bahwa nilai tidak ada dalam array.

3. Berikut adalah algoritma dalam Bahasa Pascal untuk menghitung nilai total dari matriks
3x4 yang diinisialisasi dengan nilai konstan:

```pascal
program HitungTotalMatriks;
const
ROW = 3;
COL = 4;
var
matriks: array[1..ROW, 1..COL] of integer;
i, j, total: integer;
begin
// Inisialisasi matriks dengan nilai konstan
matriks[1, 1] := 5;
 matriks[1, 2] := 2;
matriks[1, 3] := 9;
matriks[1, 4] := 3;

matriks[2, 1] := 7;
matriks[2, 2] := 1;
matriks[2, 3] := 6;
matriks[2, 4] := 4;

matriks[3, 1] := 8;
matriks[3, 2] := 3;
matriks[3, 3] := 2;
matriks[3, 4] := 1;

// Menghitung nilai total dari matriks

total := 0;
for i := 1 to ROW do
begin
for j := 1 to COL do
begin
total := total + matriks[i, j];
end;
end;

// Menampilkan nilai total dari matriks

writeln('Total nilai matriks: ', total);

readln;
end.
```

Dalam algoritma di atas, kita menggunakan array dua dimensi `matriks` dengan ukuran
3x4. Setiap elemen matriks diinisialisasi dengan nilai konstan menggunakan indeks baris
dan kolom. Kemudian, dilakukan perulangan untuk menjumlahkan semua nilai dalam
matriks dan menyimpan hasilnya dalam variabel `total`. Terakhir, nilai total dari matriks
ditampilkan sebagai output.

4. Berikut adalah implementasi pengurutan menggunakan metode Bubble Sort dan

Selection Sort dalam Bahasa Pascal untuk larik yang diberikan:

1. Bubble Sort:
```pascal
program BubbleSort;
const
 n = 5;
var
arr: array[1..n] of integer;
i, j, temp: integer;
begin
// Mengisi larik dengan elemen yang belum terurut
arr[1] := 29;
arr[2] := 27;
arr[3] := 10;
arr[4] := 8;
arr[5] := 76;

// Melakukan pengurutan dengan Bubble Sort

for i := 1 to n - 1 do
begin
for j := 1 to n - i do
begin
if arr[j] > arr[j + 1] then
begin
temp := arr[j];
arr[j] := arr[j + 1];
arr[j + 1] := temp;
end;
end;
end;

// Menampilkan larik setelah diurutkan

writeln('Larik setelah diurutkan dengan Bubble Sort:');
for i := 1 to n do
write(arr[i], ' ');
writeln;

readln;
end.
```

2. Selection Sort:
```pascal
program SelectionSort;
const
n = 5;
var
arr: array[1..n] of integer;
i, j, minIndex, temp: integer;
 begin
// Mengisi larik dengan elemen yang belum terurut
arr[1] := 29;
arr[2] := 27;
arr[3] := 10;
arr[4] := 8;
arr[5] := 76;

// Melakukan pengurutan dengan Selection Sort

for i := 1 to n - 1 do
begin
minIndex := i;
for j := i + 1 to n do
begin
if arr[j] < arr[minIndex] then
minIndex := j;
end;

if minIndex <> i then

begin
temp := arr[i];
arr[i] := arr[minIndex];
arr[minIndex] := temp;
end;
end;

// Menampilkan larik setelah diurutkan

writeln('Larik setelah diurutkan dengan Selection Sort:');
for i := 1 to n do
write(arr[i], ' ');
writeln;

readln;
end.
```

5. Dalam kedua implementasi di atas, kita menggunakan larik dengan ukuran n=5 yang diisi
dengan elemen yang belum terurut. Kemudian, dilakukan pengurutan menggunakan
Bubble Sort dan Selection Sort. Setelah pengurutan selesai, larik yang diurutkan
ditampilkan sebagai output.

Output program di bawah ini adalah:

```
A=6 B=9 C=15
X=6 Y=9 Z=0
```

Penjelasan:
- Pada awal program, variabel X diinisialisasi dengan nilai 6, variabel Y diinisialisasi
dengan nilai 9, dan variabel Z diinisialisasi dengan nilai 0.
- Program memanggil prosedur `Hitung` dengan parameter X, Y, dan Z.
- Pada prosedur `Hitung`, parameter C diubah nilainya dengan menjumlahkan nilai A dan
B.
- Setelah itu, program kembali ke bagian utama dan mencetak hasil dari prosedur
`Hitung`, yaitu A=6, B=9, dan C=15.
- Kemudian, program mencetak nilai X, Y, dan Z dari bagian utama, yaitu X=6, Y=9, dan
Z=0.