Koncepcje programowania/Rozwiązania zadań

Pierwszy program

Napisz program, który wczytuje imię, nazwisko, wiek oraz cenę chleba, a następnie te cztery zmienne drukuje na ekranie komputera.

# Pobieramy dane od użytkownika i konwertujemy cenę chleba na liczbę zmiennoprzecinkową
imie = input("Podaj swoje imię: ")
nazwisko = input("Podaj swoje nazwisko: ")
wiek = input("Podaj swój wiek: ")
cena_chleba = float(input("Podaj cenę chleba: "))

# Drukujemy pobrane dane na ekranie
print("Imię:", imie)
print("Nazwisko:", nazwisko)
print("Wiek:", wiek)
print("Cena chleba:", cena_chleba)

Ten program pobiera dane od użytkownika za pomocą funkcji input(), a następnie drukuje je na ekranie za pomocą funkcji print(). Możesz go uruchomić w konsoli lub w interpreterze Pythona.

Zmienne oraz typy danych

Napisz program,, który oblicza logarytm naturalny podanej na wejściu danych liczby

# Importujemy potrzebne biblioteki
import math

# Pobieramy liczbę od użytkownika
x = float(input("Podaj liczbę, dla której chcesz obliczyć logarytm naturalny: "))

# Obliczamy logarytm naturalny za pomocą funkcji log() z biblioteki math
ln = math.log(x)

# Drukujemy wynik na ekranie
print("Logarytm naturalny liczby", x, "wynosi:", ln)

Ten program używa biblioteki math do obliczenia logarytmu naturalnego za pomocą funkcji log(). Aby użyć tej funkcji, należy najpierw zaimportować bibliotekę math za pomocą instrukcji import. Następnie pobieramy liczbę od użytkownika za pomocą funkcji input() i konwertujemy ją na typ float, aby móc obliczyć jej logarytm. Na koniec drukujemy wynik na ekranie za pomocą funkcji print().

Jeśli chcesz, możesz zmienić sposób wyświetlania wyniku, na przykład zaokrąglając go do określonej liczby miejsc po przecinku lub używając notacji naukowej. Aby to zrobić, możesz użyć funkcji round() lub specjalnych formatów dla liczb zmiennoprzecinkowych w instrukcji print().

Napisz program, który oblicza pole koła o podanych na wejściu danych promieniu.

# Przyjmujemy promień koła od użytkownika
promien = float(input("Podaj promień koła: "))

# Obliczamy pole koła
pole = 3.14 * (promien ** 2)

# Wyświetlamy wynik na ekranie
print("Pole koła wynosi:", pole)

Napisz program, który oblicza pole prostokąta. Wartości boków a i b są typu float i należy je wyprowadzić z klawiatury. Wynik działania programu należy wyprowadzić na ekran komputera.

# Pobierz od użytkownika wartości boków a i b
a = float(input("Podaj wartość boku a: "))
b = float(input("Podaj wartość boku b: "))

# Oblicz pole prostokąta
pole = a * b

# Wyświetl wynik
print("Pole prostokąta wynosi:", pole)

W powyższym przykładzie używamy funkcji input() do pobrania wartości boków od użytkownika, a następnie obliczamy pole prostokąta przez mnożenie boków a i b. Ostatecznie wynik jest wyświetlany na ekranie za pomocą funkcji print().

Napisz program, który wyświetla na ekranie komputera wartość predefiniowanej stałej pi = 3.14... Naley przyjąć format wyświetlania tej stałej z dokładnością do trzech miejsc po przecinku

# Importuj bibliotekę math, aby uzyskać dostęp do stałej pi
import math

# Wyświetl wartość stałej pi z dokładnością do trzech miejsc po przecinku
print(f"Wartość stałej pi wynosi: {math.pi:.3f}")

W powyższym przykładzie najpierw importujemy bibliotekę math za pomocą instrukcji import, aby mieć dostęp do stałej pi. Następnie wyświetlamy wartość stałej pi za pomocą funkcji print(), a w specjalnym formacie wyświetlania f-string używamy notacji :.3f, aby zaokrąglić wartość do trzech miejsc po przecinku.

Napisz program, który wyświetla na ekranie komputera pierwiastek kwadratowy z wartości predefiniowanej pi = 3.14 z dokładnością do czterech miejsc po przecinku

# Importuj bibliotekę math, aby uzyskać dostęp do stałej pi
import math

# Oblicz pierwiastek kwadratowy z wartości stałej pi
pierwiastek = math.sqrt(math.pi)

# Wyświetl wartość pierwiastka z dokładnością do czterech miejsc po przecinku
print(f"Pierwiastek kwadratowy z pi wynosi: {pierwiastek:.4f}")

W powyższym przykładzie najpierw importujemy bibliotekę math za pomocą instrukcji import, aby mieć dostęp do stałej pi. Następnie obliczamy pierwiastek kwadratowy z pi przy użyciu funkcji sqrt() z biblioteki math. Ostatecznie wyświetlamy wartość pierwiastka za pomocą funkcji print() i specjalnego formatu wyświetlania f-string z notacją :.4f, aby zaokrąglić wynik do czterech miejsc po przecinku.

Napisz program, który oblicza resztę z dzielenia całkowitego dwóch liczb całkowitych a = 37 i b = 11

# Zdefiniuj liczby a i b
a = 37
b = 11

# Oblicz resztę z dzielenia całkowitego a przez b
reszta = a % b

# Wyświetl wynik
print(f"Reszta z dzielenia całkowitego {a} przez {b} wynosi: {reszta}")

Napisz program, w który generuje 5 liczb pseudolosowych z przedziału od 1 do 100

# Importuj bibliotekę random, aby uzyskać dostęp do funkcji losujących
import random

# Utwórz pustą listę, do której będziemy dodawać wylosowane liczby
liczby = []

# Wylosuj 5 liczb całkowitych z przedziału od 1 do 100 i dodaj je do listy
for _ in range(5):
    liczba = random.randint(1, 100)
    liczby.append(liczba)

# Wyświetl wylosowane liczby
print("Wylosowane liczby to:", liczby)

W powyższym przykładzie najpierw importujemy bibliotekę random za pomocą instrukcji import, aby uzyskać dostęp do funkcji losujących. Następnie tworzymy pustą listę liczby, do której będziemy dodawać wylosowane liczby. W pętli for wykorzystujemy funkcję randint() z biblioteki random do wylosowania pięciu liczb całkowitych z przedziału od 1 do 100 i dodajemy je do listy liczby. Ostatecznie wylosowane liczby są wyświetlane na ekranie za pomocą funkcji print().

Instrukcje warunkowe

