Kumpulan Tugas kampus

Senin, 14 Juni 2021

Laporan tugas kelompok Human Computer Interaction

Dalam pembuatan proyek kami, kami mengevaluasi proyek kami melalui UI/UX dengan inspeksi secara evaluasi heuristik, sebelum mengevaluasi, kami melakukan proses desain membangun User interface dan user experience antara lain sebagai berikut:

Understand
Sebelum memulai desain, ada baiknya kita mempelajari apa saja yang dibutuhkan untuk memecahkan masalah yang ada. Jadi dalam desain kami, dengan hadirnya batik membuat masyarakat indonesia maupun luar negeri menjadi jauh lebih tertarik dengan barang produk lokal Indonesia.
Research
Menganalisa pesaing atau kompetitor, Meriset trend terkini, dan pikirkan desain dan opsi yang dapat membuat UX bagus, sehingga dengan riset ini mampu membawakan peminat bagi orang yang tertarik pada website kami
Sketch
Mengumpulkan Ide dari anggota kelompok, Menggambarkan sketsa layout, Serta lakukan diskusi secara berulang
Design
Desain gambar, Membuat layout, mencari asset gambar, memilih penggunaan text yang sesuai
Implementation
Mencoba hasil desain yang telah dibuat. Saat implementasi, mungkin akan ada perubahan kecil yang perlu dilakukan untuk menghasilkan desain yang optimal.
Evaluate
Membuat laporan desain yang telah dibuat sesuai dengan beberapa faktor:

Kegunaan sistem
Sulit tidaknya ketika digunakan end User
Apakah fleksibel dan mudah diubah
Apakah memberikan solusi yang diinginkan untuk mengatasi masalah pengguna
Tingkat kredibilitas yang membuat seseorang memutuskan menggunakan produk

Dan dengan tipe evaluasi heuristik yang dimana evaluasi heuristik dapat dilakukan pada tahap apapun sepanjang proses desain interface. Dan apa saja sih yang harus dilakukan dalam evaluasi heuristik ini? Tim kami melakukannya antara lain sebagai berikut:

Clarity
Membuat website harus sejelas-jelasnya dan dapat digunakan sesuai dengan kebutuhan pengguna web. Dengan penyampaian informasi yang singkat dan jelas, seperti icon yang tidak berbelit-belit, dan penggunaan perkataan yang jelas dan tidak mengulang.
Minimize unnecessary complexity and cognitive load

Membuat tampilan website sesimpel mungkin untuk pengguna. Pecah proses rumit menjadi beberapa langkah, komponen-komponen yang tidak terlalu rumit dan penggunaan warna harus jelas.

Provide user with context
Membuat tampilan website harus menyediakan konteks dan waktu yang jelas, sehingga website menjadi lebih enak dilihat dari segi informasi dan pemahaman pengguna. Seperti nama website yang jelas, tidak berbelit-belit dalam animasi dan memberikan kemudahan pengguna dalam menggunakan website.
Promote a pleasurable and positive user experience

Desain harus menyenangkan secara estetika dan mempromosikan pengalaman yang menyenangkan dan bermanfaat. Berikan tujuan yang mudah dicapai, dan memberikan tanggapan positif untuk pengguna website.

Selasa, 09 Juni 2020

Ringkasan Data Structure after UTS

Nama: Vincent Fanditama Wijaya
NIM: 2301885983
Hari, tanggal: Selasa, 9/6/2020
Kelas: CB01-CL
Lecturer: Ferdinand Ariandy Luwinda (D4522) dan Henry Chong ( D4460 )
Lecturer kelas kecil LB08: Diana (D4458)

AVL Tree

Jadi pada pertemuan tanggal 28 April 2020, kelas kami membahas tentang AVL Tree. Penamaan AVL Tree berasal dari 2 penemu nya yang bernama "Adelson-Veleskii dan Landis". Fungsi utama dari penerapan konsep AVL tree adalah untuk menyeimbangkan BST (Binary Search Tree). Tingkat kekompleksan pengunaan AVL Tree hingga log n, dimana BST hanya sampai n saja.

