Search This Blog

Wednesday 31 August 2016

Bubble Sort

Untuk topik kali ini penulis ingin membahas sedikit mengenai sorting dan memberikan sedikit contoh metode sorting dengan bubble sort. Sekilas mengenai sorting, sorting merupakan proses untuk mengurutkan data dalam sebuah memori dengan urut ascending (urut menaik) atau Descending (urut menurun). Untuk ascending atau urut menaik, maka nilai diurutkan dari yang terkecil hingga yang terbesar, sedangkan pada descending dengan urutan yang menurun maka nilai yang diurutkan ialah dari yang terbesar hingga yang terkecil. Sorting sendiri terbagi menjadi dua, yaitu Internal sort dimana data yang diurutkan ialah data yang berada dalam media penyimpanan internal, dan juga External sort dimana data yang akan diurutkan berada dalam media penyimpanan external. Jika diibaratkan dengan sebuah handphone, media penyimpanan internal itu merupakan memori handphone itu sendiri, sedangkan untuk media penyimpanan externalnya ialah memori (seperti micro sd) yang biasa disisipkan oleh pengguna handphone itu sendiri.

Untuk sorting sendiri, banyak sekali metode yang dapat dilakukan, seperti pada internal sort yang dapat dilakukan dengan bubble sort, selection sort, insertion sort, shell sort, merge sort, radix sort, quick sort, heap sort, namun untuk topik yang dibahas kali ini ialah bubble sort. Metode bubble sort sendiri bertugas untuk menempatkan nilai terbesar di sebelah kanan pada setiap perulangan yang dilakukan. Dengan kata lain proses bubble sort ialah proses sorting dengan menempatkan nilai terbesar ada posisi paling kanan. Jika kita mensorting angka 97,1,24. Maka nanti angka 97 akan ditempatkan pada posisi akhir pada paling kanan, setelah itu nanti angka 24 akan berada pada posisi tepat disebelah kiri angka 97 tersebut, begitupun dengan angka 1, ia akan berada tepat disebelah kiri angka 24. Namun tetap proses yang ditempuh karena menggunakan perulangan, maka yang pertama dilakukan ialah pertukaran angka dari indeks yang pertama atau indeks 0, jika indeks nol pada contoh tersebut 97 dan indeks berikutnya berisi nilai 1, maka kedua angka tersebut akan bertukar posisinya, karena angka 97 lebih besar dari angka 1, dengan demikian urutannya akan berubah menjadi 1,97,24. Setelah itu, maka proses selanjutnya untuk membandingkan angka 97 dengan angka 24, jika angka 97 lebih besar dari angka 24, maka kedua angka tersebut akan bertukar posisi, angka 97 akan berada paling kanan (karena menjadi angka tertinggi dari ketiga angka tersebut) dan angka 24 akan berada tepat disebelah kiri angka 97nya. Dengan demikian urutannya akan berubah menjadi 1,24,97. Begitupun dengan proses selanjutnya, akan ada perbandingan angka 1 dengan angka 24, jika memang angka 1 nilainya lebih besar dari angka 24, maka kedua angka tersebut akan bertukar posisi. Namun dikarenakan angka 1 tidak lebih besar dari angka 24 (nilainya), maka kedua angka tersebut akan tetap berada di posisinya masing-masing. Walaupun angkanya banyak, jika jumlah perulangan yang dilakukan sesuai dengan jumlah angka yang akan dibandingkan, maka proses perbandingan akan berlangsung lebih banyak sesuai dengan jumlah perulangan dan angka yang ada, tetapi tetap saja pada intinya proses yang ditempuh akan sama selama dilakukan dengan metode yang sama, yaitu dengan memposisikan nilai tertinggi pada posisi paling kanan. Perhatikan contoh program berikut:

#include<stdio.h>
main(){
int R[3]={97,1,24}, y, q, T;
printf("  Bentuk awalnya:\n\n");

for(q=0; q<3; q++){
printf("%5i", R[q]);
}

for(q=0; q<2; q++){
for(y=0; y<2; y++){
if(R[y]>R[y+1]){
T=R[y];
R[y]=R[y+1];
R[y+1]=T;
}
}
}
printf("\n\n\n\n\n   Hasil sorting:\n\n");

for(q=0; q<3; q++){
printf("%5i", R[q]);
}
}

Dalam contoh program tersebut terlihat ada variabel array dengan nama variabel R, dimana variabel R memiliki 3 indeks dengan isi variabel yang ialah tipe data numerik dengan nilai masing-masing 97,1 dan 24. Terdapat pula variabel y dan q yang bertugas untuk membantu proses perulangan serta variabel T yang bertugas untuk membantu proses sorting itu sendiri. Mengapa proses sorting ini menggunakan bantuan variabel lain? Karena pada proses bubble sort membutuhkan 3 variabel berbeda untuk mengurutkan nilai-nilai yang dimaksud. Setelah deklarasi dilakukan, seperti yang biasa dilakukan pada sebuah program ialah memeri keterangan (bilai perlu) pada saat mencetak ke layar. Keterangan ini tidak dapat dianggap remeh, karena user tidak akan tahu apa yang harus ia lakukan saat menghadapi sebuah hal baru tanpa ia tahu prosesnya. Maka jika diperhatikan dari sisi usability, keterangan itu sudah jelas akan sangat mempermudah user dalam memahami apa yang harus ia lakukan dengan apa yang ada dihadapannya (di layar). Dan perulangan dibawahnyapun ialah proses untuk keterangan pula, kedua hal itu sama-sama bertugas untuk mencetak keterangan ke layar, hanya saja bedanya proses cetak yang pertama dilakukan secara langsung sedangkan proses cetak yang kedua menggunakan bantuan perulangan. Perulangan sendiri dilakukan tidak lain karena proses cetak yang dilakukan ialah untuk mencetak isi dari variabel array. Dengan demikian proses perulanganpun dilakukan sebanyak isi dari variabel array tersebut.

Mari perhatikan proses sortingnya. Proses sorting dalam contoh program diatas dilakukan dalam dua buah perulangan, dimana perulangan kedua berada dalam perulangan. Dengan kata lain, pada proses terebut tidak menjadi dua perulangan, namun satu perulangan dengan perulangan didalamnya, dapat dikatakan bahwa proses perulangan tersebut ialah proses perulangan dalam perulangan. Mengapa proses sorting tersebut dilakukan dalam perulangan yang terdapat dalam perulangan pula? Ialah karena setiap nilai yang terkandung dalam variabel array akan mengalami perbandingan sebanyak jumlah isi variabel array sendiri, seperti dalam contoh yang terdapat 3 buah nilai dan setiap nilai akan mengalami 2 kali perbandingan. Jika 2 dikali 2 maka hasilnya ialah 4, namun bukan berarti dilakukan dalam 4 kali perulangan dalam satu buah metode perulangan. Karena jika demikian, maka hanya akan ada satu buah nilai yang dibandingkan sebanyak 4 kali, sedangkan 2 angka lainnya tidak dibandingkan satu sama lain (hanya pernah dibandingkan dengan angka yang satu tadi). Namun pada proses perulangan tersebut maka jika disesuaikan dengan contoh diatas, pada perulangan pertama di for() yang pertama, angka pada indeks pertama akan dibandingkan sebanyak 2 kali, dimana yang pertama ialah indeks pertama (indeks 0) dengan indeks kedua (indeks 1), lalu indeks tersebut (yang tadi indeks pertama) dibandingkan kembali dengan indeks ketiga (indeks 2). Lalu pada perulangan kedua dalam for() yang pertama, akan ada proses yang sama namun dengan isi indeks yang sedikit berbeda (andai angkanya belum tersusun rapi). Lalu mengapa hanya 2 kali perulangan? Karena jika indeks 0 pernah dibandingkan dengan indeks 1, indeks 1 pernah dibandingkan dengan indeks 2 serta indeks 0 pernah dibandingkan dengan indeks 2, maka hanya butuh untuk merapihkan saja. Tidak perlu terlalu banyak perbandingan untuk itu. Bisa saja jika memang disesuaikan, membuat perulangan lebih banyak dari itu, seperti perulangan pertama sebanyak 3x dan dan perulangan didalamnya sebanyak 3x pula (untuk diterapkan pada contoh diatas), namun jika dengan 2x2 perulangan sudah cukup, untuk apa perulangan tersebut diperbanyak lagi?

Selain itu, mari kita perhatikan isi didalam perulangan tersebut. Terdapat kondisi if(), dimana kondisi tersebut berperan sebagai pengarah program, jika memang indeks sekian(indeks sesuai dengan hitungan perulangan) lebih besar dari indeks berikutnya, maka akan dikerjakan statement true dalam kondisi if() tersebut. Statement true dalam kondisi tersebut berisikan 3 buah perintah, dimana satu sama lain perintahnya saling berhubungan. Dalam baris pertama statement true tersebut terdapat perintah untuk mengisi variabel T dengan isi variabel yang sedang ditunjuk (sesuai dengan indeks perulangan). Lalu pada baris keduanya, terdapat perintah untuk mengisi indeks yang sedang ditunjuk tersebut dengan isi indeks berikutnya (yang sudah dibandingkan tadi dan mengandung nilai lebih besar darinya). Dan perintah terakhir ialah untuk mengisi variabel berikutnya tersebut dengan isi variabel T, dimana variabel T berisi nilai yang sebelumnya menjadi isi variabel dari indeks yang sedang ditunjuk. Jika diperhatikan proses tersebut, maka sebenarnya yang dilakukan oleh program tak lain untuk menukar nilai dalam indeks yang ditunjuk dengan nilai dalam indeks didepannya (indeks yang dibandingkan), hanya itu yang dilakukan oleh program, dan variabel T hanya bertugas untuk membantu proses tersebut. Dan setelah proses sorting selesai, ada satu perulangan lagi, perulangan ini tak lain hanya untuk memerikan informasi pada user dengan percetakan ke layar menganai hasil yang sebelumnya menjadi keterangan untuk user. Sebenarnya sama saja, sama-sama bertugas untuk mencetak pada layar, hanya saja yang pertama mencetak nilai awal, dan kali ini mencetaknya nilai akhir (hasil).

Tuesday 30 August 2016

Merge array 1 dimensi

Merge merupakan suatu proses untuk penggabungan, atau dengan kata lain merge berarti menggabungkan. Untuk menggabungkan sendiri sudah jelas bahwa harus ada sesuatu yang digabungkan, artinya harus ada lebih dari satu data agar dapat berlangsung proses penggabungan tersebut. Dalam hal pemrograman pun merge biasa diartikan suatu proses menggabungkan dua file data dalam memori external, tapi penggabungan disini bukan berarti kedua file itu dijumlahkan seperti dalam posted sebelumnya. Dalam penggabungan yang satu ini ialah bagaimana dua buah file dapat menjadi satu file baru yang didalamnya terdapat semua komponen dari dua file itu. Dapat diibaratkan seperti saat Anda memiliki 2 buah buku dalam rak yang hanya dapat menampung 2 buah buku tersebut, dan Anda ingin kedua buah buku tersebut disatukan dengan 3 buku lainnya dalam rak yang berbeda dan hanya dapat menampung 3 buah buku pula. Dengan demikian Anda harus memiliki rak buku baru yang mampu menampung 5 buah buku sekaligus, sehingga semua buku tersebut dapat digabungkan dalam rak yang sama. Dalam topik kali ini penulis hanya ingin memberi sebuah contoh program untuk menggabungkan dua buah isi array beserta sedikit penjelasan dari program tersebut. Yang paling penting dalam topik ini ialah logikanya, dimana pada saat Anda ingin membuat sebuah program untuk menggabungkan dua buah data/file, maka perintah apa saja yang harus Anda tuliskan dalam program tersebut. Agar tidak terlalu banyak basa-basi, maka lebih baik jika langsung pada contoh programnya saja:

#include<stdio.h>
main(){
int b, s=0, S[3]={24,1,97}, E[3]={22,1,97},W[6];


printf("\n\t\tDeret yang akan ditempatkan awal:\n\n");


for(b=0; b<3; b++){
if(b==0){printf("\t\t\t    ");}

W[s]=S[b];
s++;
printf("%3i", S[b]);
}


printf("\n\n\n\t Angka yang akan ditempatkan pada indeks berikutnya:\n\n");


for(b=0; b<3; b++){
if(b==0){printf("\t\t\t    ");}

W[s]=E[b];
s++;
printf("%3i", E[b]);
}


printf("\n\n\n\n\t *=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*\n\n");
printf("\n\n\t\t Hasil Penggabungan / MERGE tersebut:\n\n");


for(s=0; s<6; s++){
if(s==0||s==3){printf("\t\t\t    ");}

printf("%3i", W[s]);

if(s==2){
printf("\n");
}
}
}

