modul iii larik dan matriks - dhamidin’s weblog type larikint : array [1..maks] of integer a :...

III-1

MODUL III

LARIK DAN MATRIKS

3.1 Tujuan

Tujuan modul III ini, adalah:

• Praktikan bisa membuat program sederhana berdasarkan algoritma dengan

memakai larik

• Praktikan bisa membuat program matriks sederhana berdasarkan algoritma

dengan memakai larik

• Praktikan dapat membiasakan diri untuk membuat program secara terstruktur.

• Praktikan memahami algoritma larik dan matriks

3.2 Teori

3.2.1 Larik

Larik atau array adalah struktur data yang menyimpan sekumpulan elemen

yang bertipe sama. Setiap elemen diakses langsung melalui indeksnya. Contoh:

larik A dengan 8 elemen yang setiap elemennya berisi tinggi badan siswa di

sebuah sekolah.

A

1 158

2 159

3 342

4 324

5 123

6 645

7 452

8 323

3.2.1.1 Mendefinisikan Larik di Dalam Deklarasi

Larik adalah struktur data statik, artinya elemen larik harus sudah

diketahui sebelum program dieksekusi. Jumlah elemen larik tidak dapat diubah,

ditambah atau dikurangi selama pelaksanaan program.

III-2

Mendefinisikan larik di dalam bagian deklarasi berarti:

1. Mendefinisikan banyaknya elemen larik, berarti memesan sejumlah tempat

di memori sebanyak elemen larik yang bersangkutan.

2. Mendefinisikan tipe elemen larik, dapat berupa tipe sederhana

Contoh mendefinisikan larik di dalam bagian deklarasi

a. Sebagai peubah

Deklarasi

L : array[1..50] of integer

Namamhs : array[‘a’..’d’] of string

NilaiUjian : array[0..50] of real

b. Sebagai tipe baru

Deklarasi

Type larikint : array[1..100] of integer {nama tipe baru}

P : larikint

c. Mendefinisikan ukuran maksimum elemen larik sebagai sebuah konstanta

Deklarasi

Const nmaks = 1000 {jumlah elemen larik sebagai konstanta}

Type larikint : array[1..nmaks] of integer

P : larikint

3.2.1.2 Pemrosesan Larik

Elemen larik tersusun secara beruntun. Karena itu, elemennya diproses

secara beruntun melalui indeksnya yang terurut. Pemrosesan beruntun pada larik

adalah pemrosesan mulai dari elemen pertama larik (yaitu elemen dengan indeks

terkecil, berturut-turut pada elemen berikutnya, sampai elemen terakhir dicapai,

yaitu elemen dengan indeks terbesar).

Skema umum pemrosesan larik

Algoritma skema_umum_pemrosesan_larik

{memproses setiap elemen larik secara beruntun, mulai dari indeks terkecil

sampai indeks terbesar}

Deklarasi

Const Maks = 100 {banyak elemen larik}

III-3

Type Larikint : array[1..Maks] of integer

A : Larikint

K : integer {indeks larik}

Deskripsi

Inisialisasi nilai

K ←1 {mulai dari elemen pertama}

While K ≤ NMaks do

Pemrosesan terhadap A[K]

K ← K + 1

Endwhile

{K > NMaks}

Terminasi

3.2.1.3 Menginisialisasi Larik

Menginisialisasi larik adalah memberikan harga awal untuk seluruh

elemen larik. Inisialisasi kadang-kadang diperlukan, misalnya “mengosongkan”

elemen larik sebelum dipakai untuk proses tertentu. “Mengosongkan” larik bertipe

numeric dapat berupa pengisian elemen larik dengan nol, sedangkan pada larik

karakter, “mengosongkan” larik berarti mengisi elemen larik dengan spasi atau

karakter kosong. Nol atau spasi bukanlah satu-satunya nilai yang dipakai untuk

kinisialisasi. Permrogram dapat membiarkan nilai lain bergantung pada

kebutuhan.

Contoh Algoritma 1:

Procedure Inisdengan0(output A : Larikint, input N: integer)

{menginisialisasi setiap elemen larik A[1..n] dengan nol}

{k.awal: n adalah jumlah elemen efektif larik, nilainya sudah terdefinisi}

{k.akhir: seluruh elemen larik A bernilai nol}

Deklarasi

K: integer {pencatat indeks larik}

Deskripsi

For K←1 to N do

A[K] ← 0

Endfor

Algoritma Pemroseslarik

{pemrogram utama untuk mengisi elemen larik dengan nilai 0}

III-4

Deklarasi

Const NMaks = 100 {banyaknya elemen larik}

Type Larikint : array[1..NMaks] of integer

A : Larikint


