Laporan CBR Dan Analisis Studi Kasus

LAPORAN CBR DAN ANALISIS STUDI KASUS
DISUSUN GUNA MEMENUHI TUGAS MATAKULIAH STRUKTUR DATA
DOSEN PENGAMPU : Ibu Ressy Dwitias Sari,S.T.,M.T.I
KELOMPOK 3
TARISA RIANI RIZKI (5211151006)
NAZWA ZULFA (5212451004)
TIO AINAWANI (5212451005)
ANNISA RIZKI AGUSTI (5213151002)
FRILIA ARIANI (5213151005)
PROGRAM STUDI S-1 PENDIDIKAN TEKNOLOGI INFORMATIKA DAN

KOMPUTER
FAKULTAS TEKNIK
UNIVERSITAS NEGERI MEDAN
2022
1 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

KATA PENGANTAR
Puji syukur senantiasa kita panjatkan ke hadirat Tuhan yang maha Esa, yang berkuasa
atas seluruh alam semesta, karena berkat rahmat, taufik serta hidayah-Nya jugalah maka Laporan
Critical Book Review (CBR) dan analisis studi kasus mata kuliah Struktur Data ini dapat
diselesaikan tepat pada waktunya.
Kami menyadari bahwa dalam penyusunan tugas CBR ini tidak terlepas dari kesalahan
dan sangat jauh dari sempurna. Oleh sebab itu, kami sangat mengharapkan kritik dan saran yang
sifatnya membangun demi sempurnanya laporan ini. Kami berharap semoga laporan ini dapat
digunakan sebagaimana mestinya dan bisa memberikan manfaat bagi kita semua. Semoga Tuhan
yang maha Esa mencurahkan rahmat dan karunia-Nya kepada kita semua.
Medan, Maret 2022
Penyusun
Kelompok 3

DAFTAR ISI
KATA PENGANTAR ………………………………………………………. 2
DAFTAR ISI …………………………………………………………………

3
BAB I: PENDAHULUAN …………………………………………………...

4
A. Latar Belakang Pentingnya CBR ……………………………………………….…..

4
B. Tujuan Penulisan CBR ……………………………………………………………..
4
C. Manfaat CBR ……………………………………………………………………… 4
D. Identitas Buku ………………………………………………………………..……. 5
BAB II: ISI BUKU ……………………………………………………..…… 7
A. BUKU 1 ………………………………………………………………………...…. 7
B. BUKU 2 ……………………………………………………………………….…. 32
BAB III: PEMBAHASAN ……………………………………...……….….

53
BAB IV: PENUTUP ……………………………………………………..… 55
A. Kesimpulan ………………………………………………………………………. 55
B. Daftar Pustaka ………………………………………………………………….…
56

BAB I
PENDAHULUAN
A. Latar Belakang Pentingnya CBR
Critical Book Review (CBR) merupakan salah satu instrument yang dapat mendukung
keberhasilan dalam proses pembelajaran dibangku perkuliahan melalui Critical Book Review
(CBR) mahasiswa diajak untuk menguji pemikiran dari pengarang maupun penulis berdasarkan
sudut pandang yang akan di bangun oleh setiap mahasiswa berdasarkan pengetahuan &
pengalaman yang mereka miliki.
B. Tujuan Penulisan CBR
 Untuk menyelesaikan kewajiban tugas pada Mata Kuliah Struktur Data sekaligus untuk
untuk meningkatkan pengetahuan tentang SET dan MAPS .
 Untuk meningkatkan wawasan dalam bidang Struktur Data
C. Manfaat CBR
❖ Bagi Penulis :
 Memenuhi tugas mata kuliah Struktur Data

 Melatih kemampuan penulis dalam mengkritisi isi buku.
 Menumbuhkan pola pikir kreatif setelah mereview buku.
 Lebih memahami tentang SET dan MAPS serta implementasinya dalam menyelesaikan
studi Kasus..

❖ Bagi Pembaca:
 Menambah pengetahuan dan wawasan mengenai SET dan MAPS pada Struktur Data
 Dapat mengaplikasikannya secara langsung.
D. IDENTITAS BUKU
 BUKU 1
Judul Buku : Data Structures and Algorithms Using Python
Penulis : Rance D. Necaise
Penerbit : JOHN WILEY & SONS, INC.
ISBN : 978-0-470-61829-5
Tahun Terbit : 2011
Jumlah Halaman : 507

 BUKU 2
Judul Buku : Data Structures and Algorithms with Python
Penulis : Kent D. Lee Steve Hubbard
Penerbit : Springer
ISBN : 978-3-319-13071-2
Tahun Terbit : 2015
Jumlah Halaman : 361

BAB II
ISI BUKU
A. BUKU 1
 HASIL TERJEMAHAN DAN PARAFRASE
Set dan peta
1. Set

Set ADT adalah wadah yang biasa digunakan dalam ilmu komputer. Namun, tidak seperti
bagian ADT yang diperkenalkan di Bab 1, himpunan berisi nilai unik dan mewakili struktur
yang sama dengan matematika. Ini biasanya digunakan saat anda perlu menyimpan koleksi
nilai unik terlepas dari cara penyimpanannya, atau saat anda perlu melakukan operasi
himpunan matematika yang berbeda pada koleksi.
1. 1 Kumpulan Tipe Data Abstrak
Definisi tipe data abstrak yang ditentukan disediakan di sini, diikuti dengan implementasi
menggunakan daftar. Bab berikutnya memberikan dan mengevaluasi implementasi alternatif
dari himpunan ADT.
Mendefiniskan Setel ADT
Set adalah wadah yang menyimpan sekumpulan nilai unik pada domain tertentu, seperti, dan
nilai yang disimpan tidak dalam urutan tertentu.
 Set (): Membuat set baru yang diinisialisasi dengan set kosong.
 Panjang (): Mengembalikan jumlah elemen dalam himpunan. Ini juga dikenal sebagai
kardinalitas.
 Akses melalui fungsi len(). Menunjukkan apakah nilai yang ditentukan adalah elemen
dari himpunan dan mengembalikan nilai Boolean yang sesuai.
 Add (elemen): Ubah himpunan dengan menambahkan nilai yang ditetapkan ke
himpunan atau elemen jika elemen tersebut belum menjadi anggota. Jika elemen tidak
unik, tidak ada tindakan yang dilakukan dan operasi dilewati.
 Hapus (elemen): Jika nilainya ada di himpunan, hapus nilai yang ditentukan dari
himpunan. Jika tidak, itu melempar pengecualian.
 Equals (setB): Menentukan apakah suatu himpunan sama dengan himpunan lain dan
mengembalikan nilai Boolean. Agar dua himpunan A dan B sama, A dan B harus
mengandung elemen yang sama, dan semua elemen A juga harus menjadi elemen B.
Jika kedua himpunan kosong, himpunannya sama. == atau! Akses dengan =.
 isSubsetOf (setB): Menunjukkan apakah suatu himpunan adalah subset dari
himpunan lain dan mengembalikan nilai Boolean.

 Union (setB): Membuat dan mengembalikan set baru yang merupakan gabungan
dengan set ini. Set B. Himpunan baru dibuat dari gabungan dua himpunan A dan B,
termasuk semua elemen A dan elemen B yang tidak ada di A. Tidak ada pernyataan A
dan yang tidak diubah oleh operasi ini.
 Persimpangan (setB): Membuat dan mengembalikan set baru dari persimpangan dari
set ini dan set B. Irisan himpunan A dan B hanya berisi elemen di A dan B. Baik set
A maupun set B tidak diubah oleh operasi ini.
 Selisih (setB): Membuat dan mengembalikan set baru yang merupakan selisih antara
set dan set B ini. Selisih himpunan AB hanya berisi elemen-elemen yang dimiliki A
tetapi B tidak. Operasi ini tidak mengubah set A atau set B.
Contoh aplikasi
Untuk mengilustrasikan cara menggunakan himpunan ADT, kami membuat dan

menggunakan himpunan yang menyertakan mata pelajaran yang sedang diambil oleh kedua
siswa tersebut. Segmen kode berikut membuat dua set dan menambahkan elemen ke masing-
masing. Hasilnya ditunjukkan pada Gambar 1.
smith = Set()
smith.add( "CSCI-112" )
smith.add( "MATH-121" )
smith.add( "HIST-340" )
smith.add( "ECON-101" )
roberts = Set()
roberts.add( "POL-101" )
roberts.add( "ANTH-230" )
roberts.add( "CSCI-112" )
roberts.add( "ECON-101" )

