NEOMUSHLIH

Memasak Pancake Ala Cheff

Pada suatu saat senggang, Farah sedang membuka resep masakannya dan matanya tertuju pada salah satu resep pancakenya. Farah sedang bosan dan ingin mencoba resep pancakenya. Pada saat membentuk lapisan pancake, rupanya Farah kesulitan mencetak adonan dengan lebar yang sama. Alhasil pancake tersebut memiliki lebar yang berbeda satu dengan yang laen. Setelah ditumpuk, lapisan-lapisan pancake membentuk susunan yang tidak terurut. Pancake yang lebih kecil ada yang terletak di bawah pancake yang lebih besar, begitu pula dengan pancake yang lebih besar ada yang terletak di atas pancake yang kecil. Oleh karena itu si Farah perlu melakukan suatu sorting agar susunannya kembali terurut. Dalam proses sorting tersebut hanya dikenal istilah flip, dimana flip itu sendiri adalah proses membalik susunan pancake dari indeks ke t sampai ke atas. Berikut contoh ilustrasinya :

Maka Farah yang juga lulusan S1 teknik Informatika ITS pun membuat simulasinya menggunakan program C :

------------------------------------------------------------------------------------------------------------------------------------------

//bismillah
//PANCAKE FARAH
#include // suatu hari farah ingin membuat pancake. diambillah daftar bahan di library standard
#include //dia juga ingin melihat pancakenya, maka ia mengikutsertakan conio untuk menahan tampilan
#include //ternyata masih ada yang kurang, diambillah sisanya di stdlib.h
#include //karena bahannya ia ambil acak berdasarkan waktu, maka Farah menyertakan time.h

struct cake //pertama ia buat cetakan pancake dari linked list dengan model stack
{ int panjang; //di dalamnya ada ukuran panjang tertentu
cake *turun, *naik; //Farah ingin satu cetakan dengan yang lain bersambung, jadi ya disambung
};
cake *atas=NULL, *bawah=NULL, *gerak, *kunci; //oiya, Farah juga ingin memberi nama cetakannya.
//kalo cetakan paling atas itu atas, paling dasar itu bawah. untuk menggerakkan cetakan, ia butuh variabel gerak dan kunci untuk menandai cetakan batas bawah
struct queue //ia juga menyiapkan tempat cadangan bila pancakenya akan ditata. tempat itu berbentuk linked list bertipe queue
{ int data; //tempat itu harus memiliki ukuran tertentu yang disamakan dengan cetakan pancakenya
queue *next, *prev; //tempat itu juga saling terhubung bolak balik
};
queue *head=NULL, *tail=NULL, *move; //Farah juga menamai tempat itu sesuai kebutuhan. head=paling depan, tail=paling belakang, move untuk menggerakkan/dinamisasi
int a=0,jumlah=0, maks=0, balik=0; //Farah butuh beberapa tempat untuk adonan
//a=tempat memasukkan isi pancake, jumlah=banyaknya lapisan pancake, maks=lapisan pancake terpanjang, balik=menghitung jumlah penataan pancake.
bool status=false; //karena pada mulanya belum urut, maka status pancakenya false
//memanggil fungsi
void push(int a); //fungsi untuk memasukkan lapisan pancake
void cekmaks(); //fungsi untuk mencari lapisan pancake terpanjang
void popcake(); //fungsi untuk mengeluarkan pancake
void pushque(); //fungsi untuk men-enqueue lapisan pancake ke tempat sementara agar mudah ditata
void popque(); //fungsi untuk men-dequeue lapisan pancake dari wadah sementara dan dikembalikan ke pancake
void cekstatus(); //fungsi untuk mengecek urutan dari kecil(paling atas) sampai besar(paling bawah)
void cetak(); //fungi untuk membuat pancake terlihat
//Farah mulai membuat pancake
main() //begini caranya
{ srand(time(NULL)); //pertama kali ia membuat susunan secara random/acak

printf("masukkan jumlah bilangan: "); //dia ingin menentukan jumlah lapisannya
scanf("%d", &jumlah); //Farah sudah dapat jumlah lapisan pancakenya
for(int b=0;bdata; //lalu ia mengambil wadah a sebagai tempat 1 lapisan pancake yang akan dikembalikan ke pancake
push(a); //pancake dikembalikan. urutan teratas sebelumnya jadi terbawah dan sebaliknya
move=move->prev; //Farah berpindah ke wadah yang selanjutnya
}
popque(); //karena memindah, maka Farah meindah semua wadah sampai tidak ada lapisan lagi di wadah sementara
balik++; //Farah menghitung jumlah pemindahan
if(atas->turun==kunci) status=true; //kalo batas flipping sudah sampai bawahnya lapisan puncak, berarti pancake sudah urut
cekstatus(); //Farah mengamati apakah lapisannya sudah urut atau belum
}

printf("\n\nhasil pancake: "); //kalo sudah urut, ia pamer ke teman-temannya
cetak(); //dan memperlihatkan pancakenya
printf("\n\n\njumlah flipping minimum: %d", balik); //dia juga memberitahu jumlah penataan yang dilakukan agar urut
getch();
return 0;
}