N : integer {jumlah elemen efektif larik}

Procedure Inisdengan0(output A:Larikint, input N: integer)

{menginisialisasi setiap elemen larik A[1..N] dengan nol}

Deskripsi

Read(N)

Inisdengan0(A, N)

Larik digunakan bila kita memerlukan penyimpanan sementara data yang bertipe

sama di dalam memori, untuk selanjutnya data tersebut dimanipulasi, dihitung

atau diterapkan oleh proses lainnya.

Contoh Algoritma 2:

Algoritma BacaTampilLarik

{program utama untuk membaca dan menampilkan hasil larik}

Deklarasi

A[10], N, K : integer

Deskripsi

Read(N)

K ← 0

repeat

K ← K+1

read(A[K])

until K=N

K=0

repeat

K ← K+1

write(‘A[‘,K,’] =’,’A[K])

until K=N

III-5

Program Algoritma 2

//tulisbacalarik

#include "stdio.h"

main(){

int A[10], N, K;

printf("Jumlah : ");scanf("%d", &N);

K=0;

do {

K++;

printf("A[%d]",K);scanf("%d", &A[K]);

} while (K<N);

K=0;

do {

K++;

printf("A[%d] = %d", K, A[K]);

} while (K< N);

}

Contoh Algoritma 3:

Procedure HitungRata2(input A : Larikint, input N : integer, output U : real)

{menghitung nilai rata-rata elemen larik A [1..N]}

{k.awal: elemen larik A[1..N] sudah terdefinisi nilainya}

{k.akhir: U berisi nilai rata-rata seluruh elemen}

Deklarasi


Jumlah : real {jumlah total seluruh nilai}

Deskripsi

Jumlah←0

K←0

repeat{

K←K+1

Jumlah ← Jumlah+A[K]

}until (K=N)

U←Jumlah/N

}

Program Hitungratarata

{program utama menghitung rata-rata seluruh elemen larik}

III-6

Deklarasi



Procedure HitungRata2(input A : Larikint, input N : integer, output U : real)

{menghitung nilai rata-rata elemen larik A[1..N]}

A : Larikint

N, K : integer

U : real

Deskripsi

read(N)

K←0

repeat

K←K+1

read(A[K])

until (K=N)

HitungRata2(A, N, U)

write(U)

Program Algoritma 3:

//tulisbacalarik

#include "stdio.h"

#define NMaks 100

typedef int Larikint[NMaks+1];

void HitungRata2(Larikint A, int N, float *U);

main(){

Larikint A;

int N, K;

float U;

printf("Jumlah : ");scanf("%d",&N);

K=0;

do {

K++;

printf("A[%d]= ",K);scanf("%d",&A[K]);

} while (K<N);

HitungRata2(A, N,&U);

printf("%4.2f",U);}

III-7

void HitungRata2(Larikint A, int N, float *U){

int K;

float Jumlah;

Jumlah=0;

K=0;

do{

K++;

Jumlah = Jumlah+A[K];

}while (K<N);

*U=Jumlah/N;

}

Contoh Algoritma 4:

Function Maksimum(input A : Larikint, input N : integer)→integer

{mengembalikan elemen terbesar di dalam larik A[1..N]}

Deklarasi

K : integer {pencatat indeks larik}

Deskripsi

Maks ← -9999 {nilai maksimum sementara}

For K←1 to N do

If A[K] > Maks then

Maks←A[K]

Endif

Endfor

Return maks

Program mencarinilaimaksimum

{program utama mencari nilai maksimum}

Deskripsi



Function Maksimum(input A : Larikint, input N : integer)→integer

{mengembalikan elemen terbesar di dalam larik A[1..N]}

A : Larikint

N ,K : integer

Maks : integer

Deskripsi

read(N)

III-8

K←0

repeat {

K←K+1

read(A[K])

} until (K=N)

write(Maks(A, N))


//cari nilai maksimum

#include "stdio.h"

#define NMaks 100

typedef int Larikint[NMaks+1];

int Carimaks(Larikint A, int N);

int Maks;

main(){

Larikint A;

int N, K;

printf("Jumlah : ");scanf("%d",&N);

K=0;

do {

K++;

printf("A[%d]= ",K);scanf("%d",&A[K]);

} while (K<N);

printf("Nilai maksimum dari keseluruhan elemen : %d",Carimaks(A, N));

}

int Carimaks(Larikint A, int N){

int K;

Maks = -9999;

for (K=1;K<=N;K++) {

if (A[K] > Maks) {Maks = A[K];}

}return Maks;

}

3.2.1.4 Larik Bertipe Terstruktur

Misalkan tabmhs adalah sebuah larik yang elemennya menyatakan nilai

