anchor.diff:  zdejmuje się :ZERO 0, potem :ONE 1, i tak do końca listy :NINE 9 jest sprawdzane osobno,
   gdyż pod koniec sprawdzamy jeszcze warunek brzegowy dla HEAP-EMPTY-P. |#
   (let ((heap (make-heap 10))) 
  -    (labels ((check-peek (data priority)
  -               (let ((entry (heap-peek heap)))
  -                 (assert (equal data (data entry)))
  -                 (assert (equal priority (priority entry)))))
  -             (check-pop (data priority) 
  -               (check-peek data priority)
  -               (heap-pop heap)))
  -      
  -      (signals heap-error (heap-peek heap))
  -      (signals heap-error (heap-pop heap))
  -      
  -      (assert (heap-empty-p heap))
  -      (heap-push heap :two 2)
  -      (check-peek :two 2)
  -      (assert (not (heap-empty-p heap)))
  -      
  -      (heap-push heap :one 1)
  -      (check-peek :one 1)
  -      (heap-push heap :three 3)
  -      (check-peek :one 1)
  -      
  -      (heap-push heap :zero 0)
  -      (check-peek :zero 0)
  -
  -      (heap-push heap :zero 0)
  -      (check-peek :zero 0) 
  -      (heap-push heap :zero 0)
  -      (check-peek :zero 0)
  -      (check-pop :zero 0)
  -      (check-peek :zero 0)
  -      (check-pop :zero 0)
  -      (check-peek :zero 0)
  -      
  -      (heap-push heap :eight 8)
  -      (check-peek :zero 0)
  -      
  -      (heap-push heap :four 4)
  -      (check-peek :zero 0)
  -      
  -      (heap-push heap :seven 7)
  -      (check-peek :zero 0)
  -      
  -      (heap-push heap :nine 9)
  -      (check-peek :zero 0)
  -      
  -      (heap-push heap :six 6)
  -      (check-peek :zero 0)
  -      
  -      (assert (not (heap-full-p heap)))
  -      (heap-push heap :five 5)
  -      (check-peek :zero 0)
  -      (assert (heap-full-p heap))
  -      
  -      (signals heap-error (heap-push heap :ten 10))
  -
  -      (mapcar (lambda (x) (apply #'check-pop x))
  -              '((:zero 0) (:one 1) (:two 2)
  -                (:three 3) (:four 4) (:five 5)
  -                (:six 6) (:seven 7) (:eight 8)))
  -      
  -      (assert (not (heap-empty-p heap))) 
  -      (check-pop :nine 9) 
  -      (assert (heap-empty-p heap))
  -      
  -      (signals heap-error (heap-peek heap))
  -      (signals heap-error (heap-pop heap))))
  +  (labels ((check-peek (data priority)
  +             (let ((entry (heap-peek heap)))
  +               (assert (equal data (data entry)))
  +               (assert (equal priority (priority entry)))))
  +           (check-pop (data priority) 
  +             (check-peek data priority)
  +             (heap-pop heap))) 
  +    (signals heap-error (heap-peek heap))
  +    (signals heap-error (heap-pop heap))
  +    
  +    (assert (heap-empty-p heap))
  +    (heap-push heap :two 2)
  +    (check-peek :two 2)
  +    (assert (not (heap-empty-p heap)))
  +    
  +    (heap-push heap :one 1)
  +    (check-peek :one 1)
  +    (heap-push heap :three 3)
  +    (check-peek :one 1)
  +    
  +    (heap-push heap :zero 0)
  +    (check-peek :zero 0)
  +
  +    (heap-push heap :zero 0)
  +    (check-peek :zero 0) 
  +    (heap-push heap :zero 0)
  +    (check-peek :zero 0)
  +    (check-pop :zero 0)
  +    (check-peek :zero 0)
  +    (check-pop :zero 0)
  +    (check-peek :zero 0)
  +    
  +    (heap-push heap :eight 8)
  +    (check-peek :zero 0)
  +    
  +    (heap-push heap :four 4)
  +    (check-peek :zero 0)
  +    
  +    (heap-push heap :seven 7)
  +    (check-peek :zero 0)
  +    
  +    (heap-push heap :nine 9)
  +    (check-peek :zero 0)
  +    
  +    (heap-push heap :six 6)
  +    (check-peek :zero 0)
  +    
  +    (assert (not (heap-full-p heap)))
  +    (heap-push heap :five 5)
  +    (check-peek :zero 0)
  +    (assert (heap-full-p heap))
  +    
  +    (signals heap-error (heap-push heap :ten 10))
  +
  +    (mapcar (lambda (x) (apply #'check-pop x))
  +            '((:zero 0) (:one 1) (:two 2)
  +              (:three 3) (:four 4) (:five 5)
  +              (:six 6) (:seven 7) (:eight 8)))
  +    
  +    (assert (not (heap-empty-p heap))) 
  +    (check-pop :nine 9) 
  +    (assert (heap-empty-p heap))
  +    
  +    (signals heap-error (heap-peek heap))
  +    (signals heap-error (heap-pop heap))))
   
   
   
  
positive.code: 
  #| Nie będzie tu skomplikowane - piszemy funkcję, która tworzy tablicę, po czym
  wypełnia ją liczbami pseudolosowymi.
  Wyróżniam to jako osobny odcinek, bo jest tu pole do rozwoju, gdyby trzeba byłouwzględnić 
  nieco bardziej regularne dane do generowania labiryntów. Jakieś lokalne zgrupowania, 
  wzniesienia, detale geograficzne - można to zaimplementować właśnie w tym miejscu.|#
  (defun make-randomized-array (y-size x-size &optional (maximum 255))
    (let ((array (make-array (list y-size x-size) :element-type 'integer)))
      (dotimes (y y-size)
  
negative.code: te liczby jako wierzchołki grafu, to musimy również mieć sposób na oznaczenie krawędzi - możemy
  to osiągnąć za pomocą trójwymiarowej tablicy informującej o tym, czy wierzchołek ma krawędzie 
  w dół albo w prawo. Dwa pierwsze wymiary to wymiary oryginalnej tablicy, trzeci wymiar oznacza
  dwa bity; pierwszy oznacza krawędź w dół, drugi - w prawo. 
  
  Pesymistycznie rzecz biorąc, w kolejce może znaleźć się 4/5 wszystkich wierzchołków, każdy w
  maksymalnie czterech duplikatach - stąd rozmiar sterty. Nie usuwam duplikatów, gdyż sprawdzanie
  całej sterty za każdym razem byłoby O(n) - lepiej sprawdzać to za każdym razem przy zdejmowaniu
  wierzchołka ze sterty.
  