Mari perhatikan contoh program tersebut, seperti biasa yang dilakukan pertama kali ialah deklarasi dan inisialisasi variabel. Namun dalam contoh program terebut terlihar perbedaan antara variabel b dan s. Variabel b terlihat hanya dideklarasikan saja, sedangkan s sudah diberi nilai awal langsung. Mengapa demikian? Oke mari perhatikan perintah-perintah berikutnya, variabel b hanya digunakan dalam 2 perulangan pertama, dan dalam setiap perulangan tersebut variabel b diberi nilai awal, jadi dengan demikian variabel b dapat tidak diberi nilai awal pada saat deklarasi dilakukan. Sedangkan untuk variabel s, walau dalam perulangan ketiga variabel tersebut diberi nilai awal, namun untuk perulangan pertama dan kedua sendiri variabel tersebut tidak memiliki nilai awal. Maka dengan demikian variabel s harus diberi nilai awal terlebih dahulu sebelum perulangan pertama dan kedua dilaksanakan, itulah perbedaan antara variabel b dan s. Lalu mengapa dengan variabel array S dan E diberi nilai awal sedangkan variabel array W hanya dideklarasikan saja? Oke mari perhatikan kembali perintah-perintah berikutnya. Dalam program tersebut tidak ada perintah untuk input, maka untuk menyatakan informasi dalam percetakan, sebagai bukti bahwa variabel array S dan E sudah digabungkan maka kedua variabel array tersebut diberi nilai awal terlebih dahulu. Sedangkan untuk variabel array W sendiri mengapa ia hanya dideklarasikan saja ialah karena ia nantipun akan terisi oleh deret isi variabel S dan E. Dengan demikian variabel array W tidak perlu lagi diberi nilai awal, kecuali jika memang nilai variabel tersebut dibutuhkan dalam program yang dibuat, dan atau mungkin untuk kesesuaian dengan keinginan bahwa variabel tersebut ingin diberi nilai awal terlebih dahulu, itu tidak menjadi masalah, karena pada akhirnya jika nilai tersebut tidak diberi perintah tambahan (selain perintah dalam contoh program diatas) maka isi dari variabel tersebut akan terganti dengan hasil merge tersebut. Dan mengapa variabel array S dan E hanya memiliki 3 deret indeks sedangkan variabel array W memiliki 6 deret indeks? Karena variabel W hanyalah variabel array yang akan menampung isi dari kedua variabel tersebut (variabel array S dan E), maka untuk deklarasi sendiri variabel array W harus mengandung deret indeks sejumlah deret indeks yang ada dalam variabel array S ditambah dengan jumlah deret indeks variabel array E.

Agar tidak terlalu banyak basa-basi, mari kita langung menuju inti dari program tersebut. Untuk perintah printf() sendiri sebelum perulangan dilakukan ialah hanya untuk memberi keterangan pada proses cetak ke layar. Dan dalam perulangan pertama kita melihat variabel yang digunakan untuk perulangan tersebut ialah variabel b, dimana variabel tersebut harus sesuai dengan tujuan dilakukannya perulangan. Dalam perulangan pertama, variabel b juga digunakan untuk mengindeks variabel array S yang mana variabel array tersebut memiliki 3 indeks, dengan demikian perulanganpun dilakukan sebanyak indeks dalam variabel S. Lalu mengapa tidak digunakan untuk variabel W, mengapa digunakan untuk variabel S? Karena yang akan diproses ialah isi dari variabel B, sedangkan variabel array W hanya akan menampung hasil dari proses tersebut. Lalu untuk apa perintah s++ dibawahnya? Perintah s++ tersebut digunakan untuk memberi perubahan kondisi pada variabel s. Karena pada dasarnya antara variabel b dan s memiliki perintah-perintah yang sama, pada variabel b memiliki nilai awal, kondisi dan perubahan kondisi yang ditulis berderet dalam proses perulangan, sedangkan variabel s nilai awalnya ditulis pada saat deklarasi, perubahan kondisi dilakukan didalam perulangan serta kondisinya diwakilkan oleh variabel b sebagai pembantu proses perulangan. Dan peran variabel s dalam inti program ini ialah untuk membantu proses pengindeksan variabel array W, sehingga pada saat perulangan dilaksanakan, maka perpindahan antar indeks dalam variabel array W menyesuaikan perpindahan dari variabel array S. Untuk kondisi if() sendiri yang berisikan perintah jika b==0 maka diberi jarak (tab) dari pojok kiri layar, sehingga pada saat percetakan dilaksanakan, maka perintah printf() dibawahnya lebih tergeser ke kanan. Dengan kata lain tulisan yang tercetak lebih dikekanankan. Demikianlah proses-proses yang terjadi pada perulangan pertama. Dan pada perulangan kedua pun tidak jauh berbeda dimana isi dari variabel array E akan mengisi indeks berikutnya dari variabel array W. Mengapa bisa mengisi indeks berikutnya? Mengapa tidak dari indeks nol lagi? Sedangkan perulangan sendiri berawal dari nol. Itu disebabkan karena s++ yang ada dalam perulangan sebelumnya tidak diberi nilai awal 0 lagi, sedangkan untuk variabel b, pada perulangan kedua diberi nilai awal kembali. Jadi variabel s untuk mengindeks variabel array W hanya akan melanjutkan dari indeks yang sudah dilakukan sebelumnya. Jadi intinya dalam kedua perulangan tersebut tidak banyak mengandung perbedaan, dan alurnya pun sama saja (terlihat dari perintah-perintah yang diberikan).

Proses yang dijelaskan diatas merupakan proses inti dari merge tersebut, dimana isi kedua variabel array (S dan E) akan digabungkan dalam variabel array baru dengan nama variabel W. Proses tersebut memang terlihat mudah, namun yang harus diperhatikan ialah pengindeksan nya. Dimana pada saat perulangan, perulangan tersebut akan dilakukan untuk mengindeks yang mana (menyesuaikan dengan indeks variabel yang mana), apakah variabel yang diisi atau variabel yang mengisi (variabel yang akan digabungkan atau variabel yang akan menampung hasil penggabungan tersebut). Selain itu, yang harus diperhatikan pula ialah pengindeks variabel yang akan menampung hasil penggabungannya. Untuk variabel tersebut, memberi nilai awal harus dilakukan sebelum proses perulangan dilakukan, dan tidak ketinggalan akan perubahan kondisi pada setiap perulangan yang dilakukan. Untuk if() sendiri sebenarnya tidak disertakan dalam kodinganpun tidak menjadi masalah, karena kondisi if() tersebut tidak lain hanyalah pemberi jarak agar cetakan lebih tergeser ke kanan. Begitupun dengan printf() yang berada dalam perulangan tersebut, itu hanyalah keterangan dari nilai dalam variabel yang akan digabungkan, tidak disertakan dalam program tersebutpun tidak menjadi masalah. Dan yang terakhir ialah pada perulangan ketiga. Sebelum perulangan tersebut kita melihat terdapat 2 buah perintah printf() yang mana perintah kedua sama seperti pada sebelum perulangan yang lalu. Namun ada perintah satu lagi yang isinya tak lain karakter = - * namun karakter tersebut tidak mempengaruhi alur program sedikitpun, karena itu hanya untuk memberi sedikit variasi pada cetakan ke layar, juga untuk pemisah antara keterangan awal dengan keterangan hasil dari program yang sudah diproses lebih lanjut. Dan untuk perulangannya sendiri mengapa perulangan tersebut terjadi 6 kali dan berbeda dengan perulangan sebelumnya (3x perulangan), ialah karena jumlah indeks pada variabel W ialah 6, dan nilai 6 tersebut didapat dari penjumlahan indeks variabel S dan E. Dalam perulangan ketiga yang dilakukan sebenarnya hanyalah pencetakan ke layar untuk isi variabel W, dan program tersebut dapat dijalankan tanpa adanya kedua kondisi if() seperti dalam contoh. Karena kondisi pertama hanyalah bertugas untuk memberi jarak seperti kondisi dalam perulangan sebelumnya, hanya saja pemberian jarak disini dilakukan 3 kali, karena pada kondisi if() kedua diberi baris baru setelah 3 indeks pertama. Dengan diberinya baris baru tersebut, maka jika perintah yang menggeser ke kanan hanya diberikan satu kali, maka 3 indeks berikutnya akan tetap berada di posisi sebelah kiri, maka dengan demikianlah pemberian jarak dari kiri dilakukan sebanyak 2 kali setiap 3 indeks. Dan mengapa dalam kodisi tersebut digunakan logika atau (ditulis || ), ialah karena perulangan dilakukan per indeks, tidak sekaligus, maka jika digunakan logika dan (ditulis && ), maka justru per tiga indeks tersebut tidak ada yang bergeser satupun ke kanan.

Saturday 27 August 2016

Mengalikan isi array 1 dimensi

Untuk materi kali ini kita akan membahas mengenai perkalian array 1 dimensi. Pada perkalian array satu dimensi ini kita akan menggunakan dua metode, yaitu pengalian untuk angka-angka yang terdapat dalam array yang sama (se-array), dan dalam dua array. Untuk metode yang pertama (dalam array yang sama) kita akan menggunakan metode yang sama seperti pada topik sebelumnnya, yaitu dalam penjumlahan isi array. Dalam metode tersebut memang sama saja algoritmanya, namun untuk pengalian sendiri memiliki sedikit perbedaan dengan penjumlahan, dimana apabila dalam penjumlahan, untuk variabel yang akan menampung isi hasil penjumlahan tersebut diberi nilai awal 0 agar tidak mengubah keadaan (jika diberi nilai awal selain nol maka hasilnya akan berbeda, karena angka selain nol jika ditambahkan dengan angka lain maka angka lain tersebut akan berubah nilainya, lain halnya dengan angka 0). Dan dalam perkalian sendiri kita tidak lagi dapat menggunakan nilai awal 0, karena setiap angka yang dikali dengan 0 maka hasilnya akan 0, dengan demikian pada proses perkalian ini untuk variabel yang akan menjadi lokasi nilai akhir (hasil) akan diberi nilai awal 1. Mengapa demikian? Karena setiap angka yang dikalikan dengan angka 1 maka hasilnya tidak akan berubah. Lalu untuk apa dikalikan jika hasilnya tidak berubah? Disini kita hanya memberi nilai awal 1 pada variabel penampung hasil, sedangkan yang akan dikalikan ialah yang ada dalam array, jadi memang sudah seharusnya variabel penampung hasil hanya bertugas untuk menampung hasil, bukan mempengaruhi proses yang diinginkan. Perhatikan contoh berikut:

#include<stdio.h>
main(){
int a, S[3]={2,4,5}, jumlah=1;

for(a=0; a<3; a++){
jumlah=jumlah*S[a];
}
printf("\n%3i", jumlah);
}

Dalam contoh program tersebut terlihat sebuah program yang menghitung dengan inisialisasi variabel penampung hasil 1. Untuk proses input dapat dilakukan dengan menambahkan metode perulangan setelah deklarasi dan inisialisasi pada contoh diatas. Dan untuk proses dalam pengalian diatas ialah dengan memberi perintah for(a=0; a<3; a++){ jumlah=jumlah*S[a]; }. Dalam perintah tersebut maka variabel jumlah yang bernilai awal 1 akan dikalikan dengan isi dari tiap indeks variabel S. Dalam perulangan pertama maka nilai 1 yang terdapat dalam variabel penampung hasil (variabel jumlah) akan dikalikan dengan angka yang terdapat dalam indeks 0 variabel S. mengapa dikalikan dengan indeks 0 terlebih dahulu? Lihat nilai awal untuk perulangan, terdapat perintah inisialisasi a=0, maka indeks array yang akan diproses ialah dari indeks 0. Dan dengan demikian angka 1 dalam variabel jumlah akan dikalikan dengan angka 2 pada variabel S dengan indeks 0, hingga isi dari variabel jumlah berubah menjadi 2, karena 1 dikalikan dengan 2 ialah =2. Begitupun dengan perulangan berikutnya, angka 2 yang telah terdapat dalam variabel jumlah akan dikalikan dengan isi dari variabel S indeks ke 1 yang isinya ialah angka 4, hingga hasil dari perkalian dalam perulangan kedua itu ialah angka 8, dan angka 8 tersebut akan menggantikan angka 2 yang terdapat dalam variabel jumlah pada perulangan sebelumnya. Dan pada perulangan terakhirpun tidak ada bedanya (perulangan ketiga yaitu indeks ke 2, karena walau isinya ada 3 angka, namun karena indeks tersebut dimulai dari angka 0 maka indeks terakhirnya bukanlah indeks ke 3 namun 2, karena 0-2 mengandung 3 hitungan didalamnya, ialah 0, 1 dan 2), pada perulangan terakhir ini angka 8 yang terdapat dalam variabel jumlah akan dikalikan dengan angka ke tiga atau indeks ke 2 dalam variabel S, dimana indeks ke 2 tersebut mengandung angka/nilai 5. Maka pada hasil akhir, nilai yang terkandung dalam variabel jumlah ialah 40, dan pada saat dicetak ke layarpun 40, karena 2*4*5 = 40. Dengan demikian telah terbukti bahwa memang inisialisasi untuk variabel jumlah harus dengan angka 1 agar keadaannya tidak berubah. Bukan berarti karena pada topik sebelumnya (menjumlah isi dari variabel array) kita memberi nilai awal 0, maka untuk perkalianpun harus memberi nilai awal yang sama, sungguh salah, karena ini bukan perintah default dari program, justru program inilah yang kita buat, apa yang kita buat ialah harus disesuaikan dengan apa yang kita maksud/kita butuh. Dengan demikian, kembali seperti yang biasa penulis sampaikan bahwa semua itu bergantung pada algoritma yang digunakan, penulispun memberi nilai awal seperti itu dengan perintah-perintah yang demikian tidak lain hanyalah menyesuaikan dengan program yang dibuat, jika pembaca memiliki algoritma lain untuk program perkalian seperti ini, silahkan digunakan/dicoba dituangkan pada programnya, karena banyak sekali alur pikir yang digunakan dalam membuat program yang sama, seperti halnya dalam mengerjakan soal matematika, banyak rumus yang dapat digunakan untuk menyelesaikan sebuah soal, kembali pada yang mengerjakan soal tersebut akan menggunakan rumus yang mana. Seperti pada progam yang sama, ada cara lain yang sudah penulis siapkan sebelumnya, dimana program yang dimaksud ialah sebagai berikut:

