Monday, December 26, 2016

Bab 3. Soal & Penyelesaian C++


ARRAY





Soal & Penyelesaian
1.       Demonstrasikanlah penggunaan sebuah array integer.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//arrayInteger.cpp
#include <iostream>
#include <conio.h>

int main()
{
    int arrayKu[5]; // Array memuat 5 integer
    int i;
    for ( i=0; i<5; i++) // 0-4
    {
        std::cout << "Nilai untuk arrayKu[" << i << "]: ";
        std::cin >> arrayKu[i];
    }

    for (i = 0; i<5; i++)
        std::cout << i << ": " << arrayKu[i] << std::endl;

    getch();
    return 0;
}

Nilai untuk arrayKu[0]: 12
Nilai untuk arrayKu[1]: 23
Nilai untuk arrayKu[2]: 32
Nilai untuk arrayKu[3]: 34
Nilai untuk arrayKu[4]: 54
0: 12
1: 23
2: 32
3: 34
4: 54

2.       Demonstrasikanlah penggunaan const dan enum dalam array.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//ConstEnumArray.cpp
#include <iostream>
#include <conio.h>

int main()
{
    enum Hari2Minggu { Mggu, Senin, Selasa, Rabu, Kamis, Jumat, Sabtu, HariDlmMnggu };
    int ArrayMinggu[HariDlmMnggu] = { 10, 20, 30, 40, 50, 60, 70 };

    std::cout << "Nilai pada Selasa adalah: " << ArrayMinggu[Selasa];

    getch();
    return 0;
}

Nilai pada Selasa adalah: 30

3.       Demonstrasikanlah bagaimana membuat sebuah array yang berisi objek-objek.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//ArrayIsiObjek.cpp
#include <iostream>
#include <conio.h>
using namespace std;

class Kucing
{
public:
    Kucing() { umurNya = 1; beratNya=5; }
    ~Kucing() {}
    int GetUmur() const { return umurNya; }
    int GetBerat() const { return beratNya; }
    void SetUmur(int umur) { umurNya = umur; }

private:
    int umurNya;
    int beratNya;
};

int main()
{
    Kucing arrayKucing[5];
    int i;
    for (i = 0; i < 5; i++)
        arrayKucing[i].SetUmur(2*i +1);

    for (i = 0; i < 5; i++)
    {
        cout << "Kucing #" << i+1<< ": ";
        cout << arrayKucing[i].GetUmur() << endl;
    }

    getch();
    return 0;
}

Kucing #1: 1
Kucing #2: 3
Kucing #3: 5
Kucing #4: 7
Kucing #5: 9

4.       Tulislah sebuah program C++ untuk menciptakan suatu array dua-dimensi.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//ArrayDuaDimensi.cpp
#include <iostream>
#include <conio.h>
using namespace std;

int main()
{
    int Array2D[2][5] = { {0,1,2,3,4}, {0,2,4,6,8}};
    for (int i = 0; i<2; i++)
    {
        for (int j=0; j<5; j++)
        {
            cout << "Array2D[" << i << "][" << j << "]: ";
            cout << Array2D[i][j]<< endl;
        }
    }

    getch();
    return 0;
}

Array2D[0][0]: 0
Array2D[0][1]: 1
Array2D[0][2]: 2
Array2D[0][3]: 3
Array2D[0][4]: 4
Array2D[1][0]: 0
Array2D[1][1]: 2
Array2D[1][2]: 4
Array2D[1][3]: 6
Array2D[1][4]: 8

5.       Demonstrasikanlah bagaimana menciptakan sebuah array yang memuat pointer-pointer.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//ArrayPointer.cpp
#include <iostream>
#include <conio.h>
using namespace std;

class Kucing
{
public:
    Kucing() { umurNya = 1; beratNya=5; }
    ~Kucing() {} // destruktor
    int GetUmur() const { return umurNya; }
    int GetBerat() const { return beratNya; }
    void SetUmur(int umur) { umurNya = umur; }

private:
    int umurNya;
    int beratNya;
};

int main()
{
    Kucing * Famili[500];
    int i;
    Kucing * pKucing;
    for (i = 0; i < 500; i++)
    {
        pKucing = new Kucing;
        pKucing->SetUmur(2*i +1);
        Famili[i] = pKucing;
    }

    for (i = 0; i < 500; i++)
    {
        cout << "Kucing #" << i+1 << ": ";
        cout << Famili[i]->GetUmur() << endl;
    }

    getch();
    return 0;
}

Kucing #202: 403
Kucing #203: 405
Kucing #204: 407
…
Kucing #497: 993
Kucing #498: 995
Kucing #499: 997
Kucing #500: 999

6.       Demonstrasikanlah bagaimana menciptakan sebuah array menggunakan operator new.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//newUntukArray.cpp
#include <iostream>
#include <conio.h>

class Kucing
{
public:
    Kucing() { umurNya = 1; beratNya=5; }
    ~Kucing();
    int GetUmur() const { return umurNya; }
    int GetBerat() const { return beratNya; }
    void SetUmur(int umur) { umurNya = umur; }

private:
    int umurNya;
    int beratNya;
};

Kucing :: ~Kucing()
{
    // std::cout << "Destruktor dipanggil!\n";
}

int main()
{
    Kucing * Famili = new Kucing[500];
    int i;

    for (i = 0; i < 500; i++)
    {
       Famili[i].SetUmur(2*i +1);
    }

    for (i = 0; i < 500; i++)
    {
        std::cout << "Kucing #" << i+1 << ": ";
        std::cout << Famili[i].GetUmur() << std::endl;
    }

    delete [] Famili;

    getch();
    return 0;
}

Kucing #202: 403
Kucing #203: 405
Kucing #204: 407
…
Kucing #497: 993
Kucing #498: 995
Kucing #499: 997
Kucing #500: 999

7.       Demonstrasikanlah bagaimana mengalokasikan array pada saat runtime.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//AlokasiArrayRunTime.cpp
#include <iostream>
#include <conio.h>

using namespace std;

