Program Pencarian Pohon Akar Menggunakan Breath first Search ( BFS ) Dan Depth First Search ( DFS ) Dengan Sofware Python.

Program Pencarian Pohon Akar Menggunakan  Breath first Search ( BFS ) Dan Depth First Search ( DFS ) Dengan Sofware Python.




Breath first Search ( BFS )


pohon = {'A':set(['B','C','E']),
         'B':set(['A','G','D']),
         'C':set(['A','I']),
         'D':set(['B','H','I']),
         'E':set(['A','F']),
         'F':set(['E','H']),
         'G':set(['B','H']),
         'H':set(['D','F','G','I']),
         'I':set(['C','D'])}

def bfs(graf, mulai, tujuan):
    queue = [[mulai]]
    visited = set()

    while queue:
        jalur = queue.pop(0)
        state = jalur[-1]
        if state == tujuan:
            return jalur
        elif state not in visited:
            for cabang in graf.get(state, []):
                jalur_baru = list(jalur)
                jalur_baru.append(cabang)
                queue.append(jalur_baru)

            visited.add(state)

        isi = len(queue)
        if isi == 0:
            print("tidak ditemukan")

 Depth First Search ( DFS )



pohon = {'A':set(['B','C','E']),
         'B':set(['A','G','D']),
         'C':set(['A','I']),
         'D':set(['B','H','I']),
         'E':set(['A','F']),
         'F':set(['E','H']),
         'G':set(['B','H']),
         'H':set(['D','F','G','I']),
         'I':set(['C','D'])}

def dfs(graf, mulai, tujuan):
    stack = [[mulai]]
    visited = set()

    while stack:
        panjang_tumpukan = len(stack)-1
        jalur = stack.pop(panjang_tumpukan)
        state = jalur[-1]
        if state == tujuan:
            return jalur
        elif state not in visited:
            for cabang in graf.get(state, []):
                jalur_baru = list(jalur)
                jalur_baru.append(cabang)
                stack.append(jalur_baru)
            visited.add(state)

        isi = len(stack)
        if isi == 0:
            print("Tidak ditemukan")

TUGAS BESAR SP ALPRO MENGHITUNG JUMLAH KRAMIK DAN HARGA KERAMIK SATU RUMAH.

TUGAS BESAR SP ALPRO MENGHITUNG JUMLAH KRAMIK DAN HARGA KERAMIK SATU RUMAH.



 http://dinus.ac.id/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define true 1
#define false 0
#define boolean unsigned char
#define nil 0

typedef char jNama[40];
typedef struct tInfo *next;
typedef struct tInfo
{
      jNama NamaRuang;
      next ruang;
      float lebar;
      float panjang;
      float Luas;
      int harga;
      char keramik;

}Info;

typedef struct
{
    next Pertama;
}  Rumah;

void BuatRumah(Rumah *U)
{
    next room,loop;
    room = nil;

    // Buat ruang teras
    room = (next)malloc(sizeof(Info));

    strcpy(room->NamaRuang,"Ruang Teras");
    room->keramik = 'D';
    (*U).Pertama = room;
    loop = room;
int i;

    // buat kamar kamar
    for( i=1;i<=2;i++){
    room = nil;
    room=(next)malloc(sizeof(Info));


    strcpy(room->NamaRuang,"Kamar Tidur Standard");
    room->keramik = 'A';
    loop->ruang = room;
    loop = room;

    }

    // Buat kamar VIP
    room = nil;
    room=(next)malloc(sizeof(Info));
    strcpy(room->NamaRuang,"Ruang kamar VIP");
    room->keramik = 'A';
    loop->ruang = room;
    loop = room;

    // Buat ruang Kamar Mandi
    room = nil;
    room=(next)malloc(sizeof(Info));
    strcpy(room->NamaRuang,"Ruang kamar mandi");
    room->keramik = 'C';
    loop->ruang = room;
    loop = room;

    //Buat ruang dapur
    room = nil;
    room=(next)malloc(sizeof(Info));
    strcpy(room->NamaRuang,"Ruang Dapur");
    room->keramik = 'B';
    loop->ruang = room;
    room->ruang = nil;


}

void InputUkuranRumah(Rumah *U){
    next room,loop;
    float ukuran;
    room = (*U).Pertama;

    printf("Masukkan ukuran rumah anda per meter persegi\n");
    printf("Type ruang teras\n");
    printf("Lebar ruang : "); scanf("%f",&ukuran);
    room->lebar = ukuran;

    printf("Panjang ruang : "); scanf("%f",&ukuran);
    room->panjang = ukuran;

    room->Luas = room->lebar * room->panjang;
    room->harga = room->Luas * 1.44 * 10000 +1;

    loop = room;
    room = loop->ruang;

    printf("Type ruang kamar standard 1\n");
    printf("Lebar ruang : "); scanf("%f",&ukuran);
    room->lebar = ukuran;

    printf("Panjang ruang : "); scanf("%f",&ukuran);
    room->panjang = ukuran;

    room->Luas = room->lebar * room->panjang;
    room->harga = room->Luas * 0.96 * 40000 +1;

    loop = room;
    room = loop->ruang;

    printf("Type ruang kamar standard 2\n");
    printf("Lebar ruang : "); scanf("%f",&ukuran);
    room->lebar = ukuran;

    printf("Panjang ruang : "); scanf("%f",&ukuran);
    room->panjang = ukuran;

    room->Luas = room->lebar * room->panjang;
    room->harga = room->Luas * 0.96 * 40000 +1;

    loop = room;
    room = loop->ruang;

    printf("Type ruang kamar VIP\n");
    printf("Lebar ruang : "); scanf("%f",&ukuran);
    room->lebar = ukuran;

    printf("Panjang ruang : "); scanf("%f",&ukuran);
    room->panjang = ukuran;

    room->Luas = room->lebar * room->panjang;
    room->harga = room->Luas * 0.96 * 40000 +1;

    loop = room;
    room = loop->ruang;

    printf("Type ruang kamar mandi\n");
    printf("Lebar ruang : "); scanf("%f",&ukuran);
    room->lebar = ukuran;

    printf("Panjang ruang : "); scanf("%f",&ukuran);
    room->panjang = ukuran;

    room->Luas = room->lebar * room->panjang;
    room->harga = room->Luas * 1 * 20000 ;

    loop = room;
    room = loop->ruang;

    printf("Type ruang dapur\n");
    printf("Lebar ruang : "); scanf("%f",&ukuran);
    room->lebar = ukuran;

    printf("Panjang ruang : "); scanf("%f",&ukuran);
    room->panjang = ukuran;

    room->Luas = room->lebar * room->panjang;
    room->harga = room->Luas * 0.99 * 30000 +1;
}

