Pengulangan for Algoritma

www.csa-interganesha.com Tutorial Struktur Pengulangan For Algoritma

Created By Edi Casnadi - IM 1

Judul : Struktur Pengulangan For (Repeat) Penulis : Edi Casnadi Level : Basic Hak : csa-interganesha / www.csa-interganesha.com Kategori : Public

STUKTUR PENGULANGAN FOR (…)

1. Dasar Pengulangan Dalam sebuah program sering kali kita mendapati satu perintah atau blok perintah yang sama diulang-ulang beberapa kali. Hal ini mengakibatkan pembuatan program menjadi tidak efektif karena membutuhkan waktu, tempat, biaya, tenaga, dan memori yang berlebihan untuk mengulang suatu blok printah yang banyak. Untuk mengatasi masalah tersebut, biasanya bahasa pemrograman menyediakan perintah pemrosesan pengulangan yang disebut itrasi (looping). Salah satu kelebihan komputer dibandingkan dengan manusia adalah kemampuannya untuk melaksanakan suatu instruksi berulang kali, tanpa mengenal lelah dan bosan, tetapi manusia pasti mempunyai titik jenuh ketika kita melakukan pekerjaan yang sama dalam jumlah banyak. Bentuk perulangan yang sederhana, yaitu: 1. Perulangan digunakan untuk mengerjakan suatu atau beberapa perintah secara

berulang-ulang sesuai dengan yang diinginkan. 2. Perulangan sederhana yaitu perulangan yang hanya membutuhkan 1 kali

perulangan saja. 3. Di dalam perulangan sederhana tidak ada pengulangan bersarang (nested loop). Struktur pengulangan terdiri atas dua bagian, yaitu:

1. Kondisi pengulangan, yaitu ekspresi boolean yang harus dipenuhi untuk melaksanakan pengulangan.

2. Badan (body) pengulangan, yaitu satu atau lebih aksi atau intsruksi yang akan diulang.



Disamping itu, struktur pengulangan biasanya disertai dengan bagian: 1. Inisialisai, yaitu aksi yang dilakukan sebelum pengulangan dilakukan pertama

kali 2. Penaikan nilai pengulangan(counter/increment), yaitu secara otomatis akan

mengalami penaikan nilai atau pengurangan nilai. 3. Terminasi, yaitu aksi dilakukan setelah pengulangan selesai dilaksanakan.

Inisialisasi dan terminasi tidak salalu ada seperti di VB6 dan PHP secara otomatis akan menjadi tipe variant, namun pada berbagai kasus inisialisasi umumnya diperlukan. Struktur dasar pengulangan secara umum:

<inisialisasi> awal pengulangnan badan pengulanngan akhir pengulangan <terminasi>

Di dalam algoritma terdapat beberapa macam struktur pengulangan berbeda yang tergantung pada kondisi pengulangannya. Beberapa struktur pengulangan dapat dipakai untuk masalah tertentu. Pemilihan struktur pengulangan untuk masalah tertentu dapat mempengaruhi dari kebenaran algoritma. Dasar dari struktur pengulangan ini terdapat beberapa jenis pengulangan yaitu: Struktur for (..) do Struktur while (..) do Struktur do .. while (..)

2. Struktur for (... ) do Struktur for (...) do, dapat digunakan untuk menghasilkan pengulangan sebanyak sejumlah kali. Struktur pengulangan ini akan menyebabkan aksi/statement diulangi sejumlah kali (tertentu). Pada dasarnya perulangan dengan struktur for (...) do digunakan, untuk mengulang sejumlah statement/aksi atau satu blok statement/aksi berulang kali, dengan sejumlah nilai yang telah kita tentukan nilainya sehingga dapat melakukan pengulangan berapa banyak statement diulang. Jadi kesimpulan dari perulangan struktur for(..) do, yaitu untuk melakukan suatu pengulangan yang sudah diketahui jumlah nilai pengulangannya. Contoh : saya ingin mengulang kata ”belajar algoritma” sebanyak 10 kali. Hal ini instruksi tersebut dapat mengulang kata ”belajar algoritma” sebanyak 10 kali. Ini diakibatkan karena penggunaan struktur for (...) do dengan nilai batasan awal 1 dan batasan nilai akhir 10.



