Fejtörő (2014-2015)

Mókás, de direkt dögnehéz programozási feladványok Spectrumra...
Avatar
njozsef
Speccyalista
Hozzászólások: 54
Csatlakozott: 2012.01.06. 18:49

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: njozsef » 2015.01.09. 20:44

Én is nagyon várom a megoldást, mert nekem nem sikerült rájönnöm. :(

Avatar
Bali
Site Admin
Hozzászólások: 1929
Csatlakozott: 2012.01.06. 13:34
Tartózkodási hely: Budapest III.
Kapcsolat:

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: Bali » 2015.01.12. 22:11

Már napok óta izgulunk! :)
-= Bali =-
(c) 1983-2017 Evil-Soft

Avatar
Pgyuri
Speccyalista
Hozzászólások: 485
Csatlakozott: 2012.01.06. 13:34

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: Pgyuri » 2015.01.13. 23:28

Kedves Versenyzők!

Még egy pici türelmet kell, hogy kérjek, mivel a sok megoldás formába öntött elemzése eltart egy ideig .... de haladok velük :)

Köszönettel

Pgyuri

Avatar
Pgyuri
Speccyalista
Hozzászólások: 485
Csatlakozott: 2012.01.06. 13:34

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: Pgyuri » 2015.01.18. 15:13

Kedves Fejtörők!

Az idei évi feladat elsősorban programozási feladat volt, amelyre számos megoldás érkezett, de csak nagyon kevés felelt meg a kiírásnak. Mindenki elsősorban sebesség oldalról közelítette meg a felhívást és eközben felejtette el, hogy nem a program átírása, átszervezése volt a cél, hanem a legjobb, leggyorsabb tükrözés kidolgozása.

Idézve a kiírásból:
"A 40. és 60. programsorok közé írj egy "egyszerű" programrészt, amely a READ utasítással beolvasott értéket megtükrözi."

Mielőtt a megoldásokra térnék ki, pár szó a fejtörő születéséről:

Miután az idei évben is sikerült elindulni a "vacak játékok versenyén" az ALL-KEY-TESTER termékkel (reklám helye), abban BASIC-ben szükségem volt egy szám bináris vizsgálatára. Itt szembesültem azzal, hogy a AND művelet Spectrum BASIC tájszólásában nem épp azt csinálja, amit alapból elvárnék, azaz IF (A AND 128) sajnos nem a bit értékét adja vissza, hanem az A 0 vagy 1 értékét teszi ÉS kapcsolatba a 128-al, ami vagy 0 (ha A=0) vagy 1 (A<>0) értéket jelez. Ez használhatatlan így bináris bontásra, tehát más megoldást kellett keresnem.

Itt jött az képbe, hogy olyan fejtörőt szerettem volna adni, ami sima futtatásnál is eredményt ad, csak épp nem megfelelőt. Ehhez készült a BUÉK kép, majd már csak a bináris művelethez kellett egy jó ötlet, ami végül a tükrözés lett.

Kapóra is jött a tükrözés, mivel ugyanezzel a feladattal megküzd a Z80-as processzor is. Közvetlen utasítása nincs rá, hanem bizony bitenként kell tologatni az értékeket ahhoz, hogy egy byte értéket megtükrözzük. Kérdezheti bárki, hogy na mégis mire kellhet ez, hiszen ésszerű oka nemigen van, de bizony van, mégpedig pont abban az esetben, amire a mikroszámítógépek nagyrésze használva volt .... a JÁTÉKBAN!

Egy grafikai elem - nevezzük sprite-nak - legyen egy sima emberke, mozog jobbra és balra is. Ha nem szimmetrikus, akkor bizony ellenkező irányba másképp byte-sor írja le, mint alapirányába. Legyen a főhős most a jól ismert Miner:

00000110
00111110
01111100
00110100
00111110
00111100
00011000
00111100
01111110
01111110
11110111
11111011
00111100
01110110
01101110
01110111

A játék készítők sok esetben a sebesség miatt (mivel a tükrözés lassú byte-onként) kénytelenek jelentős memóriát pazarolni, mivel egy sprite jobbra néző képe mellett a bal oldali képét is tárolniuk kell. Kár, hogy a Z80 processzor a rengeteg bitművelet mellett ezt a lépést épp nem támogatta. Sokkal több grafika fért volna játékokba, amelyek pedig inkább a tükrözést választották, jelentősen gyorsabbak lehettek volna.