void tampilkan(Rumah U){
    next room ;
    room= U.Pertama;

    while(room!=nil){
    if (room->keramik=='A'){
        printf("\n\nRuang %s \ndengan lebar = %f dan panjang %f\nLuas ruang tsb = %f\n",room->NamaRuang,room->lebar,room->panjang,room->Luas);
        printf("type keramik = %c dengan tipe keramik 40cm x 40cm dengan harga tiap box Rp 40000,00\n",room->keramik);
        printf("Total harga yang dibutuhkan untuk ruangan ini %d",room->harga);

    }
    else if(room->keramik=='B'){
        printf("\n\nRuang %s \ndengan lebar = %f dan panjang %f\nLuas ruang tsb = %f\n",room->NamaRuang,room->lebar,room->panjang,room->Luas);
        printf("type keramik = %c dengan tipe keramik 30cm x 30cm dengan harga tiap box Rp 30000,00\n",room->keramik);
        printf("Total harga yang dibutuhkan untuk ruangan ini %d",room->harga);

    }
    else if(room->keramik=='C'){
        printf("\n\nRuang %s \ndengan lebar = %f dan panjang %f\nLuas ruang tsb = %f\n",room->NamaRuang,room->lebar,room->panjang,room->Luas);
        printf("type keramik = %c dengan tipe keramik 20cm x 20cm dengan harga tiap box Rp 20000,00\n",room->keramik);
        printf("Total harga yang dibutuhkan untuk ruangan ini %d",room->harga);

    }
    else if(room->keramik=='D'){
        printf("\n\nRuang %s \ndengan lebar = %f dan panjang %f\nLuas ruang tsb = %f\n",room->NamaRuang,room->lebar,room->panjang,room->Luas);
        printf("type keramik = %c dengan tipe keramik 60cm x 60cm dengan harga tiap box Rp 10000,00\n",room->keramik);
        printf("Total harga yang dibutuhkan untuk ruangan ini %d",room->harga);

    }

    room = room->ruang;

    }

}

Int searchingMax(Rumah U){
   next room ;
   float luas max = 0;
   room = U.Pertama;
   while(room! = nil){

   if LuasMax (room -> Luas)
       LuasMax = room -> Luas
       room = room -> ruang;
    }

}



int main(){
    Rumah Idaman;
    Idaman.Pertama = nil;


    BuatRumah(&Idaman);
    menu();
    InputUkuranRumah(&Idaman);
    tampilkan(Idaman);
}

Prosedur pertemuan ke-4

Pengertian prosedur
Prosedur yaitu sederetan instruksi logika dan algoritma yang telah diberi nama Atau suatu perogram terpisah dalam blok tersendiri yang berfungsi sebagai subprogram.

Mendefinisikan prosedur yaitu berati
- menentukan nama prosedur beserta parameternya
- mendefinisikan keadaan pada sebuah yang berada di awal ataupun di akhir program

parameter prosedur ada dua yaitu
- prosedur tanpa parameter
- prosedur parameter

 Prosedur banyak digunakan pada program yang terstruktur karena :
Merupakan penerapan konsep program Modular, yaitu memecah-mecah program yang rumit menjadi bagian yang lebih sederhana dalam bentuk prosedur.
Untuk hal-hal yang sering dilakukan berulang-ulang, cukup dituliskan sekali saja dalam prosedur dan dapat dipanggil atau dipergunakan sewaktu-waktu bila diperlukan.
Membuat kode program lebih mudah dibaca.
Dapat digunakan untuk menyembunyikan detil program


Struktur Procedure:
Judul = nama prosedur dan deklarasi parameter(kalau ada)
Deklarasi = mengumumkan nama-nama dan tipe data
Algoritama = badan prosedur (instruksi)


Penggunaan/Pemangilan Pprosedure :
-         -  Prosedur yaitu program yang tidak beridiri sendiri
-          - Prosedur tidak dapat dieksekusi secara langsung.

Jika prosedur tanpa parameter, maka pemanggilannya cukup dengan nama prosedurnya saja, Selain itu procedure yang banyak dipakai untuk menampung baris-baris perintah yang sering dipakai dalam sebuah program. Untuk mendeklarasikan procedure dapat dilakukan dengan dua cara
- Header Procedure tanpa parameter
- Header Procedure dengan menggunakan parameter.


NAMA = MUHAMAD ALIV FAHRUDIN
NIM = A11.2013.07901
MATA KULIAH = SP ALPRO
http://dinus.ac.id/
http://dinus.ac.id/

Materi Pertemuan Ke-3 fungsi

Fungsi / Function adalah pengelompokan satu blok kode yang melakukan tugas tertentu dengan tata cara sebuah intruksi berdasarkan statment , mempunyai maksud dan tujuan.
Cara membuat fungsi harus mengetahui sebuah sistemnya dahulu.
fungsi  dapat didefinisikan ''dipanggil'' untuk dieksekusi diberi parameter.

Tujuan Fungsi yaitu :
- Memudahkan user dalam membuat program.

Keuntungan dari pemakaian fungsi :
- Mengurangi penyamaan kode (kode yang sama ditulis berulang-ulang / looping) dalam suatu program.
- Dapat menggunakan kode yang ditulis dalam tiap program yang berbeda.
- Memecah program besar menjadi kecil sehingga dapat dikerjakan oleh programmer atau dipecah menjadi beberapa tahap sehingga mempermudah pengerjaan dalam sebuah projek










Jenis-jenis fungsi pada program C++ antara lain ;
1. Void 
Fungsi void atau prosedur. Disebut void dikarenakan fungsi tersebut tidak mengembalikan suatu nilai output yang diperoleh dari hasil proses fungsi tersebut.
Ciri-ciri dari jenis fungsi Void sebagai berikut:
- Selalu menggunakan keyword void.
- Tidak dapat langsung ditampilkan hasil inputan dan outputannya.
- Tidak terdapat keyword return.

2. Non Void
Fungsi non-void disebut juga function. Disebut non-void karena mengembalikan nilai kembalian yang berasal dari keluaran hasil proses function tersebut .
Ciri-ciri dari jenis fungsi non void adalah sebagai berikut:
- Tidak adanya keyword void
- Memiliki sebuah nilai balikan.
- terdapat keyword return
- Dapat dianalogikan sebagai suatu variabel yang memiliki tipe data tertentu sehingga dapat langsung ditampilkan hasilnya

Parameter adalah hubungan antar fungsi yang satu dengan fungsi yang lain yang bersifat tidak tergantung satu sama lain, ada tiga jenis parameter dalam pemrograman antara lain;
- parameter masukan
- parameter keluaran
- parameter gabungan antara masukan dan keluaran

Ada beberapa cara menggunakan fungsi dalam bahasa C. Kita bisa menggunakan fungsi dengan. Kemudian kita juga bisa menggunakan fungsi dengan atau tanpa argumen/parameter. Dan yang terakhir kita juga bisa menggunakan fungsi dengan atau tanpa menghasilkan nilai balik.
Implementasi
Contoh : Hitung luas segitiga dengan menggunakan fungsi
-          Input alas dan tinggi
-          Output luas segitiga
Jawab
Main () {
                        Float luas segitiga()
                        {
                                    Float alas = 6, tinggi =8 ;
                                    Float hasil = (alas*tinggi/2);
                                    Return hasil ;
                        }
            }

Dengan prosedur
Main () {
                        Int a
                        Int t
                        Float luas segitiga = luas (6,8)
}
Void luas segitiga (int a, int t)
{
            Float luas segitiga = (a*t)/2 ;
            Return (luas segitiga);

}


NAMA = MUHAMAD ALIV FAHRUDIN
NIM = A11.2013.07901
MATA KULIAH = SP ALPRO
http://dinus.ac.id/
http://dinus.ac.id/

Contoh Pertemuan Ke-2 Dari Sebuah Tipe Bentukan

Contoh Pertemuan Ke-2 Dari Sebuah Tipe Bentukan 

JUDUL
MENGHITUNG JUMLAH KERAMIK SUATU RUMAH

KAMUS