#include<stdio.h>
main(){
int a, S[3]={2,4,5}, jum=1;

for(a=0; a<3; a++){
jum*=S[a];
}
printf("\n%3i", jum);
}
Mari bandingkan dengan program sebelumnya, apa yang berbeda? Ya, yang berbeda hanyalah perintah untuk mengalikannya yang disimpan dalam perulangan. Jika dalam program sebelumnya proses yang dilakukan ialah mengisi nilai variabel jumlah dengan hasil perkalian antara variabel jumlah dengan setiap isi dari indeks variabel S / variabel array yang dimaksud, namun kali ini variabel jum / jumlah langsung dikalikan dengan setiap isi indeks variabel S, dan didalam perintah tersebut tertulis bahwa jum*=S[a] yang artinya jum dikali dengan apa yang ada dalam indeks variabel S dan hasil yang akan diperoleh jum ialah apa yang telah diproses terebut. Hampir sama saja dengan proses sebelumnya, namun pada jumlah=jumlah*S[a] ada proses pengisian pada variabel jumlah, dimana setiap hasil dari perkalian antara variabel jumlah dengan variabel S akan disimpan pada variabel jumlah, namun pada jum*=S[a] lebih tepatnya bukan diisikan, namun ditunjuk (walau memang sama saja dengan mengisikan, karena pada akhirnya akan dimasukan ke dalam variabel jum), lalu apa maksud ditunjuk tersebut? kata "ditunjuk" tersebut sesungguhnya ialah karangan atau pendapat dari penulis sendiri, karena pada perintah terebut walau dimasukan kedalam variabel jum, tetapi "jum dikali dengan S[a] dan isi dari jum ialah angka tersebut", angka yang dimaksud ialah angka hasil perkalian jum dengan S[a]. Sama saja memang pada dasarnya, namun jika diperhatikan lebih jauh, pada saat jumlah=jumlah*S[a] maka jumlah= (hasil perkalian) jumlah*S[a], tetapi pada jum*=S[a] maka tanda sama dengan yang ada ditengah tersebut seakan menunjuk langsung atau menegaskan bahwa apa yang akan dikalikan dengan jum, itulah hasil akhir jum, dan yang dikalikan dengan jum ialah S[a]. Tetapi itu sebenarnya hanya pendapat penulis, jika memang pembaca memiliki pendapat lain atau menganggap kedua program tersebut sama saja ya silahkan, tidak masalah, justru dengan pendapat itulah mungkin yang nantinya akan membuktikan bahwa pembaca sudah mengerti akan alur programnya / bahkan mungkin lebih mengerti dari penulis sendiri. Dan satu lagi, selain seperti pada contoh program diatas, ada cara lain untuk memberikan perintah yang sama pada program, ialah dengan memberi nilai awal jum=S[0] dan for(a=1; a<3; a++){ jum*=S[a]; } namun jangan lupa, apabila jum sudah diberi nilai awal S[0] maka tidak perlu lagi perulangannya dilakukan dari indeks ke nol, karena indeks ke 0 sudah terdapat dalam jum, tinggal saja mengalikan dengan yang ada dalam indeks berikutnya.

Selain perkalian yang dilakukan pada satu array, penulis ingin pula memberikan sedikit tambahan contoh mengenai pengalian dengan dua array yang berbeda berikut sedikit tambahan mengenai inputan dengan perulangan seperti yang dimaksud dalam sebuah kalimat diatas (bisa dibilang paling atas setelah contoh program pertama). Namun untuk contoh program berikut ini, tidak akan penulis jelaskan lagi alur yang digunakannnya, karena dirasa sama saja (hampir sama persis dengan perintah jumlah=jumlah*S[a] ), namun perbedaannya jika dalam contoh program tersebut Variabel S dikalikan dengan variabel jumlah (variabel penampung hasil sebagai bantuan), pada program kali ini tidak lagi ada pengalian dengan variabel penampung hasil tersebut, namun langsung dikalikan dengan variabel array yang satunya (proses kali dilakukan antara array pengali dan yang dikali). Dengan kata lain variabel jumlah tidak lagi harus ikut campur untuk proses perkalian, tetapi disisi lain Anda harus mempersiapkan sebuah array baru yang akan menampung hasil tersebut, karena hasil kalinya pun akan berbentuk array, lain halnya pada contoh program diatas yang hasilnya bukan lagi array. Perhatikan contoh berikut:

#include<stdio.h<
main(){
int c, A[3]={1,2,3}, B[3]={12,6,4}, C[3];
printf("\n3 angka pertamanya ialah:\n");

for(c=0; c<3; c++){
printf("%3i", A[c]);
}
printf("\nDan akan dikalikan dengan:\n");

for(c=0; c<3; c++){
printf("%3i", B[c]);
}
printf("\n\nHasil perkaliannya ialah:\n");

for(c=0; c<3; c++){
C[c]=A[c]*B[c];
printf("%3i", C[c]);
}
}
Dan dapat pula dilakukan tanpa bantuan array kosong sebagai array baru yang dikhususkan untuk menampung hasilnya tersebut, seperti pada contoh diatas, Anda dapat saja tidak lagi menggunakan C[3], Anda dapat menghapus deklarasi terebut, namun untuk perintahnya sendiri Anda harus mengorbankan salah satu array yang sudah ada yang menjadi bahan perkalian tersebut, misal Anda menggunakan perintah A[c]=A[c]*B[c]; bisa saja dengan cara seperti itu, dan untuk percetakannya tinggal disesuaikan. Namun penulis rasa cara seperti itu kurang efektif bahkan kurang enak untuk dilihatnya. Tetapi semua itu kembali pada pembut programnya sendiri.

Thursday 25 August 2016

Menghitung total isi array

Pada materi yang satu ini penulis ingin memperkenalkan cara untuk menghitung total isi aray. pada penghitungan total isi array disini masih tidak jauh berbeda dengan program-program sebelumnya yaitu memanfaatkan metode perulangan, dan penghitungan total isi arraynya pun masih mengenai array satu dimensi. Dalam penghitungan isi array ini tidak banyak menggunakan perintah, dan variable yang digunakannya pun hanyalah dengan menambakan sebuah satu yaitu variable untuk menyimpan hasil perhitungan isi arraynya tersebut. Untuk prosesnya sendiri seperti yang baru saja dikatakan bahwa pertama kali dilakukan ialah menyiapkan variable arraynya, baik itu variable yang langsung diisi dengan cara inisialisai, maupun melalui proses input dari user. Dan selain variable array, disiapkan pula variable untuk proses perulangan yang nantinya akan diberi nilai awal dalam perulangan itu sendiri, diberi kondisi berikut perubahan kondisinya. Serta tidak kalah pentingnya dalam program yang satu ini ialah menyiapkan variable untuk menyimpan nilai total dari isi array yang dijumlahkan. Variable untuk menyimpan nilai total tersebu wajib diberi nilai awal terlebih dahulu sebelum diproses lebih lanjut layaknya variable untuk menghitung jumlah pada program mencari jumlah karakter yang sesuai dengan inputan. Jika variable tersebut tidak diisi nilai awalnya, maka pada saat dicetak akan menampilkan angka sembarang. Maka dengan demikian, alangkah lebih baiknya jika memberi nilai awal 0 pada variable tersebut. Setalah semua variable tersebut selesai dideklarasi dan diberi nilai awal, maka proses selanjutnya ialah langsung pada perulangan. Untuk perulangan sendiri dilakukann sebanyak jumlah indeks arraynya, dan didalam perulangan tersebut akanada sebuah perintah untuk menjumlah setiap isi array dengan perintah yang mengharuskan program untuk mengisikan setiap isi dari variable array tersebut kedalam variable penampung total penjumlahannya. Namun dalam perintah ini, program tidak sebatas mengisikan seluruh isi dari tiap indeks array kedalam variable penampung total, melainkan menjumlahkan semua variable yang diisikan tersebut. Jadi dengan kata lain perintahnya tidak hanya mengisikan karakter kedalam variable penampung total, namun juga sembari menjumlahkannya. Lain halnya dengan proses inisialisasi yang selanjutnya diisikan hasil inputan, pada hal tersebut nilai yang terkandung dalam proses inisialisasi akan terganti dengan nilai barunya dari proses input, namun pada hal ini semua yang diisikan akan digabungkan, dengan semikian nilai awalnyapun tidak akan hilang, tetapi digabungkan dengan nilai-nilai baru melalui proses perulangan. Perintah yang digunakan untuk menjumlahkan sendiri ialah dengan menuliskan "total=total +variable[indeks]", dengan perintah yang sederhana tersebut maka setiap isi dari indeks array akan tergabungkan dengan sendirinya. Tapi tetap, seperti biasa bahwa indeks yang dimaksud harus sesuai dengan nama variable yang digunakan untuk perulangannya. Mengapa harus sama dengan nama variable yang digunakan dalam perulangan? Karena saat dalam perulangan tersebut, untuk mengindeks variable arraynya ialah memanfaatkan indeks dari variable perulangan. Apa maksud dari indeks variable perulangan? Ya, tentu saja yang dimaksud disini bukanlah karena perulangan mengandung array. Namun karena perulangan tersebut telah disesuaikan antara jumlah perulangannya dengan jumlah indeks pada variable array yang diproses. Dengan demikian untuk mengindeks si array tersebut memang menggunakan hitungan dari perulangannya. Dalam setiap perulangan yang berjalan, maka akan mempengaruhi setiap deret array, dan jelas akan satu persatu. Seperti pada saat menginput, missal menginput 5 angka tanpa menekan enter dari setiap angkanya, maka inputan tersebut dianggap untuk mengisi sebuah indeks saja, berbeda dengan saat diberi enter setelah menginput per angkanya, maka program akan menganggap setiap angka tersebut memiliki indeks yang berbeda. Oke mari kembali pada pembahasan program. Setelah perulangan selesai, maka variable yang menampung total perhitungan tersebut sudah terisi dengan jumlah yang diinginkan, dengan kata lain kita hanya tinggal mencetak informasi hasilnya ke layar. Nah untuk percetakannya sendiri kita tidak lagi menggunakan perulangan, karena dalam percetakan sebuah total hitungan maka kita hanya akan mencetak satu variable yaitu variable penampung total hitungan tersebut, maka dengan demikian kita hanya tinggal mencetaknya tersendiri diluar perulangan. Ya memang bisa saja dicetak dalam perulangan, namun kurang efektif jika mencetak satu perintah saja harus menggunakan perulangan. Apalagi jika perulangannya berlangsung dalam jumlah yang banyak, maka programpun akan mencetaknya banyak padahal yang kita perlukan hanya satu. Terkecuali jika memang perulangan tersebut diperlukan (program diminta untuk mencetak beberapa cetakan ke layar). Setalah semua proses tersebut berjalan lancar, maka dapat dikatakan bahwa program tersebut selesai (sukses). Apakah ada yang dibingunkan dari keterangan diatas? Oke jika memang masih bingung dengan kata-kata yan diberikan, maka lebih baik jika kita membahasnya lebih lanjut melalui contoh program. Perhatikan contoh berikut ini

#include<stdio.h>
main(){
int I[5]={15,25,20,5,35}, o, tot=0;

for(o=0; o<5; o++){
tot=tot+I[o];
}
printf("%i", tot);
}