Kemudian tentukan apakah kedua siswa tersebut mengambil mata kuliah yang sama persis.
Jika tidak, saya ingin tahu apakah mereka mengambil kursus yang sama. Untuk melakukan
ini, hitung persimpangan antara dua set.
If smith == robert:
print ("Smith dan Roberts mengambil jurusan yang sama.") Lainnya:
sameCourses = smith.intersection (roberts) if
sameCourses.isEmpty():
print ("Smith and Roberts" \ + "tidak mengambil mata kuliah yang sama.")
lainnya:
print("Smith dan Roberts mengambil beberapa" \
+ "kursus yang sama :")
untuk kursus dalam kursus yang sama:
percetakan (kursus)
Dalam hal ini, kedua siswa mengambil CSCI 112 dan ECON 101. Jadi jika Anda
menjalankan segmen kode sebelumnya pada, Smith dan Roberts akan mengambil jumlah
kursus yang sama:
CSCI112 ECON101
Misalkan Smith ingin tahu kursus mana yang dia ambil dan yang tidak diambil Roberts. Ini
dapat dikonfirmasi oleh operasi changeset.
UniqueCourses = smith.difference (roberts) untukkursus
pada dalamkursus yang sama:
mencetak(kursus)
Contoh ini memperkuat salah satu manfaat menggunakan abstraksi daripada bagaimana
mengimplementasikan fitur tersebut dengan berfokus pada fitur yang disediakan ADT.
Dengan menyembunyikan detail implementasi, kita dapat menggunakan ADT independen
dari implementasinya. Sebenarnya, pilihan implementasi untuk Set ADT tidak akan
berpengaruh pada instruksi dalam contoh program kita.
1. 2 Memilih Struktur Data
Untuk mengimplementasikan Set ADT, Anda harus memilih struktur data berdasarkan
kriteria yang digunakan untuk kantong ADT pada Bab 1. Karena saya mencoba untuk
menduplikasinya, mengatur fungsionalitas struktural yang disediakan oleh Python. Ingatlah
bahwa kamus berisi pasangan kunci / nilai, ini membutuhkan dua bidang data untuk setiap
entri. Untuk menggunakan struktur array. Simpan elemen set dan sediakan, seperti dalam
kasus tas Fungsionalitas ADT penuh. Daftar memungkinkan nilai duplikat, jadi Namun,
sebagai bagian dari implementasi, Anda perlu memastikan tidak ada duplikat yang
ditambahkan ke set.
1. 3 Implementasi Berbasis Daftar
Anda dapat memilih struktur daftar untuk mengimplementasikan kumpulan ADT, seperti,
seperti yang ditunjukkan pada Gambar 1. Beberapa operasi himpunan sangat mirip dengan
diagram ADT dan diimplementasikan dengan cara yang serupa. Contoh dua set Gambar 1
ditunjukkan pada Gambar 2.

Menambahkan Elemen
Seperti yang disebutkan sebelumnya, struktur daftar tidak menambahkan nilai duplikat, jadi
Anda perlu memastikan bahwa tidak ada nilai duplikat yang ditambahkan ke kumpulan. Saat

menerapkan metode tambah yang ditunjukkan pada baris 16-18, Anda harus terlebih dahulu
menentukan apa yang disediakan. Apakah item tersebut sudah ada dalam daftar. Jika itemnya
unik, tambahkan saja nilainya di akhir daftar. Jika item diduplikasi, jangan lakukan apa pun.
Ini karena definisi untuk operasi tambah () menunjukkan bahwa tindakan tidak dilakukan
saat mencoba menambahkan nilai duplikat.
Membandingkan Dua Set
Untuk operasi yang memerlukan set kedua sebagai argumen, Anda dapat menggunakan
operasi ADT set itu sendiri untuk mengakses dan memanipulasi data di set kedua.
Pertimbangkan operasi "sama" dari, yang berlaku untuk baris 26-30 dari Gambar 1, untuk
menentukan apakah dua set berisi elemen yang sama persis. Pastikan kedua himpunan berisi
jumlah elemen yang sama. Kalau tidak, mereka tidak bisa sama. Membandingkan elemen
individu tidak efisien karena kita telah mengetahui bahwa kedua himpunan tidak mungkin
sama.
2. Peta
Mencari item data berdasarkan nilai kunci unik adalah aplikasi yang sangat umum dalam
ilmu komputer. Tipe data abstrak yang menyediakan tipe pencarian ini sering disebut
sebagai peta atau kamus karena mereka memetakan kunci ke nilai yang sesuai. Pikirkan
tentang masalah lulusan perguruan tinggi yang perlu mengelola dan memproses sejumlah
besar data terkait siswa. Untuk melacak informasi atau catatan, pencatat memberikan setiap
siswa nomor identifikasi siswa yang unik, seperti yang ditunjukkan pada Gambar 3. Jika
pendaftar perlu mengambil informasi siswa nanti, nomor identifikasi itu akan digunakan.
Pendekatan penguncian ini memberi Anda akses ke catatan siswa tertentu.

2. 1 Tipe Data Abstrak Peta
Mendefinisikan Peta ADT
Peta adalah wadah untuk menyimpan kumpulan catatan, dan setiap catatan dikaitkan dengan
kunci unik. Komponen utama harus setara.
 Peta (): Buat peta kosong baru.

 Panjang (): Mengembalikan jumlah pasangan kunci/nilai dalam peta.
 Berisi (kunci): Menunjukkan apakah kunci yang ditentukan ada pada kartu,
mengembalikan True jika kunci ditemukan, Salah jika tidak ditemukan.
 Add (key, value): Menambahkan pasangan kunci/nilai baru ke peta jika kunci belum
ada di peta. Jika kunci ada di peta, ganti data yang terkait dengan kunci tersebut.
Mengembalikan True jika ini adalah kunci baru, Salah jika menggantikan data yang
terkait dengan kunci yang sudah ada.
 Hapus (kunci): Menghapus pasangan kunci / nilai untuk kunci yang ditentukan jika
ada di peta
 Valueof (key): Mengembalikan record yang terkait dengan kunci yang ditentukan.
 Iterator (): Membuat dan mengembalikan iterator yang dapat digunakan untuk
mengulang kunci pada peta
2. 2 Implementasi Berbasis Daftar
Kami sebelumnya telah menunjukkan bahwa banyak struktur data yang berbeda dapat
digunakan untuk mengimplementasikan peta. Kami tidak menggunakan struktur ini karena
kami mencoba untuk menduplikasi fungsi kamus yang disediakan oleh Python. Implementasi

bag dan set ADT menggunakan satu daftar untuk menyimpan barang individu. Namun, untuk
ADT Peta, Anda perlu menyimpan komponen kunci dan komponen nilai yang sesuai untuk
setiap entri di peta.
Untuk beberapa alasan, tidak mungkin untuk menambahkan pasangan komponen ke daftar
tanpa mempertahankan asosiasi . Satu untuk kunci dan satu untuk nilai yang sesuai. Untuk
mencapai ini, setiap kunci / nilai harus disimpan dalam elemen yang sesuai dari daftar
paralel, dan pemetaan ini harus dipertahankan.
3. Array Multi-Dimensi
Di Bab 2, kita bekerja dengan array satu dan dua dimensi, tetapi array bisa menjadi lebih
besar dari dua dimensi. Faktanya, array dapat berisi sejumlah dimensi yang mungkin
diperlukan untuk masalah tertentu. Gambar 4 mengilustrasikan tampilan abstrak dari a array
dua dan tiga dimensi. Seperti yang kita lihat sebelumnya, array dua dimensi adalah biasanya
dilihat sebagai tabel atau kisi yang terdiri dari baris dan kolom.
Array 3D dapat divisualisasikan sebagai kisi tabel di mana setiap tabel dibagi menjadi baris
dan kolom
Sebagian besar bahasa pemrograman tingkat tinggi menyediakan cara yang nyaman untuk
membuat dan mengelola array multidimensi, sementara bahasa lain memerlukan pendekatan
yang lebih pragmatis. C++ dan Java adalah dua contoh bahasa yang menyediakan array
multidimensi sebagai bagian dari bahasa.
3. 1Tipe Data Abstrak MultiArray

Untuk mengakomodasi array multidimensi dengan dua atau lebih dimensi, kami
mendefinisikan ADT MultiArray yang, seperti tipe data abstrak array sebelumnya,
memisahkan operasi yang biasanya disediakan oleh array di sebagian besar bahasa
pemrograman yang menyediakan struktur array.
Mendefinisikan MultiArray ADT
Array multidimensi terdiri dari kumpulan elemen yang diatur dalam beberapa dimensi. Setiap
elemen direferensikan dengan menetapkan tupel atau indeks untuk beberapa komponen (i1,
i2, ... in), satu untuk setiap dimensi himpunan. Semua indeks tupel dimulai dari nol.
 MultiArray (d1, d2, .. dn): Membuat array elemen multidimensi n-dimensi, setiap
elemen awalnya diatur ke None. Nomor dimensi yang ditentukan oleh jumlah
argumen harus lebih besar dari 1.
 Dims(): Mengembalikan jumlah dimensi dalam larik multidimensi.
 Panjang (redup): Mengembalikan panjang dimensi larik yang ditentukan. Setiap
dimensi diberi nomor dimulai dengan 1. Di mana 1 mewakili dimensi pertama atau
tertinggi dari array.
 clear (nilai): Menghapus array dengan mengatur setiap elemen ke nilai yang
ditentukan.
 Getitem (i1, i2, ... in): Mengembalikan nilai elemen posisi yang ditentukan oleh
ntuple (i1, i2, ... in) yang disimpan dalam array. Semua indeks yang ditentukan harus
ditentukan dan harus berada dalam rentang yang valid dari dimensi larik yang
sesuai. Akses melalui operator elemen: y = x [1, 2].
 Setitem (i1, i2, ... in, value): Memodifikasi konten array dalam definisi item untuk
memasukkan nilai yang ditentukan. Elemen didefinisikan oleh ntuple (i1, i2, ... in).
Semua komponen subskrip harus ditentukan dan harus berada dalam cakupan dimensi
larik yang sesuai. Akses melalui operator elemen: x [1, 2] = y.
3.2 Organisasi Data
Pada Array Multi-Dimensi, bahasa pemrograman hanya perlu menyediakan sintaks yang sesuai
untuk menggunakan larik 1-D. Array multi-dimensi tidak ditangani di tingkat perangkat keras.