type kamar standart A
<
float pj
float lbr
float luas
>
type kamar standart B
<
float pj
float lbr
float luas
>
type kamar VIP
<
float pj
float lbr
float luas
>
type kamar mandi
<
float pj
float lbr
float luas
>
type kamar dapur
<
float pj
float lbr
float luas
>
type kamar space
<
float pj
float lbr
float luas
>
type keramik A
<
float pj
float lbr
>
type keramik B
<
float pj
float lbr
>
type keramik B
<
float pj
float lbr
>
type keramik C
<
float pj
float lbr
>
type keramik D
<
float pj
float lbr
>
type luas lantai
<
float luas
>
type keramik yang dibutuhkan dalam ruangan
<
float Total_JmlKrmk_KmTidurStd_A
float Total_JmlKrmk_KmTidurStd_B
float Total_JmlKrmk_KmTidurStdVIP
float Total_JmlKrmk_KmMandi
float Total_JmlKrmk_Dapur
float Total_JmlKrmk_Space
>
type total keramik yang dibutuhkan
<
float total
>

DESKRIPSI

Luas Kamar Standar A

Pjg_KmTidurStd_A  <- 4 
Lbr_KmTidurStd_A  <- 2
Luas_KmTidurStd_A <- Pjg_KmTidurStd_A x Lbr_KmTidurStd_B
Outuput  <-("Jumlah Luas kamar standart A menurut Panjang "+Pjg_KmTidurStd_A+" dan Lebar "+Lbr_KmTidurStd_A+" sebesar "+Luas_KmTidur Std_A" .")

Luas Kamar Standar B
Pjg_KmTidurStd_B  <- 4
Lbr_KmTidurStd_B  <- 2
Luas_KmTidurStd_B <- Pjg_KmTidurStd_B x Lbr_KmTidurStd_B
Outuput  <-("Jumlah Luas kamar standart B menurut Panjang "+Pjg_KmTidurStd_B+" dan Lebar "+Lbr_KmTidurStd_B+" sebesar "+Luas_KmTidur Std_B" .")

Luas Kamar VIP
Pjg_KmTidurVIP  <- 4
Lbr_KmTidurVIP  <- 4
Luas_KmTidurVIP <- Pjg_KmTidurVIP x Lbr_KmTidurVIP
Outuput  <-("Jumlah Luas kamar VIP menurut Panjang "+Pjg_KmTidurVIP+" dan Lebar "+Lbr_KmTidurVIP+" sebesar "+Luas_KmTidurVIP" .")


Luas Kamar Mandi
Pjg_KmMandi <- 3
Lbr_KmMandi <- 3
Luas_KmMandi<- Pjg_KmMandi_A x Lbr_KmMandi_A
Outuput  <-("Jumlah Luas kamar Mandi menurut Panjang "+Pjg_KmMandi_A+" dan Lebar "+Lbr_KmMandi_A+" sebesar "+Luas_KmMandi_A" .")

Luas Dapur
Pjg_Dapur <- 3
Lbr_Dapur <- 4
Luas_Dapur <- Pjg_Dapur x Lbr_Dapur
Outuput  <-("Jumlah Luas Dapur menurut Panjang "+Pjg_Dapur+" dan Lebar "+Lbr_Dapur+" sebesar "+Luas_Dapur" .")

Luas Space
Pjg_Teras <- 8
Lbr_Teras <- 3
Luas_Teras <- Pjg_Teras x Lbr_Teras
Outuput  <-("Jumlah Luas Teras menurut Panjang "+Pjg_Teras+" dan Lebar "+Lbr_Teras+" sebesar "+Luas_Teras" .")

======================================================================================================================================================================================================

Keramik untuk Kamar Standar A
Krmk_B <- 0,96
Luas_KmTidurStd_A
Total_JmlKrmk_KmTidurStd_A <- Krmk_B x Luas_KmTidurStd_A /* Jumlah total box keramik untuk ruangan kamar standar A */
Output <- ("Jumlah Keramik yang dibutuhkan kamar tidur standart A menurut jenis keramik "+Krmk_B+" dan Luas kamar "+Luas_KmTidurStd_A+" adalah sebanyak "+Total_JmlKrmk_KmTidurStd_A+" box keramik").

Keramik untuk Kamar Standar B
Krmk_C <- 0,96
Luas_KmTidurStd_B
Total_JmlKrmk_KmTidurStd_B <- Keramik_B x Luas_KmTidurStd_B /* Jumlah total box keramik untuk ruangan kamar standar B */
Output <- ("Jumlah Keramik yang dibutuhkan kamar tidur standart B menurut jenis keramik "+Krmk_C+" dan Luas kamar "+Luas_KmTidurStd_B+" adalah sebanyak "+Total_JmlKrmk_KmTidurStd_B+" box keramik").

Keramik untuk Kamar VIP
Krmk_D <- 1,08
Luas_KmTidurVIP
Total_JmlKrmk_KmTidurVIP <- Keramik_A x Luas_KmTidurVIp /* Jumlah total box keramik untuk ruangan kamar VIP */
Output <- ("Jumlah Keramik yang dibutuhkan kamar tidur VIP berdasarkan jenis keramik "+Krmk_D+" dan Luas kamar "+Luas_KmTidurVIP+" adalah sebanyak "+Total_JmlKrmk_KmTidurVIP+" box keramik").

========================================================================================================================================================================================================

Keramik untuk Kamar Mandi
Krmk_A <- 0,99
Luas_KmMandi_A
Total_JmlKrmk_KmMandi <- Krmk_A x Luas_KmMandi_A /* J
umlah total box keramik untuk ruangan kamar Mandi */
Output <- ("Jumlah Keramik yang dibutuhkan kamar Mandi menurut jenis keramik "+Krmk_A+" dan Luas kamar mandi "+Luas_KmMandi_A+" adalah sebanyak "+Total_JmlKrmk_KmMandi+" box keramik").


Keramik untuk Dapur
Krmk_A  <- 0,99
Luas_Dapur
Total_JmlKrmk_Dapur <- Krmk_A x Luas_Dapur /* Jumlah total box keramik untuk ruangan Dapur */
Output <- ("Jumlah Keramik yang dibutuhkan Dapur menurut jenis keramik "+Krmk_A+" dan Luas Dapur "+Luas_Dapur+" adalah sebanyak "+Total_JmlKrmk_Dapur+" box keramik").


Keramik untuk Space */
Krmk_A <- 0,99
Luas_Teras
Total_JmlKrmk_Teras <- Krmk_A x Luas_Teras /* Jumlah total box keramik untuk ruangan Teras */
Output <- ("Jumlah Keramik yang dibutuhkan Space menurut jenis keramik "+Krmk_A+" dan Luas Teras "+Luas_Teras+" adalah sebanyak "+Total_JmlKrmk_Teras+" box keramik").

========================================================================================================================================================================================================

Total Jumlah Keramik Yang Dibutuhkan
Total_Krmk <- Total_JmlKrmk_KmTidurStd_A + Total_JmlKrmk_KmTidurStd_B + Total_JmlKrmk_KmTidurVIP + Total_JmlKrmk_KmMandi + Total_JmlKrmk_Dapur + Total_JmlKrmk_Space
Output (" Jumlah Total keseluruhan keramik yang dibutuhkan adalah sebanyak "+Total_Krmk+" box Keramik ")






NAMA =  MUHAMAD ALIV FAHRUDIN
NIM     = A11.2013.07901
MATA KULIAH = SP ALPRO
http://dinus.ac.id/

