Post on 03-Jan-2016
description
Semester genap2011/2012
Algoritma&Pemrograman
STRUKTUR DASAR & PERINTAH DASARPrima Dewi P, AAP Ratna, Dodi Sudiana
Algoritma&Pemrograman
2
Outline
Introduction Algoritma, pseudocode Basic program structure
User friendly program Basic selection structure using IF Repetition structure
using while using for and do..while
Selection structure using switch Break and continue statement
3 Introduction
Algoritma&Pemrograman
Pendahuluan4
Sebelum membuat program: Harus memahami masalah yang
dihadapi definisi dan deskripsi masalah
Membuat perencanaan yang baik (Algoritma) untuk menyelesaikannya.
Algoritma&Pemrograman
Algoritma5
Permasalahan komputasi Dapat diselesaikan dengan mejalankan
sekumpulan kegiatan dalam urutan tertentu. Dengan cara Pengendalian Program
Algoritma&Pemrograman
Pseudocode6
Pseudocode Bahasa buatan yang tidak formal dimana
dapat membantu untuk mengembangkan algoritma
Dapat menggunakan bahasa sehari-hari Tidak dapat dijalankan dengan komputer Membantu ‘membuat’ program sebelum
membuat codingnya. Mudah untuk diterjemahkan ke dalam bentuk
bahasa pemrograman
Algoritma&Pemrograman
7
Perintah Dasar
Menyatakan algoritma Alur pemecahan masalah Mudah diimplementasi dengan bahasa pemrograman
Singkat, jelas, terstruktur, fleksibel
Konsep pengolahan data berbasis Komputer
Algoritma&Pemrograman
8
Perintah Dasar dalam pseudocode
Perintah-perintah dasar yang dapat digunakan pada pseudocode
Perintah Lambang
penulisan tulis/printf/writepembacaan baca/scanf/readpemuatan (assignment) =pengulangan while…(do)-ewhilepencabangan if…(then)-else-eif
Algoritma&Pemrograman
9
Struktur Dasar
Bohm dan Jacopini Seluruh program dapat ditulis dalam 3 struktur pengendali: Struktur berurut (sequence structure) Struktur seleksi/percabangan
(selection structure): if, if…else, and switch
Struktur pengulangan (repetition structure): while, do…while and for
10 User friendly program
Algoritma&Pemrograman
11
Program yang akrab (User friendly)
Komunikatif Mudah digunakan (memberikan Fasilitas
Kemudahan bagi pemakai) Petunjuk singkat penggunaan program Pernyataan error Cara mengatasi kesalahan Fasilitas Help
Singkat, jelas, terstruktur dan fleksibel
Algoritma&Pemrograman
Hal-hal penting yang dapat membuat program User friendly
12
Tujuan/Judul program Petunjuk pengoperasian program Pesan kesalahan Keterangan Siap Panggil Tataletak peragaan Hemat kegiatan Fleksibel
Algoritma&Pemrograman
Contoh program yang user friendly13
/*Peragakan petunjuk pengoperasian*/Write (‘Menghitung rata-rata bilangan positif \n
======================================= \n - Masukkan sembarang bil. Positif atau \n
negatif diakhiri dengan <enter> \n - Masukkan nol untuk menandakan bilangan\n
terakhir \n ----------------------------------------\n’)
/*Inisialisasi*/n = 0jumlah = 0
Algoritma&Pemrograman
14
/*Penjumlahan bilangan positif*/read (bil) while (bil<> 0) do
if (bil > 0) thenjumlah = jumlah + biln = n + 1
eif read (bil)
Ewhile
/*Penulisan hasil perhitungan*/If (n <>) 0 then
write (n, jumlah, jumlah/n)eif
15 Basic selection structure
Algoritma&Pemrograman
Struktur berurut (sequence structure)16
Eksekusi urutan/pernyataan tidak bersyarat
Proses A
Proses B
Proses C
Algoritma&Pemrograman
Struktur seleksi/percabangan (selection structure)
17
Tidak setiap baris program akan dikerjakan Hanya yang memenuhi syarat (kondisi)
Syarat/kondisi terdiri dari operand-operand yang dihubungkan dengan operator relasi dan operator logika
Pengalihan pengendalian Bila perintah yang dijalankan adalah bukan perintah
berikutnya dalam urutan program
Hindari perintah ‘goto’ menimbulkan banyak masalah
Algoritma&Pemrograman
18
Struktur seleksi/percabangan (selection structure)
Kondisi/syarat berisi pernyataan Boolean, yang dapat bernilai benar (true) atau salah (false)
Menggunakan perintah: if If else switch
Algoritma&Pemrograman
Pernyataan Seleksi if19
Digunakan untuk memilih alur alternatif Contoh Pseudocode:
If nilai mahasiswa lebih besar atau sama dengan 60Print “lulus”
Jika kondisi true (benar) Pernyataan Print dijalankan dan program
akan meneruskan ke perintah berikutnya. Jika false, pernyataan print diabaikan
dan menjalankan perintah berikutnya.
Algoritma&Pemrograman
Mengubah pseudocode if menjadi program C
20
Pseudocode:If nilai mahasiswa lebih besar atau sama
dengan 60Print “lulus”
Bahasa C:if ( grade >= 60 ) printf( "Passed\n" );
Kondisi yang diseleksi
Algoritma&Pemrograman
21
Flowchart if
Digunakan untuk seleksi
Hasilnya: benar atau salah
Menguji kondisi dan mengikuti jalur yang tepat.
Simbol Berlian (decision symbol)
Apakah Nilai >= 60 ?
Cetak ‘LULUS’YA
TIDAK
Algoritma&Pemrograman
Seleksi dengan if…else22
if Hanya melaksanakan aksi bila kondisinya
adalah benar/true if…else
Melaksanakan suatu aksi untuk kedua kondisi, baik benar/true atau salah/false
Algoritma&Pemrograman
Mengubah pseudocode if..else menjadi program C
23
Pseudocode:If nilai siswa lebih besar atau sama dengan 60
Print “Lulus”else
Print “Gagal” Code C:
if ( nilai >= 60 ) printf( “Lulus\n“ );else printf( “Gagal\n“ );
Algoritma&Pemrograman
24
Flowchart if..else
Apakah Nilai >= 60 ?
Cetak ‘LULUS’YATIDAK
Cetak ‘Gagal’
Algoritma&Pemrograman
Pernyataan if…else bersarang25
Pernyataan if…else di dalam pernyataan if…else
Struktur ini digunakan apabila ada banyak kemungkinan kondisi yang diseleksi Satu kondisi terpenuhi, yang lain di-skip
Algoritma&Pemrograman
26
PseudocodeIf student’s grade is greater than or equal to 90
Print “A”else
If student’s grade is greater than or equal to 80 Print “B”else If student’s grade is greater than or equal to 70
Print “C” else If student’s grade is greater than or equal to
60 Print “D” else Print “F”
Pernyataan if…else bersarang
Algoritma&Pemrograman
Jenis kesalahan27
Syntax errors Caught by compiler
Logic errors: Have their effect at execution time Non-fatal: program runs, but has incorrect
output Fatal: program exits prematurely
28
Selection Structure using ifif
Only performs an action if the condition is true
if…elseSpecifies an action to be performed both when the condition
is true and when it is false
Nested if..elseTest for multiple cases by placing if…else selection
statements inside if…else selection statement
Once condition is met, rest of statements skipped
What we have learned so far..
29Repetition structure using while
Algoritma&Pemrograman
30
Struktur perulangan (Repetition structure)
Sejumlah aksi harus dilaksanakan berulang kali selama kondisi bernilai benar (true)
Dapat dibuat dengan while for do…while (equal to repeat…until)
Algoritma&Pemrograman
31
Repetition Essentials
Counter-controlled repetition Definite repetition: jumlah perulangan
diketahui Control variable digunakan untuk
menghitung jumlah perulangan Sentinel-controlled repetition
Indefinite repetition: jumlah perulangan tidak diketahui
Sentinel value digunakan untuk menyatakan akhir data
Algoritma&Pemrograman
32
Counter-Controlled Repetition
Counter-controlled repetition requires1. The name of a control variable (or loop
counter)2. The initial value of the control variable3. An increment (or decrement) by which the
control variable is modified each time through the loop
4. A condition that tests for the final value of the control variable (i.e., whether looping should continue)
Algoritma&Pemrograman
33
Contoh
Sepuluh orang mahasiswa mengikuti kuis. Range nilai yang diberikan adalah 0-100. User (dosen) akan diminta memasukkan nilai yang didapat oleh seluruh mahasiswa. Program akan menentukan rata-rata nilai kuis yang diperoleh
Algoritma&Pemrograman
34
1 Set total to zero
2 Set grade counter to one
3
4 While grade counter is less than or equal to ten
5 Input the next grade
6 Add the grade into the total
7 Add one to the grade counter
8
9 Set the class average to the total divided by ten 10 Print the class average
Fig. 3.5 | Pseudocode algorithm that uses counter-controlled repetition to
solve the class average problem.
Algoritma&Pemrograman
35
Counter-Controlled Repetition using While
Format for while repetitioninitialization;while ( loopContinuationTest ) { statement; increment;}
Example: int counter = 1; // control variable & initializationwhile ( counter <= 10 ) { // repetition condition printf( "%d\n", counter ); ++counter; // increment}
36
1 /* Fig. 3.6: fig03_06.c
2 Class average program with counter-controlled repetition */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
7 {
8 int counter; /* number of grade to be entered next */
9 int grade; /* grade value */
10 int total; /* sum of grades input by user */
11 int average; /* average of grades */
12
13 /* initialization phase */
14 total = 0; /* initialize total */
15 counter = 1; /* initialize loop counter */
16
17 /* processing phase */
18 while ( counter <= 10 ) { /* loop 10 times */
19 printf( "Enter grade: " ); /* prompt for input */
20 scanf( "%d", &grade ); /* read grade from user */
21 total = total + grade; /* add grade to total */
22 counter = counter + 1; /* increment counter */
23 } /* end while */
Outline
fig03_06.c
(1 of 2 )
Counter to control while loop
Initialize counter to 1
while loop iterates as long as counter <= 10
Increment the counter
37
24
25 /* termination phase */
26 average = total / 10; /* integer division */
27
28 printf( "Class average is %d\n", average ); /* display result */
29
30 return 0; /* indicate program ended successfully */
31
32 } /* end function main */ Enter grade: 98 Enter grade: 76 Enter grade: 71 Enter grade: 87 Enter grade: 83 Enter grade: 90 Enter grade: 57 Enter grade: 79 Enter grade: 82 Enter grade: 94 Class average is 81
Outline
fig03_06.c
(2 of 2 )
Calculate the average
Algoritma&Pemrograman
38
Sentinel-controlled repetition
Contoh:
User (dosen) akan diminta memasukkan nilai yang didapat oleh seluruh mahasiswa. Range nilai yang diberikan adalah 0-100. Jumlah mahasiswa belum diketahuti (tidak terbatas). Program akan menentukan rata-rata nilai kuis yang diperoleh.
Soal ini mirip dengan contoh sebelumnya. Bedanya hanyalah perulangan tidak diketahui (indefinite loop). Oleh karena itu dibutuhkan sentinel value
Algoritma&Pemrograman
39
Fig. 3.7 | Pseudocode algorithm that uses sentinel-controlled repetition to
solve the class average problem.
1 Initialize total to zero
2 Initialize counter to zero
3
4 Input the first grade
5 While the user has not as yet entered the sentinel
6 Add this grade into the running total
7 Add one to the grade counter
8 Input the next grade (possibly the sentinel)
9
10 If the counter is not equal to zero
11 Set the average to the total divided by the counter
12 Print the average
13 else 14 Print “No grades were entered”
Algoritma&Pemrograman
40
Bagaimana cara menentukan Sentinel?
Nilai sentinel yang ditentukan harus memiliki tipe yang sama dengan input yang dimasukkan, namun berada diluar range nilai yang benar Nilai input yang dimasukkan berupa angka
integer 0-100. Sehingga dapat dipilih nilai -1 yang berada diluar range nilai mahasiswa
41
1 /* Fig. 3.8: fig03_08.c
2 Class average program with sentinel-controlled repetition */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
7 {
8 int counter; /* number of grades entered */
9 int grade; /* grade value */
10 int total; /* sum of grades */
11
12 float average; /* number with decimal point for average */
13
14 /* initialization phase */
15 total = 0; /* initialize total */
16 counter = 0; /* initialize loop counter */
17
18 /* processing phase */
19 /* get first grade from user */
20 printf( "Enter grade, -1 to end: " ); /* prompt for input */
21 scanf( "%d", &grade ); /* read grade from user */
22
Outline
fig03_08.c
(1 of 3 )
float type indicates variable can be a non-integer
42
23 /* loop while sentinel value not yet read from user */
24 while ( grade != -1 ) {
25 total = total + grade; /* add grade to total */
26 counter = counter + 1; /* increment counter */
27
28 /* get next grade from user */
29 printf( "Enter grade, -1 to end: " ); /* prompt for input */
30 scanf("%d", &grade); /* read next grade */
31 } /* end while */
32
33 /* termination phase */
34 /* if user entered at least one grade */
35 if ( counter != 0 ) {
36
37 /* calculate average of all grades entered */
38 average = ( float ) total / counter; /* avoid truncation */
39
40 /* display average with two digits of precision */
41 printf( "Class average is %.2f\n", average );
42 } /* end if */
43 else { /* if no grades were entered, output message */
44 printf( "No grades were entered\n" );
45 } /* end else */
46
47 return 0; /* indicate program ended successfully */
48
49 } /* end function main */
Outline
fig03_08.c
(2 of 3 )
while loop repeats until user enters a value of -1
Ensures the user entered at least one grade
Prints result with 2 digits after decimal point
Converts total to float type
43
Enter grade, -1 to end: 75 Enter grade, -1 to end: 94 Enter grade, -1 to end: 97 Enter grade, -1 to end: 88 Enter grade, -1 to end: 70 Enter grade, -1 to end: 64 Enter grade, -1 to end: 83 Enter grade, -1 to end: 89 Enter grade, -1 to end: -1 Class average is 82.50
Enter grade, -1 to end: -1 No grades were entered
Outline
fig03_08.c
(3 of 3 )
44 More repetition structure
Algoritma&Pemrograman
45
Counter-Controlled Repetition using For
Hanya bisa digunakan untuk jumlah perulangan yang diketahui (definite repetition)
Format:for ( initialization; loopContinuationTest; increment
or decrement ) statement
Example: for( int counter = 1; counter <= 10; counter++ )
printf( "%d\n", counter );
Prints the integers from one to ten
Algoritma&Pemrograman
46
Counter-Controlled Repetition using For
Fig. 4.3 | for statement header components.
47
1 /* Fig. 4.2: fig04_02.c 2 Counter-controlled repetition with the for statement */ 3 #include <stdio.h> 4
5 /* function main begins program execution */ 6 int main( void ) 7 { 8 int counter; /* define counter */ 9
10 /* initialization, repetition condition, and increment 11 are all included in the for statement header. */ 12 for ( counter = 1; counter <= 10; counter++ ) { 13 printf( "%d\n", counter ); 14 } /* end for */ 15
16 return 0; /* indicate program ended successfully */ 17
18 } /* end function main */
Outline
fig04_02.c
for loop begins by setting counter to 1 and repeats while counter <= 10. Each time the end of the loop is reached, counter is incremented by 1.
Algoritma&Pemrograman
48
Fig. 4.4 | Flowcharting a typical for repetition statement.
49
1 /* Fig. 4.5: fig04_05.c 2 Summation with for */ 3 #include <stdio.h> 4
5 /* function main begins program execution */ 6 int main( void ) 7 { 8 int sum = 0; /* initialize sum */ 9 int number; /* number to be added to sum */ 10
11 for ( number = 2; number <= 100; number += 2 ) { 12 sum += number; /* add number to sum */ 13 } /* end for */ 14
15 printf( "Sum is %d\n", sum ); /* output sum */ 16
17 return 0; /* indicate program ended successfully */
18
19 } /* end function main */ Sum is 2550
Outline
fig04_05.c
Note that number has a different value each time this statement is executed
Algoritma&Pemrograman
50
do…while Repetition Statement
The do…while repetition statement Similar to the while structure Condition for repetition only tested after
the body of the loop is performed All actions are performed at least once
Format: do { statement; } while ( condition );
Algoritma&Pemrograman
51
do…while Repetition Statement
Example (letting counter = 1): do { printf( "%d ", counter ); } while (++counter <= 10);
Prints the integers from 1 to 10
52
1 /* Fig. 4.9: fig04_09.c 2 Using the do/while repetition statement */ 3 #include <stdio.h> 4
5 /* function main begins program execution */ 6 int main( void ) 7 { 8 int counter = 1; /* initialize counter */ 9
10 do { 11 printf( "%d ", counter ); /* display counter */ 12 } while ( ++counter <= 10 ); /* end do...while */ 13
14 return 0; /* indicate program ended successfully */ 15
16 } /* end function main */ 1 2 3 4 5 6 7 8 9 10
Outline
fig04_09.c
increments counter then checks if it is less than or equal to 10
Algoritma&Pemrograman
53
Fig. 4.10 | Flowcharting the do...while repetition statement.
Algoritma&Pemrograman
For vs Do..while vs While54
For hanya dapat digunakan untuk proses pengulangan berdasarkan harga satu variabel.
Do…whilePengulangan ditempatkan diakhir simpai.Perintah didalam simpai pasti dikerjakan 1X
kondisi awal pengulangan harus benar
Penggunaan simpai while lebih ‘aman’ karena penyeleksian kondisi dilakukan diawal
55 Selection statement using switch
Algoritma&Pemrograman
56
Selection statement using switch
switch Useful when a variable or expression is tested for all the values
it can assume and different actions are taken Format
Series of case labels and an optional default caseswitch ( value ){
case '1':actionsbreak;
case '2':actionsbreak;
default:actions
}
break; exits from statement
57
Fig. 4.8 | switch multiple-selection statement with breaks.
Algoritma&Pemrograman
Switch vs If58
prinsip sama dengan if (lebih umum)
hanya digunakan untuk pemeriksaan berdasarkan 1 variabel (if sembarang)
digunakan untuk memeriksa harga variabel terhadap sekumpulan nilai (kalau sedikit if)
59Break and continue statement
Algoritma&Pemrograman
60
break and continue Statements
break Causes immediate exit from a while, for, do…while or switch statement
Program execution continues with the first statement after the structure
Common uses of the break statement Escape early from a loop Skip the remainder of a switch statement
61
1 /* Fig. 4.11: fig04_11.c
2 Using the break statement in a for statement */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
7 {
8 int x; /* counter */
9
10 /* loop 10 times */
11 for ( x = 1; x <= 10; x++ ) {
12
13 /* if x is 5, terminate loop */
14 if ( x == 5 ) {
15 break; /* break loop only if x is 5 */
16 } /* end if */
17
18 printf( "%d ", x ); /* display value of x */
19 } /* end for */
20
21 printf( "\nBroke out of loop at x == %d\n", x );
22
23 return 0; /* indicate program ended successfully */
24
25 } /* end function main */ 1 2 3 4 Broke out of loop at x == 5
Outline
fig04_11.c
break immediately ends for loop
Algoritma&Pemrograman
62
continue Statements
continue Skips the remaining statements in the body
of a while, for or do…while statement Proceeds with the next iteration of the loop
while and do…while Loop-continuation test is evaluated
immediately after the continue statement is executed
for Increment expression is executed, then the
loop-continuation test is evaluated
63
1 /* Fig. 4.12: fig04_12.c
2 Using the continue statement in a for statement */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
7 {
8 int x; /* counter */
9
10 /* loop 10 times */
11 for ( x = 1; x <= 10; x++ ) {
12
13 /* if x is 5, continue with next iteration of loop */
14 if ( x == 5 ) {
15 continue; /* skip remaining code in loop body */
16 } /* end if */
17
18 printf( "%d ", x ); /* display value of x */
19 } /* end for */
20
21 printf( "\nUsed continue to skip printing the value 5\n" );
22
23 return 0; /* indicate program ended successfully */
24
25 } /* end function main */
1 2 3 4 6 7 8 9 10
Used continue to skip printing the value 5
Outline
fig04_12.c
continue skips to end of for loop and performs next iteration
64 Summary
Algoritma&Pemrograman
65
Summary
Structured programming Easier than unstructured programs to understand, test,
debug and, modify programs All programs can be broken down into 3 controls
Sequence – handled automatically by compiler Selection – if, if…else or switch Repetition – while, do…while or for
Can only be combined in two ways Nesting Stacking
Any selection can be rewritten as an if statement, and any repetition can be rewritten as a while statement
Algoritma&Pemrograman
66
Latihan
Buatlah pseudocode untuk mengkonversi suhu dengan pengulangan dan pencabangan Pengulangan sampai 5 kali Pencabangan untuk input dalam C, R, K, F
Pseudocode harus sudah memasukkan unsur user friendly
67
Dikerjakan berkelompok1 kelompok terdiri dari 3 orang
Menggunakan DevC++Didemokan pekan depan
Assignment 1
Algoritma&Pemrograman
68
Soal 1
“Harga Mutlak Bilangan“ Tujuan : menentukan harga mutlak
setiap bilangan yang dimasukkan lewat keyboard (akhirdata = 0)
Algoritma&Pemrograman
bil > 0
mutlak = bilmutlak = - bil
tidak
ya
Algoritma&Pemrograman
Algoritmanyabaca(bil)
if bil > 0 then mutlak = bil else mutlak = -bil eif
tulis (mutlak) {peragakan harga mutlak tersebut}
Algoritma&Pemrograman
71
Soal 2
“Bilangan genap dan ganjil” Tujuan : membuat algoritma yang dapat
menyatakan suatu bilangan adalah genap atau ganjil
Akhir data dinyatakan dengan nilai “0”
Algoritma&Pemrograman
Langkah-langkahnya menentukan suatu bilangan genap
atau ganjil dengan membagi bilangan dengan bilangan 2 (mod)Sisa pembagian nol bilangan genap
jika tidak nol bilangan ganjil
Algoritma&Pemrograman
AlgoritmanyaakhirData = 0Baca (bil)while bil <> akhirData do sisa =bil mod 2 if sisa == 0 then write (‘genap’) else write (‘ganjil’) eif baca (bil)ewhile
Algoritma&Pemrograman
74
Soal 3
“Persamaan Kuadrat” Tujuan : membuat algoritma
program menghitung akar-akar persamaan kuadrat yang koefisiennya dimasukkan melalui keyboard
Algoritma&Pemrograman
Langkah-langkahnya menyeleksi kondisi salah dengan memeriksa nilai koefisien
menentukan jenis akar persamaan berdasarkan koefisien
Algoritma&Pemrograman
Algoritma: baca (a) while a<>0 do baca (b,c)
d=b^2-4*a*c
continue
Algoritma&Pemrograman
if d<0 then {hitung akar kompleks} p= -b/(2*a) q = abs (sqr(-d)/((2*a)) tulis (‘x1=‘, p, ‘+’, q, ‘i’) tulis (‘x2=‘, p, ‘-’, q, ‘i’) else
continue
Algoritma&Pemrograman
{akar komplek atau tidak} if d=0 then {hitung akar kembar} x1 = -b/(2*a) x2 = x1
Algoritma&Pemrograman
else {hitung akar tidak kembar} x1 = (-b+sqr(d))/(2*a) x2 = (-b-sqr(d))/(2*a) eif tulis (‘x1=‘, x1) tulis (‘x2=‘,x2)eifBaca (a)
Algoritma&Pemrograman
80
Soal 4
“Relasi bilangan” Tujuan: Menentukan apakah kedua
buah bilangan yang diinput sama, lebih kecil atau lebih besar
Algoritma&Pemrograman
81
Tugas Kelompok C program (DevC++)
Kel 1 – 4 soal 1 Kel 5 – 8 soal 2 Kel 8 – 13 soal 3 Kel 14 - 17 soal 4
Algoritma&Pemrograman
82
Dev C++
Jangan lupa save program dalam .C Supaya window bisa freeze dan terlihat
hasilnya sebelum tertutup otomatis, tambahkan: System(“pause”);
Sebelum Return 0; }