Wprowadzenie

Podczas tej lekcji nauczysz się rozwiązywać problemy podobne do tych, które pojawiają się w konkursach informatycznych. Będziemy ćwiczyć logiczne myślenie i programowanie w języku Python, czyli umiejętności, które pomagają rozwiązywać zadania typu „algorytmicznego”.

w3schools – Kurs Pythona online
programiz – Edytor kodu Python online

Wprowadzenie do Pythona – pierwszy krok

Zanim zaczniemy rozwiązywać algorytmy, poznajmy kilka podstawowych zasad języka Python.
Python jest bardzo prosty w zapisie – wystarczy kilka linijek, by komputer wykonał polecenie.

1. Polecenie print() – wyświetlanie wyniku

W Pythonie instrukcja print() służy do wypisywania tekstu lub liczb.

print("Witaj w świecie Pythona!")
print(2 + 3)

2. Zmienna – miejsce na dane

Zmienna to jak pudełko, do którego możemy coś włożyć (np. liczbę lub tekst).

wiek = 12
imie = "Kuba"
print(imie, "ma", wiek, "lat")

3. Wczytywanie danych od użytkownika

Aby poprosić użytkownika o dane, używamy funkcji input().
Dane z input() są zawsze tekstem, więc jeśli chcemy liczyć, trzeba je zamienić na liczbę – przez int().

liczba = int(input("Podaj liczbę: "))
print("Podałeś:", liczba)

4. Obliczenia krok po kroku

Python rozumie zwykłe działania matematyczne:

a = 5
b = 3
suma = a + b
roznica = a - b
print("Suma:", suma)
print("Różnica:", roznica)

5. Skrócone zapisy – dopiero później

Zamiast pisać:

suma_cyfr = suma_cyfr + cyfra

można skrócić do:

suma_cyfr += cyfra

To znaczy dokładnie to samo!
Jednak na początku lepiej pisać pełne wersje, żeby łatwiej zrozumieć logikę.

6. Pętla while – powtarzanie czynności

Pętla to sposób, żeby komputer powtarzał czynność wiele razy.

i = 1
while i <= 5:
    print("To jest krok", i)
    i = i + 1

7. Operacje na cyfrach – // i %

• n // 10 – dzielenie całkowite (usuwa ostatnią cyfrę)
• n % 10 – reszta z dzielenia (czyli ostatnia cyfra liczby)