Ciri-ciri AVL Tree mirip seperti BST, hanya dia memerlukan keseimbangan antara subtree kiri dengan kanan, dengan toleransi max selisih kanan-kiri nya =1.

Jika terdapat ketidakseimbangan antara subtree kanan dan subtree kiri yang melebihi selisih 1, maka kita perlu melakukan rebalance, bisa hanya single rotation, maupun double rotation

untuk melakukan pengukuran penyeimbangan, diperlukan pencarian node yang paling terdalam di subtree kiri vs subtree kanan

1. Untuk operasi insertion pada AVL Tree:
1. pertama masukkan key baru seperti biasa di BST
2. Jika tidak seimbang antara subtree kiri dengan subtree kanan, maka bisa dilakukan rebalanced, seperti ilustrasi dibawah

Seperti kita lihat, ketika kita memasukkan key "4", maka terjadi ketidakseimbangan di node key 3, maka perlu dilakukan penggeseran node di node "3"

Penyeimbangan, dilakukan pada node yang paling terdalam

Ketidaksesuaian pada subtree bagian kiri dan anak subtree kiri terdalam DAN Ketidaksesuaian pada subtree bagian kanan dan anak subtree kanan terdalam, dapat dilakukan hanya menggunakan single rotation. (paling mudah, cari yang paling terdalam dan lurus tidak bengkok)

Sedangkan, Ketidaksesuaian pada subtree bagian kiri dan anak subtree kanan terdalam DAN Ketidaksesuaian pada subtree bagian kanan dan anak subtree kiri terdalam, dapat dilakukan menggunakan double rotation. (paling mudah, cari yang paling terdalam dan terlihat cabangnya bengkok)

Contoh ilustrasi single rotation (ketika new key 12, barusan dimasukkan kedalam tree)

Terlihat di node 30 terjadi ketimpangan, antara subtree kanan dan subtree kiri, oleh sebab itu, subtree yang terpanjang/terdalam digeser ke arah berlawanan, dan tiap anak node "22" yang terkena geser (27 dan 29), maka diperlukan penataan ulang juga dari atas.

Contoh ilustrasi double rotation (ketika new key 26, barusan dimasukkan kedalam tree)

Rotasi pertama:

Terjadi ketimpangan pada node 30, dimana node terdalam berada di cabang node 22 (cabang bengkok) , maka pertama tama diperlukan penarikan node 27 ke arah berlawanan. Lalu anak dari node 27, perlu penataan ulang dari atas.

Rotasi kedua:
Setelah itu, terjadi ketimpangan di node 30 sebelah kiri, maka perlu ditarik node 27 ke arah berlawanan, dan tiap anak dari node 27 (29), ditata ulang dari atas.

2. Untuk operasi delete pada AVL tree:
1. Node yang boleh di delete, adalah node yang hanya memiliki 1 anak saja atau 0 anak
2. Jika tidak seimbang antara subtree kiri dengan subtree kanan, maka bisa dilakukan rebalanced, seperti insertion balanced (single rotation maupun double rotation).

Untuk simulasi dan lebih jelasnya, bisa dicoba sendiri menggunakan simulator:
https://www.cs.usfca.edu/~galles/visualization/AVLtree.html

Sekian, ringkasan pada pertemuan pembelajaran kali ini. Terima Kasih.

Heaps and Tries

Heap adalah binary tree yang terdiri dari berbagai macam jenis heap.

Macam-macam heap:
1. Min Heap (ascending order)
2. Max Heap (descending order)
3. Min-Max Heap

Aturan Heap mirip dengan aturan binary tree biasa, tetapi ditambah spesifik, seperti:

Min heap: memiliki ciri root nya merupakan bilangan terkecil. Heap biasanya menggunakan implementasi array yang dimulai dari index ke 1 (root) untuk mempermudah perhitungan rumus.

Contoh ilustrasi:

Terlihat angka 7 merupakan nilai minimum dan diletakkan di root

