Schemat blokowy: symbole, zasady rysowania i przykłady

Symbole schematu blokowego

Algorytm blokowy to po prostu algorytm przedstawiony w postaci schematu. Do narysowania większości zadań szkolnych wystarczą cztery rodzaje bloków i strzałki.

W tekstowych schematach poniżej kształty zastąpiono znakami: ( ) to owal, [ ] prostokąt, < > romb, / / równoległobok. Strzałki to znaki │ oraz ▼.

Zasady rysowania

Tabela pokazuje zasady stosowane w zadaniach szkolnych. Kolumna „Podstawa” mówi, czy zasada wynika z opisu bloków w źródłach (opis w materiałach edukacyjnych i encyklopedii), czy jest konwencją przyjętą dla czytelności, bez normy przywołanej w tym tekście.

Po narysowaniu sprawdź schemat „na sucho”: przejdź go z konkretnymi danymi i zapisz wartości zmiennych w tabelce po każdym kroku.

Przykład 1. Czy liczba jest parzysta (warunek)

Zadanie: wczytaj liczbę całkowitą n i napisz, czy jest parzysta. Warunek: reszta z dzielenia n przez 2 jest równa 0.

        ( START )
            │
            ▼
        /wczytaj n/
            │
            ▼
      < n mod 2 = 0 ? >
        │TAK        │NIE
        ▼           ▼
 /wypisz "parzysta"/  /wypisz "nieparzysta"/
        │           │
        └─────┬─────┘
              ▼
         ( STOP )

Odpowiadający pseudokod:

wczytaj n
jeżeli n mod 2 = 0 to
    wypisz "parzysta"
w przeciwnym razie
    wypisz "nieparzysta"

Kod w Pythonie:

def parzysta(n):
    if n % 2 == 0:
        return "parzysta"
    else:
        return "nieparzysta"

for n in (7, 10, 0, -3):
    print(n, parzysta(n))

Wynik uruchomienia (Python 3.13):

7 nieparzysta
10 parzysta
0 parzysta
-3 nieparzysta

Romb to instrukcja wyboru, a w Pythonie odpowiada jej if z gałęzią else: wykonywana jest dokładnie jedna z dwóch ścieżek. Zero jest parzyste, co schemat obsługuje bez dodatkowych reguł.

Przykład 2. Suma liczb od 1 do n (pętla)

Zadanie: oblicz 1 + 2 + … + n. Potrzebujesz zmiennej suma (start od 0) i licznika i (start od 1). Dopóki i ≤ n, dodajesz i do sumy i zwiększasz i o 1. Romb leży na początku pętli, więc dla n = 0 pętla nie wykona się ani razu.

         ( START )
             │
             ▼
         /wczytaj n/
             │
             ▼
       [ suma ← 0 ; i ← 1 ]
             │
             ▼
   ┌────>< i ≤ n ? >──NIE──> /wypisz suma/ ──> ( STOP )
   │         │TAK
   │         ▼
   │   [ suma ← suma + i ]
   │         │
   │         ▼
   │   [ i ← i + 1 ]
   │         │
   └─────────┘

Pseudokod:

wczytaj n
suma ← 0
i ← 1
dopóki i ≤ n wykonuj
    suma ← suma + i
    i ← i + 1
wypisz suma

Kod w Pythonie:

def suma_do(n):
    suma = 0
    i = 1
    while i <= n:
        suma = suma + i
        i = i + 1
    return suma

for n in (0, 1, 5, 10, 100):
    print(n, suma_do(n))

Wynik uruchomienia:

0 0
1 1
5 15
10 55
100 5050

Wartość 5050 zgadza się ze wzorem n(n + 1)/2 dla n = 100. Dla n = 5 test „na sucho” wygląda tak:

Po szóstym sprawdzeniu warunku i = 6 > 5, więc ścieżka NIE prowadzi do wypisania wyniku 15. Python opisuje pętlę while jako wielokrotne sprawdzanie warunku i wykonywanie bloku, dopóki warunek jest prawdziwy, co dokładnie odpowiada strzałce wracającej przed romb.