Ennyi elmélet után pedig következzen a gyakorlat. Bár publikálásra, értékelésre teszem a beérkezett pályaműveket, de sajnos nem tudom díjjal értékelni egyik megoldást sem igazán (a programok szerzők szerint ABC sorrendben):

Bali megoldásai:

256 elemű tömb (DIM) előre feltöltve, majd GO TO 1-el indításhoz

50 LET a=m(a+1)

2. megoldásában próbálta átszervezni a programot, ami nem rossz:

50 POKE f,m(a+1) : NEXT f

Hátha még a +1 lépést is megspórolta volna, akkor lett volna végletekig optimalizált, de sajnos a GO TO 1 nem jó megoldás. Bár nem szerepelt a RUN-al indítás, de nem is szerepelt benne, hogy bármilyen előkészület vagy egyéb instrukció engedélyezett lett volna.

Csaba megoldásai:

41 REM ........
42 LET A=PEEK (23924+A)

A REM sor begépelhetetlen, így publikálásra alkalmatlan. Ravasznak minősíthető megoldás, de nem minden gépen működik, hiszen egy Interface I már problémát okoz.

50 LET C$="aiemckgobjfndlhp"
55 LET A=(CODE c$((a-16*INT (A/16))+1-97)*16+CODE c$(INT (A/16)+1)-97

Teljesíti a kiírást, egyedi ötlet, elfogadható! (utólag törölve szerk: egyetlen hátránya, hogy nem általánosan alkalmazható.)

Végül még egy értékelhetetlen, de ténylegesen működő (a REM sor rengeteg byte-ot tartalmaz...)

41 REM ............ de begépelhetetlen sor
50 FOR n=22528 TO 23295: POKE N,PEEK (n+1396): NEXT N: GO TO 80

Csory megoldása:

41 POKE 22207,0: POKE22463,0
42 FOR C=0 TO 7
43 PLOT INVERSE NOT POINT(255-C,0); 247+C,1
44 NEXT C
45 LET A=PEEK 22207

Elvont megoldás, de sajnos koszolja a képernyőt.

Kapitány megoldása:

42 LET I=7
44 LET B=A
45 LET N=0
46 IF B=0 THEN GO TO 59
47 LET B=B/2
49 LET N=N+(INT b<>B)*(2^i)
51 LET B=INT B
53 LET I=I-1
55 GO TO 46
59 LET A=N

Ez tulajdnoképpen egy jó megoldás, általánosan képes egy értéket binárisan tükrözni. Hibája a szervezetlensége és a lassúsága, de kiindulásnak egész jó.

KPBendi megoldása:

43 IF a=3 THEN NEXT F
45 IF A=PEEK(48000+A) THEN POKE f,PEEK(48256+a): NEXT F
49 LET B=A: LET C=A: LET A=0
50 IF C>127 THEN LET C=C-128: LET A=1
51 IF C>63 THEN LET C=C-64: LET A=A+2
52 IF C>31 THEN LET C=C-32: LET A=A+4
53 IF C>15 THEN LET C=C-16: LET A=A+8
54 IF C>7 THEN LET C=C-8: LET A=A+16
55 IF C>3 THEN LET C=C-4: LET A=A+32
56 IF C>1 THEN LET C=C-2: LET A=A+64
57 IF C>0 THEN LET A=A+128
59 POKE (48000+B),B: POKE (48256+B),A

Nem a kiírásnak megfelelő megoldás, de a menet közben felépülő, már tükrözött értékek eltárolása egész jó gondolat.

Lala megoldásai:

Sajnos csak a 3. megoldása felelt meg a kiírásnak, de a többi is bemutatásra alkalmas. Nagy energiákat fektetett be a kidolgozásokba, ami mindenképpen dícséretes. (a megoldások előtt saját kommentjei olvashatók)

1. A leggyorsabb: 356 (7.12 sec).

50 POKE 60003,192: POKE 60005,160: POKE 60011,208: POKE 60015,240: POKE
60019,200: POKE 60021,168: POKE 60023,232: POKE 60027,216: POKE 60029,184:
POKE 60031,248: POKE 60033,132: POKE 60037,164: POKE 60055,236: POKE
60059,220: POKE 60067,194: POKE 60083,202: POKE 60099,198: POKE 60101,166:
POKE 60107,214: POKE 60109,182: POKE 60117,174: POKE 60125,190: POKE
60131,193: POKE 60151,233: POKE 60161,133: POKE 60163,197: POKE 60173,181:
POKE 60181,173: POKE 60195,195: POKE 60219,219: POKE 60223,251: POKE
60227,199: POKE 60237,183: POKE 60249,159: POKE 60251,223: RESTORE 1000
51 FOR f=22528 TO 23295 STEP 16: READ a: POKE f,PEEK (60000+a): READ a:
POKE f+1,PEEK (60000+a): READ a: POKE f+2,PEEK (60000+a): READ a: POKE
f+3,PEEK (60000+a): READ a: POKE f+4,PEEK (60000+a): READ a: POKE f+5,PEEK
(60000+a): READ a: POKE f+6,PEEK (60000+a): READ a: POKE f+7,PEEK
(60000+a): READ a: POKE f+8,PEEK (60000+a): READ a: POKE f+9,PEEK
(60000+a): READ a: POKE f+10,PEEK (60000+a): READ a: POKE f+11,PEEK
(60000+a): READ a: POKE f+12,PEEK (60000+a): READ a: POKE f+13,PEEK
(60000+a): READ a: POKE f+14,PEEK (60000+a): READ a: POKE f+15,PEEK
(60000+a): NEXT f: LET f=f-1: LET a=PEEK (f)

2. Kicsit szebb, univerzális, de lassú: 851 (17.02 sec)

50 IF f>22528 THEN GO TO 59
51 RESTORE 55: FOR n=60000 TO 60031: READ a: POKE n,a: POKE n+32,a+4: POKE n+64,a+2: POKE n+96,a+6: POKE n+128,a+1: POKE n+160,a+5: POKE
n+192,a+3: POKE n+224,a+7: NEXT n
55 DATA 0,128,64,192,32,160,96,224,16,144,80,208,48,176,112,240,8,136,72,200,40,168,104,232,24,152,88,216,56,184,120,248
56 RESTORE 1000: READ a
59 LET a=PEEK (60000+a)

3. Végül a bájtonkénti tükrözés, cache-eléssel: 1236 (24.72 sec)

51 IF PEEK (60000+a)>0 THEN GO TO 59
52 LET e=a: LET a=0: LET c=1: LET d=128: LET x=e
53 FOR i=0 TO 7: IF e>=d THEN LET e=e-d: LET a=a+c
54 LET c=c*2: LET d=d/2: NEXT i
55 POKE 60000+x,a: POKE 60000+a,x: LET a=x
59 LET a=PEEK (60000+a)

Makranc megoldásai:

50 LET Y=0: FOR n=0 TO 7: LET X=INT (A/2^(7-N)): LET A=A-X*2^(7-N): LET Y=Y+X*2^N: NEXT N: LET A=Y

Normál bitenkénti vizsgálat és tükrözés, ez mindenképpen szerepel az ÁTTEKINTHETŐ megoldások között. Lehetett volna rajta még dolgozni, kiváltani a ciklust, gyorsítani.

42 IF a=3 THEN GO TO 70
43 IF f>22528 THEN GO TO 58
44 BRIGHT 1: FLASH 1: INK 0: CLS : BRIGHT 0: FLASH 0: INK 7
45 DIM d(255)
46 LET d(5)=160: LET d(11)=208: LET d(15)=240: LET d(19)=200: LET d(21)=168: LET d(23)=232: LET d(27)=216: LET d(29)=184: LET d(31)=248
48 LET d(33)=132: LET d(37)=164: LET d(55)=236: LET d(59)=220: LET d(67)=194: LET d(83)=202: LET d(99)=198: LET d(101)=166: LET d(107)=214
50 LET d(109)=182: LET d(117)=174: LET d(125)=190: LET d(131)=193: LET d(151)=233: LET d(161)=133: LET d(163)=197: LET d(173)=181: LET d(181)=173
52 LET d(195)=195: LET d(219)=219: LET d(223)=251: LET d(227)=199: LET d(237)=183: LET d(249)=159: LET d(251)=223
58 LET a=d(a)

Sajnos nem a kiírásnak megfelelő, ráadásul lassú.

41 IF f<>22528 THEN GO TO 50
42 DIM d(255): RESTORE 45: FOR n=1 TO 35: READ x,y: LET d(x)=y: NEXT n: RESTORE 1000: READ a
45 DATA 3,192,5,160,11,208,15,240,19,200,21,168,23,232,27,88,29,56,31,120,33,4,37,164,55,236,59,220,67,194,83,74,99,198,101,38,107,86,109,182,117,174,125,190,131,193,151,233,161,133,163,197,173,181,181,173,195,195,219,219,223,251,227,199,237,183,249,159,251,223
50 LET a=d(a)

Nem épp kifogástalan megoldás-elgondolás.

41 IF a=3 THEN LET a=192: GO TO 60
42 IF a=109 THEN LET a=182: GO TO 60
43 IF a=15 THEN LET a=240: GO TO 60
44 IF a=99 THEN LET a=198: GO TO 60
45 IF a=37 THEN LET a=164: GO TO 60
46 IF a=219 THEN GO TO 60
47 IF a=23 THEN LET a=232: GO TO 60
48 IF a=131 THEN LET a=193: GO TO 60
49 IF a=67 THEN LET a=194: GO TO 60
50 IF a=11 THEN LET a=208: GO TO 60
51 LET y=0: IF (a/128)>=1 THEN LET y=y+1: LET a=a-128
52 IF (a/64)>=1 THEN LET y=y+2: LET a=a-64
53 IF (a/32)>=1 THEN LET y=y+4: LET a=a-32
54 IF (a/16)>=1 THEN LET y=y+8: LET a=a-16
55 IF (a/8)>=1 THEN LET y=y+16: LET a=a-8
56 IF (a/4)>=1 THEN LET y=y+32: LET a=a-4
57 IF (a/2)>=1 THEN LET y=y+64: LET a=a-2
58 IF a=1 THEN LET y=y+128
59 LET a=y

Látszik a próbálkozás a gyorsításra, a bitenkénti tükrözés már egész szépen látszik.

41 IF f<>22528 THEN GO TO 45
42 DIM d(255)
45 IF a=0 THEN GO TO 60
47 IF d(a)<>0 THEN LET a=d(a): GO TO 60
50 LET y=0: IF (a/128)>=1 THEN LET y=y+1: LET a=a-128
51 IF (a/64)>=1 THEN LET y=y+2: LET a=a-64
52 IF (a/32)>=1 THEN LET y=y+4: LET a=a-32
53 IF (a/16)>=1 THEN LET y=y+8: LET a=a-16
54 IF (a/8)>=1 THEN LET y=y+16: LET a=a-8
55 IF (a/4)>=1 THEN LET y=y+32: LET a=a-4
56 IF (a/2)>=1 THEN LET y=y+64: LET a=a-2
57 IF a=1 THEN LET y=y+128
58 LET a=y: LET d(a)=a


41 DIM d(256): POKE 23693,192: CLS : POKE 23693,7: POKE 23923,234
42 IF a=3 THEN NEXT f
44 IF d(a+1)<>0 THEN LET a=d(a+1): GO TO 60
45 LET x=0: LET y=a: IF a/128>=1 THEN LET a=a-128: LET x=x+1
46 IF a/64>=1 THEN LET a=a-64: LET x=x+2
47 IF a/32>=1 THEN LET a=a-32: LET x=x+4
48 IF a/16>=1 THEN LET a=a-16: LET x=x+8
49 IF a/8>=1 THEN LET a=a-8: LET x=x+16
50 IF a/4>=1 THEN LET a=a-4: LET x=x+32
51 IF a/2>=1 THEN LET a=a-2: LET x=x+64
52 IF a=1 THEN LET x=x+128
53 LET a=x: LET d(y+1)=x

Most, hogy mindenki "megemészthesse" az olvasottakat, várok néhány napot és utána bemutatom az általam készített megoldást. Ha bárki még szeretné bemutatni programrészletét, a végső zárás előtt tegye meg, de szívesen látnék jó megoldásokat is még!

Pgyuri

Avatar
leslie.wss
Speccyalista
Hozzászólások: 75
Csatlakozott: 2012.01.18. 23:36

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: leslie.wss » 2015.01.18. 16:45

Én is próbálkoztam egy olyan Makrancféle megoldással, ahol IF-ekkel figyeltem az aktuális, megfordítandó értéket, mert vannak olyanok, amelyeknek a tükörképe is ugyanaz, tehát nem kell megfordítani (195 és 219), át lehet ugrani a bájt fordító kódot.
Két ilyen érték is van, de aztán ezt elvetettem, mert még lassabban futott, mintha simán megfordítom azokat az értékeket is. Nem tudom, miért, gondolom az IF vagy a GO TO túl sok idő neki.

A 3-as (eredeti) érték viszont megfordítva a fekete hátteret adja, csak BRIGHT-al és FLASH-el, ami elvileg a képernyőn nem látszódik, tehát azokat óvatosan kihagytam a feldolgozásból. Mivel ebből van a legtöbb darab (59%), így a futás egész jól gyorsítható, ha ezt a kis könnyítést megengedhetjük, és elfogadjuk jó megoldásnak.

Megoldásaim:
Működő megoldás, de csalással (az idő 0 :)):