Napisz program, który dla trzech liczb a, b, i c wprowadzonych z klawiatury sprawdza, czy to są trójki pitagorejskie. Dodatkowo należy założyć, że a > 0, b > 0 i c > 0

# Pobierz od użytkownika wartości liczb a, b i c
a = int(input("Podaj wartość liczby a: "))
b = int(input("Podaj wartość liczby b: "))
c = int(input("Podaj wartość liczby c: "))

# Sprawdź, czy liczby a, b i c tworzą trójkę pitagorejską
if a > 0 and b > 0 and c > 0 and a**2 + b**2 == c**2:
    print("Liczby a, b i c tworzą trójkę pitagorejską.")
else:
    print("Liczby a, b i c nie tworzą trójki pitagorejskiej.")

W powyższym przykładzie najpierw pobieramy wartości liczb a, b i c od użytkownika za pomocą funkcji input(). Następnie w instrukcji warunkowej if sprawdzamy, czy liczby a, b i c spełniają warunki tworzenia trójki pitagorejskiej (tj. czy są większe od zera i czy spełniają równanie a^2 + b^2 = c^2). W zależności od wyniku tych sprawdzeń wyświetlana jest odpowiednia informacja na ekranie za pomocą funkcji print().

Napisz program, który oblicza wartość x równiana ax + b = c. Wartości a, b i c należą do zbioru liczb rzeczywistych i są wprowadzane z klawiatury. Dodatkowo należy zabezpieczyć program na wypadek sytuacji, kiedy wprowadzona wartość a jest równa zero. Dla zmiennych a, b, i c oraz x należy przyjąć format wyświetlania ich z dokładnością do dwóch miejsc po kropce.

# Pobierz od użytkownika wartości liczb a, b i c
a = float(input("Podaj wartość liczby a: "))
b = float(input("Podaj wartość liczby b: "))
c = float(input("Podaj wartość liczby c: "))

# Jeśli wartość a jest równa zero, wyświetl odpowiedni komunikat
if a == 0:
    print("Wartość a nie może być równa zero.")
else:
    # Oblicz wartość x
    x = (c - b) / a

    # Wyświetl wynik z dokładnością do dwóch miejsc po kropce
    print(f"Wartość x wynosi: {x:.2f}")

W powyższym przykładzie najpierw pobieramy wartości liczb a, b i c od użytkownika za pomocą funkcji input(). Następnie w instrukcji warunkowej if sprawdzamy, czy wartość a jest równa zero, i w zależności od tego wyświetlamy odpowiedni komunikat lub obliczamy wartość x (przy użyciu równania x = (c - b) / a) i wyświetlamy wynik z dokładnością do dwóch miejsc po kropce za pomocą specjalnego formatu wyświetlania f-string.

Pętle

Napisz program, dla danych wartości x rosnących od 0 do 10 oblicza wartość funkcji y = 3x.

 for x in range(11):
    y = 3*x
    print("x =", x, "y =", y)

Program powyżej używa pętli for, która iteruje od 0 do 10 (range(11)) i dla każdej wartości x oblicza wartość y = 3x. Wynik jest wyświetlany na ekranie przy pomocy instrukcji print.

Napisz program, wyświetla wszystkie iczby całkowite od 1 do 20.

 
for i in range(1, 21):
    print(i)

Program powyżej używa pętli for, która iteruje od 1 do 20 (range(1, 21)) i dla każdej liczby całkowitej i ją wyświetla na ekranie przy pomocy instrukcji print.

Napisz program, sumuje liczby parzyste od 1 do 100

sum = 0

for i in range(1, 101):
    if i % 2 == 0:
        sum += i

print(sum)

Program powyżej używa pętli for, która iteruje od 1 do 100 (range(1, 101)). Następnie, sprawdza czy dana liczba jest parzysta (if i % 2 == 0) i jeśli jest, to dodaje ją do zmiennej sum.

Napisz program, sumuje liczby nieparzyste od 1 do 100

sum = 0

for i in range(1, 101):
    if i % 2 != 0:
        sum += i

print(sum)

Program powyżej używa pętli for, która iteruje od 1 do 100 (range(1, 101)). Następnie, sprawdza czy dana liczba jest nieparzysta (if i % 2 != 0) i jeśli jest, to dodaje ją do zmiennej sum.

Napisz program, który znajduje największą i najmniejszą liczbę ze zbioru n wylosowanych liczb całkowitych, generowanych losowo, w przedziale od 0 do 100 (w zadaniu - n = 5) oraz oblicza wartość średnią ze wszystkich wylosowanych liczb.

import random

n = 5
numbers = [random.randint(0, 100) for _ in range(n)]
print("Wylosowane liczby:", numbers)

min_num = min(numbers)
max_num = max(numbers)
mean = sum(numbers) / n

print("Najmniejsza liczba:", min_num)
print("Największa liczba:", max_num)
print("Wartość średnia:", mean)

Program powyżej importuje moduł random, następnie tworzy listę n liczb całkowitych losowych (numbers = [random.randint(0, 100) for _ in range(n)]) w przedziale od 0 do 100. Następnie wyświetla te liczby za pomocą instrukcji print. Następnie za pomocą build-in min i max znajdujemy największą i najmniejszą liczbę, a następnie obliczamy wartość średnią liczb n razy sumując listę i dzieląc przez n.

Napisz program, wyświetlający tabliczkę mnożenia dla liczb od 1 do 10 z wykorzystaniem podwójnej pętli for

for i in range(1, 11):
    for j in range(1, 11):
        print(f"{i} * {j} = {i*j}")
    print()

(range(1, 11)) i jest odpowiedzialna za wiersze tabliczki mnożenia. Druga pętla iteruje od 1 do 10 (range(1, 11)) i jest odpowiedzialna za kolumny tabliczki mnożenia. Dla każdej kombinacji liczby z pierwszej i drugiej pętli obliczana jest wartość iloczynu (i*j) i wyświetlana przy pomocy instrukcji print.

Funkcje

Napisz program, który definiuje prostą funkcję o nazwie wiadomosc() a następnie wywołuje tę funkcję w programie

def wiadomosc():
    print("Witaj w programie!")

wiadomosc()

Powyższy program definiuje funkcję o nazwie wiadomosc(), która wyświetla na ekranie komunikat "Witaj w programie!". Następnie, funkcja ta jest wywoływana na końcu programu za pomocą instrukcji wiadomosc().

Napisz program, w którym zdefiniowano cztery funkcje: dodawanie, odejmowanie, mnożenie i dzielenie. Liczby a i b należy wprowadzić z klawiatury. Dodatkowo trzeba założyć, że b musi być różne od zera.

def dodawanie(a, b):
    return a + b

def odejmowanie(a, b):
    return a - b

def mnozenie(a, b):
    return a * b