Sebaliknya, bahasa pemrograman biasanya menyediakan mekanismenya sendiri untuk membuat
dan mengelola array multi-dimensi.
Array satu dimensi terdiri dari sekelompok elemen berurutan yang disimpan di lokasi memori
yang berurutan. Indeks yang digunakan untuk mereferensikan elemen tertentu hanyalah offset
dari elemen pertama dalam array. Dalam kebanyakan bahasa pemrograman, array multi dimensi
sebenarnya dibuat dan disimpan dalam memori sebagai array satu dimensi. Dengan organisasi
ini, array multidimensi hanyalah tampilan abstrak dari struktur data fisik satu dimensi.
Penyimpanan Array
Array satu dimensi biasanya digunakan untuk menyimpan array dimensi yang lebih tinggi secara
fisik. Pertimbangkan array dua dimensi yang dibagi menjadi tabel baris dan kolom seperti yang
diilustrasikan pada Gambar 3.6. Elemen dapat disimpan dalam urutan baris-utama atau urutan
kolom-utama. Sebagian besar bahasa pemrograman tingkat tinggi menggunakan urutan baris-
utama, dengan FORTRAN menjadi salah satu dari sedikit bahasa yang menggunakan urutan
kolom-utama untuk menyimpan dan mengelola array 2-D.
Untuk dimensi yang lebih besar, pendekatan serupa dapat digunakan. Dengan array tiga dimensi,
tabel individual dapat disimpan secara berurutan menggunakan urutan baris-utama atau kolom-
utama. Seiring bertambahnya jumlah dimensi, semua elemen dalam satu instance dari setiap
dimensi disimpan secara berurutan sebelum instance berikutnya. Misalnya, mengingat array
empat dimensi, yang dapat dianggap sebagai array kotak, semua elemen kotak individu (array 3-
D) disimpan sebelum kotak berikutnya.

Komputasi Indeks
Perhatikan larik 2-D yang diilustrasikan pada Gambar 3.8 dan amati lokasi penyimpanan fisik
dalam larik 1-D untuk elemen pertama dalam beberapa baris. Elemen (0; 0) dipetakan ke posisi 0
karena merupakan elemen pertama dalam larik 2-D abstrak dan fisik 1-D. Entri pertama dari
baris kedua (1; 0) dipetakan ke posisi n karena mengikuti n elemen pertama dari baris pertama.
Demikian juga, elemen (2; 0) dipetakan ke posisi 2n karena mengikuti elemen 2n pertama dalam
dua baris pertama. Kita dapat melanjutkan dengan cara yang sama melalui semua baris, tetapi
Anda akan segera melihat posisi elemen pertama dari baris ke-i adalah
n∗i. Karena subskrip dimulai dari nol, subskrip ke-i tidak hanya mewakili baris tertentu tetapi
juga menunjukkan jumlah baris lengkap yang dilewati untuk mencapai baris ke-i.
Mengetahui posisi elemen pertama dari setiap baris, posisi elemen apa pun dalam larik 2D dapat
ditentukan. Diberikan sebuah elemen (i; j) dari larik 2-D, lokasi penyimpanan elemen itu dalam
larik 1-D dihitung sebagai
indeks2(i; j) = i∗n+ j

Indeks kolom, j, tidak hanya offset dalam baris yang diberikan tetapi juga jumlah elemen yang
harus dilewati pada baris ke-i untuk mencapai kolom ke-j. Untuk melihat formula ini beraksi,
perhatikan kembali larik 2-D dari Gambar 3.7 dan asumsikan kita ingin mengakses elemen (2;
3). Menemukan elemen target dalam larik 1-D memerlukan melewatkan 2 baris lengkap elemen
pertama:
dan 3 elemen pertama dalam baris 2:
Persamaan serupa dapat diturunkan untuk array dimensi yang lebih tinggi. Diberikan array 3-D
dengan ukuran d 1 x d 2 x d 3, offset array 1-D dari elemen (i 1 , i 2, i 3) yang disimpan menggunakan
urutan baris-utama akan menjadi
indeks3 (i 1 , i 2, i 3) = i 1 ¿ (d ¿ ¿ 2¿ d 3 )+i 2 ¿ d 3 +i 3 ¿
Untuk setiap komponen (i) dalam subskrip, persamaan menghitung jumlah elemen yang harus
dilewati dalam dimensi yang sesuai. Misalnya, faktor (d ¿ ¿ 2 ¿ d 3)¿ menunjukkan jumlah elemen
dalam satu tabel kubus. Ketika dikalikan dengani 1 kita mendapatkan jumlah tabel lengkap yang
harus dilewati dan pada gilirannya jumlah elemen yang harus dilewati untuk sampai pada elemen
pertama tabel i 1.

Bagian persamaan yang tersisa (i 2 x d 3 +i3 ) setara dengan indeks2 (i 2 ,i 3) , yang menunjukkan
jumlah elemen yang akan dilewati dalam tabel i 1. Saat jumlah dimensi meningkat, produk
tambahan ditambahkan ke persamaan, satu untuk setiap dimensi baru. Misalnya, persamaan
untuk menghitung offset untuk array 4-D adalah
Anda mungkin melihat sebuah pola berkembang seiring dengan bertambahnya jumlah dimensi.
Pola ini mengarah ke persamaan umum untuk menghitung offset larik 1-D untuk elemen
i 1 , i 2 ,… , i n dalam larik n-dimensi:
di mana nilai f j adalah faktor yang mewakili jumlah elemen yang akan dilewati dalam dimensi
yang sesuai dan dihitung menggunakan
3.3 Argumen Panjang Variabel

Definisi ADT MultiArray memerlukan argumen panjang variabel untuk konstruktor dan dua
metode akses elemen. Jumlah argumen yang diteruskan ke setiap metode seharusnya sama
dengan jumlah dimensi dalam array. Fungsi dan metode Python dapat didefinisikan untuk
menerima sejumlah variabel argumen, yang persis seperti yang kita perlukan untuk

mengimplementasikan MultiArray ADT. Pertimbangkan fungsi berikut, yang menerima
sejumlah argumen (diasumsikan numerik dalam contoh ini) dan kemudian mencetak berapa
banyak argumen yang dilewatkan dan jumlah argumen tersebut:
def func( *args ):

print "Number of arguments: ", len( args )
sum = 0
for value in args :
sum += value
print( "Sum of the arguments: ", sum )
Saat menggunakan fungsi, kita dapat melewatkan sejumlah variabel argumen untuk
setiap pemanggilan. Misalnya, semua berikut ini adalah panggilan fungsi yang valid:
func( 12 )
func( 5, 8, 2 )
func( 18, -2, 50, 21, 6 )
yang menghasilkan output berikut:
Number of arguments: 1
Sum of the arguments: 12
Tanda bintang di sebelah nama argumen (*args) memberi tahu Python untuk menerima
sejumlah argumen dan menggabungkannya menjadi tupel. Tuple kemudian diteruskan ke fungsi
dan ditugaskan ke argumen formal yang ditandai dengan tanda bintang. Perhatikan tanda bintang
hanya digunakan dalam daftar argumen untuk menunjukkan bahwa fungsi atau metode dapat

menerima sejumlah argumen. Itu bukan bagian dari nama argumen. Operasi len() dapat
diterapkan ke tupel untuk menentukan jumlah argumen aktual yang diteruskan ke fungsi.
Argumen individu, yang merupakan elemen dalam tupel, dapat diakses dengan menggunakan
notasi subskrip atau dengan mengulangi koleksi.
3.3.4 Menerapkan MultiArray
Untuk mengimplementasikan MultiArray ADT, elemen array multidimensi dapat disimpan

dalam array 1-D tunggal dalam urutan baris-utama. Hal ini tidak hanya menciptakan struktur
array yang cepat dan ringkas, tetapi juga merupakan teknik aktual yang digunakan oleh sebagian
besar bahasa pemrograman. Implementasi sebagian dari kelas MultiArray disediakan di Listing
3.3.
The array.py module with the MultiArray class.

1 # Implementation of the MultiArray ADT using a 1-D array.
2 class MultiArray :
3 # Creates a multi-dimensional array.
4 def __init__( self, *dimensions ):
5 assert len(dimensions) > 1, "The array must have 2 or more dimensions."
6 # The variable argument tuple contains the dim sizes.
7 self._dims = dimensions
8
9 # Compute the total number of elements in the array.

10 size = 1
11 for d in dimensions :
12 assert d > 0, "Dimensions must be > 0."
13 size *= d
14
15 # Create the 1-D array to store the elements.
16 self._elements = Array( size )
17 # Create a 1-D array to store the equation factors.

18 self._factors = Array( len(dimensions) )
19 self._computeFactors()
20
21 # Returns the number of dimensions in the array.
22 def numDims( self ):
23 return len(self._dims)
24
25 # Returns the length of the given dimension.
26 def length( self, dim ):
27 assert dim >= 1 and dim < len(self._dims),\
28 "Dimension component out of range."
29 return self._dims[dim - 1]
30
31 # Clears the array by setting all elements to the given value.
32 def clear( self, value ):
33 self._elements.clear( value )
34
35 # Returns the contents of element (i_1, i_2, ..., i_n).
36 def __getitem__( self, ndxTuple ):
37 assert len(ndxTuple) == self.numDims(), "Invalid # of array subscripts."
38 index = self._computeIndex( ndxTuple )
39 assert index is not None, "Array subscript out of range."
40 return self._elements[index]
41
42 # Sets the contents of element (i_1, i_2, ..., i_n).
43 def __setitem__( self, ndxTuple, value ):
44 assert len(ndxTuple) == self.numDims(), "Invalid # of array subscripts."
45 index = self._computeIndex( ndxTuple )
46 assert index is not None, "Array subscript out of range."
47 self._elements[index] = value
48