int main()
{
    int UkuranAlokasi = 5;
    int *pArrayAngka = new int[UkuranAlokasi];
    int ElemenDigunakanSejauhIni = 0;
    int MaksElemenDiijinkan = UkuranAlokasi;
    int AngkaMasukan = -1;

    cout << endl << "Angka selanjutnya = ";
    cin >> AngkaMasukan;

    while ( AngkaMasukan > 0 )
    {
        pArrayAngka[ElemenDigunakanSejauhIni++] = AngkaMasukan;

        if ( ElemenDigunakanSejauhIni == MaksElemenDiijinkan )
        {
            int *pArrayBesar =
                new int[MaksElemenDiijinkan+UkuranAlokasi];

            for ( int SalinIndeks = 0;
            SalinIndeks < MaksElemenDiijinkan;
            SalinIndeks++ )
            {
                pArrayBesar[SalinIndeks] = pArrayAngka[SalinIndeks];
            };

            delete [] pArrayAngka;
            pArrayAngka = pArrayBesar;
            MaksElemenDiijinkan+= UkuranAlokasi;
        };
        cout << endl << "Angka selanjutnya = ";
        cin >> AngkaMasukan;
    }

    for (int Indeks = 0; Indeks < ElemenDigunakanSejauhIni; Indeks++)
    {
        cout << pArrayAngka[Indeks] << endl;
    }

    getch();
    return 0;
}

Angka selanjutnya = 12

Angka selanjutnya = 23

Angka selanjutnya = 32

Angka selanjutnya = 34

Angka selanjutnya = 54

Angka selanjutnya = 55

Angka selanjutnya = 0
12
23
32
34
54
55

8.       Demonstrasikanlah bagaimana menggunakan kelas String.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
//gunakanKelasString.cpp
#include <iostream>
#include <string.h>
#include <conio.h>
using namespace std;

// kelas String sederhana
class String
{
public:
    // konstruktor
    String();
    String(const char *const);
    String(const String &);
    ~String();

    // operator teroverload
    char & operator[](unsigned short offset);
    char operator[](unsigned short offset) const;
    String operator+(const String&);
    void operator+=(const String&);
    String & operator= (const String &);

    // aksesor umum
    unsigned short GetPanjang()const { return pjgNya; }
    const char * GetString() const { return stringNya; }

private:
    String (unsigned short); // konstruktor private
    char * stringNya;
    unsigned short pjgNya;
};

// konstruktor default menciptakan string 0 byte
String::String()
{
    stringNya = new char[1];
    stringNya[0] = '\0';
    pjgNya=0;
}

// konstruktor private (penolong) constructor, hanya digunakan
// oleh metode kelas untuk menciptakan sebuah string baru
// dengan ukuran yang diminta. Diisi dengan null
String::String(unsigned short pjg)
{
    stringNya = new char[pjg+1];
    for (unsigned short i = 0; i<=pjg; i++)
        stringNya[i] = '\0';
    pjgNya=pjg;
}

// Mengkonversi sebuah array karakter menjadi String
String::String(const char * const cString)
{
    pjgNya = strlen(cString);
    stringNya = new char[pjgNya+1];

       for (unsigned short i = 0; i<pjgNya; i++)
        stringNya[i] = cString[i];
    stringNya[pjgNya]='\0';
}

// konstruktor penyalin
String::String (const String & rhs)
{
    pjgNya=rhs.GetPanjang();
    stringNya = new char[pjgNya+1];

       for (unsigned short i = 0; i<pjgNya;i++)
        stringNya[i] = rhs[i];
    stringNya[pjgNya] = '\0';
}

// destruktor, membebaskan memori yang dipakai
String::~String ()
{
    delete [] stringNya;
    pjgNya = 0;
}

// operator =, membebaskan memori yang dipakai
// kemudian menyalin string dan ukurannya
String& String::operator=(const String & rhs)
{
    if (this == &rhs)
        return *this;
    delete [] stringNya;

       pjgNya=rhs.GetPanjang();
    stringNya = new char[pjgNya+1];

    for (unsigned short i = 0; i<pjgNya;i++)
        stringNya[i] = rhs[i];

    stringNya[pjgNya] = '\0';
    return *this;
}

char & String::operator[](unsigned short offset)
{
    if (offset > pjgNya)
        return stringNya[pjgNya-1];
    else
        return stringNya[offset];
}

char String::operator[](unsigned short offset) const
{
    if (offset > pjgNya)
        return stringNya[pjgNya-1];
    else
        return stringNya[offset];
}

String String::operator+(const String& rhs)
{
    unsigned short pjgTotal = pjgNya + rhs.GetPanjang();
    String temp(pjgTotal);
    unsigned short i;

    for ( i= 0; i<pjgNya; i++)
        temp[i] = stringNya[i];
    for (unsigned short j = 0; j<rhs.GetPanjang(); j++, i++)
        temp[i] = rhs[j];

    temp[pjgTotal]='\0';
    return temp;
}

// mengubah string sekarang, tidak menghasilkan apapun
void String::operator+=(const String& rhs)
{
    unsigned short pjgRhs = rhs.GetPanjang();
    unsigned short pjgTotal = pjgNya + pjgRhs;
    String temp(pjgTotal);
    unsigned short i;

    for (i = 0; i<pjgNya; i++)
        temp[i] = stringNya[i];

    for (unsigned short j = 0; j<rhs.GetPanjang(); j++, i++)
        temp[i] = rhs[i-pjgNya];

       temp[pjgTotal]='\0';
    *this = temp;
}

int main()
{
    String s1("uji awal");
    cout << "S1:\t" << s1.GetString() << endl;

    char * temp = "Teknik Elektro";
    s1 = temp;
    cout << "S1:\t" << s1.GetString() << endl;

    char tempDua[20];
    strcpy_s(tempDua,"; Selamat Datang!");
    s1 += tempDua;
    cout << "tempDua:\t" << tempDua << endl;
    cout << "S1:\t" << s1.GetString() << endl;

    cout << "S1[4]:\t" << s1[4] << endl;
    s1[4]='x';
    cout << "S1:\t" << s1.GetString() << endl;

    cout << "S1[999]:\t" << s1[999] << endl;

    String s2(" String lainnya");
    String s3;
    s3 = s1+s2;
    cout << "S3:\t" << s3.GetString() << endl;

    String s4;
    s4 = "Ini bisa dilakukan?";
    cout << "S4:\t" << s4.GetString() << endl;

    getch();
    return 0;
}

S1:     uji awal
S1:     Teknik Elektro
tempDua:        ; Selamat Datang!
S1:     Teknik Elektro; Selamat Datang!
S1[4]:  i
S1:     Teknxk Elektro; Selamat Datang!
S1[999]:        !
S3:     Teknxk Elektro; Selamat Datang! String lainnya
S4:     Ini bisa dilakukan?