def dzielenie(a, b):
    if b == 0:
        return "Nie można dzielić przez 0!"
    return a / b

a = float(input("Podaj pierwszą liczbę: "))
b = float(input("Podaj drugą liczbę: "))

while b == 0:
    print("Druga liczba musi być różna od 0!")
    b = float(input("Podaj drugą liczbę: "))

print("Wynik dodawania: ", dodawanie(a,b))
print("Wynik odejmowania: ", odejmowanie(a,b))
print("Wynik mnożenia: ", mnozenie(a,b))
print("Wynik dzielenia: ", dzielenie(a,b))

Program powyżej definiuje cztery funkcje: dodawanie(), odejmowanie(), mnozenie(), dzielenie(). W funkcji dzielenie

Tablice

Utwórz listę swoich ulubionych filmów, a następnie napisz program , który wyświetla pierwsze i ostatnie filmy na liście.

favorite_movies = ["Incepcja", "Skazani na Shawshank", "Ojciec chrzestny", "Interstellar", "Lot nad kukułczym gniazdem", "Forrest Gump", "Milczenie owiec", "Szeregowiec Ryan", "Mroczny Rycerz", "Matrix"]

print("Mój pierwszy ulubiony film to:", favorite_movies[0])
print("Mój ostatni ulubiony film to:", favorite_movies[-1])

Napisz program , który skłania użytkownika do wprowadzenia 5 liczb całkowitych, a następnie przechowuje je na liście. Program powinien następnie obliczyć i wyświetlić sumę i średnią liczb na liście.

# prośba o wprowadzenie 5 liczb całkowitych
print("Proszę podać 5 liczb całkowitych:")
numbers = []
for i in range(5):
    number = int(input("Liczba {}: ".format(i+1)))
    numbers.append(number)

# obliczenie sumy i średniej
sum = 0
for number in numbers:
    sum += number
average = sum / len(numbers)

# wyświetlenie wyników
print("Suma liczb wynosi:", sum)
print("Średnia liczb wynosi:", average)

Program prosi użytkownika o wprowadzenie pięciu liczb całkowitych. Następnie liczby te są przechowywane na liście o nazwie numbers. Suma liczb jest obliczana przez iterowanie po liście i dodawanie każdej liczby do zmiennej sum. Średnia jest obliczana poprzez podzielenie sumy przez liczbę elementów na liście (w tym przypadku 5).

Napisz program , który generuje listę pierwszych 10 liczb równych, a następnie wydrukuje listę w odwrotnej kolejności.

# generowanie listy pierwszych 10 liczb naturalnych
numbers = list(range(1, 11))

# wyświetlenie oryginalnej listy
print("Oryginalna lista liczb:", numbers)

# wyświetlenie listy w odwrotnej kolejności
reversed_numbers = list(reversed(numbers))
print("Lista liczb w odwrotnej kolejności:", reversed_numbers)

W tym programie najpierw generowana jest lista pierwszych 10 liczb naturalnych przy użyciu funkcji range. Następnie oryginalna lista jest wyświetlana za pomocą funkcji print. Na koniec używamy funkcji reversed do odwrócenia kolejności elementów na liście, a następnie funkcji list do utworzenia nowej listy z tą odwróconą kolejnością. Wynik jest wyświetlany za pomocą funkcji print.

Napisz program , który skłania użytkownika do wprowadzenia zdania, a następnie przekształca zdanie w listę słów. Program powinien następnie wyświetlić liczbę słów w zdaniu i listę słów w kolejności alfabetycznej.

# prośba o wprowadzenie zdania
sentence = input("Proszę podać zdanie: ")

# podział zdania na słowa
words = sentence.split()

# wyświetlenie liczby słów w zdaniu
word_count = len(words)
print("Liczba słów w zdaniu wynosi:", word_count)

# wyświetlenie listy słów w kolejności alfabetycznej
words.sort()
print("Lista słów w kolejności alfabetycznej:")
for word in words:
    print(word)

W tym programie użytkownik jest proszony o wprowadzenie zdania, a następnie używamy metody split do podzielenia zdania na słowa i utworzenia listy słów o nazwie words. Następnie wyświetlamy liczbę słów w zdaniu za pomocą funkcji len. Następnie używamy metody sort do posortowania listy words w kolejności alfabetycznej. Ostatecznie wyświetlamy listę słów w kolejności alfabetycznej za pomocą pętli for.

Napisz program , który tworzy listę liczb od 1 do 20, a następnie używa slicing do wyświetlania tylko liczb na liście.

# tworzenie listy liczb od 1 do 20
numbers = list(range(1, 21))

# wyświetlanie listy liczb za pomocą slicingu
print("Pierwsze trzy liczby na liście:", numbers[:3])
print("Ostatnie trzy liczby na liście:", numbers[-3:])
print("Co trzecia liczba na liście:", numbers[::3])

W tym programie najpierw tworzona jest lista liczb od 1 do 20 przy użyciu funkcji range i konwersji na listę. Następnie używamy slicingu do wyświetlenia tylko niektórych elementów z tej listy.

W pierwszym print wyświetlamy pierwsze trzy liczby na liście za pomocą slicingu numbers[:3].

W drugim print wyświetlamy ostatnie trzy liczby na liście za pomocą slicingu numbers[-3:].

W trzecim print wyświetlamy co trzecią liczbę na liście za pomocą slicingu numbers[::3].

Napisz program , który skłania użytkownika do wprowadzenia listy liczb oddzielonych przecinkami, a następnie przekształca wejście ciągów na listę liczb całkowitych. Program powinien następnie wyświetlić sumę liczb na liście.

# prośba o wprowadzenie listy liczb oddzielonych przecinkami
numbers_string = input("Proszę podać listę liczb oddzielonych przecinkami: ")

# podział ciągu liczb na listę liczb
numbers_list = numbers_string.split(",")
numbers_list = [int(number) for number in numbers_list]

# wyświetlenie sumy liczb
sum_numbers = sum(numbers_list)
print("Suma liczb na liście wynosi:", sum_numbers)

W tym programie użytkownik jest proszony o wprowadzenie listy liczb oddzielonych przecinkami. Następnie używamy metody split do podzielenia ciągu liczb na listę liczb o nazwie numbers_list. Aby przekształcić każdy element na liście z ciągu znaków na liczbę całkowitą, używamy pętli listowej w połączeniu z funkcją int, jak pokazano powyżej.

Ostatecznie obliczamy sumę liczb na liście za pomocą funkcji sum i wyświetlamy ją.

Napisz program , który generuje listę 10 losowych liczb między 1 a 100, a następnie wyświetla największe i najmniejsze liczby na liście.

import random

# generowanie listy 10 losowych liczb
numbers = random.sample(range(1, 101), 10)