49 # Computes the 1-D array offset for element (i_1, i_2, ... i_n)
50 # using the equation i_1 * f_1 + i_2 * f_2 + ... + i_n * f_n
51 def _computeIndex( self, idx ):
52 offset = 0
53 for j in range( len(idx) ):
54 # Make sure the index components are within the legal range.
55 if idx[j] < 0 || idx[j] >= self._dims[j] :
56 return None
57 else : # sum the product of i_j * f_j.
58 offset += idx[j] * self._factors[j]
59 return offset
60
61 # Computes the factor values used in the index equation.
62 def _computeFactors( self ):
63 ......
Konstruktor
Konstruktor didefinisikan untuk menerima argumen panjang variabel seperti yang dipersyaratkan
dalam definisi ADT. Tuple yang dihasilkan akan berisi ukuran dimensi individu dan ditetapkan
ke bidang redup. Dimensi larik harus diverifikasi di awal konstruktor karena ADT MultiArray
dimaksudkan untuk digunakan dengan larik dua dimensi atau lebih.
Perhitungan dan inisialisasi sebenarnya dilakukan oleh metode helper computeFactors(), yang
dibiarkan sebagai latihan. Contoh contoh kelas MultiArray diilustrasikan pada Gambar 3.9.
Dimensi dan Panjang
Dalam versi multi-dimensi dari array, tidak ada nilai panjang tunggal. Sebaliknya, setiap dimensi
array memiliki ukuran terkait. Fungsi len() Python tidak dapat digunakan untuk tugas ini karena