Bentuk Array dan index dr tree disamping

7, 15, 10, 18, 28, 17, 12, 21, .....
1, 2, 3, 4, 5, 6, 7, 8, ....

Rumus untuk mencari f(x), dimana x merupakan current node:
- Parent(x) = x/2
- Anak kiri(x) = 2*x
- Anak kanan(x) = 2 *x+1

Jadi, pembuktiannya:

1. misalkan kita mau mencari parent dari 15. 15 merupakan index ke 2. Maka 2/2= 1. Jadi parent dari 15 adalah index ke 1 yaitu 7
2. misalkan kita mau mencari anak kanan dari 15. 15 merupakan index ke 2. Maka 2*2 + 1 = 5. Jadi anak kanan dari 15 adalah index ke 5 yaitu 28.

Nilai min dari min-heap selalu berada di index pertama atau di root

Cara push heap di min-heap adalah dengan metode push-uphead. Isi dari index paling akhir. Lalu swap (tukar) dengan parent nya jika value childnya lebih kecil. Tukar terus sampai value anaknya nya lebih besar daripada parent nya atau sampai dengan root (index ke 1).

Cara delete di min-heap adalah dengan membuang root nya saja (value terkecil/index ke 1). Setelah selesai delete, maka tukar root dengan index terakhir dari heap. Lalu sesuaikan lagi nilai minimum root dengan cara tukar dengan child bagian kanan/kiri nya (downheap root) sampai nilai paling kecil kembali ke root nya.

Max Heap: memiliki ciri root nya merupakan bilangan terbesar. Heap biasanya menggunakan implementasi array yang dimulai dari index ke 1 (root) untuk mempermudah perhitungan rumus.
Cara push dan delete nya sama dengan min-heap, tapi dia fokus dari besar-kecil.

Min-Max Heap: Tiap kedalaman genap selalu berisi nilai min dari anak-anaknya. Sedangkan tiap kedalaman ganjil selalu berisi nilai max dari anak-anaknya.

Contoh ilustrasinya:

Nilai Minimum selalu berada di rootnya. Sedangkan nilai max selalu berada di salah satu anak dari root nya (baik kanan atau kiri nya) (level 1).

Insertion selalu dari index paling terakhir. Dan intinya adalah baris yang min level dibandingkan dengan baris yang min level atasnya. Sedangkan baris yang max level dibandingkan dengan max level atasnya.

Jika node baru berada di kedalaman genap (min):

Jika parent nya lebih kecil dari node barunya maka tukar dan berlakukan upheapmax
Jika parent nya lebih besar dari node barunya maka berlakukan upheapmin

Jika node baru berada di kedalaman ganjil (max):

Jika parent nya lebih besar dari node barunya maka tukar dan berlakukan upheapmin
Jika parent nya lebih kecil dari node barunya maka berlakukan upheapmax

Upheapmin

Bandingkan nilai node saat ini dengan nilai grand-parent-nya. Jika nilai node saat ini lebih kecil dari nilai induknya daripada swap nilai-nilai mereka dan teruskan sampai grand-parent node.

Upheadmax
Bandingkan nilai node saat ini dengan nilai grand-parent-nya. Jika nilai node saat ini lebih besar dari nilai induknya daripada swap nilai-nilai mereka dan teruskan sampai grand-parent node.

Delete hanya bisa dilakukan pada nilai max dan nilai min

Jika melakukan delete pada nilai minimum atau maximum, maka gantikan nilai root dengan element di index terakhir (genap/ganjil). Mirip caranya dengan min heap.

TRIES adalah tree yang tiap setiap vertex nya mempresentasikan 1 kata (string)

Ciri-ciri nya:
1. Root nya selalu berupa karakter NULL (kosong) (takde isi)
2. Setiap vertex nya mempresentasikan 1 kata (string) yang terdiri dari kumpulan char
3. Ada boolean yang menyatakan end. (Kata itu sudah berakhir)

Contoh ilustrasinya:

Contoh aplikasi Tries:
1. Spell checker
2. Autocomplete/predictive text
3. Dictionary searching

Sekian pertemuan minggu ini.

Selasa, 12 Mei 2020

Heaps and Tries

Contoh aplikasi Tries:
1. Spell checker
2. Autocomplete/predictive text
3. Dictionary searching

Sekian pertemuan minggu ini.

Selasa, 28 April 2020

AVL Tree

Rotasi pertama:

Rabu, 01 April 2020

Rangkuman setengah semester dan soal coding

Apa itu Linked List

Linked list adalah struktur data yang terdiri dari urutan record data dimana setiap record memiliki field yang menyimpan alamat/referensi dari record selanjutnya (dalam urutan).

Macam- Macam Linked List yang akan dibahas kali ini:

1.Single Linked List

Single Linked List merupakan suatu linked list yang hanya memiliki satu variabel pointer saja. Dimana pointer tersebut menunjuk ke node selanjutnya. Biasanya field pada tail menunjuk ke NULL. Berikut source code linked list;
struct data
{
int angka;
struct data *next;
}*head,*tail,*curr;

void pushdpn(int a){
curr = (struct data*) malloc(sizeof(struct data));
curr->angka = a;

if (head==NULL)
{
  head=tail=curr;
  tail->next=NULL;
}
else
{
  curr->next=head;
  head=curr;
}
}
void pushblkg(int a)
{
curr=(struct data*) malloc (sizeof(struct data));
curr->angka=a;

if (head==NULL)
{
  head=tail=curr;
  tail->next=NULL;
}

else
{
  tail->next=curr;
  tail=curr;
  tail->next=NULL;
}
}
void pop(int a){
curr=head;
if (curr->angka==a)
{
   if (head!=NULL)
   {
    curr=head;
    head=head->next;
    free(curr);
   }
}
else
{
  while (curr->next->angka!=a)
  {
curr=curr->next;
  }
  struct data *temp;
  temp=curr->next;
  curr->next=temp->next;
  free(temp);
}
}
void cetak()
{
curr=head;
while(curr!=NULL)
{
  printf("%d ", curr->angka);
  curr=curr->next;
}
}
int main (){
pushdpn(10);
pushblkg(100);
pushblkg(40);
pushdpn(200);
pop(100);
cetak();

return 0;
}

2. Circular Single Linked List

Merupakan suatu linked list dimana tail(node terakhir) menunjuk ke head (node pertama). Jadi, tidak ada pointer yang menunjuk ke NULL.

3. Circular double Linked List

Hampir sama dengan Circular Single Linked list, akan tetapi ada 2 pointer di setiap nodes.

4. Double Linked List

Merupakan suatu linked list yang memiliki dua variabel pointer yang menunjuk ke node selanjutnya dan pointer yang menunjuk ke node sebelumnya. Setiap head dan tail juga menunjuk ke NULL.

Apa itu Hashing

Hashing adalah cara untuk menyimpan data dimana data kita akan dibuat lebih singkat dengan menggunakan key. Biasa nya data nya bisa disimpan dalam bentuk array.Ada beberapa jenis hash function
a. Mid-square

b. Divisi (paling umum)

c. Fold

d. Ekstraksi Digit

e. Rotasi Hash

Untuk collision adalah cara handle ketika hash key kita sama sehingga tidak unik lagi, makanya kita butuh penanganan kejadian seperti ini. Ada 2 jenis penanganan collision;
1. Linear Probing

Pada saat terjadi collision, maka akan mencari posisi yang kosong di bawah tempat terjadinya collision, jika masih penuh terus ke bawah, hingga ketemu tempat yang kosong. Jika tidak ada tempat yang kosong berarti HashTable sudah penuh

2. Chaining

Tambahkan key and entry di manapun dalam list (lebih mudah dari depan)

Kerugian: Overhead pada memory tinggi jika jumlah entry sedikit

Keunggulan dibandingkan open addressing:

- Proses insert dan remove lebih sederhana