# wyświetlenie wylosowanych liczb
print("Wylosowane liczby:", numbers)

# wyświetlenie największej i najmniejszej liczby na liście
print("Największa liczba na liście to:", max(numbers))
print("Najmniejsza liczba na liście to:", min(numbers))

W tym programie używamy modułu random w języku Python, aby wygenerować listę 10 losowych liczb między 1 a 100 za pomocą funkcji random.sample. Następnie wyświetlamy wylosowane liczby za pomocą funkcji print.

Aby wyświetlić największą i najmniejszą liczbę na liście, używamy funkcji max i min, odpowiednio.

Napisz program , który zachęca użytkownika do wprowadzenia dwóch list liczb, a następnie łączy listy razem, aby utworzyć jedną listę. Program powinien następnie wyświetlić nową listę.

# pobieranie dwóch list liczb od użytkownika
list1 = input("Wprowadź pierwszą listę liczb oddzielonych przecinkami: ").split(",")
list2 = input("Wprowadź drugą listę liczb oddzielonych przecinkami: ").split(",")

# konwersja elementów list na typ int
list1 = [int(i) for i in list1]
list2 = [int(i) for i in list2]

# łączenie dwóch list w jedną
new_list = list1 + list2

# wyświetlenie nowej listy
print("Nowa lista: ", new_list)

W tym programie używamy funkcji input, aby pobierać od użytkownika dwie listy liczb oddzielonych przecinkami. Następnie używamy metody split, aby podzielić wprowadzony ciąg znaków na pojedyncze elementy, a następnie używamy list comprehension, aby przekonwertować każdy element listy na typ int.

Następnie łączymy dwie listy za pomocą operatora + i zapisujemy wynik w zmiennej new_list.

Ostatecznie wyświetlamy nową listę za pomocą funkcji print.

Napisz program , który tworzy listę 10 losowych liczb między 1 a 100, a następnie używa pętli do obliczenia i wyświetlania sumy liczb na liście.

import random

# tworzenie listy 10 losowych liczb między 1 a 100
numbers = []
for i in range(10):
    numbers.append(random.randint(1, 100))

# obliczanie sumy liczb na liście za pomocą pętli
sum = 0
for number in numbers:
    sum += number

# wyświetlanie sumy liczb na liście
print("Suma liczb na liście wynosi:", sum)

W tym programie używamy modułu random, aby wygenerować 10 losowych liczb między 1 a 100 i zapisujemy je w liście numbers. Następnie używamy pętli for do przejścia przez każdy element listy i dodajemy go do zmiennej sum.

Ostatecznie wyświetlamy sumę liczb na liście za pomocą funkcji print.

Napisz program , który zachęca użytkownika do wprowadzenia listy słów, a następnie usuwa dowolne duplikaty z listy. Program powinien następnie wyświetlić nową listę bez duplikatów.

# zachęcanie użytkownika do wprowadzenia listy słów
words = input("Wprowadź listę słów oddzielonych przecinkami: ")

# dzielenie ciągu wejściowego na słowa i usuwanie duplikatów
words_list = list(set(words.split(",")))

# wyświetlanie nowej listy bez duplikatów
print("Nowa lista bez duplikatów: ", ", ".join(words_list))

W tym programie zachęcamy użytkownika do wprowadzenia listy słów oddzielonych przecinkami za pomocą funkcji input. Następnie dzielimy ciąg wejściowy na słowa za pomocą metody split i usuwamy duplikaty z listy za pomocą funkcji set. Na koniec zamieniamy listę z powrotem na ciąg znaków, używając join i wyświetlamy nową listę bez duplikatów za pomocą funkcji print.

Wskaźniki i referencje

Napisz pogram, który deklaruje zmienną wskaźnika, inicjuje ją, aby wskazać zmienną liczbową, a następnie używa wskaźnika do przypisania nowej wartości do zmiennej liczby całkowitych.

Oto przykładowy program w języku C++, który realizuje zadanie opisane w pytaniu:

#include <iostream>

int main() {
    int liczba = 10; // deklaracja i inicjacja zmiennej liczbowej
    int *wskaznik = &liczba; // deklaracja wskaźnika i inicjacja go adresem zmiennej liczbowej

    std::cout << "Wartość zmiennej liczba: " << liczba << std::endl;
    std::cout << "Wartość zmiennej wskaznik: " << wskaznik << std::endl;
    std::cout << "Wartość zmiennej wskazywanej przez wskaźnik: " << *wskaznik << std::endl;

    *wskaznik = 20; // przypisanie nowej wartości do zmiennej liczbowej za pomocą wskaźnika

    std::cout << "Nowa wartość zmiennej liczba: " << liczba << std::endl;

    return 0;
}

Napisz pogram, który deklaruje tablicę liczb całkowitych, a następnie używa wskaźnika do dostępu i modyfikacji wartości w tablicy.

#include <iostream>

int main() {
    const int rozmiar = 5;
    int tablica[rozmiar] = {1, 2, 3, 4, 5}; // deklaracja i inicjacja tablicy liczb całkowitych

    std::cout << "Wartości w tablicy przed modyfikacją:" << std::endl;
    for (int i = 0; i < rozmiar; i++) {
        std::cout << "tablica[" << i << "] = " << tablica[i] << std::endl;
    }

    int *wskaznik = tablica; // deklaracja wskaźnika i inicjacja go adresem początku tablicy

    *wskaznik = 10; // modyfikacja wartości pierwszego elementu tablicy za pomocą wskaźnika

    std::cout << "Wartości w tablicy po modyfikacji:" << std::endl;
    for (int i = 0; i < rozmiar; i++) {
        std::cout << "tablica[" << i << "] = " << *(wskaznik + i) << std::endl;
    }

    return 0;
}

Program deklaruje tablicę liczb całkowitych tablica o rozmiarze 5 i inicjuje jej wartości. Następnie deklaruje wskaźnik wskaznik i inicjuje go adresem pierwszego elementu tablicy za pomocą nazwy tablicy (co automatycznie jest konwertowane na wskaźnik na pierwszy element). Program wyświetla na ekranie wartości w tablicy przed modyfikacją. Następnie program modyfikuje wartość pierwszego elementu tablicy za pomocą wskaźnika *wskaznik. Na koniec program wyświetla na ekranie wartości w tablicy po modyfikacji za pomocą operatora indeksowania oraz operatora inkrementacji wskaźnika.

Uwaga: tablice w C++ są indeksowane od zera, dlatego pierwszy element tablicy ma indeks 0, a ostatni element ma indeks rozmiar-1.

Napisz pogram, który deklaruje dwie zmienne całkowite, a następnie wykorzystuje wskaźnik do wymiany wartości dwóch zmiennych.

#include <iostream>