kita harus menentukan dimensi tertentu untuk mendapatkan ukurannya. Sebagai gantinya,
metode length(), seperti yang ditunjukkan pada baris 26{29 dari Listing 3.3, digunakan. Metode
pertama memverifikasi indeks dimensi yang diberikan adalah antara 1 dan n, yang merupakan
rentang hukum yang ditentukan dalam definisi ADT. Ukuran dimensi yang diminta kemudian
dikembalikan menggunakan nilai yang sesuai dari dims tuple. Metode numDims()
mengembalikan dimensi larik, yang dapat diperoleh dari jumlah elemen dalam tupel redup.
Akses Elemen
Akses ke elemen individu dalam array nD memerlukan n-tupel atau subskrip multikomponen,
satu untuk setiap dimensi. Seperti yang ditunjukkan dalam Bagian 2.3.2, ketika subskrip multi-
komponen ditentukan (yaitu, y = x[i,j]), Python secara otomatis menyimpan komponen dalam
sebuah tupel dalam urutan yang tercantum dalam tanda kurung dan meneruskan tupel ke
argumen ndxTuple.
Konten ndxTuple diteruskan ke metode helper computeIndex() untuk menghitung offset indeks
dalam larik penyimpanan 1-D. Penggunaan metode pembantu mengurangi kebutuhan akan kode
duplikat yang seharusnya diperlukan di kedua metode akses elemen. Metode operator _setitem_
dapat diimplementasikan dengan cara yang sama. Perbedaan utama adalah bahwa metode ini
memerlukan argumen kedua untuk menerima nilai yang menjadi dasar suatu elemen dan
memodifikasi elemen yang ditunjukkan dengan nilai baru alih-alih mengembalikan nilai.
Menghitung Offset
Metode helper computeIndex(), yang ditunjukkan pada baris 51{59 dari Listing 3.3,
mengimplementasikan Persamaan 3.4, yang menghitung offset dalam larik penyimpanan 1-D.
Metode ini juga harus memverifikasi komponen subskrip berada dalam rentang hukum dari
panjang dimensi. Jika valid, offset dihitung dan dikembalikan; jika tidak, None dikembalikan ke
indeks array yang tidak valid. Dengan mengembalikan None dari metode helper alih-alih
memunculkan pengecualian di dalam metode, informasi yang lebih baik dapat diberikan kepada
programmer mengenai operasi akses elemen yang tepat yang menyebabkan kesalahan.
3.4 Aplikasi: Laporan Penjualan

Lazy Mart, Inc. adalah department store rantai regional kecil dengan lokasi di beberapa kota dan
negara bagian yang berbeda. Perusahaan memelihara kumpulan catatan penjualan untuk berbagai
item yang dijual dan ingin menghasilkan beberapa jenis laporan yang berbeda dari data ini. Salah
satu laporan tersebut, misalnya, adalah penjualan tahunan menurut toko, seperti yang
diilustrasikan pada Gambar 3.13 di halaman berikutnya, sementara laporan lainnya dapat
mencakup total penjualan di semua toko untuk bulan tertentu atau barang tertentu.
Data penjualan tahun kalender saat ini untuk semua toko Lazy Mart disimpan sebagai kumpulan
entri dalam file teks. Misalnya, berikut ini mengilustrasikan beberapa baris pertama dari contoh
file teks data penjualan:
100
5 11 85 45,23
1 4 26 128,93
1 8 75 39,77
di mana baris pertama menunjukkan jumlah toko; baris kedua menunjukkan jumlah item
individual (keduanya bilangan bulat); dan baris yang tersisa berisi data penjualan. Setiap baris
data penjualan terdiri dari empat informasi: nomor toko, nomor bulan, nomor barang, dan jumlah
penjualan untuk barang tertentu di toko tertentu selama bulan tertentu. Untuk mempermudah,
nomor toko dan item akan terdiri dari nilai bilangan bulat berurutan dalam rentang [1…max], di

mana max adalah jumlah toko atau item yang diambil dari dua baris pertama file. Bulan
ditunjukkan dengan bilangan bulat dalam kisaran [1…12] dan jumlah penjualan adalah nilai
floating-point.
Organisasi Data
Sementara beberapa laporan mudah dibuat hanya dengan mengekstrak data dan menulisnya ke
laporan, yang lain mengharuskan kita mengatur data dengan cara yang berarti untuk mengekstrak
informasi yang dibutuhkan. Di mana kita mungkin perlu menghasilkan banyak laporan berbeda
dari kumpulan data yang sama. Struktur ideal untuk menyimpan data penjualan adalah array 3-D,
seperti yang ditunjukkan pada Gambar 3.14, di mana satu dimensi mewakili toko, dimensi lain
mewakili barang yang dijual di toko, dan dimensi terakhir mewakili masing-masing dari 12
bulan di toko. tahun kalender. Array 3-D dapat dilihat sebagai kumpulan spreadsheet, seperti
yang diilustrasikan pada Gambar 3.15.
Setiap spreadsheet berisi penjualan untuk toko tertentu dan dibagi menjadi baris dan kolom di
mana setiap baris berisi penjualan untuk satu item dan kolom berisi penjualan untuk setiap bulan.

Karena nomor toko, item, dan bulan semuanya terdiri dari nilai bilangan bulat berurutan mulai
dari 1, kita dapat dengan mudah mewakili masing-masing dengan indeks unik yang kurang satu
dari angka yang diberikan. Misalnya, data bulan Januari akan disimpan di kolom 0, data bulan
Februari akan disimpan di kolom 1, dan seterusnya. Demikian juga data soal nomor 1 akan
disimpan di baris 0, data nomor 2 akan disimpan di baris 1, dan seterusnya. Kami meninggalkan
ekstraksi data yang sebenarnya dari file teks sebagai latihan. Tetapi untuk tujuan ilustrasi, kami
menganggap langkah ini telah selesai menghasilkan pembuatan dan inisialisasi array 3-D seperti
yang ditunjukkan di sini:
data penjualan = MultiArray( 8, 100, 12 )
Total Penjualan berdasarkan Toko
Dengan data yang dimuat dari file dan disimpan dalam array 3-D, kami dapat menghasilkan
berbagai jenis laporan atau mengekstrak berbagai informasi dari data penjualan. Misalnya, kita
ingin menentukan total penjualan untuk toko tertentu, yang mencakup angka penjualan semua
barang yang terjual di toko itu selama 12 bulan. Fungsi berikut menghitung nilai ini:
# Compute the total sales of all items for all months in a given store.
def totalSalesByStore( salesData, store ):
# Subtract 1 from the store # since the array indices are 1 less
# than the given store #.
s = store-1
# Accumulate the total sales for the given store.
total = 0.0
# Iterate over item.
for i in range( salesData.length(2) ):
# Iterate over each month of the i item.
for m in range( salesData.length(3) ):

total += salesData[s, i, m]
return total
Dengan asumsi pandangan kami tentang data sebagai kumpulan spreadsheet, ini membutuhkan
melintasi setiap elemen dalam spreadsheet yang berisi data untuk penyimpanan yang diberikan.
Jika simpan sama dengan 1, ini setara dengan memproses setiap elemen dalam spreadsheet yang
ditunjukkan di depan Gambar 3.15. Diperlukan dua loop bersarang karena kita harus
menjumlahkan nilai dari setiap baris dan kolom yang terdapat dalam spreadsheet toko yang
diberikan. Jumlah baris (nomor dimensi 2) dan kolom (nomor dimensi 3) dapat diperoleh dengan
menggunakan metode array length().
Total Penjualan per Bulan
Selanjutnya, misalkan kita ingin menghitung total penjualan untuk bulan tertentu yang mencakup
angka penjualan semua barang di semua toko yang terjual selama bulan tersebut. Nilai ini dapat
dihitung menggunakan fungsi berikut:
# Compute the total sales of all items in all stores for a given month.
def totalSalesByMonth( salesData, month ):
# The month number must be offset by 1.
m = month - 1
# Accumulate the total sales for the given month.
total = 0.0
# Iterate over each store.
for s in range( salesData.length(1) ):
# Iterate over each item of the s store.

return total
Kali ini, dua loop bersarang harus mengulangi setiap baris dari setiap spreadsheet untuk satu
kolom yang mewakili bulan tertentu. Jika kita menggunakan fungsi ini untuk menghitung total
penjualan untuk bulan Januari, elemen array 3-D yang akan diakses ditunjukkan oleh area yang
diarsir pada Gambar 3.16.
Total Penjualan berdasarkan Item
Nilai lain yang dapat kita hitung dari data penjualan dalam larik 3-D adalah total penjualan untuk
item tertentu, yang mencakup angka penjualan selama 12 bulan dan dari 8 toko. Ini dihitung
dengan fungsi berikut:
# Compute the total sales of a single item in all stores over all months.
def totalSalesByItem( salesData, item ):
# The item number must be offset by 1.
m = item - 1
# Accumulate the total sales for the given month.
total = 0.0
# Iterate over each store.
for s in range( salesData.length(1) ):
# Iterate over each month of the s store.
return total

Sel-sel larik yang akan diakses saat menggunakan fungsi ini untuk menghitung total penjualan
untuk item nomor 5 ditunjukkan oleh area yang diarsir pada Gambar 3.17. Ingat, penjualan untuk
setiap item disimpan dalam baris tertentu dari array dan indeks baris tersebut kurang dari satu
nomor item karena indeks dimulai dari 0.
Penjualan Bulanan berdasarkan Toko
Misalkan kita ingin menghitung total penjualan bulanan untuk masing-masing dari 12 bulan di
toko tertentu. Sementara contoh sebelumnya menghitung nilai tunggal, tugas ini membutuhkan
perhitungan 12 total yang berbeda, satu untuk setiap bulan. Kita dapat menyimpan total bulanan
dalam larik 1-D dan mengembalikan strukturnya, seperti yang dilakukan dalam fungsi berikut:
# Compute the total sales per month for a given store. A 1-D array is
# returned that contains the totals for each month.
def totalSalesPerMonth( salesData, store ):
# The store number must be offset by 1.
s = store - 1
# The totals will be returned in a 1-D array.
totals = Array( 12 )
# Iterate over the sales of each month.
sum = 0.0

# Iterate over the sales of each item sold during the m month.
sum += salesData[s, i, m]
# Store the result in the corresponding month of the totals array.
totals[m] = sum
# Return the 1-D array.
return totals
Gambar 3.17 mengilustrasikan penggunaan larik 1-D untuk menyimpan total bulanan individu.
Area yang diarsir menunjukkan elemen larik 3-D yang diakses saat menghitung total penjualan
untuk bulan April di toko nomor 1. Total bulanan akan disimpan pada posisi indeks 3 dalam larik
1-D karena itu adalah kolom yang sesuai dalam larik 3-D untuk bulan April.

B. BUKU 2
 HASIL TERJEMAHAN DAN PARAFRASE
Set dan Peta
A. Memainkan Sudoku
Ketika bermain sudoku seperti Gambar 5.1, tugas kita adalah menemukan sisa angka yang
diberikan nomor yang sudah muncul di teka-teki. Cara umum untuk memecahkan teka-teki
ini adalah dengan proses eliminasi. Cara ini membantu untuk menuliskan nilai yang mungkin
untuk teka-teki dan kemudian menghilangkan nilai yang mungkin satu per satu. Misalnya,
teka-teki pada Gambar 5.1 dapat dianotasi dengan nilai yang mungkin untuk yang tidak
diketahui seperti yang ditunjukkan pada Gambar 5.2 .
Gambar 5.1

Gambar 5.2
Berikut ini ada dua aturan dalam menyelesaikan sudoku.
 ATURAN 1 . Aturan pertama adalah generalisasi dari proses yang digunakan di atas
untuk menghapus beberapa nilai dari sel . Di dalam grup, cari sel yang berisi kumpulan
nilai yang mungkin sama. Jika kardinalitas himpunan (yaitu jumlah item dalam
himpunan) cocok dengan jumlah duplikat set yang ditemukan, maka item dari set
duplikat dapat dengan aman dihapus dari semua set non-duplikat dalam grup. Aturan ini
berlaku bahkan dalam kasus degeneratif di mana jumlah set duplikat adalah 1 dan ukuran
set itu adalah 1. Kasus degeneratif adalah apa yang digunakan di atas untuk menghapus
item tunggal dari set lain. Aturan ini dapat diterapkan pada Gambar 5.3 untuk menghapus
2 dari semua sel di baris ke-7 teka-teki kecuali kolom ke-7 di mana 2 muncul dengan
sendirinya.
 ATURAN 2 . Aturan kedua melihat setiap sel dalam grup dan membuang semua item
yang muncul di sel lain dalam grup. Jika kita dibiarkan dengan hanya satu nilai di sel
yang dipilih, maka itu harus muncul di sel ini dan sel dapat diperbarui dengan membuang

Gambar 5.3
membuang semua nilai lain yang muncul di sel yang dipilih. Menerapkan aturan ini ke yang
kelima baris pada Gambar. 5.3 menghasilkan kolom keempat yang direduksi menjadi berisi 1
karena 1 tidak muncul di sel lain di baris ke-5. Aturan ini juga berlaku pada baris teka-teki
yang terakhir di mana 2 hanya mungkin di kolom kedua setelah dihapus 1, 5 dan 6 dari sel itu
karena mereka muncul di dalam sel lain di baris itu.
B. Set
Algoritma reduksi untuk teka-teki Sudoku memanipulasi set angka dan menghilangkan nilai
yang mungkin dari set tersebut saat pengurangan berlangsung. Himpunan adalah kumpulan
yang tidak mengizinkan nilai duplikat. Set dapat terdiri dari nilai apa pun seperti bilangan
bulat, objek karyawan, karakter, string, secara harfiah objek apa pun dengan Python dapat
menjadi elemen dari beberapa set. Suatu himpunan memiliki kardinalitas . Kardinalitas
suatu himpunan adalah jumlah item di dalamnya.
Operasi Compleksit Penggunaan Keterangan
as
Set Creation O(1) s=set([iterable]) Memanggil konstruktor set untuk
membuat set. Iterable adalah
konten awal opsional di mana
kita memiliki kompleksitas O(n).
Set Creation O(1) s=frozenset([iterable]) Memanggil konstruktor frozenset
untuk objek set yang tidak dapat
diubah untuk membuat objek
frozenset .
Cardinality O(1) len(s) Jumlah elemen dalam s
dikembalikan.
Membership O(1) e in s Mengembalikan True jika e
dalam s dan False sebaliknya.
non- O(1) e not in s Mengembalikan True jika e tidak
Membership dalam s dan False sebaliknya.
Disjoint O(n) s.isdisjoint(t) Mengembalikan True jika s dan t
tidak berbagi elemen, dan False
sebaliknya.
Subset O(n) s.issubset(t) Mengembalikan True jika s
adalah subset dari t, dan False
Superset O(n) s.issuperset(t) sebaliknya.
Mengembalikan True jika s
adalah superset dari t dan False
Union O(n) s.union(t) sebaliknya.
Mengembalikan set baru yang
berisi semua elemen dalam s dan
Intersection O(n) s.intersection(t) t.
Set O(n) s.difference(t) hanya berisi elemen di s dan t.
Difference Mengembalikan set baru yang

Symmetric O(n) s.symmetric_difference berisi elemen s yang tidak ada di
Difference (t) t.
berisi
Set Copy O(n) s.copy() s.difference(t).union(t.difference(.
s))
Mengembalikan salinan dangkal
s.
Tabel di atas menjelaskan operasi yang didefinisikan secara umum pada himpunan dan
kompleksitas komputasi terkaitnya. Python memiliki dukungan bawaan untuk dua jenis set,
set dan kelas frozenset. Kelas frozenset tidak dapat diubah. Objek dari kelas yang ditetapkan
dapat bermutasi. Pada table di atas, variabel s harus berupa himpunan dan variabel t harus
berupa urutan yang dapat diubah , yang akan mencakup himpunan.
Operasi pada table di bawah tidak didefinisikan pada kelas frozenset karena mereka
mengubah set s . Mereka hanya didefinisikan pada kelas yang ditetapkan . Sekali lagi, ada
operator untuk beberapa metode yang disajikan pada Gambar 5.5 . Metode serikat mutator
dapat ditulis s| = t . Pembaruan persimpangan dapat ditulis sebagai s& = t . Akhirnya,
operator pembaruan perbedaan simetris ditulis s^ = t . Sementara ini operator nyaman,
mereka tidak terkenal dan kode yang ditulis dengan memanggil metode pada tabel di atas
akan lebih deskriptif.
Operasi Compleksitas Penggunaan Keterangan

Union O(n) s.update(t) Menambahkan isi t ke s.
Intersection O(n) s.intersection_update(t) Memperbaharui s agar
hanya berisi
perpotongan elemen
Set Difference O(n) s.difference_update(t) dari s dan t.
Mengurangi elemen t
Symmetric O(n) s.symmetric_difference_update(t) dari elemen s.
Difference Memperbaharui s

Add O(1) s.add(e) dengan perbedaan
simetris s dan t.
Remove O(1) s.remove(e) Menambahkan elemen
e ke himpunan s.
Menghapus elemen e
dari himpunan s. Ini
Discard O(1) s.discard(e) menimbulkan KeyError
jika e tidak ada di s.
Menghapus elemen e
Pop O(1) s.pop() jika ada di s dan
abaikan jika tidak.
Menghapus semua
Clear O(1) s.clear() elemen dari s biarkan
himpunan kosong.
Menghapus elemen
arbitrer dari s.
C. Hashing
Tanpa uji keanggotaan O(1), mengambil gabungan dua himpunan akan membutuhkan lebih
lama seperti yang ditunjukkan di atas. Pengujian keanggotaan set dalam waktu O(1)
dilakukan dengan menggunakan hashing. Hashing adalah konsep yang sangat penting dalam
Ilmu Komputer dan terkait dengan akses acak di komputer.
Jika kita ingin mengimplementasikan suatu himpunan di mana kita dapat menguji
keanggotaan dalam waktu O(1), kita mungkin berpikir untuk menyimpan item-item
himpunan tersebut dalam sebuah daftar. Python (dan banyak bahasa modern lainnya) telah
disertakan fungsi yang disebut hash yang dapat dipanggil pada objek apa pun untuk
mengembalikan nilai integer untuk Sebuah Objek. Kami akan menyebut nilai ini sebagai
kode hash objek atau nilai hash . Pertimbangkan ini panggilan ke fungsi hash.

Python 3.2 (r32:88452, Feb 20 2011, 10:19:59)
[GCC 4.0.1 (Apple Inc. build 5493)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> hash("abc")
-1600925533
>>> hash("123")
1911471187
>>> hash(45)
45
>>> hash(45.0)
45
>>> hash(45.3)
1503225491
>>> hash(True)
>>> hash(False)
>>> hash([1,2,3])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: ’list’
>>>

Sementara sebagian besar objek dapat di- hash , tapi tidak untuk setiap objek. Secara khusus,
objek yang dapat diubah seperti daftar mungkin tidak dapat di- hash karena ketika suatu
objek dimutasi, nilai hash-nya juga dapat berubah. Hal ini memiliki konsekuensi saat
menggunakan nilai hash dalam struktur data.
D. KELAS HASHSET
Nilai Hash dapat digunakan untuk menghitung indeks kedalam bentuk daftar(list) untuk
mendapatkan pencarian item O(1) yang kompleks. Sebuah set class dapat ditulis untuk
menyembunyikan detai list dan memanggil fungsi hash yang berguna untuk menemukan
indeks suatu item. Kelas Hashnet disajikan guna menunjukkan bagaimana set kelas
diimpelmentasikan. Pada awalnya objek Hashset akan berisi daftar dan nomor item yang
tidak bernilai. Namun list harus diisi oleh item yang memiliki nilai karena hashet tidak
berfungsi untuk menyimpan suatu item yang tidak bernilai di dalam daftar(list).Namun
faktanya , beberapa hashset bernilai negative namun tidak negative Ketika dimasukkan
kedalam daftar.
1) KONSTRUKSI HASHSET
2) PENYIMPANAN ITEM
Untuk menyimpan item dalam hash set, pertama-tama kita menghitung indeksnya
menggunakan fungsi hash. Ada dua masalah yang harus dihadapi. Pertama, daftar tempat
item yang disimpan harus memiliki panjang yang terbatas dan tidak boleh sama dengan nilai
hash unik yang akan kita hasilkan dengan memanggil fungsi hash.Kedua , Nilai hash belum
tentu unik. Nilai hash merupakan bilangan bulat dan kemungkinan munculnya bilangan
dalam komputer juga akan .Selain itu, karena telah membagi nilai hash dengan panjang

daftar, sisa, atau dengan indeks daftar, maka nilai hash akan menjadi kurang unik daripada
nilai hash yang asli.
3) RESOLUSI YANG BERTABRAKAN
Ketika dua objek perlu disimpan pada indeks yang sama dalam daftar hash set, maka akan
terjadi suatu tabrakan.Untuk menangani masalah ini diperlukan untuk menemukan skema
resolusi tabrakannya.Terdapat berbagai jenis skema. Salah satunya adalah skema yang
disebut Linear Probing .Ketika tabrakan muncul Ketika menggunakan Linear Probing , kita
bisa melihat lokasi selanjutnya pada list dan menentukan apakah lokasi tersebut tersedia atau
tidak.Lokasi yang tersedia dapat dilihat jika ditemukan sebuah None Value pada list .
4) MENAMBAHKAN FUNGSI PEMBANTU PADA HASHSET
Kode diatas digunakan untuk menambahkan item baru yang belum terdaftar pada list.
Perintah While pada source code tersebut menujukkan bagian Linear Probing . Menemukan
sebuah None Value akan menjadi akhir dari rantai linear , karena tujuan akhir dari pencarian