Pengulangan for (...) do merupakan suatu bentuk yang paling sederhana dalam hal pengulangan. Dalam menggunakan perulangan for (..) do, ada beberapa elemen yang perlu diperhatikan, yaitu: Elemen inisialisasi dan pemberian nilai awal Elemen penguji atau validasi Elemen nilai penambahan atau pengurangan

Karakteristik dari pengulangan for (…) do, yaitu: Digunakan untuk perulangan yang batasnya sudah diketahui dengan jelas,

misalnya 10 kali. Memerlukan 2 buah penanda(nilai awal) dan akhir perulangan (nilai akhir). Nilai penghitung/increment akan secara otomatis bertambah atau berkurang setiap

kali sebuah pengulangan dilaksanakan, tergantung jenis perulangannya. Memerlukan suatu Statement/aksi yang dapat diulangi sebanyak perulangan

Bentuk umum pengulangan FOR dalam Algoritma

for (variabelnilai_awal; variabel< nilai_akhir; variabel nilai_penaikan) do Statement End_for

Keterangan: variabel nilai_awal, untuk inisialisasi variabel kendali pengulangan (nilai

awal dari pengulangan) variabel < nilai akhir, untuk membandingkan variabel kendali atau nilai_awal

pengulangan dengan nilai_batas/nilai_akhir. (jika nilai_awal sudah melampaui nilai_akhir atau false maka pengulangan diberhentikan.

Nilai_penaikan, menspesifikasikan cara variabel kendali dimodifikasi sebelum iterasi berikutnya. (sebagai nilai penaikan nilai variabel)

Contoh:

for (i0; i<5; i++) do println(“Statement”); End_for

Pengulangan struktur for (..) do, terbagi menjadi dua hal yaitu

a. Pengulangan for (..) do menaik (positif) b. Pengulangan for (..) do menurun (negatif), yaitu:



a. For (...) do bentuk positif (menaik) Perulangan positif adalah perulangan dengan penghitung (counter/increment) dari kecil ke besar atau dengan kata lain pertambahannya positif. Contoh: mengulang angka sebanyak 0 s/d 6, maka pengulangan tersebut akan dimulai dari angka 0, 1, 2, 3, 4, 5, 6, kenapa bisa terjadi demikian karena ada suatu increment yaitu penambahan secara otomatis misalnya kenaikan pada variabel i dimana i++ (i = i +1), kalau kita masukan i awal = 2 maka i = i + 1 akan menghasilkan i akhirnya = 3, ( atau i = 3 ), untuk lebih jelasnya yaitu: i = 2 // masukan nilai i awal i = i +1 jadi i = 2 + 1 i = 3

Bentuk umum algoritma pengulangan for (...) do menaik (Positif)

for (variabelnilai_awal ; variabelnilai akhir ; increment ) do Statement end_for

Bentuk umum algoritma flowchart untuk for (..) do menaik (Positif)

tidak ya/true tidak / false loop increment i

Gambar 2 Flowchart pengulangan for menaik

Inisialisasi hitungan

i=nilai_awal; i < nilai_akhir; i ++

Stop

statment



Bentuk umum pengulangan for (...) do positif dalam bahasa Java, yaitu: i = int; // variabel i dengan tipe data integer for ( i=nilai_awal ; i <nilai akhir ; i++ ) { println(i); //statement }

Contoh: for (int i = 0; i < 6; i++ ) { System.out.println( i ); // ini adalah statement }

Contoh kasus pengulangan for (...) do positif, Buatlah algoritma pseudo code untuk mencetak angka 0 s/d 5, yaitu:

ALGORITMA cetak_kalimat { mencetak kalimat Belajar Algoritma sebanyak 6 kali dalam for positif} DEKLARASI i integer; DESKRIPSI for ( i = 0; i < 6; i++ ) do println( i); // ini statement end_for End_algo

Cobalah kita analisis algoritma di atas dengan menggunakan sebuah tabel, yaitu: Tabel 1. analisi for (...) do

I i<6 i++ println(i) 0 1 2 3 4 5 6

True True True True True True False

1 2 3 4 5 6 -

0 1 2 3 4 5 -



Jadi perintah println(i) ini akan ditampilkan dalam monitor, sedangkan sisanya merupakan suatu proses di dalam komputer. Bentuk umum dalam algoritma flowchart, yaitu:

i integer tidak ya Belajar Algoritma

Gambar 3 Flowchart for (...) do positif Contoh: Pengulangan for (...) do dalam bahasa Java, yaitu:

public class cetak_kalimat { public static void main(String[] args) { int i; for ( i = 0; i < 6; i++ ) { System.out.println( i + “ Belajar Algoritma“); // ini statement } } }

Hasil output, yaitu:

0 Belajar Algoritma 1 Belajar Algoritma 2 Belajar Algoritma 3 Belajar Algoritma 4 Belajar Algoritma

5 Belajar Algoritma

Start

i=0; i<6; i++

stop



b. For (...) do bentuk negatif (menurun) Perulangan negatif adalah perulangan dengan penghitung (counter/increment) dari besar ke kecil atau dengan kata lain pertambahannya negatif. Bentuk umum for (…) do menurun (negatif) dalam algoritma, yaitu:

for ( variabel nilai_akhir; peubah>nilai_awal; variabel_menurun ) do Statement End_for

Contoh:

for ( i=5; i>1; i-- ) do println(“ Belajar Algo”) //ini adalah statement end_for

Bentuk umum Java pengulangan for (...) do menurun (negatif), yaitu:

for ( int i=nilai_akhir; i > nilai_awal; pengurangan_i ) { System.out.println( i ); }

Contoh:

for ( int i = 3; i > 0; i-- ) { System.out.println( i ); }

Analisi prosesnya Tabel 2 Proses for (...) do

i=3 i > 0 i-- println(i) 3 2 1 0

True True True false

2 1 0 -

3 2 1 -



Bentuk umum algoritma flowchart for menurun (negatif), yaitu: ya tidak loop increment negatif

Gambar 4 Flowchart pengulangan for (...) do

Contoh kasus pengulangan for (...) do negatif Buat algoritma untuk menampilkan pengulangan kata ”Belajar Algoritma” sebanyak 6 kali. Dalam Algoritma pseudo-code

ALGORITMA Pengulangan_negatif {untuk menampilkan pengulangan kata Belajar Algoritma

sebanyak 6 kali dengan for negatif} DEKLARASI i integer DESKRIPSI for ( i = 6 ; i >0; i--) do print( i + ” Belajar Algoritma”) end_for End_algo

Inisialisasi hitungan

Stop

Statement Pengulangan

i =nilai_akhir; i > nilai_awal; i --



Penyelesaian dengan algoritma flowchart tidak ya

Gambar 5 Flowchart for (...) do negatif

Penyelesaian dalam bahasa Java, yaitu: public class Pengulangan_Negatif { public static void main(String[] args) { for (int i=0;i<=5; i++ ) { System.out.println( i + " Belajar Algoritma"); } } }

Hasil dari RUN, yaitu:

6 Belajar Algoritma 5 Belajar Algoritma 4 Belajar Algoritma 3 Belajar Algoritma 2 Belajar Algoritma 1 Belajar Algoritma Process completed.

Start

i=6; i>0; i--

stop



Belajar algoritma melalui contoh-contoh: Contoh ke-1 Algoritma untuk menentukan nilai perpangkatan

ALGORITMA Hitung_pangkat {untuk menampilkan nilai pangkat dari bilangan yang dipangkatkan} DEKLARASI i, jml integer // tipe data integer bil, pang integer DESKRIPSI Jml1 read(bil) // input data bil dari keboard read(pang) // input data bil dari keboard for ( i = 0 ; i <pang; i++) do jml=jml + bil // penjumlahan data dari sebuah bil end_for print( “ pangkat = “ +jml ) //menampilkan hasil pangkat End_algo

Keterangan: Struktur for (..) do, disini digunakan untuk melakukan pengulangan untuk menghitung nilai perpangkatan. Misalnya 23=4. Dimana: angka 2, merupakan bilangan yang akan dipangkatan,

angka 3, merupakan bilangan pangkat yang akan memangkatkan bilangan tertentu,

angka 4 adalah hasil dari perpangkatan. Dengan proses sebagai berikut: 2 x 2 x 2 = 4.

Pengulangan sebanyak nilai pangkat, dengan banyaknya pengulangan dari for (...) do. Untuk lebih jelasnya kita gambarkan saja dengan sebuah tabel, dengan bil=2 dan pang=3, jadi 23, yaitu:

Tabel.3 Pengulangan for untuk perpangkatan

i bil pang jml = jml * bil print(jml) 0 1 2

2

3 jml = 1 * 3 jml = 3 * 3 jml = 9. * 3

3 19 27

Jadi hasil akhir yaitu 27



Contoh ke-2, Algoritma menghitung faktorial, yaitu:

ALGORITMA Hiung_faktorial {untuk menampilkan nilai faktorial dari n} DEKLARASI i, n, fak integer // tipe data integer DESKRIPSI fak 1; read(n) // input data n dari keboard for ( i = 1 ; i <= n; i++) do fak fak * i // perkalian faktorial end_for print( “ faktorial = “ + fak + “ ! ” ) //menampilkan hasil factorial End_algo

Contoh ke-3 Algoritma pengulangan for (...) do untuk menghitung nilai rata-rata dari jumlah ke-n, yaitu:

ALGORITMA Hitung_Rata-rata {untuk menampilkan hasil nilai rata-rata dari jumlah ke-n} DEKLARASI i, n, jml, data integer // tipe data integer rata_rata float //tipe data desimal DESKRIPSI jml=0; read(n) // input data n dari keboard for ( i = 0 ; i < n; i++) do read(data) // input data dari keyboard jml=jml + data // penjumlahan data dari sebuah data End_for rata_rata = jml / n // jml di bagi dengan banyak data (n) print( “ rata –rata = “ + rata_rata ) //menampilkan hasil rata-rata End_algo



Belajar melalui latihan For (...) do dalam bahasa Java, yaitu Latihan-1

public class ulang { public static void main(String[] args) { for (int i=0;i<=5; i++ ) { System.out.println( " i = " + i ); } } }

Ketika di RUN atau tekan F5, yaitu: i = 0 i = 1 i = 2 i = 3 i = 4

i = 5 Latihan-2

import javax.swing.*; public class ulangInputan { static int n; static void masukan(){ String msk=JOptionPane.showInputDialog(“masukan n pengulangan”); n = Integer.parseInt(msk); } static void proses(){ for (int i=0;i<=n; i++ ) { System.out.println( " i = " + i ); } } public static void main(String[] args) { masukan(); proses(); } }



Latihan-3 Menentukan nilai faktorial ( 5! ) dengan inputan dari keyboard

import javax.swing.*; public class faktorial { static int n; static void masukan(){ String msk=JOptionPane.showInputDialog(“Masukan nilai faktorial”); n = Integer.parseInt(msk);

} public static void main(String[] args) { int i; int fak=1; masukan(); //memanggil method masukan for ( i=1; i <=n; i ++) { fak = fak * i; } System.out.println("faktorial = " + fak + " ! "); } }

Latihan-4 Membuat pengulangan sejumlah inputan n, dari keyboard, yaitu:

import java.io.*; public class jml_ulang { public static void main(String[] args) throws IOException { int a ; InputStreamReader reader = new InputStreamReader(System.in); BufferedReader input = new BufferedReader(reader); System.out.print("Masukan jumlah pengulangan ? "); String n = input.readLine(); a = Integer.parseInt(n); for ( int i = 0; i < a ; i ++ ) { System.out.println( i + " Algoritma”); } } }



Ketika di RUN, yaitu: Masukan jumlah pengulangan ? 4 0 Algoritma 1 Algoritma 2 Algoritma

3 Algoritma

c. For (...) do bersarang Pengulangan bersarang (nested loop) adalah pengulangan berada di dalam pengulangan yang lainnya. Dengan cara sebegai berikut: Pada pengulangan pertama akan diproses satu kali. Kemudian dilanjutkan pada pengulangan kedua tetapi pengulangan diproses

sampai habis Setelah itu kembali pada pengulangan pertama dan melakukan pengulangan satu

kali lagi dan seterusnya

Jadi for (...) do bersarang yaitu pengulangan for (...) do berada dalam pengulangan for (...) do lainnya. Pernyataan ini menyatakan bahwa suatu for (...) do ada pengulangan for (...) do lagi. Inilah kenapa dikatakan pengulangan for (...) do bersarang. Bentuk umum for (...) do bersarang

n=2; m=2 for (i=0; i<n; i++ ) do //for pertama for (j=0; j<m; j++ ) do //for dalam for atau for bersarang Statement end_for end_for

Misal n=2 dan m=2, maka sebagai berikut:

for i for j Keterangan 1 1 2 2

1 2 1 2

Pada for i bernilai (1,1) tetapi pada for j bernilai (1,2), karena akan mengerjakan sebanyak for j untuk di dalam dan mengerjakan sebanyak for i untuk diluar



Contoh algoritma segitiga bintang, seperti berikut: ALGORITMA segitiga_bintang {untuk menampilkan segitiga dengan bintang } DEKLARASI i, j Integer DESKRIPSI for ( i =1 ; i <= 11; i++) do for ( j = i ; j<=11; j++ ) do print(“ * “) end_for println() end_for End_algo

Algoritma diatas akan menampilkan segitiga sebagai berikut

*********** ********** ******** ******* ****** **** *** ** *

Contoh for bersarang dalam Java, yaitu:

public class segitiga_bintang { public static void main(String[] args) { for (int i =1 ; i <= 11; i++) { for (int j = i ; j<=11; j++) { System.out.print(” * ”); } System.out.println(); } } }



Ketika di RUN *********** ********** ********* ******** ******* ****** ***** **** *** ** *

Belajar melalui latihan dengan algoritma Latihan-1 Membentuk segitiga dengan bintang sebagai berikut

* * * * * * * * * * * * * * *

Algoritmanya, yaitu

ALGORITMA Segitiga {membentuk segitiga dengan karakter bintang } DEKLARASI i, j Integer DESEKRIPSI for ( i=0; i<5; i++) do for ( j=0; j<=i; j++) do print(” * ”); end_for println(); end_for End_algo



Latihan-2 Membentuk segitiga dengan bintang sebagai berikut

* * * * * * * * * * * * * * *

Algoritmanya, yaitu:

ALGORITMA Segitiga {membentuk segitiga dengan karakter bintang } DEKLARASI i, j Integer DESEKRIPSI for ( i=0; i<5; i++) do for (int j = 4; i< =j; j--) do print(” * ”); end_for println(); end_for End_algo


* * * * * * * * * * * * * * *

Algoritmanya, yaitu:

ALGORITMA Segitiga {membentuk segitiga dengan karakter bintang } DEKLARASI i, j Integer



DESEKRIPSI for ( int i=0;i<5; i++ ) do for ( int j=0; j<=i; j++ ) do print(" ") end_for for ( j=0; j<5-i; j++ ) do print("*"); end_for println(); end_for End_algo


* * * * * * * * * * * * * * *

Agoritma segitiga, yaitu:

ALGORITMA Segitiga {membentuk segitiga dengan karakter bintang } DEKLARASI i, j Integer DESEKRIPSI for ( i=0; i<5; i++) do for ( j=0; j<=5-i; j++) do print(" ") end_for for ( j=0;j<i+1;j++) do print("*") end_for println(); end_for End_algo



Latihan-5 Coba Anda buat algoritmanya

* * * * * * * * * * * * * * *

Dikethui dalam bahasa Java, yaitu:

public class segitiga { public static void main(String[] args) { for(int i=0;i<5; i++){ for (int j=0; j<=i; j++){ System.out.print(" "); } for (int j=0;j<5-i;j++){ System.out.print("* "); } System.out.println(); } } }

Education

Pengulangan for Algoritma