ujian seorang mahasiswa untuk suatu mata kuliah (MK) yang ia ambil. Data setiap

III-9

mahasiswa adalah NIM, nama mahasiswa, mata kuliah yang diambil dan nilai

mata kuliah tersebut.

Deklarasi

Const nmaks = 100

Type mahasiswa : record < nim : integer,

Namamhs : string,

Kodemk : string,

Nilai : char

>

tabmhs : array[1..nmaks] of mahasiswa

Struktur logik larik tabmhs:

Tabmhs

NIM Namamhs Kodemk nilai

1

2

…

100

Cara mengacu elemen larik :

Tabmhs[k] {elemen ke-k dari larik tabmhs}

Tabmhs[k].nim {mengacu ke field nim dari elemen ke-k larik}

Pencetakan elemen larik :

Write(Tabmhs[k].nim)

Pengisian elemen larik:

Tabmhs[k].nim ← Tabmhs[k+1].nim

Contoh Algoritma 5:

Algoritma Bacalarikmhs

{mengisi elemen larik mahasiswa dengan data yang dibaca dari piranti

masukan}

Deklarasi

Const NMaks =100

Type Mahasiswa : record < Nim : integer,

Namamhs : string,

Kodemk : string,

Nilai : integer >

III-10

Tabmhs : array[1..NMaks] of Mahasiswa

K : integer

N : integer

Deskripsi

Read(N)

For K←1 to N do

Read(Tabmhs[K]).Nim

Read(Tabmhs[K]).Namamhs

Read(Tabmhs[K]).Kodemk

Read(Tabmhs[K]).Nilai

Endfor

For K←1 to N do

write(Tabmhs[K]).Nim

write (Tabmhs[K]).Namamhs

write (Tabmhs[K]).Kodemk

write (Tabmhs[K]).Nilai

Endfor


// bacalarikmhs

#include "stdio.h"

#define NMaks 100

typedef struct { int Nim[8];

char Namamhs[25];

char Kodemk[20];

int Nilai;}Mahasiswa;

typedef Mahasiswa Larikint[NMaks+1];

main(){

Larikint Tabmhs;

int N, K;

printf("Jumlah : ");scanf("%d", &N);

printf("Masukan Data\n\n\n");

for (K=1;K<=N;K++){

printf("record ke-[%d]\n", K);

printf("Nim : ");scanf("%d", &Tabmhs[K].Nim);

printf("Nama mhs : ");scanf("%s", Tabmhs[K].Namamhs);

printf("Kode MK : ");scanf("%s", Tabmhs[K].Kodemk);

printf("Nilai : ");scanf("%d", &Tabmhs[K].Nilai);}

K=0;

III-11

printf("\n\nTampilkan\n");

for (K=1;K<=N;K++){

printf("record ke-[%d]\n", K);

printf("Nim : %d\n", Tabmhs[K].Nim);

printf("Nama mhs : %s\n", Tabmhs[K].Namamhs);

printf("Kode MK : %s\n", Tabmhs[K].Kodemk);

printf("Nilai : %d\n", Tabmhs[K].Nilai);}

}

3.2.2 Matriks

Matriks adalah struktur penyimpanan data di dalam memori utama yang

individu elemennya diacu dengan menggunakan dua buah indeks (yang biasanya

dikonotasikan dengan baris dan kolom).

kolom

1 2 3 4

1

2

Baris 3

4

5

Gambar 3.1. Matriks yang terdiri atas 5 bari dan 4 kolom

1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4

Gambar 3.2. Representasi matriks 5x4 di dalam memori sebagai larik

Karena matriks sebenarnya adalah larik, maka konsep umum dari larik juga

berlaku untuk matriks, yaitu:

• Kumpulan elemen yang bertipe sama. Tipe elemen matriks dapat berupa

tipe dasar (integer, real, boolean, char dan string), atau tipe terstruktur

seperti record

Elemen(2,3)

Baris 1 Baris 2 Baris 3 Baris 4 Baris 5

III-12

• Setiap elemen data dapat diakses secara langsung jika indeksnya (baris dan

kolom) diketahui, yang dalam hal ini indeks menyatakan posisi relatif di

dalam kumpulannya

• Merupakan struktur data yang statik, artinya jumlah elemennya sudah

dideklarasi terlebih dahulu di dalam bagian kamus dan tidak bisa diubah

selama pelaksanaan program.

3.2.2.1 Pendeklarasian Matriks

Pendeklarasian matriks di dalam teks algoritma ditulis di dalam bagian

Deklarasi. Ada beberapa cara pendeklarasian matriks, yaitu:

1. Sebagai nama peubah

Deklarasi