Kód: Egész kijelölése

41 IF a=3 THEN NEXT f
43 POKE 16663,a: LET a=128+POINT (184,174)+POINT (185,174)*2+POINT (186,174)*4+POINT (187,174)*8+POINT (188,174)*16+POINT (189,174)*32+POINT (190,175)*64
59 POKE 23672,255: POKE 23673,255: POKE 23674,255
A képernyőt szemeteli menet közben, de a végére ez kijavul :).

Mondjuk "csalás" nélkül ugyanez (976):

Kód: Egész kijelölése

41 IF a=3 THEN NEXT f
43 POKE 16663,a: LET a=128+POINT (184,174)+POINT (185,174)*2+POINT (186,174)*4+POINT (187,174)*8+POINT (188,174)*16+POINT (189,174)*32+POINT (190,175)*64
Más megoldás, nem pontozással, hanem számolgatással (1096):

Kód: Egész kijelölése

41 IF a=3 THEN NEXT f
42 LET b=128: IF a>128 THEN LET b=b+1: LET a=a-128
43 IF a>64 THEN LET b=b+2: LET a=a-64
44 IF a>32 THEN LET b=b+4: LET a=a-32
45 IF a>16 THEN LET b=b+8: LET a=a-16
46 IF a>8 THEN LET b=b+16: LET a=a-8
47 IF a>4 THEN LET b=b+32: LET a=a-4
48 IF a>2 THEN LET b=b+64
59 LET a=b
Az eredeti értékek között nem volt olyan, melynek a legalsó bitje ne lenne 1-be állítva, így azt nem kell vizsgálni, rögtön mehet a 128 a fordított értékbe.
Ezért van a 42. sorban b=128, és az IF a>1-re pedig nincs szükség.