linear adalah untuk menentukan apakah sebuah item sudah terdaftar didalam list atau
belum.Jika sebuah item belum terdapat didalam list , maka item akan ditambahkan di lokasi
Placeholder pertama yang ditemukan dalam pencarian atau di lokasi None value diakhir
rantai.
Ketika hanya terdapat satu posisi yang tersedia dalam daftar hashset , pencarian linear akan
melakukan pencarian ke seluruh isi list. Ketika list penuh maka hasilnya akan menjadi
perulangan tak hingga.Oleh karena itu untuk memastikan bahwa kita mendapatkan
komplesitas yang diamortisasi dari O(1) , list tidak boleh tersisi penuh.
5) FAKTOR BEBAN
Faktor beban adalah kelengkapan list hash set. Fakor beban sebuah hash set dapat ditentukan
dengan membagi jumlah item yang disimpan dengan Panjangnya. Faktor beban yang kecil
berarti memiliki list yang lebih besar daripada jumlah item yang disimpan dan kemungkinan
terjadinya tabrakan juga kecil.Sedangkan faktor beban tinggi berarti memiliki ruang yang
lebih efisien namun memiliki kemungkinan tabrakan yang tinggi juga.Eksperimen
membuktikan bahwa faktor beban maksimum yang wajar adalah sebesar 75%. Ketika faktor
beban lebih dari itu maka semua nilai dan item yang disimpan harus dipindahkan ke list
lain.Proses ini disebut proses pengulangan atau looping.
6) MENAMBAHKAN HASHSET
7) MENGHAPUS SEBUAH ITEM

Menghapus nilai dari Hash set berarti menemukan item terlebih dahulu.Hal ini mubgkin akan
melibatkan proses pencarian linear dalam rantai nilai yang berada pada list. Jika sebuah nilai
dihapus maka nilai terakhir dalam rantai akan diganti dengan none value dan item diganti
dengan objek placeholder agar rantai tidak putus dan linear probing dapat terus melanjutkan
tugasmua umtuk mencari objek bila diperlukan.
8) PEMBANTU FUNGSI REMOVE PADA HASHSET
Saat menghapus item, faktor beban mungkin terlalu rendah untuk menggunakan ruang di
memori secara efisien. Ketika faktor beban turun di bawah 25%, daftar tersebut diulang lagi
untuk mengurangi ukuran daftar hingga setengahnya untuk meningkatkan faktor
beban.Pembantu fungsi remove dapat dilihat dibawah ini.
9) MENGHAPUS HASHSET
Untuk alasan yang sama bahwa menambahkan nilai dapat dilakukan dalam waktu O(1),
menghapus nilai juga dapat dilakukan dengan kompleksitas yang diamortisasi dari O(1).

Metode buang hampir sama dengan metode hapus yang disajikan dibawah ini , kecuali tidak
ada pengecualian yang dimunculkan jika item tersebut tidak ada di dalam set saat item
tersebut dibuang.
10) MENEMUKAN SEBUAH ITEM
Untuk menemukan sebuah item dalam sebuah hashset maka diperlukan pencarian alamat dan
kemungkinan rantai nilainya.Jika item tersebut berada disuatu rantai nilai , maka metode
_contains_ akan mengeluarkan nilai FALSE atau TRUE
11) KEANGGOTAAN HASHSET
Dalam menemukan item yang menghasilkan 0 (1) yang kompleksitas dan diamortisasi.
Rantai yang dijaga akan selama sebagian besar nilai hash didistribusikan secara merata dan
juga faktor beban yang dijaga agar tidak mendekati 1.
12) ITERASI PADA SET
Untuk mengulangi suatu item pada set, kita perlu mendefinisikan metode untuk
menghasilkan suatu elemen hashset. Metode ini melintasi daftar suatu item yang melewati
elemen placeholder dan referensi none. Berikut ini adalah kode untuk iterator

13) OPERASI SET LAINNYA
Pada hashset terdapat banyak operasi himpunan yang dibiarkan sebagai latihan untuk
pembaca. Namun, kebanyakan dari mereka dapat mengimplemtasikannya dengan metode
yang telah disajikan pada bab ini. Mempertimbangkan metode perbedaan pembaruan itu
dapat diimplementasikan menggunakan iterator, tes keanggotaan, dan metode buang. Kode
di sect .5.5.1.4. menyediakan implementasi untuk metode perbedaan pembaruan tersebut.
14) PEMBARUAN PERBEDAAN HASHSET
Metode perbedaan pembaruan yang disajikan dalam sect .5.5.1.4. adalah metode mutator,
karena mengubah urutan yang direferensikan oleh diri sendiri dibandingkan dengan metode
perbedaan pembaruan di sect .5.5.1.4. yang tidak mengubah objek yang dirujuk oleh diri
sendiri. Sebagai gantinya, metode perbedaan pembaruan ini mengembalikan set baru yang
terdiri dari selisih antara diri sendiri dan lainnya.
15) PERBEDAAN HASHSET
Metode inj diimplemetasikan dengan menggunakan metode perbedaan pembaruan pada

hashset. Kumpulan hashset yang direferensikan oleh diri sendiri kodenya sederhana dan
memiliki manfaat tambahan, bahkan jika metode ini ditulis dengan benar. Pemrogram harus
selalu menghindari penulisan yang duplikat bila memungkinkan dan hampir identik kecuali
metode ini melakukan referensi perbedaan pada set yang baru dibangun oleh ahli-ahli set.

