Algoritma program penghapusan string

Program ini bertujuan untuk menghapus beberapa bagian string dari string yang sudah ada berdasarkan index awal dan akhir yang dimasukkan oleh pengguna.

Algoritma program hapus string adalah sebagai berikut.

Deklarasi global

1. Deklarasikan konstanta maxChar=255

2. Deklarasikan tipe arrKata=array[1..maxChar] of char;

Fungsi doHapus

fungsi doHapus bertujuan untuk memproses penghapusan karakter dari karakter yang dimasukkan. Adapun parameter yang di ikutkan adalah strKata bertipe string berfungsi untuk melewatkan kata atau kalimat yang ingin dihapus nilainya, awal dan akhir yang merupakan batas penghapusan karakter. Nilai keluaran dari fungsi ini adalah string hasil penghapusan. Adapun algoritma pada fungsi doHapus ini adalah sebagai berikut.

1. Deklarasikan variable I dan j dengan tipe data integer

2. Deklarasikan arrHasilHapus bertipe arrKata

3. Deklarasikan strHasilHapus bertipe string

4. Inisialisasi j=0

5. Lakukan langkah 6 dari i=1 sampai dengan panjang strKata

6. Jika i<awal atau i>akhir i>akhir maka karakter tersebut dimasukkan kedalam arrHasilHapus ke j dan naikkan nilai j sebesar 1.

Program Utama

1. Memasukkan kata atau kalimat yang ingin di hapus karakternya.

2. Masukkan batas awal dan akhir penghapusan

3. Memanggil fungsi doHapus

4. Cetak hasil dari fungsi doHapus

Source Code program penghapusan string

program HapusString;

uses wincrt;

const maxChar=255; {maximal jumlah karakter}

type

arrKata=array[1..maxChar] of char;

var awal, akhir:byte; {posisi awal dan akhir karakter yang dihapus}

kata, hasilHapus, tempNilai:string;

nilaiKonv:integer;

pil : char;

isNumber:boolean;

function doHapus(strKata:string; awal, akhir:byte):string;

{fungsi untuk melakukan penghapusan mulai dari index Awal sampai index akhir dengan keluaran berupa string yang sudah dihapus }

var i,j:integer;

arrHasilHapus:arrKata;

strHasilhapus:string;

begin

j:=1; {inisialisasi untuk counter arrHasilHapus}

for i := 1 to length(strKata) do

begin

if (i<awal) or (i>akhir) then

begin

arrHasilHapus[j]:=strKata[i];

j:=j+1; {pencacah j di increase sebanyak 1}

end

end;

strHasilHapus :=”;

for i:=1 to j-1 do

begin

strHasilHapus:=strHasilHapus+ arrHasilHapus[i];

end;

doHapus:=strHasilHapus;

end;

procedure menu;

begin

clrscr;

writeln(‘===============================================================================’);