Csináltam egy bitenként lépegetős megoldást is, de borzasztó lassú (7338):

Kód: Egész kijelölése

41 LET b=0: LET c=128: LET d=1
42 FOR n=0 TO 7
43 IF a>c THEN LET b=b+d: LET a=a-c
44 LET c=c/2: LET d=d*2
45 NEXT n
59 LET a=b

Avatar
makranc
Speccyalista
Hozzászólások: 252
Csatlakozott: 2012.01.11. 11:00
Tartózkodási hely: Budapest, III.

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: makranc » 2015.01.18. 17:15

Pgyuri írta: 50 LET Y=0: FOR n=0 TO 7: LET X=INT (A/2^=7-N)): LET A=A-X*2^(7-N): LET Y=Y+X*2^N: NEXT N: LET A=Y
Egy kis hibajavítás, egy kezdő zárójel helyett egyenlőségjelet írtál, tehát helyesen:

50 LET Y=0: FOR n=0 TO 7: LET X=INT (A/2^(7-N)): LET A=A-X*2^(7-N): LET Y=Y+X*2^N: NEXT N: LET A=Y

Avatar
makranc
Speccyalista
Hozzászólások: 252
Csatlakozott: 2012.01.11. 11:00
Tartózkodási hely: Budapest, III.

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: makranc » 2015.01.19. 00:00