M : array[1..5, 1..4] of integer

2. Sebagai tipe

Deklarasi

Type mat : array[1..5, 1..4] of integer

M : mat

3. Mendefinisikan ukuran maksimum matriks sebagai sebuah konstanta

Deklarasi

Const nbarismaks = 20

Const nkolommaks = 20

M : array[1..nbarismaks, 1..nkolommaks] of integer

3.2.2.2 Pemrosesan Matriks

Algoritma pemrosesan matriks pada umumnya adalah memanipulasi

elemen-elemen matriks. Pemrosesan matriks adalah proses beruntun (sekuensial).

Setiap elemen matriks “dikunjungi” lalu dilakukan aksi terhadap elemen tersebut.

Berikut adalah skema umum pemroses matriks (per baris per kolom).

Procedure Prosesmatriks(input M : Matriksint, input NBar, NKol : integer)

{pemroses elemen matriks m[1..NBar, 1..NKol] per baris per kolom}

{k.awal : matriks m sudah terdefinisi elemen-elemennya}

{k.akhir : setiap elemen matriks m telah diproses}

III-13

Deklarasi

I : integer {indeks baris}

J : integer {indeks kolom}

Deskripsi

For I ←1 to NBar do

For J ←1 to NKol do

Proses(N[I, J])

Endfor

Endfor

3.2.2.3 Inisialisasi Matriks

Menginisialisasi matriks artinya memberi nilai awal yang sama untuk

seluruh/ sebagian elemen matriks. Proses inisialisasi biasanya dilakukan sebelum

matriks digunakan untuk perhitungan.

Contoh Algoritma 1:

Procedure Inismatriks(input/output M : Matrikint, input NBar, NKol : integer)

{menginisialisasi seluruh elemen matriks M[1..NBar, 1..NKol] dengan 0}

{k.awal : NBar dan NKol sudah terdefinisi dengan banyaknya baris dan kolom

matriks}

{k.akhir : M[I,J]=0 untuk I=1..NBar, J=1..NKol}

Deklarasi

I, J : integer

Deskripsi



N[I, J] ← 0

Endfor

Endfor


//inisialisasi matriks

#include "stdio.h"

#define NBarismaks 10

#define NKolommaks 10

typedef int Matriksint[NBarismaks+1][NKolommaks+1];

III-14

Matriksint M;

int I, J, NKol, NBar;

void Inismatriks(Matriksint *M, int NBar, int NKol);

main(){

NBar=5;

NKol=5;

Inismatriks(&M, NBar, NKol); }

void Inismatriks(Matriksint *M, int NBar, int NKol) {

for (I=1;I<=NBar;I++) {

for (J=1;J<=NKol;J++) {

*M[I][J]=0; }}

}

3.2.2.4 Membaca dan Menulis Elemen Matriks

Membaca elemen matriks artiknya mengisi elemen matriks dengan data

dari piranti masukan. Menulis matriks artinya mencetak elemen-elemen matriks

ke piranti keluaran dengan asumsi bahwa elemen matriks sudah terdefinisi

nilainya.

Contoh Algoritma 2:

Procedure Bacamatriks(input/output M : Matriksint, input NBar, NKol :

integer)

{mengisi elemen matriks M[1..NBar, 1..NKol] dari piranti masukan}

{k.awal : NBar dan NKol sudah terdefinisi dengan banyaknya baris dan kolom

matriks}

{k.akhir : seluruh elemen matriks sudah berisi nilai yang dibaca dari piranti

masukan}

Deklarasi

I, J : integer

Deskripsi



Write(’M[’, I, ’,’ ,J, ’] = ’)

Read(M[I,J])

Endfor

Endfor

III-15

Procedure Tulismatriks(input Mat : Matriksint, input NBar, NKol : integer)

{mencetak elemen matriks M[1..NBar, 1..NKol] dari piranti masukan}

{k.awal : elemen-elemen matriks sudah terdefinisi harganya}

{k.akhir : seluruh elemen matriks tertulis ke piranti keluaran}

Deklarasi

I, J : integer

Deskripsi



Write(’M[’, I, ’,’ ,J, ’] = ’)

write(M[I, J])

Endfor

Endfor


//bacatulis matriks

#include "stdio.h"




matriksint m;


void Bacamatriks(Matriksint *M, int NBar, int NKol);

void Tulismatriks(Matriksint *M, int NBar, int NKol);

main(){

printf("Masukan jumlah baris");scanf("%d", &NBar);

printf("Masukan jumlah baris");scanf("%d", &NKol);

Bacamatriks(&M, NBar, NKol);

Tulismatriks(&M, NBar, NKol);

}