9.       Tulislah sebuah program C++ yang mengimplementasikan array untuk mencari nilai elemen tertinggi dan selisih dari tiap elemen terhadap nilai elemen tertinggi tersebut.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//ArrayElemenTertinggi.cpp
//Membaca 5 skor dan menunjukkan bagaimana setiap skor
//berbeda dari skor tertinggi
#include <iostream>
#include <conio.h>
using namespace std;

int main( )
{
    using namespace std;
    int i, skor[5], maks;
    cout << "Masukkan 5 skor:\n";
    cin >> skor[0];
    maks = skor[0];

    for (i = 1; i < 5; i++)
    {
        cin >> skor[i];
        if (skor[i] > maks)
            maks = skor[i];
            //maks merupakan elemen tertinggi dari skor[0],..., skor[i]
    }

    cout << "Skor tertinggi adalah " << maks << endl
         << "Daftar skor dan selisihnya dari \n"
         << "skor tertinggi adalah:\n";

    for (i = 0; i < 5; i++)
        cout << skor[i] << ", selisih dari elemen tertinggi adalah: "                     
             << (maks - skor[i]) << endl;

    getch();
    return 0;
}

Masukkan 5 skor:
23
43
45
56
76
Skor tertinggi adalah 76
Daftar skor dan selisihnya dari
skor tertinggi adalah:
23, selisih dari elemen tertinggi adalah: 53
43, selisih dari elemen tertinggi adalah: 33
45, selisih dari elemen tertinggi adalah: 31
56, selisih dari elemen tertinggi adalah: 20
76, selisih dari elemen tertinggi adalah: 0

10.    Demonstrasikanlah penginisialisasian (pemberian nilai) array dengan cara yang konvensional.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//InisialisasiArray.cpp
//mendemonstrasikan penginisialisasian array
#include <iostream>
#include <conio.h>
using namespace std;

int main()
{
    int arr[100];        //array
    int jumElemen = 0;   //jumlah item pada array
    int j;               //kounter loop
    int kunciPencarian;  //key of item to search for

    arr[0] = 77; //menyisipkan 10 item
    arr[1] = 99;
    arr[2] = 44;
    arr[3] = 55;
    arr[4] = 22;
    arr[5] = 88;
    arr[6] = 11;
    arr[7] = 00;
    arr[8] = 66;
    arr[9] = 33;
    jumElemen = 10; //sekarang 10 item pada array

    for(j=0; j<jumElemen; j++) //menampilkan item-item
        cout << arr[j] << " ";
    cout << endl;

    kunciPencarian = 66; //mencari item dengan kunci 66

    for(j=0; j<jumElemen; j++) //untuk setiap elemen,
        if(arr[j] == kunciPencarian) //menemukan item?
            break; //ya, keluar sebelum end

    if(j == jumElemen) //di akhir?
        cout << "Tidak ditemukan " << kunciPencarian << endl;
    else
        cout << "Ditemukan " << kunciPencarian << endl;

    kunciPencarian = 55; //menghapus item dengan kunci 55
    cout << "Menghapus... " << kunciPencarian << endl;

    for(j=0; j<jumElemen; j++) //mencari item 55
        if(arr[j] == kunciPencarian)
            break;
    for(int k = j; k<jumElemen; k++) //memindahkan ke bawah
        arr[k] = arr[k+1];
    jumElemen--; //mendekremen jumElemen

    for(j=0; j<jumElemen; j++) //menampilkan setiap item
        cout << arr[j] << " ";
    cout << endl;
   
       getch();
       return 0;
} //akhir main()

77 99 44 55 22 88 11 0 66 33
Ditemukan 66
Menghapus... 55
77 99 44 22 88 11 0 66 33

11.    Tuliskanlah sebuah program C++ dimana variabel berindeks dijadikan sebagai argumen.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//VariabelBerindeksSbgArgumen.cpp
//Mengilustrasikan penggunaan variabel berindeks sebagai argumen.
//Menambahkan 5 pada jumlah hari libur untuk tiap karyawan.
#include <iostream>
#include <conio.h>

const int JUMLAH_KARYAWAN = 3;
int ubah_hari(int hari_lama);
//Menghasilkan jumlah hari libut ditambah 5.

int main( )
{
    using namespace std;
    int libur[JUMLAH_KARYAWAN], angka;

    cout << "Masukkan jumlah hari libur untuk karyawan 1"
         << " sampai karyawan " << JUMLAH_KARYAWAN << ":\n";

    for (angka = 1; angka <= JUMLAH_KARYAWAN; angka++)
        cin >> libur[angka-1];

    for (angka = 0; angka < JUMLAH_KARYAWAN; angka++)
        libur[angka] = ubah_hari(libur[angka]);
    cout << "Jumlah libur yang direvisi:\n";

    for (angka = 1; angka <= JUMLAH_KARYAWAN; angka++)
        cout << "Nomor karyawan " << angka
             << " jumlah hari libur = " << libur[angka-1] << endl;
      
       getch();
    return 0;
 }

 int ubah_hari(int hari_lama)
 {
     return (hari_lama + 5);
 }

Masukkan jumlah hari libur untuk karyawan 1 sampai karyawan 3:
15
14
16
Jumlah libur yang direvisi:
Nomor karyawan 1 jumlah hari libur = 20
Nomor karyawan 2 jumlah hari libur = 19
Nomor karyawan 3 jumlah hari libur = 21

12.    Organisasikanlah kasus pada nomor 2 dalam sebuah kelas.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
//InisialisasiArrayKelas.cpp
//mendemonstrasikan KelasArray
#include <iostream>
#include <vector>
#include <conio.h>
using namespace std;

class KelasArray
{
    private:
        vector<double> v; //vector memuat nilai-nilai double

    public:
        KelasArray(int maks)  //konstruktor
        { v.resize(maks); }   //mengubah ukuran vector

        void setElem(int indeks, double nilai) //menempatkan elemen ke
        { v[indeks] = nilai; }                 //dalam array, pada indeks

        double getElem(int indeks) //membaca elemen dari
        { return v[indeks]; }      //array, pada indeks
}; //akhir dari KelasArray

