Bab Iii

BAB III
PEMBAHASAN
Pada bab ini membahas mengenai program yang telah dibuat saat
praktikum. Meliputi, flowchart, pseudocode, kode program dalam Dev C++,
trace, dan hasil setelah dicompile.
116

3.3.1....
Dasar Penggunaan Bahasa Pemrograman
Modul ini membahas tentang dasar penggunaan bahasa pemrograman.
Program yang akan dibahas dalam modul ini adalah program menghitung akar
persamaan kuadrat, program konversi desimal dan biner, program zodiak,
program nilai akhir mahasiswa, dan program deret bilangan prima. Kelima
program tersebut mengunakan dasar-dasar dari bahasa pemrograman.
23 Program Menghitung Akar Persamaan Kuadrat

Hal yang pertama dilakukaan pada saat pembuatan program menghitung
akar persamaan kuadrat adalah pembuatan flowchart. Flowchat yang dimaksud
dapat dilihat pada Gambar 3.1.
38
Gambar 3.1 Flowchart program menghitung akar persamaan kuadrat
Gambar 3.1 adalah flowchart yang digunakan dalam program menghitung

akar persamaan kuadrat.
Bentuk pseudocode dari program menghitung akar persamaan kuadrat
dapat dilihat pada Kode Program 3.1.
23 Mulai
24 Input A, B, C
25 D = (B*B)-(4AC)
26 If A = 0 Then
27 Print "Bukan persamaan kuadrat"
28 Else if D < O Then
29 Print "Akar Imajiner"
30 Else if D > O Then
31 Print "Akar real beda"
32 x1 = -B+ / 2A
33 x2 = -B- / 2A
34 Print "x1 :" x1,"x2:" x2
35 Else
36 Print "Akar real sama"
39
23 x1 = x2 = -B/2A
24 Print "x1 = "x1, "x2 = "x2
25 End If
26 Selesai
Kode Program 3.1 Pseudocode program menghitung akar persamaan kuadrat
Kode Program 3.1 menjelaskan tentang program menghitung akar

persamaan kuadrat dengan menggunakan pseudocode.
Flowchart maupun pseudocode di atas jika dituangkan dalam program C+
+, maka sintaks dari program tersebut dapat dilihat pada Kode Program 3.2.
23 #include <iostream>
24 #include <math.h>
25 #include <conio.h>
26 #include <limits>
27 #include <stdlib.h>
28 using namespace std;
29 class Scanner {
30 public:
31 int nextInt(const char* errorMessage);
32 bool isNumInteger(string numericString);
33 private:
34 int count(char item, string list);
35 };
36 int Scanner::nextInt(const char* errorMessage) {
37 string tmp;
38 cin >> tmp;
39 while (!this->isNumInteger(tmp)){
18. cout << errorMessage;
19. cin >> tmp;
23 }
24 return atoi(tmp.c_str());
25 }
26 int Scanner::count(char item, string list){
27 int cnt = 0;
28 for (int i=0; i<list.length(); i++){
26. if (list[i] == item){
27. cnt++;
28. }
23 }
24 return cnt;}
25 bool Scanner::isNumInteger(string numericString){
26 for (int i=0; i<numericString.length(); i++){
33. if (numericString[0] == '-'){
34. return false;
35. }
36. if (this->count('-', numericString) > 1){
37. return false;
38. }
39. if ((numericString[i] == '-') && (i != 0)){
40. return false;
41. }
42. if (numericString[i] < '0' || numericString[i]
> '9'){
43. if (numericString[i] != '-'){
40
44. return false;
45. }
46. }
23 }
24 return true;
25 }
26 int main()
27 {
28 program:
29 Scanner* input = new Scanner;
30 system("cls");
31 int A,B,C;
32 char pilih;
33 long d;
34 float x1,x2,s;
35 cout<<" __________________________________"<<endl;
60. cout<<"| Kelompok 16 |"<<endl;
23 cout<<"|__________________________________|"<<endl;
62. cout<<"| ~~Persamaan Kuadrat~~ |"<<endl;
23 cout<<" __________________________________"<<endl;
24 cout<<"Masukkan nilai a :";
65. A = input->nextInt("Input salah\nMasukkan nilai a: ");
23 cout<<"Masukkan nilai b :";

67. B = input->nextInt("Input salah\nMasukkan nilai b: ");
23 cout<<"Masukkan nilai c :";

69. C = input->nextInt("Input salah\nMasukkan nilai c: ");
256 d=(B*B)-(4*A*C);
257 cout<<"\n";
258 if(A==0)
259 {
260 cout<<"Bukan persamaan kuadrat"<<endl;
261 }
262 else if(d<0)
263 {
264 cout<<"Akar imajiner";
265 }
266 else if(d>0)
267 {
268 cout<<"Akar real berbeda"<<endl;
269 s=sqrt(d);
270 x1 =(-B+(s))/(2*A);
271 x2 =(-B-(s))/(2*A);
272 cout<<"Nilai x1 :"<<x1<<endl;
274 }
275 else
276 {
277 cout<<"Akar real kembar"<<endl;
278 x1=(-B)/(2*A);
279 x2=x1;
282 }
283 cout<<"\nIngin menjalankan program lagi ? : ";
284 pilihan :
99. cout<<"Ya(Y) | Tidak(N)"<<endl;
41
100. cin>>pilih;
101.
0 if(pilih=='y'|| pilih=='Y') {
1 goto program;
2 }
105. else if(pilih=='n'|| pilih=='N') cout<<"Terimakasih.";
106.
23 else{
108. cout <<"Input salah, silahkan ulangi! "<< endl;
23 goto pilihan;
24 }
25 return 0;
26 }
Kode Program 3.2 Program menghitung akar persamaan kuadrat
Kode program 3.2 merupakan sintaks dari program menghitung akar

persamaan kuadrat. Awalnya pengguna memasukkan angka A, angka B, dan angka
C. Kemudian ketiga angka tersebut diproses dalam program sehingga
menghasilkan output yang sesuai.
Trace dari program menghitung akar persamaan kuadrat dapat dilihat pada
Kode Program 3.3
Input:
Masukan nilai a:3
Masukan nilai b:9
Masukan nilai c:4
Proses:
D > 0
x1 = -B + /2A
x2 = -B - /2A
Output:
Akar real berbeda
nilai x1 = -0,542573
nilai x2 = -2.455743
Kode Program 3.3 Trace program menghitung akar persamaan kuadrat
Kode Program 3.3 menjelaskan tentang trace dari program menghitung

akar persamaan kuadrat. Pengguna memasukkan angka A, angka B, dan angka C.
Program menghitung akar persamaan kuadrat jika di-compile melalui
Dev C++ maka hasilnya dapat dilihat pada Gambar 3.2.
42
Gambar 3.2 Hasil compile program menghitung akar persamaan kuadrat pada Dev C++
Gambar 3.2 merupakan hasil dari sintaks program menghitung akar

persamaan kuadrat yang telah di-compile, terdari dari input-an pengguna, dan
hasil yang didapatkan.
23 Program Konversi Desimal Dan Biner

Program kedua adalah program konversi desimal dan biner. Flowchart
dari program ini dapat dilihat pada Gambar 3.3.
43
Gambar 3.3 Flowchart program konversi biner dan desimal
Gambar 3.3 merupakan flowchart yang digunakan dalam pembuatan

program konversi biner dan desimal.
Bentuk pseudocode dari program konversi biner dan desimal dapat
dilihat pada Kode Program 3.4.
23 Mulai
24 Input menu
25 If menu = 1 Then
26 Input Biner
27 If Biner %10>=2 && Biner%10<=9 Then
28 Desimal + = (Biner %2)x2
29 Biner / = 10
30 Print Desimal
31 Else
32 Print "Bukan biner"
33 Kembali ke nomor 4
34 Else if menu = 2 Then
35 Read m,n[50],r = 0
44
23 Input Desimal
24 While m > 0 Then
25 n[r]= m%2
26 m = m/2
27 r++
28 End while
29 For (x = r-1, x >= 0, x++)
30 Biner = n[x]
31 print Biner
32 End for
33 Else
34 Kembali ke no2
35 Selesai
Kode Program 3.4 Pseudocode program konversi biner dan desimal
Kode Program 3.4 merupakan pseudocode dalam program konversi

biner dan desimal.
Flowchart maupun pseudocode di atas jika dituangkan dalam program
C++, maka sintaks dari program tersebut dapat dilihat pada Kode Program 3.5.
23 #include<iostream>
24 #include<limits>
27 class Scanner {
28 public:
31 private:
33 };
35 string tmp;
36 cin >> tmp;
17. cin >> tmp;
23 }
25 }
27 int cnt = 0;
25. cnt++;
26. }
23 }
24 return cnt;
25 }
33. return false;
34. }
45
36. return false;
37. }
39. return false;
40. }
41. if (numericString[i] <'0'||numericString[i]>
'9'){
43. return false;
44. }
45. }
23 }
24 return true;
25 }
49.
23 void biner();
24 void desimal();
25 int main()
26 {
27 program:
29 system("cls");
30 int a;
31 char pilih;
59.
23 cout<<" __________________________________"<<endl;
23 cout<<"|__________________________________|"<<endl;
63. cout<<"| ~~Konversi Bilangan~~ |"<<endl;
23 cout<<" __________________________________"<<endl;
24 cout<<"\n";
25 cout<<"Menu "<<endl;
26 cout<<"(1) Konversi Biner ke Desimal"<<endl;
27 cout<<"(2) Konversi Desimal ke Biner"<<endl;
28 cout<<"\n";
29 ulang:
30 cout<<"Masukkan Pilihan (1 atau 2) : ";
31 a = input->nextInt("Input salah\nMasukkan Pilihan (1 atau
2) : ");
73. if(a==1){
74. biner();
75. }
76. else if(a==2){
77. desimal();
78. }
79. else {
80. cout <<"Input salah, silahkan ulangi!
"<< endl;
81. goto program;
82. }
24 pilihan :
25 cout<<"Ya(Y) | Tidak(N)"<<endl;
26 cin>>pilih;
28 goto program;
29 }
30 else if(pilih=='n'|| pilih=='N')
cout<<"Terimakasih.";
46
91.
23 else{
23 goto pilihan;
24 }
25 }
97.
256 void biner(){
257 binary:
259 int biner, dit,cek,desi,dua;
260 dua=1;
261 desi=0;
262 cout<<"Masukkan Bilangan Biner : ";
263 biner = input->nextInt("Input salah\nMasukkan
Bilangan Biner : ");
106.
0 cek=biner;
1 while(cek>0){
2 dit=biner%10;
3 if (dit>=2 &&dit<=9){
111. cout<<"Bukan Bilangan Biner\n";
112. goto binary;
23 }
24 cek=cek/10;
25 }
116.
23 do{
24 desi+=(biner%2)*dua;
25 dua*=2;
26 biner/=10;
27 }
28 while (biner);
29 cout<<"Bilangan Desimalnya adalah : "<<desi<<endl;
30 }
125.
23 void desimal(){
25 int m,n[50],r=0;
26 cout<<"Masukkan Bilangan Desimal : ";
27 m = input->nextInt("Input salah\nMasukkan Bilangan
Desimal : ");
131.
23 while(m>0){
133. n[r]=m%2;
134. m=m/2;
135. r++;
136. }
137.
23 cout<<"Bilangan Binernya adalah : ";
24 for(int x=r-1;x>=0;x--){
140. cout<<n[x];
23 }
24 cout<<endl;
25 }
Kode Program 3.5 Program konversi biner dan desimal
47
Kode program 3.5 merupakan kode program yang telah dibuat dalam
Dev C++ dari program konversi biner dan desimal.
Trace dari program konversi biner dan desimal dapat dilihat pada Kode
Program 3.6.
Input:
Masukan Pilihan : 1, masukan Biner : 1011
Proses:
Biner%10>=2 && Biner %10<=9
Desimal+ = (Biner %2)*2
Biner/= 10
Print Desimal
Output:
Bilangan Desimalnya : 11
Kode Program 3.6 Trace program konversi bilangan biner ke desimal
Kode Program 3.6 menjelaskan tentang trace dari program konversi

biner ke desimal.
Trace yang terdapat dalam program konversi desimal ke biner dapat
Input :
Masukan Pilihan : 2, masukan Biner :
9 Proses :
Read m,n[50],r = 0
While m > 0
(
n[r]= m%2
m = m/2
r++
)
End while
For (x = r-1, x >= 0, x++)
Biner = n[x]
Print
Biner Output :
Bilangan Binernya adalah : 1001
Kode Program 3.7 Trace program konversi bilangan desimal ke biner
Kode Program 3.7 menjelaskan tentang trace dari program konversi

biner ke desimal.
Program konversi biner dan desimal jika di-compile melalui Dev C++
maka hasilnya dapat dilihat pada Gambar 3.4.
48
Gambar 3.4 Hasil compile program konversi biner dan desimal pada Dev C++
Gambar 3.4 merupakan hasil dari sintaks program konversi biner dan
desimal yang telah di-compile pada program Dev C++.
23 Program Zodiak
Program ketiga adalah program zodiak. Flowchart dari program ini dapat
dilihat pada Gambar 3.5.
49
50
Gambar 3.5 Flowchart program zodiak
Gambar 3.5 adalah flowchart yang digunakan dalam pembuatan program

zodiak.
Bentuk dari pseudocode yang digunakan untuk pembuatan program zodiak
23 Mulai
24 Input tanggal lahir
25 input bulan lahir
26 if tanggal 21-31 bulan 3 && tanggal 1-19 bulan 4 ther
27 Print "ARIES"
28 Else if tanggal 20-30 bulan 4 && tanggal 1-20 bulan 5 then
29 Print "TAURUS"
31 Print "GEMINI"
10.Else if tanggal 21-30 bulan 6 && tanggal 1-22 bulan 7 then
11.Print "CANCER"
24 Print "LEO"
26 Print "VIRGO"
28 Print "LIBRA"
51
23 Print "SCORPIO"
25 Print "SAGITARIUS"
27 Print "CAPRICON"
29 Print "AQUARIUS"
31 Print "PISCES"
32 Else
33 Kembali ke nomor 2
34 End if
35 Selesai
Kode Program 3.7 Pseudocode program zodiak
Kode Program 3.7 menjelaskan tentang program zodiak dengan

menggunakan pseudocode.
24 #include<limits>
27 class Scanner {
28 public:
31 private:
33 };
35 string tmp;
36 cin >> tmp;
17. cin >> tmp;
256 }
258 }
260 int cnt = 0;
25. cnt++;
26. }
0 }
1 return cnt;
2 }
33. return false;
34. }
52
36. return false;
37. }
39. return false;
40. }
> '9'){
43. return false;
44. }
45. }
0 }
1 return true;
2 }
49.
0 int main(){
1 program:
3 system("cls");
4 int tanggal, bulan;
5 char pilih;
6 cout<<" __________________________________"<<endl;
0 cout<<"|__________________________________|"<<endl;
59. cout<<"| ~~Zodiak~~ |"<<endl;
0 cout<<" __________________________________"<<endl;
1 cout<<"\n";
2 cout << "Masukkkan tanggal lahir :";
3 tanggal = input->nextInt("Input salah\nMasukkan tanggal
lahir : ");
4 cout <<"Masukkan bulan lahir :";
65. bulan= input->nextInt("Input salah\nMasukkan tanggal
lahir : ");
66.
67. if((tanggal >= 21 && tanggal <=31 && bulan == 3) ||
(tanggal >=1 && tanggal<= 19 && bulan ==4))
68. cout << "Zodiak Aries \n";
69. else if((tanggal >= 20 && tanggal <=30 && bulan == 4) ||
(tanggal >=1 && tanggal <= 20 && bulan == 5))
70. cout << "Zodiak Taurus \n";
(tanggal >=1 && tanggal <= 20 && bulan ==6))
72. cout << "Zodiak Gemini \n";
74. cout << "Zodiak Cancer \n";
76. cout << "Zodiak Leo \n";
78. cout << "Zodiak Virgo \n";
80. cout << "Zodiak Libra \n";
81. else if((tanggal >= 23 && tanggal <=31 && bulan == 10)
0 (tanggal >=1 && tanggal <= 21 && bulan == 11))
82. cout << "Zodiak Scorpio \n";
53
0 (tanggal >=1 && tanggal <= 21 && bulan == 12))
84. cout << "Zodiak Sagitarius \n";
|| (tanggal >=1 && tanggal <= 19 && bulan == 1))
86. cout << "Zodiak Capricorn \n";
88. cout << "Zodiak Aquarius \n";
90. cout << "Zodiak Piscess \n";
0 else{
1 cout <<"Input salah, silahkan ulangi! "<< endl;
2 goto program;
3 }
4 cout<<endl;
6 pilihan :
99. cin>>pilih;
100.
1 goto program;}
103. else if(pilih=='n'|| pilih=='N')
0 else{
0 goto pilihan;}
1 return 0;
2 }
Kode Program 3.8 Program zodiak
Kode program 3.8 merupakan sintaks dari program zodiak. Awalnya

pengguna memasukkan bulan lahir, serta tanggal lahir. Tanggal dan bulan lahir
tersebut diproses sehingga akan diketahui zodiak pengguna berdasarkan tanggal
dan bulan lahir yang di-input.
Trace yang dapat dibuat dalam program zodiak terdapat pada Kode
Program 3.9.
Input:
Masukan tanggal lahir : 26
Masukan bulan lahir : 06
Proses:
21 tanggal 30 && bulan ==4 ll 1 tanggal 20&&
bulan ==5
Output:
CANCER
Kode Program 3.9 Trace program zodiak
54
Kode Program 3.9 menjelaskan tentang trace yang merupakan hasil dari
program zodiak. Pengguna memasukkan tanggal dan bulan lahir.
Program zodiak jika di-compile melalui Dev C++ maka hasilnya dapat
dilihat dari Gambar 3.6.
Gambar 3.6 Hasil compile program zodiak pada Dev C++
Gambar 3.6 merupakan hasil dari sintaks program zodiak yang telah di-
compile, terdari dari input-an pengguna, dan hasil yang didapatkan.
0 Program Nilai Akhir Mahasiswa

Hal yang pertama dilakukaan pada saat pembuatan program nilai akhir
mahasiswa adalah pembuatan flowchart. Flowchat yang dimaksud dapat dilihat
pada Gambar 3.7.
55
Gambar 3.7 Flowchart program nilai akhir mahasiswa
Gambar 3.7 adalah flowchart yang digunakan dalam program nilai akhir
mahasiswa.
Bentuk pseudocode dari program nilai akhir mahasiswa dapat dilihat pada
Kode Program 3.10.
0 Mulai
1 Read Nilai Tugas, Nilai UTS, Nilai UAS
2 Nilai Akhir = (0,3 x N.Tugas)+(0,3 x N.UTS)+(0,4 x N.UAS)
3 Print "Nilai Akhir :" Nilai Akhir
4 If 0Nilai Akhir<45 Then
5 Print "(E)"
6 else if 45Nilai Akhir <55 Then
56
256
print "(D)"
257
else if 55Nilai akhir <65 Then
258
print "(C)"
259
else if 65Nilai akhir <80 Then
260
print "(B)"
261
else if 80Nilai Akhir <100 Then
262
print "(A)"
263
End if
264
Selesai
Kode Program 3.10 Pseudocode program nilai akhir mahasiswa
Kode Program 3.10 menjelaskan tentang program nilai akhir mahasiswa

dengan menggunakan pseudocode.
0 #include<iostream>
1 #include<limits>
4 class Scanner {
5 public:
8 private:
10 };
12 string tmp;
13 cin >> tmp;
17. cin >> tmp;
23 }
25 }
27 int cnt = 0;
25. cnt++;
26. }
23 }
24 return cnt;
25 }
33. return false;
34. }
36. return false;}
38. return false;}
57
> '9'){
41. return false;}
42. }
23 }
24 return true;
25 }
26 int main(){
27 program:
29 system("cls");
30 int tugas,uts,uas,nilai;
31 char pilih;
52. cout<<"
__________________________________"<<endl;
53. cout<<"| Kelompok 16
|"<<endl;
54.
cout<<"|__________________________________|"<<endl;
55. cout<<"| ~~Nilai Akhir Mahasiswa~~
|"<<endl;
56. cout<<"
__________________________________"<<endl;
57. cout<<"\n";
23 cout<<"Nilai tugas : ";
59. tugas = input->nextInt("Input salah\nNilai tugas : ");
23 cout<<"Nilai UTS : ";

24 uts = input->nextInt("Input salah\nNilai UTS : ");
25 cout<<"Nilai UAS : ";
26 uas = input->nextInt("Input salah\nNilai UAS : ");
27 nilai=(0.3*tugas)+(0.3*uts)+(0.4*uas);
28 cout<<"Nilai Akhir :"<<nilai<<endl;
29 cout<<"Huruf yang didapat :";
30 if(nilai>=0&&nilai<45){
68. cout<<"E";
23 }
24 else if(nilai>=45&&nilai<55){
71. cout<<"D";
23 }
74. cout<<"C";
23 }
77. cout<<"B";
0 }
1 else if(nilai>=80&&nilai<=100){
80. cout<<"A";
0 }
1 cout<<endl;
3 pilihan :
86. cin>>pilih;
1 goto program;
2 }
90. else if(pilih=='n'|| pilih=='N') cout<<"Terimakasih.";
58
0 else{
0 goto pilihan;
1 }
2 }
Kode Program 3.11 Program nilai akhir mahasiswa
Kode program 3.11 merupakan sintaks dari program menghitung akar

persamaan kuadrat. awalnya mengguna memasukkan nilai UTS, UAS, dan nilai
Tugas. Kemudian ketiga nilai tersebut diproses dalam program sehingga
menghasilkan output yang sesuai.
Trace dari program nilai akhir mahasiswa yang dapat dibuat dapat dilihat
pada Kode Program 3.12.
Input:
Nilai Tugas = 85
Nilai UTS = 75
Nilai UAS = 80
Proses:
Nilai Akhir = (0,3 * 85)+(0,3*75)+(0,4*80)= 80
Output:
Nilai Akhir = 80 (A)
Kode Program 3.12 Trace program nilai akhir mahasiswa
Kode Program 3.12 menjelaskan tentang trace dari program nilai akhir
mahasiswa. Pengguna hanya memasukkan nilai Tugas, UTS, dan UAS.
Program nilai akhir mahasiswa jika di-compile melalui Dev C++ maka
hasilnya pada Gambar 3.8.
Gambar 3.8 Hasil compile program nilai akhir mahasiswa pada Dev C++
59
Gambar 3.8 merupakan hasil dari sintaks program nilai akhir mahasiswa
yang telah di-compile, terdari dari input-an pengguna, dan hasil yang didapatkan.
0 Program Deret Bilangan Prima