void Bacamatriks(Matriksint *M, int NBar, int NKol) {

for (I=1;i<=NBar;I++) {


printf("M[%d,%d]= ", I, J);scanf("%d", &(*M[I][J])); }}

}

III-16

void Tulismatriks(Matriksint *M, int NBar, int NKol) {



printf("M[%d,%d]=%d\n", I, J,*M[I][J]); }}

}

Contoh Algoritma 3:

Procedure Jumlahduamatriks(input M : Matriksint, input A : Matriksint, output

C: Matriksint, input NBar, NKol : integer)

{menjumlahkan matriks M dan A, yaitu M+A = C}

{k.awal : matriks M dan A sudah terdefinisi elemen-elemennya}

{k.akhir : matriks C berisi hasil penjumlahan M dan A}

Deklarasi

I, J : integer

Deskripsi



C[I, J] = M[I, J] + A[I, J]

Endfor

Endfor

Program Algoritma 3

//jumlah dua matriks

#include "stdio.h"




Matriksint M;

Matriksint A;

Matriksint C;


void Bacamatriks(Matriksint *M, Matriksint *A, int NBar, int NKol);

void Jumlahduamatriks(Matriksint *M,Matriksint *A, Matriksint *C,int NBar,

int NKol);

void Tulismatriks(Matriksint *M,int NBar, int NKol);

III-17

main(){

printf("Masukan jumlah baris");scanf("%d",&NBar);

printf("Masukan jumlah baris");scanf("%d",&NKol);

Bacamatriks(&M, &A, NBar, NKol);

Jumlahduamatriks(&M, &A, &C, NBar, NKol);

Tulismatriks(&C, NBar, NKol);

}

void Bacamatriks(Matriksint *M, Matriksint *A, int NBar, int NKol) {



printf("M[%d,%d]= ", I, J);scanf("%d",&(*M[I][J]));

printf("A[%d,%d]= ", I, J);scanf("%d",&(*A[I][J]));}

}

}

void Jumlahduamatriks(Matriksint *M, Matriksint *A, Matriksint *C, int NBar,

int NKol) {



*C[I][J]=*M[I][J] + *A[I][J]; }

}

}

void Tulismatriks(Matriksint *C, int NBar, int NKol) {

for (I=1;I<=NBar;i++) {


printf("C[%d,%d]=%d\n", I, J,*C[I][J]); }

}

}

Contoh Algoritma 4:

Matriks nol adalah matriks dengan semua elemen adalah 0.

1 2 3 4

1 0 0 0 0

2 0 0 0 0

3 0 0 0 0

4 0 0 0 0

Function Nol(input A : Matriksint, input NBar, NKol : integer) → boolean

{memeriksa apakah matriks A[1..NBar, 1..NKol] merupakan matriks nol;

mengembalikan nilai true jika A adalah matriks nol atau false jika bukan

matriks nol}

III-18

Deklarasi

I, J : integer

Zero : boolean

Deskripsi

I ← 1

Zero ← true

While (I ≤ NBar) and (Zero) do

J ← 1

While (I ≤ NKol) and (Zero) do

If A[I,J] ≠ 0 then

Zero ← false {bukan matriks nol. stop}

Else

J ← J+1 {periksa kolom berikutnya}

Endif

Endwhile

{J > NKol or not Zero}

If zero then

I ← I+1 {periksa baris berikutnya}

Endif

Endwhile

{I > NBar or not Zero}

Return Zero


//jumlah dua matriks

#include "stdio.h"




Matriksint M;


void Bacamatriks(Matriksint *M, int NBar, int NKol);

bool Nol(Matriksint *M, int NBar, int NKol);

main(){

printf("Masukan jumlah baris");scanf("%d",&NBar);

printf("Masukan jumlah baris");scanf("%d",&NKol);

Bacamatriks(&M, NBar, NKol);

III-19

if (Nol(&M, NBar, NKol)==true)

printf("matriks nol");

else

printf("bukan matriks nol");

}

void Bacamatriks(Matriksint *M, int NBar, int NKol) {



printf("M[%d,%d]= ", I, J);scanf("%d",&(*M[I][J])); }

}

}

bool Nol(Matriksint *M, int NBar, int NKol) {

bool Zero;

I=1;

Zero=true;

while ((I <= NBar) && (Zero)) {

J=1;

while ((J<=NKol) && (Zero)) {

if ((*M[I][J]) != 0)

Zero = false;

else

J=J+1;

}

if (Zero)

{I=I+1;}

}

return Zero; }

Contoh Algoritma 5:

1 2 3 4 5 6 7

1 ’a’ ’m’ ’p’ ’u’ ’h’

2 ’b’ ’a’ ’n’ ’d’ ’u’ ’n’ ’g’