int main()
{
    KelasArray arr(100); //menciptakan sebuah KelasArray
    int jumElemen = 0;   //jumlah item
    int j;               //variabel loop

    arr.setElem(0, 77); //menyisipkan 10 item
    arr.setElem(1, 99);
    arr.setElem(2, 44);
    arr.setElem(3, 55);
    arr.setElem(4, 22);
    arr.setElem(5, 88);
    arr.setElem(6, 11);
    arr.setElem(7, 00);
    arr.setElem(8, 66);
    arr.setElem(9, 33);
    jumElemen = 10; //sekarang 10 item dalam array

    for(j=0; j<jumElemen; j++) //menampilkan setiap item
        cout << arr.getElem(j) << " ";
    cout << endl;

    int kunciPencarian = 26; //mencari item dengan nilai 26
    for(j=0; j<jumElemen; j++) //untuk setiap elemen,
        if(arr.getElem(j) == kunciPencarian) //ditemukan?
            break;

    if(j == jumElemen) //tidak
        cout << "Tidak menemukan " << kunciPencarian << endl;
    else //ya
        cout << "Menemukan" << kunciPencarian << endl;

    double kunciPenghapusan = 55; //menghapus item dengan nilai 55
    cout << "Menghapus elemen " << kunciPenghapusan << endl;

    for(j=0; j<jumElemen; j++) //mencari
        if(arr.getElem(j) == kunciPenghapusan)
            break;

    for(int k = j; k<jumElemen; k++) //memindahkan tiap elemen mulai dari indeks j ke bawah
        arr.setElem(k, arr.getElem(k+1) );
    jumElemen--; //mendekremen

    for(j=0; j<jumElemen; j++) //menampilkan tiap item
        cout << arr.getElem(j) << " ";
    cout << endl;

    getch();
    return 0;
} //akhir main()

77 99 44 55 22 88 11 0 66 33
Ditemukan 66
Menghapus... 55
77 99 44 22 88 11 0 66 33

13.    Perbaikilah kelas pada soal sebelumnya sehingga menjadi lebih terstruktur.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
//InisialisasiKelasArrayBaik.cpp
//Mendemonstrasikan kelas array dengan lebih baik
#include <iostream>
#include <vector>
#include <conio.h>
using namespace std;

class KelasArrayBaik
{
    private:
        vector<double> v; //vector v
        int jumElemen;    //jumlah item

    public:
        KelasArrayBaik() : jumElemen(0) //konstruktor default
        { }

        KelasArrayBaik(int maks) : jumElemen(0) //konstruktur satu-argumen
        { v.resize(maks); } //mengubah ukuran vektor

        bool cari(double kunciPencarian) //mencari nilai tertentu
        {
            int j;
            for(j=0; j<jumElemen; j++) //untuk tiap elemen,
                if(v[j] == kunciPencarian) //menemukan?
                    break; //keluar loop sebelum end
           
             if(j == jumElemen) //sampai akhir?
                 return false; //tidak bisa menemukannya
                 
             else
                return true; //menemukannya
        } //akhir cari()

        void sisip(double nilai) //menempatkan elemen ke dalam array
        {
            v[jumElemen] = nilai; //menyisipkan
            jumElemen++; //menginkremen
        }

        bool hapus(double nilai) //menghapus elemen dari array
        {
            int j;
            for(j=0; j<jumElemen; j++) //mencari
                if( nilai == v[j] )
                    break;

            if(j==jumElemen) //tidak menemukannya
                return false;
            else //menemukannya
            {
                for(int k=j; k<jumElemen; k++) //memindahkan ke bawah
                    v[k] = v[k+1];
               
                jumElemen--; // mendekreman
                return true;
            }
        } //akhir hapus()

        void tampil() //menampilkan isi array
        {
            for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
                cout << v[j] << " "; //menampilkan
            cout << endl;
        }
}; //akhir kelas KelasArrayBaik

int main()
{
    int ukuranMaks = 100; //ukuran array
    KelasArrayBaik arr(ukuranMaks); //vector

    arr.sisip(77); //menyisipkan 10 item
    arr.sisip(99);
    arr.sisip(44);
    arr.sisip(55);
    arr.sisip(22);
    arr.sisip(88);
    arr.sisip(11);
    arr.sisip(0);
    arr.sisip(66);
    arr.sisip(33);
    arr.tampil(); //menampilkan item-item

    int kunciPencarian = 35; //mencari item dengan nilai 25

    if( arr.cari(kunciPencarian) )
        cout << "Menemukan " << kunciPencarian << endl;
    else
        cout << "Tidak menemukan " << kunciPencarian << endl;
   
    cout << "Menghapus 0, 55, dan 99" << endl;
    arr.hapus(0); //menghapus 3 item
    arr.hapus(55);
    arr.hapus(99);
    arr.tampil(); //menampilkan item-item kembali

       getch();
       return 0;
} //akhir main()

77 99 44 55 22 88 11 0 66 33
Tidak menemukan 35
Menghapus 0, 55, dan 99
77 44 22 88 11 66 33

14.    Tulislah sebuah program yang mengisi array secara parsial.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
//IsiArrayParsial.cpp
//Menunjukkan selisih tiap skor golf dan reratanya.
#include <iostream>
#include <conio.h>
const int JUM_SKOR_MAKS = 10;

void isi_array(int a[], int ukuran, int& banyak_digunakan);
//Prakondisi: ukuran merupakan ukuran dari array a.
//Pascakondisi: banyak_digunakan merupakan banyaknya nilai disimpan dalam a.
//a[0] sampai a[banyak_digunakan− 1] telah terisi dengan
//integer-integer tak-negatif dari keyboard.

double hitung_rerata(const int a[], int banyak_digunakan);
//Prakondisi: a[0] sampai a[banyak_digunakan− 1] memiliki nilai-nilai;
//banyak_digunakan > 0.
//Menghasilkan rerata dari a[0] sampai a[banyak_digunakan− 1].

void tampil_selisih(const int a[], int banyak_digunakan);
//Prakondisi: Sejumlah banyak_digunakan dari variabel berindeks yang memiliki nilai.
//Pascakondisi: Menampilkan berapa banyak dari
//banyak_digunakan elemen pertama yang berbeda dari reratanya.

int main( )
{
    using namespace std;
    int skor[JUM_SKOR_MAKS], banyak_digunakan;
    cout << "Program ini membaca skor golf dan menampilkan\n"
         << "berapa banyak tiap skor berbeda dari rerata.\n";

    cout << "Masukkan skor golf:\n";
    isi_array(skor, JUM_SKOR_MAKS, banyak_digunakan);
    tampil_selisih(skor, banyak_digunakan);

    getch();
    return 0;
}

void isi_array(int a[], int ukuran, int& banyak_digunakan)
{
    using namespace std;
    cout << "Masukkan sampai " << ukuran << " buah integer tak-negatif.\n"
         << "Akhiri dengan sebuah integer negatif.\n";
   
    int brktnya, indeks = 0;
    cin >> brktnya;
    while ((brktnya >= 0) && (indeks < ukuran))
    {
        a[indeks] = brktnya;
        indeks++;
        cin >> brktnya;
    }
    banyak_digunakan = indeks;
}