Pertemuan Ke-2 mengamati tipe bentukan Algoritma Pemrograman ( SP ).

Pertemuan Ke-2 mengamati tipe bentukan Algoritma Pemrograman ( SP ).

Tipe bentukan adalah tipe yang didefenisikan sebagai oleh pemogram (user defined type data). Tipe bentukan ini di susun oleh satu atau lebih dari sebuah tipe dasar. Ada 2 macam tipe bentukan :
1. Tipe dasar yang diberikan sebuah nama tipe baru
2. Tipe terstruktur

Tipe dasar ini menjadi nama tipe baru (user defined type data). Sebagai penamaan tipe baru disebabkan oleh beberapa kemungkinan yang terjadi untuk membantu memudahkan interpretasi dan bacaan program oleh pemogram.
Kita dapat melakukan untuk memberi nama baru untuk tipe dasar-dasar tersebut dengan kata kunci type. Untuk Menilai, Nilai, konstanta, dan operasi-operasi tipe tersebut tidak akan berubah dan sesuai dengan tipe dasar-dasar aslinya, misalnya mungkin : type bilangan bulat / integer.
Keterangan. Bilangan sama saja dengan sebuah tipe integer. Jadi, kemungkinan variabel i bertipe sebuah bilangan bulat, sama seperti jika i bertipe integer.

Sebuah tipe bentukan bisa mungkin dikatakan sebagai “tipe yang sengaja” dibuat oleh programer guna memudahkan pemrograman. Apakah penting ?? Bisa penting bisa juga mungkin tidak. Ketika sebagian kita berbicara sebuah data dengan atribut yang banyak dan kompleks,
maka sebagian tipe bentukan bisa terjadi karena akan sangat berguna untuk mengelompokan data dan membuatnya terlihat lebih teratur.

NAMA = MUHAMAD ALIV FAHRUDIN 

NIM     = A11.2013.07901
MATA KULIAH = SP ALPRO
http://dinus.ac.id/ 

Contoh Pertemuan Ke-1 Materi Pertemuan Pertama Algoritma Pemrograman ( SP )

Contoh  Pertemuan Ke-1 Materi Pertemuan Pertama Algoritma Pemrograman ( SP )

Deskripsi Rumah :
1. Teras
2. Kamar Tidur 3 terdiri dari : Km. Tidur Standar A, Km. Tidur Standar B dan Km. Tidur VIP 1.
3. Kamar Mandi 2 terdiri dari : Km. Mandi A dan Km. Mandi B.
4. Dapur

Luas tiap kamar / ruangan :
1. Luas Teras : 8 m2 x 3 m2
2. Luas Kamar Tidur Standard A : 4 m2 x 2 m2
3. Luas Kamar Tidur Standard B : 4 m2 x 2 m2
4. Luas Kamar Tidur VIP : 5 m2 x 4 m2
5. Luas Kamar Mandi A : 4 m2 x 2 m2
6. Luas Kamar Mandi B : 4 m2 x 2 m2
7. Luas Dapur : 4 m2 x 4 m2

Luas keseluruhan lantai :
LUAS LANTAI RUMAH : ( 8 m2 x 3 m2)+(4 m2 x 2 m2)+(4 m2 x 2 m2)+(5 m2 x 4 m2)+(4 m2 x 2 m2)+(4 m2 x 2 m2)+(4 m2 x 4 m2)
TOTAL : 92 m2

Kebutuhan Keramik

Keramik kamar Tidur Std A : 0,40m x 0,40m x 6 = 0,96 m2
Sehingga : 0,96 m2 x 16 m2 = 15.36 Kotak Keramik
Keramik kamar Tidur Std B : 0,40m x 0,40m x 6 = 0,96 m2
Sehingga : 0,96 m2 x 16 m2 = 15.36 Kotak Keramik
Keramik kamar Tidur VIP : 0,40m x 0,40m x 6 = 0,96 m2
Sehingga : 0,96 m2 x 20 m2 = 19.2 Kotak Keramik
Total keramik kamar tidur : 15.36 + 15.36 + 19.2 = 49.92 Kotak Keramik <>

Keramik Teras : 0,60m x 0,60m x 4 = 1,44 m2
Sehingga : 1,44 m2 x 24 m2 = 34.56 Kotak Keramik <>

Keramik Dapur : 0,30 x 0,30 x 11 = 0,99 m2
Sehingga : 0,99 m2 x 16 m2 = 15.84 Kotak Keramik

Keramik Kamar Mandi A : 0,2m x 0,2m x 25 = 1 m2
Sehingga : 1 m2 x 16 m2 = 16 Kotak Keramik

Keramik Kamar Mandi B : 0,2m x 0,2m x 25 = 1 m2
Sehingga : 1 m2 x 16 m2 = 16 Kotak Keramik

TOTAL SELURUH KEBUTUHAN KERAMIK IALAH : 49,92 + 34,56 + 15,84 + 16 + 16 = 132.32 dibulatkan menjadi 133 kotak keramik.

==----------------------------------------------------------------------------------------------------------------------------------------==

NOTASI ALGORITMA PROGRAM

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
JUDUL : ALGORITMA PROGRAM MENGHITUNG KEBUTUHAN KERAMIK PADA SEBUAH RUMAH BERUKURAN 39.8m x 39.8m

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
KAMUS :
/* Keterangan */
/* Pjg = Panjang ; Lbr = Lebar ; Km = Kamar ; Jml = Jumlah */


/* Variabel Kamar Tidur */
- riil Pjg_KmTidurStd_A   /* Variabel untuk nilai Panjang dari Kamar Tidur Standard A */
- riil Lbr_KmTidurStd_A   /* Variabel untuk nilai Lebar dari Kamar Tidur Standard A */
- riil Luas_KmTidurStd_A  /* Variabel Jumlah Luas dari perhitungan variabel Pjg_KmTidurStd_A x  variabel Lbr_KmTidurStd_A */

- riil Pjg_KmTidurStd_B   /* Variabel untuk nilai Panjang dari Kamar Tidur Standard B */
- riil Lbr_KmTidurStd_B   /* Variabel untuk nilai Lebar dari Kamar Tidur Standard B */
- riil Luas_KmTidurStd_B  /* Variabel Jumlah Luas dari perhitungan variabel Pjg_KmTidurStd_B x  variabel Lbr_KmTidurStd_B */

- riil Pjg_KmTidurVIP     /* Variabel untuk nilai Panjang dari Kamar Tidur VIP */
- riil Lbr_KmTidurVIP     /* Variabel untuk nilai Lebar dari Kamar Tidur VIP */
- riil Luas_KmTidurVIP    /* Variabel Jumlah Luas dari perhitungan variabel Pjg_KmTidurVIP x  variabel Lbr_KmTidurVIP */



/* Variabel Kamar Mandi */
- riil Pjg_KmMandi_A   /* Variabel untuk nilai Panjang dari Kamar Mandi A */
- riil Lbr_KmMandi_A   /* Variabel untuk nilai Lebar dari Kamar Mandi A */
- riil Luas_KmMandi_A  /* Variabel Jumlah Luas dari perhitungan variabel Pjg_KmMandi_A x  variabel Lbr_KmMandi_A */

- riil Pjg_KmMandi_B   /* Variabel untuk nilai Panjang dari Kamar Mandi B */
- riil Lbr_KmMandi_B   /* Variabel untuk nilai Lebar dari Kamar Mandi B */
- riil Luas_KmMandi_B  /* Variabel Jumlah Luas dari perhitungan variabel Pjg_KmMandi_B x  variabel Lbr_KmMandi_B */