void push(int a) //begini cara Farah untuk memasukkan 1 lapisan ke dalam pancake
{ cake *isi=(cake*)malloc(sizeof(cake)); //pertama-tama ia harus menyiapkan tempat kosong untuk cakenya
isi->panjang=a; //ia lalu membuat lapisan sesuai keinginannya secara random
if(atas==NULL) //kalo pancake masih kosong
{ atas=bawah=isi; //lapisan baru jadi paling atas sekaligus paling bawah
bawah->turun=NULL; //Farah tidak membuat lapisan pancake dibawahnya 'bawah;
atas->naik=NULL; } //Farah juga belum membuat lapisan atasnya puncak
else //namun kalo pancakenya ga kosong
{ atas->naik=isi; //Farah memasukkan lapisan baru di atasnya lapisan teratas, biasnya disebut addfirst
isi->turun=atas; //lapisan baru dan atas harus terhubung
atas=isi; //dan lapisan baru jadi yang paling atas
atas->naik=NULL; } //lapisan di atasnya masih kosong.
if(isi->panjang==maks && isi->turun==kunci) //kalo lapisan tepanjang berada di atas batas bawah
{ kunci=isi; //batasnya dinaikkan 1 tingkat di atasnya dan lapisan terbesar tidak akan dipop lagi
maks=0; } //lapisan pancake mulai mencari lapisan terbesar selanjutnya
}

void popque() //begini caranya Farah untuk men-dequeue lapisan pancake yang berada di tempat sementara
{ while(head) head=head->prev; // patokannya dari atas(lapisan yang paling awal masuk)
} //jadi bagian atasnya diambil dan diganti belakangnya
//cara tersebut sering disebut FIFO=first in, first out
void popcake() //begini cara Farah mengeluarkan lapisan pancake
{ if(atas->panjang!=maks) //kalo yang paling atas bukan lapisan terpanjang
{ while(atas!=kunci) //dan juga bukan batas bawah, maka akan dipop sampai lapisan terpanjang ketemu
{ if(atas->panjang==maks) //ternyata farah sudah menemukan lapisan terpanjang
{ atas=atas->turun; break; } //dan dia menge-pop lapisan itu dan sekarang lapisan teratas berada di bawah lapisan terpanjang yang sudah di-pop
else atas=atas->turun; } //kalo belum ketemu, Farah akan terus menyusurinya
}
else if(atas->panjang==maks) //tapi kalo lapisan pertama(teratas) adalah lapisan terpanjang
{ atas=kunci; } //maka semua harus di-pop sampai menyentuh batas bawah, sehingga batas bawah sekarang jadi lapisan teratas
}

void cekmaks() //Farah ingin mencari mencari lapisan terpanjang pancake
{ gerak=atas; //dia mulai dari lapisan teratas
while(gerak!=kunci) //Dia menyusuri sampai batas bawah
{ if(gerak->panjang>maks) { maks=gerak->panjang; } //ternyata ketemu dan Farah menyimpan nilai terpanjang lapisan pancake
gerak=gerak->turun; } //kalo belum ketemu, Farah akan terus menyusuri dari atas ke bawah
}
void pushque() //Farah ingin memasukkan cake ke dalam wadah sementara waktu dilakukan flipping. wadahnya berbentuk queue
{ gerak=atas; //dia mualai dari lapisan teratas
while(gerak!=kunci) //Farah menyusuri sampai lapisan batas bawah
{ move=(queue*)malloc(sizeof(queue)); //dia sipakan tempat untuk wadah sementaranya
move->data=gerak->panjang; //dan dia masukkan lapisan cake ke dalam wadah
if(head==NULL) //kalo wadahnya masih kosong
{ head=tail=move; //lapisan baru itu jadi yang kepala dan jadi ekornya juga
head->next=NULL; //karena masih baru, maka di depan kepala tidak ada apa-apa
tail->prev=NULL; } //begitu pula di belakang ekor juga kosongh
else //tapi kalau wadahnya tidak kosong
{ tail->prev=move; //Farah taruh wadah baru di belakang ekor. ekor disambung dengan wadah baru
move->next=tail; //dan wadah baru juga disambung dengan ekor
tail=move; //karena lapisan baru lebih "terbelakang" daripada ekor, maka lapisan baru jadi ekor
tail->prev=NULL; } //di belakang ekor baru masih kosong
if(gerak->panjang==maks && atas->panjang!=maks) break; //jika yang dimasukkan adl lapisan terpanjang, maka Farah berhenti memasukkan cake ke wadah sementara
else gerak=gerak->turun; //kalau belum ketemu, FArah akan menyusuri dari yang paling depan sampai yang paling belakang
}
}

void cekstatus() //setelah dialkukan beberapa proses, Farah ingin mengecek urutannya
{ gerak=atas; //dia mulai dari cake teratas
cake *banding=gerak->turun; //dia buat variabel lokal untuk membandingkan nilai antara lapisan di atasnya dengan lapisan itu
while(banding) //Farah akan menyusuri semua lapisan sampai kosong
{ if(gerak->panjang<=banding->panjang) status=true; //bila lapisan di 'gerak' lebih kecil daripada lapisan di 'banding' yang berada di bawahnya, maka pancake sudah urut
else { status=false; break; } //tapi kalo belum urut, ia akan keluar dan melakukan proses lagi dan dicek ulang
gerak=gerak->turun; //Farah menyusuri dari atas ke bawah
banding=banding->turun; } //dan membandingkan dengan lapisan di bawahnya lagi
}

void cetak() //Farah ingin melihat pancakenya
{ gerak=atas; //jadi dia mulai melihat lapisan teratas
while(gerak) //sampai semua lapisan dilihat
{ printf(" %d ", gerak->panjang); //ia mencetak pancakenya sesuai panjang lapisan pancake
gerak=gerak->turun; } //dan dia akan terus turun untuk mencetak lapisan di bawahnya
}
//alhamdulillah, sekarang Farah senang. Lapisan Pancakenya sudah terurut dan dia pamerkan pada teman-temannya di kost. tapi sayang Pancakenya sudah tak berbentuk lagi karena terlalu banyak di-flipping

---------------------------------------------------------------------------------------------------------------------------------------

klo ada apa2 tentang code-nya harap hubungi Farah ya, dengan meng-comment artikel ini. makasih.

klo butuh file nya dalam cpp, silahkan ambil.
gratis