double hitung_rerata(const int a[], int banyak_digunakan)
{
    double total = 0;
    for (int indeks = 0; indeks < banyak_digunakan; indeks++)
        total = total + a[indeks];

    if (banyak_digunakan > 0)
    {
        return (total/banyak_digunakan);
    }
    else
    {
        using namespace std;
        cout << "ERROR: jumlah elemen adalah 0 dalam hitung_rerata.\n"
             << "hitung_rerata menghasilkan 0.\n";
        return 0;
    }
}

void tampil_selisih(const int a[], int banyak_digunakan)
{
    using namespace std;
    double rerata = hitung_rerata(a, banyak_digunakan);
   
       cout << "Rerata dari " << banyak_digunakan
         << " skor = " << rerata << endl
               << "Skor-skor:\n";

    for (int indeks = 0; indeks < banyak_digunakan; indeks++)
        cout << a[indeks] << " berbeda dari rerata sejauh "
             << (a[indeks] - rerata) << endl;
}

Akhiri dengan sebuah integer negatif.
23
34
43
32
33
24
25
26
26
27
-1
Rerata dari 10 skor6 = 29.3
Skor-skor:
23 berbeda dari rerata sejauh -6.3
34 berbeda dari rerata sejauh 4.7
43 berbeda dari rerata sejauh 13.7
32 berbeda dari rerata sejauh 2.7
33 berbeda dari rerata sejauh 3.7
24 berbeda dari rerata sejauh -5.3
25 berbeda dari rerata sejauh -4.3
26 berbeda dari rerata sejauh -3.3
26 berbeda dari rerata sejauh -3.3
27 berbeda dari rerata sejauh -2.3

15.    Tulislah sebuah program C++ untuk melakukan pencarian pada suatu array.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
//pencarianArray.cpp
//Melakukan pencarian pada suatu array dengan elemen-elemen tak-negatif.
#include <iostream>
#include <conio.h>
const int UKURAN_DIDEKLARASIKAN = 20;

void isi_array(int a[], int ukuran, int& banyak_digunakan);
//Prakondisi: ukuran merupakan ukuran dari array a.
//Pascakondisi: banyak_digunakan merupakan banyaknya nilai disimpan dalam a.
//a[0] sampai a[banyak_digunakan− 1] telah terisi dengan
//integer-integer tak-negatif dari keyboard.

int cari(const int a[], int banyak_digunakan, int target);
//Prakondisi: banyak_digunakan <= ukuran dari a.
//Juga, a[0] sampai a[banyak_digunakan −1] memiliki nilai-nilai.
//Menghasilkan indeks pertama sehingga a[indeks] == target,
//jika tidak ditemukan menghasilkan −1.

int main( )
{
    using namespace std;
    int arr[UKURAN_DIDEKLARASIKAN], ukuran_daftar, target;

       isi_array(arr, UKURAN_DIDEKLARASIKAN, ukuran_daftar);
    char jwb;
    int hasil;

    do
    {
        cout << "Masukkan sebuah angka yang akan dicari: ";
        cin >> target;
        hasil = cari(arr, ukuran_daftar, target);

        if (hasil == -1)
            cout << target << " tidak ada dalam daftar.\n";
        else
            cout << target << " disimpan dalam array pada posisi "
                 << hasil << endl
                 << "(Ingat: Posisi pertama adalah 0.)\n";

        cout << "cari lagi?(y/t kemudian tekan ENTER): ";
        cin >> jwb;
    }while ((jwb != 't') && (jwb != 'T'));
   
    cout << "Akhir program.\n";

    getch();
    return 0;
}

void isi_array(int a[], int ukuran, int& banyak_digunakan)
{
    using namespace std;
    cout << "Masukkan sampai " << ukuran << " buah integer tak-negatif.\n"
         << "Akhiri dengan sebuah integer negatif.\n";
   
    int brktnya, indeks = 0;
    cin >> brktnya;

    while ((brktnya >= 0) && (indeks < ukuran))
    {
        a[indeks] = brktnya;
        indeks++;
        cin >> brktnya;
    }

    banyak_digunakan = indeks;
}

int cari(const int a[], int banyak_digunakan, int target)
{
    int indeks = 0;
    bool ditemukan = false;

    while ((!ditemukan) && (indeks < banyak_digunakan))
        if (target == a[indeks])
            ditemukan = true;
        else
            indeks++;

    if (ditemukan)
        return indeks;
    else
   
    return -1;
 }

Masukkan sampai 20 buah integer tak-negatif.
Akhiri dengan sebuah integer negatif.
23 43 54 65 67 87 76 65 56 54 56 76 86 -1

Masukkan sebuah angka yang akan dicari: 87
87 disimpan dalam array pada posisi 5
(Ingat: Posisi pertama adalah 0.)

cari lagi?(y/t kemudian tekan ENTER): y
Masukkan sebuah angka yang akan dicari: 67
67 disimpan dalam array pada posisi 4
(Ingat: Posisi pertama adalah 0.)

cari lagi?(y/t kemudian tekan ENTER): y
Masukkan sebuah angka yang akan dicari: 87
87 disimpan dalam array pada posisi 5
(Ingat: Posisi pertama adalah 0.)

cari lagi?(y/t kemudian tekan ENTER): y
Masukkan sebuah angka yang akan dicari: 54
54 disimpan dalam array pada posisi 2
(Ingat: Posisi pertama adalah 0.)

cari lagi?(y/t kemudian tekan ENTER): t
Akhir program.

16.    Tulislah sebuah program C++ untuk melakukan pengurutan terhadap suatu array.
Penyelesaian:
Ilustrasi pengurutan yang dilakukan adalah sebagai berikut:



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
//MengurutkanArray.cpp
//Menguji prosedur pengurutan array.
#include <iostream>
#include <conio.h>

void isi_array(int a[], int ukuran, int& banyak_digunakan);
//Prakondisi: ukuran merupakan ukuran dari array a.
//Pascakondisi: banyak_digunakan merupakan banyaknya nilai disimpan dalam a.
//a[0] sampai a[banyak_digunakan− 1] telah terisi dengan
//integer-integer tak-negatif dari keyboard.