writeln(‘# PROGRAM PENGHAPUS KARAKTER #’);

writeln(‘# program ini menghapus karakter dari kalimat yang dimasukkan. #’);

writeln(‘#—————————————————————————–#’);

writeln(‘# Silakan pilih menu berikut : #’);

writeln(‘# 1. Masukkan kalimat #’);

writeln(‘# 2. Masukkan index awal dan akhir penghapusan #’);

writeln(‘# x. Keluar #’);

writeln(‘# Pilihan : #’);

writeln(‘===============================================================================’);

gotoxy(2,11);writeln(‘##################################################################’);

gotoxy(2,12);writeln(‘# #’);

gotoxy(2,13);writeln(‘# Kalimat yang dimasukkan : ‘,kata);

gotoxy(2,14);writeln(‘# #’);

gotoxy(2,15);writeln(‘##################################################################’);

gotoxy(67,13);writeln(‘#’);

gotoxy(4,17);writeln(‘ ——————’);

gotoxy(4,18);writeln(‘|Indexs Awal :’,awal);

gotoxy(4,19);writeln(‘|Indexs Akhir :’,akhir);

gotoxy(4,20);writeln(‘ ——————’);

gotoxy(23,18);writeln(‘|’);

gotoxy(23,19);writeln(‘|’);

gotoxy(2,21);writeln(‘==================================================================’);

gotoxy(2,22);writeln(‘# Hasil Penghapusan : ‘,hasilHapus);

gotoxy(2,23);writeln(‘==================================================================’);

gotoxy(67,22);writeln(‘#’);

pil:=’ ‘;

end;

begin

{Program utama}

repeat

menu;

gotoxy(46,9);pil:=readkey;

case upcase(pil) of

’1′ : begin

gotoxy(46,9);writeln(‘Memasukkan kalimat’);

gotoxy(30,13);writeln(‘ ‘);

gotoxy(30,13);readln(kata);

hasilHapus:=doHapus(kata, awal, akhir);

end;

’2′ : begin

if kata=” then

begin

clrscr;

gotoxy(6,11);writeln(‘————————————————————————’);

gotoxy(6,12);writeln(‘ Kalimat masih kosong, silakan isi dahulu ‘);

gotoxy(6,13);writeln(‘————————————————————————’);

readln;

end else

begin

gotoxy(46,9);writeln(‘Memasukkan index’);

gotoxy(19,18);writeln(‘ ‘);

gotoxy(19,19);writeln(‘ ‘);

gotoxy(19,18);readln(tempNilai);

val(tempNilai, awal,nilaiKonv);

if nilaiKonv=0 then

begin

isNumber:=true;

gotoxy(19,19);readln(tempNilai);

val(tempNilai, akhir,nilaiKonv);

if nilaiKonv<>0 then

begin

isNumber:=false

end;

end else isnumber:=false;

if isnumber=false then

begin

clrscr;

gotoxy(6,11);writeln(‘————————————————————————’);

gotoxy(6,12);writeln(‘silakan masukkan angka’);

gotoxy(6,13);writeln(‘err : ‘,tempNilai,’ : bukan angka’);

gotoxy(6,14);writeln(‘————————————————————————’);

readln;

end else

begin

if (awal<1) or (awal >length(kata)) or (akhir<1) or (akhir>length(kata)) or (awal>akhir) then

{pengecekan apakah memnuhi syarat untuk dihapus}

begin

clrscr;

gotoxy(6,11);writeln(‘————————————————————————’);

gotoxy(6,12);writeln(‘index awal dan akhir tidak sesuai dengan karakter pada kalimat : ‘);

gotoxy(6,13);writeln(kata);

gotoxy(6,14);writeln(‘————————————————————————’);

readln;

end else

begin

hasilHapus:=doHapus(kata, awal, akhir); end;

end;

end;

end;

‘X’ : begin

donewincrt;

end;

else writeln(‘Maaf, pilihan yang anda masukkan salah. Silakan ulangi lagi’);

end;

until upcase(pil)=’X';

end.

Array adalah koleksi data yang tipenya sama, tersusun dalam bentuk barisan linier berurutan (sequence) dan jumlah elemen atau datanya tidak berubah (statis) sesuai dengan deklarasi awal. Semua elemen array diidentifikasi dengan sebuah nama (nama array) dan untuk setiap elemennya diidentifikasi/dibedakan dengan sebuah index.

2. Deklarasi.

Bentuk umum deklarasi array adalah:

type tipe_array = array [range_index] of ipe_data;

var var_array : tipe_array; (1.1)

Atau dapat langsung dituliskan sebagai berikut:

var var_array = array [range_index] of tipe_data; (1.1)

var_array adalah nama variabel array yang dipakai untuk mengidentifikasi array. Pemilihan nama variabel array mengikuti aturan pemberian nama variabel secara umum.

Range_index adalah batasan index yang digunakan untuk mengidentifikasi elemen array. Range_index menentukan jumlah elemen array, yang jumlahnya tidak akan berubah (statis) mulai saat awal disediakan (program dijalankan) hingga program selesai dijalankan. Misalnya range 0..9 atau 1..10 atau –1..8 atau ‘A’..’J’ akan menentukan jumlah elemen array sebanyak 10 buah.

Setiap elemen array diidentifikasi oleh salah satu index yang berada dalam range yang telah ditentukan. Penggunaan index yang berada di luar range Index akan mengakibatkan kesalah, Index ini tidak harus berupa bilangan positif, tetapi harus berupa bilangan bulat atau data-data yang masuk kategori tipe data ordinal (seluruh tipe data dasar selain real dan double), seperti semua varian integer, char, boolean atau tipe data enumerasi yang dibuat sendiri oleh user.

Tipe_data adalah tipe data untuk elemen array. Tipe data elemen array tidak harus berupa integer, atau tipe data dasar yang lain, tetapi dapat berupa tipe data terstruktur seperti array.

Tentang pemilihan model deklarasi, model deklarasi dengan membuat sebuah tipe array seperti model (1.1) akan lebih jelas dan lebih ringkas yang dapat dirasakan saat variabel-variabel bertipe array digunakan sebagai parameter sebuah fungsi atau prosedur.

3. Operasi Pada Array

- Operasi Memasukkan dan Mengambil Nilai

Bila array sudah dideklarasikan dan sudah diberi suatu nama, maka dapat dimanfaatkan sesuai fungsinya sebagai objek data. Operasi memasukkan nilai adalah operasi untuk memasukkan nilai data ke dalam elemen-elemen array. Biasanya hal ini dilakukan dengan operasi penugasan (assignment) dengan objek array terletak sebagai operan di sebelah kiri tanda ‘:=’.

Sedangkan operasi mengambil nilai adalah operasi untuk mendapatkan/membaca nilai dari suatu array. Hal dini dilakukan ketika menggunakan array sebagai operan nada suatu operasi atau sebagai parameter sebuah fungsi/prosedur.

- Operasi Mengakses Array

Operasi mengakses suatu objek data merupakan nama yang lebih umum daripada operasi memasukkan nilai ataupun membaca nilai. Jadi, operasi mengakses array dapat berupa memasukkan nilai atau membaca nilai array. Operasi ini dapat dilakukan pada array secara keseluruhan ataupun pada suatu elemen tertentu.

- Mengakses Elemen Array Secara Acak/Random

Setiap elemen array dapat diperlakukan secara individual terlepas dari elemen-elemen lainnya. Misalnya dalam hal memasukkan data, nilai[7] dapat dimasukkan lebih dulu daripada elemen lainnya.meskipun akhirnya semua elemen array akan diakses, namun tidak aturan yang pasti tentang urutan mengaksesnya. Kita bisa saja mengakses nilai[5] tanpa mengakses komponen array lainnya.

- Mengakses Elemen Array Secara Sequensial (Berurutan)

Struktur array yang elemen-elemennya tersusun secara berurutan, memungkinkan kita mengakses sebagian atau seluruh elemen array secara berurutan.

Untuk proses mengunjungi elemen array (traversal of array) secara berurutan dapat dilakukan dengan proses looping (perulangan). Pada model-model di atas, elemen-elemen array diakses secara berurutan dengan selisih satu index. Jadi elemen ke-6 akan diakses sebelum atau sesudah elemen ke-5 ataupun ke-7. Pergeseran index dilakukan dengan menambah atau mengurangi index sebelumnya dengan 1. Kita juga dapat membuat model yang lain dengan mengubah selisih indexnya. Misalkan menjadi 2, 3, atau berapa saja sesuai keperluan, asalkan selalu berada pada range index.

- Mengakses Array Secara Keseluruhan

Selain mengakses komponen array, kita juga dapat mengakses array secara keseluruhan yang akan mempengaruhi semua elemennya sekaligus. Misalkan A dan B adalah dua buah variabel array yang tipenya sama, dan jumlah elemennya juga sama, maka dalam Pascal dapat dilakukan operasi penugasan A := B yang berarti memasukkan nilai dari setiap elemen array B ke semua elemen A pada Index-Index yang bersesuaian.

4. Array Multidimensi

Tipe data elemen array tidak harus berupa tipe data elementer, namun juga dapat berupa tipe data terstruktur, misalnya array. Sebagai contoh, perhatikan deklarasi berikut :

Var Matrix:array[1..3,1..3] of integer;

Bentuk deklarasi mungkin saja dibuat untuk kasus demikian, tipe nilai_ujian adalah berupa array dengan dua elemen bertipe integer untuk menyimpan nilai ujian midterm dan ujian akhir. Sedangkan variabel nilai adalah array dengan sepuluh elemen bertipe nilai_ujian, yang digunakan untuk menyimpan nilai ujian dari 10 mahasiswa. Elemen-elemen array nilai bertipe array integer. Walaupun terdapat dua buah array, tetapi setiap deklarasi array hanya dibatasi dengna sebuah range Index saja. Jumlah elemen array nilai adalah 10, walaupun secara keseluruhan banyaknya bilangan yang dapat disimpan adalah 20 buah. Array demikian dikenal sebagai array berdimensi 1.

5. Penggunaan Konstanta untuk Batas Index Arrray

Deklarasi konstanta sering digunakan untuk batas bawah dan batas atas pada range Index array. Setiap kali menggunakan array, kita pasti berharap agar ruang yang kita sediakan sesuai dengna banyaknya data yang akan disimpan; jangan sampai berlebihan, ataupun kekurangan.

Sering kali kita terpaksa harus mengubah batas-batas range Index untuk menyesuaikan jumlah data. Penggunaan konstanta akan memudahkan bila ada keperluan untuk mengubah batas-batas range Index array, yaitu cukup mengganti nilai konstanta tersebut.