Keresés

Részletes keresés

KoporShow Creative Commons License 2005.02.10 0 0 244
Szerintem a lepest legeneralni gyorsabb (vagy ugyanolyan gyors), mert ez egy szimpla osszedas, mig a masik esetben a memoriabol kell olvasni, ami altalaban lassabb mint egy regiszteroperacio, meg akkor is, ha a cache-bol tortenik.
Előzmény: thuram (243)
thuram Creative Commons License 2005.02.10 0 0 243
Hát ugye egy mezőhöz átlagosan kb 5-6-7 huszár lépés tartozik és 64 el beszorozva ez 400 körül van. Na most akkor azt kérdem hogy
1: letárolom minden mezőhöz 8 biten melyek a legálisak hozzá, azaz ebben benne van pl balra2, fel 1 legális stb na most akkor minden lépésben megtalálom a huszárt megkeresem a hozzá tartozó 8 bitet és legenerálom a hozzá tartozó lépéseket (most már intben akarom ) azaz "d2-e4" ,"d2-f3" stb
Vagy!
2:Egyből olyan formában tárolom le amit az 1 pontban leirtam (a nagy bazi 400 elemű tömbről) és akkor már számolást nem igényel csak kikell szedni a tömbből

Melyik a gyorsabb? Azt figyelembe véve hogy ugye általában minden lépésben 4 huszárt találunk főleg az elején a táblán tehát az elején 4* hajtódnak végre a pontok ..
Előzmény: KoporShow (242)
KoporShow Creative Commons License 2005.02.10 0 0 242
Mire kell 400?

En szemely szerint csak azt tarolnam el, hogy a melyik lepes legalis, magat a lepest nem, mert azt gyorsabb legeneralni.
Előzmény: thuram (240)
thuram Creative Commons License 2005.02.10 0 0 241
valóban 8 bit kell minimum:)
Előzmény: thuram (240)
thuram Creative Commons License 2005.02.10 0 0 240
Szerintem elég lenne, mivel 8 helyre léphetsz..de most ezen ne vitatkozunk nem fontos.

Akkor csináljam az egyes módszert? azaz bazi nagy kb 400 elemű int tömb..
Előzmény: KoporShow (239)
KoporShow Creative Commons License 2005.02.10 0 0 239
Nem eleg 3 bit.

Nyugodtan hasznalhatsz int-eket, mivel ugyis minden bele fog ferni a cache-be ezert a sebessegen nem sokat modosithat.
Előzmény: thuram (235)
NevemTeve Creative Commons License 2005.02.10 0 0 238
Utólag ne javítgass semmit... előre kell kitalálni...
mondjuk van egy 0-1000 közötti értéked -> használj int-et, biztos belefér
vagy van egy 0-100000 közötti értéked -> használj long-ot, mert lehet olyan platformod, ahol nem fér el az int-ben
vagy 64 bit-re van szükséged -> használj long long-ot, de tudd, hogy van olyan platform, ahol nincs 'long long'... vagy használj helyette 'unsigned char [8]' tömböt, az mindenhol megy, de egy kicsit több programozói munkát igényel a kezelése
Előzmény: thuram (236)
thuram Creative Commons License 2005.02.10 0 0 237
Bár azon gondolkodom hogy a lépéseket pl a bástya futóhoz úgy generáltam le hogy int et ad vissza : 0"honnan" "hova" ez ugye 12 bit a végén az elején lévő 4 bitet majd másra kellene felhasználonom, amolyan különleges lépésekre mint pl lehet e még sáncolni a királlyal, mire változon át a gyalog etc . Szóval emiatt a huszárnál is inteket kellene generálnom.
Előzmény: KoporShow (232)
thuram Creative Commons License 2005.02.10 0 0 236
Tényleg akkor most még használjak nyugodtan inteket majd a végén kijvaitgatom, vagy hogy érdemes ezt?
Előzmény: NevemTeve (234)
thuram Creative Commons License 2005.02.10 0 0 235
Ez sem rossz:) Ehhez elég lenne 3 bit is:)
Előzmény: KoporShow (232)
NevemTeve Creative Commons License 2005.02.10 0 0 234
Felőlem szavazhatunk is a kérdésről, de abban biztos vagyok, hogy a DOS-os TurboC mind a mai napig 16-bites 'int'-tel dolgozik... továbbá a 16-bites Windows-ra is lehet mindmáig fejleszteni...
szóval hagyjuk a manapságot, meg az újabbant, legyünk korrektek és készüljünk föl mindenre
Előzmény: KoporShow (230)
thuram Creative Commons License 2005.02.10 0 0 233
Igen de gondolom azért találták ki ezt a tömbös módszert, mert nem akarták sokszor tesztelgetni, hogy kivülre kerül-e egy lépés, hanem egyszerűen amikor a lépéseket generálom már kezemben van az oszlop és a sor és akkor egyszerűen a tömbből kiválasztom a lehetséges lépéseket majd & a sajátszinekkel és ha 0 t kapok akkor léphetek oda és akkor kevesebb if kell, bár én nem látok bele nagyon a rejtelmekbe ez csak megérzés:) És ez a tömböt az elején legenerálom és akkor csak kiszedem ami most éppen kell nekem, és nem kell folyamatosan erölködnöm a huszár lépésein mindig ifelgetni, hogy kivül kerüle..
Előzmény: NevemTeve (231)
KoporShow Creative Commons License 2005.02.10 0 0 232
En azt csinalnam, hogy minden mezohoz lekodolnam egy byte-on (nyolc biten), hogy a lehetseges 8 ugras kozul meylik legalis. Maguknak az ugrasnak a generalasa mar egyszeru, mert ez csak egy szimpla osszeadas, ha a tabla sorfolytonosan van indexelve.
Előzmény: thuram (229)
NevemTeve Creative Commons License 2005.02.10 0 0 231
Nem is kell feltétlenül tömb... elvileg nyolc lépés lehetséges, ezek közül ki kell szűrni azokat, ahol valamelyik vagy mindkét koordináta a sakktáblán kívül kerül...
Előzmény: thuram (229)
KoporShow Creative Commons License 2005.02.10 0 0 230
Az int-et illetoen manapsag a helyzet a kovetkezo:

int 32bit
long 32/64 bit aszerint, hogy a gep cimzese 64 bites e.

Ez annyira igy van, hogy pont azert valtoztattak meg
64-bites gepekre sem az int meretet, hogy a letezo
programok meg veletlenul se tudjanak elromlani.

Az Opteron gepekre 64-bites kodot generalo forditok
(pl. gcc) is 64-bites long-ot general.

A regi 16-bites int-et el lehet felejteni, mert manapsag
meg a mobil gepeken is short-ot kell hasznalni erre
a celra.

Előzmény: NevemTeve (228)
thuram Creative Commons License 2005.02.10 0 0 229
Ok. Köszönöm a válaszokat!
Úgy néz ki az összes bábúnak letudom generálni a lépéseit (elméletben, gyakorlatban még csak a bástyát csináltam meg) csak a huszáron gondolkodok. Szóval a huszárt máshogy javasolják mint a többit. A javaslat az hogy csináljunk egy "táblázatot" (a program elején amely végig él) amely mind a 64 mezőre megmondja hogy onnan hova lehet lépni a huszárral egy üres táblán. Tehát itt 2-3 elképzelésem van.
1:Csinálok egy bazi nagy int tömböt kb 400 eleműt amely a következőt tartalmazza tömb[0]="a1-b3", tömb[1]="a1-c2", tömb[2]="b1-a3" stb. Itt még kellene csinálni egy másik tömböt amely megmondja hogy pl ha a d4 mezőn áll a huszár akkor a 202-209 intervallumban vannak a lépések.

2:Csinálok egy 64 elemű tömböt, amelynek elemei listák, azaz tömb[0]="a1-b3" -> "a1-c2" tömb[1]="b1-a3" -> stb. Na most itt nem tudom hogy hogy érdemes, azaz pl itt is érdemes e felvenni egy tömböt amely megmondja hogy a tömb[x] ben lévő lista milyen hsszú? stb

3: csinálok egy 64 elemű ULL tömböt ennek egy elemében eltudom tárolni az összes lépést egy mezőhőz mert 6*8 bit lehet a max. Csak valszeg itt is kellene egy segéd tömb, talán..

Nektek melyik tünik a legjobbnak ill van e jobb ötletetek, javaslatotok?
Előzmény: NevemTeve (228)
NevemTeve Creative Commons License 2005.02.10 0 0 228
A strtoul, strtol-nak megadhatsz számrendszer-alapot 2-36 között
A #define a fordítónak szól, futáskor nem létezik.
Az int rendszerint 2/4 byte-os, a long tipikusan 4 byte, lásd még a sizeof-ot.
Előzmény: thuram (225)
KoporShow Creative Commons License 2005.02.10 0 0 227
Egy C-file sosem fut le, es tök mindegy, hogy a define-okat hova rakod.

MAX_INT (limit.h)

Egyebkent az int alapvetöen tiz evnel nem öregebb gepeken
legalabb 32 bites, (söt altalaban pontosan annyi), igy ezt
nyugodtan feltetelezheted.



Előzmény: thuram (225)
thuram Creative Commons License 2005.02.09 0 0 226
OK aszem az oktálist megtaláltam a neten. Illetve itt azt is irják hogy az int 2 bit. (az egyik c s könyvem emlitette hogy ez függhet a hardwaretől ill OS től)
Előzmény: thuram (225)
thuram Creative Commons License 2005.02.09 0 0 225
A gdb s topik jó, minden megvan ami kellett nekem eddig.