void urut(int a[], int banyak_digunakan);
//Prakondisi: banyak_digunakan <= ukuran dari array a.
//Elemen-elemen array a[0] sampai a[banyak_digunakan − 1] memiliki nilai-nilai.
//Pascakondisi: Nilai dari a[0] sampai a[banyak_digunakan − 1] ditata
//sehingga a[0] <= a[1] <= ... <= a[banyak_digunakan − 1].

void tukar_nilai(int& v1, int& v2);
//Saling-menukar nilai v1 dan v2.

int indeks_terkecil(const int a[], int indekas_awal, int banyak_digunakan);
//Prakondisi: 0 <= indekas_awal < banyak_digunakan.
//Menghasilkan indeks i sehingga a[i] adalah nilai terkecil
//a[indekas_awal], a[indekas_awal + 1], ..., a[banyak_digunakan − 1].

int main( )
{
    using namespace std;
    cout << "Program ini mengurutkan angka-angka dari terkecil sampai terbesar.\n";

    int sample_array[10], banyak_digunakan;
    isi_array(sample_array, 10, banyak_digunakan);

    urut(sample_array, banyak_digunakan);
    cout << "Dalam tatanan terurut, angka-angka tersebut adalah:\n";

    for (int indeks = 0; indeks < banyak_digunakan; indeks++)
        cout << sample_array[indeks] << " ";
    cout << endl;

    getch();
    return 0;
}

void isi_array(int a[], int ukuran, int& banyak_digunakan)
{
    using namespace std;
    cout << "Masukkan sampai " << ukuran << " buah integer tak-negatif.\n"
         << "Akhiri dengan sebuah integer negatif.\n";
   
    int brktnya, indeks = 0;
    cin >> brktnya;

    while ((brktnya >= 0) && (indeks < ukuran))
    {
        a[indeks] = brktnya;
        indeks++;
        cin >> brktnya;
    }

    banyak_digunakan = indeks;
}

void urut(int a[], int banyak_digunakan)
{
    int indeks_dekat_terkecil;

    for (int indeks = 0; indeks < banyak_digunakan - 1; indeks++)
    {//Menempatkan nilai yang tepat pada a[indeks]:
        indeks_dekat_terkecil =
            indeks_terkecil(a, indeks, banyak_digunakan);

        tukar_nilai(a[indeks], a[indeks_dekat_terkecil]);
        //a[0] <= a[1] <=...<= a[indeks] adalah elemen-elemen terkecil pada
        //array semula. Sisa elemen pada posisi lainnya.
    }
}

void tukar_nilai(int& v1, int& v2)
{
    int temp;
    temp = v1;
    v1 = v2;
    v2 = temp;
}

int indeks_terkecil(const int a[], int indekas_awal, int banyak_digunakan)
{
    int min = a[indekas_awal],
    indeks_of_min = indekas_awal;

    for (int indeks = indekas_awal + 1; indeks < banyak_digunakan; indeks++)
        if (a[indeks] < min)
        {
            min = a[indeks];
            indeks_of_min = indeks;
            //min adalah yang terkecil dari a[indekas_awal] sampai a[indeks]
        }

    return indeks_of_min;
}

Program ini mengurutkan angka-angka dari terkecil sampai terbesar.
Masukkan sampai 10 buah integer tak-negatif.
Akhiri dengan sebuah integer negatif.
12 32 344 32 21 32 21 23 34 32 -1

Dalam tatanan terurut, angka-angka tersebut adalah:
12 21 21 23 32 32 32 32 34 344

17.    Tulislah sebuah program C++ yang mengimplementasikan array dua-dimensi, dimana di dalamnya dilibatkan penghitungan rerata.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
120
121
122
123
124
125
126
127
//ArrayDuaDimensiRerata.cpp
//Menempatkan skor kuis untuk tiap mahasiswa ke dalam array dua-dimensi
//Menghitung skor rerata untuk tiap mahasiswa.
//Menghitung skor rerata untuk tiap kuis.
//Menampilkan skor kuis dan reratanya.
#include <iostream>
#include <iomanip>
#include <conio.h>
const int JUMLAH_MAHASISWA = 4, JUMLAH_KUIS = 3;

void hitung_rerata_mahasiswa(const double nilai[][JUMLAH_KUIS],   
    double rerata_mahasiswa[]);
//Prakondisi: konstanta global JUMLAH_MAHASISWA dan JUMLAH_KUIS
//merupakan dimensi dari array nilai. Tiap variabel indeks
//nilai[nomor_mahasiswa− 1, nomor_kuis− 1] memuat skor untuk
//mahasiswa nomor_mahasiswa pada nomor_kuis.
//Pascakondisi: Setiap rerata_mahasiswa[nomor_mahasiswa− 1] memuat rerata untuk
//nomor mahasiswa nomor_mahasiswa.

void hitung_rerata_kuis(const double nilai[][JUMLAH_KUIS],
    double rerata_kuis[]);
//Prakondisi: konstanta global JUMLAH_MAHASISWA dan JUMLAH_KUIS
//merupakan dimensi dari array nilai. Tiap variabel indeks
//nilai[nomor_mahasiswa− 1, nomor_kuis− 1] memuat skor untuk
//mahasiswa nomor_mahasiswa pada nomor_kuis.
//Pascakondisi: Setiap rerata_kuis[nomor_kuis− 1] memuat rerata untuk
//nomor kuis nomor_kuis.

void tampil(const double nilai[][JUMLAH_KUIS],
    const double rerata_mahasiswa[], const double rerata_kuis[]);
//Prakondisi: konstanta global JUMLAH_MAHASISWA dan JUMLAH_KUIS
//merupakan dimensi dari array nilai. Tiap variabel indeks
//nilai[nomor_mahasiswa− 1, nomor_kuis− 1] memuat skor untuk //mahasiswa nomor_mahasiswa pada nomor_kuis.
//Setiap rerata_mahasiswa[nomor_mahasiswa− 1] memuat rerata untuk
//nomor mahasiswa nomor_mahasiswa.
//Setiap rerata_kuis[nomor_kuis− 1] memuat rerata untuk
//nomor kuis nomor_kuis.
//Pascakondisi: Semua data dalam array nilai, rerata_mahasiswa,
//dan rerata_kuis akan ditampilkan.