3 ’a’ ’p’ ’i’

4 ’k’ ’u’ ’d’ ’a’

...

M ’l’ ’a’ ’l’ ’a’ ’t’

Procedure Cetakkata(input Word : Matrikskar, input M, N : integer)

{mencetak ’Kata’ di dalam matriks word}

{k.awal: matriks Word sudah terdefinisi elemen-elemennya}

{k.akhir : ‘Kata’ tercetak ke piranti keluaran}

III-20

Deklarasi

I, J : integer

Deskripsi

For I ← 1 to M do

J ←1

{telusuri elemen matriks pada baris I sampai ketemu spasi}

While (J < N) and (Word[I, J] ≠ ’ ’) do

Write(Word[I, J])

J ← J+1

Endwhile

{J=N or Word[I, J] = ‘ ’}

{cetak karakter terakhir jika bukan spasi}

If M[I, J] ≠ ’ ’ then

Write(M[I, J])

Endif

Endfor

Cobalah buat programnya dari algoritma berikut!

3.3 Kasus

3.3.1 Kasus 1

1. Diberikan larik integer A dan integer larik B yang masing-masing berukuran n

elemen. Larik A dan B sudah terdefinisi elemen-elemennya. Tuliskan

algoritma prosedur untuk mempertukarkan elemen larik A dan elemen larik B

pada indeks yang bersesuaian, sedemikian sehingga larik A berisi elemen-

elemen larik B dan larik B berisi elemen-elemen larik A semula. Buatlah

program dari algoritma tersebut.

2. Diberikan larik karakter A yang berukuran N elemen. Larik A sudah

terdefinisi elemen-elemennya. Tuliskan algoritma prosedur yang

membalikkan elemen-elemen larik A sedemikian sehingga elemen terakhir

pada larik semula menjadi elemen pertama pada larik akhir.

Contoh: Sebelum pembalikan:

‘a’ ‘b’ ‘c’ ‘d’ ‘e’

Setelah pembalikan:

‘e’ ‘d’ ‘c’ ‘b’ ‘a’

III-21

3. Diberikan larik integer A yang berukuran N elemen. Larik A sudah terdefinisi

elemen-elemen yang sudah terurut menaik (ascending order). Tuliskan

algoritma prosedur untuk menghasilkan median dari elemen-elemen tersebut

(median adalah elemen tengah dari sekumpulan elemen yang sudah tersusun

terurut). Buatlah program dari algoritma tersebut.

3.3.2 Kasus 2

1. Misalkan matriks C yang berukuran M x N sudah berisi data karakter.

Tuliskan algoritma untuk menghitung frekuensi kemunculan huruf ‘A' di

dalam matriks tersebut.

2. M orang mahasiswa mengambil N mata kuliah. Setelah setelah seluruh ujian

akhir selesai, nilai rata-rata (NR) mahasiswa tersebut segera dihitung. NR

dihitung dengan rumus:

∑

∑

=

=

=N

j

j

N

j

jj

SKS

xSKSMK

NR

1

1

yang dalam hal ini, MKj adalah mata kuliah yang ke j dan SKSj adalah bobot

SKS dari mata kulia MKj nilai mahasiswa (berupa indeks nilai A, B, C, D, E)

disimpan di dalam matriks nilaimhs yang berukuran M x N. baris i pada

matriks menyatakan mahasiswa ke-I dan kolom j menyatakan mata kuliah

(MK) ke-j. setiap elemen matriks adalah berupa record yang terdiri atas field

SKS dan field indeksnilai (jadi matriksnya bertipe terstruktur). Nilaimhs[i,j]

menyatakan data nilai mahasiswa yang mengambil mata kuliah j, nilaimhs[i,j].

indeksnilai menyatakan indeks nilai mata kuliah j yang diambil mahasiswa i.

tulislah algoritma dan program untuk menuliskan NR setiap mahasiswa.

3.4 Tugas – Tugas Pendahuluan

Tugas pendahuluan akan dikerjakan selama 30 menit di awal jam

praktikum dengan menggunakan software Self Assessment

III-22

3.5 Latihan Praktikum V, VI dan VII

3.5.1 Latihan Praktikum V (Pertemuan Kelima)

Algoritma 1

Procedure Minmaks(input A : Larikint, input N : integer, output Min : integer,

output Maks : integer)

{mencari elemen terkecil dan elemen terbesar di dalam larik A[1..N]}

{k.awal : elemen larik A[1..N] sudah terdefinisi nilainya}

{k.akhir : min berisi elemen larik yang bernilai terkecil, maks berisi elemen

larik yang bernilai terbesar}

Deklarasi

K : integer {pencatat indeks larik}

