te hol dolgozol most? épp melót keresek, ahol elbírják ha nem vállalok teljes munkaidőt, és nem ilyen biszembaszom párforintos "gyakornok"-ként vagyok ott.

.net/asp/javascript érdekel. nem tudsz valami faszányos helyet? jó PM-ben is

This post was edited by kuzdithom on Nov 17 2013 12:05pm

correct'd

jo hogy rajottem igy este nyolckor, hogy teljes hulyeseget csinaltam egesz nap, es magamtol ez nem fog menni

utana olvastam es most meg kell prokramozni az egeszet ujra

;_;

ez (amit írtam) természetesen nem fog működni, csak jegyzettömbnek használtam a VS-t

csak hogy mit kéne, körvonalakban....

// ahol ExecuteSearch egy sima lokális hegymászó keresés, az se biztos hogy az jó erre a célra (= hogy egyáltalán talál-e IsGoal() State-et) // E sőt szerintem biztos hogy ide gráfkeresés kell (nyíltcsúcsok, bejárt csúcsok etc)

majd postolom a heurisztikát, ha sikerült kigugliznom a "nim-sum"-ot, de valami olyasmi lesz hogy


ebben azért nem vagyok biztos mert nem tudom pontosan hogy mit is akar, de valami olyasmi hogy bitenként összeadjuk az elemeket, majd rávágunk egy xort, mindjárt megnézem rendesen

viszont ezt nem fogod csak úgy 1 óra alatt összedobni ^^



This post was edited by Anarkin on Nov 17 2013 01:23pm

szomorú vagyok hogy naivan nekiálltam, hogy majd magamtól kitalálom a heurisztikát

de amúgy annyira nem nehéz, a lényeg, az hogy átváltod kettes számrendszerbe az összeset, és úgy adod össze, hogy nem viszel át semmit, tehát az oszlop ahol páratlan egyes van oda egyes kerül, ahol páros oda 0

1 3 5 7

001
011
101
111
-----
000

és ezt az összeget mindig 000-n kell majd tartani

ebből a játékos húz akkor a nim összeg változik

1 1 5 7

001
001
101
111
-----
010

ezt vissza kell állítani 000-ra így

001
001
101
101
----
000

tehát 1 1 5 5

és így a gép biztosan nyerni fog.

Ezt szerintem annyira nem nehéz leprogramozni, és nem kell keresési fát építeni, és gyorsan meglesz.

Mondjuk gecigusztustalan lesz, eléggé ég a pofám, látszani fog hogy kiguglizott shiet, de az ötöst csak megadja.

This post was edited by jarabekg on Nov 17 2013 01:29pm

igazából a keresés nem is kell konkrétan a feladathoz


a program nyílván máshogy nézne ki, ott egy CurrentState-et tartana karban a GUI

a CurrentState nyílván ez az osztály lenne

és a GetChildren pedig helyben kiértékeli a gyerekeit (mint lehetséges következő lépéseket) aszerint hogy melyiknek 0 a heurisztikája, és azt választaná az AI player


.. csak hogy támpontot adjak arra hogy ezt hogy lehetne visszabutítani és felokosítani a konkrét feladathoz



jaja az kicsit overkill volt hogy odaírtam

This post was edited by Anarkin on Nov 17 2013 01:30pm

Annyira gyönyörű a megoldás amit mondasz, hogy könnyezik a szemem, de lusta leszek úgy csinálni (felokosítás lépést kihagyom)

Csak szorgalmi feladat, annak simán beadom ezt a kókány verziót, nem fogom szégyellni magamat xd.

jól haladok, a programom már tökmindegy mi történik veszíteni fog, és nem lehet bebugolni
alakul, már mindig nyer, de néha nem akar lépni xd

gecire úgy érzem, hogy amit programozás címén művelek, az nevetséges

This post was edited by jarabekg on Nov 17 2013 03:46pm

nyugodtan postolj néha kódrészleteket, szívesen megerősítünk benne bármikor