Hal yang pertama dilakukaan pada saat pembuatan program deret bilangan
prima adalah pembuatan flowchart. Flowchat yang dimaksud dapat dilihat pada
Gambar 3.8.
60
Gambar 3.9 Flowchart program deret bilangan prima
Gambar 3.9 adalah flowchart yang digunakan dalam pembuatan program

deret bilangan prima.
Bentuk pseudocode dari program deret bilangan prima dapat dilihat pada
Kode Program 3.13.
0 Mulai
1 Read bil, jum, i, n, j
61
23 input jumlah deret (jum)
24 bil = 0
25 n = 0
26 while n<jum Then
27 bil ++
28 j = 0
29 for (i=1, i bil, i++) Then
30 if bil %i = 0 Then
31 J++
32 End if
33 If J=2 Then
34 Print bilangan prima (bil)
35 n++
36 End If
37 Selesai
Kode Program 3.13 Pseudocode program deret bilangan prima
Kode Program 3.13 menjelaskan tentang program deret bilangan prima

24 #include<limits>
25 #include<conio.h>
28 class Scanner {
29 public:
32 private:
34 };
36 string tmp;
37 cin >> tmp;
18. cin >> tmp;
23 }
25 }
27 int cnt = 0;
26. cnt++;
27. }
23 }
24 return cnt;
25 }
62
34. return false;
35. }
37. return false;
38. }
40. return false;
41. }
> '9'){
44. return false;
45. }
46. }
23 }
24 return true;
25 }
50.
23 int main(){
24 program :
26 system("cls");
27 int bil,jum,i,n,j;
28 char pilih;
29 cout<<" __________________________________"<<endl;
23 cout<<"|__________________________________|"<<endl;
60. cout<<"| ~~Deret Bilangan Prima~~ |"<<endl;
23 cout<<" __________________________________"<<endl;
24 cout<<"\n";
63.
23 cout<<"Masukkan nilai N: ";
65. jum = input->nextInt("Input salah\nMasukkan nilai N: ");
23 cout<<"Deret bilangan Prima : ";

24 bil=0;
25 n=0;
26 while(n<jum){
70. bil++;
71. j=0;
72. for(i=1;i<=bil;i++){
73. if(bil%i==0){
74. j++;
75. }
76. }
77. if(j==2){
78. cout<<bil<<" ";
79. n++;
80. }
23 }
24 getch();
25 cout<<endl;
27 pilihan :
87. cin>>pilih;
89. ("cls");
90. goto program;
63
91. }
92. else if(pilih=='n'|| pilih=='N')
93. else{
95. goto pilihan;
96. }
97. }
Kode Program 3.14 Program deret bilangan prima
Kode program 3.14 merupakan sintaks dari program deret bilangan prima.
Pengguna hanya memasukkan jumlah deret dari bilangan prima. Kemudian
program akan melakukan looping sehingga menghasilkan bilangan prima yang
berjumlah sesuai dengan nilai yang diinput pengguna.
Trace dari program deret bilangan prima yang dapat dilihat pada Kode
Program 3.14
Input:
Jumlah deret = 10
Proses:
While (jum > 0){ bil ++, j = 0;
for(i=1; i bil; i++){ if bil % i=0{j++;}}}
if(j==2){print "bilangan prima:" bil, n++}
Output:
Bilangan prima : 2,3,5,7,11,13,17,19,23,29
Kode Program 3.15 Trace program deret bilangan prima
Kode Program 3.15 menjelaskan tentang trace dari program deret

bilangan prima. Pengguna hanya memasukkan jumlah deret dari bilangan prima.
Program deret bilangan prima jika di-compile melalui Dev C++ maka
hasilnya dapat dilihat pada Gambar 3.10.
Gambar 3.10 Hasil compile program zodiak pada Dev C++
Gambar 3.10 merupakan hasil dari sintaks program deret bilangan prima
yang telah di-compile, terdari dari input-an pengguna, dan hasil yang didapatkan.
64
23 Fungsi Dan Procedure
Modul ini membahas tentang penggunaan fungsi dan prosedur. Program
yang akan dibahas dalam modul ini adalah program Fibonacci, program Tower of
Hanoi, program FPB, program bangun datar, dan program bangun ruang. Kelima
program tersebut mengunakan fungsi dan procedure.
23 Program Fibonacci
Hal yang pertama dilakukaan pada saat pembuatan program fibonacci
adalah pembuatan flowchart. Flowchat yang dimaksud dapat dilihat pada Gambar
3.11.
65
Gambar 3.11 Flowchart program fibonacci
Gambar 3.11 adalah flowchart utama dari program fibonacci. Berdasarkan

flowchart diatas, terdapat dua sub flowchart yaitu flowchart fibonacci iteratif, dan
rekursif.
66
Flowchart program secara iteratif dan secara rekursif dapat dilihat pada
Gambar 3.12.
Gambar 3.12 Flowchart fibonacci rekursif
Gambar 3.12 adalah sub-flowchart dari program fibonacci yang berisikan

alur program fibonacci rekursif.
Flowchart program fibonacci dengan menggunakan fungsi secara iteratif
dapa dilihat pada Gambar 3.13.
67
Gambar 3.13 Flowchart fibonacci iteratif
Gambar 3.13 adalah sub-flowchart dari flowchart program fibonacci yang

berisikan alur program fibonacci secara iteratif.
Kode program Pseudocode dari program utama dalam deret fibonacci
23 Mulai
24 Read bil
25 Write "secara rekursif"
26 For x < 1 < bil DO
27 Write Fibo_rekursif(x)
28 End for
29 Write "secara heralif"
30 For x < 1 < bil DO
31 Write fibo_heralif(x)
32 End for
33 Read tombol
34 If tombol ='Y'll'y' Then
68
23 Goto 2
24 End if
25 Selesai
Kode Program 3.16 Pseudocode program fibonacci utama
Kode Program 3.16 menjelaskan tentang program fibonacci dengan

Pseudocode dari program fibonacci secara rekursif dapat dilihat pada
Kode Program 3.17
23 Mulai
24 Read x
25 If x <- 0 Then
26 Return 0
27 Else if x <- 1 Then
28 Return 1
29 Else
30 Return fibo_rekursif (x-1)+fibo_rekursif(x-2)
31 Selesai
Kode Program 3.17 Pseudocode program fibonacci rekursif
Kode Program 3.17 merupakan Pseudocode yang menjelaskan mengenai

program fibonacci secara rekursif.
Pseudocode dari program fibonacci secara rekursif dapat dilihat pada
Kode Program 3.18
23 Mulai
24 Read un
25 angka[un]
26 For x <- o-un DO
27 If x <- 0 Then
28 angka[x] <- o
29 Else if x <- l Then
30 angka[x] <- l
31 Else
32 a <- x-1
33 b <- x-2
34 angka[x] <- angka[a]+angka[b]
35 End if
36 End for
37 Write angka[un]
38 Selesai
Kode Program 3.18 Pseudocode program fibonacci iteratif
Kode Program 3.18 merupakan Pseudocode yang menjelaskan mengenai

program fibonacci secara iteratif.
69
24 #include <windows.h>
25 #include <conio.h>
26 #include <limits>
28 class Scanner {
29 public:
32 private:
34 };
36 string tmp;
37 cin >> tmp;
18. cin >> tmp;
23 }
25 }
27 int cnt = 0;
26. cnt++;
27. }
23 }
24 return cnt;
25 }
34. return false;
35. }
37. return false;
38. }
40. return false;
41. }
> '9'){
44. return false;
45. }
46. }
23 }
24 return true;
25 }
26 int fibo_rekursif(int);
27 void fibo_iteratif(int);
28 main(){
29 ulang:
30 Scanner* input = new Scanner();
70
23 system("cls");
24 int bil;
25 char tombol;
26 cout<<" __________________________________"<<endl;
23 cout<<"|__________________________________|"<<endl;
61. cout<<"| ~~Bilangan Fibonacci~~ |"<<endl;
23 cout<<" __________________________________"<<endl;
24 cout<<"\n";
64.
23 cout<<"Masukkan jumlah deret fibonacci: ";
66. bil=input->nextInt("Input salah\nMasukkan jumlah
deret fibonacci: ");
23 cout<<"\nSecara Rekursif\n\t:";
24 for(int x=0; x<bil; x++)
69. cout<<fibo_rekursif(x)<<", ";
23 cout<<"\n\nSecara Iteratif\n\t:";
24 for(int x=0; x<bil; x++){
72. fibo_iteratif(x);
73. cout<<", ";
23 }
24 cout<<"\n\nUlangi?\t[y/t]\t";
25 cin>>tombol;
26 if (tombol=='Y'||tombol=='y')
78. goto ulang;
23 else
80. cout<<"\nTerima Kasih";
23 getch();
24 return 0;
25 }
26 int fibo_rekursif(int x)
27 {
28 if(x==0)
87. return 0;
23 else if(x==1)
89. return 1;
23 else
91. return fibo_rekursif(x-1)+fibo_rekursif(x-2);
23 }
24 void fibo_iteratif(int Un)
25 {
26 int x,a,b;
27 int angka[Un];
28 for (x=0;x<=Un;x++){
98. if (x==0)
99. angka[x]=0;
100. else if (x==1)
101. angka[x]=1;
102. else{
103. a=x-1;
104. b=x-2;
105. angka[x]=angka[a]+angka[b];
106. }
23 }
24 cout<<angka[Un];
25 }
Kode Program 3.19 Program fibonacci
71
Kode program 3.19 merupakan sintaks dari program fibonacci yang telah
dibuat di dalam Dev C++.
Trace dari program fibonacci yang telah dibuat diatas dapat dilihat pada
Kode Program 3.20.
input:
bil = 3
proses:
//secara rekursif
for (X = 0-2)
(X = 0
fibo_rekursif(0)
if(X == 0)(benar)
return 0
out:0
X = 1
fibo_rekursif(1)
if(X == 0)(salah)
else if (X == 1)(benar)
return 1
out = 1
X = 2
Fibo_rekursif(2) if
(X == 0)(salah)
else if(X == 1)(salah)
{
return fibo_rekursif(1)+fibo_rekursif(0)
return 1+0
return 1
}
out:1)
//secara iteratif
For (X = 0-2)
(X = 0
fibo_iteratif(0)
for (X = 0-0)
X = 0
if (X == 0)(benar)
angka[0]=0
out:0(angka[0])
X = 1
Fibo_iteratif(0)
for(X = 0-1)
X = 0
If(X == 1)(benar)
angka[1]= 1
out:1 (angka[1])
X = 2
Fibo_iteratif(0)
For(X = 0-2)
X = 0
if(X == 0)(benar)
angka[0]=0
X = 1
72
if (X == 0)(salah)
angka[1]=1
X = 2
if(X == 0)(salah)
23= 2-1 = 1
24= 2-2 = 0
angka[2]=angka[1]+angka[0]=1+01
out:1 (angka[2]))
output:
secara rekursif = 0,1,1
secara iteratif = 0,1,1
Kode Program 3.20Trace program fibonacci
Trace 3.20 menjelaskan tentang trace dari program Fibonacci secara

iteratif dan secara rekursif.
Program fibonacci tersebut jika di-compile melalui Dev C++ maka
hasilnya Gambar 3.13.
Gambar 3.14 Hasil compile program fibonacci pada Dev C++
Gambar 3.14 merupakan hasil compile dari program fibonacci pada Dev
C++ secara rekursif dan iteratif.
23 Program Tower Of Hanoi

Hal yang pertama dilakukaan pada saat pembuatan program tower of hanoi
3.14.
73
Gambar 3.15 Flowchart program Tower Of Hanoi
Gambar 3.15 merupakan flowchart dari program utama Tower of Hanoi

dalam pemrograman dengan menggunakan Dev C++.
Dalam flowchart utama program tower of hanoi, terdapat dua sub program
yaitu program secara rekursif, dan iteratif. Flowchart dari rekursif dan iteratif
tersebut dapat dilihat pada Gambar 3.16.
74
Gambar 3.16 Flowchart program Tower Of Hanoi secara rekursif
Gambar 3.16 menjelaskan tentang flowchart dari program tower of hanoi

secara rekursif.
Flowchart dari program tower of hanoi secara iteratif dapat dilihat pada
Gambar 3.17.
75
76
Gambar 3.17 Flowchart program Tower Of Hanoi secara iteratif
Gambar 3.17 adalah flowchart yang dibuat berdasarkan program tower of

hanoi secara iteratif.
Bentuk pseudocode dari program utama tower of hanoi dapat dilihat pada
Kode Program 3.21.
77
23 Mulai
24 Read disk
25 Write "secara rekursif"
26 Hanoi_rek(disk,'A','B','C')
27 Write "secara iteratif"
28 Perulangan <- counter(disk)
29 Hanoi_ite(disk,perulangan,'A','B','C')
30 Read tombol
31 If tombol = 'Y'll'Y'then
32 Go to 2
33 End if
34 Selesai
Kode Program 3.21 Pseudocode program tower of hanoi utama
Kode Program 3.21 merupakan pseudocode berdasarkan dari program

tower of hanoi yang menjelaskan tentang pseudocode dari tower of hanoi.
Pseudocode untuk program tower of hanoi secara rekursif dan iteratif
23 Mulai
24 Read disk,dari,bantu,ke
25 If disk >0 Then
26 Hanoi_rek(disk_1,bantu,dari,ke)
27 Write "pindahkan disk dari"dari"ke" ke
28 Hanoi_rek(disk_1,bantu,dari,ke)
29 End if
30 Selesai
Kode Program 3.22 Pseudocode program tower of hanoi rekursif
Kode Program 3.22 adalah pseudocode program tower of hanoi secara

rekursif.
Kode Program 3.23 selanjutnya merupakan pseudocode dari program
tower of hanoi secara iteratif.
23 Mulai
24 Read disk,perulangan,dari,bantu,ke
25 If! genap(disk)then
26 For loop <- 1- perulangan DO
27 Switch(pilihan (loop,pil_disk(loop_disk),disk))
28 Case1:
29 If! genap(pil_disk(loop,disk)) then
30 Write "pindahkan disk dari"dari"ke"ke
31 Else
32 Write "pindahkan disk dari"dari"ke"bantu
33 End if
34 Case2:
35 If! genap(pil_disk(loop,disk)) Then
36 Write "pindahkan disk dari"ke"ke"bantu
37 Else
78
23 Write "pindahkan disk dari"bantu"ke"ke"
24 End if
25 Case3:
26 If! genap(pil_disk(loop,disk)) Then
27 Write "pindahkan disk dari"bantu"ke"dari
28 Else
29 Write "pindahkan disk dari"ke"ke"dari
30 End if
31 End switch
32 End for
33 Else
34 For loop <- 1- perulangan DO
35 Switch(pilihan(loop,pil_disk(loop,disk),disk))
36 Case1:
38 Write "pindahkan disk dari"dari"ke"bantu
39 Else
40 Write "pindahkan disk dari"dari"ke"ke
41 End if
42 Case2:
43 If! genap(pil_disk(loop_disk)) then
45 Else
47 End if
48 Case3:
51 Else
53 End if
54 End switch
55 End for
56 End if
57 Selesai
Kode Program 3.23 Pseudocode program tower of hanoi iteratif
Kode Program 3.23 adalah pseudocode dari program tower of hanoi secara
iteratif.
Pembuatan flowchart dan pseudocode selesai, flowchart dan pseudocode
tersebut dituangkan kedalah program Dev C++. Program yang telah dibuat dalam
Dev C++ dapat dilihat pada Kode Program 3.24.
#include <iostream>
#include <windows.h>
#include <conio.h>
#include <limits>
#include <stdlib.h>
#include <cstdlib>
using namespace std;
class Scanner {
public:
int nextInt(const char* errorMessage);
bool isNumInteger(string numericString);
79
private:
int count(char item, string list);
};
int Scanner::nextInt(const char* errorMessage) {
string tmp;
cin >> tmp;
while (!this->isNumInteger(tmp)){
20. cin >> tmp;
}
return atoi(tmp.c_str());
}
int Scanner::count(char item, string list){
int cnt = 0;
for (int i=0; i<list.length(); i++){
28. cnt++;
29. }
}
return cnt;
}
bool Scanner::isNumInteger(string numericString){
for (int i=0; i<numericString.length(); i++){
36. return false;
37. }
39. return false;
40. }
42. return false;
43. }
> '9'){
46. return false;
47. }
48. }
}
return true;
}
void hanoi_rek (int, char, char, char);
void hanoi_ite(int, int, char, char, char);
bool genap(int);
int counter(int);
int pil_disk(int,int);
int pilihan(int,int,int);
main (){
ulang:
Scanner* input = new Scanner;
system("cls");
char tombol;
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
66. cout<<"| ~~Tower of Hanoi~~ |"<<endl;
cout<<" __________________________________"<<endl;
int disk, perulangan;
cout<<"Masukkan banyaknya disk: ";
80
70. disk = input->nextInt("Input salah\nMasukkan
banyaknya disk: ");
cout<<"\nLangkah-langkahnya adalah:"<<endl<<endl;
cout<<"Secara Rekursif:"<<endl;
hanoi_rek(disk,'A','B','C');
74.
cout<<"\nSecara Iteratif:"<<endl;
perulangan=counter(disk);
hanoi_ite(disk,perulangan,'A','B','C');
cout<<"\n\nUlangi?\t[y/t]\t";
cin>>tombol;
if (tombol=='Y'||tombol=='y')
82. goto ulang;
else
getche ();
return 0;
}
void hanoi_rek (int disk, char dari, char bantu, char ke){
if (disk>0){
90. hanoi_rek (disk-1,dari,ke,bantu);
91. cout<<"\tPindahkan disk dari "<<dari<<" ke "<<ke<<endl;
92. hanoi_rek (disk-1,bantu,dari,ke);

}
}
void hanoi_ite(int disk, int perulangan, char dari, char bantu,
char ke){
int loop;
if(!genap(disk)){
98. for(loop=1; loop<=perulangan; loop++){
99.
switch(pilihan(loop,pil_disk(loop,disk),disk)){
100. case 1:
101.
if(!genap(pil_disk(loop,disk)))
102. cout<<"\tPindahkan disk
dari "<<dari<<" ke "<<ke<<endl;
103. else
dari "<<dari<<" ke "<<bantu<<endl;
105. break;
106. case 2:
107.
dari "<<ke<<" ke "<<bantu<<endl;
109. else
dari "<<bantu<<" ke "<<ke<<endl;
111. break;
112. case 3:
113.
dari "<<bantu<<" ke "<<dari<<endl;
115. else
81
dari "<<ke<<" ke "<<dari<<endl;
117. break;
118. }
119. }
}
else{
122. for(loop=1; loop<=perulangan; loop++){
123. switch(pilihan(loop,pil_disk(loop,disk),disk)){
124. case 1:
125.
dari "<<dari<<" ke "<<bantu<<endl;
127. else
dari "<<dari<<" ke "<<ke<<endl;
129. break;
130. case 2:
131.
dari "<<bantu<<" ke "<<ke<<endl;
133. else
dari "<<ke<<" ke "<<bantu<<endl;
135. break;
136. case 3:
137.
dari "<<ke<<" ke "<<dari<<endl;
139. else
dari "<<bantu<<" ke "<<dari<<endl;
141. break;
142. }
143. }
}
}
bool genap(int disk){
bool genap;
if (disk%2==0)
149. genap=true;
else
151. genap=false;
return genap;
}
int counter(int disk) {
int counter=0;
for (int x=1; x<=disk; x++)
157. counter=(counter*2)+1;
return counter;
}
int pil_disk(int loop, int disk){
int pil_disk;
int awal=1;
int increment=2;
int perulangan=counter(disk);
for(int x=1; x<=disk; x++){
82
166. for(int y=awal; y<=perulangan; y+=increment){
167. if(loop==y){
168. pil_disk=x;}
169. }
170. awal*=2;
171. increment*=2;
}
return pil_disk;}
int pilihan(int loop,int pil_disk,int disk){
int pilihan=0;
int increment=2;
int awal=1;
for(int x=1; x<=disk; x++){
179. if(x==pil_disk){
180. for(int y=awal; y<=loop; y+=increment){
181. pilihan++;
182. if(pilihan==3 && y!=loop)
183. pilihan=0;
184. }
185. }
186. awal*=2;
187. increment*=2;
}
return pilihan;
}
Kode Program 3.24 Program Tower of Hanoi
Kode program 3.24 merupakan sintaks dari program tower of hanoi.

Pengguna hanya perlu memasukkan banyaknya disk dari tower of hanoi.
Program akan memproses input tersebut dalam program sehingga
menghasilkan output yang sesuai. Trace dari program tower of hanoi dapat dilihat
pada Kode Program 3.25
Input:
disk = 2
Proses :
//Secara Rekursif
hanoi_rek(2,A,B,C)
If(2>0)(benar)
hanoi_rek(1,A,C,B)
if(1>0)(benar)
hanoi_rek(0,A,B,C)
if(0>0)(salah)
out: A ke B
hanoi_rek(0,C,A,B)
if(0>0)(salah)
out: A ke C
hanoi_rek(1,B,A,C)
if(1>0)(benar)
hanoi_rek(0,B,C,A)
if(0>0)(salah)
out: B ke C
hanoi_rek(0,C,A,B)
83
if(0>0)(salah)
//secara iteratif
Perulangan= counter(2)= 3{
counter = 0
for(X = 1-2;X++)
X = 1
counter = (0*2)+1 = 1
X = 2
counter = (1*2)+1 = 3
return 3
}
hanoi_ite (2,3,A,B,C) If(!
genap(2))(salah)
{ if(2%2==0)(benar)
genap = true
return genap
}
for(loop = 1-3; loop++)
loop = 1
switch (pilihan(1,pil_disk(1,2),2))
{ pil_disk(1,2)= 1{
awal = 1
increment = 2
perulangan = counter(2)= 3
for(X = 1-2; X++)
X = 1
for(y = 1-3; y+ = 2)
y = 1
if(1 == 1)(benar)
pil_disk = 1
y = 3 if(1==1)
(salah) awal = 1*2 =
2 increment = 2*2 =4
x = 1 if(1==1)
(benar) for(y = 1-1;
y+ = 2) y = 1
pilihan = 0+1 = 1
if(1==3 && 1!=1)(salah)
awal = 1*2 = 2 increment
= 2*2 = 4
x = 2 if(2==1)
(salah) return
pilihan = 1
}
}
case1:
if(!genap(1))(benar)
out: A ke B
loop: 2
switch(pilihan(2,pil_disk(2,2),2)){
pil_disk (2,2)= 2 {
awal = 1
increment = 2
for(X = 1 -2; X++)
y = 1
84
if(2==2)(benar)
pil_disk = 2
awal = 2*2 = 4
increment = 4*2 = 8
return pil_disk = 2
}
pilihan(2,2,2)=
1{ pilihan =
0 increment =
2 awal = 1
for(X = 1-2; X++)
X = 1
if(1==2)(salah) awal
= 1*2 = 2 increment
= 2*2 = 4
X = 2
if(2==2)(benar) for(y
= 2-2; y+ = 2)
y = 2
pilihan = 0+1 = 1
if(1==3 && 2! =2)(salah)
awal = 2*2 =4
increment = 4*4 = 8
return pilihan = 1
}
}
Case1:
if(!genap(2))(salah)
out: A ke C
loop = 3
switch(pilihan (3,pil_disk(3,2),2))
{ pil_disk (3,2)= 1 {
awal = 1
increment = 2
for(X = 1-2; X++)
X = 1
for(y = 1-3; y+ = 2)
y = 1
if(3==1)(salah)
y = 3 if(3==3)
(benar)
pil_disk = 1
awal = 1*2 = 2
increment = 2*2 = 4
x = 2
for(y = 2-3; y+ = 4)
y = 2
= 2*2 = 4 increment
= 4*2 = 8
return pil_disk = 1
}
pilihan(3,1,2)=
2{ pilihan =
0 increment =
2 awal = 1
for(X = 1-2; x++)
X = 1
85
if(1==1)(benar) for(y
= 1-3; y+ = 2)
y = 1
pilihan = 0+1 = 1 if(1===3
&& 2!= 2)(salah)
y = 2
pilihan = 1+1 = 2 if(1==3
&& 2!= 2)(salah)
awal = 1*2 = 2
increment = 2*2 = 4
X = 2
= 2*2 = 4 increment
= 4*2 = 8
return pilihan = 2
}
}
Case2:
If(!genap(1))(benar)
out = B ke C
output =
//Secara rekursif
A ke B
A ke C
B ke C
//Secara iteratif
A ke B
A ke C
B ke C
Kode Program 3.25Trace program tower of hanoi
Kode Program 3.25 menjelaskan tentang trace dari program tower of

hanoi. Pengguna hanya perlu memasukkan banyaknya disk dari tower of Hanoi,
selanjutnya program tower of hanoi jika di-compile melalui Dev C++ maka
86
Gambar 3.18 Hasil compile program tower of hanoi pada Dev C++
Gambar 3.18 merupakan hasil compile dari program tower of hanoi pada
pemrograman dengan menggunakan Dev C++ secara iteratif dan rekursif.
Program Faktor Persekutuan Terbesar (FPB)

Hal yang pertama dilakukaan pada saat pembuatan program FPB adalah
pembuatan flowchart. Flowchat yang dimaksud dapat dilihat pada Gambar 3.19.
87
Gambar 3.19 Flowchart program FPB
Gambar 3.19 adalah flowchart yang dibuat berdasarkan pada program

utama FPB yang dibuat menggunakan Dev C++.
Flowchart untuk program rekursif dan iteratif dapat dilihat pada gambar
Gambar 3.20 dan Gambar 3.21.
88
Gambar 3.20 Flowchart program FPB rekursif
Gambar 3.20 adalah flowchart yang dibuat berdasarkan pada program FPB
secara rekursif yang dibuat menggunakan Dev C++.
Gambar untuk flowchart dari program FPB secara iteratif dapat dilihat
pada Gambar 3.21.
89
Gambar 3.21 Flowchart program FPB iteratif
Gambar 3.21 adalah flowchart yang dibuat berdasarkan pada program FPB
secara iteratif yang dibuat menggunakan Dev C++.
Bentuk pseudocode dari program utama FPB dapat dilihat pada Kode
Program 3.26
Mulai
Read bil1,bil2
Write "secara rekursif"
Write "FPBnya"FPB_rek(bil1,bil2)
Write "secara iteratif"
FPB_he(bil1,bil2)
Read tombol
if tombol = 'Y'll'y' then
Go to 2
End if
Selesai
Kode Program 3.26 Pseudocode program FPB
Kode Program 3.26 menjelaskan tentang program FPB dengan

Pseudocode dari program FPB secara rekursif dan iteratif dapat dilihat
Mulai
Read a,b
if b<=A && a% b==0 then
return b
90
Else if a<b then
hasil <- FPBrek (b,a)
return hasil;
Else
mod <- a%
hasil <- FPBrek(b,mod);
End if
Return hasil
Selesai
Kode Program 3.27 Pseudocode program FPB rekursif
Kode program 3.27 merupakan Pseudocode dari program FPB secara

rekursif yang dibuat dengan menggunakan Dev C++.
Kode program dari pseudocode dari program FPB secara iteratif dapat
dilihat pada Kode Program 3.28
Mulai
Read a,b
m <- a
n <- b
r <- m%n
While r!= 0 DO
m <- n
n <- r
r <- m%
Write "FPBnya"n
Selesai
Kode Program 3.28 Pseudocode program FPB iteratif
Kode program 3.28 merupakan Pseudocode dari program FPB secara

iteratif yang dibuat dengan menggunakan Dev C++.
#include <iostream>
#include <conio.h>
#include <limits>
#include <cstdlib>
class Scanner
{ public:
private:
};
string tmp;
cin >> tmp;
while (!this->isNumInteger(tmp))
{ cout << errorMessage;
91
cin >> tmp;
}
}
int cnt = 0;
if (list[i] == item){
cnt++;
}
}
return cnt;
}
bool Scanner::isNumInteger(string numericString){ for
(int i=0; i<numericString.length(); i++){
if (numericString[0] == '-'){
return false;
}
if (this->count('-', numericString) > 1){
return false;
}
if ((numericString[i] == '-') && (i != 0)){
return false;
}
if (numericString[i] < '0' || numericString[i] >
'9'){
if (numericString[i] != '-'){
return false;
}
}
}
return true;
}
int FPB_rek (int,int);
void FPB_ite (int,int);
main(){
ulang:
system("cls");
cout<<" __________________________________"<<endl;
cout<<"| Kelompok 16 |"<<endl;
cout<<"|__________________________________|"<<endl;
cout<<"| ~~Persamaan Kuadrat~~ |"<<endl;
cout<<" __________________________________"<<endl;
int bil1,bil2,hm,n,hasil,r;
char tombol;
cout<<"Input Bilangan 1: ";
bil1 = input->nextInt("Input salah\nInput Bilangan 1: ");
cout<<"Input Bilangan 2: ";
bil2 = input->nextInt("Input salah\nInput Bilangan 2: ");
cout<<"\nSecara Rekursif:"<<endl;
cout<<"\tFPB bilangan "<<bil1<<" dan "<<bil2<<" adalah
"<<FPB_rek(bil1,bil2)<<endl;
cout<<"\nSecara Iteratif:"<<endl;
FPB_ite(bil1,bil2);
cout<<"\nUlangi?\t[y/t]\t";
cin>>tombol;
if (tombol=='Y'||tombol=='y') goto
ulang;
92
else
cout<<"\nTerima Kasih";
getch();
return 0;
}
int FPB_rek(int a,int b){
int hasil,mod;
if(b<=a && a%b==0)
return b;
else if(a<b){
hasil=FPB_rek(b,a);
return hasil;
}
else
mod=a%b;
hasil=FPB_rek(b,mod);
return hasil;
}
void FPB_ite (int a,int b)
{ int m=a, n=b, r = m
%n;
while(r!=0){
m = n;
n = r;
r = m%n;
}
cout<<"\tFPB bilangan "<<a<<" dan "<<b<<" adalah "<<n<<endl;
}
Kode Program 3.29 Program FPB
Kode program 3.29 merupakan sintaks dari program FPB dengan