E. MEMECAHKAN SUDOKU
Untuk menggunakan suatu aturan atau hashset tipe data, kita bisa memiliki alat untuk
memecahkan sebagian besar teka-teki yang terdapat pada sudoku. Teka-teki dapat dibaca dari
file dimana nilai yang diketahui diwakili oleh nilai dan digitnya tidak diketahui, seperti pada
teka-teki dibawa ini. Memecahkan teka-teki sudoku berarti mengurangi jumlah item dari
setiap set grup sesuai dengan aturan yang disajikan pada sect .5.2. Menulis fungsi yang
disebut kurangi grup yang diberikan daftar set untuk dapat membantu mengurangi.
Fungsinya harus kembali benar, jika itu bisa mengurangi grup palsu. Jika tidak, mengingat
fungsi kurangi grup adalah seperti yang didefinisikan dalam sect .5.6.1.
Fungsi Pengurangan Sudoku

Ada beberapa teka-teki yang tidak akan bisa dipecahkan oleh pemecah sudoku ini karena dua
aturan yang disajikan diatas tidak cukup kuat untuk semua teka-teki. Ada beberapa situasi
dimana jumlah item dalam satu set tidak dapat dikurangi dengan melihat hanya satu
kelompok.
Aturan yang disajikan dalam bab ini akan memecahkan teka-teki sudoku yang diberikan pada
bagian ini dan bagian lainnya. Teka-teki sudoku dapat diselesaikan oleh pemecah sudoku
jika fungsi diatas akan memanggil daftar masing-masing grup, jika benar maka akan
dipanggil kembali dan jika salah atau palsu maka sebaliknya.
F. MAPS
Peta dalam ilmu komputer, berbeda dengan peta yang sering digunakan untuk menunjukan
arah. Peta merupakan istilah matematis yang mengacu pada fungsi yang memetakan domain
ke rentang. Peta memiliki banyak nama, termasuk kamus, tabel hash, dan peta hash.
Ketiganya merupakan struktur data yang sama.
Peta atau kamus memetakan sekumpulan kunci unik ke nilai terkaitnya, sama seperti fungsi
memetakan nilai dalam domain ke rentang. Saat kita ingin mencari pasangan kunci/nilai,
kuncinya adalah apa yang kita berikan ke peta. Kunci peta itu unik. Hanya ada satu salinan
dari nilai kunci yang diberikan dalam kamus pada satu waktu. Seperti yang kita lihat di Bab
1, Python memiliki dukungan bawaan untuk kamus atau peta. Berikut adalah beberapa
contoh interaksi dengan kamus di shell Python.

Peta atau kamus sangat mirip dengan koleksi. Set dan kamus memiliki nilai yang unik. Tipe
data yang ditentukan berisi kumpulan nilai yang unik. Peta berisi kumpulan kunci unik yang
memetakan ke nilai terkait. Seperti set, kita dapat mencari kunci dan nilai terkaitnya di peta
dalam waktu O(1). Seperti yang kita tau, peta dan set diimplementasikan menggunakan hash.
Meskipun implementasi dasarnya sama, peta dan set digunakan secara berbeda.
Perbedaan yang menarik dari pernyataan diatas adalah bahwa pasangan kunci/nilai yang
disimpan dalam kamus, bukan hanya item dalam koleksi. Bagian kunci dari pasangan
kunci/nilai digunakan untuk menentukan apakah kunci ada dalam kamus, seperti yang kita
harapkan.
1) KELAS HASHMAP
HashMap, seperti kelas dict pada Python, menggunakan hashing untuk mencapai
kompleksitas yang dijelaskan dalam tabel di Gambar 5.6. Instansi __KVPair menyimpan
pasangan kunci/nilai saat ditambahkan ke objek HashMap. Kelas HashMap dapat
diimplementasikan menggunakan kelas HashSet dengan menambahkan metode __getitem__
ke kelas HashSet. Metode __getitem__ lainnya dari HashSet diberikan di Sect. 5.7.3
2) HASHSET UNTUK MENDAPATKAN ITEM

Kemudian, untuk mengimplementasikan HashMap, kita dapat menggunakan HashSet seperti
yang ditunjukkan pada Sect. 5.7.3 Dalam definisi kelas __KVPair, kita perlu untuk
mendefinisikan metode __eq__ untuk membandingkan kunci ketika membandingkan dua item
dalam peta hash. Metode __hash__ dari __KVPair hanya meng-hash nilai kunci, karena kunci
digunakan untuk mencari pasangan kunci/nilai di peta hash. Implementasi disediakan di bagian.
5.7.3 bersifat lokal. Metode lain yang tersisa sebagai latihan untuk pembaca.
3) KELAS HASHMAP

Implementasi disediakan di bagian. 5.7.3 membantu menunjukkan kesamaan antara
implementasi kelas HashSet dan HashMap, atau antara kelas set dan dict dalam Python. Kedua
tipe struktur data tersebut diimplementasikan menggunakan hashing. Keduanya sangat
bergantung pada tes keanggotaan O(1). Meskipun penting untuk memahami bagaimana kelas
HashMap diimplementasikan, sebagian besar bahasa pemrograman menyertakan semacam peta
hash di pustaka tipe bawaannya, dan begitu pula Python. Penting untuk memahami asal-usul
metode peta hash, tetapi sama pentingnya untuk memahami kapan harus menggunakan peta hash
dan bagaimana menggunakannya.
G. MEMOISASI
Memoisasi adalah teknik pemrograman yang menarik yang dapat digunakan saat menulis fungsi
yang dapat dipanggil beberapa kali dengan argumen yang sama. Gagasan di balik memoisasi
adalah melakukan pekerjaan menghitung nilai sekali dalam suatu fungsi. Kemudian, yang perlu
diingat ketika fungsi dipanggil kembali dengan argumen yang sama, kita akan kembali

mengembalikan nilai yang baru saja kita hitung. Ini menghindari lebih banyak pekerjaan untuk
menghitung nilai.
Contoh yang kuat adalah fungsi Fibonacci rekursif. Deret Fibonacci didefinisikan sebagai
berikut.
 Fib(0) = 0
 Fib(1) = 1
 Fib(n) = Fib(n−1) + Fib(n−2)
Namun, kita tidak perlu menggunakan fungsi ini selain untuk demonstrasi sederhana dari angka
Fibonacci kecil. Fungsi tersebut bahkan tidak dapat digunakan untuk menghitung sesuatu sebesar
fib(100). Bahkan menjalankan fungsi dengan 100 argumen di komputer tercepat membutuhkan
waktu lama. Pertimbangkan apa yang terjadi pada perhitungan fib(5). Untuk melakukan ini,
fib(4) dan fib(3) harus dihitung terlebih dahulu. Kedua hasil tersebut kemudian dapat
ditambahkan untuk menemukan fib(5). Namun, untuk menghitung fib(4), nilai fib(3) dan fib(2)
harus dihitung. Sekarang kita menghitung fib(3) dua kali untuk menghitung fib(5), tetapi untuk
menghitung fib(3) kita harus menghitung fib(2) dan fib(1). Namun, fib(2) harus dihitung untuk
menemukan fib(4). Gambar 5.7 menunjukkan semua panggilan ke fib untuk menghitung fib(5).

Seperti yang kita lihat dari Gambar 5.7, dibutuhkan banyak panggilan ke fungsi fib untuk
menghitung fib(5). Sekarang bayangkan berapa banyak panggilan yang diperlukan untuk
menghitung fib (6). Untuk menghitung fib(6) pertama-tama kita harus menghitung fib(5) dan
kemudian menghitung fib(4). Dibutuhkan 15 panggilan ke fib untuk menghitung fib(5) dan dari
gambar kita dapat melihat bahwa dibutuhkan 9 panggilan untuk menghitung fib(4). Termasuk
panggilan ke fib(6), dibutuhkan 25 panggilan ke fib untuk menghitung fib(6). Komputasi fib(7)
akan mengambil 41 panggilan. Menghitung fib(n) dengan cara ini lebih dari dua kali lipat jumlah
panggilan untuk menghitung fib(n−2). Ini disebut pertumbuhan eksponensial. Kompleksitas
fungsi fib adalah O(2n). Sebuah fungsi dengan kompleksitas eksponensial tidak berharga kecuali
untuk nilai n yang sangat kecil.
Semua tidak hilang. Ada cara yang lebih baik untuk menghitung deret Fibonacci. Cara untuk
menjadi lebih efisien adalah dengan menghindari semua pekerjaan yang tidak perlu. Setelah
menghitung fib (2), kita tidak dapat menghitungnya lagi. Setidaknya ada beberapa cara untuk
meningkatkan efisiensi. Salah satu pendekatan melibatkan menghilangkan rekursi dan komputasi
fib(n) menggunakan loop, yang mungkin merupakan pilihan terbaik. Namun, fungsi rekursif
lebih dekat dengan definisi aslinya. Kami dapat meningkatkan fungsi rekursif melalui
memoisasi. Dalam 5.8.1, kamus memo bertindak sebagai peta kita dari nilai n ke hasil fib(n).

