Makalah Tugas 1 Puzzle
-
Upload
shavira-dyahayu-permata -
Category
Documents
-
view
202 -
download
25
description
Transcript of Makalah Tugas 1 Puzzle
IMPLEMENTASI KECERDASAN BUATAN
PADA PUZZLE 8
Untuk memenuhi Tugas Matakuliah Kecerdasan Buatan
Oleh :
REZHA KHARISMA PUTRI 409312417680
INGE RATIH PUSPITASARI 409312417682
NINE WINDA YUNITA 409312419793
UNIVERSITAS NEGERI MALANG
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
JURUSAN MATEMATIKA
SEPTEMBER 2012
KATA PENGANTAR
Puji dan syukur dipanjatkan kepada Allah SWT karena berkat rahmat dan hidayah-Nya,
penulis dapat menyelesaikan tugas matakuliah Kecerdasan Buatan yang berjudul Implementasi
Kecerdasan Buatan Pada Puzzle 8.
Ucapan terima kasih kepada semua pihak yang telah memberikan bantuan secara langsung
maupun tidak langsung, sehingga penyusunan tugas ini dapat diselesaikan dengan baik.
Dalam kesempatan kali ini, ucapan terima kasih ditujukan kepada:
1. Allah SWT yang telah memberikan segalanya yang terbaik kepada penulis
2. Bapak Moh. Yasin selaku dosen Pengampu.
3. Kedua orang tua dan segenap keluarga yang selalu mendukung.
4. Seluruh teman mahasiswa Program Studi S1 Matematika Angkatan 2009.
Penulis menyadari bahwa masih banyak kekurangan dalam penulisan tugas ini, oleh karena
itu penulis mengharapkan kritik dan saran yang membangun untuk kesempurnaan tugas ini.
Malang, 25 September 2012
Penulis
DAFTAR ISI
KATA PENGANTAR ................................................................................ i
DAFTAR ISI ............................................................................................... ii
BAB I PENDAHULUAN............................................................................ 1
BAB II DASAR TEORI
2.1 Puzzle......................................................................................... 3
2.2 Algoritma .................................................................................. 4
2.3 Kecerdasan Buatan Pada Puzzle................................................ 7
BAB III DESAIN PROGRAM DAN IMPLEMENTASI............................ 9
BAB IV PENUTUP
4.1 Kesimpulan................................................................................ 11
4.2.Saran........................................................................................... 11
LAMPIRAN ...............................................................................................
BAB I
PENDAHULUAN
Program permainan (game) merupakan salah satu implementasi dari bidang ilmu
komputer. Perkembangan permainan pada masa kini sudah sangat besar dan telah menjadi mode
tersendiri di dunia karena mayoritas pengguna komputer menghabiskan sebagian besar waktu
mereka di depan komputer dalam program permainan. Salah satu game yang diminati yaitu slide
puzzle.
Puzzle adalah representasi permainan teka-teki yang dapat diselesaikan dengan men-
gurutkan atau menyusun komponen-komponen pembentuknya sesuai dengan kondisi yang di-
inginkan. 8-Puzzle adalah permainan teka-teki yang berukuran 3x3. Komponen pada 8-Puzzle
adalah berupa kotak-kotak bernomor atau bergambar (sesuai kebutuhan) yang dapat diacak
sedemikian hingga menjadi suatu pola random yang dapat dicari jalan penyelesaiannya. Sesuai
namanya, 8-Puzzle terdiri atas 8 kotak dan 1 tempat kosong yang dapat digerakkan dengan atu-
ran tertentu. Aturan pergerakannya hanya berupa empat (4) arah pergerakan, yaitu: atas, bawah,
kanan, dan kiri. Serta terlimitasi oleh ukuran dimensi papan yang ditempatinya. Pada 8-Puzzle,
batasannya adalah ukuran 3×3. Sehingga, 8 kotak yang dimiliki hanya dapat bergerak dalam
lingkup ukuran tersebut.
Permasalahan pada 8-puzzle berupa pencarian langkah-langkah konkret sesuai aturan,
sehingga menuju kondisi akhir yang diinginkan. Oleh karena itu, pada bidang Artificial
Intellegence, penyelesaian permasalahan 8-puzzle ini dapat dikategorikan ke dalam pencarian
atau searching.
Kecerdasan buatan atau Artificial Intellegence (AI) adalah salah satu bagian dari ilmu
komputer yang membuat agar mesin (komputer) dapat melakukan pekerjaan seperti dan sebaik
yang dilakukan oleh manusia. Kecerdasan buatan atau AI ini meliputi studi tentang
pemrograman simbolik, penyelesaian masalah (problem solving) dan pencarian (searching).
Penyelesaian 8-puzzle dapat menggunakan algoritma dalam kecerdasaan buatan yaitu
Algoritma A*, Algoritma Hill Climbing Search , Deph-Frist-Search dan masih banyak yang
lainnya. Dari uraian diatas penulis akan membahas sedikit tentang 8-puzzle dengan
menggunakan Algoritma A*.
BAB II
DASAR TEORI
2.1. Puzzle
Puzzle adalah representasi permainan teka-teki yang dapat diselesaikan dengan men-
gurutkan atau menyusun komponen-komponen pembentuknya sesuai dengan kondisi yang di-
inginkan. Puzzle merupakan permainan menyusun potongan hanya dapat dipindahkan dengan
menggesernya ke ruang kosong. Puzzle memiliki tingkat kesulitan yang sangat tinggi dalam
menyelesaikan masalah. Umumnya orang yang memainkan puzzle ini butuh waktu lama dalam
menyelesaikan permainannya. Hal ini disebabkan karena pada slide puzzle tidak ada informasi
tambahan yang dimiliki untuk membantu melakukan pencarian solusi, sehingga saat proses
penyusunan potongan-potongan puzzle terjadi susunan puzzle semula. Untuk menyelesaikan
persoalan pada permainan ini dibutuhkan suatu algoritma pencarian efektif yang dapat
diterapkan. 8-Puzzle adalah permainan teka-teki yang berukuran 3x3. Komponen pada 8-Puzzle
adalah berupa kotak-kotak bernomor atau bergambar (sesuai kebutuhan) yang dapat diacak
sedemikian hingga menjadi suatu pola random yang dapat dicari jalan penyelesaiannya. Sesuai
namanya, 8-Puzzle terdiri atas 8 kotak dan 1 tempat kosong yang dapat digerakkan dengan atu-
ran tertentu. Aturan pergerakannya hanya berupa empat (4) arah pergerakan, yaitu: atas, bawah,
kanan, dan kiri. Serta terlimitasi oleh ukuran dimensi papan yang ditempatinya. Pada 8-Puzzle,
batasannya adalah ukuran 3×3. Sehingga, 8 kotak yang dimiliki hanya dapat bergerak dalam
lingkup ukuran tersebut. Gambar 2.1.1 adalah contoh 8-puzzle.
Gambar 2.1.1
2.2. Algoritma
Algoritma heuristic
Teknik pencarian heuristic merupakan pencarian suatu strategi untuk melakukan proses
pencarian ruang keadaan suatu problema secara selektif, yang memandu proses
pencarian yang kita lakukan di sepanjang jalur yang memiliki kemungkinan sukses
paling besar, dan mengesampingkan usaha yg memboroskan waktu.
Penentuan Rumus Heuristik
Rumus heuristik yang digunakan pada kasus ini adalah |(AbsAwal – OrdAkhir)| + |
(OrdAwal – AbsAkhir)| (1). Rumus heuristik ini diterapkan pada kotak yang mungkin
untuk digerakkan. Kemudian dipilih heuristik yang paling besar diantara semua
kemungkinan tadi. Kotak yang terpilih, akan digerakkan ke kotak yang kosong, lalu
akan dibangkitkan lagi anak pohon dari status yang sekarang. Dan memulai lagi proses
penentuan heuristik untuk kemungkinan kotak yang baru.
Penerapan Algoritma A*
Setelah menentukan heuristik, kita menggerakkan kotak yang terpilih. Setiap
pergerakan yang dilakukan statusnya akan disimpan pada suatu list. List ini akan
digunakan untuk melakukan pengecekan apakah kita sudah pernah membangun status
tersebut atau belum agar kita tidak menggerakkan kotak yang sama berkali-kali ke
status yang sama. Dengan menerapkan strategi ini, selain menemukan solusi, algoritma
ini juga bisa menemukan langkah terpendek untuk mencapai solusi tersebut.
Algoritma A* untuk Persoalan 8 Puzzle
1. Jadikan status awal sebagai akar pohon persoalan.
2. Tentukan heuristik untuk tiap kotak yang mungkin untuk digerakkan.
3. Dari kemungkinan yang ada, lakukan perbandingan heuristiknya.
4. Bila ada nilai heuristik yang sama, maka yang digerakkan adalah kotak yang nilai
heuristiknya ditentukan pertama kali.
5. Bila tidak ada nilai yang sama, maka yang digerakkan adalah kotak yang nilai
heuristiknya yang terbesar
6. Bangkitkan anak pohon status dari simpul saat ini, dengan status baru adalah status
setelah kotak digerakkan
7. Ulangi prosedur 2-6 sampai ditemukan solusi yang paling optimum.
Fungsi heuristic ini digunakan untuk mengevaluasi keadaan-keadaan problema
individual dan menentukan seberapa jauh hal tersebut dapat digunakan untuk mendapatkan
solusi yang diinginkan.
Jenis-jenis pencarian heuristic:
1. Hill Climbing
Hill Climbing sering digunakan jika terdapat fungsi heuristic yang baik untuk
mengevaluasi keadaan (state).
2. Best First Search
Best First Search merupakan algoritma heuristic yang akan mencari rute melewati
keadaan dengan cost terendah menuju keadaan akhirnya.
Suatu keadaan n setidaknya mempunyai 3 macam cost seperti :
a. G(n) : Path Cost, jarak keadaan n dari keadaan awal. Cost ini
menunjukkan tingkat kedalaman pencarian.
b. H(n) : Cost Heuristic, jarak keadaan n ke keadaan akhir. Untuk 8puzzle,
jarak heuristic ini dapat dihitung menggunakan H1(jumlah tile yang
berbeda di keadaan n dan keadaan tujuan) dan H2(Manhattan Distance,
jumlah jarak tile-tile yang tidak bersesuaian antara keadaan n dan
keadaan tujuan).
c. F(n) : Cost Total,cost total ini yang digunakan algoritma untuk
menentukan keadaan mana yang akan diambil sebagai rute menuju
keadaan akhir. Cost mana saja yang akan digunakan untuk menghitung
cost total ini menunjukkan algoritma searching yang digunakan
misalnya:
1. Uniform-cost: f(n)=g(n); dengan kata lain h(n)=0
2. Greedy: f(n)=h(n); dengan kata lain g(n)=0
3. A*/star: f(n)=g(n)+h(n); g(n) dan h(n) keduanya
diperhitungkan.
Dengan nilai cost-nya masing-masing, suatu keadaan dapat
dinyatakan sebagai n(g,h). Satu keadaan diwakili oleh satu node.
Algoritma Best-First mengambil keunggulan dari Breath-First dari
sisi completeness, namun tidak semua node atau keadaan yang akan
dibangkitkan node successornya untuk mencapai solusi yang mungkin.
Hanya node yang memiliki cost terendah (sebagai node terbaik) yang
akan di ekspan.
Perbedaan antara Uniform Cost, Greedy dan A* terletak di penentuan
node terbaik ini :
1. Uniform Cost memilih node dengan path cost, g(n), yang terkecil.
Algoritma ini akan menjamin jalur yang dipilih optimal, namun
memiliki kelemahan terhadap efisiensi karena hampir semua node
dengan level sama akan mempunyai g(n) yang unniform, sehingga
bisa jadi semua node akan diekspan dan ini akan menyerupai
Breadth-First –Search.
2. Greedy memilih node dengan cost heuristic, h(n), terkecil.
Algoritma ini mengejar efisiensi dengan memilih node yang lebih
dekat ke node tujuan. Harga yang harus dibayar adalah adanya
kemungkinan jalur yang dipilih tidak optimal, ada jalur yang
dipilih tidak optimal, ada jalur lain yang lebih pendek yang bisa
ditempuh tapi terlewatkan (algoritma tidak komplit dalam
mengevaluasi node-node).
3. A* memilih node dengan jumlah path cost dan heuristic cost,
f(n)=g(n)+h(n), yang terkecil. A* menggabungkan keunggulan
dari uniform-cost dan greedy, dengan trade-off antara tingkat
optimalitas jalur dan efisiensi yang didapatkan. Dalam
implementasinya, Algoritma A* dapat dibedakan menjadi 4 tipe
sebagai berikut :
a. A* standart
b. A* with guaranteed minimum pathcost
c. Conditional A* with g(n) (optimal greedy)
d. Conditional A* with h(n) (efficient A*)
3. Simulated Annealing (SA)
Simulated Annealing biasanya digunakan untuk penyelesaian masalah yang mana
perubahan keadaan dari suatu kondisi ke kondisi yang lainnya membutuhkan
ruang yang sangat luas, misalkan perubahan gerakan dengan menggunakan
permutasi pada masalah Traveling Salesman Problem.
Algoritma Simulated Annealing (SA)
1. Evaluasi keadaan awal. Jika tujuan maka keluar. Jika tidak lanjutkan dengan
keadaan awwal sebagai keadaan sekarang.
2. Inisialisasi BEST_SO_FAR untuk keadaan sekarang.
3. Inisialisasi T sesuai dengan annealing shedule
4. Kerjakan hingga solusi ditemukan atau sudah tidak ada operator baru lagi akan
diaplikasikan ke kondisi sekarang.
a. Gunakan operator yang belum pernah digunakan untuk menghasilkan
keadaan baru.
b. Evaluasi kondisi baru dengan menghitung:
i. Jika kondisi baru tujuan maka KELUAR.
ii. Jika bukan tujuan, namun nilainya lebih baik dari sekarang, maka
jadikan keadaan tersebut sebagai keadaan sekarang.
iii.Jika nilai kondisi baru tidak lebih baik dari keadaan sekarang, maka
tetapkan kondisi baru sebagai keadaan sekarang dengan probabilitas:
c. Perbaiki T sesuai dengan annealing scheduling
5. BEST_SO_FAR adalah jawaban yang dimaksud.
2.3. Kecerdasan Buatan Pada Puzzle
Kecerdasan buatan merupakan cabang ilmu pengetahuan pada komputer yang dapat
melakukan pekerjaan seperti dan sebaik manusia. Dalam kecerdasan buatan ada beberapa teknik
dalam pemecahan masalah, salah satu yang sering digunakan yaitu teknik pencarian. Salah satu
pencarian yaitu menggunakan fungsi heuristic.
Fungsi heuristic yang dipelajari menggunakan puzzle angka yaitu dengan menghitung
jumlah posisi paling banyak benar, jumlah yang paling tinggi diharapkan paling baik, dan
menghitung jumlah posisi sedikit salah, jumlah yang paling sedikit diharapkan paling baik.
Proses pembelajaran yang pertama yaitu melakukan acak angka puzzle yang telah ditentukan
fungsi heuristicnya. Setelah itu dilakukan tes geser ubin kosong pada setiap operator yang
memungkinkan,setelah dapat nilai yang dicari maka ubin kosong pada puzzle digeser ke arah
yang diharapkan paling baik. Pada penelitian ini proses sekali random yaitu dengan 5 kali geser
ini merupakan kondisi stabil.
BAB III
DESAIN PROGRAM DAN IMPLEMENTASI
Gerakkan f(n) terkecil
Gerakkan f(n) yang pertama kali dicari
Terdapat lebih dari satu nilai terkecil
Dapatkan langkah susun
puzzle
Hitung f(n)=g(n)+h(n)
end
start
Inisialisasi kotak-kotak yang
mungkin untuk digerakkan
Posisi berurut?
ya
tidak
ya
tidak
BAB IV
PENUTUP
4.1. Kesimpulan
Salah satu implementasi kecerdasan buatan adalah pada 8-puzzle. Permasalahan pada 8-
puzzle berupa pencarian langkah-langkah konkret sesuai aturan, sehingga menuju kondisi akhir
yang diinginkan. Pada kecerdasan buatan, penyelesaian permasalahan 8-puzzle ini dapat
dikategorikan ke dalam pencarian atau searching. Salah satu algoritma yang dapat digunakan
untuk menyelesaikan permasalahan pada 8-puzzle adalah algoritma Astar, dengan perhitungan
heuristic manhattan distance.
4.2 Saran
Saran yang dapat diberikan dari penulis adalah dalam program ini, masih banyak kekurangan
yakni belum dapat mencapai goal state. Maka untuk pembaca disarankan untuk menyelasaikan program
ini agar dapat mencapai goal state.
LAMPIRAN
Listing Program
unit puzzle;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ExtCtrls, StdCtrls, Math, XPMan, ShellAPI;
type
TForm17 = class(TForm)
Panel1: TPanel;
Panel2: TPanel;
Panel3: TPanel;
Panel4: TPanel;
Panel6: TPanel;
Panel7: TPanel;
Panel8: TPanel;
Panel5: TPanel;
Bevel1: TBevel;
Button1: TButton;
XPManifest1: TXPManifest;
Button3: TButton;
Label1: TLabel;
Edit1: TEdit;
Label2: TLabel;
Edit2: TEdit;
Edit3: TEdit;
Edit4: TEdit;
Edit5: TEdit;
Label3: TLabel;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Button2: TButton;
Label8: TLabel;
Edit6: TEdit;
Memo1: TMemo;
Label7: TLabel;
Label9: TLabel;
Label10: TLabel;
Label11: TLabel;
Label12: TLabel;
Button4: TButton;
procedure cekbenar;
procedure FormCreate(Sender: TObject);
procedure Panel8Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Label1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form17: TForm17;
blank: TPoint;
points: array [1..9] of TPoint;
time: int64;
done, go: boolean;
h:array [1..4] of integer;
r:integer;
s:TPoint;
implementation
{$R *.dfm}
procedure RenderCell(id: integer);
begin
TPanel(Form17.FindComponent('Panel' + inttostr(id))).Top := (61 * (points[id].y - 1)) + 3;
TPanel(Form17.FindComponent('Panel' + inttostr(id))).Left := (66 * (points[id].x - 1)) + 4;
end;
function pe(p1, p2: TPoint): boolean;
begin
if (p1.X = p2.x) and (p1.Y = p2.y) then begin
Result := true;
end else begin
Result := false;
end;
end;
procedure Check();
var
timestr: string;
begin
if (pe(points[1], Point(1 , 1))) and (pe(points[2], Point(2 , 1))) and (pe(points[3], Point(3 , 1)))
and (pe(points[4], Point(1 , 2))) and (pe(points[5], Point(2 , 2))) and (pe(points[6], Point(3 , 2)))
and (pe(points[7], Point(1 , 3))) and (pe(points[8], Point(2 , 3))) then begin
done := true;
time := GetTickCount - time;
go := false;
if time div 1000 > 60 then begin
timestr := IntToStr(time div 60000) + '.' + IntToStr((time mod 60000) div 6000) + ' Minutes';
end else begin
timestr := IntToStr(time div 1000) + '.' + IntToStr(time mod 1000) + ' Seconds';
end;
Showmessage('You Won!' + #13 + 'Time: ' + timestr);
time := 0;
end;
end;
function heuristik():integer;
var
h1,h2,h3,h4,h5,h6,h7,h8:integer;
h:integer;
begin
h1:=abs((points[1].x-1))+abs((points[1].y-1));
h2:=abs((points[2].x-2))+abs((points[2].y-1));
h3:=abs((points[3].x-3))+abs((points[3].y-1));
h4:=abs((points[4].x-1))+abs((points[4].y-2));
h5:=abs((points[5].x-2))+abs((points[5].y-2));
h6:=abs((points[6].x-3))+abs((points[6].y-2));
h7:=abs((points[7].x-1))+abs((points[7].y-3));
h8:=abs((points[8].x-2))+abs((points[8].y-3));
h:=h1+h2+h3+h4+h5+h6+h7+h8;
Result:=h;
end;
procedure RandomizePuzzle();
var
i, j, x: integer;
buffer: array[1..8] of TPoint;
bufpoint: TPoint;
label check;
begin
for x := 0 to 7 do
begin
Randomize;
for I := 1 to 8 do
begin
buffer[i] := points[i];
end;
j := randomrange(2, 9);
for I := j downto 1 do
begin
points[i] := buffer[i + 1];
end;
points[j] := buffer[1];
points[1] := buffer[2];
end;
bufpoint := points[7];
points[7] := points[8];
points[8] := bufpoint;
for I := 1 to 8 do
begin
RenderCell(i);
end;
go := true;
end;
procedure TForm17.Button1Click(Sender: TObject);
var
heu:integer;
begin
RandomizePuzzle();
cekbenar;
heu:=heuristik;
edit6.Text:=inttostr(heu);
end;
procedure TForm17.Button3Click(Sender: TObject);
begin
application.Terminate;
end;
procedure TForm17.FormCreate(Sender: TObject);
var
i: integer;
begin
time := 0;
done := true;
go := false;
blank := Point(3, 3);
for I := 1 to 8 do begin
points[i] := Point((I mod 3) + 0, (I div 3) + 1);
if points[i].x = 0 then begin
points[i].x := 3;
end;
if i > 6 then begin
points[i].Y := 3;
end;
if i mod 3 = 0 then begin
points[i].Y := points[i].Y - 1;
end;
end;
points[1].X := 1;
points[8].X := 2;
end;
procedure TForm17.Label1Click(Sender: TObject);
begin
ShellExecute(handle, 'open', 'http://www.asimtot.wordpress.com', nil, nil, SW_SHOWNOR-
MAL);
end;
procedure TForm17.Panel8Click(Sender: TObject);
var
id, heu: integer;
p, p2: TPoint;
begin
if go then begin
if done then begin
time := GetTickCount();
end;
done := false;
id := (Sender as TPanel).Tag;
p := blank;
p2 := point(0,0);
if (p.x - 1 = points[id].x) and (p.y = points[id].y) then begin
p2 := points[id];
points[id] := p;
p := p2;
end else if (p.x + 1 = points[id].x) and (p.y = points[id].y) then begin
p2 := points[id];
points[id] := p;
p := p2;
end else if (p.y - 1 = points[id].y) and (p.x = points[id].x) then begin
p2 := points[id];
points[id] := p;
p := p2;
end else if (p.y + 1 = points[id].y) and (p.x = points[id].x) then begin
p2 := points[id];
points[id] := p;
p := p2;
end;
blank := p;
RenderCell(id);
Check();
end;
cekbenar;
heu:=heuristik;
edit6.Text:=inttostr(heu);
end;
procedure TForm17.cekbenar;
var
n,k,i:integer;
begin
n:=0;
for i:=1 to 8 do
begin
if i<=3 then
begin
if (pe(points[i], Point(((i-1) mod 3)+1 , 1))) then
begin
k:=1;
n:=n+k
end;
end;
if (i>3) and (i<=6) then
begin
if pe(points[i], Point(((i-1) mod 3)+1 , 2)) then
begin
k:=1;
n:=n+k
end;
end;
if i>6 then
begin
if pe(points[i], Point(((i-1) mod 3)+1 , 3)) then
begin
k:=1;
n:=n+k
end;
end;
end;
edit1.Text:=inttostr(n);
end;
function atas(blank:TPoint):integer;
var
i,k:integer;
begin
for i:=1 to 8 do
begin
if ((points[i].x)=(blank.x)) and ((points[i].y)=(blank.y)-1) then
begin
k:=i;
break;
end;
end;
Result:=k;
end;
function bawah(blank:TPoint):integer;
var
i,k:integer;
begin
for i:=1 to 8 do
begin
if ((points[i].x)=(blank.x)) and ((points[i].y)=(blank.y)+1) then
begin
k:=i;
break;
end;
end;
Result:=k;
end;
function kiri(blank:TPoint):integer;
var
i,k:integer;
begin
for i:=1 to 8 do
begin
if ((points[i].x)=(blank.x)-1) and ((points[i].y)=(blank.y)) then
begin
k:=i;
break;
end;
end;
Result:=k;
end;
function kanan(blank:TPoint):integer;
var
i,k:integer;
begin
for i:=1 to 8 do
begin
if ((points[i].x)=(blank.x)+1) and ((points[i].y)=(blank.y)) then
begin
k:=i;
break;
end;
end;
Result:=k;
end;
function pindah(b:integer):integer;
var
po:TPoint;
ka:integer;
begin
po:=blank;
blank:=points[b];
points[b]:=po;
ka:=heuristik;
po:=blank;
blank:=points[b];
points[b]:=po;
Result:=ka;
end;
procedure TForm17.Button2Click(Sender: TObject);
var
ka,ki,nd,ni,mi,jj,j,cc:integer;
begin
if (blank.x=1) or (blank.x=2) then
begin
ka:=kanan(blank);
h[4]:=pindah(ka);
edit4.Text:=inttostr(h[4]);
end
else
begin
h[4]:=99;
edit4.Text:='99';
end;
if (blank.x=2) or (blank.x=3) then
begin
ki:=kiri(blank);
h[2]:=pindah(ki);
edit3.Text:=inttostr(h[2]);
end
else
begin
h[2]:=99;
edit3.Text:='99';
end;
if (blank.y=1) or (blank.y=2) then
begin
ni:=bawah(blank);
h[3]:=pindah(ni);
edit5.Text:=inttostr(h[3]);
end
else
begin
h[3]:=99;
edit5.Text:='99';
end;
if (blank.y=2) or (blank.y=3) then
begin
nd:=atas(blank);
h[1]:=pindah(nd);
edit2.Text:=inttostr(h[1]);
end
else
begin
h[1]:=99;
edit2.Text:='99';
end;
mi:=min(min(min(h[1],h[2]),h[3]),h[4]);
cc:=randomrange(0,3);
if cc=1 then begin for j:=1 to 4 do begin if h[j]=mi then jj:=j; end; if jj=1 then r:=nd; if jj=2 then
r:=ki; if jj=3 then r:=ni; if jj=4 then r:=ka; end;
if cc=2 then begin for j:=4 downto 1 do begin if h[j]=mi then jj:=j; end; if jj=1 then r:=nd; if jj=2
then r:=ki; if jj=3 then r:=ni; if jj=4 then r:=ka; end;
memo1.lines.add(inttostr(r));
s:=blank;
blank:=points[r];
points[r]:=s;
RenderCell(r);
end;
procedure TForm17.Button4Click(Sender: TObject);
begin
s:=blank;
blank:=points[r];
points[r]:=s;
RenderCell(r);
Check();
end;
end.