- Ukuran Array bukan batasan (tetapi harus tetap meminimalisir collision: buat ukuran tabel sesuai dengan jumlah key dan entry yang diharapkan)

Binary Tree

Binary Search Tree adalah binary tree yang sudah di sort atau diurutkan

Bagian sub kiri tree mengandung element yang lebih kecil daripada yang tersimpan di variabel x
Bagian sub kanan tree mengandung element yang lebih besar daripada yang tersimpan di variabel x

3 operasi dalam binary tree search adalah
1. Find key(x)

Anggaplah kata kunci nya adalah variabel x:
I. Kita mulai dari akar
II. Jika root berisi X maka pencarian berhasil dihentikan.
III. Jika X kurang dari kunci root, maka cari secara rekursif pada sub pohon kiri, jika tidak cari secara rekursif pada sub pohon kanan.

2. Insert key (x) pakai metode rekursif

Anggaplah kata kunci nya adalah variabel x:

I. Mulailah dari akar

II. Jika X kurang dari kunci simpul maka masukkan X ke sub pohon kiri, jika tidak masukkan X ke sub pohon kanan

III. Ulangi sampai kami menemukan simpul kosong untuk meletakkan X (X akan selalu menjadi daun baru)

3. Remove key (x)

Ada 3 kasus yang harus dipertimbangkan:

I. Jika kunci ada di daun, hapus saja simpul itu.

II. Jika kunci ada di simpul yang memiliki satu anak, hapus simpul itu dan sambungkan anaknya

ke induknya

III. Jika kunci ada di simpul yang memiliki dua anak, temukan anak paling kanan dari sub pohon kirinya (simpul P), ganti kuncinya dengan kunci P dan hapus P secara rekursif. (atau secara bergantian Anda dapat memilih anak paling kiri dari sub pohon kanannya)

Soal coding AprilMarket with double linked list source code:

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

struct data{
char nama[101];
int jumlah;
long long int harga;
struct data *next, *prev;
}*head=NULL,*tail=NULL,*curr=NULL;

void pushdpn(char namaI[],int jumlahI,long long int hargaI){
curr=(struct data*) malloc(sizeof(struct data));

strcpy(curr->nama,namaI);
curr->jumlah=jumlahI;
curr->harga=hargaI;

if (head==NULL)
{
head=tail=curr;
}
else
{
curr->next=head;
head->prev=curr;
head=curr;
}
tail->next=head->prev=NULL;
}

void pushblkg(char namaI[],int jumlahI,long long int hargaI){
curr=(struct data*) malloc(sizeof(struct data));
strcpy(curr->nama,namaI);
curr->jumlah=jumlahI;
curr->harga=hargaI;
if (head==NULL)
{
head=tail=NULL;
}
else
{
tail->next=curr;
curr->prev=tail;
tail=curr;
}
head->prev=tail->next=NULL;
}

void push(char namaI[],int jumlahI, long long int hargaI)
{
curr = (struct data*)malloc(sizeof(struct data));

strcpy(curr->nama,namaI);
curr->jumlah=jumlahI;
curr->harga=hargaI;

if (head==NULL)
{
head=tail=curr;
}

else if (strcmp(curr->nama,head->nama)<0)
{
pushdpn(namaI,jumlahI,hargaI);
}
else if (strcmp(curr->nama,tail->nama)>0)
{
pushblkg(namaI,jumlahI,hargaI);
}
else
{
struct data*temp;
temp=head;

while (strcmp(temp->next->nama,curr->nama)<0)
{
temp=temp->next;
}

curr->next = temp->next;
temp->next->prev=curr;
temp->next=curr;
curr->prev=temp;
}
}

void edit(char namaI[],int jumlahI, long long int hargaI)
{
struct data *search=head;
while (search!=NULL)
{
if (strcmp(search->nama,namaI)==0)
{
search->jumlah=jumlahI;
search->harga=hargaI;
break;
}
search=search->next;
}
}

void popdpn()
{
curr =head;
head=head->next;
free (curr);
head->prev=NULL;
}