int main( )
{
    using namespace std;
    double nilai[JUMLAH_MAHASISWA][JUMLAH_KUIS];
    double rerata_mahasiswa[JUMLAH_MAHASISWA];
    double rerata_kuis[JUMLAH_KUIS];

    nilai[0][0] = 78.5; nilai[0][1]=87.8; nilai[0][2]=76.8;
    nilai[1][0] = 88.5; nilai[1][1]=97.8; nilai[1][2]=86.8;
    nilai[2][0] = 67.2; nilai[2][1]=77.7; nilai[2][2]=66.5;
    nilai[3][0] = 88.7; nilai[3][1]=86.9; nilai[3][2]=79.7;

    hitung_rerata_mahasiswa(nilai, rerata_mahasiswa);
    hitung_rerata_kuis(nilai, rerata_kuis);
    tampil(nilai, rerata_mahasiswa, rerata_kuis);

    getch();
    return 0;
}

void hitung_rerata_mahasiswa(const double nilai[][JUMLAH_KUIS],
    double rerata_mahasiswa[])
{
    for (int nomor_mahasiswa = 1; nomor_mahasiswa <= JUMLAH_MAHASISWA; nomor_mahasiswa++)
    {//Memproses satu nomor_mahasiswa:
        double jum = 0;
        for (int nomor_kuis = 1; nomor_kuis <= JUMLAH_KUIS; nomor_kuis++)
            jum = jum + nilai[nomor_mahasiswa-1][nomor_kuis-1];

        //jum memuat penjumlahan atas tiap nilai skor
        //untuk nomor mahasiswa nomor_mahasiswa.
        rerata_mahasiswa[nomor_mahasiswa-1] = jum/JUMLAH_KUIS;
        //Rerata untuk mahasiswa nomor_mahasiswa adalah nilai
        //dari rerata_mahasiswa[nomor_mahasiswa-1]
    }
}

void hitung_rerata_kuis(const double nilai[][JUMLAH_KUIS],
    double rerata_kuis[])
{
    for (int nomor_kuis = 1; nomor_kuis <= JUMLAH_KUIS; nomor_kuis++)
    {//Memproses satu kuis (untuk semua mahasiswa):
        double jum = 0;

        for (int nomor_mahasiswa = 1; nomor_mahasiswa <=
             JUMLAH_MAHASISWA; nomor_mahasiswa++)
            jum = jum + nilai[nomor_mahasiswa-1][nomor_kuis-1];

        //jum memuat penjumlahan atas semua skor mahasiswa
        //untuk nomor kuis nomor_kuis.
        rerata_kuis[nomor_kuis-1] = jum/JUMLAH_MAHASISWA;
        //Rerata untuk kuis nomor_kuis
        //adalah nilai dari rerata_kuis[nomor_kuis-1]
    }
}

void tampil(const double nilai[][JUMLAH_KUIS], const double
    rerata_mahasiswa[], const double rerata_kuis[])
{
    using namespace std;
    cout.setf(ios::fixed);
    cout.setf(ios::showpoint);
    cout.precision(1);
    cout << setw(10) << "Mahasiswa"
         << setw(5) << "Rerata"
         << setw(15) << "Kuis\n";

    for (int nomor_mahasiswa = 1; nomor_mahasiswa <=
        JUMLAH_MAHASISWA; nomor_mahasiswa++)
    {//menampilkan untuk satu nomor_mahasiswa:
        cout << setw(10) << nomor_mahasiswa
             << setw(5) << rerata_mahasiswa[nomor_mahasiswa-1] << " ";

        for (int nomor_kuis = 1; nomor_kuis <= JUMLAH_KUIS; nomor_kuis++)
            cout << setw(5) << nilai[nomor_mahasiswa-1][nomor_kuis-1];

        cout << endl;
    }

    cout << "Rerata kuis = ";
    for (int nomor_kuis = 1; nomor_kuis <= JUMLAH_KUIS; nomor_kuis++)
        cout << setw(5) << rerata_kuis[nomor_kuis-1];

    cout << endl;
}

Mahasiswa  Rerata   Kuis
1          81.0     78.5 87.8 76.8
2          91.0     88.5 97.8 86.8
3          70.5     67.2 77.7 66.5
4          85.1     88.7 86.9 79.7

Rerata kuis =  80.7 87.6 77.5

18.    Tulislah sebuah program C++ yang melakukan pencarian, penghapusan, dan penyisipan pada sebuah array.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
//modifikasi_array.cpp
#include <iostream>
#include <vector>
#include <conio.h>
using namespace std;

class ArrayTerurut
{
    private:
        vector<double> v; //vector v
        int jumElemen;    //jumlah item data

    public:
        ArrayTerurut(int maks) : jumElemen(0) //konstruktor
        { v.resize(maks); } //ukuran vector

        int getUkuran() //menghasilkan jumlah elemen
        { return jumElemen; }

        int cari(double kunciPencarian) //pencarian Biner
        {
            int batasBawah = 0;
            int batasAtas = jumElemen-1;
            int indeksSkrg;
           
            while(true)
            {
                indeksSkrg = (batasBawah + batasAtas ) / 2;
                if(v[indeksSkrg]==kunciPencarian)
                    return indeksSkrg; //ditemukan
                else if(batasBawah > batasAtas)
                    return jumElemen; //tidak ditemukan
                else //membagi rentang
                {
                    if(v[indeksSkrg] < kunciPencarian)
                        batasBawah = indeksSkrg + 1; //di bagian atas
                    else
                        batasAtas = indeksSkrg - 1; //di bagian bawah
                } //akhir else bagi rentang
            } //akhir while
        } //akhir cari()

        void sisip(double nilai) //menempatkan elemen ke dalam array
        {
            int j;
            for(j=0; j<jumElemen; j++)
                if(v[j] > nilai) //(pencarian linier)
                    break;
           
            for(int k=jumElemen; k>j; k--) //memindahkan satu ke atas
                v[k] = v[k-1];

            v[j] = nilai; //menyisipkan
            jumElemen++; //menginkremen
        } //akhir sisip()

        bool hapus(double nilai)
        {
            int j = cari(nilai);

            if(j==jumElemen) //tidak ditemukan
                return false;
            else //ditemukan
            {
                for(int k=j; k<jumElemen; k++) //memindahkan satu ke atas
                    v[k] = v[k+1];
                jumElemen--; //mendekremen
                return true;
            }
        } //akhir hapus()

        void display() //menampilkan isi array
        {
            for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
                cout << v[j] << " "; //ditampilkan
            cout << endl;
        }
}; //akhir kelas ArrayTerurut

