home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1997 #3 / amigamamagazinepolishissue03-1 / ma_1995 / 05 / ami038.txt < prev    next >
Text File  |  1997-04-07  |  13KB  |  578 lines
  1. KOMPUTEROWE MYÔLENIE
  2.  
  3. <lead>Na czym polegajâ algorytmy myôlowe komputera? Jak to sië
  4. dzieje, ûe grajâc w najprzeróûniejsze strategie z komputerem,
  5. mamy przed sobâ peînoprawnego partnera, umiejâcego ze swoistym
  6. wyrachowaniem poruszaê swoimi wojskami tak, aby doprowadziê do
  7. naszej przegranej? W jaki sposób komputer potrafi analizowaê
  8. sytuacjë na polu bitwy? To, oczywiôcie, temat-rzeka. Jednak mimo
  9. to postaram sië choê w maîym stopniu przybliûyê Czytelnikom
  10. zagadkë "sztucznej inteligencji".
  11.  
  12. <a>Krzysztof Prusik
  13.  
  14. <txt>Wszyscy wiemy, ûe komputer bez programu to kupa zîomu (tak,
  15. nawet Amiga). Program to ciâg rozkazów i danych napisanych przez
  16. czîowieka. Jaki z tego wniosek? To nie komputer myôli, tylko
  17. programy sâ tak skonstruowane, ûe na kaûde nasze posuniëcie, np.
  18. podczas gry w szachy, majâ przygotowanâ odpowiedniâ ripostë (a
  19. przynajmniej tak sië wydaje).
  20.  
  21. Jak dziaîajâ takie programy? Po prostu analizujâ wszystkie
  22. moûliwe posuniëcia (lub przynajmniej wiëkszoôê), czyli zwykle
  23. dziaîajâ wedîug zasady:
  24.  
  25. <l>Wykonaj pierwsze posuniëcie (jedno z moûliwych)
  26.  
  27.     Jeôli trzeba 
  28.  
  29.         wykonaj nastëpne posuniëcie (jedno z moûliwych)
  30.  
  31.         Jeôli trzeba
  32.  
  33.             wykonaj nastëpne posuniëcie (jedno z moûliwych)
  34.  
  35.             Jeôli trzeba
  36.  
  37.                 ...
  38.  
  39.             Inaczej
  40.  
  41.                 Daj wynik analizy
  42.  
  43.         Inaczej
  44.  
  45.             Daj wynik analizy
  46.  
  47.     Inaczej
  48.  
  49.         Daj wynik analizy
  50.  
  51.  
  52.  
  53. <txt>Oczywiôcie bardziej elegancka byîaby odpowiednia procedura
  54. rekurencyjna (w AMOS-ie):
  55.  
  56. <l>Procedure ANALIZA[KROK]
  57.  
  58.     ' Na wejôciu procedury mamy KROK, czyli numer posuniëcia
  59.  
  60.     For I=1 TO OSTANIE_POSUNIECIE
  61.  
  62.         ' obliczenie warunku KONIEC_OBLICZEN w kroku KROK
  63.  
  64.         If Not KONIEC_OBLICZEN
  65.  
  66.             ANALIZA[KROK+1] : KONIEC=Param
  67.  
  68.         Else
  69.  
  70.             ' Wypisz wynik analizy
  71.  
  72.             KONIEC=True
  73.  
  74.     End If
  75.  
  76.         ' wyjdú z pëtli jeôli juû otrzymaliômy wynik
  77.  
  78.         Exit If KONIEC
  79.  
  80.     Next
  81.  
  82. End Proc
  83.  
  84. <txt>Gwoli wyjaônienia: >Not< -- neguje warunek KONIEC_OBLICZEN,
  85. czyli jeôli KONIEC_OBLICZEN=>True< (prawda), to >Not<
  86. KONIEC_OBLICZEN=>False< (faîsz) i na odwrót. >Exit If< --
  87. powoduje wyjôcie z pëtli >For..Next<, jeôli speîniony bëdzie
  88. warunek KONIEC.
  89.  
  90.  
  91. <sr>Labirynt
  92.  
  93. <txt>Proponujë poanalizowaê teraz trochë ten algorytm, aby go
  94. zrozumieê, bo za chwilë postawimy przed sobâ o wiele trudniejsze
  95. zadanie. Napiszemy prostâ gierkë, która przetestuje myôlenie
  96. komputera. Po prostu zaprojektujemy labirynt i umieôcimy gdzieô w
  97. jego ôrodku myszkë oraz serek, a nastëpnie nakaûemy myszce
  98. znaleúê drogë do serka. Ok?
  99.  
  100. Zaczynamy od spraw technicznych: labirynt bëdzie reprezentowany w
  101. pamiëci komputera przez dwuwymiarowâ tablicë liczb. I tak:
  102.  
  103. 1 bëdzie oznaczaê puste pole (PUSTY)
  104.  
  105. 2 bëdzie oznaczaê ôcianë (SCIANA)
  106.  
  107. 3 bëdzie oznaczaê serek (SEREK)
  108.  
  109. 4 bëdzie oznaczaê miejsca juû odwiedzone (ODWIEDZONY). Gdybyômy
  110. juû odwiedzonych pól w ûaden sposób nie zaznaczali, myszka
  111. mogîaby krâûyê "w nieskoïczonoôê" i nie wiedziaîaby, na których
  112. polach juû byîa, a na których jeszcze nie.
  113.  
  114. --------------!Rys.1: Przykîadowy labirynt z liczb!--------------------
  115.  
  116. Warto wiëc na poczâtku programu poczyniê odpowiednie deklaracje:
  117.  
  118. <l>PUSTY=1 : Rem----- pole puste
  119.  
  120. SCIANA=2 : Rem------- sciana
  121.  
  122. SEREK=3 : Rem-------- serek!
  123.  
  124. ODWIEDZONY=4 : Rem--- miejsce juû odwiedzione
  125.  
  126. X_MAX=10 : Rem------- liczba pol w x
  127.  
  128. Y_MAX=10 : Rem------- liczba pol w y
  129.  
  130. X_DELTA=10 : Rem----- szerokoôê pola
  131.  
  132. Y_DELTA=10 : Rem----- wysokosc pola
  133.  
  134. Dim POLE(X_MAX,Y_MAX)
  135.  
  136. Global PUSTY,SCIANA,SEREK,ODWIEDZONY
  137.  
  138. Global X_MAX,Y_MAX,POLE(),X_DELTA,Y_DELTA
  139.  
  140.  
  141. <txt>Proszë zwróciê uwagë, ûe dziëki dodaniu nowych zmiennych:
  142. PUSTY, SCIANA, SEREK i ODWIEDZONY, w programie, zamiast nic nie
  143. mówiâcych liczb 1, 2, 3 i 4, bëdziemy mogli zamiennie uûywaê nazw
  144. tych zmiennych.
  145.  
  146. <sr>Projektowanie labiryntu
  147.  
  148. <txt>Ogólnie nasz program bëdzie wyglâdaî nastëpujâco:
  149.  
  150. 1. Projektowanie labiryntu przez uûytkownika.
  151.  
  152. 2. Szukanie drogi wyjôcia przez myszkë.
  153.  
  154. Zaczynamy od zaprojektowania labiryntu: naciskajâc klawisze kursora, 
  155. bëdziemy przemieszczaê sië po naszym labiryncie, wciôniëcie zaô
  156.  
  157. "1" -- spowoduje wpisanie pustego pola do tablicy POLE()
  158.  
  159. "2" -- spowoduje wpisanie ôciany
  160.  
  161. "3" -- wpisanie serka
  162.  
  163. "K" lub klawisza [Enter] -- koniec projektowania.
  164.  
  165.  
  166. <l>Procedure PROJEKTUJ_LABIRYNT
  167.  
  168.     ZERUJ_TABLICE
  169.  
  170.     WYSWIETL_LABIRYNT
  171.  
  172.     X=0 : Y=0
  173.  
  174.     Repeat
  175.  
  176.         POKAZ_KURSOR[X,Y]
  177.  
  178.         Repeat
  179.  
  180.             KLAWISZ$=Inkey$
  181.  
  182.         Until KLAWISZ$<>""
  183.  
  184.         If (KLAWISZ$=Cup$)and(Y>0) Then Dec Y
  185.  
  186.         If (KLAWISZ$=Cdown$)and(Y<Y_MAX) Then Inc Y
  187.  
  188.         If (KLAWISZ$=Cleft$)and(X>0) Then Dec X
  189.  
  190.         If (KLAWISZ$=Cright$)and(X<X_MAX) Then Inc X
  191.  
  192.         If KLAWISZ$="1" Then POLE(X,Y)=PUSTY
  193.  
  194.         If KLAWISZ$="2" Then POLE(X,Y)=SCIANA
  195.  
  196.         If KLAWISZ$="3" Then POLE(X,Y)=SEREK
  197.  
  198.         POKAZ_POLE[X,Y,POLE(X,Y)]
  199.  
  200.     Until (KLAWISZ$="K")or(KLAWISZ$="k")or(KLAWISZ$=Chr$(13)
  201.  
  202. End Proc
  203.  
  204. Procedure POKAZ_KURSOR[X,Y]
  205.  
  206.     'ta procedurka ustawia kursor myszki
  207.  
  208.     'w punkcie tablicy POLE()
  209.  
  210.     'o wspolrzednych X,Y
  211.  
  212.     X Mouse=X Hard(X*X_DELTA)
  213.  
  214.     Y Mouse=Y Hard(Y*Y_DELTA)
  215.  
  216. End Proc
  217.  
  218. <txt>>Chr$(13)< -- to kod, jaki odpowiada naciôniëciu klawisza
  219. [Enter]. Dziaîanie procedury PROJEKTUJ_LABIRYNT chyba nie wymaga
  220. komentarza. Trzeba tylko jeszcze stworzyê dwie pomocnicze
  221. procedurki: ZERUJ_TABLICE (sîuûy do zainicjalizowania tablicy
  222. POLE(), czyli po prostu wypeînia caîâ tablicë wartoôciami PUSTY),
  223. oraz wyswietl labirynt (do pokazania zawartosci tablicy na
  224. ekranie monitora).
  225.  
  226. <l>Procedure ZERUJ_TABLICE
  227.  
  228.     For X=0 To X_MAX
  229.  
  230.         For Y=0 To Y_MAX
  231.  
  232.             POLE(X,Y)=PUSTY
  233.  
  234.         Next
  235.  
  236.     Next
  237.  
  238. End Proc
  239.  
  240. Procedure WYSWIETL_LABIRYNT
  241.  
  242.     For X=0 To X_MAX
  243.  
  244.         For Y=0 To Y_MAX
  245.  
  246.             POKAZ_POLE[X,Y,POLE(X,Y)]
  247.  
  248.         Next
  249.  
  250.     Next
  251.  
  252. End Proc
  253.  
  254. <txt>Uwaûni Czytelnicy zauwaûyli zapewne, ûe jeszcze nie zostaîa
  255. zdefiniowana procedura POKAZ_POLE. W wyniku jej dziaîania, na
  256. ekranie zostanie wyôwietlona zawartoôê pojedynczego pola
  257. labiryntu (albo SCIANA, albo PUSTY, albo SEREK).  Proszë
  258. zauwaûyê, ûe dziëki takiemu podziaîowi programu gîównego na
  259. procedury, bezproblemowo, w kaûdej chwili, moûemy zmieniê sposób
  260. pokazywania zawartoôci tablicy z zakodowanym w niej labiryntem,
  261. zmieniajâc jedynie zawartoôê procedurki POKAZ_POLE. Oto pierwsza
  262. metoda, w trybie tekstowym (uwaga!  X_DELTA musi byê równe 8
  263. oraz: Y_DELTA=8, bo taki jest rozmiar systemowego fontu):
  264.  
  265. <l>Procedure POKAZ_POLE[X,Y,TYP_POLA]
  266.  
  267.     If TYP_POLA=PUSTY 
  268.  
  269.         Print At(X,Y);"O";
  270.  
  271.     End If
  272.  
  273.     If TYP_POLA=SCIANA
  274.  
  275.         Print At(X,Y);"*";
  276.  
  277.     End If
  278.  
  279.     If TYP_POLA=SEREK
  280.  
  281.         Print At(X,Y);"S";
  282.  
  283.     End if
  284.  
  285. End Proc
  286.  
  287.  
  288. <txt>No pewnie, ûe to by dziaîaîo, ale... czy to nie jest dziwne? Amiga 
  289. pracujâca w trybie tekstowym? No tak. Trzeba to zrobiê lepiej,
  290. wykorzystujâc tryb graficzny. Oto druga wersja procedury:
  291.  
  292. <l>Procedure POKAZ_POLE[X,Y,TYP_POLA]
  293.  
  294.     If TYP_POLA=SCIANA Then Ink 2
  295.  
  296.     If TYP_POLA=PUSTY Then Ink 0
  297.  
  298.     If TYP_POLA=SEREK Then Ink 1
  299.  
  300.     X_POCZ=X*X_DELTA
  301.  
  302.     Y_POCZ=Y*Y_DELTA
  303.  
  304.     X_KON=X_POCZ+X_DELTA-1
  305.  
  306.     Y_KON=Y_POCZ+Y_DELTA-1
  307.  
  308.     Bar X_POCZ,Y_POCZ To X_KON,Y_KON
  309.  
  310.     If TYP_POLA=SEREK Then Text X_POCZ+1,Y_POCZ+7,"S"
  311.  
  312. End Proc
  313.  
  314. <txt>Proste? Uruchom procedurkë PROJEKTUJ_LABIRYNT i zobacz, jak
  315. dziaîa.  I co? Wszystko w porzâdku? No lecimy dalej!
  316.  
  317.  
  318. <sr>Szukanie drogi do serka
  319.  
  320. <txt>Sprawy techniczne mamy za sobâ, teraz pozostaîy problemy
  321. abstrakcyjne. No wîaônie, jak to zrobiê, ûeby komputer potrafiî
  322. znaleúê wyjôcie z labiryntu, a jeszcze na dodatek nam je pokazaî?
  323. Trudne? Tak sië tylko wydaje. Generalna zasada dotyczâca sposobu
  324. rozwiâzywania tego typu problemów jest nastëpujâca: "nie
  325. myôleê...o wszystkim naraz". Tak wiëc, jeûeli kiedykolwiek (jak
  326. np. teraz) bëdziemy musieli napisaê jakiô skomplikowany algorytm,
  327. starajmy sië go podzieliê na jak najmniejsze kawaîeczki.
  328.  
  329. Wracajâc do naszego labiryntu. Wyobraúmy sobie, ûe jesteômy
  330. myszkâ. Juû? W kaûdej chwili moûemy pójôê albo w lewo, albo w
  331. prawo, albo w górë, albo w dóî. Oczywiôcie jeûeli nie wyjdziemy
  332. poza labirynt, jeûeli mamy przejôcie (czyli tam, gdzie chcemy
  333. iôê, nie ma ôciany) oraz jeûeli danego pola jeszcze nie
  334. odwiedziliômy (bo nie ma sensu dwa razy chodziê w to samo
  335. miejsce). Cóû nam wiëc pozostaje innego, jak tylko napisaê
  336. odpowiedniâ procedurë rekurencyjnâ? Ûeby jednak wszystko byîo
  337. jasne, wypiszmy warunki, jakie bëdziemy musieli sprawdzaê w tej
  338. procedurce:
  339.  
  340. <l>Czy jesteômy w labiryncie?
  341.  
  342.     TAK:
  343.  
  344.     Czy to pole jest wolne (PUSTY)?
  345.  
  346.         TAK:
  347.  
  348.         Pokazujemy myszkë (np. kursor myszki).
  349.  
  350.         Zaznaczamy to pole jako odwiedzone (ODWIEDZONY) i szukamy 
  351.  
  352.         dalej, czyli wywoîujemy të procedurë rekurencyjnâ dla czterech 
  353.  
  354.         sâsiednich pól (lewego, prawego, górnego i dolnego).
  355.  
  356.         Czy którakolwiek z wywoîanych procedur znalazîa serek?
  357.  
  358.             TAK: Jako wynik zwracamy prawdë i ewentualnie 
  359.  
  360.             w sprawdzanym punkcie rysujemy drogë.
  361.  
  362.             NIE: Jako wynik procedury zwracamy faîsz.
  363.  
  364.         NIE:
  365.  
  366.         Czy juû znaleúliômy serek?
  367.  
  368.             TAK:
  369.  
  370.             Jako wynik dziaîania procedury zwracamy prawdë (bo 
  371.  
  372.             znaleúliômy serek) i wracamy do procedury, która 
  373.  
  374.             wywoîaîa nas rekurencyjnie i kazaîa przyjôê w to 
  375.  
  376.             miejsce.
  377.  
  378.             NIE:
  379.  
  380.             Jako wynik zwracamy faîsz i jak wyûej.
  381.  
  382.     NIE:
  383.  
  384.     Jako wynik zwracamy faîsz i wracamy do procedury, ktora nas wywoîaîa 
  385.  
  386.     rekurencyjnie.
  387.  
  388.  
  389. <txt>Ha! I oto jedna jedyna procedura rekurencyjna zaîatwia caîy
  390. problem.  Dlaczego? Bo jest wywoîywana dla (prawie) wszystkich
  391. punktów labiryntu (tablicy POLE()). Radzë zgîëbiê tajniki jej
  392. dziaîania, bo za chwilë przystâpimy do jej implementacji w
  393. AMOS-ie.
  394.  
  395. Juû? No to piszemy:
  396.  
  397. <l>Procedure SZUKAJ_SERKA
  398.  
  399.     ' Zaîóûmy, ûe myszka startuje od punktu 0,0
  400.  
  401.     JEST_DROGA[0,0] : WYNIK=Param
  402.  
  403.     'jeôli WYNIK=True, znaczy to, 
  404.  
  405.     'ûe myszka znalazîa serek
  406.  
  407.     If WYNIK 
  408.  
  409.         'Jest droga do serka
  410.  
  411.         Print " Jest droga do serka! "
  412.  
  413.         Bell 50
  414.  
  415.     Else
  416.  
  417.         'Niestety takiej nie ma
  418.  
  419.         Print " Nie ma drogi do serka. "
  420.  
  421.         Boom
  422.  
  423.     End If
  424.  
  425. End Proc
  426.  
  427. Procedure JEST_DROGA[X,Y]
  428.  
  429.     'sprawdza, czy w polu X,Y jest serek
  430.  
  431.     'i ewentualnie rekurencyjnie sprawdza pola sâsiednie
  432.  
  433.     If (X<=X_MAX)and(X>=0)and(Y<=Y_MAX)and(Y>=0)
  434.  
  435.         'nie wyszliômy poza tablicë
  436.  
  437.         If POLE(X,Y)=PUSTY
  438.  
  439.             'pole puste, wiec pokazujemy sie tutaj
  440.  
  441.             POKAZ_KURSOR[X,Y] : Wait OPOZNIENIE
  442.  
  443.             'jeszcze tu nie byliômy
  444.  
  445.             'wiëc zaznaczamy to pole
  446.  
  447.             POLE(X,Y)=ODWIEDZONY
  448.  
  449.             'sprawdzamy pole po lewej
  450.  
  451.             JEST_DROGA[X-1,Y]
  452.  
  453.             WYNIK=Param
  454.  
  455.             If Not WYNIK 
  456.  
  457.                 'sprawdzamy pole po prawej
  458.  
  459.                 JEST_DROGA[X+1,Y]
  460.  
  461.                 WYNIK=Param
  462.  
  463.             End If
  464.  
  465.             If Not WYNIK
  466.  
  467.                 'sprawdzamy pole na górze
  468.  
  469.                 JEST_DROGA[X,Y-1]
  470.  
  471.                 WYNIK=Param
  472.  
  473.             End If
  474.  
  475.             If Not WYNIK
  476.  
  477.                 'sprawdzamy pole na dole
  478.  
  479.                 JEST_DROGA[X,Y+1]
  480.  
  481.                 WYNIK=Param
  482.  
  483.             End If
  484.  
  485.             'podczas powrotu
  486.  
  487.             POKAZ_KURSOR[X,Y] : Wait OPOZNIENIE
  488.  
  489.         Else
  490.  
  491.             If POLE(X,Y)=SEREK
  492.  
  493.                 'wreszcie znalezlismy serek!
  494.  
  495.                 WYNIK=True
  496.  
  497.                 Bell 20
  498.  
  499.             Else
  500.  
  501.                 WYNIK=False
  502.  
  503.             End If
  504.  
  505.         End If
  506.  
  507.     Else
  508.  
  509.         WYNIK=False
  510.  
  511.     End If
  512.  
  513. End Proc[WYNIK]
  514.  
  515.  
  516. <txt>Aby procedurka dziaîaîa poprawnie, wôród zmiennych
  517. globalnych powinno sië znaleúê OPOZNIENIE, które bëdzie nam
  518. okreôlaê prëdkoôê poruszania sië myszki. Mam skromnâ nadziejë, ûe
  519. teraz wszystko jest dla Was jasne. Oczywiôcie gîówny moduî
  520. programu bëdzie wyglâdaî tak:
  521.  
  522. <l>PROJEKTUJ_LABIRYNT
  523.  
  524. SZUKAJ_SERKA
  525.  
  526. <txt>I tyle. Stworzyliômy chyba najprostszy model "sztucznej
  527. inteligencji". Gdybyômy teraz wsadzili nasz komputer do choêby
  528. nie wiem jak skomplikowanego labiryntu (ale zawierajâcego
  529. wyjôcie), to za pomocâ takiego programu jak ten (oraz nóg lub
  530. chociaû kóîek), na pewno wydostaîby sië stamtâd. Róûne mutacje
  531. algorytmu, z którym sië zapoznaliômy w artykule, sâ
  532. wykorzystywane we wszystkich grach strategicznych (z nielicznymi
  533. wyjâtkami, które zresztâ potwierdzajâ reguîë).
  534.  
  535. Hmmm. Z przykroôciâ muszë jednak wyznaê, ûe maîo jest gier
  536. przeprowadzajâcych dogîëbnâ analizë ruchów swoich i przeciwnika
  537. (tak jak np. szachy). Nawet osîawione Battle Isle (spëdziîem
  538. wiele nocy nad tâ gierkâ), nie potrafi "myôleê" naprawdë, a ruchy
  539. wojsk komputera (których jest zwykle dwa lub trzy razy tyle co
  540. naszych), sprowadzajâ sië do znalezienia najkrótszej drogi,
  541. prowadzâcej do naszych oddziaîów. I tyle! No, moûe troszkë
  542. przesadziîem... Szczâtkowa postaê analitycznego myôlenia
  543. przejawia sië tym, ûe zwykle wokóî swojej bazy komputer zostawia
  544. przynajmniej jeden oddziaî, ale to chyba potrafiîby zakodowaê
  545. kaûdy programista. Konkluzja: warto zapoznaê sië z algorytmem
  546. labirynt. Moûe w przyszîoôci zaprojektujemy Battle Isle 2000?
  547. Dygresja: sîyszaîem, ûe nastëpnâ czëôê tej gry przygotowuje Union
  548. Software.
  549.  
  550. Na tym koïczë dzisiejszy odcinek AMOS-a. Moje propozycje
  551. ciekawych problemów:
  552.  
  553. 1. Co sië stanie, gdy zlikwidujemy zaznaczanie pól labiryntu, na
  554. których juû byliômy?
  555.  
  556. 2. Co sië stanie, gdy zaraz po sprawdzeniu danego pola labiryntu
  557. (czyli za 28. liniâ procedury JEST_DROGA[X,Y]) umieôcimy rozkaz
  558. POLE(X,Y)=PUSTY (czyli odmarkujemy, odznaczymy, dane pole)?
  559.  
  560. 3. Jak zaprojektowaê algorytm, który znajdzie najkrótszâ drogë do
  561. serka?
  562.  
  563. 4. Wizualnie uatrakcyjniê rysowany labirynt, czyli np. ôciany
  564. narysowaê za pomocâ ikonek, a myszka niech bëdzie np. BOB-em.
  565.  
  566. 5. Powiëkszyê rozmiar labiryntu, ale uwaga! W takim wypadku
  567. najprawdopodobniej trzeba bëdzie zwiëkszyê rozmiar stosu komendâ
  568. >Set Stack< oraz wielkoôê na dane (>Set Buffer<).
  569. Zainteresowanych odsyîam do mojej ksiâûki "AMOS Professional w
  570. praktyce -- programowaê moûe kaûdy", wydanej przez RaWi sc.
  571.  
  572. 6. Odmienne zadanie: Mamy pole kwiatków o róûnych wysokoôciach.
  573. Na jednym z tych kwiatków wyleguje sië pszczóîka Maja. Gucio
  574. bardzo chce sië z niâ spotkaê, ale jest na tyle leniwy, ûe moûe
  575. jedynie przeskoczyê z wyûszego kwiatka na niûszy. Trzeba napisaê
  576. algorytm, który sprawdzi, czy jest moûliwe, aby skaczâc w ten
  577. sposób, Gucio dotarî w koïcu do pszczóîki.
  578.