Milyen számrendszerekben lehet még dolgozni? eddig a hexadec et tudom csak használni és most jó lenne egy 8 as számrendszer ill binárisra is kiváncsi lennék ha már itt tartunk.Ami érdekel konkrétan érdekelne ami a hexánál a 0x azaz a megadáshoz kell mit kell a 8 ill 2 esben ehelyett?
Van egy .c fileom ami valszeg sokszor lesz meghivva. Az elején van egy olyan, hogy #define LEPGENT 200 ,nem nagy gond ha ez állandóan lefut tegyem jobb helyre hogy ne fusson feleslegesen le sokszor?
Hogy tudom eldönteni hogy az int az én gépemen hány biten van ábrázolva?(irjak egy programot ami az int u=1; u= u<<1;stb vagy van egyszerübb módszer is?Esetleg használjak inkább longot az nem gép ill oprendszer függő?
thuram Creative Commons License 2005.02.09 0 0 224
Bocs félreértettem. Kösz a segítségeket.
Előzmény: NevemTeve (223)
NevemTeve Creative Commons License 2005.02.09 0 0 223
Annyira nem vagyunk, hogy az egyes függvényeket valamiféle jogosultsági rendszerbe soroljuk be... esetleg még be is kelljen jelentkezniük (azonosító+jelszó+chipkártya)

A gdb-ről van egy topik az indexen: GNU debugger (gdb)
Előzmény: thuram (222)
thuram Creative Commons License 2005.02.09 0 0 222
"Azért ennyire még nem vagyunk... " Ezt nem értem megint:(. Gondolom nem túl jót jelent túl sokat pofáztam vagy miért kaptam??Csak a lényeget mondjam?
A gdb ill ddd alapjairól van szép magyar leírás valahol ? pl hogy tudok egy változót végig nyomón követni stb..
Előzmény: NevemTeve (221)
NevemTeve Creative Commons License 2005.02.09 0 0 221
Azért ennyire még nem vagyunk... mindenestre udvarias dolog, ha a függvény fejrészében használod a const kulcsszót.
Előzmény: thuram (220)
thuram Creative Commons License 2005.02.09 0 0 220
OK. A kiiratás most már tökéletes:). Most jön a lehetséges lépések legenerállása:) .
Most még csak úgy tervezem hogy szépen végigsétálok a 64 mezőn minden mezőn megnézem milyen bábú áll ott stb (és azt mondták hogy ezt tegyem bele egy nagy tömbbe)
Gondolom ez úgy lenne szép ha a változókhoz csak olvasási jogot kapna ez a függvény, ez hogyan oldható meg?
Zahy Creative Commons License 2005.02.07 0 0 219
És ugye mielőtt felraktad volna a bábukat, minden mezőre raktál egy "ott nincs senki" jelentésű _nyomtatható_ karaktert (pl. szóközt) is? Meg ugyanezt majdan a lépések után is elvégzed, hogy szóközre (akármire) cseréled a bábut? Mert gondolom a lefoglalt tömböd memóriaszemetét látod a kiíratásnál.
Előzmény: thuram (215)
NevemTeve Creative Commons License 2005.02.07 0 0 218
char tomb[8][8];
for (ind=0; ind<8;++ind) printf ("%.8sn", tomb[ind]);
Előzmény: thuram (215)
KoporShow Creative Commons License 2005.02.06 0 0 217
Bocs, de nem jott at :
'for(i=0;i<0;i++)tomb[8]='''
Előzmény: KoporShow (216)
KoporShow Creative Commons License 2005.02.06 0 0 216
A 'tomb[8][8]' deklaracio egy 64 byte hosszu folytonos memoriat allokal amelyben tomb a 8*i-nel kezdodo darabot cimzi. A problemad az, hogy a C-ben a stringeknek 0 karakterre kell vegzodniuk, ezert a printf(tomb[0]) valoszinuleg az egesz stringet kiirja.

Egy megoldas pl. hogy a tombod sorainak meretet megnoveled eggyel: 'tomb[8][9]', es mindegyik sor vegere beirsz egy 0 karaktert:

for(i=0;i<0;i++)tomb[8]='';
Előzmény: thuram (215)
thuram Creative Commons License 2005.02.05 0 0 215

Köszönöm a választ. Egyenlőre akkor megirom a programot (ha megtudom), és ha már nagyon akarom fejlesztgetni akkor fogok foglalkozni ilyennel.

 

Probáltam irni egy megjelenitőt, amely azt csinálná hogy egy 64 elemű char tömbbel megjelenitené melyik mezőn melyik bábú áll. Mivel úgy lenne a szép hogy 8*8 alakban irná ki ezért 'tomb [8] [8]' tömbbe számoltam ki melyik bábú hol áll, majd a printf("%s n", tomb [i]); probáltam kiiratni egy sort(azaz 8 mezőt). Ez jó igy? mert nekem érthetetlen karakterek is bejöttek:), és valszeg a kiiratással van a gond, bár lehet nem:)

Előzmény: KoporShow (214)

Ha kedveled azért, ha nem azért nyomj egy lájkot a Fórumért!