pemrograman menggunakan Dev C++. Pengguna cukup memasukkan dua angka
yang ingin dicari FPB-nya. Kemudian kedua angka tersebut diproses dalam
program sehingga menghasilkan output yang sesuai.
Trace dari program FPB secara iteratif maupun rekursif pada Kode
Program 3.30.
Input :
bil1 = 4,bil2 = 6
Proses :
//Secara rekursif
FPB_rek(4,6)
If(6 <= 4 && 4%6==0)(salah)
else if(4<6)(benar)
hasil = FPB_rek(6,4)
{ FPB_rek(6,4)
If(4 <= 6 && 6%4==0)(salah)
else if(6 < 4)(salah)
mod = 6% = 2
hasil = FPB_rek (4,2){
FPB_rek(4,2)
If(2 <= 4 && 4%2==0)(benar)
}
return 2
}
93
//Secara iteratif
FPB_he (4,6)
m = 4
n = 6
r = 4%6 = 2
Output :
Secara rekursif :
FPB bilangan 4 dan 6 adalah 2
Secara iteratif :
FPB bilangan 4 dan 6 adalah 2
Kode Program 3.30 Trace program FPB
Kode Program 3.30 menjelaskan tentang trace dari program FPB secara
iteratif dan secara rekursif.
Program FPB jika di-compile melalui Dev C++ maka hasilnya dapat
Gambar 3.22 Hasil compile program FPB pada Dev C++
Gambar 3.22 merupakan hasil dari sintaks program FPB yang telah di-
compile, terdari dari input-an pengguna, dan hasil yang didapatkan.
Program Bangun Datar

Hal yang pertama dilakukaan pada saat pembuatan program bangun datar
3.22.
94
95
Gambar 3.23 Flowchart program bangun datar
Gambar 3.23 menjelaskan tentang flowchart bangun datar, dalam program

tersebut terdapat lima sub program. Oleh karena itu, dibuatlah lima flowchart
tambahan yang mewakili sub program tersebut. Flowchart tersebut dapat dilihat
pada Gambar 3.24.
96
Gambar 3.24 Flowchart program luas bangun datar persegi panjang
Gambar 3.24 diatas menjelaskan mengenai flowchart dari fungsi luas

persegi panjang.
Flowchart keliling persegi panjang dari program bangun datar dapat
Gambar 3.25 Flowchart program keliling bangun datar persegi panjang
Gambar 3.25 diatas menjelaskan mengenai flowchart dari fungsi keliling

persegi panjang.
Flowchart luas segitiga sembarang dari program bangun datar dapat dilihat
pada Gambar 3.26.
97
Gambar 3.26 Flowchart program luas bangun datar segitiga sembarang

segitiga sembarang.
Flowchart keliling segitiga sembarang dari program bangun datar dapat
Gambar 3.27 Flowchart program keliling bangun datar segitiga sembarang

segitiga sembarang.
Flowchart luas lingkaran dari program bangun datar dapat dilihat pada
Gambar 3.28.
98
Gambar 3.28 Flowchart program luas bangun datar lingkaran
Gambar 3.28 diatas menjelaskan mengenai flowchart ldari fungsi uas

lingkaran.
Flowchart keliling lingkaran dari program bangun datar dapat dilihat pada
Gambar 3.29.
Gambar 3.29 Flowchart program keliling bangun datar lingkaran

lingkaran.
Flowchart luas trapesium dari prgram bangun datar dapat dilihat pada
Gambar 3.29.
99
Gambar 3.30 Flowchart program luas bangun datar trapesium

trapesium.
Flowchart keliling trapesium dari program bangun datar dapat dilihat pada
Gambar 3.31 berikut.
Gambar 3.31 Flowchart program keliling bangun datar trapesium

trapesium.
Flowchart luas jajargenjang dari program bangun datar dapat dilihat pada
Gambar 3.32 berikut.
100
Gambar 3.32 Flowchart program luas bangun datar jajargenjang

jajargenjang.
Flowchart keliling jajargenjang dari program bangun datar dapat dilihat
pada Gambar 3.33 berikut.
Gambar 3.33 Flowchart program keliling bangun datar jajargenjang

jajargenjang.
101
Pseudocode yang dapat dibuat berdasarkan flowchart tersebut dapat dilihat
Mulai
Read menu
switch(menu)
Case1:
Read p,p
L_per_panjang(p,p)
K_per_panjang(p,p)
Case2:
Read a,b,c
L_segi_sem(a,b,c)
K_segi_sem(a,b,c)
Case3:
Read r
L_lingkaran(r)
K_lingkaran(r)
Case4:
Read a,b,t,miring
L_trapesium (a,b,t)
K_trapesium (a,b,t,miring)
Case5:
Read a,t,miring
L_jajargenjang(a,t)
K_jajargenjang(a,miring)
Case6:
goto 3i
default
Read tombol
If tombol = 'Y'll'y'
goto 2
End if
Selesai
Kode Program 3.31 Pseudocode utama program bangun datar
Kode 3.31 diatas adalah pseudocode dari program utama bangun datar
dengan menggunakan bahasa pemrograman C++.
Pseudocode dari fungsi luas persegi panjang berdasarkan program bangun
datar dapat dilihat pada Kode Program 3.32.
Mulai
Read p,P
luas <- p*P
return luas
selesai
Kode Program 3.32 Pseudocode program luas persegi panjang
Kode 3.32 diatas adalah pseudocode dari fungsi luas persegi panjang
berdasarkan program bangun datar.
102
Pseudocode dari fungsi keliling persegi panjang berdarsarkan program
bangun datar dapat dilihat pada Kode Program 3.33.
Mulai
Read p,P
K <- 2*(p+P)
return k
selesai
Kode Program 3.33 Pseudocode keliling persegi panjang
Kode 3.33 diatas adalah pseudocode dari fungsi keliling persegi panjang
Pseudocode dari fungsi luas segitiga sembarang berdasrakan program
Mulai
Read a,b,c
S <- (a+b+c)/2
luas <- pow (s*(s-a)*(s-b)*0,5)
return luas
Selesai
Kode Program 3.34 Pseudocode luas segitiga sembarang
Kode 3.34 diatas adalah pseudocode dari fungsi luas segitiga sembarang
Pseudocode dari fungsi keliling segitiga sembarang berdasarkan program
Mulai
Read a,b,c
K <- a+b+c
return K
Selesai
Kode Program 3.35 Pseudocode keliling segitiga sembarang
Kode 3.35 diatas adalah pseudocode dari fungsi keliling segitiga

sembarang berdasarkan program bangun datar.
Pseudocode dari fungsi luas lingkaran berdasarkan program bangun datar
Mulai
Read
luas <- phi*r*r
Return luas
Selesai
Kode Program 3.36 Pseudocode luas lingkaran
103
Kode 3.36 diatas adalah pseudocode luas lingkaran berdasarkan program
bangun datar.
Pseudocode dari keliling lingkaran dapat berdasarkan program bangun
datar dilihat pada Kode Program 3.37.
Mulai
Read r
K <- 2*phi*r
return k
Selesai
Kode Program 3.37 Pseudocode keliling lingkaran
Kode 3.37 diatas adalah pseudocode keliling lingkaran berdasarkan

program bangun datar.
Pseudocode dari luas trapesium berdasarkan program bangun datar dapat
Mulai
Read a,b,c
Luas <- (a+b)*t/2
return luas
selesai
Kode Program 3.38 Pseudocode luas trapesium
Kode 3.38 diatas adalah pseudocode luas trapesium berdasarkan program

bangun datar.
Pseudocode dari keliling trapesium berdasarkan program bangun datar
Mulai
Read a,b,t,miring
K <- a+b+c+t+miring
return K
Selesai
Kode Program 3.39 Pseudocode keliling trapesium
Kode 3.39 diatas adalah pseudocode keliling trapesium berdasarkan

Pseudocode dari luas jajargenjang berdasarkan program bangun datar
dapat dilihat pada Kode Program 3.40
Mulai
Read a,t
104
luas <- a*t
return luas
Selesai
Kode Program 3.40 Pseudocode luas jajargenjang
Kode 3.40 diatas adalah pseudocode luas jajargenjang berdasarkan

Pseudocode dari keliling jajargenjang berdasarkan program bangun datar
Mulai
Read a,miring
K <- 2*(a+miring)
return K
Selesai
Kode Program 3.41 Pseudocode keliling jajargenjang
Kode 3.41 diatas adalah pseudocode keliling jajargenjang berdasarkan