Pada contoh program tersebut terlihat apa yang kita bahas diatas tertera semua, dari mulai deklarasi dan inisialisasi variable array (inisialisasi tersebut lebih ditujukan untuk proses penghitungan, karena tidak ada yang diinput dan maka yang akan dihitung ialah angka-angka yang ada didalamnya tersebut. Selain itu terdapat huruf o sebagai variable yang selanjutkan membantu proses perulangan. Setelah itu terdapat deklarasi yang disertai inisialisasi untuk variable penampun total hitungan. Variable tersebut seperti yang sudah dibahas diatas wajib untuk diberi nilai awal, dan nilai awalnya yang diperlukan dalam program ini ialah angka 0, yang jika nanti dijumlahkan dalam proses berikutnya tidak akan mempengaruhi jumlah isi variable array. Karena apapun yang ditambahkan nol maka angka tersebut tidak berubah. Tapi disini bukan berarti boleh kosong, tetap harus diisi walau angka itu bernilai 0. Setelah semua intro (deklarasi dan inisialisasi) dilakukan, maka program akan melanjukan pada proses perulangan (karena tidak ada proses lain lagi sebelum berulangan dan sesudah deklarasi tersebut). Dalam perulangan terlihat ada proses penjumlahan yang mana jumlah dari hitungan tersebut akan disimpan dalam variable tot (penampung total). Dikarenakan variable tot bernilai 0, maka saat perulangan pertama variable tot akan terisi dengan isi array pada indeks pertama (tidak berubah), lalu pada perulangan kedua dan seterusnya angka yang terkandung dalam variable tot tersebut akan digabungkan dengan tiap isi indeks berikutnya pada variable array. Dengan demikian sudah jelas bahwa pada saat perulangan berakhir, semua isi variable array sudah terjumlahkan dengan rapid an tersimpan dalam variable tot. maka daripada itu sudah jelas bahwa yang harus dilakukan ialah tinggal mencetak hasil tersebut. Memang tidak begitu sulit kelihatannya, namun berhati-hatilah dalam deklarasi variable penampung total hitungan, karena sebagian orang (termasuk penulis) sering kali lupa untuk memberi nilai awal, hingga pada saat program dijalankan seakan terjadi error dengan informasi yang tidak akurat, padahal kesalahannya hanya satu kurang tanda sama dengan berikut nilai awalnya untuk variable yang dimaksud. Dan selain daripada itu, untuk menjumlah jangan lupa menuliskannya tot=tot+I[o], jangan sampai karena lupa langsung saja menulisnya tot+I[o], karena dengan perintah tersebut perintah penjumlahan tidak akan berjalan, dengan kata lain yang akan tercetak pada layar hanyalah nilai awal dari variable tot tersebut (hanya angka 0). Terkecuali jika menuliskan perintahnya tot+=I[o], karena perintah tersebut dapat digunakan untuk menjumlah. Dengan kata lain perintah tot+=I[o] sama dengan tot=tot+I[o]. silahkan dipilih salah satu, karena keduanya sama dalam hal menjumlah. Hanya saja dipilih, tidak perlu ditulis keduanya. Dan apabila Anda memiliki algoritma lain untuk menjumlah, maka itu akan lebih baik. Bukan karena tidak boleh menggunakan program ini, tetapi semakin algoritma Anda terlatih, maka semakin mudah Anda dalam memahami setiap program yang dibuat, dengan demikian tidak akan lagi ada rasa bingung saat program yang Anda buat bermasalah.

Menyalin isi array satu dimensi

Menyalin isi array satu dimensi dapat dilakukan dengan menggunakan perulangan dan tidak lagi seperti pada program sebelumnya yang harus mengandalkan kondisi untuk selection, karena pada program yang satu ini tidak ada lagi diperlukan perintah untuk mengecek apapun, yang diperlukan ialah perintah untuk menyalin isi sebuah array ke array lainnya. Dan yang pertama dilakukan dalam deklarasi dan inisialisasi pun hanyalah mendeklarasikan sebuah variabel untuk membantu proses perulangan, deklarasi dan inisialisasi variabel array pertama (jika memang tidak menggunakan proses input dari user), serta mendeklarasikan sebuah variabel array yang akan menjadi tempat penyalinan isi array yang sebelumnya tersebut. Perhatikan contoh program berikut:

#include<stdio.h>
main(){
int a, S[5]={2,4,1,9,7}, C[5];

for(a=0; a<5; a++){
C[a]=S[a];
}

for(a=0; a<5; a++){
printf("%3i", C[a]);
}
}

Dalam contoh program tersebut terlihat proses pertama yang dilakukan ialah deklarasi variabel untuk membantu perulangan serta variabel array yang menjadi tempat penempatan hasil salinan isi dari variabel array lainnya, dan tidak lupa tentunya mendeklarasikan variabel array yang juga diberi nilai awal. Proses inisialisasi ini tidak diwajibkan, karena ini dilakukan hanya sebab tidak adanya proses input dari user, andai ditambah inputan, maka inisialisasi ini bisa dibiarkan dan bisa juga dikosongkan seperti variabel array C. Mengapa dapat dilakukan proses input tanpa dikosongkan terlebih dahulu isi dari variabel array tersebut? Karena yang namanya nilai awal, jika diberi nilai baru maka nilai itu akan terganti dengan sendirinya. Perhatikan contoh program berikut ini:

#include<stdio.h>
main(){
int a, S[5]={2,4,1,9,7}, C[5];

for(a=0; a<5; a++){
scanf("%i", &S[a]);
}

for(a=0; a<5; a++){
 C[a]=S[a];
}

for(a=0; a<5; a++){
printf("%3i", C[a]);
}
}
Dalam program tersebut jelas inisialisasi tetap dilakukan, namun lihat pada perulangan pertama, pada perulangan tersebut dilakukan proses input untuk user, dan hasil input tersebut dimasukan kedalam variabel array yang sudah terisi dengan nilai sebelumnya. Apakah keduanya (antara nilai awal dengan hasil input) akan terjumlahkan? Tentu saja tidak, karena dalam proses ini user hanya mengisikan inputannya kedalam variabel array tersebut, tidak dilengkapi dengan proses penjulahan didalamnya. Lalu dikemanakan nilai awal tersebut jika memang akan terganti dengan suatu nilai yang baru? Nilai tersebut akan tetap tertulis di program sebagai nilai awal, hanya saja setiap kali user melakukan proses input, maka nilai tersebut akan dianggap hilang/tergantikan, dengan kata lain dapat dikatakan bahwa nilai tersebut sudah dianggap tidak ada lagi dalam melanjutkan proses berikutnya (nilai yang sudah tergantikan tersebut tidak akan lagi diproses, yang diproses ialah nilai barunya). Dan dengan demikian, apabila program tersebut dicetak ke layar, maka akan tampil seperti berikut ini:

Saat diinputkan angka 1 sampai 5 akan tampil:

1 2 3 4 5
Mengapa demikian? Mengapa tidak ada sama sekali pengaruh nilai awal yang sudah disisipkan sebelumnya? Jelas karena yang namanya nilai awal jika diberi nilai baru akan menjadi diabaikan, seperti saat Anda memiliki kartu pelajar di sekolah dasar, lalu pada saat SMP Anda diberikan kartu pelajar yang baru, maka kartu pelajar Anda yang SD tersebut tidak lagi berlaku/tergantikan dengan kartu pelajar yang baru. Begitupun dalam program yang satu ini, nilai awal tidak akan mempengaruhi nilai yang baru, terkecuali jika memang nilai baru tersebut tidak ada. Tapi untuk apa kita selalu melakukan pemberian nilai awal pada variabel yang akan diproses selanjutnya jika nilai awal itu sendiri akan tergantikan pada proses tersebut? Ya, memang untuk program yang ini nilai awal tidak begitu penting, Anda dapat membuat sebuah program inputan tanpa harus memberikan nilai awal terlebih dahulu. Namun untuk beberapa program lain, ada yang memang diwajibkan memberi nilai awal terlebih dahulu sebelum diproses lebih lanjut. Seperti halnya pada saat mencari nilai maksimum, apabila pada variabel yang akan digunakan untuk menampung nilai maksimum tersebut tidak diberi nilai awal terlebih dahulu, maka pada saat program dijalankan akan terjadi error karena akan menampilkan angka sembarang pada layar. Seperti contoh berikut ini:

#include<stdio.h>
main(){
int a, S[5]={1,2,3,4,5}, maks;

for(a=0; a<5; a++){
if(S[a]>maks){
maks=S[a];
}
}
printf("\n%3i", maks);
}
Jika program diatas dijalankan, maka yang akan tampil di layar ialah angka sembarang, bukan angka 5 seperti yang diinginkan. Perhatikan saja dalam deklarasinya, tertulis maks dan hanya tertulis "maks". Lain halnya dengan pada saat Anda ganti dengan "maks=0 atau maks=S[0]", maka pada saat program tersebut dijalankan akan menampilkan angka yang sesuai dengan semestinya, yaitu angka 5. Dan bukan hanya dalam hal pencarian nilai maksimum, masih banyak lagi program yang memang mewajibkan untuk penggunaan inisialisasi. Dengan demikian terbukti bahwa walau variabel tersebut akan memiliki nilai baru nantinya, namun proses inisialisasi tidak dapat dikatakan tidak penting.

Sekilas untuk tambahan, bahwa pada contoh program diatas (contoh program paling atas / yang pertama) terlihat antara perulangan untuk menginput dengan perulangan untuk menyalin dipisahkan, namun sesungguhnya untuk mempersingkat program dapat maka kedua proses tersebut dapat dilakukan dalam satu perulangan. Dan untuk program diatas memang dibuat untuk memperjelas saja akan kedua prosesnya. Untuk penggabungan proses dalam satu perulangan tersebut dapat dilakukan seperti berikut:

for(a=0; a<5; a++){
scanf("%i", &S[a]);
C[a]=S[a];
}
Namun sedikit catatan untuk potongan program tersebut, walau memang hanya tinggal meletakan proses penyalinan dibawah perintah untuk inputan, namun jangan sesekali menyimpan perintah untuk penyalinan tersebut diatas perintah input, karena jika demikian, yang akan disalin bukanlah apa yang diinputkan, namun justru nilai awal pada inisialisasi pertama. Mengapa demikian? Karena proses penyalinan dilakukan dalam perulangan, maka dengan begitu proses akan terus berdampingan. Jika pada perulangan pertama dilakukan penyalinan isi array S pada indeks pertama sebelum adanya perubahan dalam perulangan tersebut, maka nilai pada indeks pertama array S masih angka 2 seperti yang tertera dalam inisialisasi, setelah itu barulah terjadi perubahan karena diikuti dengan proses input untuk mengisi array tersebut. Dengan demikian, apabila perintah untuk menyalin tersebut diletakan diatas perintah input, maka hasil yang terjadi sebagai berikut:

isi dari array S = (sesuai dengan inputan)

isi dari array C ialah deret angka 2 4 1 9 7 sesuai dengan nilai awal array S
Maka dengan demikian hindarilah penyimpanan perintah seperti itu, terkecuali jika hanya untuk mencoba, karena lebih baik mencoba untuk pengetahuan lebih daripada tidak tahu apa-apa. Dan sekilas tambahan untuk masalah inputan isi variabel array, mengapa harus dilakukan dalam perulangan? Karena jika diluar perulangan, maka indeks array yang akan terisi hanyalah satu indeks yang ditentukan. Seperti contoh berikut ini:

scanf("%i", &S[0]);
Pada perintah tersebut dapat dilakukan diluar perulangan, namun perhatikan perintah tersebut, tertulis input untuk variabel S ke 0, yang artinya hanya satu indeks yang disikan inputan. Maka jika perintah tersebut disisipkan pada program diatas dan menghapus perulangan untuk input yang sudah ada, maka apabila program tersebut dijalankan, yang akan tampil pada layar ialah:

(inputan) 4 1 9 7
Maka dengan demikian dapat disimpulkan bahwa proses input isi variabel array dilakukan hanya untuk mempersingkat program (membuat program lebih simple/praktis). Karena jika tanpa bantuan perulangan, untuk mengginput indeks yang banyak harus ditulis satu persatu perintahnya. Jika pada contoh tersebut hanya menginput indeks ke 0, maka dalam program tersebut kita harus menulis 4 perintah yang sama untuk indeks lainnya. Repot bukan? Ya, apalagi itu baru 5 indeks, bayangkan apabila indeks yang tersedia jumlahnya puluhan atau ratusan. Mungkin jari-jari Anda dapat mendadak berotot setelah pembuatan program tersebut selesai. Maka dengan demikian, penulis sangat menyarankan untuk proses inputan isi variabel array dilakukan dengan bantuan perulangan, terkecuali jika memang inputan yang dilakukan hanya untuk indeks-indeks tertentu (ditentukan).

Searching nilai minimum dan maksimum

Setelah sebelumnya kita membahas tentang pencarian jumlah dari karakter sesuai antara inputan dengan yang terdapat dalam variabel array serta mencari indeks dari sebuah karakter dalam array, kali ini akan dibahas mengenai cara mencari nilai maksimum dan minimum dalam variabel array dengan menggunakan metode perulangan dan selection seperti pada program sebelumnya. Dalam program kali ini kita hanya menambahkan sedikit lagi perintah untuk menyeleksi setiap nilai yang terdapat dalam elemen array. Dan untuk mencari nilai maksimum serta minimum tentunyna kita akan menggunakan tipe data integer, karena dengan tipe data integer maka angka-angka yang terdapat didalam indeks array dapat dihitung dan dibandingkan bobot dari setiap nilainya. Serta untuk variabel yang akan diisikan nilai maksimum itu sendiri sebelum diproses harus diberi nilai awal terlebih dahulu. Nilai awal dapat diisikan seperti biasa, misal kita menggunakan variabel dengan nama "max", maka max dapat diberi nilai awal max=0 atau berapapun angkanya yang pasti diusahakan angka terendah dan tidak lebih besar dari nilai yang ada dalam variabel array. Namun untuk penulisan inisialisasi yang langsung dengan angka seperti itu penulis sarankan lebih baik manggunakan max=0 atau dengan kata lain max diberi nilai awal 0, karena dikhawatirkan pada saat max diberi nilai awal (misal) 10 dan ternyata user hanya menginputkan nilai antara angka 1 sampai dengan 5, dengan demikian user tidak menemukan nilai maksimal dari inputannya, karena yang akan tercetak ke layar nilai maksimalnya ialah 10 (nilai awal yang ternyata lebih besar dari nilai yang diinputkan. Selain penggunaan nilai awal dengan angka langsung, pada program kali ini dapat pula memberi nilai awal dengan indeks. Bagaimana maksudnya? Ialah dengan memberi nilai awal seperti A[0] atau indeks lainnya, dengan demikian pembuat program tidak harus membingungkan lagi akan nilai awal yang harus ditentukan.

Setelah kita membahas algoritma dasar untuk membuat program pencari nilai minimum dan maksimum tersebut, alangkah lebih baik jika kita memahami bentuk dasar dari program tersebut. Karena dengan contoh, maka pembahasan akan lebih dirasa nyaman. Yang pasti jika hanya mengandalkan kata-kata pembahas tanpa adanya contoh, tentu hanya akan membuat pusing dan menimbulkan banyak pertanyaan, apa yang dimaksud dari bahasan tersebut?, oleh karena itu, berikut ini contoh program dasar dari untuk searching nilai minimum dan maksimum dengan pemrograman c:
Mencari nilai maksimum

#include<stdio.h>
main(){
int s, T[5]={1,24,97,100,22}, max=T[0];

for(s=0; s<5; s++){
if(T[s]>max){
max=T[s];
}
}
printf("Nilai maksimumnya adalah: %3i", max);
}
Mencari nilai minimum

#include<stdio.h>
main(){
int s, T[5]={1,24,97,100,22}, min=T[0];

for(s=0; s<5; s++){
if(T[s]<min){
min=T[s];
}
}
printf("Nilai minimumnya adalah: %3i", min);
}
Mari kita bahas untuk contoh program diatas. Dalam kedua contoh program diatas sungguh algoritmanya sama, hanya tinggal mengubah tanda lebih dari menjadi kurang dari. Karena pada dasarnya kedua program itu mengandung proses yang sama, hanya saja untuk nilai maksimum yang dicari ialah nilai yang paling tinggi, maka yang diseleksipun setiap kali angka yang lebih tinggi dari angka yang ditemukan pada perulangan sebelumnya. Dan seperti yang sudah dibahas sebelumnya bahwa yang dilakukan pertama ialah inisialisasi dan deklarasi. Dalam program diatas tidak ada inputan dari user serta nilai awal dari variabel arraynya pun sudah ditentukan, maka dari itu yang akan diseleksi nanti adalah nilai yang sudah ditentukan tersebut. Dan selain variabel array, disana terdapat inisialisasi variabel yang akan menjadi patokan atau menampung nilai maksimum/minimum dari hasil prosesnya nanti. Dan inisialisasi yang dilakukan ialah menggunakan metode nilai awal dari indeks pertama, dan sekali lagi, indeks pertama adalah nol bukan satu. Maka dalam program diatas terlihar bahwa min/max=T[0], yang artinya nilai minimum dan maksimum pertama kali diberi nilai awal yang diambil dari indeks ke 0 sebelum akhirnya diproses lebih lanjut lagi.

Setelah deklarasi dan inisialisasi dilakukan, kita melihat program langsung menuju perulangan, dimana dalam perulangan tersebut terdapat selection, yang mana statement didalamnya hanya ada statement true nya. Dan statement tersebut hanya akan diproses/dijalankan ketika angka yang ada dalam indeks pada perulangan lebih besar dari angka sebelumnya, baik itu angka yang ditemukan program dalam perulangan sebelumnya maupun angka yang sudah ditentukan dalam nilai awalnya. If(T[s]>max) dan if(T[s]<min) tersebut maksudnya ialah jika T pada indeks saat perulangan lebih dari max maka program akan menjalankan statement true yang ada didalamnya, begitupun sebaliknya untuk mencari nilai minimum. Maksud dari indeks saat perulangan sendiri ialah seperti misalnya pada perulangan pertama, maka nilai variabel s tersebut ialah indeks ke 0 dan T ke s (ditulis T[s] ) berisi nilai yang terkandung dalam indeks ke 0 tersebut. Selanjutnya akan di cek apakah pada indeks ke nol lebih besar dari nilai yang terkandung dalam variabel max. Begitupun pada perulangan berikutnya, pada perulangan kedua maka variabel s akan mengandung indeks ke 1 serta T ke s akan mengandung nilai yang ada dalam indeks ke 1 tersebut, dengan demikian akan ada pengecekan apakah nilai tersebut lebih besar dari max. Jika memang pada perulangan sebelumnya max tidak mengalami perubahan (nilai dalam index ke 0 tidak lebih besar dari max) maka nilai max tidak berubah, dan nilai yang ada pada T dalam indeks ke 1 akan dibandingkan dengan nilai awal max tersebut. Begitupun sebaliknya, andai nilai max sudah mengalami perubahan, maka dalam selection tersebut tidak akan membandingkan dua kali antara nilai awal max dengan perubahan tersebut, karena pada proses sebelumnya nilai max sudah berubah dengan sendirinya pada saat ditemukan angka yang melebihi nilai awalnya, dengan demikian T pada indeks ke 1 hanya tinggal dibandingkan dengan nilai max (nilai barunya). Dan begitupun dengan proses/alur untuk seleksi nilai minimum, proses yang dilakukan tidak jauh berbeda, hanya saja dalam pencarian nilai minimum yang akan diambil dan dimasukan pada variabel max ialah nilai-nilai yang ditemukan lebih kecil pada setiap perulangan yang dilakukan.

Pada program diatas kita hanya membahas mengenai proses seleksinya saja, tanpa ada inputan dari user karena nilai dalam variabel array sudah ditentukan sebelumnya. Tapi bukan berarti untuk menginput karakter dari user sama seperti pada program-program sebelumnya, karena pada program sebelumnya user hanya mencari nilai yang ada dalam variabel array, yang artinya pada variabel array itu sendiri sudah diberi nilai awal pada sebelumnya, dan user sudah bebas untuk menginput karakter dalam memastikan apakah ada atau tidak karakter yang diinputkannya tersebut dalam elemen array. Lalu bagaimana untuk variabel array yang hanya terdeklarasi dan isinya masih kosong? Semua itu akan dibahas disini, dimana untuk nilai yang yang ada dalam elemen array tersebut ialah hasil inputan dari user, dan tugas program ialah membantu user menentukan nilai tertinggi dan terendah dari inputannya tersebut. Untuk contoh perogramnya, mari perhatikan berikut ini:

#include<stdio.h>
main(){
int e, U[5], maksimum;
printf("Masukan 5 angka yang ingin dicari nilai maksimumnya: \n\n");

for(e=0; e<5; e++){
scanf("%i", &U[e]);
}
maksimum=U[0];

for(e=0; e<5; e++){
if(U[e]>maksimum){
maksimum=U[e];
}
}
printf("\nNilai maxnya: %3i", maksimum);
}

Untuk proses pencarian nilai minimum dan maksimum sudah dibahas diatas, namun pada kali ini yang perlu dijelaskan ialah proses untuk mencari nilai maksimum dan minimum yang diinputkan user, dimana yang paling utama untuk dibahas ialah proses inputnya, mengapa pada contoh program diatas inputannya dilakukan didalam perulangan? Karena untuk mengisi variabel array tidak hanya dilakukan dengan sekali menekan tombol enter. Dalam contoh program tersebut, ada sebuah variabel array yang berisikan 5 elemen yang masih kosong, dan user diminta untuk mengisi kelima elemen tersebut melalui input dari keyboard. Maka dengan demikian proses input dilakukan secara berulang (dengan perulangan) selama 5 kali perulangan, hingga semua elemen array dapat terisi. Dan setelah semua elemen tersebut terisi, maka program baru dapat menyeleksi nilai maksimum yang dicari.

Selain itu, ada sedikit tambahan, mengapa untuk mencetak hasil dari proses pencarian nilai maksimum dipisahkkan dari proses lainnya setelah perulangan dilakukan? Karena apabila program cetak tersebut dilakukan dalam perulangan, maka pada setiap kali dalam perulangan program menemukan angka yang lebih besar dari nilai awalnya, maka program akan mencetak semua itu hingga perulangan selesai. Serta dalam program inputan ini mengapa inisialisasi variabel max / maksimum dilakukan setelah inputan? Karena pada proses deklarasi, isi dari variabel array masih kosong / tidak jelas. Dan untuk menentukan U ke 0 pun tidak jelas jadinya, berbeda dengan setelah inputan, isi variabel array sudah ada dan U ke 0 sudah jelas. Kecuali jika nilai awalnya ditulis U=0, maka penulisan tersebut dapat dilakukan sebelum inputan (karena tidak mengandalkan isi variabel array).

Wednesday 24 August 2016

Searching indeks dalam variabel array

Dalam topik sebelumnya kita sudah membahas tentang perulangan dan pencarian untuk sebuah karakter yanng diinputkan oleh user, apakah karakter tersebut ada dalam indeks array, dan dalam program selanjutnya pun kita sudah mempelajari sedikit tentang pencarian jumlah karakter yang diinputkan user yang ada dalam variabel indeks tersebut. Untuk kali ini kita akan membahas tentang bagaimana untuk menginformasikan pada user akan indeks karakter yang dicarinya. Informasi indeks ini memang cukup sederhana, yaitu memberikan keterangan dimana karakter yang sesuai dengan inputan tersebut ditempatkan dalam sebuah elemen array. Dan untuk itu alangkah lebih baiknya jika kita memahami terlebih dahulu apa itu indeks, dan bagaimana proses pencarian indeks tersebut.

Mencari indeks merupakan sebuah proses pencarian lokasi karakter yang diinputkan user. Dimana pada saat kita menyusun sebuah elemen array tentunya indeks tersebut sudah tersusun dengan sendirinya. Seperti yang pernah dibahas sebelumnya, indeks pada elemen array bagaikan sebuah barisan prajurit, dimana terdapat dalam satu arah barisan yang memiliki alamat masing-masing. Dengan kata lain alamat tersebut dapat disebut dengan nomor urut. Namun apabila pada sebuah barisan biasanya urutan tersebut dimulai dari nomor 1, dalam array sendiri barisan tersebut memiliki indeks yang berawal dari angka 0. Dan untuk proses pencarian indeks sendiri tidak jauh berbeda dengan pencarian untuk jumlah karakter yang sesuai pada inputan user. Namun bedannya, apabila pada pencarian jumlah, maka setiap indeksnya dianggap bernilai 1, lalu kemudian nilai tersebut akan dijumlahkan satu dengan lainnya. Dan jumlah dari indeks tersebut merupakan informasi yang dapat diberikan pada user untuk sebuah pemberitahuan ada berapa karakter yang diinputkannya dalam variabel array. Nah pada pencarian indeks sendiri sama halnya dengan pencarian jumlah tersebut, hanya saja setiap indeks tidak dianggap bernilai 1 dan juga tidak dijumlahkan, tetapi justru indeks itulah yang akan diinformasikan langsung pada user. Lalu bagaimana untuk mencari indeks apabila indeksnya banyak? Sama seperti dalam program sebelumnya, kita akan menggunakan proses perulangan, dimana dalam perulangan tersebut akan disisipkan kondisi untuk selection/seleksi. Pada proses seleksi itu akan disesuaikan dengan inputan dari si user. Apabila karakter yang diinputkan user terdapat dalam elemen array, maka program akan menjalankan statement true yang terdapat dalam selection tersebut. Namun sebaliknya, apabila karakter yang telah diinputkan oleh user ternyata tidak ada yang sesuai dengan isi dari elemen array tersebut, maka kondisi untuk seleksi tersebut akan dilewatkan oleh program, atau apabila disisipkan statement false, maka program akan menjalankan statement tersebut. Untuk statement true sendiri berisikan sebuah perintah untuk mencetak indeksnya langsung, tidak harus menggunakan perintah lain dengan potongan program tambahan. Dengan demikian maka si indeks akan dengan sendirinya menjadi informasi untuk user akan lokasi dimana karakter tersebut disisipkan dalam sebuah elemen array. Untuk perintah mencetak indeks sendiri tidaklah sulit, hanya dengan memanfaatkan variabel yang digunakan untuk proses perulangan serta menggunakan sebuah fungsi untuk cetak. Sebagai contoh, pada saat kita menuliskan perulangan dengan menggunakan:
 for(i=0; i<3; i++);
maka dalam program tersebut kita dapat memanfaatkan variabel i sebagai penunjuk indek, karena dengan perulangan yang kita gunakan tersebut, kita telah mengindeks satu persatu dari isi sebuah array, maka untuk mencetaknya pun kita dapat menggunakan variabel tersebut.

Untuk lebih jelasnya, mari perhatikan contoh dari potongan program berikut:
for(i=0; i<4; i++){
if(A==B[i]){
printf("%3i", i);
}
}
Seperti yang sudah dijelaskan diatas, bahwa untuk membuat sebuah informasi akan lokasi sebuah variabel dalam array kita akan menggunakan sebuah perintah perulangan yang didalamnya akan disisipkan sebuah kondisi. Pada potongan program tersebut terlihat bahwa terdapat sebuah perulangan dengan menggunakan for() yang diisi sebuah kondisi if() dengan statement true didalamnya. Pada perulangan, terdapat variabel i sebagai variabel pendukung perulangan, dengan nilai awal, kondisi berikut perubahan kondisi yang disisipkan didalamnya. Dan didalam kondisi if(), terlihat ada variabel A dan B ke i (ditulis B[i] ). Walau memang didalam contoh tersebut hanyalah sebuah potongan program, tetapi sedikit penjelasan bahwa yang dimaksud disitu A merupakan variabel yang akan mengisi inputan dari user (sama seperti pada topik sebelumnya untuk pencarian jumlah variabel yang ada didalam array), sedangkan B ke i merupakan sebuah variabel yang berisikan elemen array dengan i sebagai penunjuk indeks dari array tersebut melalui sebuah perulangan. Dan didalam statement true pada kondisi if() tersebut terlihat fungsi printf() dimana isinya merupakan pencetakan sebuah tipe data integer dengan variabel i sebagai variabel yang isinya akan dicetak. Sedikit catatan bahwa untuk mencetak indeks harus menggunakan tipe data integer. Mengapa demikian? Karena jelas untuk nomor urut dari urutan sebuah array (indeks) maka akan berbentuk sebuah angka, urutan 0, 1, 2 dan seterusnya. Begitupun dengan deklarasi variabel i sebelumnya, harus juga dengan tipe data integer. Walau yang dicari oleh user serta yang terdapat dalam variabel array sendiri mengandung tipe data character, namun tetap untuk sebuah perulangan dan pencetakan indeks menggunakan tipe data integer. Integer merupakan tipe data yang berisikan angka-angka yang dapat dihitung, jadi walau tipe data character dapat menampung angka pula, tetapi untuk tipe data character tersebut, angka yang terdapat didalamnya tidak dapat dihitung, seperti halnya pada saat kita menuliskan nomor induk, kita dapat menggunakan tipe data character karena nomor induk angkanya bukan untuk dihitung. Namun pada kasus matematika seperti penjumlahan, perkalian dan hal lainnya harus menggunakan tipe data integer.

Diatas kita sudah membahas sedikit potongan program untuk membahas algoritma dari pencetakan indeks array, namun untuk lebih lengkapnya mari perhatikan contoh program berikut ini:

#include<stdio.h>
main(){
char Q[5]="ucup", R;
int w;
printf("masukan inputan: ");
scanf("%c", &R);
for(w=0; w<4; w++){
if(R==Q[w]){
printf("\n\nAda dalam indeks ke %3i", w);
}
}
}

Dalam contoh program diatas, seperti contoh potongan program yang dibahas sebelumnya, antara kedua itu sama saja, hanya memiliki sedikit perbedaan yaitu dalam penamaan variabel. Namun untuk proses pencarian indeksnya sendiri sungguh tidak ada perbedaan, karena keduanya menggunakan algoritma yang sama. Dan dalam contoh program yang satu ini terlihat sebuah program lengkap dimana dimulai dari instruksi pra processornya yaitu include dengan nama file stdio.h yang artinya dalam program ini kita menggunakan bahasa C bukan C++. Dan diikuti dengan beberapa proses deklarasi berikut inisialisasinya. Dan seperti yang sudah dikatakan, setalah itu akan adanya proses input dari user sebelum proses lainnya dilanjutkan. Dan setelah user menginputkan sebuah karakter yang dicarinya dalam elemen array, maka program perulangan akan berjalan secara otomatis untuk menelusuri isi array dengan sebuah kondisi didalamnya yang akan menyeleksi apabila memang apa yang diinputkan oleh user terdapat dalam array. Dan dalam kondisi itu pula pencetakan informasi indeks untuk user dilakukan. Dan dalam program ini tidak terdapat perintah break seperti pada program sebelumnya. Mengapa demikian? Karena apabila kita menggunakan perintah break; maka pada saat program menemukan karakter yang sesuai dengan inputan user akan segera mencetak informasi indeks tersebut, namun indeks yang diinformasikan pada user hanya satu, yaitu indeks yang pertama kali ditemukan oleh program. Lain halnya dengan pada saat tidak menggunakan perintah break; (seperti pada contoh diatas), walaupun program sudah menemukan indeks dari karakter yang dicari, maka perulangan akan terus berjalan hingga kondisi (w<4) berakhir. Dan yang kan tercetak ke layarpun meliputi semua indeks yang menunjuk karakter dalam array tersebut, bukan hanya satu indeks yang pertama ditemukan. Dan apabila Anda mencoba program diatas, maka pada saat Anda menginputkan karakter "u" akan tercetak di layar sebuah informasi sebagai berikut:
Ada dalam indeks ke 0

Ada dalam indeks ke 2

Namun perlu diingat kembali bahwa program ini sangat sensitif pada perbedaan karakter, apabila menuliskan "U" pada inputan, maka tidak akan keluar informasi seperti pada contoh diatas, karena perbedaan antara huruf besar dan kecil. Dan soal indeks tersebut, perlu diingat kembali mengapa indeksnya 0 dan 2, karena indeks array dimulai dari 0 bukan 1. Maka huruf pertama dalam variabel tersebut akan berada pada indeks 0 dan huruf ketiga berada pada indeks ke 2.

Mencari jumlah karakter yang ada dalam variabel array

Searching jumlah angka yang ada dalam variabel array merupakan sebuah usaha untuk mencari tahu berapa banyak karakter yang sesuai antara hasil inputan dengan isi dari variabel array dengan karakter yang sama. Dalam program pencarian jumlah angka yang ada dalam variabel array ini pada dasarnya sama dengan proses pencarian yang dibahas pada materi sebelumnya, hanya saja dalam pencarian jumlah ini ada beberapa potongan program yang ditambahkan, namun bukan berarti ada pula yang diubah dari materi sebelumnya. Karena intinya sama saja, melakukan pencarian terlebih dahulu untuk variabel yang sama antara isi variabel hasil inputan dengan isi dari variabel array yang sudah ditetapkan, namun setelah pencarian tersebut dilaksanakan, ada proses didalamnya yaitu untuk menghitung seberapa banyak angka tersebut dalam variabel array. Jika dalam pencarian sebelumnya ada penggalan program yang memerintahkan untuk break ketika ditemukan sebuah karakter yang sama untuk membuat program lebih terlihat singkat, namun pada program kali ini penggunaan penanda seperti flag justru lebih mempersingkat sebuah program. Memang bisa saja menggunakan algoritma lain, tetapi untuk penulis sendiri sejauh ini merasa bahwa dengan menggunakannya penanda untuk program pencarian jumlah jauh lebih singkat. Mengapa demikian? Karena dalam perulangan yang tidak menggunakan perintah untuk break dapat disisipkan proses penghitungan jumlah tersebut.

Proses yang dilakukan sama halnya dengan pada program sebelumnya, yaitu pertama kali yang dilakukan ialah mendeklarasikan variabel array dan memberinya nilai awal, tidak lupa untuk mendeklarasikan variabel untuk input, untuk perulangan dan juga untuk penanda. Namun bedanya, dalam program untuk menghitung jumlah isi variabel yang sama dengan inputan ini ada tambahan deklarasinya, yaitu mendeklarasikan sebuah variabel yang nanti akan menjadi tempat dimana hasil penghitungan jumlah tersebut disimpan. Setelah deklarasi selesai, maka akan disisipkan perintah untuk input dari user, dimana programmer dapat menyisipkan pula pada sebelumnya sebuah cetakan kalimat yang mengarahkan user untuk melakukan inputan tersebut dengan perintah printf atau yang lainnya. Lalu seperti yang biasa dilakukan pada saat pencarian karakter akan keberadaannya, kita dapat menyisipkan program perulangan yang dimana perulangan tersebut akan dilakukan sejumlah karakter yang ada dalam variabel array. Didalam perulangan sediri disisipkan sebuah kondisi untuk seleksi, seperti contoh program sebelumnya yang menggunakan kondisi if untuk proses seleksi tersebut. Proses seleksi dilakukan untuk mengecek isi array per-indeksnya, apakah hasil inputan yang dilakukan oleh user memiliki karakter yang sama dengan isi dari varabel array yang sudah disediakan tersebut. Namun dikarenakan dalam program yang dibahas ini tidak menggunakan perintah break, maka dalam kondisi if ini dapat disisipkan pula perintah untuk menghitung jumlah dari isi array yang sama tersebut. Hingga pada saat proses perulangan tersebut berakhir, maka akan diadakannya seleksi lanjutan, dimana pada proses seleksi ini sama seperti contoh program sebelumnya (posted yang diberi judul pencarian isi variabel array [ada dan tidak ada]), yaitu proses seleksi yang bukan untuk mengecek kesamaan dari inputan dengan isi variabel array, melainkan untuk mengecek apakah si penanda telah mengalami perubahan. Apabila si penanda sudah memiliki perubahan, maka dalam statement true terdapat perintah untuk memberitahukan user bahwa karakter yang dicarinya ada. Dan untuk mempersingkat program, maka dalam statement true ini dapat disisipkan pula perintah untuk mencetak hasil hitung jumlah dari isi variabel yang sama tersebut. Dan apabila ternyata isi dari variabel penanda tersebut justru tidak memiliki perubahan apa-apa, maka akan manuju statement false, dimana dalam statement tersebut terdapat perintah untuk mencetak / memberitahukan user bahwa karakter yang dicarinya tidak ada. Dan sebenarnya untuk perintah-perintah cetak informasi pada user tersebut tidak wajib, itu hanya jika diperlukan saja, karena itu bukanlah bagian dari proses pencarian maupun proses penghitungan jumlah yang dimaksud, itu hanyalah sebuah informasi yang diberikan oleh program agar user mengetahui hasil dari proses tersebut. Dan demikian, kembalii ditegaskan bahwa proses utamanya ialah apa yang diinput oleh user dan apa yang dijalankan oleh program dalam perulangannya.

Mungkin akan terlalu membingungkan jika penulis hanya membahas melalui penjelasan, untuk itu berikut merupakan contoh program yang dimaksud penulis, silahkan dipahami dan disesuaikan kembali dengan apa yang dijelaskan diatas:

#include<stdio.h>
main(){
 char X[9]="goomilar", Y;
int g, jum=0, tanda=0;
printf("inputkan karakter: ");
scanf("%c", &Y);

for(g=0; g<5; g++){
if(Y==X[g]){
tanda=1;
jum++;
}
}

if(tanda==1){
printf("\n\nKarakter \"%c\" ADA", Y);
printf("\n\njumlah karakter \"%c\" adalah %i",Y, jum);
}else{
printf("\n\nKarakter \"%c\" TIDAK ADA", Y);
}
}

Dalam program tersebut terlihat bahwa yang pertama kali dilakukan ialah deklarasi variabel array dengan memberinya nilai awal, serta deklarasi variabel lainnya yang dibutuhkan serta inisialisasi variabel penanda berikut penghitung. Diikuti dengan pencetakan ke layar untuk pengarah pada user akan apa yang harus dilakukannya, dan itu dilakukan agar user memahami bahwa yang harus dilakukannya ialah menginputkan karakter dari keyboard. Ditemani dengan perintah scanf dimana user akan melakukan proses input karena adanya perintah tersebut. Dan proses untuk pencarian berikut penghitunganpun dilakukan dengan dibantunya perulangan yang mana dalam perulangan tersebut akan mengecek per-indeks array. Serta disisipkannya kondisi selection yang menjadi kunci utama pengecekan ada atau tidak adanya karakter yang diinput dalam array. Serta adanya sedikit tambahan perintah untuk menghitung jumlah karakter yang ada jika memang karakter tersebut benar ada. Dan apabila ternyata memang tidak ada karakter tersebut, maka proses perulangan akan melewati perintah tersebut. Dan seperti yang sudah disebutkan diatas, bahwa setelah proses perulangan selesai akan ada seleksi lanjutan untuk sang penanda, apakah ada perubahan dalam penanda tersebut, apabila ada akan diberitahukannya pada user bahwa karakter tersebut ada, disertai keterangan hasil hitung yang memberitahukan berapa jumlah karakter tersebut yang tersimpan dalam variabel array. Namun apabila program tidak menjalankan proses tersebut, yang dengan kata lain hanya menjalankan statement false dikarenakan tidak adanya perubahan dari si penanda, maka yang akan tercetak ke layar ialah pemberitahuan bahwa karakter yang diinputkan ternyata tidak ada dalam array.

Dan jika kembali kita bandingkan dengan posted sebelumnya, perbedaan program untuk mencari ada dan tidak ada dengan program yang satu ini hanyalah terdapat pada deklarasi+inisialisasi variabel untuk menghitung tambahan satu perintah untuk menghitung dalam perulangan serta untuk mencetak informasi jumlah tersebut. Untuk sisanya sungguh sama dengan program sebelumnya, hanya saja yang dilakukan oleh penulis ialah mengganti nama dari tiap variabel yang digunakan. Memang terlihat sedikit membingungkan, karena jika dibandingkan dengan contoh-contoh program sebelumnya, penamaan variabel dalam program yang satu ini terlihat asing. Namun penulis memiliki sedikit unsur kesengajaan, ialah agar pembaca tidak hanya berpatok dengan beberapa huruf yang biasa digunakan, dengan harapan agar pembaca tidak merasa asing dan kebingungan saat menghadapi sebuah program dengan penamaan variabel menggunakan huruf lain. Dan dengan demikian, lebih diharapkan lagi dari contoh-contoh yang diberikan dalam setiap post pada blog ini akan menghasilkan algoritma dan kepahaman yang baik dari pembaca, bukan sekedar cukup tau akan hasil bacaan yang ada. Karena akan sia-sia suatu hal yang penting untuk dimengerti namun tidak diperdalam lagi (hanya dibaca tanpa dicoba sendiri programnya). Maka dengan demikian, cobalah pahami setiap contoh program yang didapat, dan alangkah lebih baik lagi jika Anda mencoba untuk membuat program yang sama atau bahkan lebih baik lagi dengan algoritma Anda sendiri.

Mencari isi array (ada dan tidak ada)

Mencari ada dan tidak ada dalam program ini dimaksudkan untuk mencari sebuah isi dari variabel yang sudah ditentukan sebelumnya, apakah nilai yang diinputkan ada dalam variabel tersebut. Seperti pada saat menginisialisasikan sebuah variabel dengan tipe data character dan dalam variabel tersebut terisi dengan array berupa tulisan GOOMILAR, maka kita dapat mencari rangkaian huruf tersebut satu persatu dengan memanfaatkan metode perulangan. Dengan demikian kita dapat memastikan huruf yang kita cari tersebut ada ataukah tidak ada. Perhatikan contoh program berikut ini:

#include<stdio.h>
main(){
char A[9]="GOOMILAR", B;
int i, flag=0;
printf("masukan nilai yang ingin dicari: ");
scanf("%c", &B);

for(i=0; i<8; i++){
if(B==A[i]){
flag=1;
 }
}

if(flag==1){
printf("\n\nNilai yang Anda cari ADA");
}else{
printf("Nilai yang Anda cari TIDAK ADA");
}
}

Terlihat dalam program tersebut bahwa proses untuk mencari suatu nilai apakah ada atau tidak ada dalam variabel yang sudah diinisialisasikan sebelumnya ialah dengan cara membentuk sebuah array terlebih dahulu, sebuah kata "GOOMILAR" terlebih dahulu dibuat menjadi rangkaian huruf yang disimpan dalam sebuah variabel array, lalu setelahnya kita menentukan sebuah variabel untuk penanda. Pada contoh program diatas variabel yang digunakan untuk penanda diberi nama flag, flag bukanlah sebuah fungsi, flag hanya sebuah variabel yang digunakan untuk membantu proses pencarian karakter. Flag merupakan variabel yang dapat diganti dengan apa saja namanya. Flag dalam contoh tersebut diberi nilai awal 0, dan dalam kondisi if, untuk statement true maka flag diberi nilai 1. Namun pemberian nilai awal dan penentu nilai flag dalam kondisi if tersebut tidak harus sama dengan contoh yang diberikan diatas, itu hanya untuk penanda saja. Anda dapat mengganti nilai awal dan perubahan nilainya sesuai dengan yang Anda inginkan, namun dengan catatan harus sesuai antara perubahan nilai flag pada statement true dalam if pertama (if yang terdapat dalam perulangan) dengan seleksi yang dilakukan pada pernyataan if yang kedua (if yang terakhir / if yang setelah perulangan). Seperti misalnya Anda mengganti nilai awal flag yang tadinya 0 menjadi 86, dan Anda mengganti nilai flag pada statement true dalam perulangan menjadi 97, maka Andapun harus mengganti nilai flag pada seleksi if setelah perulangan menjadi 97 pula, karena itu yang menjadi patokan yang membantu kita melakukan pencarian tersebut.

Mari kita bahas satu persatu dari potongan program diatas. Pada pertama kalinya kita mendeklarasikan variabel array A dan memberi nilai awal "GOOMILAR". Lalu selanjutnya kita mendeklarasikan variabel B, dimana variabel B akan digunakan untuk menyimpan data inputan dari user. Dan berikutnya terdapat percetakan yang memberi arahan pada user untuk menginputkan suatu nilai yang dicarinya. Disamping itu, ada perintah untuk menginput dengan scanf, dimana user akan menginputkan karakter yang dicarinya lalu karakter tersebut akan disimpan dalam variabel B yang selanjutnya akan diproses. Setelah itu, kita menerapkan perintah untuk perulangan, dimana perulangan tersebut akan dilakukan sejumlah karakter yang ada dalam variabel array (variabel yang akan dicari). Dalam contoh diatas terlihat bahwa i bernilai awal 0 dan diakhiri dengan 7, setiap perulangannya nilai i ditambah 1. Maka perulangan akan dilakukan sebanyak 8 kali dari 0 hingga 7 (tidak sampai 8 kali, karena tertulis i<8 bukan i<=8). Dan didalam perulangan tersebut maka variabel array akan dicek per-indeksnya dengan kondisi if. Apabila isi variabel B (karakter yang diinputkan oleh user tadi dan sudah tersimpan dengan sendirinya pada variabel B saat ditekan tombol enter oleh user) sesuai dengan isi array dari variabel A, maka nilai flag yang tadinya 0 akan berubah menjadi 1, namun sebaliknya, apabila isi dari variabel B tidak sesuai dengan isi array dari variabel A, maka program akan melewatkan statement dalam kondisi if tersebut. Dengan demikian nilai flag tidak akan berubah, dengan kata lain nilai flag akan tetap 0 seperti nilai awal yang sudah diberikan sebelumnya. Setelah perulangan tersebut kita melihat ada kondisi if lagi dalam potongan program berikutnya, dimana kondisi if tersebut mengecek kembali nilai dari flag. Ya, dalam kondisi if yang satu ini bukan lagi mengecek atau menyeleksi kesamaan isi variabel B dan variabel array A, namun if yang satu ini tugasnya adalah untuk mengecek apakah hasil perulangan tersebut menghasilkan perubahan pada nilai flag, apabila nilai flag berubah menjadi 1, maka dalam statement true pada if yang satu ini akan mencetak ke layar / memberitahukan user bahwa karakter yang dicarinya ada. Namun sebaliknya, apabila kondisi if dalam perulangan tersebut dilewatkan semua (dengan kata lain tidak ada yang sesuai antara yang diinputkan user dengan isi dari array A), maka nilai flag tidak mengalami perubahan, yang artinya nilai dari flag masih sama dengan saat inisialisasi. Dengan demikian pada kondisi if yang satu ini, program akan melewatkan statement true dan hanya akan menjalankan perintah yang ada dalam statement false. Dalam statement false ini terlihat bahwa program akan mencetak pula ke layar untuk memberitahukan user akan karakter yang dicarinya tersebut tidak ada. Dan setelah semua proses itu terjadi, program akan berakhir saat pesan tersebut sudah sampai pada layar monitor user.

Yang penting untuk diberitahukan disini (diingatkan), ialah untuk inputan. Bahwa dalam program ini perbedaan karakter sangat sensitif, seperti halnya pada program diatas, apabila Anda menjadi user dan menginputkan huruf g, maka program akan menganggap itu menjadi statement false, dikarenakan dalam bahasa C huruf besar dan kecil itu dianggap berbeda. Namun apabila Anda menginputkan huruf G, maka program akan menjalankan statement true. Bukan karena dalam program ini user harus selalu menggunakan huruf besar untuk inputannya, namun karena harus adanya kesesuaian antara user dengan programmer. Apabila dalam inisialisasi variabel array diberi isi tipe data character dengan huruf besar maka inputanpun harus menggunakan huruf besar, begitupun sebaliknya, pada saat programmer menggunakan huruf kecil, userpun harus menggunakan huruf kecil sebagai penyesuaian. Dengan demikian, jangan kaget apabila Anda membuat program dengan rangkaian huruf besar lalu pada saat running dan menginputkan huruf kecil dianggap salah, itu bukan karena program Anda yang error, hanya saja terdapat perbedaan antara inputan dengan nilai yang terdapat pada arraynya.

Memang kelihatannya tidak sulit untuk membuat program seperti contoh diatas, namun jika Anda tidak mencobanya, maka Anda tidak akan tahu apa yang harus dilakukan pada saat mengalami error dalam program tertentu. Bahkan yang sudah mengertipun dapat lupa dalam pembuatan program tersebut, terutama apabila sudah lama tidak menggunakan / mencoba program tersebut. Dan perlu diingatkan lagi bahwa untuk mencari suatu nilai apakah ada atau tidak ada, tidak harus selalu menggunakan program seperti diatas, masih banyak cara lain untuk melakukan pencariannya. Semua kembali pada algoritma yang digunakan, seperti contoh berikut ini:

#include<stdio.h>
main(){
char D[9]="gugum", E;
int c;
printf("inputkan karakter: ");
scanf("%c", &E);

for(c=0; c<5; c++){
if(E==D[c]){
printf("\n\nKarakter tersebut ADA");
break;
}
}

if(E!=D[c])
printf("\n\nKarakter tersebut TIDAK ADA");
}
Dalam program tersebut sesungguhnya sama saja, hanya yang membedakan ialah algoritmanya, jika pada program sebelumnya kita lebih mengandalkan bantuan variabel flag dalam menentukan ada atau tidaknya, disini kita mengandalkan bantuan break; dalam mencetak pemberitahuan ke layar (mencetak hasil). Break; dalam program C berartikan berhenti, dalam contoh program diatas penulis menggunakannya untuk memberhentikan perulangan pada saat telah ditemukannya karakter yang sesuai. Dan apabila perintah break; tersebut dihilangkan, maka program akan terus mencetak pemberitahuan ada apabila pada beberapa kali perulangan ternyata karakter yang dicari tersebut ditemukan beberapa kali, hingga akhirnya perulangan berhenti dan akan melanjutkan pada perintah if berikutnya, yaitu untuk mencetak pemberitahuan tidak ada. Namun jika perintah break; tersebut tidak dihilangkan (sesuai dengan contoh diatas), maka program akan melakukan perulangan sebagaimana mestinya, apabila kondisi if itu terus dilewatkan (tidak ada isi array yang sesuai dengan inputan) maka perintah break; dan cetak yang ada dalam kondisi if tersebut tidak akan dijakankan, hingga perulangan selesai dan progran akan melanjutkan pada kondisi if yang berikutnya yaitu apabila memang tidak ada yang sesuai akan diberikan pemberitahuan ke layar bahwa karakter tersebut tidak ada dalam array yang dimaksud.

Tuesday 23 August 2016

Array satu dimensi

Array merupakan sesuatu yang berderet atau berbentuk barisan. Dalam pengertian ini kita dapat menyimpulkan bahwa array memiliki indeks dalam satu sama lainnya, dengan demikian array dapat terdiri dari banyak personil didalamnya. Dalam bahasa pemrograman sendiri array diartikan sebagai suatu variabel sejenis yang sedemikian rupa membentuk barisan hingga alamatnya saling menyambung atau bersebelahan, dan dapat pula dikatakan bahwa alamat tersebut berdampingan. Dapat kita ibaratkan seperti sebuah prajurit yang sedang berbaris, satu sama lainnya berdekatan dan memiliki indeks yang bersebelahan. Dan yang dimaksud dalam variabel sejenis, seperti halnya dalam barisan prajurit tersebut, mereka berada dalam baris yang sama, namun satu sama lain berbeda (bukan orang yang sama). Dalam satu array kosong dapat kita ilustrasikan seperti sebuah kolom yang menyambung dengan nomor masing-masing, dan nomor tersebut dimulai dari nol (indeks awalnya 0). Dan kolom tersebut biasa dikenal dengan sebutan elemen, cell, lokasi atau kolom array.

Array satu dimensi biasa disebut dengan vektor, karena hanya memiliki satu arah. Dengan demikian, untuk mengilustrasikan array satu dimensi cukup dengan membayangkan sebuah vektor yang dalam setiap vektor tersebut memiliki banyak isi dengan tanda pemisah disetiap isinya. Penulisannya pun tidak jauh berbeda, pada saat kita menulis sebuah vektor A={97, 24, 1}, dalam penulisan arraypun sama, hanya saja kita diharuskan untuk mendeklarasikan terlebih dahulu jumlah ruang yang akan dibutuhkan untuk menyimpan isi array tersebut. Pendeklarasian tersebut ialah dengan menuliskan nama dari variabel array dan diikuti dengan tanda kurung siku yang didalamnya terdapat hitungan jumlah ruang yang dibutuhkan si array, setelah itu diberi tanda sama dengan yang diikuti tanda kurung kurawal berikut isi array didalamnya, ditulis seperti berikut: A[3]={97,24,1}. Untuk penggunaan umum dari array satu dimensi sendiri tidak lain seperti berikut ini:

#include&ltstdio.h>
main(){
int i, A[3]={97, 24, 1};
for(i=0; i<3; i++){
printf("%3i", A[i]);
}
}
Dalam program tersebut tertulis bahwa sudah disiapkan sebuah Array A satu dimensi dengan 3 buah isi yang bertipe data integer, dimana isinya ialah angka 97, 24 dan 1. Dan kemudian ketiga angka tersebut akan dicetak dengan tipe data yang sama, yaitu integer. Pada percetakan tertulis A[i] yang berartikan A ke i. Mengapa ditulis demikian? Karena untuk mencetak isi array tersebut kita menggunakan perulangan, tidak dapat sekaligus mencetak semuanya, kita mencetak per-indeks array, dan "i" merupakan pengindeksan melalui perulangan. Maksudnya dengan perulangan tersebut kita memanfaatkan i sebagai pengindeks karena nilai yang digunakan pada inisialisasi i pun dari angka 0, dimana sesuai dengan indeks array yang dimulai dari nol. Maka saat dicetak ke layar, yang terlihat ialah:
97 24 1

Namun jika kita bicara tentang apa bedanya Array dengan pengisian biasa pada sebuah variabel? Ialah jika array dicetak per-indeks, dengan demikian pada saat mencetak, seperti halnya mencetak sebuah nama, pada variabel biasa untuk menulis (contoh) "GOOMILAR", maka kita akan mencetak semuanya secara sekaligus atau bersamaan, namun pada array kita dapat mencetak huruf-huruf tertentu yang kita inginkan atau yang kita ambil dari elemen arrray tersebut. Seperti contoh berikut ini:

#include<stdio.h>
main(){
char A[9]="GOOMILAR";
printf("%3c", A[0]);
printf("%3c", A[3]);
printf("%3c", A[5]);
}
Pada program tersebut untuk tulisan GOOMILAR sendiri tidak tercetak semuanya, namun hanya sebagian yang dipilih saja, seperti pada contoh diatas, yang dicetak hanyalah indeks ke 0 yang berisikan huruf G, indeks ke 3 yang berisikan huruf M dan indeks ke 5 yang berisikan huruf L. Maka yang akan tercetak ke layar pada saat program di compile & run ialah ketiga huruf tersebut, dengan tampilan sebagai berikut:

 G M L 
Dan bukan hanya seperti diatas, kelebihan saat menggunakan arraypun sangat banyak, seperti halnya untuk mencetak ke layar, tidak hanya seperti pada variabel biasa, untuk mencetak variabel biasa kita akan mendapatkan tampilan sesuai dengan apa yang kita isikan pada variabel tersebut, namun dalam array, kita dapat membuat banyak variasi didalamnya, seperti membuat cetakan berbentuk persegi, segitiga dan banyak lagi. Begitupun untuk menyalin isi array tersebut, kita dapat menyalinnya satu persatu isi dari array tersebut, tidak seperti pada variabel biasa yang hanya menyalin sama persis sepersi isi dari variabel yang disalinnya. Berikut ini merupakan contoh dari pencetakan isi array yang dibuat menyerupai segitiga:

#include<stdio.h>
main(){
char A[16]="ABCDEFGHIJKLMNO";
int i, j=0, k=1;
for(i=0; i<15; i++){
printf("%3c", A[i]);
j++;
if(j%k==0){
printf("\n");
j=0; k++;
}
 }
}

Merasa bingung dengan program diatas, oke, mari kita bahas satu persatu dari mulai inisialisasi nilai dari variabel j dan k. Dalam variabel j dan k, kita melihat bahwa j memiliki nilai 0 sedangkan k memiliki nilai 1. Namun pada saat setelah percetakan dan sebelum masuk pada kondisi if, terlihat ada tulisan j++, mengapa demikian? Karena dalam kondisi if, untuk meng-enterkannya harus j%k==0, yang artinya saat j dimodulus k hasilnya harus 0. Dan pada program tersebut walau nilai awal j=0, tetapi pada saat dimoduluskan nilai j sudah menjadi 1 karena sebelumnya j sudah ditambah 1 melalui perintah j++. Lalu setelah itu nilai j kembali menjadi 0 karena ada perintah j=0; yang berarti nilai j kembali menjadi 0. Maka pada perulangan perikutnya, begitu masuk pada perintah if, nilai j akan menjadi 1 dengan perintah j++ sebelum if, sedangkan nilai k sudah menjadi 2 dengan perintah k++ setelah if tadi, dan k nilainya terus bertambah tanpa ada perintah seperti j yang mengubah nilainya kembali seperti semula. Dengan demikian pada perulangan kedua tidak akan diberi baris baru karena j%k tidak sama dengan 0, j bernilai 1 dan k bernilai 2, dan dengan demikian perintah yang berada didalam if pun tidak dilaksanakan, dengan kata lain nilai j masih 1 dan k masih 2. Lalu menuju perulangan berikutnya dimana setelah mencetak  huruf A (baris baru) B C, maka akan dilaksanakan perintah dalam if, karena nilai j sebelum masuk perintah if sudah menjadi 2 dengan adanya j++, sedangkan k tidak menjadi 3 alias masih 2 karena perintah k++ dalam if tidak dilaksanakan tadi. Maka dengan demikian setelah J=2 dan k=2, program dalam if dijalankan kembali, yaitu untuk memberi baris baru, karena pada saat dimoduluskan nilainya menjadi 0, 2%2=0. Dan begitupun pada perulangan berikutnya, perintah untuk memberi baris baru hanya akan berjalan setiap nilai j dan k sama. Maka dengan demikian, yang akan Anda lihat di layar pada saat menjalankan program tersebut ialah:

A
B C
D E F
G H I J
K L M N O
Itu merupakan salah satu kelebihan dalam penggunaan array satu dimensi, dan masih banyak lagi tentunya kelebihan lain yang dimiliki array apabila dibandingkan dengan penggunaan variabel biasa (yang bukan array). Begitupun soal variasi, banyak lagi variasi percetakan dengan menggunakan array yang hanya bermodalkan kepahaman looping berikut pengondisian pada array terebut, tinggal saja disusun algoritmanya serta dipahami setiap programnya. Memang terkadang algoritma pemrograman itu menjadi keluhan, terutama bagi para programmer pemula atau yang baru mengenalnya, namun pada saat semua program tersebut dibawa asik, maka semua rasa bingung Anda akan menjadi tantangan baru yang menjadi seru dalam otak Anda. Begitupun yang diderita penulis pada saat pertama mengenal algoritma tersebut, sungguh bingung, namun setelah dicoba terus dan dipahami, sungguh semua itu asik untuk dipelajari.

Selain dari variasi membuat segitiga dengan array satu dimensi yang sudah dicontohkan tadi, ada satu hal lagi yang ingin ditambahkan disini, yaitu untuk menyalin isi array ke array lain, dimana contoh programnya adalah sebagai berikut:

*Menyalin isi array

#include<stdio.h>
main(){
 int i, j=0, A[3]={97, 24, 1}, B[3];
for(i=0; i<3; i++){
B[j]=A[i];
j++;
}
for(j=0; j<3; j++){
printf("%3i", B[j]);
}
}

Perulangan dengan for(), while() dan do while()

Looping merupakan proses dimana sebuah instruksi dalam pemrograman dapat dilakukan secara berulang. Untuk melakukan perulangan tersebut memiliki tiga kunci utama, yaitu memberi nilai awal sebagai nilai dimana kita memulai perulangan dari awalan berapa. Yang kedua ialah kondisi, kondisi merupakan tempat pengecekan benar atau salah. Sama halnya dengan kondisi if dan switch, namun disini kita akan menentukan batas dari nilai akhir setelah kita menentukan nilai awalnya tadi. Bagaimana maksudnya? Dalam kondisi yang satu ini, setiap perulangan akan melalui pengecekan terlebih dahulu, apakah nilainya itu masih sesuai dengan batas yang ditentukan. Sebagai contoh pada saat kita memberikan nilai awal 1 dan memberi kondisi bahwa perulangan tidak boleh melebihi tiga, maka pada saat perulangan pertama selesai akan adanya pengecekan apakah perulangan selanjutnya tidak melebihi hitungan kedua. Dan begitupun perulangan berikutnya, akan ada pengecekan kembali. Namun dikarenakan kita sudah membatasi bahwa perulangan tersebut tidak boleh sampai dengan hitungan ketiga, maka perulangan tersebut akan berhenti.

Yang harus dipahami disini, ialah pada saat kita menulis for(i=1; i<3; i++) maka dalam program tersebut dimaksudkan bahwa perulangan berawal dari angka 1 dan berakhir sebelum angka 3, dengan kata lain perulangan tersebut hanya akan terjadi 2 kali bukan tiga kali. Dan dalam contoh tersebut tertulis i++, maksud dari i++ tersebut ialah setiap perulangan ditambah 1. Nilai awalnya ialah adalah 1, maka setelah perulangan pertama maka nilai 1 tersebut akan ditambah lagi dengan 1 hingga nilai awal tersebut berubah menjadi 2, lalu melakukan pengecekan kembali, dan ditambah kembali dengan 1. Hingga pada saat angka tersebut sudah menjadi 3, maka program berakhir, karena 3 tidak kurang dari 3. Dan apabila i dicetak ke layar, maka yang tercetak ialah: 1 2. Mengapa hanya sampai angka 2? Karena perulangan tersebut hanya berlangsung 2 kali, perulangan pertama pada saat menempati angka satu dan perulangan kedua pada saat menempati angka 2.

Ada cara lain untuk penulisan kondisi pada perulangan ini, tidak hanya dengan i<(angka yang ditentukan) namun juga dapat ditulis i<=(angka yang ditentukan). Apa bedanya antara < dan <=? Terlihat hanya ada karakter sama dengan yang membedakan tulisan tersebut, namun dalam sama dengan tersebut terdapat perbedaan pandangan dari komputer. Apabila kita menulis i<3, maka perulangan hanya akan terjadi dua kali, karena angka 3 tidak kurang dari 3 pada saat pengecekan. Sedangkan apabila kita menulis i<=3, maka perulangan akan terjadi 3 kali, karena angka 3 walau tidak kurang dari 3, tetapi sama dengan 3. Karena sama dengan matematika, <= dibaca "kurang dari atau sama dengan". Oh iya satu lagi yang tidak kalah penting, huruf i yang tertulis pada contoh diatas bukan sebuah aturan huruf yang ditentukan, karena i merupakan sebuah variabel yang sebelumnya harus dideklarasikan terlebih dahulu. Dengan kata lain, i dapat diganti dengan huruf lain sesuai dengan keinginan. Dalam kesempatan kali ini, penulis ini memperkenalkan proses Looping dengan control statement for, while, do while. Sebenarnya ketiga control statement ini sama saja, sama-sama untuk melakukan perulangan dan dengan syarat yang sama, ialah dengan menentukan inisialisasi, kondisi dan perubahan kondisinya. Inisialisasi atau pemberian nilai awal yang sering kita temukan di buku-buku dengan nama initialization terdapat dalam ketiga control statement tersebut, dan yang membedakan hanyalah penempatan posisi dari inisialisasi tersebut. Kondisi atau conditionpun sama, berada dalam ketiganya, hanya beda dalam bentuk posisi saja. Begitupun dengan perubahan kondisinya, atau yang sering kita dengar dengan nama change condition. Berikut merupakan bentuk umum perulangan dengan for():

for(inisialisasi; kondisi; perubahan kondisi){
.............................................
lokasi statement yang akan menjadi perulangan)
.............................................
}
Dalam perintah tersebut terlihat didalam for tertulis pertama inisialisasi dengan diakhiri oleh karakter titik koma. Ini sudah menjadi aturan bahwa penulisannya harus seperti itu dan diakhiri dengan titik koma pada setiap akhir kata. Apa gunanya titik koma? Titik koma dalam sebuah program dapat menjadi sebuah pemisah antar perintah. Seperti pada dasarnya, dalam bahasa C memang diperbolehkan memiliki banyak spasi dari setiap kata yang berbeda (terkecuali dalam menulis sebuah kata dipisahkan dari setiap hurufnya), namun untuk pemisah itu sendiri tidak ditentukan dengan baris baru atau titik, dapat saja Anda menuliskan sebuah program tanpa baris baru, namun Anda tidak boleh menuliskan sebuah perintah tanpa diakhiri dengan titik koma selagi ada perintah lain setelah penulisan perintah tersebut. Seperti pada contoh sebelumnya, tertulis for(i=1; yang berarti inisialisasi dari variabel i diberi nilai 1. Begitupun selanjutnya terlihat ada kondisi i<3 yang diakhiri dengan tanda titik koma. Namun untuk yang i++ sendiri tidak diakhiri dengan karakter titik koma karena posisinya yang berada di akhir perintah.

#include<stdio.h>
main(){
int i;
for(i=1; i<=2; i++){
printf("%3i", i);
}
}

Dalam contoh program diatas, terlihat yang pertama ialah mendeklarasikan variabel yang akan dijadikan patokan dan diisi oleh suatu nilai tertentu. Setelah deklarasi selesai, dalam perintah for() yang pertama ialah adanya inisialisasi dengan memberikan nilai awal untuk i ialah 1. Nilai tersebut akan tersimpan kedalam variabel i dan diproses untuk selanjutnya. Seperti pada bentuk dasar yang dijelaskan diatas, setelah inisialisasi, yang dilakukan ialah menentukan kondisi serta menentukan perubahan kondisi dalam setiap perulangan yang dilakukan. Dan yang akan dilakukan perulangan ialah mencetak i ke layar. Seperti pada penjelasan sebelumnya, yang akan tercetak ke layar ialah angka 1 dan 2. Namun penulis berharap, pembaca tidak hanya mendapatkan jawaban dari apa yang dibawa akan hasil cetak ke layar tersebut, namun juga pembaca mencoba program tersebut, sehingga lebih memahami akan apa yang dimaksud dalam pembahasan ini. Dan karena manusia itu tidak ada yang sempurna, penulispun mengkhawatirkan ada kekeliruan dalam pengetikan atau penjelasan mengenai ini, maka kritik dan saran yang membangun sangat diharapkan untuk setiap terbitan.

Selain for, ada juga bentuk lain, ialah while dan do while. Seperti yang sudah disebutkan diatas, bahwa ketiganya sama saja dalam melakukan perulangan, hanya saja posisi dalam penulisannya yang berbeda. Dan untuk membuat sebuah program tidak perlu membingungkan harus memakai yang mana, cukup Anda coba terlebih dahulu dan rasakan Anda lebih nyaman dengan perintah yang mana. Karena yang orang lain rasa kurang baikpun jika Anda rasa nyaman dan menguasainya, semua itu akan lebih baik daripada mengikuti orang lain namun tidak nyaman dan tidak menguasainya. Untuk bentuk umum while() sendiri seperti berikut ini:

inisialisasi;
while(kondisi){
....................................
statement untuk dilakukan perulangan
....................................
perubahan kondisi;
}
Dalam bentuk diatas terlihat perbedaan yang penulis maksud tersebut, ialah posisi penulisan. Dalam control statement while(), inisialisasi dilakukan diluar tanda kurung dan sebelum penulisan while() itu sendiri, yang tertulis didalam kurung hanyalah kondisi dari proses perulangan tersebut. Bahkan perubahan kondisinya pun menyatu dalam koloh perintah yang dilakukan perulangan. Untuk contoh program dengan perulangan while() ialah sebagai berikut:

#include<stdio.h>
main(){
int i;
i=1;
while(i<=2){
printf("%3i", i);
i++;
}
}
Program tersebut sama halnya dengan yang dilakukan oleh control statement for() tadi, inisialisasi, kondisi dan perubahan kondisinya sama, hanya lokasi penulisannya saja yang berbeda, menyesuaikan dengan bentuk umum dari control statement tersebut. Jadi intinya sudah terbukti bahwa tidak ada perbedaan dalam melakukan perulangan dari kedua program tersebut. Dan yang terakhir ialah do while, yang sama saja alur perulangannya, yang sama pula hanya memiliki perbedaan dari posisi penulisan. Berikut bentuk umum dari do while() berikut contohnya:

inisialisasi;
do{
....................................
statement untuk dilakukan perulangan
....................................
perubahan kondisi;
}
while(kondisi);
Contoh program:


#include<stdio.h>
main(){
int i;
i=1;
do{
printf("%3i", i);
i++;
}
while(i<=2);
}
Sedikit penjelasan mengenai %3i dalam printf, yang dimaksud %i ialah untuk mencetak karakter dengan tipe data integer dan angka 3 disana ialah untuk memberikan spasi dari setiap cetakannya, angka tersebut dapat diganti dengan berapa saja sesuai dengan yang diinginkan.