Deksripsi

Min ← A[1]

Maks ← A[1]

For K ← 2 to N do

If A[K] < Min then

Min ← A[K]

endif

If A[K] > Maks then

Maks ← A[K]

Endif

Endfor

Buatlah algoritma untuk program utamanya....

Algoritma 2

Procedure CariX(input A : Larikint, input N : integer, input X : integer, output

Ix : integer)

{mencari keberadaan nilai X di dalam larik A[1..N]}

{k.awal : nilai X dan elemen larik A[1..N] sudah terdefinisi}

{k.akhir : ix berisi indeks larik A tempat X berada. Jika X tidak ditemukan, Ix

diisi dengan nilai 0}

Deklarasi

X : integer {indeks larik}

Deskripsi

K ← 1

While (K<N) and (A[K] ≠ X) do

III-23

K ← K+1

Endwhile

{K=N or A[K] = X}

if A[K] = X then {X ditemukan}

Ix ← K

else

Ix ← 0

Endif

Algoritma pencarian

{program utama mencari nilai tertentu di dalam larik}

Deklarasi

Const NMaks = 100 {banyak elemen larik}


A : Larikint

X : integer {elemen yang dicari}

Ix : integer {indeks larik tempat X ditemukan}

Procedure Bacalarik(output A: Larikint, input N : integer)

{mengisi elemen larik A[1..N] dengan nilai yang dibaca dari piranti masukan}

Procedure CariX(input A : Larikint, input N : integer, input X : integer, output

Ix : integer)

{mencari keberadaan nilai X di dalam larik A[1..N]}

Deskripsi

Read(N)

Bacalarik(A, N)

Read(X)

CariX(A, N, X, Ix)

If Ix = 0 then

Write(‘data tidak ditemukan’)

Else

Write(‘ditemukan pada indeks larik ke-’,Ix)

Endif

Algoritma 3

Algoritma Bacalarikmahasiswa

{mengisi elemen larik mahasiswa dengan data yang dibaca dari piranti

masukan}

III-24

Deklarasi

Const NMaks =100

Type Matakuliah : record < KodeMK : string,

NamaMK : string,

Nilai : integer

>

Type Mahasiswa : record < Nim : string,

Namamhs : string,

MK : array[1..5] of matakuliah

>

Larikmhs : array[1..NMaks] of Mahasiswa

I, J : integer

N : integer

JmlMK : integer

Deskripsi

JmlMK = 4

Read(N)

For I←1 to N do

Read(Larikmhs[I].Nim)

Read(Larikmhs[I].Namamhs)

For J←1 to JmlMK do

Read(Larikmhs[I].MK[J].KodeMK)

Read(Larikmhs[I].MK[J].NamaMK)

Read(Larikmhs[I]).MK[J].Nilai)

Endfor

Endfor

Algoritma 4

Tambahkan program di ’algoritma 3’ dengan procedure ’algoritma 4’...

Procedure Hitungindeks(input Nilaiujian : Larikmhs, input N : integer, output

Indeks : Larikmhs)

{menghitung indeks nilai ujian mahasiswa}

{k.awal : N sudah berisi ukuran larik. Elemen larik Nilaiujian[1..N] sudah

terdefinisi nilainya}

{k.akhir : larik Indeks[1..N] berisi nilai indeks ujian}

Deklarasi

K:integer

Deskripsi

For k←1 to N do

Case (Nilaiujian[K])

III-25

Nilaiujian[I] ≥ 80 : Indeks[K]←’A’

70 ≤ Nilaiujian[I] < 80 : Indeks[K]←’B’

55 ≤ Nilaiujian[I] < 70 : Indeks[K]←’C’

45 ≤ Nilaiujian[I] < 55 : Indeks[K]←’D’

Nilaiujian[I] < 45 : Indeks[K]←’E’

Endcase

Endfor

Algoritma 5

Tambahkan ’algoritma 3’ dan ’algoritma 4’ diatas dengan ’algoritma 5’...

Procedure Cetaknilai(input Nim : Larikmhs, input Namamhs : Larikmhs, input :

KodeMK : Larikmhs, input Nilaiujian : Larikmhs, input

Indeks : Larikmhs, input JmlMK : integer)

{mencetak Nim, KodeMK, Nilaiujian dan Indeks ke piranti keluaran}

{k.awal : larik Nim, KodeMK[1..N], Nilaiujian[1..N] dan Indeks[1..N] sudah

terdefinisi}

{k.akhir : Nim, KodeMK, Nilaiujian dan Indeks dicetak ke piranti keluaran}

Deklarasi

I, J : integer

Deskripsi

For I←1 to N do

write(’Nim : ’, Larikmhs[I].Nim)