leslie.wss írta:A 3-as (eredeti) érték viszont megfordítva a fekete hátteret adja, csak BRIGHT-al és FLASH-el, ami elvileg a képernyőn nem látszódik, tehát azokat óvatosan kihagytam a feldolgozásból. Mivel ebből van a legtöbb darab (59%), így a futás egész jól gyorsítható, ha ezt a kis könnyítést megengedhetjük, és elfogadjuk jó megoldásnak.
Ezt az egyik programban úgy használtam ki, hogy az összes képernyő-attribútumot a 3-nak megfelelő 192-re állítottam, így ezeket már nem kell beállítani, csak a többit, azok meg úgyis felülírják a megfelelő helyen.
POKE 23693,192: CLS : POKE 23693,7
ezt csinálja, a második POKE visszaállítja a Gyuri által beállított PAPER és INK értéket.
Próbálkoztam azzal is, hogy minden számhoz tartozó értéket csak egyszer kell kiszámolni, és eltárolni egy tömbben.
Ha a tömbben a számnak megfelelő helyen nem nulla van, akkor már kiszámolta egyszer, és onnan vehető elő.

A Gyuri által közölt utolsó megoldásomhoz még annyit, hogy a 41. sor utolsó utasítása, POKE 23923,234 magát a 41. sort írja REM-re.
Erre azért volt szükség, mert különben az ebben a sorban lévő utasításokat egy IF-THEN párosban kellett volna elhelyezni, hogy csak az első ciklusban kerüljenek végrehajtásra, de ott lévén minden ciklusban egy összehasonlítást jelentettek volna, míg REM-re írva átlépi őket a gép.
Nem tudom, ez miért nem tetszett Gyurinak, ez általános megoldás, minden bemeneti értékre működik, mondjuk ebben a speciális esetben azzal gyorsít, hogy a leggyakoribb értékre vannak beállítva a képernyő-attribútumok és csak a többit kell egyesével átírni.
Igaz, ez se gyors túlzottan, 825-öt ír.
A hozzászólást 1 alkalommal szerkesztették, utoljára makranc 2015.01.19. 10:46-kor.