n = 123
print(n // 10)  # wynik: 12
print(n % 10)   # wynik: 3

Teraz możemy przejść do pierwszego przykładu z testu…

Teraz, gdy znasz już:

• jak działa print(),
• jak używać while,
• jak wyciągnąć ostatnią cyfrę (%) i skrócić liczbę (//),

możemy napisać pierwszy „prawdziwy” algorytm — czyli policzyć sumę cyfr liczby i liczbę cyfr.

Python na konkurs – Część 1: trening „pod test”
(z rozwiązaniami)

Czego się nauczysz

• Jak pisać i analizować proste algorytmy krok po kroku.
• Jak stosować operatory mod i div (czyli resztę i dzielenie całkowite).
• Jak obliczać sumę cyfr liczby i sprawdzać czy liczba jest parzysta.
• Jak tworzyć pętle i warunki w Pythonie.
• Jak przygotować się do zadań konkursowych z algorytmiki.

Przykład 1. Liczba cyfr i suma cyfr liczby

Treść zadania (typ 6 z testu):
Podaj liczbę cyfr oraz sumę cyfr liczby podanej przez użytkownika.

# Program obliczający liczbę cyfr i sumę cyfr liczby
n = int(input("Podaj liczbę: "))
liczba_cyfr = 0
suma_cyfr = 0

while n > 0:
    cyfra = n % 10        # reszta z dzielenia przez 10
    suma_cyfr += cyfra
    n //= 10              # dzielenie całkowite (odrzuca ostatnią cyfrę)
    liczba_cyfr += 1

print("Liczba cyfr:", liczba_cyfr)
print("Suma cyfr:", suma_cyfr)

Wskazówka:
W testach często pojawia się zapis n div 10 lub n mod 10.
W Pythonie odpowiadają im odpowiednio n // 10 oraz n % 10.

Przykład 2. Sprawdzanie palindromu

Treść zadania (typ 5 z testu):
Napisz program, który sprawdzi, czy wprowadzony wyraz to palindrom.

s = input("Podaj wyraz: ")
if s == s[::-1]:
    print("Tak, to palindrom")
else:
    print("Nie, to nie jest palindrom")

Wskazówka:
Palindrom to wyraz, który czyta się tak samo od początku i od końca, np. kajak.

Przykład 3. Suma cyfr parzystych liczby

Treść zadania (typ 17 z testu):

n = int(input("Podaj liczbę: "))
w = 0
while n != 0:
    if n % 2 == 0:            # sprawdzenie parzystości całej liczby
        w += n % 10           # dodaj ostatnią cyfrę
    n //= 10
print("Suma cyfr parzystych:", w)

Przykład 4. Zamiana liczb miejscami (bez zmiennej pomocniczej)

Treść zadania (typ 9 z testu):

x = int(input("Podaj X: "))
y = int(input("Podaj Y: "))

x = x + y
y = x - y
x = x - y

print("Po zamianie: X =", x, ", Y =", y)

Zadanie praktyczne

Napisz program, który:

1. Wczyta dowolną liczbę n.
2. Obliczy sumę cyfr parzystych.
3. Policz, ile jest cyfr w liczbie.
4. Wyświetli wyniki.

Zadania dodatkowe do samodzielnego rozwiązania

1. Napisz program, który zamienia liczbę dziesiętną na binarną (system dwójkowy).
2. Oblicz różnicę dat w dniach (np. między 10.05.2020 a 10.04.2020) używając biblioteki datetime.
3. Wczytaj z klawiatury imię i wypisz je od końca.
4. Wypisz wszystkie liczby od 1 do n, które są podzielne przez 3.

Podsumowanie

Podczas testu konkursowego możesz spotkać:

• pytania z logiki algorytmów (mod, div, pętla, warunek),
• proste zadania dotyczące systemów liczbowych i kodów binarnych,
• zastosowania arkuszy kalkulacyjnych i podstaw sieci komputerowych.

Python to doskonałe narzędzie, żeby zrozumieć, co dzieje się „pod maską” takich zadań.

Python na konkurs – Część 2: trening „pod test”
(z rozwiązaniami)

Cel: przećwiczyć w Pythonie dokładnie te schematy, które pojawiają się na etapie rejonowym: pętle, warunki, mod/div, operacje na cyfrach, sekwencje instrukcji, zamiana wartości, kontrola parzystości, konwersje do binarnego.

Przypominajka: zapisy mod, div, pętle

• a mod b → w Pythonie: a % b (reszta).
• a div b → w Pythonie: a // b (dzielenie całkowite).
• Pętla „dopóki (warunek)” → while warunek:.
• Instrukcja warunkowa → if ...: elif ...: else:.

1) Liczba cyfr i suma cyfr liczby

Typ arkuszowy: „ile cyfr + suma cyfr” (operacje % 10, // 10).

Kod (gotowiec):

n = int(input("Podaj liczbę naturalną: "))
liczba_cyfr = 0
suma_cyfr = 0

x = n
while x > 0:
    cyfra = x % 10      # ostatnia cyfra
    suma_cyfr += cyfra
    x //= 10            # ucinamy ostatnią cyfrę
    liczba_cyfr += 1

print("Liczba cyfr:", liczba_cyfr)
print("Suma cyfr:", suma_cyfr)

Test: dla n = 50218 → Liczba cyfr: 5, Suma cyfr: 16.

Spróbuj sam: dopisz liczenie sumy cyfr nieparzystych.

2) Suma cyfr parzystych liczby

Typ arkuszowy: sumowanie z warunkiem (por. zadanie z pętlą i mod).

Kod:

n = int(input("Podaj liczbę naturalną: "))
suma_parzystych_cyfr = 0
x = n
while x != 0:
    cyfra = x % 10
    if cyfra % 2 == 0:
        suma_parzystych_cyfr += cyfra
    x //= 10
print("Suma cyfr parzystych:", suma_parzystych_cyfr)

Spróbuj sam: policz także sumę cyfr nieparzystych oraz różnicę między sumami.

3) Palindrom na dwa sposoby

Typ arkuszowy: odwracanie łańcucha, porównanie.

Wersja prosta (slicing):

s = input("Podaj tekst: ")
print("palindrom" if s == s[::-1] else "nie")

Wersja pętlą (jak w algorytmie „doklejania na początek”):

s = input("Podaj tekst: ")
w = ""
for znak in s:
    w = znak + w
print("palindrom" if s == w else "nie")

Test: kajak → palindrom; kot → nie.

4) Zamiana X i Y bez zmiennej pomocniczej

Typ arkuszowy: zamiana wartości (ciąg trzech operacji).

x = int(input("X: "))
y = int(input("Y: "))