int main() {
    int a = 5, b = 10; // deklaracja i inicjacja dwóch zmiennych całkowitych

    std::cout << "Wartości przed wymianą: a = " << a << ", b = " << b << std::endl;

    int *wskaznik_a = &a; // deklaracja i inicjacja wskaźnika na zmienną a
    int *wskaznik_b = &b; // deklaracja i inicjacja wskaźnika na zmienną b

    int temp = *wskaznik_a; // przechowanie wartości zmiennej a w zmiennej tymczasowej
    *wskaznik_a = *wskaznik_b; // przypisanie wartości zmiennej b do zmiennej a za pomocą wskaźnika
    *wskaznik_b = temp; // przypisanie wartości zmiennej tymczasowej do zmiennej b za pomocą wskaźnika

    std::cout << "Wartości po wymianie: a = " << a << ", b = " << b << std::endl;

    return 0;
}

Program deklaruje dwie zmienne całkowite a i b i inicjuje ich wartości. Następnie program deklaruje dwa wskaźniki wskaznik_a i wskaznik_b i inicjuje je adresem zmiennych a i b odpowiednio. Program wyświetla na ekranie wartości zmiennych a i b przed wymianą. Następnie program wymienia wartości zmiennych a i b za pomocą wskaźników. Wartości zmiennych a i b są przypisywane do zmiennych tymczasowych i następnie wartość zmiennej b jest przypisywana do zmiennej a za pomocą wskaźnika *wskaznik_a. Na koniec wartość zmiennej tymczasowej jest przypisywana do zmiennej b za pomocą wskaźnika *wskaznik_b. Program wyświetla na ekranie wartości zmiennych a i b po wymianie.

Napisz pogram, który deklaruje zmienną ciągów, a następnie używa wskaźnika do wyświetlania każdego znaku w ciągu.

#include <iostream>

int main() {
    std::string slowo = "Hello, World!"; // deklaracja i inicjacja zmiennej ciągów

    std::cout << "Znak po znaku: ";
    for (char *wskaznik = &slowo[0]; *wskaznik != '\0'; wskaznik++) {
        std::cout << *wskaznik << " "; // wyświetlenie każdego znaku za pomocą wskaźnika
    }
    std::cout << std::endl;

    return 0;
}

Program deklaruje zmienną ciągów slowo i inicjuje jej wartość. Następnie program deklaruje wskaźnik wskaznik i inicjuje go adresem pierwszego znaku w ciągu, czyli adresem slowo[0]. Program wykorzystuje pętlę for, aby wyświetlić każdy znak w ciągu. W warunku pętli sprawdzane jest, czy wartość wskaźnika *wskaznik nie jest równa znakowi końca ciągu \0. Jeśli wartość wskaźnika jest różna od \0, to program wyświetla na ekranie wartość wskaźnika *wskaznik, czyli kolejny znak w ciągu, za pomocą operatora <<. Następnie wskaźnik jest inkrementowany, aby wskazywać na kolejny znak w ciągu. Program wyświetla na ekranie wartość każdego znaku w ciągu, oddzielając je spacją.

Napisz pogram, który deklaruje wskaźnik do struktury, inicjuje strukturę z niektórymi wartościami, a następnie wykorzystuje wskaźnik do uzyskiwania dostępu i modyfikacji wartości w strukturze.

#include <iostream>

struct Osoba {
    std::string imie;
    std::string nazwisko;
    int wiek;
};

int main() {
    Osoba osoba = {"Jan", "Kowalski", 30}; // inicjacja struktury
    Osoba *wskaznik = &osoba; // deklaracja i inicjacja wskaźnika

    std::cout << "Przed modyfikacją: " << std::endl;
    std::cout << "Imię: " << wskaznik->imie << ", Nazwisko: " << wskaznik->nazwisko << ", Wiek: " << wskaznik->wiek << std::endl;

    wskaznik->imie = "Adam"; // modyfikacja wartości w strukturze za pomocą wskaźnika
    wskaznik->nazwisko = "Nowak";
    wskaznik->wiek = 25;

    std::cout << "Po modyfikacji: " << std::endl;
    std::cout << "Imię: " << wskaznik->imie << ", Nazwisko: " << wskaznik->nazwisko << ", Wiek: " << wskaznik->wiek << std::endl;

    return 0;
}

Program deklaruje strukturę Osoba, która składa się z trzech pól: imie, nazwisko i wiek. Następnie program inicjuje strukturę osoba za pomocą składni listy inicjującej. Program deklaruje również wskaźnik wskaznik do struktury Osoba i inicjuje go adresem struktury osoba.

Program wykorzystuje operator strzałki ->, aby uzyskać dostęp do pól w strukturze za pomocą wskaźnika. Najpierw program wyświetla na ekranie wartości pól struktury osoba, używając wskaźnika do uzyskania dostępu do wartości. Następnie program modyfikuje wartości pól struktury osoba za pomocą wskaźnika i ponownie wyświetla wartości pól, aby potwierdzić, że modyfikacje zostały wykonane.

Napisz pogram, który deklaruje wskaźnik do funkcji, a następnie używa wskaźnika do wywołania funkcji i przekazywania niektórych argumentów.

#include <iostream>

int dodaj(int a, int b) {
    return a + b;
}

int main() {
    int (*wskaznik)(int, int); // deklaracja wskaźnika do funkcji
    wskaznik = &dodaj; // inicjacja wskaźnika

    int a = 3;
    int b = 5;
    int wynik = wskaznik(a, b); // wywołanie funkcji za pomocą wskaźnika i przekazanie argumentów

    std::cout << "Wynik dodawania " << a << " i " << b << " wynosi " << wynik << std::endl;

    return 0;
}

Program deklaruje funkcję dodaj, która przyjmuje dwa argumenty typu int i zwraca sumę tych argumentów. Następnie program deklaruje wskaźnik do funkcji o sygnaturze int (*wskaznik)(int, int). Ten wskaźnik wskazuje na funkcję dodaj za pomocą operatora adresu &.

W programie deklarowane są również zmienne a i b, które są argumentami przekazywanymi do funkcji dodaj. Następnie program wywołuje funkcję dodaj za pomocą wskaźnika wskaznik, przekazując zmienne a i b jako argumenty.

Wynik działania funkcji jest przypisywany do zmiennej wynik, a następnie wyświetlany na ekranie za pomocą obiektu std::cout.

Program napisz, który deklaruje wskaźnik do tablicy liczb całkowitych, a następnie używa wskaźnika do dostępu i modyfikacji wartości w tablicy.

#include <iostream>