Przykład 3. Suma wczytywanych liczb do zera (pętla i warunek)

Zadanie: wczytuj liczby i dodawaj je do sumy, aż użytkownik poda 0. Liczba 0 kończy wczytywanie i nie jest dodawana. W schemacie pętla ma tu dwa bloki: wczytanie i romb sprawdzający zero.

        ( START )
            │
            ▼
       [ suma ← 0 ]
            │
            ▼
   ┌───> /wczytaj x/
   │        │
   │        ▼
   │   < x = 0 ? >──TAK──> /wypisz suma/ ──> ( STOP )
   │        │NIE
   │        ▼
   │   [ suma ← suma + x ]
   │        │
   └────────┘

Kod w Pythonie (dane testowe w liście zamiast klawiatury, żeby wynik był powtarzalny):

def suma_do_zera(dane):
    suma = 0
    for x in dane:
        if x == 0:
            break
        suma = suma + x
    return suma

print(suma_do_zera([4, 7, -1, 0, 9]))

Wynik uruchomienia:

10

Suma 4 + 7 − 1 = 10, a liczba 9 po zerze jest pomijana. Pętla for z break to zapis tego samego schematu: przerwanie następuje, gdy warunek w rombie jest spełniony. Python opisuje for jako iterowanie po elementach sekwencji, więc dane z listy zastępują kolejne wczytania z klawiatury.

Jak zamienić schemat na kod

Python opisuje instrukcję if jako wybór dokładnie jednej z gałęzi. Dzięki temu romb z dwiema strzałkami TAK i NIE ma prosty odpowiednik w kodzie.

Najczęstsze błędy

• Brak ścieżki NIE lub TAK przy rombie. Z rombu muszą wychodzić dwie strzałki, inaczej schemat nie mówi, co robić po nieudanym warunku.
• Pętla bez zmiany zmiennej w warunku. Jeśli w przykładzie 2 pominiesz i ← i + 1, warunek i ≤ n nigdy nie przestanie być prawdziwy i algorytm się nie skończy.
• Pomylenie przypisania z porównaniem. Zapis i ← i + 1 oznacza zmianę wartości, a n mod 2 = 0 to pytanie o równość.
• Warunek wewnątrz prostokąta. Instrukcje wyboru należą do rombu, prostokąt jest na czynności.
• Brak testu na sucho. Sprawdź schemat dla danych skrajnych, na przykład n = 0 w przykładzie 2.

Zobacz też: Algorytm, Rok przestępny, Sortowanie bąbelkowe.

Najczęstsze pytania (FAQ)

Czym różni się schemat blokowy od pseudokodu?

Schemat blokowy pokazuje przebieg graficznie, strzałkami i figurami, a pseudokod zapisuje te same kroki tekstem zbliżonym do języka programowania. Oba opisują ten sam algorytm i da się je zamieniać jeden na drugi, jak w przykładach wyżej.

Jaki kształt ma blok wejścia i wyjścia?

Równoległobok. Służy zarówno do wprowadzania wartości do algorytmu (na przykład wczytaj n), jak i do wypisywania wyników (na przykład wypisz suma).

Ile bloków STOP może mieć schemat?

Zaleca się jeden blok STOP. Przy bardzo rozbudowanych algorytmach dopuszcza się więcej, ale w zadaniach szkolnych łatwiej jednym blokiem kończyć wszystkie ścieżki.

Czy schemat blokowy trzeba rysować w specjalnym programie?

Nie. Wystarczy kartka i ołówek, a przy pracy w edytorze działają także schematy tekstowe jak w tym artykule. Ważne są poprawne kształty, strzałki i opisane wyjścia rombu.

Jak sprawdzić, czy schemat jest poprawny?

Przejdź go z kilkoma zestawami danych, w tym skrajnymi (zero, liczba ujemna, pusty zakres), i zapisuj wartości zmiennych po każdym kroku. Potem zapisz ten sam algorytm w Pythonie i porównaj wyniki.