====== Den 4 ======
===== Úkoly na funkce =====
==== Úkol 0 ====
TODO
==== Úkol 1 ====
# riskoana
def BMI_num(vyska_m, hmotnost_kg):
return(hmotnost_kg/(vyska_m**2))
def BMI_eval(BMI):
if BMI < 18.5:
print("podvaha")
elif BMI > 30:
print("nadvaha")
else:
print("zdrava vaha")
hmotnost_kg = float(input("Zadejte vahu v kg: "))
vyska_m = float(input("Zadejte vysku v m: "))
hodnota = BMI_num(vyska_m, hmotnost_kg)
print(hodnota)
print(BMI_eval(hodnota))
----
==== Úkol 2 ====
# riskoana
def swap(numbers, index_1, index_2):
# ověření, jestli jsou dodané indexy validní
if (index_1 < 0) or (index_2 < 0) or (index_1 > len(numbers) - 1) or (index_2 > len(numbers) - 1) or (index_1 == index_2):
print("zkus to znova, prosímtě")
else:
i = numbers[index_1]
j = numbers[index_2]
numbers[index_1] = j
numbers[index_2] = i
return numbers
# část pro testování
numbers = [1, 2, 3, 4, 5]
swap(numbers, 0, 1)
print(numbers)
----
==== Úkol 3 ====
# riskoana
import math
def smallest_number(numbers):
# minimum nastavíme na hodotu, oproti které je jakékoliv číslo menší
min = math.inf
index = len(numbers) + 1 # index nastaven na nevalidní hodnotu - pokud bude vrácena -1, máme jistotu selhání
for i in range(len(numbers)):
if numbers[i] < min:
min = numbers[i]
index = i
return index
numbers = [1, 2, 3, 4, 5, 0]
print(smallest_number(numbers))
----
==== Úkol 4 ====
# riskoana
from ukol3_reseni import smallest_number
# Napr opet za pomoci selection sort
def sort(array):
for i in range(len(array)):
idx_of_smallesrt = i + smallest_number(array[i:])
tmp = array[i]
array[i] = array[idx_of_smallesrt]
array[idx_of_smallesrt] = tmp
arr = [64, 25, 12, 22, 11, 3, 4, 53, 42]
print("Pred serazenim: " + str(arr))
sort(arr)
print("Po serazeni: " + str(arr))
----
===== Rozsáhlejší úkoly =====
==== Úkol 1 ====
# riskoana
import math
def read_input():
array = []
a = float(input())
while a != 0:
array.append(a)
a = float(input())
return array
def get_sum(array):
Sum = 0
for i in range(len(array)):
Sum += array[i]
return Sum
def get_sum_lazy(array):
return sum(array)
def get_avg(array):
return (get_sum(array) / len(array))
#další funkce
def get_max(array):
max = -(math.inf)
for i in range(len(array)):
if array[i] > max:
max = array[i]
return max
def get_min(array):
min = math.inf
for i in range(len(array)):
if array[i] < min:
min = array[i]
return min
def array_contains(array, number):
for i in range(len(array)):
if array[i] == number:
return True
return False
def print_receipt(array):
for i in range(len(array)):
print(array[i])
def serve_custormer():
prices = read_input()
print_receipt(prices)
----
==== Úkol 2 ====
# author kubikji2
import random
# minimalni hodnota ve vektoru
MIN_NUM = -10
# maximalni hodnota ve vektoru
MAX_NUM = 10
# rozsah hodnot ve vektoru
# '-> POZNAMKA: vsimni si, ze konstanta je psana velkymi pismena a je tedy
# pro Python neco jineho nez `range` ve for-cyklu
RANGE = MAX_NUM-MIN_NUM
# funkce pro kontrolu hodnoty delky vstupu
def check_length(length):
if length <= 0:
print("Vektor musi mit alespon jeden prvek.")
return False
else:
return True
# funkce pro generovani vektoru dane delky
def generate_vector(length):
# prazdny seznam pro vektor
v = []
# pro kazdy prvek vektoru ...
for i in range(length):
# ... nahodne vygeneruji cislo ...
el = random.random()*(RANGE)+MIN_NUM # [1]
# ... a cislo pridej do vektoru
v.append(el)
# vrat vektor
return v
# [1] altenativne lze pouzit randomrange, ktery generuje cela cisla:
# el = random.randrange(MIN_NUM, MAX_NUM)
# funkce pro vypocet skalarniho soucinu
def scalar_product(v1,v2):
# zjisti delku vektoru (bez obav, oba jsou stejne dlouhe)
length = len(v1)
result = 0
# pro kazdou pozici ve vektorech ...
for i in range(length):
# ... vynasob cisla a pridej je k vysledku
result += v1[i]*v2[i]
return result
# vytiskne vektor na jeden radek
def print_vector(vec):
# zjisti delku vektoru
length = len(vec)
# leva zavorka s mezerou ...
print("[ ", end="")
# ... vsechna cisla s mezerou na konci
for i in range(length):
print("{:5.2f} ".format(vec[i]), end="")
# ... prava zavorka bez mezery
print("]", end="")
# 1. nacist a zkontroloval velikost vektoru
length = int(input("Zadej delku vektoru: "))
is_length_ok = check_length(length)
# 2. je-li vse ok pokracovat
if is_length_ok:
# 3. vygenerovat oba vektory
v1 = generate_vector(length)
v2 = generate_vector(length)
# 4. provest skalarni soucin
a = scalar_product(v1,v2)
# 5. vypsat
print_vector(v1)
print(" . ", end="")
print_vector(v2)
print(" = {:5.2f}".format(a))
----
==== Rozšíření 2.1 ====
# author kubikji2
import random
# minimalni hodnota ve vektoru
MIN_NUM = -10
# maximalni hodnota ve vektoru
MAX_NUM = 10
# rozsah hodnot ve vektoru
# '-> POZNAMKA: vsimni si, ze konstanta je psana velkymi pismena a je tedy
# pro Python neco jineho nez `range` ve for-cyklu
RANGE = MAX_NUM-MIN_NUM
# funkce pro kontrolu hodnoty delky vstupu
def check_length(length):
if length <= 0:
print("Vektor musi mit alespon jeden prvek.")
return False
else:
return True
# funkce pro generovani vektoru dane delky
def generate_vector(length):
# prazdny seznam pro vektor
v = []
# pro kazdy prvek vektoru ...
for i in range(length):
# ... nahodne vygeneruji cislo ...
el = random.random()*(RANGE)+MIN_NUM # [1]
# ... a cislo pridej do vektoru
v.append(el)
# vrat vektor
return v
# [1] altenativne lze pouzit randomrange, ktery generuje cela cisla:
# el = random.randrange(MIN_NUM, MAX_NUM)
# funkce pro vypocet skalarniho soucinu
def scalar_product(v1,v2):
# zjisti delku vektoru (bez obav, oba jsou stejne dlouhe)
length = len(v1)
result = 0
# pro kazdou pozici ve vektorech ...
for i in range(length):
# ... vynasob cisla a pridej je k vysledku
result += v1[i]*v2[i]
return result
# vytiskne vektor na jeden radek
def print_vector(vec):
# zjisti delku vektoru
length = len(vec)
# leva zavorka s mezerou ...
print("[ ", end="")
# ... vsechna cisla s mezerou na konci
for i in range(length):
print("{:5.2f} ".format(vec[i]), end="")
# ... prava zavorka bez mezery
print("]", end="")
# funkce pro kontrolu zadaneho cisla
def check_number(num):
if num >= MIN_NUM and num <= MAX_NUM:
return True
else:
print("Zadane cislo mimo rozsah [{},{}]".format(MIN_NUM, MAX_NUM))
return False
# funkce pro opakovane cteni prvku matice
def read_single_number():
num = float(input(""))
is_num_ok = check_number(num)
# dokud neni nactene cislo ok, tak otravuj uzivatele
while not is_num_ok:
num = float(input("Zkus to znovu: "))
is_num_ok = check_number(num)
return num
def read_vector(length):
# prazdny seznam pro vektor
vec = []
# pro kazdy prvek vektoru ...
for i in range(length):
# ... nacti od uzivatele cislo ...
print("Zadavas cislo na pozici {}".format(i))
num = read_single_number()
# ... a cislo pridej do vektoru ...
vec.append(num)
# vrat vektor
return vec
# 1. nacist a zkontroloval velikost vektoru
length = int(input("Zadej delku vektoru: "))
is_length_ok = check_length(length)
# 2. je-li vse ok pokracovat
if is_length_ok:
# 3. vygenerovat oba vektory
print("Zadavas prvni vektor:")
v1 = read_vector(length)
print("Zadavas druhy vektor:")
v2 = read_vector(length)
# 4. provest skalarni soucin
a = scalar_product(v1,v2)
# 5. vypsat
print_vector(v1)
print(" . ", end="")
print_vector(v2)
print(" = {:.2f}".format(a))
----
==== Úkol 3 ====
# author kubikji2
import random
# maximalni velikost matic
MAX_SIZE = 10
# minimalni hodnota v matici
MIN_NUM = -10
# maximalni hodnota v matici
MAX_NUM = 10
# rozsah hodnot v matici
# '-> POZNAMKA: vsimni si, ze konstanta je psana velkymi pismena a je tedy
# pro Python neco jineho nez `range` ve for-cyklu
RANGE = MAX_NUM-MIN_NUM
# funkce vygeneruje matici zadane velikosti
def generate_matrix(size):
# vytvor prazdny seznam reprezentujici matici
mat = []
# pro kazdy radkovy index
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... nahodne vygeneruji cislo ...
el = random.random()*(RANGE)+MIN_NUM # [1]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
mat.append(row)
# vrat vygerovany seznam seznamu (matici)
return mat
# [1] altenativne lze pouzit randomrange, ktery generuje cela cisla:
# el = random.randrange(MIN_NUM, MAX_NUM)
# funkce vytiskne matici
def print_matrix(mat):
# zjistime jeji velikost (bez obav, je zajisteno, ze je ctvercova)
size = len(mat)
# pro kazdy radkovy index ...
for row_i in range(size):
# ... a kazdy sloupcovy index ...
for col_i in range(size):
# ... vypis cislo na prislusnych indexech ...
el = mat[row_i][col_i]
# ... celkem 7 znaku:
# '-> minimum a maximum je dvojmistne, navic mozne minus,
# tecka, dve desetinna mista a jedna oddelujici mezera
print("{:7.2f}".format(el), end="")
# zalomeni radku
print()
# funkce secte matice
def add_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... secti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] + B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce pro kontrolu velikosti matice
def check_size(size):
# matice nemuze mit velikost mensi nez 1 ...
if size < 1:
print("Matice nemuze mit velikost mensi nez 1.")
return False
# ... ani nemuze byt moc velka ...
elif size > MAX_SIZE:
print("Matice nemuze mit velikost vetsi nez " + str(MAX_SIZE))
return False
# ... jinak je ale v pohode
else:
return True
# 1. nacti a zkontroluj velikost
size = int(input("Zadej velikost matice: "))
is_size_ok = check_size(size)
# 2. je-li velikost ok, pokracuj
if is_size_ok:
# 3. vygeneruj obe matice
A = generate_matrix(size)
B = generate_matrix(size)
# 4. secti matice
C = add_matrices(A,B)
# 5. vytiskni matice i jejich soucet
print_matrix(A)
print("+")
print_matrix(B)
print("=")
print_matrix(C)
----
==== Rozšíření 3.1 ====
# author kubikji2
import random
# maximalni velikost matic
MAX_SIZE = 10
# minimalni hodnota v matici
MIN_NUM = -10
# maximalni hodnota v matici
MAX_NUM = 10
# rozsah hodnot v matici
# '-> POZNAMKA: vsimni si, ze konstanta je psana velkymi pismena a je tedy
# pro Python neco jineho nez `range` ve for-cyklu
RANGE = MAX_NUM-MIN_NUM
# funkce vygeneruje matici zadane velikosti
def generate_matrix(size):
# vytvor prazdny seznam reprezentujici matici
mat = []
# pro kazdy radkovy index
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... nahodne vygeneruji cislo ...
el = random.random()*(RANGE)+MIN_NUM # [1]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
mat.append(row)
# vrat vygerovany seznam seznamu (matici)
return mat
# [1] altenativne lze pouzit randomrange, ktery generuje cela cisla:
# el = random.randrange(MIN_NUM, MAX_NUM)
# funkce vytiskne matici
def print_matrix(mat):
# zjistime jeji velikost (bez obav, je zajisteno, ze je ctvercova)
size = len(mat)
# pro kazdy radkovy index ...
for row_i in range(size):
# ... a kazdy sloupcovy index ...
for col_i in range(size):
# ... vypis cislo na prislusnych indexech ...
el = mat[row_i][col_i]
# ... celkem 7 znaku:
# '-> minimum a maximum je dvojmistne, navic mozne minus,
# tecka, dve desetinna mista a jedna oddelujici mezera
print("{:7.2f}".format(el), end="")
# zalomeni radku
print()
# funkce secte matice
def add_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... secti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] + B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce odecte od sebe matice
def subtract_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... odecti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] - B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce pro kontrolu velikosti matice
def check_size(size):
# matice nemuze mit velikost mensi nez 1 ...
if size < 1:
print("Matice nemuze mit velikost mensi nez 1.")
return False
# ... ani nemuze byt moc velka ...
elif size > MAX_SIZE:
print("Matice nemuze mit velikost vetsi nez " + str(MAX_SIZE))
return False
# ... jinak je ale v pohode
else:
return True
# 1. nacti a zkontroluj velikost
size = int(input("Zadej velikost matice: "))
is_size_ok = check_size(size)
# 2. je-li velikost ok, pokracuj
if is_size_ok:
# 3. vygeneruj obe matice
A = generate_matrix(size)
B = generate_matrix(size)
# 4. odecti matice
C = subtract_matrices(A,B)
# 5. vytiskni matice i jejich rozdil
print_matrix(A)
print("-")
print_matrix(B)
print("=")
print_matrix(C)
----
==== Rozšíření 3.2 ====
# author kubikji2
import random
# maximalni velikost matic
MAX_SIZE = 10
# minimalni hodnota v matici
MIN_NUM = -10
# maximalni hodnota v matici
MAX_NUM = 10
# rozsah hodnot v matici
# '-> POZNAMKA: vsimni si, ze konstanta je psana velkymi pismena a je tedy
# pro Python neco jineho nez `range` ve for-cyklu
RANGE = MAX_NUM-MIN_NUM
# funkce vygeneruje matici zadane velikosti
def generate_matrix(size):
# vytvor prazdny seznam reprezentujici matici
mat = []
# pro kazdy radkovy index
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... nahodne vygeneruji cislo ...
el = random.random()*(RANGE)+MIN_NUM # [1]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
mat.append(row)
# vrat vygerovany seznam seznamu (matici)
return mat
# [1] altenativne lze pouzit randomrange, ktery generuje cela cisla:
# el = random.randrange(MIN_NUM, MAX_NUM)
# funkce vytiskne matici
def print_matrix(mat):
# zjistime jeji velikost (bez obav, je zajisteno, ze je ctvercova)
size = len(mat)
# pro kazdy radkovy index ...
for row_i in range(size):
# ... a kazdy sloupcovy index ...
for col_i in range(size):
# ... vypis cislo na prislusnych indexech ...
el = mat[row_i][col_i]
# ... celkem 7 znaku:
# '-> minimum a maximum je dvojmistne, navic mozne minus,
# tecka, dve desetinna mista a jedna oddelujici mezera
print("{:7.2f}".format(el), end="")
# zalomeni radku
print()
# funkce secte matice
def add_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... secti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] + B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce odecte od sebe matice
def subtract_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... odecti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] - B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# vynasobi matici danym cislem
def multiply_matrix(k,A):
# zjistime jeji velikost (bez obav, je zajisteno, ze matice ctvercova)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... vynasob cislo na prislusnych indexech v maticich A, cislem k...
el = k*A[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce pro kontrolu velikosti matice
def check_size(size):
# matice nemuze mit velikost mensi nez 1 ...
if size < 1:
print("Matice nemuze mit velikost mensi nez 1.")
return False
# ... ani nemuze byt moc velka ...
elif size > MAX_SIZE:
print("Matice nemuze mit velikost vetsi nez " + str(MAX_SIZE))
return False
# ... jinak je ale v pohode
else:
return True
# 1. nacti a zkontroluj velikost
size = int(input("Zadej velikost matice: "))
is_size_ok = check_size(size)
# 2. je-li velikost ok, pokracuj
if is_size_ok:
# 3. vygeneruj matici ...
A = generate_matrix(size)
# ... a nahodnou konstantu (treba v rozsahu [0,1) )
k = random.random()
# 4. secti matice
C = multiply_matrix(k,A)
# 5. vytiskni konstantu, matici i vysledek
print("{:7.2f}".format(k))
print("*")
print_matrix(A)
print("=")
print_matrix(C)
----
==== Rozšíření 3.3 ====
# author kubikji2
import random
# maximalni velikost matic
MAX_SIZE = 10
# minimalni hodnota v matici
MIN_NUM = -10
# maximalni hodnota v matici
MAX_NUM = 10
# rozsah hodnot v matici
# '-> POZNAMKA: vsimni si, ze konstanta je psana velkymi pismena a je tedy
# pro Python neco jineho nez `range` ve for-cyklu
RANGE = MAX_NUM-MIN_NUM
# funkce vygeneruje matici zadane velikosti
def generate_matrix(size):
# vytvor prazdny seznam reprezentujici matici
mat = []
# pro kazdy radkovy index
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... nahodne vygeneruji cislo ...
el = random.random()*(RANGE)+MIN_NUM # [1]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
mat.append(row)
# vrat vygerovany seznam seznamu (matici)
return mat
# [1] altenativne lze pouzit randomrange, ktery generuje cela cisla:
# el = random.randrange(MIN_NUM, MAX_NUM)
# funkce vytiskne matici
def print_matrix(mat):
# zjistime jeji velikost (bez obav, je zajisteno, ze je ctvercova)
size = len(mat)
# pro kazdy radkovy index ...
for row_i in range(size):
# ... a kazdy sloupcovy index ...
for col_i in range(size):
# ... vypis cislo na prislusnych indexech ...
el = mat[row_i][col_i]
# ... celkem 7 znaku:
# '-> minimum a maximum je dvojmistne, navic mozne minus,
# tecka, dve desetinna mista a jedna oddelujici mezera
print("{:7.2f}".format(el), end="")
# zalomeni radku
print()
# funkce secte matice
def add_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... secti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] + B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce odecte od sebe matice
def subtract_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... odecti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] - B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# vynasobi matici danym cislem
def multiply_matrix(k,A):
# zjistime jeji velikost (bez obav, je zajisteno, ze matice ctvercova)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... vynasob cislo na prislusnych indexech v maticich A, cislem k...
el = k*A[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce pro kontrolu velikosti matice
def check_size(size):
# matice nemuze mit velikost mensi nez 1 ...
if size < 1:
print("Matice nemuze mit velikost mensi nez 1.")
return False
# ... ani nemuze byt moc velka ...
elif size > MAX_SIZE:
print("Matice nemuze mit velikost vetsi nez " + str(MAX_SIZE))
return False
# ... jinak je ale v pohode
else:
return True
# funkce pro kontrolu operace
def check_operation(oper):
if (oper == "+") or (oper == "-") or (oper == "*"):
return True
else:
print("Zadana neplatna operace!")
return False
# funkce pro vykonani scitani
def execute_addition(size):
# 1. vygeneruj obe matice
A = generate_matrix(size)
B = generate_matrix(size)
# 2. secti matice
C = add_matrices(A,B)
# 3. vytiskni matice i jejich soucet
print_matrix(A)
print("+")
print_matrix(B)
print("=")
print_matrix(C)
# funkce pro vykonani odcitani
def execute_subtraction(size):
# 1. vygeneruj obe matice
A = generate_matrix(size)
B = generate_matrix(size)
# 2. odecti matice
C = subtract_matrices(A,B)
# 3. vytiskni matice i jejich rozdil
print_matrix(A)
print("-")
print_matrix(B)
print("=")
print_matrix(C)
# funkce pro vykonani nasobeni cislem
def execute_multiplication(size):
# 1. vygeneruj matici ...
A = generate_matrix(size)
# ... a nahodnym cislem (treba v rozsahu [0,1) )
k = random.random()
# 2. vynasob matici cislem
C = multiply_matrix(k,A)
# 3. vytiskni cislo, matici i vysledek
print("{:7.2f}".format(k))
print("*")
print_matrix(A)
print("=")
print_matrix(C)
# 1. nacti a zkontroluj velikost ...
size = int(input("Zadej velikost matice: "))
is_size_ok = check_size(size)
# ... je-li ok, tak:
if is_size_ok:
# 2. nacti a zkontroluj operaci
operation = input("Zadejte operaci (+/-/*): ")
is_operation_ok = check_operation(operation)
# 3. je-li operace ok, pokracuj
if is_operation_ok:
# 4. rozhodni, jakou operaci budeme vykonavat
if operation == "*":
execute_multiplication(size)
elif operation == "+":
execute_addition(size)
elif operation == "-":
execute_subtraction(size)
----
==== Rozšíření 3.4 ====
# author kubikji2
import random
# maximalni velikost matic
MAX_SIZE = 10
# minimalni hodnota v matici
MIN_NUM = -10
# maximalni hodnota v matici
MAX_NUM = 10
# rozsah hodnot v matici
# '-> POZNAMKA: vsimni si, ze konstanta je psana velkymi pismena a je tedy
# pro Python neco jineho nez `range` ve for-cyklu
RANGE = MAX_NUM-MIN_NUM
# funkce vygeneruje matici zadane velikosti
def generate_matrix(size):
# vytvor prazdny seznam reprezentujici matici
mat = []
# pro kazdy radkovy index
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... nahodne vygeneruji cislo ...
el = random.random()*(RANGE)+MIN_NUM # [1]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
mat.append(row)
# vrat vygerovany seznam seznamu (matici)
return mat
# [1] altenativne lze pouzit randomrange, ktery generuje cela cisla:
# el = random.randrange(MIN_NUM, MAX_NUM)
# funkce vytiskne matici
def print_matrix(mat):
# zjistime jeji velikost (bez obav, je zajisteno, ze je ctvercova)
size = len(mat)
# pro kazdy radkovy index ...
for row_i in range(size):
# ... a kazdy sloupcovy index ...
for col_i in range(size):
# ... vypis cislo na prislusnych indexech ...
el = mat[row_i][col_i]
# ... celkem 7 znaku:
# '-> minimum a maximum je dvojmistne, navic mozne minus,
# tecka, dve desetinna mista a jedna oddelujici mezera
print("{:7.2f}".format(el), end="")
# zalomeni radku
print()
# funkce secte matice
def add_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... secti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] + B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce odecte od sebe matice
def subtract_matrices(A,B):
# zjistime jeji velikost (bez obav, je zajisteno, ze jsou obe stejne velke a ctvercove)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... odecti cisla na prislusnych indexech v maticich A a B...
el = A[row_i][col_i] - B[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# vynasobi matici danym cislem
def multiply_matrix(k,A):
# zjistime jeji velikost (bez obav, je zajisteno, ze matice ctvercova)
size = len(A)
# vysledek
C = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek ...
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... vynasob cislo na prislusnych indexech v maticich A, cislem k...
el = k*A[row_i][col_i]
# ... a cislo pridej do radku ...
row.append(el)
# ... ted je radek hotovy, tak ho pridej do matice
C.append(row)
# vrat vygerovany seznam seznamu (matici)
return C
# funkce pro kontrolu velikosti matice
def check_size(size):
# matice nemuze mit velikost mensi nez 1 ...
if size < 1:
print("Matice nemuze mit velikost mensi nez 1.")
return False
# ... ani nemuze byt moc velka ...
elif size > MAX_SIZE:
print("Matice nemuze mit velikost vetsi nez " + str(MAX_SIZE))
return False
# ... jinak je ale v pohode
else:
return True
# funkce pro kontrolu operace
def check_operation(oper):
if (oper == "+") or (oper == "-") or (oper == "*"):
return True
else:
print("Zadana neplatna operace!")
return False
# funkce pro kontrolu zadaneho cisla
def check_number(num):
if num >= MIN_NUM and num <= MAX_NUM:
return True
else:
print("Zadane cislo mimo rozsah [{},{}]".format(MIN_NUM, MAX_NUM))
return False
# funkce pro opakovane cteni prvku matice
def read_single_number():
num = float(input(""))
is_num_ok = check_number(num)
# dokud neni nactene cislo ok, tak otravuj uzivatele
while not is_num_ok:
num = float(input("Zkus to znovu: "))
is_num_ok = check_number(num)
return num
# funkce pro nacteni cele matice danne velikosti
def read_matrix(size):
# vysledek
mat = []
# pro kazdy radkovy index ...
for row_i in range(size):
# ... vytvor prazdny seznam reprezentujici novy radek ...
row = []
# ... pro kazdy sloupcovy index (v novem radku) ...
for col_i in range(size):
# ... nacti od uzivatele cislo ...
print("Zadavas cislo na indexu [{},{}]: ".format(row_i, col_i))
num = read_single_number()
# ... a cislo pridej do radku ...
row.append(num)
# ... ted je radek hotovy, tak ho pridej do matice
mat.append(row)
# vrat nacteny seznam seznamu (matici)
return mat
# funkce pro vykonani scitani
def execute_addition(size):
# 1. nacti obe matice
print("Zadavas matici A:")
A = read_matrix(size)
print("Zadavas matici B:")
B = read_matrix(size)
# 2. secti matice
C = add_matrices(A,B)
# 3. vytiskni matice i jejich soucet
print_matrix(A)
print("+")
print_matrix(B)
print("=")
print_matrix(C)
# funkce pro vykonani odcitani
def execute_subtraction(size):
# 1. nacti obe matice
print("Zadavas matici A:")
A = read_matrix(size)
print("Zadavas matici B:")
B = read_matrix(size)
# 2. odecti matice
C = subtract_matrices(A,B)
# 3. vytiskni matice i jejich rozdil
print_matrix(A)
print("-")
print_matrix(B)
print("=")
print_matrix(C)
# funkce pro vykonani nasobeni cislem
def execute_multiplication(size):
# 1. nacti cislo ...
print("Zadavas cislo k: ")
k = read_single_number()
# ... nacti matici
print("Zadavas matici A:")
A = read_matrix(size)
# 2. vynasob matici konstantou
C = multiply_matrix(k,A)
# 3. vytiskni cislo, matici i vysledek
print("{:7.2f}".format(k))
print("*")
print_matrix(A)
print("=")
print_matrix(C)
# 1. nacti a zkontroluj velikost ...
size = int(input("Zadej velikost matice: "))
is_size_ok = check_size(size)
# ... je-li ok, tak:
if is_size_ok:
# 2. nacti a zkontroluj operaci
operation = input("Zadejte operaci (+/-/*): ")
is_operation_ok = check_operation(operation)
# 3. je-li operace ok, pokracuj
if is_operation_ok:
# 4. rozhodni, jakou operaci budeme vykonavat
if operation == "*":
print("Vybral si nasobeni cislem ve tvaru k * A.")
execute_multiplication(size)
elif operation == "+":
print("Vybral si scitani matic ve tvaru A + B.")
execute_addition(size)
elif operation == "-":
print("Vybral si odcitani matic ve tvaru A - B.")
execute_subtraction(size)
----
==== Úkol 4 ====
# proposed by LaSer
numbers = [5, 6, -11, 7, 3, 0, -5]
print("pred:", numbers)
unordered_idx = 0
while unordered_idx < len(numbers) - 1:
for index in range(unordered_idx, len(numbers)):
if numbers[unordered_idx] > numbers[index]:
numbers[unordered_idx], numbers[index] = numbers[index], numbers[unordered_idx]
unordered_idx += 1
print("po:", numbers)
----
==== Úkol 5 ====
# proposed by jiri.moravcik
n = int(input('Zadejte vysku Pascalova trojuhelniku: '))
# vypocet podle
# https://en.wikipedia.org/wiki/Pascal's_triangle
# "Calculating a row or diagonal by itself"
rows = []
for line in range(1, n + 1):
num = 1
row = []
for i in range(1, line + 1):
row.append(num)
num = int(num * (line - i) / i)
rows.append(row)
# pokrocilejsi formatovani tisku
last_row_length = len(' '.join(map(str, rows[-1])))
if last_row_length % 2 != 0:
last_row_length += 1
for row in rows:
row_to_print = ' '.join(map(str, row))
row_length = len(row_to_print)
if row_length % 2 != 0:
row_length += 1
spaces_to_print = (last_row_length - row_length) // 2
for i in range(spaces_to_print):
print(" ", end="")
print(row_to_print, end="")
for i in range(spaces_to_print):
print(" ", end="")
print("")
----
===== Rekurze =====
==== Úkol 1 ====
# proposed by mareddan, adapted by kubikji2
import random
MIN_INT = 1
MAX_INT = 100
# vnejsi funkce s jednoduchym rozhranim
def generate_random_array(length):
return add_to_array_recursive([], length)
# rekurzivni pridavani do seznamu
def add_to_array_recursive(my_list, remaining_els):
# ukoncovaci podminka
# '-> vrat seznam, kdyz pocet zbyvajicich prvku je 0 ...
# '-> vrat (prazdny) seznam, i kdyz uzivatel zadal zapornou delku
if remaining_els <= 0:
return my_list
# ... jinak vygeneruj novy prvek ...
el = random.randint(MIN_INT, MAX_INT)
# ... vloz ho do listu ...
my_list.append(el)
# ... a skoc o jednu uroven rekurze niz ---------------v
return add_to_array_recursive(my_list, remaining_els - 1)
TEST_LEN = 10
generated_array = generate_random_array(TEST_LEN)
print("Nahodne generovane pole o", TEST_LEN, "prvcich:", generated_array)
----
==== Úkol 2 ====
# proposed by mareddan, adapted by kubikji2
# rekurzivni faktorial
def factorial(x):
# je-li x rovno 1, vrat jednicku ...
if x == 1:
return 1
# ... jinak vrat: x.(x-1)!
return x * factorial(x-1)
TEST_NUMBER = 5
result = factorial(TEST_NUMBER)
print("Faktorial cisla", TEST_NUMBER, "je:", result)
----
==== Úkol 3 ====
# author kubikji2
# rekurzivni Fibonacci
def fibonacci(x):
# nulty clen Fibbonaciho posloupnosti je nula (zde i pro x < 0) ...
if x <= 0:
return 0
# ... prvni a druhy clen Fibonacciho jsou jedna ...
elif x <= 2:
return 1
# ... a vechny ostatni jsou souctem dvou predchazejicich clenu
return fibonacci(x - 1) + fibonacci(x - 2)
number = int(input("Zadej poradi ve fibonacciho posloupnosti: "))
result = fibonacci(number)
print("{}-ty prvek Fibonacciho posloupnosti ma hodnotu {}".format(number, result))
----
==== Úkol 4 ====
# proposed mareddan, riskoana, adapted by kubikji2
# vnejsi funkce s jednoduchym rozhranim pro generovani matice
def generate_matrix(size):
return add_to_matrix(size, MAX_NUMBER, [])
# rekurzivni funkce pro pridani radku (sub array)
def add_to_matrix(size, max_number, matrix):
# ukoncovaci podminka
# '-> vrat matici, kdyz maximalni cislo k pridani je mensi nez 0 ...
# '-> vrat (prazdnou) matici, i kdyz uzivatel zadal zapornou velikost
if max_number <= 0:
return matrix
# ... jinak vytvor pod pole (radek matice) ...
sub_array = add_to_sub_array(size, max_number, [])
# ... a to pridej do matice ...
matrix.append(sub_array)
# ... a skoc o uroven rekurze niz ------v
return add_to_matrix(size, max_number - size, matrix)
# rekurzivni pridavani prvku do seznamu
def add_to_sub_array(size, max_number, array):
# ukoncovaci podminka
# '-> vrat seznam, kdyz pocet zbyvajicich prvku je 0 ...
# '-> vrat (prazdny) seznam, i kdyz uzivatel zadal zapornou delku
if size <= 0:
return array
# ... jinak pridej aktualni cislo do seznamu ...
array.append(max_number)
# ... a skoc o uroven rekurze nize
return add_to_sub_array(size - 1, max_number - 1, array)
SIZE = 5
MAX_NUMBER = SIZE * SIZE - 1
result = generate_matrix(SIZE)
print(str(SIZE) + "x" + str(SIZE) + " matrix is:", result)
==== Úkol 5 ====
# proposed by LaSer
# chessboard row/column coordinates in range 0 - 8 (9 squares)
# as array indexes always start at 0 this is easier to code
# than using more "human readable" 1 - 9 range
# a 9x9(!) chessboard
chessboard = [
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0]
]
# knight moves are explicitly listed here
# can be done in a shorter but imho less clear way
knightMovesList = [
[-1, -2],
[-2, -1],
[-1, 2],
[-2, 1],
[1, -2],
[2, -1],
[1, 2],
[2, 1]
]
def knight_move(row, column, move_count):
# mark our current position
chessboard[row][column] = 1
# end condition
if move_count > 0:
for by_row, by_column in knightMovesList:
to_row = row + by_row
to_column = column + by_column
# prevent jumping off the board
if 0 <= to_row <= 8 and 0 <= to_column <= 8:
knight_move(to_row, to_column, move_count - 1) # decrease count
# (unmarked) return happens, when end condition is reached
def print_chessboard():
for row in chessboard:
for square in row:
print(square, end=" ")
print("")
moves = 3 # this includes the initial move to square 4,4...
knight_move(4, 4, moves - 1) # ...so decrement before calling the recursion
print_chessboard()
---