switch (o0)
{
case 1: t1[0] = 0; t1[1] = 0; t1[2] = 1; break;
case 0: t1[0] = 0; t1[1] = 0; t1[2] = 0; break;
}
switch (o1)
{
case 3: t2[0] = 0; t2[1] = 1; t2[2] = 1; break;
case 2: t2[0] = 0; t2[1] = 1; t2[2] = 0; break;
case 1: t2[0] = 0; t2[1] = 0; t2[2] = 1; break;
case 0: t2[0] = 0; t2[1] = 0; t2[2] = 0; break;
}
switch (o2)
{
case 5: t3[0] = 1; t3[1] = 0; t3[2] = 1; break;
case 4: t3[0] = 1; t3[1] = 0; t3[2] = 0; break;
case 3: t3[0] = 0; t3[1] = 1; t3[2] = 1; break;
case 2: t3[0] = 0; t3[1] = 1; t3[2] = 0; break;
case 1: t3[0] = 0; t3[1] = 0; t3[2] = 1; break;
case 0: t3[0] = 0; t3[1] = 0; t3[2] = 0; break;
} switch (o3)
{
case 7: t4[0] = 1; t4[1] = 1; t4[2] = 1; break;
case 6: t4[0] = 1; t4[1] = 1; t4[2] = 0; break;
case 5: t4[0] = 1; t4[1] = 0; t4[2] = 1; break;
case 4: t4[0] = 1; t4[1] = 0; t4[2] = 0; break;
case 3: t4[0] = 0; t4[1] = 1; t4[2] = 1; break;
case 2: t4[0] = 0; t4[1] = 1; t4[2] = 0; break;
case 1: t4[0] = 0; t4[1] = 0; t4[2] = 1; break;
case 0: t4[0] = 0; t4[1] = 0; t4[2] = 0; break;
} for (int j = 0; j < 3; j++)
{ nimsum[j] = (t1[j] + t2[j] + t3[j] + t4[j]) % 2; }

if (nimsum[0] == 1 && t3[0] == 1) { o2 = o2 - 4; nimsum[0] = 0; }
if (nimsum[0] == 1 && t4[0] == 1) { o3 = o3 - 4; nimsum[0] = 0; }
if (nimsum[1] == 1 && t2[1] == 1) { o1 = o1 - 2; nimsum[1] = 0; }
if (nimsum[1] == 1 && t3[1] == 1) { o2 = o2 - 2; nimsum[1] = 0; }
if (nimsum[1] == 1 && t4[1] == 1) { o3 = o3 - 2; nimsum[1] = 0; }
if (nimsum[2] == 1 && t1[2] == 1) { o0 = o0 - 1; nimsum[2] = 0; }
if (nimsum[2] == 1 && t2[2] == 1) { o1 = o1 - 1; nimsum[2] = 0; }
if (nimsum[2] == 1 && t3[2] == 1) { o2 = o2 - 1; nimsum[2] = 0; }
if (nimsum[2] == 1 && t4[2] == 1) { o3 = o3 - 1; nimsum[2] = 0; }

jelenleg így néz ki ikszde
fingom nem volt hogy kell átváltani kettes számrendszerbe rendesen, így megkókányoltam
most próbálom megcsinálni a válaszlépést, a nimsumot már jól megcsinálja

úgy kéne lépjen, hogy mindig 0 legyen a nimsum, és elvileg ez biztos győzelem: http://www.archimedes-lab.org/How_to_Solve/Win_at_Nim.html
de gond van ha 1 1 5 7 a kezdő lépés, akkor arra ugye 1155 lesz a válaszlépés, ha erre azt lépem, hogy 1150 akkor kiakad az egész, mert a nimsum 101 lesz, viszont ha így kivenné az ötöt és 0-ra rendezné, akkor vesztene 1100, miközben ha 1150 ra azt lépné hogy 111 akkor nyerne

szóval nem tudom, hogy most az algoritmussal van alapvető gond, vagy csak elbaszarintok valamit