x = x + y
y = x - y
x = x - y

print("Po zamianie -> X:", x, " Y:", y)

Test: X=3, Y=7 → po zamianie X=7, Y=3.

5) Ile porównań wykona pętla?

Typ arkuszowy: „dopóki (N >= 0) { N := N – 3 }” – policz, ile razy sprawdzany jest warunek.

Kod liczący automatycznie:

N = int(input("N: "))
porownania = 0
x = N
while True:
    porownania += 1      # każde sprawdzenie warunku
    if x >= 0:
        x -= 3
    else:
        break
print("Liczba porównań warunku:", porownania)

Test: N = 15 → wypisz wynik i omów, dlaczego taki (krok po kroku).

6) Pętla „co 2”, akumulator i licznik

Typ arkuszowy: sekwencja przypisań z pętlą do warunku i <= n.

n = 8
i = 2
s = 0
while i <= n:
    s = s + i + 1
    i = i + 2
s = s + 1
print("s =", s, " i =", i)

Zadanie: uruchom i odczytaj wynik. Potem zmień n (np. na 10) i sprawdź, jak zmienia się s.

7) Sekwencja przypisań (symulacja „kroków”)

Typ arkuszowy: seria K1…K9 (zamiany a, b, c, licznik i).

a = 1
b = 2
i = 1
c = a
a = b
b = b + c + 1
i = i + 2
if i < 4:  # w oryginalnym algorytmie był skok do bloku z c,a,b,i – tu dopnij drugą iterację:
    c = a
    a = b
    b = b + c + 1
    i = i + 2

print("b =", b)

Spróbuj sam: przepisz to jako pętlę while z warunkiem na i, tak by było wierne pseudokodowi.

8) Sprawdzenie parzystości dwóch liczb (logika komunikatu)

Typ arkuszowy: warunek z mod i formułą logiczną.

a = int(input("a: "))
b = int(input("b: "))

if a % 2 != 1 and b % 2 != 1:
    print("Obie liczby są parzyste")
else:
    print("Przynajmniej jedna z liczb jest nieparzysta")

Rozszerz: dopisz wersję, która rozróżni trzy przypadki: „obie parzyste / dokładnie jedna parzysta / obie nieparzyste”.

9) Dziesiętna → binarna (i typowy błąd z kolejnością)

Typ arkuszowy: konwersja do binarnego; w wielu „pseudokodach” drukowanie reszt od razu daje odwrócony wynik.

Wersja błędna (druk od razu – pokazuje odwróconą kolejność):

n = 118
x = n
while x > 0:
    print(x % 2, end="")   # <-- źle dla finalnego zapisu
    x //= 2
print()

Wersja poprawna (gromadzenie, potem odwrócenie):

n = 118
x = n
bity = []
while x > 0:
    bity.append(x % 2)
    x //= 2
bity.reverse()
print("".join(str(bit) for bit in bity))

Test: 118 → 1110110.

Spróbuj sam: napisz funkcję to_bin(n) -> str i przetestuj dla kilku wartości.

10) Liczenie „po warunku” na liście (analogicznie do „LICZ.WARUNKI”)

Cel: przećwiczyć filtrację danych – jak w arkuszach, tylko w Pythonie.

osoby = [
    {"miasto": "Białystok", "wiek": 42, "pensja": 5200},
    {"miasto": "Białystok", "wiek": 39, "pensja": 4800},
    {"miasto": "Suwałki",   "wiek": 51, "pensja": 6100},
    {"miasto": "Białystok", "wiek": 45, "pensja": 7000},
]

# ile osób z Białegostoku i jednocześnie wiek > 40
wynik = sum(1 for o in osoby if o["miasto"] == "Białystok" and o["wiek"] > 40)
print("Wynik:", wynik)

Spróbuj sam: policz, ile osób ma nazwisko zaczynające się na „M” (gdyby rekordy miały klucz "nazwisko").

Mini-quiz (3 szybkie zadania „na punkty”)

1. Napisz funkcję licz_cyfry(n) zwracającą liczbę cyfr w n bez konwersji na string.
2. Napisz dokladnie_jedna_parzysta(a, b) – zwraca True, jeśli dokładnie jedna z liczb jest parzysta.
3. Napisz odwroc(s) – ręczne odwrócenie łańcucha pętlą for (bez [::-1]).

Podpowiedź: przetestuj na końcu:

print(licz_cyfry(10020))        # -> 5
print(dokladnie_jedna_parzysta(4, 9))  # -> True
print(odwroc("Python"))         # -> nohtyP