Kapitany
Speccyalista
Hozzászólások: 142
Csatlakozott: 2013.01.05. 10:03

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: Kapitany » 2015.01.19. 10:00

Enterprise-os vonalról azt kell mondjam, már kicsit kavarog a gyomrom és szédülök ettől a sok POKE-tól... :S

Avatar
Zozosoft
Speccyalista
Hozzászólások: 726
Csatlakozott: 2012.01.06. 14:03
Kapcsolat:

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: Zozosoft » 2015.01.19. 10:06

Kapitany írta:Enterprise-os vonalról azt kell mondjam, már kicsit kavarog a gyomrom és szédülök ettől a sok POKE-tól... :S
Dettó :-D

csaba
Speccyalista
Hozzászólások: 190
Csatlakozott: 2012.01.09. 19:18
Rádióamatőr hívójel: HG5BMU
Tartózkodási hely: Surány
Kapcsolat:

Re: Fejtörő (2014-2015)

Hozzászólás Szerző: csaba » 2015.01.19. 10:25

Kis kiegészítés az én megoldásaimhoz

41 REM ........
42 LET A=PEEK (23924+A)


az első megoldás nem alkalmazható általánosan, a rem sorban csak az előforduló számok bitfordítása van elmentve.
Ezeket néhány, utólag kitörölt basic sorral készítettem el előre.
Lehetett volna rendszerváltozóból számítani a 41. sor kezdetét, viszont az plussz idő a futásnál.

50 LET C$="aiemckgobjfndlhp"
55 LET A=(CODE c$((a-16*INT (A/16))+1-97)*16+CODE c$(INT (A/16)+1)-97


A második változat Pgyuri megjegyzése ellenére, minden 8 bites számnál működik.
a C$ string 16 helyén 4bites cserék vannak ábrázolva chr$(97)-el növelve a begépelhetőség miatt.
Jobban érthető ha leírjuk a C$ 16 darab numerikus értékét:
0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15
így már látható, hogy helyiértékenként a 4biten tükrözött érték szerepel.
Az 55. sorban az alsó és felső 4 bit tükrözése külön történik a C$ adott helyiértékének kiolvasásával majd 8bitessé alakításával.
55 LET A=(CODE c$((a-16*INT (A/16))+1-97)*16+CODE c$(INT (A/16)+1)-97
alsó 4 bit tükrözésése lesz a felső 4 bit
55 LET A=(CODE c$((a-16*INT (A/16))+1-97)*16+CODE c$(INT (A/16)+1)-97
felső 4bit tükrözése lesz az alsó 4 bit

Válasz küldése

Ki van itt

Jelenlévő fórumozók: nincs regisztrált felhasználó valamint 1 vendég