-riil Total_Luas_KmMandi /* Variabel Total_Luas_KmMandi diperoleh melalui Jumlah Luas_KmMandi_A + Luas_KmMandi_B */

/* Variabel Dapur */
- riil Pjg_Dapur  /* Variabel untuk nilai Panjang dari Dapur */
- riil Lbr_Dapur  /* Variabel untuk nilai Lebar dari Dapur */
- riil Luas_Dapur /* Variabel Jumlah Luas dari perhitungan variabel Pjg_Dapur x  variabel Lbr_Dapur */

/* Variabel Teras */
- riil Pjg_Teras  /* Variabel untuk nilai Panjang dari halaman teras */
- riil Lbr_Teras  /* Variabel untuk nilai Lebar dari halaman teras */
- riil Luas_Teras /* Variabel Jumlah Luas dari perhitungan variabel PjgTeras x  variabel LbrTeras */

/* Variabel LUAS LANTAI */
- riil Luas_Lantai_Rumah /* Variabel Luas Lantai diperoleh melalui jumalh total dari Total_Luas_KmTidur + Total_Luas_KmMandi + Luas_Dapur + Luas_Teras */


/* Variabel Keterangan Jenis Keramik berdasarkan Ukuran nya */
- riil Keramik_A = 0,96  /* Keramik yang berukuran 40cm x 40cm dan 1 kotaknya berisi 6  keping jadi isi variabelnya hasil dari perhitungan : 0,40m x 0,40m x 6   = 0,96 m2 */
- riil Keramik_B = 0,99  /* Keramik yang berukuran 30cm x 30cm dan 1 kotaknya berisi 11 keping jadi isi variabelnya hasil dari perhitungan : 0,30m x 0,30m x 11  = 0,99 m2 */
- riil Keramik_C = 1 /* Keramik yang berukuran 20cm x 20cm dan 1 kotaknya berisi 25 keping jadi isi variabelnya hasil dari perhitungan : 0,2m  x 0,2m  x 25  = 1 m2 */
- riil Keramik-D = 1.08 /* Keramik yang berukuran 60cm x 60cm dan 1 kotaknya berisi 4 keping jadi isi variabelnya hasil dari perhitungan  : 0,60m  x 0,60m  x 4 = 1,08 m2 */


/* Variabel Kebutuhan Keramik berdasarkan Kamar */
- riil Total_JmlKeramik_KmTidurStd_A   /* Variabel untuk hasil perhitungan : Keramik_A x Luas_KmTidurStd_A (Karena pada kamar tidur standart A menggunakan keramik yang berukuran 40 cm x 40 cm */
- riil Total_JmlKeramik_KmTidurStd_B   /* Variabel untuk hasil perhitungan : Keramik_A x Luas_KmTidurStd_B (Karena pada kamar tidur standart B menggunakan keramik yang berukuran 40 cm x 40 cm */
- riil Total_JmlKeramik_KmTidurVIP   /* Variabel untuk hasil perhitungan : Keramik_A x Luas_KmTidurVIP (Karena pada kamar tidur VIP menggunakan keramik yang berukuran 40 cm x 40 cm */
- riil Total_JmlKeramik_KmMandi_A   /* Variabel untuk hasil perhitungan : Keramik_B x Luas_KmMandi_A (Karena pada kamar mandi A menggunakan keramik yang berukuran 30 cm x 30 cm */
- riil Total_JmlKeramik_KmMandi_B   /* Variabel untuk hasil perhitungan : Keramik_B x Luas_KmMandi_B (Karena pada kamar mandi B menggunakan keramik yang berukuran 30 cm x 30 cm */
- riil Total_JmlKeramik_Dapur     /* Variabel untuk hasil perhitungan : Keramik_C x Luas_Dapur   (Karena pada Dapur menggunakan keramik yang berukuran   20 cm x 20 cm */
- riil Total_JmlKeramik_Teras  /* Variabel untuk hasil perhitungan : Keramik_D x Luas_Teras   (Karena pada Teras menggunakan keramik yang berukuran 60 cm x 60 cm */

/* TOTAL KESELURUHAN KEBUTUHAN KERAMIK */
- riil Total_Keramik /* Variabel untuk hasil perhitungan dari : Total_JmlKeramik_KmTidurStd_A + Total_JmlKeramik_KmTidurStd_B + Total_JmlKeramik_KmTidurVIP + Total_JmlKeramik_KmMandi_A + Total_JmlKeramik_KmMandi_B + Total_JmlKeramik_Dapur + Total_JmlKeramik_Teras */

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

DESKRIPSI :

/* Hitung Luas Kamar Tidur Standar A */
Pjg_KmTidurStd_A  <- 4  /* Nilai Panjang dari Kamar tidur standar A */
Lbr_KmTidurStd_A  <- 2 /* Nilai Lebar dari Kamar tidur standar A */
Luas_KmTidurStd_A <- Pjg_KmTidurStd_A x Lbr_KmTidurStd_B /* Jumlah Luas pada Kamar tidur standar A */
Outuput  <-("Jumlah Luas kamar tidur standart A berdasarkan Panjang "+Pjg_KmTidurStd_A+" dan Lebar "+Lbr_KmTidurStd_A+" Ialah sebesar "+Luas_KmTidur Std_A" .")

/* Hitung Luas Kamar Tidur Standar B */
Pjg_KmTidurStd_B  <- 4 /* Nilai Panjang dari Kamar tidur standar B */
Lbr_KmTidurStd_B  <- 2 /* Nilai Lebar dari Kamar tidur standar B */
Luas_KmTidurStd_B <- Pjg_KmTidurStd_B x Lbr_KmTidurStd_B /* Jumlah Luas pada Kamar tidur standar B */
Outuput  <-("Jumlah Luas kamar tidur standart B berdasarkan Panjang "+Pjg_KmTidurStd_B+" dan Lebar "+Lbr_KmTidurStd_B+" Ialah sebesar "+Luas_KmTidur Std_B" .")

/* Hitung Luas Kamar Tidur VIP */
Pjg_KmTidurVIP  <- 5 /* Nilai Panjang dari Kamar tidur VIP */
Lbr_KmTidurVIP  <- 4 /* Nilai Lebar dari Kamar tidur VIP */
Luas_KmTidurVIP <- Pjg_KmTidurVIP x Lbr_KmTidurVIP /* Jumlah Luas pada Kamar tidur VIP */
Outuput  <-("Jumlah Luas kamar tidur VIP berdasarkan Panjang "+Pjg_KmTidurVIP+" dan Lebar "+Lbr_KmTidurVIP+" Ialah sebesar "+Luas_KmTidurVIP" .")


/* Hitung Luas Kamar Mandi A */
Pjg_KmMandi_A  <- 4 /* Nilai Panjang dari Kamar Mandi A */
Lbr_KmMandi_A  <- 2 /* Nilai Lebar dari Kamar Mandi A */
Luas_KmMandi_A <- Pjg_KmMandi_A x Lbr_KmMandi_A /* Jumlah Luas pada Kamar Mandi A */
Outuput  <-("Jumlah Luas kamar Mandi A berdasarkan Panjang "+Pjg_KmMandi_A+" dan Lebar "+Lbr_KmMandi_A+" Ialah sebesar "+Luas_KmMandi_A" .")