program bangun datar. Semua flowchart dan pseudocode tersebut jika dituangkan
ke dalam aplikasi Dev C++ akan menghasilkan program seperti pada Kode
Program 3.42.
#include <iostream>
#include <conio.h>
#include <limits>
#include <cmath>
class Scanner {
public:
float nextFloat(const char* errorMessage);
bool isNumFloat(string numericString);
private:
};
float Scanner::nextFloat(const char* errorMessage) {
string tmp;
cin >> tmp;
while (!this->isNumFloat(tmp)) {
19. cin >> tmp;
}
return atof(tmp.c_str());
}
int Scanner::count(char item, string list) {
int cnt = 0;
for (int i=0; i<list.length(); i++) {
26. if (list[i] == item) {
27. cnt++;
28. }
}
105
return cnt;
}
bool Scanner::isNumFloat(string numericString) {
for (int i=0; i<numericString.length(); i++) {
35. return false;
36. }
37. if (this->count('.', numericString) > 1 ||
this->count('-', numericString) > 1){
38. return false;
39. }
40. if ((numericString[i] == '.') && ((i == 0) ||
(i == numericString.length()-1))){
41. return false;
42. }
43. if ((numericString[i] == '-') && (i != 0)) {
44. return false;
45. }
> '9') {
47. if (numericString[i] != '.' &&
numericString[i] != '-') {
48. return false;
49. }
50. }
}
return true;
}
float luas, kll;
float luas_per_panjang(float,float);
float kll_per_panjang(float,float);
float luas_segi_sem(float,float,float);
float kll_segi_sem(float,float,float);
float luas_lingkaran(float);
float kll_lingkaran(float);
float luas_trapesium(float,float,float);
float kll_trapesium(float,float,float,float);
float luas_jajargenjang(float,float);
float kll_jajargenjang(float,float);
float const phi = 3.142;
main(){
ulang:
system("cls");
char tombol;
float p,l,a,b,c,r,t,miring;
int menu;
cout<<"
____________________________________________"<<endl;
|"<<endl;
75. cout<<"|____________________________________________|
"<<endl;
76. cout<<"| ~~LUAS DAN KELILING BANGUN DATAR~~
|"<<endl;
cout<<"
____________________________________________"<<endl;
cout<<"\nMENU:"<<endl;
cout<<"1. Persegi Panjang\t[tekan 1]"<<endl;
106
cout<<"2. Segitiga Sembarang\t[tekan 2]"<<endl;
cout<<"3. Lingkaran\t\t[tekan 3]"<<endl;
cout<<"4. Trapesium\t\t[tekan 4]"<<endl;
cout<<"5. Jajargenjang\t\t[tekan 5]"<<endl;
cout<<"6. Exit\t\t\t[tekan 6]"<<endl<<endl;
cout<<"Input Pilihan: ";
menu = input->nextFloat("Input salah\nInput Pilihan:
");
switch(menu){
88. case 1:
89. cout<<"---------------- PERSEGI PANJANG -
------------"<<endl<<endl;
90. cout<<"Input panjang\t: ";
91. p = input->nextFloat("Input salah\nInput
panjang\t: ");
92. cout<<"Input lebar\t: ";
93. l = input->nextFloat("Input salah\nInput
lebar\t: ");
94. cout<<"Luas\t\t:
"<<luas_per_panjang(p,l)<<endl;
95. cout<<"Keliling\t:
"<<kll_per_panjang(p,l)<<endl<<endl;
96. cout<<"Ulangi?\t[y/t]\t";
97. cin>>tombol;
98. if (tombol=='Y'||tombol=='y')
99. goto ulang;
100. else
102. getch();
103. break;
104. case 2:
105. cout<<"------------- SEGITIGA SEMBARANG -
------------"<<endl<<endl;
106. cout<<"Input sisi a\t: ";
107. a = input->nextFloat("Input salah\nInput
sisi a\t: ");
108. cout<<"Input sisi b\t: ";
109. b = input->nextFloat("Input salah\nInput
sisi b\t: ");
110. cout<<"Input sisi c\t: ";
111. c = input->nextFloat("Input salah\nInput
sisi c\t: ");
"<<luas_segi_sem(a,b,c)<<endl;
"<<kll_segi_sem(a,b,c)<<endl<<endl;
115. cin>>tombol;
117. goto ulang;
118. else
120. getch();
121. break;
122. case 3:
123. cout<<"----------------- LINGKARAN ------
------------"<<endl<<endl;
124. cout<<"Input jari-jari\t: ";
125. r = input->nextFloat("Input salah\nInput
107
jari-jari\t: ");
"<<luas_lingkaran(r)<<endl;
"<<kll_lingkaran(r)<<endl<<endl;
129. cin>>tombol;
131. goto ulang;
132. else
134. getch();
135. break;
136. case 4:
137. cout<<"----------------- TRAPESIUM ------
------------"<<endl<<endl;
138. cout<<"Input sisi atas\t\t: ";
sisi atas\t\t: ");
140. cout<<"Input sisi bawah\t: ";
141. b = input->nextFloat("Input salah\nInput
sisi bawah\t\t: ");
142. cout<<"Input tinggi\t\t: ";
143. t = input->nextFloat("Input salah\nInput
tinggi\t\t: ");
144. cout<<"Input sisi miring\t: ";
145. miring = input->nextFloat("Input
salah\nInput sisi miring\t: ");
146. cout<<"Luas\t\t\t:
"<<luas_trapesium(a,b,t)<<endl;
147. cout<<"Keliling\t\t:
"<<kll_trapesium(a,b,t,miring)<<endl<<endl;
149. cin>>tombol;
151. goto ulang;
152. else
154. getch();
155. break;
156. case 5:
157. cout<<"---------------- JAJARGENJANG ----
------------"<<endl<<endl;
158. cout<<"Input alas\t\t: ";
alas\t\t: ");
160. cout<<"Input tinggi\t\t: ";
tinggi\t\t: ");
162. cout<<"Input sisi miring\t: ";
163. miring = input->nextFloat("Input
salah\nInput sisi miring\t: ");
164. cout<<"Luas\t\t\t:
"<<luas_jajargenjang(a,t)<<endl;
165. cout<<"Keliling\t\t:
"<<kll_jajargenjang(a,miring)<<endl<<endl;
167. cin>>tombol;
108
169. goto ulang;
170. else
172. getch();
173. break;
174. case 6:
176. getch();
177. exit(0);
178. break;
179. default:
180. cout<<"Salah! pilih yang benar";
181. cout<<"\n\nUlangi?\t[y/t]\t";
182. cin>>tombol;
184. goto ulang;
185. else
187. getch();
188. break;
}
}
float luas_per_panjang(float p,float l){
luas = p*l;
return luas;
}
float kll_per_panjang(float p, float l){
kll = 2*(p+l);
return kll;
}
float luas_segi_sem(float a, float b, float c){
float s = (a+b+c)/2;
luas = pow(s*(s-a)*(s-b)*(s-c),0.5);
return luas;
}
float kll_segi_sem(float a, float b, float c){
kll = a+b+c;
return kll;
}
float luas_lingkaran(float r){
luas = phi*r*r;
return luas;
}
float kll_lingkaran(float r){
kll = 2*phi*r;
return kll;
}
float luas_trapesium(float a, float b, float t){
luas = (a+b)*t/2;
return luas;
}
float kll_trapesium(float a, float b, float t, float miring){
kll = a+b+t+miring;
return kll;
}
float luas_jajargenjang(float a, float t){
luas = a*t;
return luas;
109
}
float kll_jajargenjang(float a, float miring){
kll = 2*(a+miring);
return kll;
}
Kode Program 3.42 Program bangun datar
Kode Program 3.42 menjelaskan program bangun datar yang dibuat dalam
aplikasi Dev C++. Pengguna cukup memilih menu yang tersedia dan memasukkan
data sehingga program dapat memproses input dari pengguna.
Trace dari tiap menu berdasarkan program bangun datar dapat dilihat pada
Kode Program 3.43.
input:
menu = 1, l = 12, P = 4
proses:
L_per_panjang(12,4)
Luas = 12*4 = 48
return Luas = 48
out: luas = 48
K_per_panjang(12,4)
K = 2*(12+4)= 32
return K =32
out = keliling = 32
output:
luas = 48
keliling = 32
Kode Program 3.43 Trace program bangun datar persegi panjang
Kode Program 3.43 diatas adalah trace dari program luas dan keliling
persegi panjang berdasarkan program bangun datar.
Trace program dari segitiga sembarang berdasarkan program bangun datar
input:
menu = 2, a = 3, b = 4, c = 5
proses:
L_segi_sem(3,4,5)
S = (3+4+5)/2 = 6
Luas = pow (6*(6-3)*(6-4)*(6-5),0,5)=6
return luas = 6
out: luas = 6
K+segi_sem(3,4,5)
K = 3+4+5 = 12
return K = 12
out: keliling = 12
output :luas = 6
keliling = 12
Kode Program 3.44 Trace program bangun datar segitiga sembarang
110
segitiga sembarang berdasarkan program bangun datar.
Trace program dari lingkaran berdasarkan program bangun datar dapat
input:
menu = 3, r = 6
proses:
L_lingkaran(6)
L = 3.142*6*6 = 113,112
return luas = 113,112
out = luas = 113,112
K_lingkaran(6)
K = 2*3.142*6:37,704
return K = 37,704
out = keliling = 37,704
output :
Luas = 113,112
Keliling = 37,704
Kode Program 3.45 Trace program bangun datar lingkaran
lingkaran berdasarkan program bangun datar.
Trace program dari jajargenjang berdasarkan program bangun datar dapat
input:
menu = 5, a = 5, t =3, miring = 4
proses:
L_jajargenjang(5,3)
Luas = 5*3 = 15
out = Luas = 15
K_jajargenjang(5,4)
K = 2*(5+4) = 18
return K =18
out = keliling = 18
output :
Luas = 15
Keliling = 18
Kode Program 3.46 Trace program bangun datar jajargenjang
jajargenjang berdasarkan program bangun datar.
Trace program dari trapesium berdasarkan program bangun datar dapat
111
input:
menu = 4, a = 5, b = 3, t = 3, miring =4
proses:
L_trapesium(5,3,3)
Luas =(3+5)*3/2 = 12
return luas = 12
out = Luas = 12
K_trapesium (5,3,3,4)
K = 5+3+3+4 = 15
return K = 15
out = keliling = 15
output :
Luas = 12
Keliling = 15
Kode Program 3.47 Trace program bangun datar trapesium
trapesium berdasarkan program bangun datar.
Hasil program setelah compile berdasarkan program bangun datar pada
Dev C++ dapat dilihat pada Gambar 3.34.
Gambar 3.34 Hasil compile program persegi panjang pada Dev C++
Gambar 3.34 diatas adalah hasil compile program bangun datar dengan
memilih menu persegi panjang.
Hasil compile program segitiga sembarang berdasarkan program bangun
datar dapat dilihat pada Gambar 3.35.
112
Gambar 3.35 Hasil compile program segitiga sembarang pada Dev C++
memilih menu segitiga sembarang.
Hasil compile program lingkaran berdasarkan program bangun datar dapat
Gambar 3.36 Hasil compile program lingkaran pada Dev C++
memilih menu lingkaran.
Hasil compile program trapesium dapat berdasarkan program bangun datar
dilihat paga Gambar 3.37.
113
Gambar 3.37 Hasil compile program trapesium pada Dev C++
memilih menu trapesium.
Hasil compile program jajargenjang berdasarkan program bangun datar
Gambar 3.38 Hasil compile program jajargenjang pada Dev C++
memilih menu jajargenjang.
114
3.2.5 Program Bangun Ruang
Hal yang pertama dilakukaan pada saat pembuatan program bangun ruang
3.38.
115
Gambar 3.39 Flowchart program bangun ruang
Gambar 3.39 menjelaskan tentang flowchart bangun ruang, dalam program

tersebut terdapat lima sub program. Oleh karena itu, dibuatlah lima flowchart
tambahan yang mewakili sub program tersebut.
Flowchart yang akan digunakan dalam pembuatan program tersebut dapat
116
Gambar 3.40 Flowchart program bangun ruang balok
Gambar 3.40 diatas menjelaskan mengenai flowchart balok berdasarkan

program bangun ruang.
Flowchart bola program bangun ruang berdasrakan permograman C++
Gambar 3.41 Flowchart program bangun ruang bola
Gambar 3.41 diatas menjelaskan mengenai flowchart bola program bangun

ruang.
Flowchart limas segitiga sama sisi program bangun ruang dapat dilihat
pada Gambar 3.42.
117
Gambar 3.42 Flowchart program bangun ruang limas segitiga sama sisi
Gambar 3.42 diatas menjelaskan mengenai flowchart limas segitiga sama

sisi program bangun ruang.
Flowchart prisma segitiga program bangun ruang dapat dilihat pada
gambar 3.43.
Gambar 3.43 Flowchart program bangun ruang prisma segitiga
Gambar 3.43 diatas menjelaskan mengenai flowchart prisma segitiga

Flowchart tabung program bangun ruang berdasrakan pemrograman C++
dapat dilihat pada gambar 3.44.
118
Gambar 3.44 Flowchart program bangun ruang tabung
Gambar 3.44 diatas menjelaskan mengenai flowchart tabung\ program

bangun ruang.
Pseudocode yang dapat dibuat berdasarkan flowchart tersebut program
bangun ruang dapat dilihat pada kode program 3.48.
Mulai
Read p,P,t
volume <- p*P*t
Luas <- 2*((p*P)+(p*t)+(p*t))
Write Volume
Write luas p
Selesai
Kode Program 3.48 Pseudocode program balok
Kode program 3.48 diatas adalah pseudocode balok berdasarkan program

bangun ruang.
Pseudocode dari bola berdasarkan program bangun ruang dapat dilihat
pada kode program 3.49.
Mulai
Read r
Volume <- 4*phi*r*r*r/3
Luas <- 4*phi*r*r
Write Volume
Write Luas p
Selesai
Kode Program 3.49 Pseudocode program bola
Kode program 3.49 diatas adalah pseudocode bola berdasarkan program

bangun ruang dengan menggunakan basaha pemrograman C++.
119
Pseudocode dari limas segitiga sama sisi berdasarkan program bangun
ruang dapat dilihat pada Kode Program 3.50.
Mulai
Read s,t
Volume <- s*s*0,87*t/6
Luas <- 2*s*s*0,87
Write Volume
Write Luas p
Selesai
Kode Program 3.50 Pseudocode program limas segitiga sama sisi
Kode program 3.50 diatas adalah pseudocode limas segitiga sama sisi
berdasarkan program bangun ruang.
Pseudocode dari prisma segitiga berdasarkan program bangun ruang dapat
dilihat pada kode program 3.51.
Mulai
Read s,t
Volume <- s*s*0,87/2*t
Luas <- (s*s*0,87)+(3*s*t)
Write Volume
Write luas p
Selesai
Kode Program 3.51 Pseudocode program prisma segitiga
Kode program 3.51 diatas adalah pseudocode prisma segitiga berdasarkan

Pseudocode dari tabung berdasarkan program bangun ruang dapat dilihat
pada Kode program 3.52.
Mulai
Read r,t
Volume <- phi*r*r*t
Luas <- 2*phi*r(r+t)
Write Volume
Write Luas p
Selesai
Kode Program 3.52 Pseudocode program tabung
Kode program 3.52 diatas adalah pseudocode luas permukaan tabung

Flowchart dan pseudocode tersebut jika dituangkan ke dalam aplikasi Dev
C++ akan menghasilkan program pada kode program 3.53.
#include <iostream>
120
#include <conio.h>
#include <limits>
#include <cmath>
class Scanner {
public:
float nextFloat(const char* errorMessage);
bool isNumFloat(string numericString);
private:
};
float Scanner::nextFloat(const char* errorMessage) {
string tmp;
cin >> tmp;
while (!this->isNumFloat(tmp)) {
19. cin >> tmp;
}
return atof(tmp.c_str());
}
int Scanner::count(char item, string list) {
int cnt = 0;
for (int i=0; i<list.length(); i++) {
26. if (list[i] == item) {
27. cnt++;
28. }
}
return cnt;
}
bool Scanner::isNumFloat(string numericString) {
for (int i=0; i<numericString.length(); i++) {
35. return false;
36. }
37. if (this->count('.', numericString) > 1 ||
this->count('-', numericString) > 1){
38. return false;
39. }
40. if ((numericString[i] == '.') && ((i == 0) ||
(i == numericString.length()-1))){
41. return false;
42. }
43. if ((numericString[i] == '-') && (i != 0)) {
44. return false;
45. }
> '9') {
47. if (numericString[i] != '.' &&
numericString[i] != '-') {
48. return false;
49. }
50. }
}
return true;
}
float volume, luasP;
void balok(float,float,float);
void bola(float);
void limas_seg_sama_sisi(float,float);
121
void prisma_segitiga(float,float);
void tabung(float,float);
float const phi = 3.142;
main(){
ulang:
system("cls");
char tombol;
float p,l,t,r,s;
int menu;
cout<<"
_____________________________________________"<<endl;
|"<<endl;
70. cout<<"|_____________________________________________
|"<<endl;
71. cout<<"| Volume & Luas Permukaan Bangun Ruang
|"<<endl;
cout<<"
_____________________________________________"<<endl;
cout<<"\n";
74.
cout<<"MENU:"<<endl;
cout<<"1. Balok\t\t\t[tekan 1]"<<endl;
cout<<"2. Bola\t\t\t\t[tekan 2]"<<endl;
cout<<"3. Limas Segitiga Sama Sisi\t[tekan 3]"<<endl;
cout<<"4. Prisma Segitiga\t\t[tekan 4]"<<endl;
cout<<"5. Tabung\t\t\t[tekan 5]"<<endl;
cout<<"6. Exit\t\t\t\t[tekan 6]"<<endl<<endl;
menu = input->nextFloat("Input salah\nInput Pilihan:
");
switch(menu){
85. case 1:
86. cout<<"------------------- BALOK --------
------------"<<endl<<endl;
87. cout<<"Input panjang\t: ";
88. p = input->nextFloat("Input salah\nInput
panjang\t: ");
89. cout<<"Input lebar\t: ";
90. l = input->nextFloat("Input salah\nInput
lebar\t: ");
91. cout<<"Input tinggi\t: ";
tinggi\t: ");
93. balok(p,l,t);
95. cin>>tombol;
97. goto ulang;
98. else
100. getch();
101. break;
102. case 2:
103. cout<<"-------------------- BOLA --------
------------"<<endl<<endl;
122
jari-jari\t: ");
106. bola(r);
108. cin>>tombol;
110. goto ulang;
111. else
113. getch();
114. break;
115. case 3:
116. cout<<"---------- LIMAS SEGITIGA SAMA
SISI ----------"<<endl<<endl;
117. cout<<"Input sisi\t: ";
118. s = input->nextFloat("Input salah\nInput
sisi\t: ");
tinggi\t: ");
121. limas_seg_sama_sisi(s,t);
123. cin>>tombol;
125. goto ulang;
126. else
128. getch();
129. break;
130. case 4:
131. cout<<"-------------- PRISMA SEGITIGA ---
------------"<<endl<<endl;
132. cout<<"Input sisi\t: ";
133. s = input->nextFloat("Input salah\nInput
sisi\t: ");
tinggi\t: ");
136. prisma_segitiga(s,t);
138. cin>>tombol;
140. goto ulang;
141. else
143. getch();
144. break;
145. case 5:
146. cout<<"------------------- TABUNG -------
------------"<<endl<<endl;
jari-jari\t: ");
tinggi\t: ");
151. tabung(r,t);
153. cin>>tombol;
123
155. goto ulang;
156. else
158. getch();
159. break;
160. case 6:
162. getch();
163. exit(0);
164. break;
165. default:
166. cout<<"Salah! pilih yang benar";
167. cout<<"\n\nUlangi?\t[y/t]\t";
168. cin>>tombol;
170. goto ulang;
171. else
173. getch();
174. break;
}
}
void balok(float p, float l, float t){
volume = p*l*t;
luasP = 2*((p*l)+(p*t)+(l*t));
cout<<"Volume\t\t: "<<volume<<endl;
cout<<"Luas Permukaan\t: "<<luasP<<endl<<endl;
}
void bola(float r){
volume = 4*phi*r*r*r/3;
luasP = 4*phi*r*r;
}
void limas_seg_sama_sisi(float s, float t){
volume = s*s*0.87*t/6;
luasP = 2*s*s*0.87;
}
void prisma_segitiga(float s, float t){
volume = s*s*0.87/2*t;
luasP = (s*s*0.87)+(3*s*t);
}
void tabung(float r, float t){
volume = phi*r*r*t;
luasP = 2*phi*r*(r+t);
}
Kode Program 3.53 Program bangun ruang
124
Kode Program 3.53 menjelaskan program bangun ruang yang dibuat dalam
aplikasi Dev C++. Pengguna cukup memilih menu yang tersedia dan
memasukkan data sehingga program dapat memproses input dari pengguna.
Trace dari tiap menu berdasarkan program bangun ruang dapat dilihat pada
Kode Program 3.54.
input:
menu = 1, p = 6, P = 1, t = 5
proses:
balok(6,4,5)
volume = 6*4*5 = 120
luas = 2*((6*4)+(6*5)+(4*5))= 148
output:
volume = 120
Luas permukaan = 148
Kode Program 3.54 Trace program bangun ruang balok
Kode Program 3.54 diatas adalah trace dari program volume dan luas
permukaan balok berdasarkan program bangun ruang.
Trace program dari bola berdasarkan program bangun ruang dapat dilihat
input:
menu = 2, r = 9
proses:
bola(9)
volume = 4*3.142*9*9*9/3 = 3054,02
luas = 4*3.142*9*9 = 1018,01
output:
volume = 3054,02
Luas permukaan = 1018,01
Kode Program 3.55 Trace program bangun ruang bola
permukaan bola berdasarkan program bangun ruang.
Trace program dari limas segitiga sama sisi berdasarkan program bangun
ruang dapat dilihat Kode Program 3.56.
input:
menu = 3, s = 3, t = 4
proses:
Limas_seg_sama_sisi(3,4)
Volume = 3*3*0,87*416 = 5,22
Luas p = 2*3*3*0,87 = 15,66
output:
volume = 5,22
Kode Program 3.56 Trace program bangun ruang limas segitiga sama sisi
125
permukaan limas segitiga sama sisi.
Trace program dari tabung berdasarkan program bangun ruang dapat
input:
menu = 5, r = 4, t = 5
proses:
tabung(4,5)
volume = 3,142*4*4*5 = 251,36
Luas = 2*3.142*4*(4+5)= 226,224
output:
volume = 251,36
Kode Program 3.57 Trace program bangun ruang tabung
permukaan tabung berdasarkan program bangun ruang.
Trace program dari prisma segitiga dapat dilihat pada Kode Program 3.58
input:
menu = 4, s = 5, t = 7
proses:
prisma_segitiga(5,7)
Volume = 5*5*0,87/2*7 = 76,125
Luas = (5*5*0,87)+(3*5*7)= 126,75
output:
volume = 76,125
Luas permukan = 126,75
Kode Program 3.58 Trace program bangun ruang prisma segitiga
permukaan prisma segitiga berdasarkan program bangun ruang.
Hasil program setelah compile berdasarkan program bangun ruang pada
Dev C++ dapat dilihat pada Gambar 3.45.
126
Gambar 3.45 Hasil compile program balok pada Dev C++
Gambar 3.45 diatas adalah hasil compile program bangun ruang dengan
memilih menu balok.
Hasil compile program bola berdasarkan program bangun ruang dapat
Gambar 3.46 Hasil compile program bola pada Dev C++
memilih menu bola.
Hasil compile program limas segitiga sama sisi berdasarkan program
bangun ruang dapat dilihat pada Gambar 3.47.
127
Gambar 3.47 Hasil compile program limas segitiga sama sisi pada Dev C++
memilih menu limas segitiga sama sisi.
Hasil compile program prisma segitiga berdasarkan program bangun ruang
Gambar 3.48 Hasil compile program prisma segitiga pada Dev C++
memilih menu prisma segitiga.
128
Hasil compile program tabung berdasarkan program bangun ruang dapat
Gambar 3.49 Hasil compile program tabung pada Dev C++
memilih menu tabung berdasarkan program bangun ruang.
Array dan Pointer

Modul ini membahas tentang array dan pointer. Program yang akan
dibahas dalam modul ini adalah program metode sorting dan searching yang
meliputi insertion sort, bubble sort, quick sort, sequential search, dan binary
search, program operasi matriks, program menghitung mean, median, dan mode,
serta program perbandingan sorting melalui cara biasa dan melalui cara pointer.
Program Sorting dan Searching

Program sorting pada subbab ini meliputi insertion sort, bubble sort, dan
quick sort, sedangkansearching meliputi sequential search, dan binary search.
Flowchart dari program sorting dan searching dapat dilihat pada Gambar 3.43.
129
130
Gambar 3.50 Flowchart program utama sorting dan searching
Gambar 3.50 adalah flowchart dari program utama menentukan sorting

dan searching.
Flowchart dari prosedur prosedur yang terdapat dalam flowchart utama
dapat dilihat pada gambar 3.51 berikut.
131
Gambar 3.51 Flowchart prosedur fillArray()
Gambar 3.51 merupakan flowchart dari prosedur inArray() dari

pemgroraman dengan menggunakan bahasa C++.
Prosedur dari inArray() dari pemgrograman dengan menggunakan bahasa
C++ dapat dilihat pada Gambar 3.52.
Gambar 3.52 Flowchart prosedur inArray()
Gambar 3.52 merupakan flowchart dari prosedur inArray()dengan

menggunakan bahasa C++.
132
Prosedur outArray dengan menggunakan bahasa C++ dapat dilihat pada
gambar 3.53 berikut.
Gambar 3.53 Flowchart prosedur outArray()
Gambar 3.53 merupakan flowchart dari prosedur outArray()dengan

Prosedur insertionSort()dengan menggunakan bahasa C++ dapat dilihat
pada Gambar 3.54.
133
Gambar 3.54 Flowchart prosedur insertionSort()
Gambar 3.54 merupakan flowchart dari prosedur insertionSort()dengan

Prosedur bubbleSort()dengan menggunakan bahasa C++ dapat dilihat pada
gambar 3.55 berikut.
134
Gambar 3.55 Flowchart prosedur bubbleSort()
Gambar 3.55 merupakan flowchart dari prosedur bubbleSort()dengan

Prosedur quickSort()dengan menggunakan bahasa C++ dapat dilihat pada
gambar 3. 56 berikut.
135
Gambar 3.56 Flowchart prosedur quickSort()
Gambar 3.56 merupakan flowchart dari prosedur quickSort()dengan

Prosedur sequentialSearch()dengan menggunakan bahasa C++ dapat
dilihat pada gambar 3.57 berikut.
136
Gambar 3.57 Flowchart prosedur sequentialSearch()
Gambar 3.57 merupakan flowchart dari prosedur sequentialSearch()

dengan menggunakan bahasa C++.
137
Prosedur binarySearch()dengan menggunakan bahasa C++ dapat dilihat
pada gambar 3.58 berikut.
Gambar 3.58 Flowchart prosedur binarySearch()
Gambar 3.58 merupakan flowchat dari prosedur binarySearch() dengan

Bentuk pseudocode dari program menentukan deret bilangan fibonacci,
Program Utama
MULAI
READ menu
IF menu = 1 THEN
READ n
WRITE sebelum diurutkan
fillArray(array,n)
outArray(array,n)
WRITE insertion sort
inArray(array,array2,n)
t1 clock()
insertionSort(array2,n)
t2 clock()
waktu1 (double)(t2-t1) /CLK_TCK
outArray(array2,n)
WRITE bubble sort
138
t1 clock()
bubbleSort(array2,n)
t2 clock()
outArray(array2,n)
WRITE quick sort
t1 clock()
quickSort(array2,0,n-1)
t2 clock()
outArray(array2,n)
WRITE waktu1, waktu2, waktu3
ELSE IF menu = 2 THEN
READ n
fillArray(array,n)
outArray(array,n)
READ tombol
IF tombol = Y || y THEN
outArray(array,n)
ENDIF
READ cari
WRITE sequential search
t1 clock()
sequentialSearch(array,n)
t2 clock()
t2 clock()
WRITE binary search
t1 clock()
binarySearch(array,n)
t2 clock()
WRITE waktu1, waktu2
ELSE IF menu = 3
GOTO 59
ENDIF
Read tombol
GOTO 2
ENDIF
SELESAI
Prosedur fillArray()
MULAI
READ array[], n
srand(time(NULL))
FOR x 0 - <n; x++ DO
array[x] rand()%n
ENDFOR
SELESAI
Prosedur inArray()
MULAI
READ array[], array2[], n
array2[x] array[x]
139
ENDFOR
SELESAI
Prosedur outArray()
MULAI
READ array[], n
srand(time(NULL))
WRITE array[x]
ENDFOR
SELESAI
Prosedur insertionSort()
MULAI
READ array[], n
key array[x]
y x-1
WHILE y>=0 && array[y]>key DO
array[y+1] array[y]
y y-1
ENDWHILE
array[y+1] key
ENDFOR
SELESAI
Prosedur bubbleSort()
1. MULAI
2. READ array[], n
3. FOR x 0 - <n; x++ DO
4. FOR x 0 <(n-1) DO
IF array[y]>array[y+1] THEN
temp = array[y]
array[y] = array[y+1]
array[y+1] = temp
ENDIF
ENDFOR
ENDFOR
SELESAI
Prosedur quickSort()
MULAI
READ array[], L, R
x L
y R
mid array[(L+R)/2]
DO
WHILE array[x]<mid DO
x++
ENDWHILE
WHILE array[y]>mid DO
y--
ENDWHILE
IF x<=y THEN
temp array[y]
array[y] array[x]
array[x] temp
x++
y--
140
ENDIF
WHILE x<y
IF L<y THEN
quickSort(array,L,y)
ENDIF
IF x<R THEN
quickSort(array,x,R)
ENDIF
SELESAI
Prosedur sequentialSearch()
MULAI
READ array[], n, cari
dapat 0
IF array[x]==cari THEN
dapat++
lokasi[x] x+1
ELSE
lokasi[x] 0
ENDIF
ENDFOR
IF dapat > 0 THEN
WRITE Data Ditemukan, terletak pada deret ke:
IF lokasi[x] > 0 THEN
WRITE lokasi[x]
ENDIF
ENDFOR
ELSE
WRITE Data tidak ditemukan
ENDIF
SELESAI
Prosedur binarySearch()
MULAI
READ array[], n, cari
awal 0
akhir n
tengah=(awal+akhir)/2
WHILE awal <= akhir && array[tengah] != cari DO
IF array[tengah] < cari THEN
awal tengah+1
ELSE
akhir tengah-1
ENDIF
tengah (awal+akhir)/2
ENDWHILE
IF array[tengah] == cari THEN
WRITE Data ditemukan
ELSE
WRITE Data tidak ditemukan
ENDIF
SELESAI
Kode Program 3.59 Pseudocode program sorting and searching
141
Kode Program 3.59 menjelaskan tentang program sorting dan searching
+, maka sintaks dari progra tersebut dapat dilihat pada Kode Program 3.60.
#include <limits>
#include<iostream>
#include<conio.h>
#include<time.h>
#include<math.h>
#include<stdlib.h>
time_t t1,t2;
int data_a[100000], data_b[1000000];
void acak_data(int data[], int x){

srand(time(NULL));
for (int a=0;a<x;a++){
14. data[a]=rand()%x;
}
}
void masuk_data(int data_a[], int data_b[], int x){
for (int a=0;a<x;a++){
19. data_b[a]=data_a[a];
}
}
void keluar_data(int data_b[], int x){
for (int b=0;b<x;b++){
24. cout<<data_b[b]<<", ";
}
}
27.
void bubble_sort (int data[], int x){
int tmp;
for(int i=0; i<x; i++)
{
for(int j=i+1; j<x;j++)
{
34. if(data[i]>data[j])
{
36. tmp = data[i];
37. data[i] = data[j];
38. data[j] = tmp;
}
}
}
42.
}
void insertion_sort(int data[], int x){
int temp;
for(int i=0;i<x;i++)
{
temp = data[i];
int j = i -1;
while(data[j]>temp && j>=0)
{
142
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
}
}
void quick_sort(int data_b[], int kiri, int kanan) {
int temp,x,y;
int tengah;
x = kiri;
y = kanan;
tengah = data_b[(kiri+kanan) / 2];
do{
while (data_b[x] < tengah)
68. x++;
69. while (data_b[y] > tengah)
70. y--;
71. if (x <=y){
72. temp = data_b[y];
73. data_b[y] = data_b[x];
74. data_b[x] = temp;
75. x++;
76. y--;
77. }
}
while (x < y);
if (kiri < y)
81. quick_sort(data_b,kiri,y);
if (x < kanan)
83. quick_sort(data_b,x,kanan);
84.
}
int binary_search(int nama_array[],int jumlah_indeks,int
kunci_pencarian)
{
int kiri, kanan, tengah;
kiri = 0;
kanan = jumlah_indeks - 1;
tengah = (kiri + kanan)/2;
while (kiri<=kanan && tengah<=jumlah_indeks){
93. tengah = (kiri + kanan)/2;
94. if(kunci_pencarian<nama_array[tengah])
95. kanan = tengah - 1;
96. else if
(kunci_pencarian>nama_array[tengah])
97. kiri = tengah + 1;
98. else
99. return tengah;
}
return 0;
}
void sequential_search(int data[], int banyak, int cari){
int ketemu=0;
105.
for(int i=0;i< banyak;i++)
{
if (data[i]==cari)
143
{
110. ketemu=1;
111. cout<<"Data ditemukan pada indeks ke-
"<<i+1<<endl;
112. }
113. }
114.
if (ketemu==0){
cout<<"Data tidak ditemukan";
}
118.
119. }
120.
int main()
{
ulang :
system ("cls");
int data_a[100000], data_b[100000];
int i, j, tmp,banyak,pilihan,cari;
int n=0;
int m=0;
char tombol;
double waktu1, waktu2, waktu3, waktu4, waktu5;
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
134. cout<<"| ~~Sorting & Searching~~ |"<<endl;
cout<<" __________________________________"<<endl;
cout<<"\n";
cout<<"1. Sorting manual. "<<endl;
cout<<"2. Sorting random. "<<endl;
cout<<"3. Searching manual. "<<endl;
cout<<"4. Searching random. "<<endl;
cout<<"5. QUIT "<<endl;
up :
while ( cout<<"Masukkan pilihan : "&&!(cin >> pilihan))
{
cout << "Input harus berupa angka!! " << endl;
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');
}
if(pilihan<1 || pilihan>5){
cout<<"Pilihan anda salah "<<endl;
goto up;
}
switch(pilihan){
case 1 : {
while ( cout<<"Masukkan banyak angka: "&&!(cin >>
banyak))
{
cin.clear();
}
for(int x=0;x<banyak;x++){
162.
while ( cout<<"Masukkan angka ke "<<x+1<<" : "&&!(cin
data_a[x]))
{
144
cin.clear();
}
}
cout<<"Data sebelum diurutkan : "<<endl;
keluar_data(data_a,banyak);
cout<<endl;
173.
masuk_data(data_a,data_b,banyak);
t1=clock();
insertion_sort(data_b,banyak);
t2=clock();
waktu1=(double)(t2-t1)/CLK_TCK;
cout<<"\nHasil pada metode insertion sort : "<<endl;
keluar_data(data_b,banyak);
181.
t1=clock();
bubble_sort(data_b,banyak);
t2=clock();
cout<<"\nHasil pada metode bubble sort : "<<endl;
189.
t1=clock();
quick_sort(data_b,0,banyak-1);
t2=clock();
cout<<"\nHasil pada metode quick sort : "<<endl;
197.
cout<<endl;
cout<<"Waktu pada metode bubble sort : "<<waktu1<<endl;
cout<<"Waktu pada metode insertion sort : "<<waktu2<<endl;
cout<<"Waktu pada metode quick sort : "<<waktu3<<endl;
break;
}
case 2 :{
banyak))
{
cin.clear();
}
211.
acak_data(data_a,banyak);
cout<<endl;
216.
t1=clock();
insertion_sort(data_b,banyak);
t2=clock();
145
cout<<"\nHasil pada metode insertion sort : "<<endl;
224.
t1=clock();
bubble_sort(data_b,banyak);
t2=clock();
cout<<"\nHasil pada metode bubble sort : "<<endl;
232.
t1=clock();
t2=clock();
cout<<"\nHasil pada metode quick sort : "<<endl;
240.
cout<<endl;
cout<<"Waktu pada metode bubble sort : "<<waktu1<<endl;
cout<<"Waktu pada metode insertion sort : "<<waktu2<<endl;
cout<<"Waktu pada metode quick sort : "<<waktu3<<endl;
break;
}
case 3 : {
banyak))
{
cin.clear();
}
for(int x=0;x<banyak;x++){
255.
while ( cout<<"Masukkan angka ke "<<x+1<<" : "&&!(cin
data_a[x]))
{
cin.clear();
}
}
cout<<endl;
cout<<"Data setelah diurut : "<<endl;
cout<<"\nMasukkan bilangan yang akan dicari : "; cin>>cari;
t1=clock();
sequential_search(data_b,banyak,cari);
t2=clock();
cout<<endl;
t1=clock();
146
int hasil=binary_search(data_b,banyak,cari);
t2=clock();
if(hasil==0)
281. cout<<"Hasil tidak ditemukan"<<endl;
282. else
283. cout<<"Hasil ditemukan. Nilai "<<cari<<"
terdapat pada indeks ke- "<<hasil+1<<endl;
cout<<"Waktu pada sequential search : "<<waktu4<<endl;
cout<<"Waktu pada binary search : "<<waktu5<<endl;
break;
}
case 4 :{
289. while ( cout<<"Masukkan banyak angka: "&&!(cin
banyak))
{
cin.clear();
}
295.
acak_data(data_a,banyak);
cout<<endl;
cout<<"Data setelah diurut : "<<endl;
cout<<"Masukkan bilangan yang akan dicari : "; cin>>cari;
t1=clock();
sequential_search(data_b,banyak,cari);
t2=clock();
cout<<endl;
t1=clock();
int hasil=binary_search(data_b,banyak,cari);
t2=clock();
if(hasil==0)
315. cout<<"Hasil tidak ditemukan"<<endl;
316. else
317. cout<<"Hasil ditemukan. Nilai "<<cari<<"
terdapat pada indeks ke- "<<hasil+1<<endl;
cout<<"Waktu pada sequential search : "<<waktu4<<endl;
cout<<"Waktu pada binary search : "<<waktu5<<endl;
break;
}
getch();
}
cin>>tombol;
327. goto ulang;
else
}
Kode Program 3.60 Program sorting dan searching
147
Kode program 3.60 merupakan sintaks dari program sorting dan searching
dalam Dev C++.
Trace dari program sorting dan searching dengan menggunakan bahasa C++
Input : menu = 1, n = 3
Proses: out: Bilangan sebelum diurutkan
fillArray(array,3){
for (x = 0 - <n; x++)
x = 0
array[0] = 1
x = 1
array[1] = 0
x = 2
array[2] = 1
}
outArray[array,n]
{ for (x = 0 - <n; x+
+) x = 0
out: array[0] = 1
x = 1
out: array[1] = 0
x = 2
out: array[2] = 1
}
Out: Insertion Sort
inArray(array,array2,3)
{ for (x = 0 - <n; x++)
x = 0
array2[0] = array[0] = 1
x = 1
x = 2
)
insertionSort(array2,3){
for (x = 0 - 2)
x = 0
key=array[0]=1
y=0-1=-1
while(-1>=0 && array[-1]>1)(salah)
array[0]=1
x = 1
key=array[1]=0
y=1-1=0
while(0>=0 && 1>0)(benar)
array[1]=array[0]=1
y=0-1=-1
array[0]=0
x = 2
key=array[2]=1
y=2-1=1
while(1>=0 && 1>0)(benar)
array[2]=array[1]=1
y=1-1=0
array[2]=1
148
}
outArray(array2,3)
Out: Bubble Sort
bubbleSort(array2,3){
for (x = 0 - 2)
x = 0
for (y = 0 - 1)
y=0
if (array[0] > array[1])(benar)
temp = array[0] = 1
array[0] = array[1] = 0
array[1] = temp = 1
y=1
if (array[1] > array[2])(salah)
x = 1
for (y = 0 - 1)
y=0
y=1
x = 2
for (y = 0 - 1)
y=0
y=1
}
outArray(array2,3)
Out: Insertion Sort
quickSort(array2,0,2)
{ x=0
y=2
mid=array[1]=0
do
while (array[0] < mid) (salah)
while (array[2] > mid) (benar)
y=2-1=1
if (0<=1) (benar)
temp = array[1] = 0
array[0] = 0
x=0+1=1
y=1-1=0
while (1 < 0) (salah)
if (0 < 0) (salah)
if (1<2) (benar)
quickSort(array,1,2)
x=1
y=2
mid=array[1]=1
do
while (array[1] < mid) (salah)
while (array[2] > mid) (salah)
if (1<=2) (benar)
temp = array[2] = 1
array[1] = 1
x=1+1=2
y=2-1=1
149
while (2 < 1) (salah)
if (1 < 1) (salah)
if (2<2) (salah)
outArray(array2,3)
Output: Bilangan Sebelum Diurutan : 0, 1, 1
Metode Indertion Sort: 0, 1, 1
Metode Bubble Sort: 0, 1, 1
Metode Indertion Sort: 0, 1, 1
Kode Program 3.61 Trace Program sorting
Kode Program 3.61 menjelaskan tentang trace dari program yang telah
dibuat untuk men-sorting bilangan secara acak(random).
Trace untuk men-searching suatu bilangan dengan pemrograman
menggunakan bahasa C++ dapat dilihat pada Kode Program 3.62.
Input : menu = 2, n = 3, cari = 2
Proses: fillArray(array,3){
for (x = 0 - <n; x++)
x = 0
array[0] = 2
x = 1
array[1] = 2
x = 2
array[2] = 0
}
sequentialSearch(array,3,2){
dapat = 0
for(x = 0 - 2; x++)
x = 0
if(array[0]==2)(benar)
dapat = 0+1 = 1
lokasi[0] = 1
x = 1 if(array[1]==2)
(benar)
dapat = 1+1 = 2
lokasi[1] = 2
x = 2 if(array[2]==2)
(salah)
if(dapat > 0) (benar)
out: Data ditemukan. Pada deret ke:
for(x = 0 - 2; x++)
x = 0
if(lokasi[0]>0) (benar)
out: lokasi[0] = 1
x = 1
if(lokasi[1]>0) (benar)
out: lokasi[1] = 2
x = 2
if(lokasi[2]>0) (salah)
}
insertionSort(array,n){
array[0] = 0
array[1] = 2
array[2] = 2
}
binarySearch(array,3,2){
150
awal = 0
akhir = 3
tengah=(0+3)/2 = 1
while(0<=3 && array[1] != cari) (salah)
if(array[1]== 2) (benar)
out: Data ditemukan
}
Output: Metode Sequential: Data ditemukan pada deret ke 1, 2
Metode Binary : Data ditemukan
Kode Program 3.62 Trace Program searching
Kode Program 3.62 menjelaskan tentang trace dari program yang telah
dibuat untuk men-searching bilangan yang ingin dicari.
Perbandingan waktu dari setiap pemrosesan yang dilakukan oleh masing -
masing metode dapat dilihat pada Tabel. 3.1.
Tabel 3.1 Perbandingan waktu pemrosesan dari masing-masing metode sorting
Banyak Data Waktu yang diperlukan (detik)
Insertion Sort Bubble Sort Quick Sort
1000 0 0,15 0
2000 0,015 0,063 0
4000 0,047 0,234 0
8000 0,187 0,951 0
16000 0,733 3,619 0,016
32000 2,537 12,699 0,016
64000 9,578 54,273 0,031
Tabel 3.1 memperlihatkan bahwa metode yang paling banyak

membutuhkan waktu pemrosesan adalah metode Bubble Sort, kemudian diikuti
oleh metode Insertion Sort, dan yang paling sedikit membutuhkan waktu
pemrosesan adalah metode Quick Sort. Pada kisaran 1000 data perbandingan
waktu dari Insertion Sort, Bubble Sort, dan Quick Sort secara berturut turut adalah
0, 0,15, dan 0 detik, hingga pada kisaran 64000 data perbandingan waktu dari
Insertion Sort, Bubble Sort, dan Quick Sort secara berturut turut adalah 9,578,
5,273, dan 0,031 detik.
Perbandingan waktu dari setiap pemrosesan yang dilakukan oleh masing-
masing metode searching dapat dilihat pada Tabel. 3.2.
Tabel 3.2 Perbandingan waktu pemrosesan dari masing-masing metode searching
Sequential Search Binary Search
1000 0 0
2000 0 0
4000 0 0
151
8000 0 0
16000 0 0
32000 0 0
64000 0 0
Tabel 3.2 memperlihatkan bahwa masih sulit menentukan metode mana

yang paling banyak ataupun paling sedikit membutuhkan waktu pemrosesan
dalam mencari suatu data. Pada kisaran 1000 sampai 64000 waktu yang
dibutuhkan kedua metode tersebut untuk mencari sebuah data adalah sama yaitu 0
detik. Hal ini dikarenakan parameter perbandingan yang digunakan masih bernilai
kecil yaitu hanya kisaran 1000 sampai 64000.
Program sorting dan searching jika di-compile melalui Dev C++ maka
Gambar 3.59 Hasil compile program sorting dan searching pada Dev C++
Gambar 3.59 merupakan hasil dari sintaks program sorting dan searching
dari sorting manual yang telah di-compile, terdiri dari hasil tiap-tiap menu yang
tersedia.
Hasil compile dari program sorting dan searching dengan menggunakan
sorting random dapat dilihat pada Gambar 3.60.
152
dari sorting random yang telah di-compile, terdiri dari hasil tiap-tiap menu yang
tersedia.
searching manual dapat dilihat pada Gambar 3.61.
dari sorting manual yang telah di-compile, terdiri dari hasil tiap-tiap menu yang
tersedia.
searching random dapat dilihat pada Gambar 3.62.
153
yang telah di-compile, terdiri dari hasil tiap-tiap menu yang tersedia.
Program Operasi Matriks

Program kedua adalah program operasi matriks dengan pemrograman
Flowchart dari program matriks dengan pemrograman menggunakan
bahasa C++ dapat dilihat pada Gambar 3.63.
154
Gambar 3.63 Flowchart program utama operasi matriks
Gambar 3.63 terlihat bahwa operasi matriks yang dimaksud adalah

penjumlahan, transpose, dan perkalian matriks.
Flowchart dari setiap prosedur yang dipakai program ini akan dijabarkan
pada Gambar 3.64.
155
Gambar 3.64 Flowchart prosedur input_matriks()
Gambar 3.64 merupakan flowchart dari prosedur input_matriks()dengan

pemrograman menggunakan bahasa C++. Prosedur ini digunakan untuk
memasukkan nilai baru pada variabel matriks menggunakan masukkan dari
keyboard secara langsung.
Flowchart dari setiap prosedur output_matriks() yang dipakai program ini
akan dijabarkan pada Gambar 3.65.
Gambar 3.65 Flowchart prosedur output_matriks()
156
Gambar 3.65 merupakan flowchart dari prosedur output_matriks()dengan
menampilkan nilai yang ada di setiap indeks array matriks.
Flowchart dari prosedur penjumlahan() yang dipakai program ini akan
dijabarkan pada Gambar 3.66.
Gambar 3.66 Flowchart prosedur penjumlahan()
Gambar 3.66 merupakan flowchart dari prosedur penjumlahan()dengan

menjalankan proses penjumlahan dua matrik dengan pemrograman menggunakan
bahasa C++.
Flowchart dari prosedur transpose() yang dipakai program ini akan
157
Gambar 3.67 Flowchart prosedur transpose()
Gambar 3.67 merupakan flowchart dari prosedur transpose()dengan

melakukan proses perhitungan transpose dari sebuah matrik.
Flowchart dari prosedur perkalian() yang dipakai program ini akan
158
Gambar 3.68 Flowchart prosedur perkalian()
Gambar 3.68 merupakan flowchart dari prosedur perkalian()dengan

pemrograman menggunakan bahasa C++. Prosedur ini digunakan untuk untuk
melakukan proses perhitungan perkalian dari dua matrik.
Berdasarkan dari beberapa flowchart diatas, maka dapat dibentuk
pseudocode pada Kode Program 3.63.
Program Utama
MULAI
READ pilihan
SWITCH pilihan
CASE 1
penjumlahan()
159
CASE 2
transpose()
CASE 3
perkalian()
CASE 4
GOTO 13
ENDSWITCH
SELESAI
Kode Program 3.63 Pseudocode program operasi matriks
Kode Program 3.63 merupakan pseudocode program operasi matriks

dengan pemrograman menggunakan bahasa C++.
Pseudocode program operasi matriks yang menyangkut input serta output
dari program dapat dilihat pada Kode Program 3.64.
Prosedur input dan output matriks()

MULAI
READ brs, klm, matriks[][20]
1 brs; i++ DO
3.FORi
1 klm; j++ DO 4.FORj
READ matriks[i][j]
6. WRITE matriks[i][j]
ENDFOR
ENDFOR
SELESAI
Kode Program 3.64 Pseudocode program input-output operasi matriks
Kode Program 3.64 menjelaskan pseudocode program operasi matriks

dalam cakupan input-output.
Pseudocode program operasi matriks dengan pilihan menu penjumlahan
Prosedur penjumlahan()
MULAI
READ baris
READ kolom
input_matriks(baris,kolom,matriks_1)
input_matriks(baris,kolom,matriks_2)
output_matriks(baris,kolom,matriks_1)
output_matriks(baris,kolom,matriks_2)
FOR i 1 baris; i++ DO
FOR j 1 kolom; j++ DO
matriks_hsl[i][j]= matriks_1[i][j]+matriks_2[i][j]
ENDFOR
ENDFOR
output_matriks(baris,kolom,matriks_hsl)
SELESAI
Kode Program 3.65 Pseudocode program operasi penjumlahan matriks
160
dengan pilihan menu penjumlahan.
Pseudocode program operasi matriks dengan pilihan menu transpose
Prosedur transpose()
MULAI
READ baris3
READ kolom3
input_matriks(baris3,kolom3,matriks_1)
output_matriks(baris3,kolom3,matriks_1)
1 kolom3; b++ DO
6.FORb
1 baris3; c++ DO 7.FORc
matriks_hsl[b][c]=matriks_1[c][b]
ENDFOR
ENDFOR
output_matriks(kolom3,baris3,matriks_hsl)
SELESAI
Kode Program 3.66 Pseudocode program operasi transpose matriks

dengan pilihan menu transpose.
Pseudocode program operasi matriks dengan pilihan menu perkalian
Prosedur perkalian()
MULAI
READ baris1
READ klm1brs2
READ kolom2
input_matriks(baris1,klm1brs2,matriks_1)
input_matriks(klm1brs2,kolom2,matriks_2)
output_matriks(baris1,klm1brs2,matriks_1)
output_matriks(klm1brs2,kolom2,matriks_2)
FOR i 1 baris1; i++ DO
FOR j 1 kolom2; j++ DO
matriks_hsl[i][j] = 0
FOR p 1 klm1brs2; p++ DO
matriks_hsl[i][j]+=matriks_1[i][p]*matriks_2[p][j]
ENDFOR
ENDFOR
ENDFOR
output_matriks(baris1,kolom2,matriks_hsl)
SELESAI
Kode Program 3.67 Pseudocode program operasi perkalian matriks

dengan pilihan menu perkalian.
161
Flowchart dan pseudocode sudah dibuat, sehingga dapat dibuat program
dalam C++ pada Kode Program 3.68.
#include <iostream>
#include <conio.h>
class Scanner {
public:
private:
};
string tmp;
cin >> tmp;
cout << errorMessage;
cin >> tmp;
}
}
int cnt = 0;
cnt++;
}
}
return cnt;
}
return false;
}
return false;
}
return false;
}
if (numericString[i] < '0' || numericString[i] > '9'){
43. return false;
}
}
}
return true;
}
int matriks_1[20][20],matriks_2[20][20],matriks_hsl[20][20];
Scanner* input = new Scanner();
void input_matriks(int brs,int klm,int matriks[][20]){
for(int i=1;i<=brs;i++){
for(int j =1;j<=klm;j++){
cout << "\tMasukan Matriks [" << i << "," << j << "]
: ";
162
matriks[i][j]=input->nextInt("\tInput
salah\n\tMasukan lagi : ");
}
}
}
59.
void output_matriks(int brs,int klm,int matriks[][20]){
for(int i=1;i<=brs;i++){
for(int j=1;j<=klm;j++){
cout <<"\t"<< matriks[i][j];
}
cout << endl << endl;
}
}
68.
void penjumlahan(){
int j,i,baris,kolom;
cout<<"\n------------- PENJUMLAHAN MATRIKS ------------
"<<endl<<endl;
cout << "Masukan jumlah Baris Matriks A dan B : ";
baris=input->nextInt("Input salah\nMasukan jumlah Baris
Matriks A dan B : ");
cout << "Masukan jumlah Kolom Matriks A dan B : ";
kolom=input->nextInt("Input salah\nMasukan jumlah Kolom
Matriks A dan B : ");
cout << "\nMasukan Matriks A: \n";
input_matriks(baris,kolom,matriks_1);
cout << "\nMasukan Matriks B: \n";
input_matriks(baris,kolom,matriks_2);
cout<<"\nMatrik A:"<<endl;
output_matriks(baris,kolom,matriks_1);
cout<<"Matrik B:"<<endl;
output_matriks(baris,kolom,matriks_2);
for(i=1;i<=baris;i++){
for(j=1;j<=kolom;j++){
matriks_hsl[i][j] = matriks_1[i][j]+matriks_2[i][j];
}
}
cout << "Hasil Matriks-nya : " << endl << endl;
output_matriks(baris,kolom,matriks_hsl);
}
92.
void transpose(){
int b,c,baris3,kolom3;
cout<<"\n-------------- TRANSPOSE MATRIKS -------------
"<<endl<<endl;
cout<<"Masukkan Jumlah Baris Matriks : ";
baris3=input->nextInt("Input salah\nMasukkan Jumlah Baris
Matriks : ");
cout<<"Masukkan Jumlah Kolom Matriks : ";
kolom3=input->nextInt("Input salah\nMasukkan Jumlah Kolom
Matriks : ");
cout<<endl;
input_matriks(baris3,kolom3,matriks_1);
cout<<endl<<endl;
cout<<"\nMatriks Sebelum Transpose :"<<endl<<endl;
output_matriks(baris3,kolom3,matriks_1) ;
105.
106. cout<<"\nMatriks Sesudah Transpose :"<<endl<<endl;
163
for (b=1;b<=kolom3;b++){
for (c=1;c<=baris3;c++){
matriks_hsl[b][c]=matriks_1[c][b];
}
cout<<endl<<endl;
}
output_matriks(kolom3,baris3,matriks_hsl);
}
115.
void perkalian(){
int baris1,klm1brs2,kolom2,i,j,p;
cout<<"\n-------------- PERKALIAN MATRIKS -------------
"<<endl<<endl;
cout << "Masukan Jumlah Baris Matriks A : ";
baris1=input->nextInt("Input salah\nMasukan Jumlah Baris
Matriks A : ");
cout << "Masukan Jumlah Kolom Matriks A dan Baris Matriks
B : ";
klm1brs2=input->nextInt("Input salah\nMasukan Jumlah Kolom
Matriks A dan Baris Matriks B : ");
cout << "Masukan Jumlah Kolom Matriks B : ";
kolom2=input->nextInt("Input salah\nMasukan Jumlah Kolom
Matriks B : ");
cout << "\nMasukan Matriks A : \n\n";
input_matriks(baris1,klm1brs2,matriks_1);
cout << endl;
cout << "\nMasukan Matriks B : \n\n";
input_matriks(klm1brs2,kolom2,matriks_2);
cout << "\nMatriks A : \n\n";
output_matriks(baris1,klm1brs2,matriks_1);
cout << "\nMatriks B : \n\n";
output_matriks(klm1brs2,kolom2,matriks_2);
for(i=1;i<=baris1;i++)
{
for(j=1;j<=kolom2;j++)
{
matriks_hsl[i][j] = 0;
for(p=1;p<=klm1brs2;p++)
{
141.
matriks_hsl[i][j]+=matriks_1[i][p]*matriks_2[p][j];
}
}
}
cout << "\nHasil Matriks-nya : \n\n";
output_matriks(baris1,kolom2,matriks_hsl);
}
148.
int main(){
int pilihan;
char tombol;
ulang:
system("cls");
cout<<"
_____________________________________________"<<endl;
|"<<endl;
156. cout<<"|_____________________________________________|"<<e
ndl;
164
157. cout<<"| ~~MATRIKS~~
|"<<endl;
cout<<"
_____________________________________________"<<endl;
cout<<"\nMENU:"<<endl;
cout<<"1. Penjumlahan Matriks\t[tekan 1]"<<endl;
cout<<"2. Transpose Matrik\t[tekan 2]"<<endl;
cout<<"3. Perkalian Matrik\t[tekan 3]"<<endl;
cout<<"4. Exit\t\t\t[tekan 4]"<<endl<<endl;
pilihan=input->nextInt("Input salah\nInput Pilihan: ");
switch(pilihan){
case 1:
penjumlahan();
cin>>tombol;
172. goto ulang;
else
getch();
break;
case 2:
transpose();
cin>>tombol;
182. goto ulang;
else
getch();
break;
case 3:
perkalian();
cin>>tombol;
192. goto ulang;
else
getch();
break;
case 4:
getch();
exit(0);
break;
default:
cout << "\nMasukan Pilihan Yang Benar";
getch();
goto ulang;
}
getch();
return 0;
}
Kode Program 3.68 Program operasi matriks
165
Kode Program 3.68 merupakan program untuk operasi matriks. Operasi
tersebut terdiri dari penjumlahan, transpose, perkalian matriks.
Hasil compile dari program ini dengan pemrograman menggunakan bahasa
C++ dapat dilihat pada Kode Program 3.69 berikut.
Input : menu = 1, baris = 1, kolom = 2
matriks_1[1][1] = 10, matriks_1[1][2] = 20
matriks_2[1][1] = 5, matriks_2[1][2] = 10
Proses: for(i = 1 - 1; i++)
x = 1
for(j = 1 2; j++)
j = 1
matriks_hsl[1][1] = matriks_1[1][1] +
matriks_2[1][1] = 15
j = 2
matriks_hsl[1][2] = matriks_1[1][2] +
matriks_2[1][2] = 30
Output: matriks_hsl[1][1] = 15
matriks_hsl[1][2] = 30
Kode Program 3.69 Program operasi penjumlahan matriks
Kode Program 3.69 memperlihatkan trace dari program matriks dengan

pilihan menu 1 dengan pemrograman menggunakan bahasa C++.
Trace dengan menu 2 dengan pemrograman menggunakan bahasa C++
Input : menu = 2, baris3 = 1, kolom3 = 2
matriks_1[1][1] = 10, matriks_1[1][2] = 20
Proses: for(b = 1 - 2; b++)
b = 1
for(c = 1 1; c++)
c = 1
matriks_hsl[1][1] = matriks_1[1][1] = 10
b = 2
for(c = 1 1; c++)
c = 1
matriks_hsl[2][1] = matriks_1[1][2] = 20
Kode Program 3.70 Program operasi transpose matriks

Trace dengan menu 3 dengan pemrograman menggunakan bahasa C++
Input : menu = 3, baris1 = 1, klm1brs2 = 2, kolom2 = 1
matriks_1[1][1] = 10, matriks_1[1][2] = 20
matriks_2[1][1] = 30, matriks_2[2][1] = 40
Proses: for(i = 1 - 1; i++)
166
i = 1
for(j = 1 1; j++)
j = 1
for(p = 1 - 2; p++)
p = 1
matriks_hsl[1][1] = matriks_hsl[1][1] +
matriks_1[1][1] * matriks_2[1][1] = 0 + 10
* 30 = 300
p = 2
matriks_hsl[1][1] = matriks_hsl[1][1] +
matriks_1[1][2] * matriks_2[2][1] = 300 +
20 * 40 = 1100
Kode Program 3.71 Program operasi perkalian matriks

Hasil dari program di atas jika di-compile melalui Dev C++ dapat dilihat
pada Gambar 3.70.
Gambar 3.69 Hasil compile program penjumlahan matriks pada Dev C++
167
Gambar 3.69 merupakan interface dari program operasi matriks yang telah
di-compile, terdiri dari empat input-an menu yaitu penjumlahan, transpose, dan
perkalian matriks.
Hasil compile program operasi matriks dengan menu 2, dapat dilihat pada
Gambar 3.70.
Gambar 3.70 Hasil compile program transpose matriks pada Dev C++
Gambar 3.70 merupakan interface dari program operasi matriks yang telah
perkalian matriks.
Hasil compile program operasi matriks dengan menu 3, dapat dilihat pada
Gambar 3.71.
168
Gambar 3.71 Hasil compile program perkalian matriks pada Dev C++
Gambar 3.71 merupakan interface dari program operasi matriksyang telah

perkalian matriks.
Program Menghitung Mean, Median, dan Mode

Program ketiga adalah program menghitung mean, median, dan mode dari
beberapa bilangan yang di-input-kan. Gambar 3.72 dibawah adalah gambar yang
merupakan flowchart dari program ini.
169
Gambar 3.72 Flowchart program menghitung mean, median, dan mode
Gambar 3.72 memperlihatkan flowchart dari program tersebut dengan

pemrograman menggunakan bahasa C++.
Flowchart dari masing-masing prosedur dan fungsi yang digunakan dapat
dilihat pada gambar flowchart gambar 3.73.
170
Gambar 3.73 Flowchart prosedur bubbleSort()
Gambar 3.73 merupakan flowchart dari prosedur bubbleSort()

menggunakan pointer. Prosedur ini digunakan untuk mengurutkan setiap bilangan
yang di-input-kan. Proses ini di perlukan untuk menentukan median dari bilangan-
bilangan tersebut.
Gambar flowchart untuk fungsi mean() pada progam ini dapat dilihat pada
gambar 3.74.
171
Gambar 3.74 Flowchart fungsi Mean()
Gambar 3.74 merupakan flowchart dari fungsi Mean()dengan

Flowchart dari fungsi Median() dengan pemrograman menggunakan
bahasa C++ dapat dilihat pada Gambar 3.75.
Gambar 3.75 Flowchart fungsi Median()
172
Gambar 3.75 merupakan flowchart dari fungsi Median() dengan
Flowchart Mode()dengan pemrograman menggunakan bahasa C++ dapat
Gambar 3.76 Flowchart prosedur Mode()
Gambar 3.76 merupakan flowchart dari prosedur Mode()dengan

Berdasarkan dari beberapa flowchart diatas, maka dapat dibentuk
pseudocode pada Kode Program 3.72.
Program Utama
1. MULAI
2. READ n
3. nums new int[n]
4. FOR x 0 n; x++ DO
READ nums[x]
ENDFOR
bubbleSort(nums, n)
WRITE Mean(nums, n)
173
WRITE Median(nums,n)
Mode(nums,n)
delete[] nums
nums 0
Read tombol
GOTO 2
ENDIF
SELESAI
Prosedur bubbleSort()
1. MULAI
2. READ *nums, n
3. FOR i 0 n; i++ DO
4. FOR j i+1 n; j++ DO
IF nums[i] > nums[j] THEN
temp = nums[i]
nums[i] = nums[j]
nums[j] = temp
ENDIF
ENDFOR
ENDFOR
SELESAI
Fungsi Mean()
MULAI
READ *nums, n
total 0
FOR count=0 n; count++ DO
total += nums[count]
ENDFOR
average = total / n
return average
SELESAI
FungsiMedian()
1. MULAI
2. READ *nums, n
3. median 0.0
4. IF n % 2 = 0 THEN
5. median (nums[n / 2 - 1] + nums[(n / 2)]) / 2.0
ENDFOR
median nums[n / 2]
return median
SELESAI
Prosedur Mode()
1. MULAI
2. READ *nums, n
3. mode 0
4. val 0
5. FOR index 0 <n-1; x++ DO
IF nums[index] = nums[index + 1] THEN
mode++
val *(nums + index)
ENDIF
ENFOR
IF val > 0 THEN
174
WRITE val
ELSE
WRITE tidak ada
SELESAI
Kode Program 3.72 Pseudocode program menghitug mean, median, dan mode
Kode Program 3.72 merupakan pseudocode program menghitung mean,

median, dan mode.
Flowchart maupun pseudocode di atas akan dituangkan dalam program C+
+, sehingga sintaks dari program tersebut adalah dapat dilihat pada Kode Program
3.73.
#include <iostream>
#include <iomanip>
#include <conio.h>
class Scanner {
public:
private:
};
string tmp;
cin >> tmp;
cout << errorMessage;
cin >> tmp;
}
}
int cnt = 0;
cnt++;
}
}
return cnt;
}
return false;
}
return false;
}
return false;
}
if (numericString[i] < '0' || numericString[i] > '9'){
175
44. return false;
}
}
}
return true;
}
50.
double Mean(int *, int);
double Median(int *, int);
void Mode(int *, int);
void bubbleSort(int *, int);
int main(){
ulang:
system("cls");
Scanner* input = new Scanner();
int *nums;
int n;
char tombol;
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
66. cout<<"| ~~Mean, Median, Modus~~ |"<<endl;
cout<<" __________________________________"<<endl;
cout<<"\n";
cout << "Masukan Banyak Bilangan: ";
n=input->nextInt("Input salah\nMasukan Banyak Bilangan:
");
nums = new int[n];
for (int x= 0; x< n; x++){
cout << "Nilai ke-"<<(x+1)<<": ";
nums[x]=input->nextInt("Input salah\nMasukan lagi:
");
}
bubbleSort(nums, n);
cout << fixed << showpoint << setprecision(1);
cout << "\nMEAN: ";
cout << Mean(nums, n) << endl;
cout << "\nMEDIAN: ";
cout << Median(nums, n) << endl;
cout << "\nMODUS: ";
Mode(nums, n);
delete[] nums;
nums = 0;
cin>>tombol;
goto ulang;
else
getch();
return 0;
}
95.
void bubbleSort(int *nums, int n){
int temp;
for (int i = 0; i < n; i++){
for (int j = i + 1; j < n; j++){
100. if (nums[i] > nums[j]){
176
101. temp = nums[i];
102. nums[i] = nums[j];
103. nums[j] = temp;
104. }
}
}
}
108.
double Mean(int *nums, int n){
double total = 0;
double average;
for (int count = 0; count < n; count++){
total += nums[count];
}
average = total / n;
return average;
}
118.
double Median(int *nums, int n){
double median = 0.0;
cout << fixed << showpoint << setprecision(1);
if (n % 2 == 0){
median = (nums[n / 2 - 1] + nums[(n / 2)]) / 2.0;
}
else
median = nums[n / 2];
return median;
}
129.
void Mode(int *nums, int n){
int mode = 0;
int val = 0;
int index;
for (index = 0; index < n - 1; index++){
if (nums[index] == nums[index + 1]){
136. mode++;
137. val = *(nums + index);
}}
if (val > 0)
cout<<val<<endl<<endl;
else
cout<<"Tidak ada"<<endl<<endl;
}
Kode Program 3.73 Program menghitung mean, median, dan mode
Kode Program 3.73 adalah program penghitungan yang telah dibuat dalam
aplikasi Dev C++.
Hasil trace dari program menghitung mean, median, dan modedapat
Input : n = 3, nums[0] = 11, nums[1] = 22, nums[2] = 11
Proses: bubbleSort(nums, 3)
nums[0] = 11, nums[1] = 11, nums[2] = 22
Mean(nums,3)
total = 0
for (count = 0 - 2; count++)
177
count = 0
total = total + nums[0]
= 0 + 11 = 11
count = 1
11 + 11 = 22
count = 2
22 + 22 = 44
average = total / n
44 / 3 = 14.7
return average = 14.7
Median(nums,3)
median = 0.0
if (3 % 2 == 0) (salah)
median = nums[3 / 2]
= nums[1] =
11.0 return median = 11.0
Mode(nums,3)
mode = 0
val = 0
for (index = 0 - 1; index++)
index = 0
if (nums[0] == nums[1]) (benar)
mode = 1
val = *(nums + 0) = 11
index = 1
if (nums[1] == nums[2]) (salah)
if (val > 0)(benar)
out: val = 11
Output: Mean = 14.7
Median = 11.0
Mode = 11
Kode Program 3.74 Program menghitung mean, median, dan mode
Kode Program 3.74 adalah trace dari program penghitungan yang telaht
dibuat dengan pemrograman menggunakan bahasa C++.
pada Gambar 3.77.
178
Gambar 3.77 Hasil compile program mean, median, dan mode pada Dev C++
Gambar 3.77 merupakan interface dari sintaks program menentukan mean,

median, dan mode yang telah di-compile, yang terdiri dari input-an banyak
bilangan dan nilai dari setiap bilangan. Hasil keluarannya adalah berupa nilai
mean, median, dan mode.
Program Perbandingan Sorting Melalui Cara Biasa dan Cara Pointer

Program selanjutnya adalah program perbandingan sorting melalui cara
biasa dan cara pointer. Hal yang ditekankan pada program ini adalah penggunaan
waktu proses dari masing-masing cara yang dilakukan. Berikut adalah flowchart
dari program ini pada Gambar 3.78.
179
Gambar 3.78 Flowchart program perbandingan sorting melalui cara biasa dan cara pointer
Gambar 3.78 adalah flowchart utama dari program ini melalui cara biasa
dan cara pointer.
180
Pseudocode dari program perbanding sorting melalui cara biasa dan
pointer dapat dilihat pada kode program 3.75.
Program utama
MULAI
READ n
arrayPtr new int[n]
fillArray(array, arrayPtr, n)
WRITE Sebelum Diurutkan
outArray(array,n)
WRITE Metode Biasa
t1 clock()
bubbleSortBiasa(array,n)
t2 clock()
waktu1=(double)(t2-t1)/CLK_TCK
outArray(array,n)
WRITE Metode Pointer
t1 clock()
bubbleSortPointer(arrayPtr,n)
t2 clock()
waktu2 (double)(t2-t1)/CLK_TCK
outArray(arrayPtr,n)
WRITE waktu1
WRITE waktu2
Read tombol
GOTO 2
ENDIF
SELESAI
Prosedur fillArray()
MULAI
READ array[], n
srand(time(NULL))
array[x] rand()%n
ENDFOR
SELESAI
Prosedur outArray()
MULAI
READ array[], n
srand(time(NULL))
WRITE array[x]
ENDFOR
SELESAI
Prosedur bubbleSortBiasa()
1. MULAI
2. READ array[], n
3. FOR x 0 - <n; x++ DO
4. FOR x 0 <(n-1) DO
IF array[y]>array[y+1] THEN
temp = array[y]
array[y] = array[y+1]
array[y+1] = temp
ENDIF
181
ENDFOR
ENDFOR
SELESAI
Prosedur bubbleSortPointer()
1. MULAI
2. READ *arrayPtr, n
3. FOR i 0 n; i++ DO
4. FOR j i+1 n; j++ DO
IF arrayPtr[i] >arrayPtr[j] THEN
temp = arrayPtr[i]
arrayPtr[i] = arrayPtr[j]
arrayPtr[j] = temp
ENDIF
ENDFOR
ENDFOR
SELESAI
Kode Program 3.75 Pseudocode program perbandingan sorting melalui cara biasa dan
cara pointer
Kode Program 3.75 merupakan pseudocode dari program perbandingan

sorting melalui cara biasa dan cara pointer.
Pemaparan pseudocode di atas di dalam program C++ dapat dilihat pada
Kode Program 3.76.
#include <iostream>
#include <limits>
#include <time.h>
#include <stdlib.h>
#include <conio.h>
time_t t1,t2;
void bubbleSort(int *, int);
void insertionSort(int *, int);
void quickSort(int *, int, int);
void bubbleSort(int *array, int x){
int tmp;
{
{
if(array[i]>array[j])
{
19. tmp = array[i];
20. array[i] = array[j];
21. array[j] = tmp;
}
}
}
25.
}
void insertionSort(int *array, int x){
int temp;
{
182
temp = array[i];
int j = i -1;
while(array[j]>temp && j>=0)
{
array[j+1] = array[j];
j--;
}
array[j+1] = temp;
}
}
void quickSort(int *array, int kiri, int kanan){
int temp,x,y;
int tengah;
x = kiri;
y = kanan;
tengah = array[(kiri+kanan) / 2];
47.
do{
while (array[x] < tengah)
x++;
while (array[y] > tengah) y--;
52. if (x <=y){
53. temp = array[y];
54. array[y] = array[x];
55. array[x] = temp;
56. x++;
57. y--;
58. }
}
while (x < y);
if (kiri < y)
quickSort(array,kiri,y);
if (x < kanan)
quickSort(array,x,kanan);
}
void bubble_sort (int data[], int x){
int tmp;
{
{
if(data[i]>data[j])
{
75. tmp = data[i];
76. data[i] = data[j];
77. data[j] = tmp;
}
}
}
81.
}
void insertion_sort(int data[], int x)
{
int temp;
{
temp = data[i];
int j = i -1;
183
while(data[j]>temp && j>=0)
{
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
}
}
void quick_sort(int data_b[], int kiri, int kanan) {
int temp,x,y;
int tengah;
x = kiri;
y = kanan;
tengah = data_b[(kiri+kanan) / 2];
do{
while (data_b[x] < tengah)
x++;
while (data_b[y] > tengah) y--;
110. if (x <=y){
111. temp = data_b[y];
112. data_b[y] = data_b[x];
113. data_b[x] = temp;
114. x++;
115. y--;
116. }
}
while (x < y);
if (kiri < y)
quick_sort(data_b,kiri,y);
if (x < kanan)
quick_sort(data_b,x,kanan);
int main (){

double waktu1, waktu2, waktu3, waktu4, waktu5, waktu6;
int *nilai;
char tombol;
int banyak, random;
char repeat;
srand(time(0));
ulang :
system("cls");
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
banyak))
{
cin.clear();
}
144.
145.
while (banyak < 0)
{
184
148. cout << "Input anda salah!\n";
149. cout << "Masukkan banyak data : ";
150. cin >> banyak;
151. }
152.
153.
nilai = new int[banyak];
for(int a=0;a<banyak;a++){
random=rand() % banyak+1;
nilai[a]=random;
}
cout<<"Data sebelum diurut : "<<endl;
for(int i=0;i<banyak;i++)
{
cout << nilai[i]<<", ";
}
cout<<endl;
t1=clock();
insertion_sort(nilai,banyak);
t2=clock();
cout<<"Hasil pada metode biasa insertion sort : "<<endl;
{
}
cout<<endl;
t1=clock();
bubble_sort(nilai,banyak);
t2=clock();
cout<<"Hasil pada metode biasa bubble sort : "<<endl;
{
}
cout<<endl;
t1=clock();
quick_sort(nilai,0,banyak-1);
t2=clock();
cout<<"Hasil pada metode biasa quick sort : "<<endl;
{
}
cout<<endl;
t1=clock();
insertionSort(nilai,banyak);
t2=clock();
cout<<"Hasil pada metode pointer insertion sort : "<<endl;
{
}
cout<<endl;
t1=clock();
bubbleSort(nilai,banyak);
185
t2=clock();
cout<<"Hasil pada metode pointer bubble sort : "<<endl;
{
}
cout<<endl;
t1=clock();
quickSort(nilai,0,banyak-1);
t2=clock();
cout<<"Hasil pada metode pointer quick sort : "<<endl;
{
}
cout<<"\nWaktu pada metode biasa insertion sort :
"<<waktu1<<endl;
cout<<"Waktu pada metode biasa bubble sort :
"<<waktu2<<endl;
cout<<"Waktu pada metode biasa quick sort :
"<<waktu3<<endl;
cout<<"Waktu pada metode pointer insertion sort :
"<<waktu4<<endl;
cout<<"Waktu pada metode pointer bubble sort :
"<<waktu5<<endl;
cout<<"Waktu pada metode pointer quick sort :
"<<waktu6<<endl;
cin>>tombol;
goto ulang;
else
236.
237. }
Kode Program 3.76 Program perbandingan sorting melalui cara biasa dan cara pointer
Kode Program 3.76 merupakan sintaks dari program perbandingan sorting

melalui cara biasa dan cara pointer.
Hasil trace dari program sorting secara array dan pointer di atas dapat
Input : n = 3,
array[0] = 1, array[1] = 0, array[2] = 1
arrayPtr[0] = 1, arrayPtr[1] = 0, arrayPtr[2] = 1
Proses: bubbleSortBiasa(array,3){
for (x = 0 - 2)
x = 0
for (y = 0 - 1)
y=0
if (array[0] > array[1])(benar)
temp = array[0] = 1
186
array[1] = temp = 1
y=1
x = 1
for (y = 0 - 1)
y=0
y=1
x = 2
for (y = 0 - 1)
y=0
y=1
}
bubbleSortPointer(arrayPtr,3){
for (i = 0 - 2)
i = 0
for (j = 1 - 2)
j=1
if (arrayPtr[0] > array[1])(benar)
temp = array[0] = 1
array[1] = temp = 1
j=2
if (arrayPtr[1] > arrayPtr[2])(salah)
i = 1
for (j = 2 - 2)
j=2
i = 2
for (j = 3 - 2) (stop)
}
Output: array[0] = 0, array[1] = 1, array[2] = 1
Kode Program 3.77 Program perbandingan sorting melalui cara biasa dan cara pointer
Kode Program 3.77 adalah trace dari program sorting melalui cara array
dan cara pointer yang telah dibuat.
Perbandingan waktu dari setiap pemrosesan yang dilakukan oleh masing-
masing cara sorting dapat dilihat pada Tabel. 3.3.
Tabel 3.3Perbandingan waktu pemrosesan dari masing-masing carasorting
Cara Biasa Cara Pointer
100 0 0
1000 0,016 0
2000 0,109 0,078
4000 0.110 0,078
8000 0,437 0,312
16000 1,763 1,217
32000 6,973 4.742
187
Tabel 3.3 memperlihatkan bahwa cara yang paling banyak membutuhkan
waktu pemrosesan adalah sorting cara biasa.
Hasil program di atas jika di-compile melalui Dev C++ dapat dilihat pada
Gambar 3.79.
Gambar 3.79 Hasil compile program perbandingan sorting melalui cara biasa dan cara pointer
pada Dev C++
Gambar 3.79 merupakan interface dari sintaks program perbandingan

sorting melalui cara biasa dan cara pointer yang telah di-compile.
Struktur dan Kelas

Modul ini membahas tentang strukturdan kelas.Program yang akan
dibahas dalam modul ini adalah program gaji harian karyawan yang menggunakan
struktur dan program mainan tamia yang menggunakan kelas.
188
Program Menghitung Gaji Harian
Program menghitung gaji harian merupakan program yang dibuat untuk
menghitung gaji harian karyawan berdasarkan jam kerja. Pada program ini
menggunakan struktur. Flowchat dari program menghitung gaji harian dapat
Gambar 3.80 Flowchart program utama menghitung gaji harian
Gambar 3.80 adalah flowchart dari program menghitung gaji harian

karyawan yang menggunakan struktur.
Pembuatan flowchart selanjutnya dapat dibuat bentuk pseudocode dari
program menentukan deret bilangan fibonacci, dapat dilihat pada Kode Program
3.78.
189
Program Utama
MULAI
STRUCT pembayaran
INT jam_kerja
FLOAT gaji
pembayaranpegawai
WRITE masukkan jumlah jam kerja
READ pegawai.jam_kerja
IF(pegawai.jam_kerja>8) THEN
pegawai.gaji=(1500*8)+((1500*(pegawai.jam_kerja-8))*10)
ELSE
pegawai.gaji=(1500*pegawai.jam_kerja)
ENDIF
WRITE Total gajiharianadalahRp. pegawai.gaji
READ tombol
GOTO 2
ENDIF
SELESAI
Kode Program 3.78 Pseudocode program menghitung gaji harian
Kode Program 3.78 merupakan program yang menjelaskan tentang

program menghitung gaji harian.
Flowchart dan pseudocode di atas jika dituangkan dalam program C++,
maka sintaks dari program tersebut dapat dilihat pada Kode Program 3.79.
#include <iostream>
#include <conio.h>
#include <limits>
#include <cstring>
int main(){
ulang:
system("cls");
char tombol;
float gaji_pokok=1500;
int jam_kerja, jam_lembur;
char nama[100];
float gaji_lembur, gaji_total, gaji;
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
18. cout<<"| ~~Gaji Karyawan~~ |"<<endl;
cout<<" __________________________________"<<endl;
cout<<"\n";
cout<<"Program Menghitung Gaji Pegawai\n"<<endl;
cout<<"Masukkan nama pegawai : ";
cin.getline(nama,23);
while ( cout<<"\nJam kerja pegawai : "&&!(cin >> jam_kerja))
{
cin.clear();
}
190
30.
cout<<"Jam kerja : "<<jam_kerja<<endl;
if(jam_kerja<=8){
gaji_lembur=0;
gaji=jam_kerja*gaji_pokok;
gaji_total=gaji+gaji_lembur;
cout<<"Total gaji adalah : "<<gaji_total<<endl;
}
else{
jam_lembur=jam_kerja-8;
gaji=8*gaji_pokok;
gaji_lembur=jam_lembur*(10*gaji_pokok);
gaji_total=gaji+gaji_lembur;
cout<<"Total gaji adalah : "<<gaji_total<<endl;
}
cin>>tombol;
goto ulang;
else
getch();
return 0;
}
Kode Program 3.79 Program menghitung gaji harian
Kode program 3.79 merupakan sintaks dari program menghitung gaji

harian dengan pemrograman menggunakan bahasa C++.
Trace dari program menghitung gaji harian dengan pemrograman
Input :
Pegawai.jam_kerja = 8;
Proses:
if(pegawai.jam_kerja (8) >8) <<salah
{
pegawai.gaji=(1500*8)+((1500*(pegawai.jam_kerja-
8))*10);
}
else <<benar
{
pegawai.gaji=(1500*pegawai.jam_kerja);
// pegawai.gaji=(1500*8)
}
Ouput :
Pegawai.gaji = 12000
Kode Program 3.80 Program menghitung gaji harian
Kode Program 3.80 merupakan trace dari program menghitung gaji harian
Program menghitung gaji harian jika di-compile melalui Dev C++ maka
191
Gambar 3.81 Hasil compile program menghitung gaji harian pada Dev C++
Gambar 3.81 merupakan hasil dari sintaks program menghitung gaji

harianyang telah di-compile, terdiri dari input-an jam kerja. Apabila yang di-input
bukan berupa angka, maka program dengan otomatis akan menampilkan input
salah, karena program telah menggunakan validasi.
Program Tamia
Program kedua adalah program mainan tamia. Flowchart dari program ini
192
Gambar 3.82 Flowchart program utama tamia
Pada Gambar 3.82 merupakan flowchart program tamia. Program tersebut

menggunakan kelas.
Flowchart dari setiap fungsi yang dipakai program ini akan dijabarkan
pada Gambar 3.83.
Gambar 3.83 Flowchart fungsi setDaya pada kelas tamia
193
Gambar 3.83 merupakan flowchart dari fungsi setDaya pada kelas tamia
Flowchart setUkuranRoda dengan pemrograman menggunakan bahasa C+
+ dapat dilihat pada Gambar 3.84.
Gambar 3.84 Flowchart fungsi setUkuranRoda
Gambar 3.84 merupakan flowchatdari fungsi setUkuranRoda dengan

Flowchart setLama dengan pemrograman menggunakan bahasa C++ dapat
Gambar 3.85 Flowchart fungsi setLama
Gambar 3.85 merupakan flowchatdari fungsi setLama dengan

Flowchart setJarakTempuh dengan pemrograman menggunakan bahasa
Gambar 3.86 Flowchart fungsi setJarakTempuh
194
Gambar 3.86 merupakan flowchatdari fungsi setJarakTempuh dengan
Flowchart dari setKecepatan dengan pemrograman menggunakan bahasa
Gambar 3.87 Flowchart fungsi setKecepatan
Gambar 3.87 merupakan flowchat dari fungsi setKecepatan dengan

Flowchart dari getDaya dengan pemrograman menggunakan bahasa C++
Gambar 3.88 Flowchart fungsi getDaya
Gambar 3.88 merupakan flowchatdari fungsigetDaya dengan

Flowchart getUkuranRoda dengan pemrograman menggunakan bahasa C+
+ dapat dilihat pada Gambar 3.89.
195
Gambar 3.89 Flowchart fungsi getUkuranRoda
Gambar 3.89 merupakan flowchatdari fungsi getUkuranRoda dengan

Flowchart getLama dengan menggunakan pemrograman menggunakan
bahasa C++ dapat dilihatpada Gambar 3.90.
Gambar 3.90 Flowchart fungsi getLama
Gambar 3.90 merupakan flowchatdari fungsi getLama dengan

Flowchart getJarakTempuh dengan pemrograman menggunakan bahasa
Gambar 3.91 Flowchart fungsi getJarakTempuh
Gambar 3.91 merupakan flowchatdari fungsi getJarakTempuh dengan

Flowchart getKecepatan dengan pemrograman menggunakan bahasa C++
196
Gambar 3.92 Flowchart fungsi getKecepatan
Gambar 3.92 merupakan flowchat fungsi getKecepatan dengan

Flowchart yang terdapat pada diatas, maka dapat dibentuk pseudocode
Program Utama
MULAI
tamiamobil
READ daya
READ ukuran
IF(ukuran==1) THEN
ukuran=18
ELSE IF(ukuran==2) THEN
ukuran=21
ELSE IF(ukuran==3) THEN
ukuran=24
ELSE
WRITE Pilihan Salah
GOTO 4
ENDIF
mobil.setDaya(daya)
mobil.setUkuranRoda(ukuran)
mobil.setLama()
mobil.setJarakTempuh()
mobil.setKecepatan()
WRITE "Dayabaterai yang digunakan: "mobil.getDaya()
WRITE "Ukuranroda yang digunakan: "mobil.getUkuranRoda()
WRITE "Perkiraanjaraktempuhdaritamia: "mobil.getJarakTempuh()
WRITE "Perkiraan lama dayatahantamia: "mobil.getLama()
WRITE "Perkiraankecepatantamia: "mobil.getKecepatan()
SELESAI
KELAS
CLASS tamia
private:
FLOAT daya, kecepatan, lama, jaraktempuh
INT ukuranroda
public:
FLOATsetDaya(FLOAT baterai)
this->daya=baterai
INT setUkuranRoda(INT ukuran)
this->ukuranroda=ukuran
FLOAT setLama()
this->lama=daya/0.001
FLOAT setJarakTempuh()
197
this->jaraktempuh=((lama*8)*ukuranroda)
FLOAT setKecepatan()
IF(ukuranroda==18) THEN
kecepatan=jaraktempuh/lama
ELSE IF(ukuranroda==21) THEN
kecepatan=0.9*jaraktempuh/lama
ELSE IF(ukuranroda==24) THEN
kecepatan=0.81*jaraktempuh/lama
ENDIF
FLOAT getDaya()
return daya
INT getUkuranRoda()
return ukuranroda
FLOAT getLama()
return lama
FLOAT getJarakTempuh()
return jaraktempuh
FLOAT getKecepatan()
return kecepatan
SELESAI
Kode Program 3.81 Pseudocode program tamia
Kode Program 3.81 merupakan pseudocode program tamia dengan

Flowchart dan pseudocode sudah dibuat, sehingga dapat dilanjutkan
dengan membuat program dalam C++ pada Kode Program 3.82.
#include<iostream>
#include<cstdlib>
#include<limits>
#include<time.h>
#include <conio.h>
class Tamia{
public:
Tamia(){
cout<<"Tamia"<<endl;
}
void hitungJarak();
void setDaya(double d);
double getDaya();
void showJarak();
void setBan(double b);
double getBan();
void hitungKecepatan();
void showKecepatan();
void showKecepatan2();
void showKecepatan3();
double getJarak();
double getKecepatan();
void hitungKecepatan2();
void hitungKecepatan3();
void hitungputarroda();
void showputarroda();
198
void showwaktu();
private :
double daya, k, ban, kec, lim, s, kec2, kec3;
int putarroda;
};
void Tamia::showwaktu(){
int waktu,detik, menit1, menit2, jam1;
waktu=putarroda/8;
if(waktu<60){
detik=waktu;
}
else if(detik>=60){
menit1=waktu/60;
detik=waktu-(menit1*60);
}
if(menit1<60){
menit2=menit1;
jam1=0;
}
else if(menit1>=60){
jam1=menit1/60;
menit2=menit1-(jam1*60);
}
cout<<"Waktu tempuh = "<<jam1<<"Jam "<<menit2<<"Menit
"<<detik<<"Detik "<<endl;
}
54.
void Tamia::showputarroda(){
cout<<"Putaran roda = "<<putarroda<<endl;
}
58.
void Tamia::showKecepatan(){
cout<<"Kecepatan Tamia = "<<kec<<" mm/s"<<endl;
}
62.
void Tamia::showKecepatan2(){
cout<<"Kecepatan Tamia = "<<kec2<<" mm/s"<<endl;
}
66.
void Tamia::showKecepatan3(){
cout<<"Kecepatan Tamia = "<<kec3<<" mm/s"<<endl;
}
void Tamia::hitungKecepatan(){
int waktu;
waktu=putarroda/8;
kec=s/waktu;
}
75.
void Tamia::hitungKecepatan2(){
int waktu;
waktu=putarroda/8;
kec2=(s/waktu)*0.9;
80.
}
void Tamia::hitungputarroda(){
putarroda=(daya*1000)*8;
}
void Tamia::hitungKecepatan3(){
int waktu;
199
waktu=putarroda/8;
kec3=((s/waktu)*0.9)*0.9;
}
void Tamia::hitungJarak(){
putarroda=(daya*1000)*8;
s=((2*3.14*(ban/2)*putarroda));
}
void Tamia::setDaya(double d){
while ( cout<<"\nMasukkan Daya : "&&!(cin >> d))
{
cin.clear();
}
daya=d;
}
103.
double Tamia::getDaya(){
return daya;
}
107.
void Tamia::showJarak(){
cout<<"Jarak yang ditempuh = "<<s<<" mm = "<<(s/1000)<<"
m"<<endl;
}
111.
void Tamia::setBan(double b){
ban=b;
}
115.
double Tamia::getBan(){
return ban;
}
119.
120.
121.
int main(){
ulang:
system("cls");
int b, pil, d;
char tombol;
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
130. cout<<"| Tamiya |"<<endl;
cout<<" __________________________________"<<endl;
cout<<"\n";
Tamia t1;
t1.setDaya(d);
cout<<"Pilih Ban : "<<endl;
cout<<"1. 18 mm"<<endl;
while(cout<<"Masukkan Settingan Ban = "&&!(cin>>pil)){
cout<<"Data yanag Anda Massukkan Salah. Silahkan Coba
Lagi"<<endl;
cin.clear();
cin.sync();
}
200
if(pil==1){
t1.setBan(18);
t1.hitungJarak();
t1.showJarak();
t1.hitungKecepatan();
t1.hitungputarroda();
t1.showputarroda();
t1.showwaktu();
t1.showKecepatan();
}
else if(pil==2){
t1.setBan(21);
t1.hitungJarak();
t1.showJarak();
t1.hitungKecepatan2();
t1.showputarroda();
t1.showwaktu();
t1.showKecepatan2();
}
else if(pil==3){
t1.setBan(24);
t1.hitungJarak();
t1.showJarak();
t1.hitungKecepatan3();
t1.showputarroda();
t1.showwaktu();
t1.showKecepatan3();
}
cin>>tombol;
goto ulang;
else
getch();
return 0;
}
Kode Program 3.82 Program tamia
Kode Program 3.82 merupakan program untuk tamia dengan

Hasil compile dari program tamia dengan pemrograman menggunakan
bahasa C++ dapat dilihat pada trace dalam Kode Program 3.83.
Input:
Dayabaterai = 3; Ukuran = 1;
Proses:
if(ukuran (1) ==1) <<benar
ukuran = 18;
else if(ukuran (1) ==2) <<salah
ukuran = 21;
else if(ukuran (1) ==3) <<salah
201
ukuran = 24;
else <<salah
{
cout<<"Pilihan Salah:";
gotoukuran;
}
mobil.setDaya(baterai) { this-
>daya = baterai; //
daya = 3
}
setUkuranRoda(ukuran){ this-
>ukuranroda = ukuran;
//ukuranroda=18
}
setLama(){
this->lama =
daya/0.001; // lama = 3 /
0.001
}
setJarakTempuh(){ this-
>jaraktempuh=((lama*8)*ukuranroda);
//jaraktempuh=((3000*8)*18)
}
setKecepatan(){
if(ukuranroda (18) ==18) <<benar
{
kecepatan=jaraktempuh/lama;
//kecepatan = 432000/3000
}
if(ukuranroda (18) ==21) <<salah
{
kecepatan=0.9*jaraktempuh/lama;
}
if(ukuranroda (18) ==24) <<salah
{
kecepatan=0.81*jaraktempuh/lama;
}
}
Output :
Jaraktempuh : 432000 mm
Lama dayatahantamia : 3000 detik
Kecepatantamia : 144 mm/detik
Kode Program 3.83 Trace program tamia
Kode Program 3.83 merupakan trace dari program tamia dengan

menggunakan pemrograman bahasa C++.
pada Gambar 3.93.
202
Gambar 3.93 Hasil compile programtamia pada Dev C++
Gambar 3.93 merupakan interface dari program tamia yang telah di-
compile, pertama terdapat input daya yang dilakukan oleh pengguna, selanjutnya
terdapat tiga pilihan ukuran roda yaitu roda 18mm, roda 21mm, roda24mm.
Operasi File
Modul ini membahas tentang operasi file. Program yang akan dibahas
dalam modul ini adalah program menentukan kata palindrom, program
menyimpan data mahasiswa, dan program mengurutkan nilai mahasiswa. Ketiga
program tersebut mengunakan metode pengoperasian file.
Program Menentukan Kata Palindrom

Hal yang pertama dilakukaan pada saat pembuatan program menentukan
kata palindrom adalah pembuatan flowchart. Flowchat yang dimaksud dapat
203
204
Gambar 3.94 Flowchart program menentukan kata palindrom
Gambar 3.94 adalah flowchart dari program utama menentukan kata

palindrom.
Bentuk pseudocode dari program menentukan menentukan kata
palindrom dapat dilihat pada Kode Program 3.84.
MULAI
READ awal
count0
FOR x0 - <strlen(awal);x++ DO
temp0
sama=false
FOR yx - <strlen(awal);y++ DO
IF(awal[x]==awal[y] THEN
temp++
ENDIF
ENDFOR
FOR y0 - <=count;y++ DO
IF(awal[x]=awal[y] THEN
sama=true
ENDIF
ENDFOR
IF(!sama) THEN
a[count]=awal[x]
b[count]=temp
count++
ENDIF
ENDFOR
OFSTREAM kamus(kamuskata.txt, ios::app)
FOR y0 - <strlen(awal);y++ DO
kamus awal[y]
ENDFOR
205
FOR x0 - <count;x++ DO
kamus a[x] = b[x]
ENDFOR
strcpy(balik,awal)
strrev(balik)
IF(strcmp(awal,balik)==0) THEN
kamus palindrom
ELSE kamus tidak palindrom
ENDIF
kamus.close()
WRITE tampilkan file ? [y/t]
READ tombol
IF(tombol==Y or tombol==y) THEN
IFSTREAM tampilkan(kamuskata.txt
WHILE(!tampilkan.eof())
getline(tampilkan,line)
WRITE line
ENDWHILE
tampilkan.close()
ENDIF
SELESAI
Kode Program 3.84 Pseudocode program menentukan kata palindrom
Kode Program 3.84 menjelaskan tentang program menentukan kata

palindrom dengan menggunakan pseudocode.
#include <iostream>
#include <cstring>
#include <string>
#include <fstream>
#include <conio.h>
#include<stdlib.h>
class kalimat{
private :
char* huruf;
char alpha;
int counter;
public :
kalimat();
void setdata(char*);
void analisis();
void cetak(char,int);
};
kalimat::kalimat(){
counter=0;
huruf=0;
}
void kalimat::setdata(char* kalimat){
huruf=new char[10000];
strcpy(huruf,kalimat);
counter=0;
}
206
void kalimat::analisis(){
for(alpha='a';alpha<'z';alpha++){
for(int a=0;*(huruf+a)!='\0';a++){
if(*(huruf+a)==alpha)
32. counter++;
}
cetak(alpha,counter);
counter=0;
36.
}
}
void kalimat::cetak(char alpha, int counter){
ofstream huruf;
huruf.open("D:/kamuskata.txt", ios::app);
if (counter!=0){
cout<<"Karakter "<<alpha<<" = "<<counter<<endl;
huruf<<"Karakter "<<alpha<<" = "<<counter<<endl;}
}
46.
47.
48. int main(){
49.
kalimat objek;
int belakang, counter=0;
bool palindrome = true;
char panjang[10000], copy[10000];
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
cout<<"\n";
58.
cout<<"Masukkan kalimat yang akan dihitung : ";
cin.getline(panjang,10000);
ofstream kata("D:/kamuskata.txt", ios::app);
kata<<panjang<<endl;
objek.setdata(panjang);
cout<<"Hasil Perhitungan : "<<endl;
objek.analisis();
int p = strlen(panjang);
belakang = p-1;
for(int a=0; a<p; a++)
{
70.
71.
if((char)tolower(panjang[a])!=(char)tolower(panjang[belakang]))
{
73. palindrome = false;
74. break;
}
belakang--;
}
cout<<endl;
if(palindrome)
cout<<"Palindrom"<<endl;
else
cout<<"Bukan Palindrom"<<endl;
ofstream palindrom1;
palindrom1.open("D:/kamuskata.txt", ios::app);
207
ofstream palindrom2;
palindrom2.open("D:/kamuskata.txt", ios::app);
if(palindrome)
palindrom1<<"Palindrom"<<endl;
else
palindrom2<<"Bukan Palindrom"<<endl;
ofstream spasi;
spasi.open("D:/kamuskata.txt", ios::app);
spasi<<endl<<endl;
getch();
return 0;
}
Kode Program 3.85 Program menentukan kata palindrom
Kode program 3.85 merupakan sintaks dariprogram menentukan kata

palindrom.
Trace dari program menentukan kata palindorm dengan pemrograman
Input : awal = katak
Proses: kamus.open(kamus.txt)
count = 0
for( x = 0 - 4 )
{ x=0
temp=0;
sama=false;
for(y= 0 4){
y=0
if(awal[0] (k)= awal[0] (k)) (benar)
temp = 1
y=1
if(awal[0] (k)= awal[1] (a)) (salah)
y=2
if(awal[0] (k)= awal[2] (t)) (salah)
y=3
if(awal[0] (k)= awal[3] (a)) (salah)
y=4
temp = 2
}
if(!sama)<<benar{
a[count]=awal[x] //a[0]= awal[0]
b[count]=temp //b[0]= 2
count++ //count=1
}
x=1
temp=0
sama=false
for(y= 1 4){
y=1
if(awal[1] (a)= awal[1] (a)) (benar)
temp = 1
y=2
if(awal[1] (a)= awal[2] (t)) (salah)
y=3
208
temp = 2
y=4
if(awal[1] (a)= awal[4] (k)) (salah)
}
for(y= 0 0){
y=0;
if(awal[0](a)== a[0](k))(salah)
if(!sama)<<benar{
count++; //count=2
}
x=2
temp=0;
sama=false;
for(y= 2 4){
y=2
if(awal[2] (t)= awal[2] (t)) (benar)
temp = 1
y=3
if(awal[2] (t)= awal[3] (a)) (salah)
y=4
if(awal[2] (t)= awal[4] (k)) (salah)
}
for(y= 0 1){
y=0
if(awal[2](t)== a[0](k))(salah)
y=1
if(awal[2](t)== a[1](a))(salah)
if(!sama)(benar) {
count++ //count=3
}
x=3
temp=0
sama=false
for(y= 3 4){
y=3
temp = 1
y=4
if(awal[3] (a)= awal[4] (k)) (salah)
}
for(y= 0 2){
y=0
if(awal[3](a)== a[0](k))(salah)
y=1
if(awal[3](a)== a[1](a))(benar){
sama= true
break
}
y=2
if(awal[3](a)== a[2](t))(salah)
}
if(!sama)(salah)
x=4
temp=0
209
sama=false
for(y= 4 4){
y=4
temp = 1
}
for(y= 0 2){
y=0
if(awal[4](k)== a[0](k))(benar){
sama=true
break
}
y=1
if(awal[4](k)== a[1](a))(salah)
y=2
if(awal[4](k)== a[2](t))(salah)
}
if(!sama)(salah)
for(y=0 - 4){
y=0
kamus<<awal[0] //k
y=1
kamus<<awal[1] //a
y=2
kamus<<awal[2] //t
y=3
kamus<<awal[3] //a
y=4
kamus<<awal[4] //k
}
kamus<<"\t";
for(x=0 - 2){
x=0
kamus<<" "<<a[0]<<"="<<b[0] //k = 2
x=1
kamus<<" "<<a[1]<<"="<<b[1] //a = 2
x=2
kamus<<" "<<a[2]<<"="<<b[2] //t = 1
}
strcpy(balik,awal)
strrev(balik) //katak
if(strcmp(awal,balik)==0)(benar){
kamus<<" Palindrom"<<endl<<endl;
}
Output: katak k=2 a=2 t=1 palindrom
Kode Program 3.86 Program menentukan kata palindrom
Kode Program 3.86 menjelaskan tentang trace dari program menentukan

kata palindrom.
Program menentukan kata palindrom jika di-compile melalui Dev C++
maka hasilnya dapat dilihat pada Gambar 3.94
210
Gambar 3.95 Hasil compile programmenentukan kata palindrom pada Dev C++
Gambar 3.95 merupakan hasil dari sintaks program menentukan kata

palindrom yang telah di-compile, terdiri dari input-an kata pada awal program.
Input-an kata tadi akan disimpan pada filekamuskata.txt.
Program Menyimpan Data Mahasiswa

Program kedua adalah program menyimpan data mahasiswa pada sebuah
file. Flowchart dari program ini dapat dilihat pada Gambar 3.96.
211
Gambar 3.97 Flowchart program menyimpan data mahasiswa
Gambar 3.97 merupakan flowchart dari program menyimpan data

mahasiswa.
212
Bentuk pseudocode dari program menyimpan data mahasiswa dapat
dilihat pada Kode Program 3.87
MULAI
OFSTREAM keluaran
READ alamat
keluaran.open(alamat, ios::app)
READ nim
READ nama
IFSTREAM masukan(alamat)
count0
WHILE(!masukan.eof()) DO
masukan>>nimTemp[count]
getline(masukan,line)
count++
ENDWHILE
IF(nim==nimTemp[x]) THEN
sama=true
Break
ENDIF
ENDFOR
IF(!sama) THEN
keluaran<<nim \t nama
WRITE Biodata berhasil dimasukkan
ELSE
WRITE Ada NIM yang sama!
ENDIF
masukkan.close()
WRITE Tampilkan file? [y/t]
READ tombol
IF(tombol==Y || tombol==y) THEN
IFSTREAM tampilkan(alamat)
WHILE(!tampilkan.eof())
getline(tampilkan,line)
WRITE line
ENDWHILE
tampilkan.close()
ENDIF
SELESAI
Kode Program 3.87 Pseudocode program menyimpan data mahasiswa
Kode Program 3.87 merupakan pseudocode program menyimpan data

mahasiswa.
#include <iostream>
#include <stdlib.h>
#include <cstring>
#include <string>
#include <fstream>
class mahasiswa{
int nim;
213
char nama[100];
public :
void inputdata(){
cout<<"Data Mahasiswa "<<endl;
13. cout<<"Nama(tanpa_spasi) : "; cin>>nama;
14. cout<<"NIM : "; cin>>nim;
15.
}
void outputdata(){
cout<<endl;
cout<<"Data Mahasiswa "<<endl;
20. cout<<"NIM : "<<nim<<endl;
21. cout<<"Nama : "<<nama<<endl;
}
int getnim(){
return nim;
}
};
27.
void simpandata(){
char daftarnama[10000]="D:/daftarnama.txt";
mahasiswa mhs;
mhs.inputdata();
ofstream f;
f.open(daftarnama,ios::binary|ios::app);
f.write((char*)&mhs, sizeof(mhs));
f.close();
}
void bacadata(){
mahasiswa mhs;
ifstream f;
f.open(daftarnama, ios::binary);
while(f.read((char*)&mhs, sizeof(mhs))){
mhs.outputdata();
}
}
int caridata(int nimb){
mahasiswa mhs, mhsKetemu;
int ketemu=0;
ifstream f;
f.open(daftarnama, ios::binary);
while(f.read((char*)&mhs, sizeof(mhs))){
if(mhs.getnim()==nimb){
mhsKetemu=mhs;
ketemu=1;
break;
}
}
return ketemu;
f.close();
}
int main(){
int periksa;
char tombol;
again :
system ("cls");
cout<<" __________________________________"<<endl;
214
cout<<"|__________________________________|"<<endl;
cout<<"\n";
cout<<"Memeriksa data! Masukkan nim mahasiswa :";
cin>>periksa;
int ketemu=caridata(periksa);
if(ketemu==0){
cout<<"Data belum diisi! Silahkan lanjutkan
pengisian!!"<<endl;
goto next;
}
else
{cout<<"Data sudah ada. Silahkan coba kembali!!"<<endl;
goto repeat;
}
next :
simpandata();
cout<<endl;
cout<<"Membaca dari File "<<endl;
bacadata();
repeat:
cin>>tombol;
{goto again;}
else
return 0;
}
Kode Program 3.88 Program menyimpan data mahasiswa
Kode Program 3.88 merupakan program untuk menyimpan data

mahasiswa pada sebuah file.
Hasil compile dari program menyimpan data mahasiswa dengan
pemrograman menggunakan bahasa C++ dapat dilihat pada trace dalam Kode
Program 3.89.
Input : alamat = D:/daftarnama.txt
nama = hasil
nim = 1404509999
daftarnama.txt = 1404505075 narendra
Proses: masukan.open(alamat)
count=0;
while(!masukan.eof()){
masukan>>nimTemp[count]
getline(masukan,line)
count++
}
for(x= 0 - 0){
x=0;
if(nim==nimTemp[0])(salah)
}
if(!sama)(benar){
keluaran<<nim<<"\t"<<nama<<endl<<endl; //1404502039
made cenik
215
cout<<"\nBiodata berhasil dimasukkan"<<endl
}
Output : daftarnama.txt = 1404505114 asmara
1404509999 hasil
Kode Program 3.89 Program menyimpan data mahasiswa
Kode Program 3.89 memperlihatkan trace dari program yang

menyimpan data mahasiswa.
pada Gambar 3.89.
Gambar 3.98 Hasil compile program menyimpan data mahasiswa pada Dev C++
Gambar 3.98 merupakan interface dari program menyimpan data

mahasiswayang telah di-compile, terdiri dari input-an alamat direktori, nim, dan
nama.
Program Mengurutkan Nilai

Program ketiga adalah program mengurutkan nilai dari datayang
tersimpan di sebuah file dan ditampilkan di file lainnya. Berikut adalah flowchart
dari program ini.
216
Gambar 3.99 Flowchart program mengurutkan nilai
Gambar 3.99 adalah flowchart dari program utama mengurutan nilai dari
data yang tersimpan di sebuah file dan ditampilkan di file lainnya, atau dengan
kata lain masukan data dari suatu file berasal dari file lainnya.
Bentuk pseudocode dari program mengurutkan nilai dapat dilihat pada
Kode Program 3.90.
MULAI
STRUCT biodata
CHAR nama[100]
INT nilai
biodata mahasiswa[100], temp
IFSTREAM masukan
OFSTREAM keluaran
masukan.open(input.txt)
217
keluaran.open(output.txt)
count0
WHILE(!masukan.eof())
masukan>>mahasiswa[count].nama
masukan>>mahasiswa[count].nilai
count++
ENDWHILE
FOR yx - <count;y++ DO
IF(mahasiswa[x].nilai<mahasiswa[y].nilai) THEN
temp=mahasiswa[x]
mahasiswa[x]=mahasiswa[y]
mahasiswa[y]=temp
ENDIF
ENDFOR
ENDFOR
tmp1
keluaran<<tmp . mahasiswa[x].nama mahasiswa[x].nilai
tmp++
ENDFOR
masukan.close()
keluaran.close()
SELESAI
Kode Program 3.90 Pseudocode program mengurutan nilai
Kode Program 3.90 merupakan pseudocode program mengurutkan nilai

dari data yang tersimpan di sebuah file dan ditampilkan di file lainnya.
Flowchart maupun pseudocode di atas akan dituangkan dalam program C+
+, sehingga sintaks dari program tersebut dapat dilihat pada Kode Program 3.91.
#include <iostream>
#include <fstream>
#include <conio.h>
#include <stdlib.h>
#include <sstream>
#include <string>
8. using namespace std;

9.
int bacafile(void);
int urutdata(void);
int tulisfile(void);
struct profil
{
string nama;
int nilai;
}
mahasiswa[30];
int panjang;
218
int main()
{
program :
system ("cls");
int input;
char tombol;
int nomer = 1;
int no = 1;
cout<<" __________________________________"<<endl;
cout<<"|__________________________________|"<<endl;
cout<<"\n";
bacafile();
panjang += 1;
cout << "Data dari D:/asistenin.txt (Belum terurut) : "
endl<<endl;
for(int i=0;i< panjang;i++)
{
cout << nomer <<" "<< mahasiswa[i].nama << "\t\t" <<
mahasiswa[i].nilai
<< endl;
nomer++;
}
cout << "\nMengurutkan data dari besar ke kecil" <<
endl<<endl;
cout << "Pilihan : \n1. Mulai Mengurutkan\n0. Keluar\n" <<
endl;
cout << "Masukkan Pilihan : ";
cin >> input;
cout<<endl;
if(input == 1)
{
urutdata();
for(int j=0;j< panjang;j++)
{
54. cout << no << mahasiswa[j].nama << " " <<
mahasiswa[j].nilai << endl;
55. no++;
56. }
57.
tulisfile();
cout << "\nData telah disimpan ke D:/asistenout.txt" <<
endl;
}
else
{
cout << "Terima Kasih!";
}
getch();
cin>>tombol;
{goto program;}
else
return 0;
}
int bacafile(void)
{
219
string alltext="";
char s[1024];
fstream fh("D:/asistenin.txt");
int a =0;
int b=0;
while(fh.getline(s, 1024))
{
alltext += s;
alltext +="\n";
if(a % 2 == 0)
{
mahasiswa[b].nama = s;
}
else
{
mahasiswa[b].nilai = atoi(s);
panjang = b;
b++;
}
a++;
}
fh.close();
return 0;
}
int urutdata(void)
{
int i, j, tmp;
string tmp2;
for(i=0; i< panjang - 1; i++)
{
for(j=i+1; j < panjang; j++)
{
if(mahasiswa[i].nilai < mahasiswa[j].nilai)
{
tmp = mahasiswa[i].nilai;
tmp2 = mahasiswa[i].nama;
mahasiswa[i].nilai = mahasiswa[j].nilai;
mahasiswa[i].nama = mahasiswa[j].nama;
mahasiswa[j].nilai = tmp;
mahasiswa[j].nama = tmp2;
}
}
}
return 0;
}
int tulisfile(void)
{
int i;
ofstream siswa("D:/asistenout.txt", ios::out);
for(i=0;i < panjang;i++)
{
siswa << mahasiswa[i].nama << "\t\t" <<mahasiswa[i].nilai <<
endl;
}
}
Kode Program 3.91 Program mengurutkan nilai
220
Kode Program 3.91 adalah kode program yang telah dibuat dengan
Hasil trace dari program mengurutkan nilai dengan pemrograman
Input : input.txt =pande 90 pradani 75 mitha 80
Proses: masukan.open("input.txt")
keluaran.open("output.txt")
count=0 while(!
masukan.eof()){
count = 0
masukan>>mahasiswa[0].nama; //narendra
masukan>>mahasiswa[0].nilai; //88 count+
+;
count = 1
masukan>>mahasiswa[1].nama; //asmara
masukan>>mahasiswa[1].nilai; //75
count++;
count = 2
masukan>>mahasiswa[1].nama; //tania
masukan>>mahasiswa[1].nilai; //86
count++;
}
for(x=0-2){
x=0
for(y=0-2)
{ y=0
if(mahasiswa[0].nilai (90) <
mahasiswa[0].nilai (90))(salah)
y=1
y=2
}
x=1
for(y=1-2){
y=1
y=2
mahasiswa[2].nilai (80))(benar){
temp = mahasiswa[1] = pradani 75
mahasiswa[1] = mahasiswa[2] = mitha 80
mahasiswa[2] = tmp = pradani 75
}
}
x=2
for(y=2-2){
y=2
if(mahasiswa[2].nilai
(80)<mahasiswa[1].nilai (80))(salah)
}
}
221
tmp = 1
for (x=0-2){
x=0
keluaran<<1<<". "<<mahasiswa[0].nama<<"
"<<mahasiswa[0].nilai<<endl;
tmp = 2
x=1
tmp = 3
x=2
tmp = 4
}
Output: narendra 88
asmara 86
tania 75
Kode Program 3.92 Program mengurutkan nilai
Kode Program 3.92 adalah trace dari program mengurutkan nilai dengan
pada Gambar 3.96.
Gambar 3.100 Hasil compile program mengurutkan nilai pada Dev C++
222
Gambar 3.100 merupakan interface dari sintaks program mengurutkan
nilai dari data yang tersimpan di sebuah file dan ditampilkan di file lainnya. Data
masukan akan berasal dari file input.txt yang akan diteruskan ke file output.txt
melalui program ini.
223

Bab Iii

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Bab Iii

Hochgeladen von

Copyright:

Verfügbare Formate

BAB III

23 Program Menghitung Akar Persamaan Kuadrat

Gambar 3.1 adalah flowchart yang digunakan dalam program menghitung

Kode Program 3.1 menjelaskan tentang program menghitung akar

23 cout<<"Masukkan nilai b :";

23 cout<<"Masukkan nilai c :";

Kode program 3.2 merupakan sintaks dari program menghitung akar

Kode Program 3.3 menjelaskan tentang trace dari program menghitung

Gambar 3.2 merupakan hasil dari sintaks program menghitung akar

23 Program Konversi Desimal Dan Biner

Gambar 3.3 merupakan flowchart yang digunakan dalam pembuatan

Kode Program 3.4 merupakan pseudocode dalam program konversi

Kode Program 3.6 menjelaskan tentang trace dari program konversi

Kode Program 3.7 menjelaskan tentang trace dari program konversi

Gambar 3.5 adalah flowchart yang digunakan dalam pembuatan program

Kode Program 3.7 menjelaskan tentang program zodiak dengan

Kode program 3.8 merupakan sintaks dari program zodiak. Awalnya

Gambar 3.6 Hasil compile program zodiak pada Dev C++

0 Program Nilai Akhir Mahasiswa

Kode Program 3.10 menjelaskan tentang program nilai akhir mahasiswa

23 cout<<"Nilai UTS : ";

Kode program 3.11 merupakan sintaks dari program menghitung akar

0 Program Deret Bilangan Prima

Gambar 3.9 adalah flowchart yang digunakan dalam pembuatan program

Kode Program 3.13 menjelaskan tentang program deret bilangan prima

23 cout<<"Deret bilangan Prima : ";

Kode Program 3.15 menjelaskan tentang trace dari program deret

Gambar 3.10 Hasil compile program zodiak pada Dev C++

Gambar 3.11 adalah flowchart utama dari program fibonacci. Berdasarkan

Gambar 3.12 Flowchart fibonacci rekursif

Gambar 3.12 adalah sub-flowchart dari program fibonacci yang berisikan

Gambar 3.13 adalah sub-flowchart dari flowchart program fibonacci yang

Kode Program 3.16 menjelaskan tentang program fibonacci dengan

Kode Program 3.17 merupakan Pseudocode yang menjelaskan mengenai

Kode Program 3.18 merupakan Pseudocode yang menjelaskan mengenai

Trace 3.20 menjelaskan tentang trace dari program Fibonacci secara

Gambar 3.14 Hasil compile program fibonacci pada Dev C++

23 Program Tower Of Hanoi

Gambar 3.15 merupakan flowchart dari program utama Tower of Hanoi

Gambar 3.16 menjelaskan tentang flowchart dari program tower of hanoi

Gambar 3.17 adalah flowchart yang dibuat berdasarkan program tower of

Kode Program 3.21 merupakan pseudocode berdasarkan dari program

Kode Program 3.22 adalah pseudocode program tower of hanoi secara

92. hanoi_rek (disk-1,bantu,dari,ke);

Kode program 3.24 merupakan sintaks dari program tower of hanoi.

Kode Program 3.25 menjelaskan tentang trace dari program tower of

Program Faktor Persekutuan Terbesar (FPB)

Gambar 3.19 adalah flowchart yang dibuat berdasarkan pada program

Kode Program 3.26 menjelaskan tentang program FPB dengan

Kode program 3.27 merupakan Pseudocode dari program FPB secara

Kode program 3.28 merupakan Pseudocode dari program FPB secara

Kode program 3.29 merupakan sintaks dari program FPB dengan

Gambar 3.22 Hasil compile program FPB pada Dev C++

Program Bangun Datar

Gambar 3.23 menjelaskan tentang flowchart bangun datar, dalam program

Gambar 3.24 diatas menjelaskan mengenai flowchart dari fungsi luas

Gambar 3.25 Flowchart program keliling bangun datar persegi panjang

Gambar 3.25 diatas menjelaskan mengenai flowchart dari fungsi keliling

Gambar 3.26 diatas menjelaskan mengenai flowchart dari fungsi luas

Gambar 3.27 Flowchart program keliling bangun datar segitiga sembarang

Gambar 3.27 diatas menjelaskan mengenai flowchart dari fungsi keliling

Gambar 3.28 diatas menjelaskan mengenai flowchart ldari fungsi uas

Gambar 3.29 Flowchart program keliling bangun datar lingkaran

Gambar 3.6 Hasil compile program zodiak pada Dev C++

Gambar 3.10 Hasil compile program zodiak pada Dev C++

Gambar 3.12 Flowchart fibonacci rekursif

Gambar 3.14 Hasil compile program fibonacci pada Dev C++

Gambar 3.22 Hasil compile program FPB pada Dev C++

Gambar 3.25 Flowchart program keliling bangun datar persegi panjang

Gambar 3.27 Flowchart program keliling bangun datar segitiga sembarang

Gambar 3.29 Flowchart program keliling bangun datar lingkaran

Gambar 3.31 Flowchart program keliling bangun datar trapesium

Gambar 3.33 Flowchart program keliling bangun datar jajargenjang

Kode Program 3.34 Pseudocode luas segitiga sembarang

Kode Program 3.44 Trace program bangun datar segitiga sembarang

Kode Program 3.45 Trace program bangun datar lingkaran

Gambar 3.36 Hasil compile program lingkaran pada Dev C++

Gambar 3.38 Hasil compile program jajargenjang pada Dev C++

Gambar 3.41 Flowchart program bangun ruang bola

Gambar 3.43 Flowchart program bangun ruang prisma segitiga

Gambar 3.46 Hasil compile program bola pada Dev C++

Gambar 3.49 Hasil compile program tabung pada Dev C++

Gambar 3.52 Flowchart prosedur inArray()

Gambar 3.53 Flowchart prosedur outArray()

Gambar 3.58 Flowchart prosedur binarySearch()

Gambar 3.65 Flowchart prosedur output_matriks()

Gambar 3.66 Flowchart prosedur penjumlahan()