Quote (jarabekg @ Nov 17 2013 11:03pm)

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

Quote (Anarkin @ 18 Nov 2013 00:47)

"1 << 2" -----> 2 (kettesben: 010)

Quote (Anarkin @ Nov 18 2013 12:47am)

001 1
010 2
011 3
100 4
101 5
110 6
111 7

http://2.ii.gl/M9Ed5.png

GetBitValue( Number, BitIndexFromRight )

------ egy példa lefutása:

Number: mondjuk 3 (ami kettesben: 011)
BitIndexFromRight: mondjuk 2

a függvény fogja, és eltolja az 1-est "<<" (shift left művelettel) balra BitIndexFromRight alkalommal, majd össze-ÉS-eli az eredeti számmal:

"1 << 2" -----> 2 (kettesben: 010) // ez a harmadik indexre 4 lenne, a negyedik indexre 8, ...
"011 & 010" -----> 010

ekkor látjuk hogy a "010" az 0-e vagy sem
ha 0 akkor tudjuk hogy 0 volt az ott lévő bit
ha nem 0 akkor tudjuk hogy nem 0 volt az ott lévő bit

ez volt a felső függvény, lényegében "maszkoltunk"

-----------

az alsó függvény pedig elég beszédes a kép alapján is

ha a kommenteket kiszedet a Failed-ek körül akkor megmondja hogy a NimSum értéke 0-e vagy sem

Quote (jarabekg @ 18 Nov 2013 01:58)

szép, de igazából eddig megy nekem is, (ha nem is ilyen simán) a válasz lépéssel van gondom :c

Quote (jarabekg @ 17 Nov 2013 20:27)

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

Quote (Anarkin @ Nov 18 2013 01:04am)

(editeltem a képet kicsit elindexeltem a két ciklust xd)

de a válaszlépéssel mi a baj, fent ott van a GetChildren cuccos: az a két ciklus egymásban legenerálja a megfelelő int[] tömböket amikre szükséged van (ezek a potencionális lépések)

a ciklus belsejében ahol valami Result.Add(NewState) vagy mi a szösz lehet, ott leírod ezt:

if (NimSum(VizsgálandóTömb) == 0)
{
  YaaySetAllapotToVizsgalandoTomb();
  break;
}

ezzel lépett is az AI

Quote (jarabekg @ 18 Nov 2013 02:08)

ebbol nem ertek egy szot sem xd