1) FUNGSI FIBONACCI YANG DIMEMOISASI
Fungsi memoisasi fib dalam denominasi. 5.8.1 Mendokumentasikan nilai apa pun yang
dikembalikan oleh fungsi dalam memonya. Variabel memo diakses dari ruang lingkup tambahan.
Memo tidak dibuat secara lokal karena memo itu bertahan dari satu panggilan fib ke panggilan
berikutnya. Setiap kali fib dipanggil dengan nilai n baru, jawabannya dicatat dalam memo. Kali
berikutnya fib(n) dipanggil, hasil memoisasi dicari dan dikembalikan. Hasil: fungsi fib yang
diingat sekarang memiliki kompleksitas O(n) dan menghitung fib(100) hampir seketika. Tanpa
memori, dibutuhkan 1.146.295.688.027.634.168.201 panggilan ke fungsi fib untuk menghitung
fib(100). Dengan asumsi setiap panggilan fungsi selesai dalam 10 mikrodetik, komputasi
fib(100) membutuhkan waktu sekitar 363 juta tahun. Menggunakan memoisasi membutuhkan
100 panggilan ke fib dan mengasumsikan bahwa setiap panggilan membutuhkan waktu 10
mikrodetik, yaitu 1000 mikrodetik atau 1/1000 detik.
Ini adalah contoh ekstrim dari manfaat memoisasi, tetapi dapat berguna dalam banyak situasi.
Misalnya, dalam masalah tic-tac-toe di Bab 1. Panggil 4 fungsi minmax di banyak papan yang
sama. Fungsi minimax tidak mempermasalahkan X diletakkan di pojok kanan atas dulu, baru
kemudian pojok kiri bawah, atau sebaliknya. Namun, cara minimax ditulis akan dipanggil untuk
menghitung nilai papan yang sama beberapa kali. Memory Mini-Max mempercepat permainan
tic-tac-toe.

H. MENGHUBUNGKAN DUA SUMBER INFORMASI
Penggunaan lain dari peta atau kamus adalah untuk menghubungkan data dari sumber yang
berbeda. Misalkan Anda mendapatkan daftar kota dan kode pos atau kode di kota-kota tersebut.
Anda dapat mencari daftar kota untuk menemukan daftar kode pos yang sesuai. Atau, Anda
dapat membuat kamus dari nama kota ke daftar kode pos. Kemudian, ketika diberi nama kota,
Anda memeriksa apakah itu ada dalam kamus, dan jika ya, Anda dapat mencari daftar kode pos
yang sesuai dalam waktu O(1).
I. KESIMPULAN
Setiap strategi resolusi konflik harus memiliki cara penanganan nilai-nilai baru yang
ditambahkan ke urutan dan nilai-nilai yang ada dihapus dari urutan.Karakteristik utama hashing
adalah kompleksitas rata-rata O(1) dari pengujian keanggotaan dan pencarian tabel. Kemampuan
untuk memeriksa nilai keanggotaan atau pencarian dalam waktu O(1) membuat banyak
algoritma efisien yang mungkin tidak bekerja secara efisien pada kumpulan data besar.Memori
adalah salah satu kegunaan paling penting dari kamus atau peta. Ketika kita memiliki informasi
dari dua sumber yang berbeda dan perlu mencocokkan kedua sumber tersebut, peta atau kamus
membuat korelasi tersebut bekerja.

BAB III
PEMBAHASAN
SOAL STUDI KASUS

SMK Nusa Bangsa akan melakukan study tour ke Perusahaan Batu Bara. Perjalanan ke
perusahaan Batu Bara dilakukan dengan bis pariwisata. Satu persatu siswa masuk ke dalam
bis sesuai dengan nomor urut dari 1-10. Urutan tempat duduk yaitu 3,7,1,8,2,10,4,9,5,6.
Silahkan analisa kasus tersebut menggunakan algoritma dan gambaran dengan
menggunakan metode bab yang telah di review.
1. Pencarian data
#include <stdio.h>
/*******************************************
Fungsi Rekursif untuk f(n) = f(n-1) + 1
********************************************/
unsigned int deret1(int n)
{
if (n == 1)
return 1;
else
return (deret1(n-1) + 1);
}
int main()
{
int x;
for (x=1; x<=10; x++)
printf("%4d", deret1(x));
return 0;
}

Output
2. Hasil Kerja

BAB IV
PENUTUP
A. KESIMPULAN
Set ADT adalah wadah yang biasa digunakan dalam ilmu komputer. Namun, tidak
seperti bagian ADT yang diperkenalkan di Bab 1, himpunan berisi nilai unik dan mewakili
struktur yang sama dengan matematika. Ini biasanya digunakan saat anda perlu menyimpan
koleksi nilai unik terlepas dari cara penyimpanannya, atau saat anda perlu melakukan operasi
himpunan matematika yang berbeda pada koleksi. Algoritme reduksi untuk teka-teki Sudoku
memanipulasi set angka dan menghilangkan nilai yang mungkin dari set tersebut saat
pengurangan berlangsung. Himpunan adalah kumpulan yang tidak mengizinkan nilai duplikat.
Set dapat terdiri dari nilai apa pun. Bilangan bulat, objek karyawan, karakter, string, secara
harfiah objek apa pun dalam Python bisa menjadi elemen dari beberapa set. Suatu himpunan
memiliki kardinalitas. Kardinalitas suatu himpunan adalah jumlah item di dalamnya.
Mencari item data berdasarkan nilai kunci unik adalah aplikasi yang sangat umum
dalam ilmu komputer. Tipe data abstrak yang menyediakan tipe pencarian ini sering disebut
sebagai peta atau kamus karena mereka memetakan kunci ke nilai yang sesuai. Pikirkan
tentang masalah lulusan perguruan tinggi yang perlu mengelola dan memproses sejumlah
besar data terkait siswa. Peta dalam ilmu komputer tidak seperti peta yang biasa Anda baca
saat pergi ke suatu tempat di mobil Anda. Istilah peta adalah istilah yang lebih matematis
yang mengacu pada fungsi yang memetakan domain ke rentang. Anda mungkin sudah
menggunakan peta dengan Python. Peta disebut dengan banyak nama termasuk kamus, tabel
hash, dan peta hash. Mereka semua adalah struktur data yang sama.
Peta atau kamus memetakan satu set kunci unik ke nilai terkaitnya seperti halnya
fungsi memetakan nilai dalam domain ke rentang. Kunci adalah apa yang kami berikan ke
peta ketika kami ingin mencari pasangan kunci/nilai. Kunci dari sebuah peta adalah unik.

C. DAFTAR PUSTAKA
Data Structures and Algorithms Using Python: Necaise, Rance D.: 9780470618295: Amazon.com:
Books. (n.d.). Retrieved March 21, 2022, from https://www.amazon.com/Data-Structures-
Algorithms-Using-Python/dp/0470618299
Data Structures and Algorithms with Python (Undergraduate Topics in Computer Science): Lee, Kent
D., Hubbard, Steve: 9783319130712: Amazon.com: Books. (n.d.). Retrieved March 21, 2022,
from https://www.amazon.com/Structures-Algorithms-Undergraduate-Computer-Science/dp/
3319130714

Laporan CBR Dan Analisis Studi Kasus

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Laporan CBR Dan Analisis Studi Kasus

Diunggah oleh

Hak Cipta:

Format Tersedia

LAPORAN CBR DAN ANALISIS STUDI KASUS

DISUSUN GUNA MEMENUHI TUGAS MATAKULIAH STRUKTUR DATA

DOSEN PENGAMPU : Ibu Ressy Dwitias Sari,S.T.,M.T.I

TARISA RIANI RIZKI (5211151006)

NAZWA ZULFA (5212451004)

TIO AINAWANI (5212451005)

ANNISA RIZKI AGUSTI (5213151002)

FRILIA ARIANI (5213151005)

PROGRAM STUDI S-1 PENDIDIKAN TEKNOLOGI INFORMATIKA DAN

UNIVERSITAS NEGERI MEDAN

1 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

Medan, Maret 2022

2 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

KATA PENGANTAR ………………………………………………………. 2

DAFTAR ISI …………………………………………………………………

BAB I: PENDAHULUAN …………………………………………………...

A. Latar Belakang Pentingnya CBR ……………………………………………….…..

BAB II: ISI BUKU ……………………………………………………..…… 7

BAB III: PEMBAHASAN ……………………………………...……….….

BAB IV: PENUTUP ……………………………………………………..… 55

3 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

A. Latar Belakang Pentingnya CBR

pengalaman yang mereka miliki.

B. Tujuan Penulisan CBR

 Memenuhi tugas mata kuliah Struktur Data

4 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

Judul Buku : Data Structures and Algorithms Using Python

Penulis : Rance D. Necaise

Penerbit : JOHN WILEY & SONS, INC.

Tahun Terbit : 2011

Jumlah Halaman : 507

5 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

Judul Buku : Data Structures and Algorithms with Python

Penulis : Kent D. Lee Steve Hubbard

Tahun Terbit : 2015

Jumlah Halaman : 361

6 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

 HASIL TERJEMAHAN DAN PARAFRASE

Set dan peta

7 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

1. 1 Kumpulan Tipe Data Abstrak

Mendefiniskan Setel ADT

8 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

Untuk mengilustrasikan cara menggunakan himpunan ADT, kami membuat dan

9 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

print ("Smith dan Roberts mengambil jurusan yang sama.") Lainnya:

sameCourses = smith.intersection (roberts) if

print("Smith dan Roberts mengambil beberapa" \

+ "kursus yang sama :")

untuk kursus dalam kursus yang sama:

pada dalamkursus yang sama:

1. 2 Memilih Struktur Data

1. 3 Implementasi Berbasis Daftar

11 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

12 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

Membandingkan Dua Set

13 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

Mendefinisikan Peta ADT

 Peta (): Buat peta kosong baru.

2. 2 Implementasi Berbasis Daftar

14 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3

3. 1Tipe Data Abstrak MultiArray

15 |Laporan CBR dan Analisis Studi Kasus_Kelompok 3