/* Hitung Luas Kamar Mandi B */
Pjg_KmMandi_B  <- 4  /* Nilai Panjang dari Kamar Mandi B */
Lbr_KmMandi_B  <- 2 /* Nilai Lebar dari Kamar Mandi B */
Luas_KmMandi_B <- Pjg_KmMandi_B x Lbr_KmMandi_B /* Jumlah Luas pada Kamar Mandi B */
Outuput  <-("Jumlah Luas kamar Mandi B berdasarkan Panjang "+Pjg_KmMandi_B+" dan Lebar "+Lbr_KmMandi_B+" Ialah sebesar "+Luas_KmMandi_B" .")

/* Hitung Luas Dapur */
Pjg_Dapur <- 4 /* Nilai Panjang pada ruangan Dapur */
Lbr_Dapur <- 4 /* Nilai Lebar pada ruangan Dapur */
Luas_Dapur <- Pjg_Dapur x Lbr_Dapur /* Jumlah Luas pada ruangan Dapur */
Outuput  <-("Jumlah Luas Dapur berdasarkan Panjang "+Pjg_Dapur+" dan Lebar "+Lbr_Dapur+" Ialah sebesar "+Luas_Dapur" .")

/* Hitung Luas Teras */
Pjg_Teras <- 8 /* Nilai Panjang pada ruangan Teras */
Lbr_Teras <- 3 /* Nilai Lebar pada ruangan Teras */
Luas_Teras <- Pjg_Teras x Lbr_Teras /* Jumlah Luas pada ruangan Teras */
Outuput  <-("Jumlah Luas Teras berdasarkan Panjang "+Pjg_Teras+" dan Lebar "+Lbr_Teras+" Ialah sebesar "+Luas_Teras" .")
------------------------------------------------------------------------------------------------------------------------------------------

/* Menghitung kebutuhan Keramik untuk Kamar Tidur Standar A */
Keramik_A <- 0,96 /* Nilai Jenis keramik_A dengan ukuran 40cm x 40cm */
Luas_KmTidurStd_A /* Hasil dari Luas Kamar Tidur Standar A */
Total_JmlKeramik_KmTidurStd_A <- Keramik_A x Luas_KmTidurStd_A /* Total jumlah kebutuhan dus keramik untuk ruangan kamar tidur standar A */
Output <- ("Jumlah Keramik yang dibutuhkan kamar tidur standart A berdasarkan jenis keramik "+Keramik_A+" dan Luas kamar tidur "+Luas_KmTidurStd_A+" ialah sebanyak "+Total_JmlKeramik_KmTidurStd_A+" Kotak keramik").

/* Menghitung kebutuhan Keramik untuk Kamar Tidur Standar B */
Keramik_A <- 0,96 /* Nilai Jenis keramik_A dengan ukuran 40cm x 40cm */
Luas_KmTidurStd_B /* Hasil dari Luas Kamar Tidur Standar B */
Total_JmlKeramik_KmTidurStd_B <- Keramik_B x Luas_KmTidurStd_B /* Total jumlah kebutuhan dus keramik untuk ruangan kamar tidur standar B */
Output <- ("Jumlah Keramik yang dibutuhkan kamar tidur standart B berdasarkan jenis keramik "+Keramik_A+" dan Luas kamar tidur "+Luas_KmTidurStd_B+" ialah sebanyak "+Total_JmlKeramik_KmTidurStd_B+" Kotak keramik").

/* Menghitung kebutuhan Keramik untuk Kamar Tidur VIP */
Keramik_A <- 0,96 /* Nilai Jenis keramik_A dengan ukuran 40cm x 40cm */
Luas_KmTidurVIP /* Hasil dari Luas Kamar Tidur VIP */
Total_JmlKeramik_KmTidurVIP <- Keramik_A x Luas_KmTidurVIp /* Total jumlah kebutuhan dus keramik untuk ruangan kamar tidur VIP */
Output <- ("Jumlah Keramik yang dibutuhkan kamar tidur VIP berdasarkan jenis keramik "+Keramik_A+" dan Luas kamar tidur "+Luas_KmTidurVIP+" ialah sebanyak "+Total_JmlKeramik_KmTidurVIP+" Kotak keramik").

|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

/* Menghitung kebutuhan Keramik untuk Kamar Mandi A */
Keramik_A <- 0,99 /* Nilai Jenis keramik_B dengan ukuran 20cm x 20cm */
Luas_KmMandi_A /* Hasil dari Luas Kamar Mandi A */
Total_JmlKeramik_KmMandi_A <- Keramik_B x Luas_KmMandi_A /* Total jumlah kebutuhan dus keramik untuk ruangan kamar Mandi A */
Output <- ("Jumlah Keramik yang dibutuhkan kamar Mandi A berdasarkan jenis keramik "+Keramik_B+" dan Luas kamar mandi A "+Luas_KmMandi_A+" ialah sebanyak "+Total_JmlKeramik_KmMandi_A+" Kotak keramik").

/* Menghitung kebutuhan Keramik untuk Kamar Mandi B */
Keramik_A <- 0,99 /* Nilai Jenis keramik_B dengan ukuran 20cm x 20cm */
Luas_KmMandi_B /* Hasil dari Luas Kamar Mandi B */
Total_JmlKeramik_KmMandi_B <- Keramik_B x Luas_KmMandi_B /* Total jumlah kebutuhan dus keramik untuk ruangan kamar Mandi B */
Output <- ("Jumlah Keramik yang dibutuhkan kamar Mandi B berdasarkan jenis keramik "+Keramik_B+" dan Luas kamar mandi B "+Luas_KmMandi_B+" ialah sebanyak "+Total_JmlKeramik_KmMandi_B+" Kotak/Dus keramik").

|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

/* Menghitung kebutuhan Keramik untuk Dapur */
Keramik_C <- 1 /* Nilai Jenis keramik_C dengan ukuran 30cm x 30cm */
Luas_Dapur /* Hasil dari Luas Dapur */
Total_JmlKeramik_Dapur <- Keramik_C x Luas_Dapur /* Total jumlah kebutuhan dus keramik untuk ruangan Dapur */
Output <- ("Jumlah Keramik yang dibutuhkan Dapur berdasarkan jenis keramik "+Keramik_C+" dan Luas Dapur "+Luas_Dapur+" ialah sebanyak "+Total_JmlKeramik_Dapur+" Kotak/Dus keramik").

||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

/* Menghitung kebutuhan Keramik untuk Teras */
Keramik_D <- 1,08 /* Nilai Jenis keramik_D dengan ukuran 60cm x 60cm */
Luas_Teras /* Hasil dari Luas Teras */
Total_JmlKeramik_Teras <- Keramik_C x Luas_Teras /* Total jumlah kebutuhan dus keramik untuk ruangan Teras */
Output <- ("Jumlah Keramik yang dibutuhkan Teras berdasarkan jenis keramik "+Keramik_D+" dan Luas Teras "+Luas_Teras+" ialah sebanyak "+Total_JmlKeramik_Teras+" Kotak/Dus keramik").

========================================================================================================

/* Hasil perhitungan total jumlah keramik keseluruha yang dibutuhkan rumah tersebut */
Total_Keramik <- Total_JmlKeramik_KmTidurStd_A + Total_JmlKeramik_KmTidurStd_B + Total_JmlKeramik_KmTidurVIP + Total_JmlKeramik_KmMandi_A + Total_JmlKeramik_KmMandi_B + Total_JmlKeramik_Dapur + Total_JmlKeramik_Teras
Output (" Total keramik jumlah keseluruhan pada rumah doni yang dibutuhkan sebanyak "+Total_Keramik+" Kota/Dus Keramik ")