int main() {
    int tablica[] = { 1, 2, 3, 4, 5 }; // deklaracja i inicjacja tablicy
    int *wskaznik = tablica; // deklaracja i inicjacja wskaźnika do tablicy

    // dostęp do wartości w tablicy za pomocą wskaźnika
    std::cout << "Pierwszy element w tablicy: " << *wskaznik << std::endl;
    std::cout << "Trzeci element w tablicy: " << *(wskaznik + 2) << std::endl;

    // modyfikacja wartości w tablicy za pomocą wskaźnika
    *(wskaznik + 1) = 10;
    std::cout << "Drugi element w tablicy po zmianie: " << *(wskaznik + 1) << std::endl;

    return 0;
}

Program deklaruje tablicę liczb całkowitych tablica i inicjuje ją przy użyciu listy inicjalizacyjnej. Następnie program deklaruje wskaźnik wskaznik do typu int, który będzie wskazywał na początek tablicy.

Aby uzyskać dostęp do wartości w tablicy, program używa operatora dereferencji *, który pozwala na odczytanie wartości spod adresu wskazywanego przez wskaźnik. W programie wykorzystano operator + do poruszania się po tablicy za pomocą wskaźnika. Np. wyrażenie *(wskaznik + 2) oznacza wartość trzeciego elementu w tablicy.

Aby zmodyfikować wartość w tablicy, program używa również operatora dereferencji *. Np. wyrażenie *(wskaznik + 1) = 10 ustawia wartość drugiego elementu w tablicy na 10.

Na końcu program wyświetla wartość zmienionej wartości w tablicy przy pomocy wskaźnika.

Napisz pogram, który deklaruje wskaźnik do wskaźnika, a następnie używa wskaźnika do dostępu i modyfikowania wartości zmiennej.

#include <iostream>

int main() {
    int liczba = 5; // deklaracja i inicjacja zmiennej liczbowej
    int *wskaznik1 = &liczba; // deklaracja i inicjacja wskaźnika do zmiennej liczbowej
    int **wskaznik2 = &wskaznik1; // deklaracja i inicjacja wskaźnika do wskaźnika

    std::cout << "Wartość zmiennej liczba: " << **wskaznik2 << std::endl; // dostęp do wartości za pomocą wskaźnika do wskaźnika

    **wskaznik2 = 10; // modyfikacja wartości zmiennej liczbowej za pomocą wskaźnika do wskaźnika

    std::cout << "Nowa wartość zmiennej liczba: " << **wskaznik2 << std::endl; // dostęp do zmodyfikowanej wartości za pomocą wskaźnika do wskaźnika

    return 0;
}

Program deklaruje zmienną liczbową liczba i inicjuje ją wartością 5. Następnie program deklaruje wskaźnik wskaznik1 do typu int, który wskazuje na adres tej zmiennej. Program deklaruje również wskaźnik wskaznik2 do typu int*, który wskazuje na adres wskaźnika wskaznik1.

Aby uzyskać dostęp do wartości zmiennej liczba za pomocą wskaźnika do wskaźnika, program używa operatora dereferencji * dwukrotnie: najpierw dla wskaznik2, a następnie dla wskaznik1. Np. wyrażenie **wskaznik2 oznacza wartość zmiennej liczba.

Aby zmodyfikować wartość zmiennej liczba za pomocą wskaźnika do wskaźnika, program również używa operatora dereferencji * dwukrotnie. Np. wyrażenie **wskaznik2 = 10 ustawia wartość zmiennej liczba na 10.

Na końcu program wyświetla nową wartość zmiennej liczba przy pomocy wskaźnika do wskaźnika.

Napisz pogram, który deklaruje zmienną liczbową, a następnie używa wskaźnika do alokacji pamięci dla tablicy liczb całkowitych i przypisania adresu tablicy do wskaźnika.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 10; // deklaracja zmiennej liczbowej
    int *p; // deklaracja wskaźnika do tablicy
    p = (int*) malloc(n * sizeof(int)); // alokacja pamięci dla tablicy i przypisanie adresu do wskaźnika

    // Przykładowe użycie wskaźnika do dostępu i modyfikacji wartości w tablicy:
    for(int i=0; i<n; i++) {
        *(p+i) = i*2; // przypisanie wartości do i-tego elementu tablicy
        printf("%d ", *(p+i)); // wyświetlenie wartości i-tego elementu tablicy
    }

    free(p); // zwolnienie zaalokowanej pamięci
    return 0;
}

W tym przykładzie, p jest wskaźnikiem do typu int, który jest używany do alokacji pamięci dla tablicy liczb całkowitych o rozmiarze n za pomocą funkcji malloc(). Następnie, w pętli for, możemy użyć p do dostępu i modyfikacji wartości w tablicy, a wyświetlenie wartości każdego elementu tablicy odbywa się za pomocą operatora * i indeksowania i. Na końcu programu, za pomocą funkcji free(), pamięć zaalokowana za pomocą malloc() zostaje zwolniona, aby uniknąć wycieku pamięci.

Napisz pogram, który deklaruje wskaźnik do postaci, a następnie używa wskaźnika do odczytu i zapisu danych do pliku.

#include <stdio.h>

typedef struct {
    int id;
    char name[20];
    float salary;
} Employee; // deklaracja struktury

int main() {
    Employee emp1 = {1, "John", 5000.0}; // deklaracja i inicjalizacja struktury
    Employee emp2; // deklaracja struktury
    Employee *ptr; // deklaracja wskaźnika do struktury
    ptr = &emp2; // przypisanie adresu struktury do wskaźnika

    // zapisywanie struktury do pliku
    FILE *fptr = fopen("employees.bin", "wb");
    if(fptr == NULL) {
        printf("Błąd otwarcia pliku.\n");
        return 1;
    }
    fwrite(&emp1, sizeof(Employee), 1, fptr);
    fclose(fptr);

    // odczytywanie struktury z pliku za pomocą wskaźnika
    fptr = fopen("employees.bin", "rb");
    if(fptr == NULL) {
        printf("Błąd otwarcia pliku.\n");
        return 1;
    }
    fseek(fptr, sizeof(Employee), SEEK_SET); // ustawienie pozycji kursora pliku
    fread(ptr, sizeof(Employee), 1, fptr); // odczytanie struktury do pamięci za pomocą wskaźnika
    fclose(fptr);

    // wyświetlenie danych odczytanych ze struktury za pomocą wskaźnika
    printf("ID: %d\n", ptr->id);
    printf("Name: %s\n", ptr->name);
    printf("Salary: %f\n", ptr->salary);

    return 0;
}