int main()
{
    int ukuranMaks = 100; //ukuran array
    ArrayTerurut arr(ukuranMaks); //menciptakan array

    arr.sisip(77); //menyisipkan 10 item
    arr.sisip(99);
    arr.sisip(44);
    arr.sisip(55);
    arr.sisip(22);
    arr.sisip(88);
    arr.sisip(11);
    arr.sisip(00);
    arr.sisip(66);
    arr.sisip(33);
   
    int kunciPencarian = 55; //mencari item dengan nilai 55
    if( arr.cari(kunciPencarian) != arr.getUkuran() )
        cout << "Menemukan " << kunciPencarian << endl;
    else
        cout << "Tidak menemukan " << kunciPencarian << endl;

    arr.display(); //menampilkan array
    cout << "Menghapus 0, 55, dan 99" << endl;
    arr.hapus(00); //menghapus 3 item
    arr.hapus(55);
    arr.hapus(99);
    arr.display(); //menampilkan array kembali

    getch();
    return 0;
} //akhir main()

Menemukan 55
0 11 22 33 44 55 66 77 88 99
Menghapus 0, 55, dan 99
11 22 33 44 66 77 88

19.    Tulislah sebuah program C++ yang mengimplementasikan array dan kelas, dimana elemen-elemen array adalah objek-objek dari suatu kelas.
Penyelesaian:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
//arrayObjek.cpp
//Elemen-elemen array sebagai objek-objek kelas
#include <iostream>
#include <string>
#include <vector>
#include <conio.h>
using namespace std;

class Orang
{
    private:
        string namaBelakang;
        string namaDepan;
        int usia;

    public:
        Orang(string belakang, string depan, int a) : //konstruktor
        namaBelakang(belakang), namaDepan(depan), usia(a)
        { }

        void tampilOrang()
        {
            cout << "Nama belakang: " << namaBelakang;
            cout << ", Nama depan: " << namaDepan;
            cout << ", usia: " << usia << endl;
        }

        string getBelakang() //membaca nama belakang
        { return namaBelakang; }
}; //akhir kelas Orang

class KelasDataArray
{
    private:
        vector<Orang*> v; //vector memuat pointer-pointer
        int jumElemen;    //jumlah item data

    public:
        KelasDataArray(int max) : jumElemen(0) //konstruktor
        { v.resize(max); } //menciptakan array

        ~KelasDataArray() //destruktor
        {
            for(int j=0; j<jumElemen; j++) //menghapus tiap elemen
                delete v[j];
        }

        Orang* cari(string namaDicari)
        { //mencari nilai tertentu
            int j;
            for(j=0; j<jumElemen; j++) //untuk tiap elemen,
                if( v[j]->getBelakang() == namaDicari ) //ditemukan?
                    break; //keluar loop sebelum end

            if(j == jumElemen) //sampai akhir?
                return NULL; //ya, tidak ditemukan
            else
                return v[j]; //tidak, item ditemukan
        }; //akhir cari()

              //menempatkan Orang ke dalam array
        void sisip(string belakang, string depan, int usia)
        {
            v[jumElemen] = new Orang(belakang, depan, usia);
            jumElemen++; //menginkremen
        }

        bool hapus(string namaDicari) //menghapus objek Orang dari array
        {
            int j;
            for(j=0; j<jumElemen; j++) //mencari
                if( v[j]->getBelakang() == namaDicari )
                    break;

            if(j==jumElemen) //tidak ditemukan
                return false;
            else //item ditemukan
            {
                delete v[j]; //menghapus objek Orang
                for(int k=j; k<jumElemen; k++) //menggeser ke bawah
                    v[k] = v[k+1];
                jumElemen--; //mendekreman
                return true;
            }
        } //akhir hapus()

        void tampilArray() //menampilkan isi array
        {
            for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
                v[j]->tampilOrang(); //menampilkan
        }
}; //akhir kelas KelasDataArray

int main()
{
    int ukuranMaks = 100; //ukuran array
    KelasDataArray arr(ukuranMaks); //array

    arr.sisip("Rismon", "Sianipar", 24); //sisip 10 items
    arr.sisip("Robert", "Tohonan", 37);
    arr.sisip("Rico", "Chandra", 43);
    arr.sisip("Rotua", "Marolop", 63);
    arr.sisip("Rini", "Meika", 21);
    arr.sisip("Eva", "Teti", 29);
    arr.sisip("Patricia", "Siahaan", 72);
    arr.sisip("Vivian", "Jozen", 54);
    arr.sisip("Jodi", "Pratama", 22);
    arr.sisip("Jonathan", "Sitanggang", 18);
    arr.tampilArray(); //menampilkan isi array

    string kunciPencarian = "Eva"; //mencari item
    cout << "Mencari Eva" << endl;
    Orang* ditemukan;
    ditemukan = arr.cari(kunciPencarian);

    if(ditemukan != NULL)
    {
        cout << "Ditemukan ";
        ditemukan->tampilOrang();
    }

    else
        cout << "Tidak ditemukan " << kunciPencarian << endl;

    cout << "Menghapus Rismon, Jodi, dan Rotua" << endl;
    arr.hapus("Rismon"); //menghapus 3 item
    arr.hapus("Jodi");
    arr.hapus("Rotua");
    arr.tampilArray(); //menampilkan array kembali

    getch();
    return 0;
} //akhir main()

Nama belakang: Rismon, Nama depan: Sianipar, usia: 24
Nama belakang: Robert, Nama depan: Tohonan, usia: 37
Nama belakang: Rico, Nama depan: Chandra, usia: 43
Nama belakang: Rotua, Nama depan: Marolop, usia: 63
Nama belakang: Rini, Nama depan: Meika, usia: 21
Nama belakang: Eva, Nama depan: Teti, usia: 29
Nama belakang: Patricia, Nama depan: Siahaan, usia: 72
Nama belakang: Vivian, Nama depan: Jozen, usia: 54
Nama belakang: Jodi, Nama depan: Pratama, usia: 22
Nama belakang: Jonathan, Nama depan: Sitanggang, usia: 18

Mencari Eva
Ditemukan Nama belakang: Eva, Nama depan: Teti, usia: 29

Menghapus Rismon, Jodi, dan Rotua
Nama belakang: Robert, Nama depan: Tohonan, usia: 37
Nama belakang: Rico, Nama depan: Chandra, usia: 43
Nama belakang: Rini, Nama depan: Meika, usia: 21
Nama belakang: Eva, Nama depan: Teti, usia: 29
Nama belakang: Patricia, Nama depan: Siahaan, usia: 72
Nama belakang: Vivian, Nama depan: Jozen, usia: 54
Nama belakang: Jonathan, Nama depan: Sitanggang, usia: 18





Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)