====== Opis pseudokodu ======

===== Informacje podstawowe =====
  * Stosujemy wcięcia zgodnie z poziomami zagnieżdżania się kodu.
  * Wszystkie zmienne typów prymitywnych piszemy małą literą.
  * Wszystkie zmienne będące strukturami złożonymi piszemy dużą literą.
  * Wprowadzamy symbol nieoznaczony **nil**.

==== Zmienne ====
  * Nie deklarujemy/definiujemy zmiennych lokalnych funkcji.
  * Jeżeli zachodzi potrzeba wprowadzenia nowej zmiennej po prostu to robimy.
  * Każda zmienna jest widzialna w zakresie całej funkcji, wyjątkiem są:
    * Zmienne globalne, które definiujemy w następujący sposób<code>global j</code>
    * Zmienne liczące w [[#petle|pętlach]].
  * Przypisanie wartości do zmiennej wykonujemy operatorem **:=**:<code>
j := 2
j := j+1
a := j
</code>

==== Komentarze ====
  * Symbolem **#** rozpoczynamy komentarz który trwa do końca linii.
  * Brak jest komentarzy wielolinijkowych.
  * W przypadku kiedy należy wykonać instrukcje nie związane bezpośrednio z kontekstem rozważanego problemu, można je zastąpić opisem słownym (komentarzem) nie poprzedzonym znakiem komentarza:<code>
...
i := i*2
wczytaj a z klawiatury
i := i*a
wypisz i na ekran
...
</code>
==== Operatory ====
  * Dostępne są podstawowe operatory arytmetyczne + - / *
  * Dostępne są również następujące operatory: % (modulo), ^ (potęgowanie), | (dzielenie całkowite)

===== Tablice =====
  * Nazwy tablic piszemy dużymi literami.
  * Numerowanie elementów tablic rozpoczynamy od **1**.
  * Do danego elementu tablicy odnosimy się podając jego indeks w nawiasach kwadratowych po nazwie tablicy:<code>
A[1]      # pierwszy element tablicy
A[i]      # i-ty element tablicy
A[i-1]    # i-1 element tablicy
</code>
  * Długość tablicy jest zwracana przez funkcję //length//:<code>
n := length(A)    # teraz n przechowuje długość tablicy, jest to jednocześnie indeks jej ostatniego elementu.
</code>
  * Nie alokujemy/dealokujemy pamięci dla tablic. Zakładamy że jest to robione automatycznie.
  * Wyznaczanie podtablicy jest możliwe przy pomocy trzykropka:<code>
Wypełnij A ciągiem kolejnych liczb pierwszych od 2 do 17
B := A[3...length(A)-1]     # Teraz B zwiera następujące wartości: 5,7,11,13
</code>
===== Funkcje =====
  * Definicję funkcji rozpoczynamy słowem **func**.
  * Koniec definicji funkcji oznaczamy przy pomocy **endfunc**.
  * Definiując funkcję specyfikujemy jedynie listę argumentów jakie przyjmuje. Nie specyfikujemy typu wartości jaką funkcja zwraca oraz typów argumentów.
  * Argumenty do funkcji są przekazywane przez wartość.
  * Szkielet przykładowej definicji funkcji (o nazwie search) wygląda następująco:<code>
func SEARCH(A, a, b)
  ...
  instrukcje wewnątrz funkcji wraz z wcięciami
  ...
endfunc
</code>
  * Funkcja może zwrócić dowolną wartość w dowolnym momencie.
  * Zwrócenie wartości przez funkcję następuję przy pomocy słowa **return** po którym musi wystąpić wartość zwracana.
  * Funkcje wywołujemy pisząc jej nazwę a następnie w okrągłych nawiasach listę argumentów rozdzielonych przecinkami:<code>
a := SEARCH(A,i,j)
</code>
  * Zakładamy że funkcja zwracająca wartość zwraca ją w postaci **niestałej referencji**, wtedy możliwy staje się zapis:<code>
c := funkcja(A)
funkcja(B) := c
</code>lub po prostu:<code>
funkcja(B) := funkcja(A)
</code>
===== Instrukcje warunkowe =====
  * Będziemy stosować głównie instrukcję **if-elseif-else-endif**.
  * Instrukcje **elseif** oraz **else** są opcjonalne.
  * Dostępne są następujące operatory relacji: =, !=, >, >=, <, < =.
  * Warunki możemy łączyć przy pomocy następujących operatorów:
    * **and** - binarny - zwraca prawdę jeżeli oba warunki są prawdziwe
    * **or** - binarny - zwraca prawdę jeżeli przynajmniej jeden warunek jest prawdziwy.
    * **xor** - binarny - zwraca prawdę jeżeli jeden z warunków jest prawdą a drugi fałszem.
    * **not** - unarny - zwraca prawdę jeżeli warunek jest niespełniony.
  * Przykładowe zastosowanie instrukcji warunkowej do określenia maksymalnej z pośród trzech wartości:<code>
func MAX(a,b,c)
  if a > b
    if a > c
      return a
    else
      return c
    endif
  else
    if b > c
      return b
    else
      return c
    endif
  endif
endfunc
</code>
  * Przy pomocy nawiasów okrągłych możemy grupować wyrażenia relacji, definiując równocześnie kolejności ich sprawdzania.\\ Powyższy kod może zostać przepisany także w następującej postaci:<code>
func MAX(a,b,c)
  if (a > b) and (a > c)
    return a
  elseif (a <= b) and (a > c)
    return b
  endif
  return c
endfunc
</code>

===== Pętle =====
  * Działanie każdej pętli może zostać przerwane w dowolnym momencie przy pomocy instrukcji **break**.
  * Działanie każdej pętli może zostać przerwane i natychmiast wznowione przy pomocy instrukcji **continue**.
  * Instrukcje **break** i **continue** odnoszą się tylko do najbardziej zagnieżdżonej pętli.
==== for ====
  * Poprawna konstrukcja pętli **for** wymaga podania:
    * nazwy zmiennej która będzie licznikiem w danej pętli,
    * krańcowych wartości licznika.
  * Podanie kroku jest opcjonalne. Domyślną wartością kroku jest **1**.
  * Przykładowa pętla **for**:<code>
for zmienna in 7...17 step 2
  wypisz zmienna na ekran
endfor
</code>
  * Powyższa pętla wypisze na ekran liczby: 7,9,11,13,15,17
==== while ====
  * Pętla **while** wykonuje kod tak długo jak długo jest spełniony warunek działania pętli.
  * Przykład pętli **while** odpowiadający powyższej pętli **for**:<code>
zmienna := 7
while zmienna <= 17
  wypisz zmienna na ekran
  zmienna := zmienna + 2
endwhile
</code>