W tym przykładzie, deklarujemy strukturę Employee, która reprezentuje pracownika z identyfikatorem, imieniem i wynagrodzeniem. Następnie deklarujemy i inicjalizujemy dwie zmienne struktury, emp1 i emp2, oraz deklarujemy wskaźnik ptr, który będzie wskazywał na emp2. Następnie zapisujemy strukturę emp1 do pliku employees.bin za pomocą funkcji fwrite(). W kolejnym etapie odczytujemy strukturę z pliku za pomocą wskaźnika ptr i funkcji fread(), a następnie wyświetlamy odczytane dane. W tym przypadku używamy operatora strzałki ->, aby uzyskać dostęp do pól struktury za pomocą wskaźnika.

Warto zauważyć, że funkcja fopen() otwiera plik w trybie binarnym "b", co oznacza, że dane będą zapisywane i odczytywane w postaci binarnej. W przypadku plików tekstowych, nie ma potrzeby używania trybu binarnego.

Łańcuchy

Napisz program, który skłania użytkownika do wprowadzenia ich nazwy, a następnie używa konkatenacji, aby wyświetlić komunikat z życzeniami, taki jak „Hello, John!”

name = input("Podaj swoje imię: ")
print("Witaj, " + name + "! Miło Cię poznać!")

Kod ten działa w następujący sposób:

W pierwszej linii tworzymy zmienną name, do której zapiszemy imię użytkownika.
W drugiej linii korzystamy z funkcji input(), aby poprosić użytkownika o wprowadzenie swojego imienia. Tekst w argumencie funkcji input() zostanie wyświetlony jako pytanie do użytkownika.
W trzeciej linii korzystamy z funkcji print() do wyświetlenia powitania, w którym korzystamy z operatora # konkatenacji (+) do połączenia tekstu "Witaj, ", imienia użytkownika oraz wykrzyknika.
Program kończy działanie.

Napisz program odczytuje ciąg użytkownika, a następnie wyświetla długość ciągu.

string = input("Wprowadź ciąg znaków: ")
length = len(string)
print("Długość ciągu to:", length)

W pierwszej linii tworzymy zmienną string, do której zapiszemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii korzystamy z funkcji len(), aby obliczyć długość ciągu.
W trzeciej linii korzystamy z funkcji print() do wyświetlenia wyniku. Tekst w argumencie funkcji print() zostanie wyświetlony razem z wartością zmiennej length.

Napisz program, który odczytuje dwa ciągi od użytkownika, a następnie używa połączenia ciągów do połączenia dwóch ciągów w nowy ciąg.

string1 = input("Wprowadź pierwszy ciąg: ")
string2 = input("Wprowadź drugi ciąg: ")
result = string1 + string2
print("Połączony ciąg to:", result)

W pierwszej linii tworzymy zmienną string1, do której zapiszemy pierwszy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii tworzymy zmienną string2, do której zapiszemy drugi ciąg znaków wprowadzony przez użytkownika.
W trzeciej linii korzystamy z operatora konkatenacji (+) do połączenia dwóch ciągów w nowy ciąg i zapisujemy wynik do zmiennej result.
W czwartej linii korzystamy z funkcji print() do wyświetlenia wyniku. Tekst w argumencie funkcji print() zostanie wyświetlony razem z wartością zmiennej result.

Napisz program, który odczytuje ciąg od użytkownika, a następnie przekształca wszystkie znaki w ciągu na duże litery.

string = input("Wprowadź ciąg znaków: ")
uppercase_string = string.upper()
print("Ciąg z dużymi literami: ", uppercase_string)

W pierwszej linii tworzymy zmienną string, do której zapiszemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii korzystamy z metody upper() na zmiennej string, aby przekształcić wszystkie litery w ciągu na duże litery i zapisujemy wynik do zmiennej uppercase_string.
W trzeciej linii korzystamy z funkcji print() do wyświetlenia wyniku. Tekst w argumencie funkcji print() zostanie wyświetlony razem z wartością zmiennej uppercase_string.

Napisz program odczytujący ciąg użytkownika, a następnie używa pętli do wyświetlania każdego znaku w ciągu w osobnym wierszu.

string = input("Wprowadź ciąg znaków: ")
for char in string:
    print(char)

W pierwszej linii tworzymy zmienną string, do której zapiszemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii tworzymy pętlę for, która przejdzie przez każdy znak w ciągu i zapisze go do zmiennej char.
W trzeciej linii korzystamy z funkcji print() do wyświetlenia każdego znaku w osobnym wierszu. Dzięki użyciu pętli for, ta sama instrukcja zostanie wykonana dla każdego znaku w ciągu.

Napisz program, który odczytuje ciąg od użytkownika, a następnie używa slicing ciągów do wyświetlenia pierwszych i ostatnich znaków ciągu.

string = input("Wprowadź ciąg znaków: ")
first_char = string[0]
last_char = string[-1]
print("Pierwszy znak: ", first_char)
print("Ostatni znak: ", last_char)

W pierwszej linii tworzymy zmienną string, do której zapiszemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii korzystamy z slicingu ciągów, aby uzyskać pierwszy znak w ciągu, i zapisujemy go do zmiennej first_char. Slicing string[0] zwraca pierwszy znak w ciągu.
W trzeciej linii korzystamy z slicingu ciągów, aby uzyskać ostatni znak w ciągu, i zapisujemy go do zmiennej last_char. Slicing string[-1] zwraca ostatni znak w ciągu.
W czwartej i piątej linii korzystamy z funkcji print() do wyświetlenia wyników. Tekst w argumencie funkcji print() zostanie wyświetlony razem z wartością zmiennej first_char lub last_char.

Napisz program który odczytuje ciąg od użytkownika, a następnie używa indeksowania ciągów do wyświetlenia trzeciego znaku ciągu.

string = input("Wprowadź ciąg znaków: ")
third_char = string[2]
print("Trzeci znak: ", third_char)

W pierwszej linii tworzymy zmienną string, do której zapiszemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii korzystamy z indeksowania ciągów, aby uzyskać trzeci znak w ciągu, i zapisujemy go do zmiennej third_char. Indeksowanie string[2] zwraca trzeci znak w ciągu (numeracja indeksów w ciągach zaczyna się od 0).
W trzeciej linii korzystamy z funkcji print() do wyświetlenia wyniku. Tekst w argumencie funkcji print() zostanie wyświetlony razem z wartością zmiennej third_char.

Napisz program który odczytuje ciąg od użytkownika, a następnie używa metod ciągów do zliczenia liczby wystąpień określonego znaku w ciągu.

string = input("Wprowadź ciąg znaków: ")
char = input("Który znak chcesz zliczyć? ")
count = string.count(char)
print("Liczba wystąpień znaku", char, "w ciągu to:", count)

W pierwszej linii tworzymy zmienną string, do której zapiszemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii pobieramy od użytkownika znak, którego wystąpienia chcemy zliczyć, i zapisujemy go do zmiennej char.
W trzeciej linii korzystamy z metody count() ciągów, aby policzyć liczbę wystąpień znaku char w ciągu string, i zapisujemy wynik do zmiennej count.
W czwartej linii korzystamy z funkcji print() do wyświetlenia wyniku. Tekst w argumencie funkcji print() zostanie wyświetlony razem z wartością zmiennej count.

Napisz program który odczytuje ciąg od użytkownika, a następnie używa metod ciągów, aby zastąpić wszystkie wystąpienia określonego znaku innym znakiem.

string = input("Wprowadź ciąg znaków: ")
char = input("Który znak chcesz zamienić? ")
replacement = input("Na jaki znak chcesz zamienić? ")
new_string = string.replace(char, replacement)
print("Nowy ciąg znaków:", new_string)

W pierwszej linii tworzymy zmienną string, do której zapiszemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii pobieramy od użytkownika znak, który chcemy zamienić, i zapisujemy go do zmiennej char.
W trzeciej linii pobieramy od użytkownika znak, na który chcemy zamienić znak char, i zapisujemy go do zmiennej replacement.
W czwartej linii korzystamy z metody replace() ciągów, aby zamienić wszystkie wystąpienia znaku char w ciągu string na znak replacement, i zapisujemy wynik do zmiennej new_string.
W piątej linii korzystamy z funkcji print() do wyświetlenia wyniku. Tekst w argumencie funkcji print() zostanie wyświetlony razem z wartością zmiennej new_string.

Napisz program odczytu w ciągu użytkownika, a następnie używa metod ciągów, aby sprawdzić, czy ciąg zawiera określone podłoże.

string = input("Wprowadź ciąg znaków: ")
substring = input("Wprowadź szukane podłoże: ")
if string.find(substring) != -1:
    print("Ciąg zawiera podłoże.")
else:
    print("Ciąg nie zawiera podłoża.")

W pierwszej linii tworzymy zmienną string, do której zapisujemy ciąg znaków wprowadzony przez użytkownika.
W drugiej linii pobieramy od użytkownika podłoże, którego obecność w ciągu będziemy szukać, i zapisujemy go do zmiennej substring.
W trzeciej linii korzystamy z metody find() ciągów, aby sprawdzić, czy ciąg string zawiera podłoże substring. Metoda find() zwraca indeks pierwszego wystąpienia podłoża w ciągu, lub -1 jeśli podłoże nie występuje w ciągu.
W warunku if sprawdzamy, czy wynik metody find() jest różny od -1. Jeśli tak, to znaczy że ciąg zawiera podłoże, więc wyświetlamy odpowiedni komunikat. Jeśli nie, to wyświetlamy inny komunikat.

Rekurencje

Napisz program, który pięciokrotnie wywołuje funkcję rekurencyjną

def rekurencyjna(n):
    if n > 0:
        print(n)
        rekurencyjna(n-1)
    else:
        return

for i in range(5):
    rekurencyjna(5)

Program powyżej definiuje funkcję rekurencyjną rekurencyjna(), która przyjmuje jeden argument n. Wewnątrz funkcji, jeśli n jest większe od 0, to funkcja wypisuje n na ekranie i rekurencyjnie woła się z argumentem n-1. Gdy n jest równe 0, funkcja zwraca None. Następnie program iteruje przez 5 przebiegów i w każdym z nich wywołuje funkcję z argumentem 5.

Napisz program, który rekurencyjnie oblicza kolejne wartości n! dla n = 10 i wynik wyświetla na ekranie komputera.

def silnia(n):
    if n == 0:
        return 1
    else:
        return n * silnia(n-1)

n = 10
print(f"{n}! = {silnia(n)}")

Program powyżej definiuje funkcję rekurencyjną silnia(n), która oblicza silnię dla danego argumentu n. Wewnątrz funkcji, jeśli n jest równe 0, funkcja zwraca 1, jest to warunek brzegowy. W innym przypadku funkcja rekurencyjnie woła się z argumentem n-1 a następnie mnoży wynik przez n. Następnie program wywołuje tą funkcję dla n = 10 i wynik zapisuje i wyświetla na ekranie za pomocą f-string

Napisz program, który rekurecyjnie znajduje 1 pierwszych lizcb trójkątnych i wyświetla je na ekranie komputera.

def liczby_trojkatne(n):
    if n == 1:
        return 1
    else:
        return n + liczby_trojkatne(n-1)

for i in range(1, 11):
    print(liczby_trojkatne(i))

Program powyżej definiuje funkcję rekurencyjną liczby_trojkatne(n), która znajduje liczby trójkątne dla danego argumentu n. Wewnątrz funkcji, jeśli n jest równe 1, funkcja zwraca 1 jest to warunek brzegowy. W innym przypadku funkcja rekurencyjnie woła się z argumentem n-1 a następnie dodaje n do wyniku. Następnie program iteruje przez 10 przebiegów i w każdym z nich wywołuje funkcję liczby_trojkatne i wynik zapisuje i wyświetla na ekranie.

Napisz program, który znajduje 10 początkowych liczb ciągu fibonacciego i wyświetla je na ekranie komputera

def fibonacci(n):
    if n <= 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

for i in range(1, 11):
    print(fibonacci(i))

Program powyżej definiuje funkcję rekurencyjną fibonacci(n), która znajduje kolejne liczby ciągu Fibonacciego dla danego argumentu n. Wewnątrz funkcji, jeśli n jest mniejsze lub równe 2, funkcja zwraca 1, jest to warunek brzegowy. W innym przypadku funkcja rekurencyjnie woła się z argumentem n-1 i n-2, sumuje te wyniki i zwraca. Następnie program iteruje przez 10 przebiegów i w każdym z nich wywołuje funkcję fibonacci i wynik zapisuje i wyświetla na ekranie.

Napisz program, który rekurencyjnie wyznacza największy wspólny dzielnik (NWD) dwóch liczb dodatnich x i y.

def nwd(x, y):
    if y == 0:
        return x
    else:
        return nwd(y, x % y)

x = int(input("Podaj pierwszą liczbę: "))
y = int(input("Podaj drugą liczbę: "))
print(f"NWD({x}, {y}) = {nwd(x, y)}")

Program powyżej definiuje funkcję rekurencyjną nwd(x, y), która oblicza największy wspólny dzielnik (NWD) dwóch liczb dodatnich x i y. Wewnątrz funkcji, jeśli y jest równe 0, funkcja zwraca x. W innym przypadku funkcja rekurencyjnie woła się z argumentami y i x % y, czyli resztą z dzielenia x przez y, i zwraca tą wartość jako NWD. Następnie program pobiera dwie liczby od użytkownika i wywołuje funkcję nwd(x, y) oraz drukuje wynik na ekranie. Ten przykład używa algorytmu Euklidesa, który jest jednym z prostrzych i efektywny.