Den 4

TODO

# 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))

# 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)

# 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))

# 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))

# 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)

# 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))

# 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))

# 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)

# 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)

# 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)

# 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)

# 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)

# 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)

# 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("")

# 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)

# 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)

# 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))

# 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)

# 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()

—