void popblkg(){
curr=tail;
tail=tail->prev;
free(curr);
tail->next=NULL;
}

void pop(char namaI[]){

if(strcmp(head->nama,namaI)==0)
{
popdpn();

}

else if (strcmp(tail->nama,namaI)==0)
{
popblkg();

}
else
{
struct data *temp = head;
int val=0;
val = strcmp(temp->next->nama,namaI);
while(val!=0)
{
temp=temp->next;
}
curr=temp->next;
temp->next=curr->next;
curr->next->prev=temp;
free(curr);
}
}

void cetak(){
curr=head;
if (curr==NULL)
{
printf("No Data\n");
}
else
{
printf("| %-10s | %-3s | %-10s | %-10s |\n","Nama Barang", "Jumlah Barang", "Harga","Total");
printf("-----------------------------------------------------------------\n");
while(curr!=NULL)
{
long long int total=curr->jumlah*curr->harga;
printf("| %-11s | %-13d | %-10lld | %-10lld |\n",curr->nama,curr->jumlah,curr->harga,total);
curr=curr->next;
}
}
printf("-----------------------------------------------------------------\n");
printf("Grand Total= Kindness is Free\n") ;
puts("");
}

int n=0;

//opsi tampilan

void menu(){
printf("Welcome to Aprilmarket\n");
printf("------------------------\n");
printf("1. Add Item\n");
printf("2. Edit Item Quantity\n");
printf("3. Delete Item\n");
printf("4. Print the bill\n");
printf("5. Exit\n");
printf("Your choice: ");
scanf("%d",&n);getchar();
}
void add(){
char NamaInput[101];
int jumlah=0;
long long int harga=0;
printf("Masukkan nama barang: ");
scanf("%[^\n]",NamaInput); getchar();
puts("");
printf("Masukkan jumlah yang dibeli: ");
scanf("%d",&jumlah);
getchar();
harga=(rand()%100)*1000;
push(NamaInput,jumlah,harga);
printf("Barang berhasil ditambahkan!\n\n");
}
void ganti(){
char NamaInput[101];
int jumlah=0;
long long int harga=0;
printf("Masukkan nama barang yang diedit: ");
scanf("%[^\n]",NamaInput); getchar();
puts("");
printf("Masukkan jumlah barang yang diedit: ");
scanf("%d",&jumlah);
getchar();
harga=(rand()%100)*1000;
edit(NamaInput,jumlah,harga);
printf("Barang berhasil diedit!\n\n");
}
void buang(){
char NamaInput[101];
printf("Masukkan nama barang: ");
scanf("%[^\n]",NamaInput); getchar();
puts("");
pop(NamaInput);
printf("Barang berhasil dihapus!\n\n");
}

int main(){
srand(time(0));
do{
menu();
if (n==1)
{
add();
}
else if (n==2)
{
ganti();
}
else if (n==3)
{
buang();
}
else if (n==4)
{
cetak();
n=5;
}
}while(n!=5);

return 0;
}

Senin, 14 Juni 2021

Laporan tugas kelompok Human Computer Interaction

Selasa, 09 Juni 2020

Ringkasan Data Structure after UTS

Nama: Vincent Fanditama Wijaya NIM: 2301885983 Hari, tanggal: Selasa, 9/6/2020 Kelas: CB01-CL Lecturer: Ferdinand Ariandy Luwinda (D4522) dan Henry Chong ( D4460 ) Lecturer kelas kecil LB08: Diana (D4458) AVL Tree

Heaps and Tries

Selasa, 12 Mei 2020

Heaps and Tries

Selasa, 28 April 2020

AVL Tree

Rabu, 01 April 2020

Rangkuman setengah semester dan soal coding

Nama: Vincent Fanditama Wijaya
NIM: 2301885983
Hari, tanggal: Selasa, 9/6/2020
Kelas: CB01-CL
Lecturer: Ferdinand Ariandy Luwinda (D4522) dan Henry Chong ( D4460 )
Lecturer kelas kecil LB08: Diana (D4458)

AVL Tree