write(’Nama : ’, Larikmhs[I].Nama)

For J←1 to JmlMK do

{Cetak header tabel}

write(’--------------------------------------’)

write(’KodeMK Nilai Indeks ’)

write(’--------------------------------------’)

write(Larikmhs[I], MK[J].KodeMK, Larikmhs[I]),MK[J].Nilaiujian),

Larikmhs[I]), MK[J].Indeks)

Endfor

Endfor

3.5.2 Latihan Praktikum VI (Pertemuan Keenam)

Algoritma 1:

procedure Maksimum(input A : Matriksint, input NBar, NKol : integer, output

maks : integer)

{mencari elemen maksimum pada matriks A[1..NBar, 1..NKol]}

{k.awal : matriks A sudah terdefinisi harga elemen-elemennya}

III-26

{k.akhir : Maks berisi elemen maksimum matriks A}

Deklarasi

I, J : integer

Deskripsi

Maks ← -9999 {diasumsikan -9999 sebagai nilai maksimum sementara}

For I ← 1 to NBar do

For J ← 1 to NKol do

If A[I, J] > Maks then

Maks ← A[I, J]

Endif

Endfor

Endfor

Algoritma 2

Procedure CariX(input A : Matriksint, input NBar, NKol : integer, output

Idxbaris, Idxkolom : integer)

{mencari X di dalam matriks A[1..NBar, 1..NKol]}

{k.awal : matriks a sudah terdefinisi nilai elemen-elemennya }

k.akhir : Idxbaris dan Idxkolom berisi indeks matriks A sedemikian sehingga

A[Idxbaris, Idxkolom] = X. Jika X tidak ditemukan maka Idxbaris dan

Idxkolom diisi nilai -1}

Deklarasi

I, J : integer

Ketemu : boolean {true jika X ditemukan, false jika sebaliknya}

Deskripsi

I ← 1

Ketemu ← false

While (I ≤ NBar) and (not Ketemu) do

J ← 1

{telusuri elemen matriks pada baris ke-I, dimulai dari kolom ke-J}

While (J ≤ NKol) and (not Ketemu) do

If A[I, J] = X then

Ketemu ← true

Else

J ← J+1 {periksa pada kolom berikutnya}

Endif

Endwhile

{J > NKol or Ketemu}

If not Ketemu then

III-27

I ← I+1 {periksa pada baris berikutnya}

Endif

Endwhile

{I > NBar or Ketemu}

If Ketemu then

Idxbaris ← I

Idxkolom ← J

Else

Idxbaris ← -1

Idxkolom ← -1

Endif

Algoritma 3

Procedure BuatTranspose(input A : Matriksint, input NBar, NKol : integer,

output At: Matriksint, output NBarAt, NKolAt :

integer)

{membentuk transpose dari matriks A[1..NBar, 1..NKol]}

{k.awal : matriks a sudah terdefinisi nilai elemen-elemennya}

{k.akhir : at adalah transpose dari matriks a sedemikian sehingga matriks hasil

transpose (jumlah aris dan jumlah kolom)}

Deklarasi

I, J : integer

Deskripsi

NBarAt ← NKol {jumlah baris matriks transpose}

NKolAt ← NBar {jumlah baris matriks transpose}

for I ← 1 to NBar do

for J ← 1 to NKol do

At[J, I] ← A[I, J]

Endfor

Endfor

Algoritma 4

Procedure Perkalianmatriks(input A : Matriks, input M, N : integer, input B :

Matriks, input P : integer, output C : Matriks, output

NBarc, NKolc : integer)

{mengalikan matriks A dan B menghasilkan matriks C}

{k.awal : matriks A dan B sudah terdefinisi elemen-elemennya}

{k.akhir : matriks C berisi hasil perkalian A dan B, NBarc dan NKolc berisi

ukuran matriks C}

III-28

Deklarasi

I, J : integer

K : integer

Deskripsi

Nbarc ← M {jumlah baris matriks hasil perkalian}

Nkolc ← P {jumlah kolom matriks hasil perkalian}

For I ← 1 to M do

For j ← 1 to P do

C[I, J] ← 0 {inisialisasi C[I, J] dengan 0}

For K ← 1 to N do

C[I, J] ← A [I, K] * B[K, J]

Endfor

Endfor

Endfor

3.5.3 Latihan Praktikum VII (Pertemuan Ketujuh)

Rangkuman Modul 0 – III. Membuat sebuah algoritma dan program

(Tugas Besar) yang akan dipersentasikan pada pertemuan ketujuh. Dibuat

perkelompok.

modul iii larik dan matriks - dhamidin’s weblog type larikint : array [1..maks] of integer a :...

Documents