==============================================================================================================================



NAMA = MUHAMAD ALIV FAHRUDIN
NIM = A11.2013.07901
MATA KULIAH = SP ALPRO
http://dinus.ac.id/

Pertemuan Ke-1 Materi Pertemuan Pertama Algoritma Pemrograman ( SP )

Pertemuan Ke-1 Materi Pertemuan Pertama Algoritma Pemrograman ( SP )

Pengertian Algoritma. menurut kesimpulan dari berbagai ahli dan  pertemuan yang lalu Algoritma itu adalah bagaimana berfikir sistematis dan logis.
Menurut kamus besar bahasa indonesia ( KBBI ) sebuah algoritma adalah urutan logis atau logika dalam pengambilan keputusan pemecahan masalah. berdasarkan sebuah riset definisi- definisi tersebut maka.
memungkinkan dapat disimpulkan bahwa algoritma adalah urutan langkah- langkah logis atau yang terhingga dan yang dapat digunakan untuk memecahkan sebuah permasalahan yang terjadi.
di dalam langkah-langkah algoritma harus mempunyai sebuah unsur logis, ini berarti hasil dari urutan tersebut harus dapat di tentukan, benar atau salah. Yang tidak benar dapat memberikan hasil yang salah.
Pengertian coding. Coding jika di artikan dengan istilah ke dalam kamus besar bahasa Indonesia dapat diartikan adalah Pemrograman.
Bahasa yang sering digunakan oleh Operating System di dalam melakukan suatu tugas tertentu disebut Coding.

Pengertian source code. Dalam Komputer, source code disebut juga dengan  source adalah kumpulan pernyataan atau deklarasi bahasa pemrogramman komputer dan dapat di baca manusia.
Source code kemungkinankan programmer untuk komunikasi dengan komputer digunakan beberapa perintah yang telah di indentifikasi beberapa faktor.
Source Code program yang biasanya dibuat satu atau lebih file teks,Disimpan dalam database yang disisipkan oleh sebagai prosedur dan dapat juga sebagai potongan code yang tercetak di buku.
Pengertian Paradigma Paradigma adalah cara untuk melihat diri sendiri dan lingkungan sekitar mempengaruhi sebuah pemikiran kognitif, sikap afektif, dan perilaku.
Paradigma juga dapat di artikan seperangkat konsep, nilai-nilai, dan praktik yang diterapkan dalam memandang realita yang terjadi  dalam sebuah kompleks komunitas yang sama,disiplin intelektual.
Pengertian type data. Tipe data adalah nilai yang dapat dinyatakan dalam bentuk konstanta atau variabel dan operator. konstanta menyatakan nilai yang tidak bakal berubah Sedangkan variabel menyatakan nilai yang dapat berubah-ubah selama eksekusi berlangsung.

NAMA = MUHAMAD ALIV FAHRUDIN
NIM     = A11.2013.07901
MATA KULIAH = SP ALPRO
http://dinus.ac.id/ 

Looping (Pengulangan) atau Looping (Repetition)

Looping (Pengulangan)

Loop atau perulangan adalah suatu bentuk kegiatan mengulang suatu statement sampai batas yang diinginkan. Dalam pemograman Loop atau perulangan sangat berguna sekali. Kegunaan sederhana dalam perulangan terlukis seperti ini: Jika kita ingin menuliskan kata “saya ganteng” sebanyak seribu kali maka kita harus membuat seribu baris kata “saya ganteng” dalam kode pemrogaman kita. Tapi dengan adanya perulangan maka kita hanya cukup menuliskan 5 sampai 7 baris kode saja. Dalam praktek sebenarnya, tentu saja perulangan sangat membantu sekali. Misal untuk memuat seluruh isi table dari sebuah database dimana datanya ingin kita tampilkan.
Loop atau perulangan dalam Java dapat dilakukan dengan 3 teknik:


• Perulangan dengan for

for (inisialisasi ekspresi; kondisi loop; ekspresi penambahan){

// pernyataan

}

Perulangan dengan teknik ini dikontrol oleh tiga bagian yang ada dalam tanda kurung dan masing-masing bagian ini dipisahkan oleh titik-koma. Pada bagian pertama(inisialisasi ekspresi), sebuah variabel akan di deklarasikan sebagai sebuah titik awal dari perulangan, biasanya variable ini mempunyai tipe data integer atau float. Sementara pada bagian kedua disinilah perulangan akan diperiksa apakah masih memenuhi syarat atau tidak, jika masih memenuhi syarat maka statement dibawahnya akan di eksekusi. Sedangkan bagian ketiga adalah bagian dimana jika bagian kedua masih memenuhi syarat maka nilai variabel akan ditambahkan sesuai dengan syarat yang dituliskan. Bagian ketiga ini secara otomatis akan tidak dibaca oleh program jika kondisi pada bagian ke-dua sudah tidak lagi memenuhi syarat, dan perulangan pun menjadi terhenti. Untuk lebih jelasnya perhatikan potongan contoh berikut ini:

for (int i=0; i <=1000; i++){

System.out.println(“Saya Ganteng”);

}

Jika digambarkan jalannya program akan seperti ini: variable i akan di inisialisasi pertama kali dan langsung diberi nilai 0, kemudian variable i tersebut akan diperiksa pada bagian kedua, apakah i lebih kecil atau sama dengan 1000, jika nilai I pertama kali adalah 0 maka pernyataan tersebut bernilai benar (true), sehingga bagian ketiga pun di eksekusi dan kali ini nilai i menjadi sama dengan 1. setelah nilai i bertambah menjadi 1 maka langkah selanjutnya program akan mengeksekusi baris pernyataan yang ada didalam tanda kurung, program akan menuliskan ke layar “Saya Ganteng”. Setelah itu kursor baris akan kembali lagi keatas ke posisi for lagi, namun inisialisasi variabel dilewatkan dan langsung ke bagian kedua yaitu memeriksa apakah i <=1000, dan jika masih memenuhi syarat maka bagian ketiga dan baris statement pun di eksekusi kembali, demikian seterusnya hinga nilai variabel i sudah menjadi sama dengan 1001. Jika nilai variabel i sudah tidak lagi memenuhi syarat bagian kedua maka program akan tidak mengeksekusi bagian ketiga dan baris statement, dan pada saat ini pula loop atau perulangan akan berhenti. Jika digambarkan dalam diagram maka seperti inilah perulangan dengan for itu tergambar

·                     Perulangan dengan while.

while(ekspresi){

//statement

}

Perulangan dengan menggunakan teknik while ini sebenarnya adalah suatu bentuk perulangan yang memodifikasi teknik pencabangan (branching) secara kasar. Pernyataan yang ada didalam blok perulangan akan dieksekusi dengan cara memeriksa ekspresi yang ada, sepanjang ekspresi bernilai true maka statement akan terus di eksekusi. Variabel sebagai kontrol perulangan bentuk ini diinisialisai di luar blok perulangan ini. Dan penambahan atau increment nilai variabel berada didalam blok perulangan ini. Kelebihan perulangan dengan bentuk ini adalah variabel yang dideklarasikan tidak hanya bertipe integer atau float saja namun bisa juga bertipe boolean atau string. Perhatikan contoh program perulangan dengan menggunakan bentuk ini yang memakai variabel bertipe integer sebagai kontrol perulangannya:

int i=0;

while(i<=10000){

System.out.println(“Saya Ganteng”);

i++;

}

Sepanjang variable i bernilai lebih kecil sama dengan 1000 maka pernyataan mencetak ke layar “Saya Ganteng” akan tetap terus di eksekusi. Yang harus kita perhatikan jika kita menggunakan perulangan dengan teknik ini adalah bahwa incremental variabel i harus ada, sebab jika tidak yang terjadi adalah perulangan yang tidak pernah akan berhenti atau Invinitive Loop.

Kemudian mari kita lihat potongan kode yang variabel kontrolnya tidak menggunakan integer atau float, berikut ini:

boolean ctrl =false;

int i = 0;

while(ctrl==false){

System.out.println(“Saya Ganteng”);

i++;

if(i == 1000){

ctrl = true;

}

}

Perhatikan pada potongan kode program tersebut. Pernyataan mencetak kelayar “Saya Ganteng” akan terus dieksekusi selama variabel kontrol perulangan tersebut masih bernilai false, sementara trigger untuk membuat variable bernilai true adalah nilai variable i yang harus sampai dengan 1000.

Jika digambarkan dalam diagram maka sketsa perulangan dengan bentuk ini seperti gambar berikut:

·                     Perulangan dengan do while

do{

//statement

}while(ekspresi);

Perulangan dengan bentuk seperti ini adalah perulangan dengan membalikkan logika perulangan dengan teknik while. Dalam perulangan dengan bentuk ini, pernyataan dieksekusi dulu, baru kemudian kondisi variabel kontrol perulangannya diperiksa apakah memenuhi syarat atau tidak. Biar lebih mudah memahaminya mari kita lihat potongan code program berikut ini:

int i=0;

do{

System.out.println(“Saya Ganteng”);

i++;

}while(i<=10000);

Variabel kontrol perulangan tetap diinisialisasi diluar blok perulangan dan harus tetap bersifat incremental / bertambah dan letak incrementalnya ada dalam blok perulangan. Secara logika maka diagram yang bisa menggambarkan proses perulangan tersebut adalah:

·                     Perulangan dengan do while

do{

//statement

}while(ekspresi);

Perulangan dengan bentuk seperti ini adalah perulangan dengan membalikkan logika perulangan dengan teknik while. Dalam perulangan dengan bentuk ini, pernyataan dieksekusi dulu, baru kemudian kondisi variabel kontrol perulangannya diperiksa apakah memenuhi syarat atau tidak. Biar lebih mudah memahaminya mari kita lihat potongan code program berikut ini:

int i=0;

do{

System.out.println(“Saya Ganteng”);

i++;

}while(i<=10000);

Variabel kontrol perulangan tetap diinisialisasi diluar blok perulangan dan harus tetap bersifat incremental / bertambah dan letak incrementalnya ada dalam blok perulangan. Secara logika maka diagram yang bisa menggambarkan proses perulangan tersebut adalah:

in English

Looping (Repetition)

Loop or loops is a form of repeating a statement to the extent desired. In the Loop or looping programming is very useful. Simple usability in the loop illustrated like this: If we want to write the word "my handsome" as much as a thousand times so we have to make a thousand lines of the word "my handsome" in our programming code. But with the looping then we just simply write 5 to 7 lines of code only. In actual practice, of course, looping very helpful at all. For example to load the entire contents of a database table where the data we want to show.

Loop or looping in Java can be done with 3 techniques:

• Looping with for

for (initialization expression; the condition of the loop; additional expression) {

// statement

}

Recurrence with this technique is controlled by three parts that exist in parentheses and each section is separated by a semicolon. In the first (initialization expression), a variable will be declared as a starting point of the loop, usually these variables have the data type integer or float. While the second part is where the loop will be checked whether they qualify or not, if they qualify the statement below will be executed. While the third part is the part where if the second part still qualify the value of the variable will be added in accordance with the terms written. The third part will not be read automatically by the program if the condition in section two are no longer eligible, and looping became stalled. For more details see the following example snippet:

for (int i = 0; i <= 1000; i ++) {

System.out.println ("I am Handsome");

}

If the described way the program will be like this: The initialization variable i will be the first time and immediately given a value of 0, then the variable i will be examined in the second part, if i is less than or equal to 1000, when I first value is 0 then the statement is true (true), so that the third part was at this time of execution and the value of i becomes equal to 1 after the value of i increases to 1 then the next step the program will execute the statement line is in brackets, the program will write to the screen "I Hunk ". Once the cursor line will be back again up to the position for longer, but the initialization of variables passed directly to the second part is to check if i <= 1000, and if it still qualifies the third section and any statement in the execution line back, and so on hinga value variable i has become equal to 1001. If the value of the variable i is no longer qualified second part of the program will not execute the third section and line statements, and at the moment anyway loop or iteration will stop. If depicted in the diagram like this looping with for the envisaged

· Looping with while.

while (expression) {

// statement

}

Looping while using this technique is actually a form of repetition that modify branching technique (branching) roughly. Statements that are in the loop block will be executed by examining existing expression, the expression is true then all statements will continue in execution. Variables as looping control this form diinisialisai outside this loop block. And the addition or increment the value of the variable is in this iteration block. Excess looping with this shape is not only a declared variable of type integer or float alone but can also be of type boolean or string. Consider the example of a looping program by using this form using as a control variable of type integer recurrence:

int i = 0;

while (i <= 10000) {

System.out.println ("I am Handsome");

i ++;

}

Throughout the variable i is worth less the same as in 1000, the statement print to screen "I Hunk" will continue in execution. We have to consider if we are using a loop with this technique is that the incremental variable i must exist, because otherwise what happens is that the loop will never stop or Invinitive Loop.

Then let's see a snippet of code that does not use a control variable integer or float, the following:

ctrl boolean = false;

int i = 0;

while (ctrl == false) {

System.out.println ("I am Handsome");

i ++;

if (i == 1000) {

ctrl = true;

}

}

Notice in the program code snippets. Kelayar print statement "I am Handsome" will continue to be executed during the loop control variable is false, while the trigger to make the variable evaluates to true is the value of variable i to be up to 1000.

If depicted in the sketch loop diagrams with this form as shown below:

· Recurrence with do while

do {

// statement

} while (expression);

Looping with form like this is to invert the logic of looping looping techniques while. In looping with this form, the statement is executed first and then the condition of recurrence control variables examined whether qualified or not. Let easier to understand let's look at the following program code snippet:

int i = 0;

do {

System.out.println ("I am Handsome");

i ++;

} while (i <= 10000);

Fixed loop control variable is initialized outside the loop block and should remain incremental / increases and layout incrementalnya in the loop block. Logically, the diagram can describe the iteration process is:

· Recurrence with do while

do {

// statement

} while (expression);

Looping with form like this is to invert the logic of looping looping techniques while. In looping with this form, the statement is executed first and then the condition of recurrence control variables examined whether qualified or not. Let easier to understand let's look at the following program code snippet:

int i = 0;

do {

System.out.println ("I am Handsome");

i ++;

} while (i <= 10000);

Fixed loop control variable is initialized outside the loop block and should remain incremental / increases and layout incrementalnya in the loop block. Logically, the diagram can describe the iteration process is: