Řešení úkolů

Den 1

Den 1 dop. - Úkol 1

# Jana
 
a = float(input("Zadejte stranu ctverce: "))
 
obvod = 4*a
obsah = a*a
 
print("Obvod je: " + str(obvod))
print("Obsah je: " + str(obsah))

Volné autorské řešení: Miroslav Müller

Den 1 dop. - Úkol 2

# Bartolomej
# revize: Honza
 
a = float(input("Zadejte delku strany a: "))
b = float(input("Zadejte delku strany b: "))
 
obvod = 2*(a+b)
obsah = a*b
 
print("Obvod je: " + str(obvod))
print("Obsah je: " + str(obsah))

Volné autorské řešení:

Miroslav Müller

Den 1 dop. - Úkol 3

# Luka Jovanovic
# revize: Honza
pi = 3.14
 
r = float(input("Zadejte polomer kruhu:"))
 
obvod = 2*pi*r
obsah = pi*r*r
 
print("Obvod kruhu je: " +str(obvod))
print("Obsah kruhu je: " +str(obsah))

Volné autorské řešení:

Miroslav Müller

Den 1 dop. - Úkol 4

# Jiri Kubik
# revize: Honza
 
pi = 3.14
 
r = float(input("Zadejte polomer koule: "))
 
V = (4/3)*pi*r*r*r
S = 4*pi*r*r
 
print("Povrch koule o polomeru " + str(r) + " je:", S)
print("Objem koule o polomeru", r, "je: " + str(V))

Volné autorské řešení:

Miroslav Müller

Den 1 dop. - Úkol 5

# Jana
a = float(input("Zadejte a: "))
b = float(input("Zadejte b: "))
print("a+b =", a+b)
print("a-b =", a-b)
print("a*b =", a*b)

Volné autorské řešení:

Miroslav Müller

Den 1 dop. - Úkol 6

# autor neznamy
# revize: Honza
 
a = input("Zadejte a: ")
b = input("Zadejte b: ")
 
# na prohozeni hodnot si nejdrive ulozime hodnotu z "a" do pomocne promenne "c"
# kdyz mame hodnotu z "a" bezpecne ulozenou, priradime hodnotu z "b" do "a" (cimz prepiseme puvodni hodnotu v "a")
# pote do "b" priradime puvodni hodnotu "a", kterou jsme si ulozili v "c"
c = a
a = b
b = c
 
print("a = ", a)
print("b = ", b)

Aritmetické prohazování bez použití pomocné proměnné

# autor:riskoana
 
a = input("Zadejte a: ")
b = input("Zadejte b: ")
 
# doporucuju si to krok po kroku rozepsat nebo pro ilustraci odkomentovat zakomentovane radky kodu :)
 
a = a + b
# print("a = ", a)
b = a - b
# print("b = ", b)
a = a - b
# print("a = ", a)
 
print("a = ", a)
print("b = ", b)

Python magie

# autor:riskoana
 
a = input("Zadejte a: ")
b = input("Zadejte b: ")
 
# doporucuju si to krok po kroku rozepsat
a, b = b, a
 
print("a = ", a)
print("b = ", b)

Volné autorské řešení:

Miroslav Müller

Den 1 odp. - Úkol 1

# Bartolomej Bornus
# revize: Honza
 
delka = float(input("Zadejte delku: "))
sirka = float(input("Zadejte sirku: "))
vyska = float(input("Zadejte vysku: "))
 
objem = delka*sirka*vyska
 
print("Objem kvadru je:", objem)

Den 1 odp. - Úkol 2

# Marek Bistricky
# revize: Honza
import math
 
x1 = float(input("Zadej x1: "))
y1 = float(input("Zadej y1: "))
x2 = float(input("Zadej x2: "))
y2 = float(input("Zadej y2: "))
 
x_vzdalenost = x2 - x1
y_vzdalenost = y2 - y1
vzdalenost = math.sqrt(x_vzdalenost**2 + y_vzdalenost**2)
 
print("Body jsou od sebe vzdaleny", vzdalenost)

Den 1 odp. - Úkol 3

# Vojta J.
import math
a=float(input("Zadejte stranu a:"))
b=float(input("Zadejte stranu b:"))
c=float(input("Zadejte stranu c:"))
 
s=(a+b+c)/2
 
obsah=math.sqrt(s*(s-a)*(s-b)*(s-c)) #Heronuv vzorec
print("Obsah trojuhelniku je",obsah)

Den 1 odp. - Úkol 4

#Luka
a = int(input("Zadejte cislo:"))
if a%2==0:
    print("cislo je sude")
else:
    print("cislo je liche")

Volné autorské řešení:

Miroslav Müller

Den 1 odp. - Úkol 5

# Marek Bistricky
# Lucka
# revize: Honza
pi = 3.14
 
d = float(input("Zadej prumer sudu [v metrech]: "))
v = float(input("Zadej vysku sudu [v metrech]: "))
 
polomer_dm = (d/2)*10
vyska_dm = v*10
 
objem_dm3 = pi * polomer_dm**2 * vyska_dm
mnozstvi_dm3 = float(input("Zadej mnozstvi vody v sudu [v litrech]: "))
 
if mnozstvi >= objem_dm3:
    print("Sud pretece.")
else:
    print("Voda se do sudu vejde.")
    vyska_dm = mnozstvi / (pi*polomer_dm**2)
    print("Voda vystoupa do", vyska_dm/10, "metru.")

Volné autorské řešení:

Miroslav Müller

Den 1 odp. - Úkol 6

# Luka
a = int(input("Zadejte cislo:"))
if a>10 and a<20:
    print("Zadane cislo lezi v intervalu")
else:
    print("Zadane cislo nelezi v intervalu")

Den 1 odp. - Úkol 7

# Lucka
a = int(input("Zadej cislo a: "))
b = int(input("Zadej cislo b: "))
if a>b:
    print(a)
elif b>a:
    print(b)
else:
    print("Cisla se rovnaji")

Den 1 - Volitelný úkol 1

Inspiraci k nalezení algoritmu řešení je možné čerpat z Wikipedie

# MarekBistricky
# revize: StepanKrivanek
a = float(input("Zadejte a: "))
b = float(input("Zadejte b: "))
c = float(input("Zadejte c: "))
x = (-c**2+a**2+b**2)/(2*a*b)
x2 = (-a**2+c**2+b**2)/(2*c*b)
x3 = (-b**2+a**2*+c**2)/(2*a*c)
if ((a+b)>c and (b+c)>a) and (a+c)>b:
    print("Trojuhelnik lze sestrojit")
    if x == 0 or x2 == 0 or x3 == 0:
        print("Trojuhelnik je pravouhly")
    elif x > 0 and x2 > 0 and x3 > 0:
        print("Trojuhelnik je ostrouhly")
    else: 
        print("Trojuhelnik je tupouhly")
else:
    print("Trojuhelnik nelze setrojit")

Den 1 - Volitelný úkol 2

# Lucka
import math
a = float(input("Zadejte koeficient a: "))
b = float(input("Zadejte koeficient b: "))
c = float(input("Zadejte koeficient c: "))
D = b**2-(4*a*c)
if D < 0:
    print("Rovnice v R nema reseni")
elif D == 0:
    x=(-b)/(2*a)
    print("Reseni rovnice je x=",x)
else:
    x1=((-b)-math.sqrt(D))/(2*a)
    x2=((-b)+math.sqrt(D))/(2*a)
    print("Reseni rovnice je x1=",x1,"a x2=",x2)

Den 1 - Volitelný úkol 3

# Vojta
 
x1 = float(input("Zadej souradnici X prvniho bodu: "))
y1 = float(input("Zadej souradnici Y prvniho bodu: "))
x2 = float(input("Zadej souradnici X druheho bodu: "))
y2 = float(input("Zadej souradnici Y druheho bodu: "))
 
if((x2-x1) == 0):
    print("Smernice lezi v nekonecnu")
else:
    print("Smernice je:", ((y2 - y1)/(x2 - x1)))

Den 1 - Volitelný úkol 4

# Vojta
 
x1 = float(input("Zadej souradnici X prvniho bodu: "))
y1 = float(input("Zadej souradnici Y prvniho bodu: "))
x2 = float(input("Zadej souradnici X druheho bodu: "))
y2 = float(input("Zadej souradnici Y druheho bodu: "))
x3 = float(input("Zadej souradnici X tretiho bodu: "))
y3 = float(input("Zadej souradnici Y tretiho bodu: "))
 
vekx = x2 - x1
veky = y2 - y1
 
a = -veky
b = vekx
c = -a*x1 - b*y1
 
if(a*x3+b*y3+c==0):
    print("Body lezi v primce.")
else:
    print("Body nelezi v primce.")

Den 1 - Volitelný úkol 5

# Vojta
# revize: Honza
 
a = float(input("Zadej prvni cislo: "))
o = input("Zadej operaci: ")
b = float(input("Zadej druhe cislo: "))
zprava = str(a) + " " + o + " " + str(b) + " ="
 
if o == "+":
    print(zprava, a+b)
elif o == "-":
    print(zprava, a-b)
elif o == "*":
    print(zprava, a*b)
elif o == "/":
    if b == 0:
        print("Deleni nulou neni dovoleno.")
    else:
        print(zprava, a/b)
elif o == "^":
    print(zprava, a**b)
else:
    print("Nezadal jsi platnou operaci.")

Den 2 - Opakování - Úkol 1

# Vojta
utrata = int(input("Zadejte vasi utratu: "))
if (utrata > 0):
    padesat = utrata//50
    zbytek = utrata%50
    dvacet = zbytek//20
    zbytek = zbytek%20
    deset = zbytek//10
    zbytek = zbytek%10
    pet = zbytek//5
    zbytek = zbytek%5
    dva = zbytek//2
    zbytek = zbytek%2
    jedna = zbytek
    celkem = padesat+dvacet+deset+pet+dva+jedna
    print("Celkem je potreba " + str(celkem) + " minci")
    print("Pocet minci o hodnote 50 Kc:", padesat)
    print("Pocet minci o hodnote 20 Kc:", dvacet)
    print("Pocet minci o hodnote 10 Kc:", deset)
    print("Pocet minci o hodnote 5 Kc:", pet)
    print("Pocet minci o hodnote 2 Kc:", dva)
    print("Pocet minci o hodnote 1 Kc:", jedna)

Den 2 - Rozcvička

# Vojta
cislo = int(input("Zadej cislo N: "))
if cislo>0:
    for i in range(cislo):
        print("Ahoj")
    for i in range(1, cislo+1):
        print (str(i))
    for i in range(cislo, 0, -1):
        print (str(i))

Den 2 - Úkol 1

# Vojta
cislo = int(input("Zadej cislo N: "))
if cislo>0:
    for i in range(1, cislo):
        print (str(i) + ", ", end='')
    print (cislo)

Den 2 - Úkol 2

# Vojta
cislo = int(input("Zadej cislo N: "))
if cislo>0:
    for i in range(cislo, 1, -1):
        print (str(i) + ", ", end='')
    print ("1")

Den 2 - Úkol 3

# Vojta
faktorial = int(input("Zadej cislo N, jehoz faktorial budeme delat: "))
if (faktorial >= 0):
    if faktorial == 0:
        print("n!=1")
    else:
        vysledek = faktorial
        for i in range (faktorial-1, 0, -1):    
            vysledek = vysledek*i
        print("n!=", vysledek)

Den 2 - Úkol 4

# Vojta
cislo = int(input("Zadej prvocislo: "))
if (cislo > 1):
    for i in range (cislo-1, 0, -1):
        if (cislo%i == 0) and (i>1):
            print("Cislo " + str(cislo) + " neni prvocislo.")
            break
        if i == 1:
            print("Cislo " + str(cislo) + " je prvocislo.")          
else:
    print("Cislo " + str(cislo) + " neni prvocislo.")

Den 2 - Úkol 5

# Vojta
b = input("Zadejte cislo ve dvojkove soustave: ")
hodnota = 0
 
for i in range (0, len(b)):
    hodnota += int(b[i])*2**(len(b)-i-1)
 
print("Cislo v desitkove soustave ma hodnotu", hodnota)

Den 2 - Vnořené cykly - Úkol 1

# Vojta
cislo = int(input("Zadej cislo: "))
for x in range (0, cislo):
    for i in range (x-1, 0, -1):
        if (x%i == 0) and (i>1):
            #print("Cislo " + str(x) + " neni prvocislo.")
            break
        if i == 1:
            print(str(x), end=" ")          
print()

Den 2 - Vnořené cykly - Úkol 2

# Vojta
hodnost = int(input("Zadej hodnost matice: ")) 
for a in range (0, hodnost):
    for b in range (0, hodnost):
        if (a==b):
            print("1", end=" ")
        else:
            print("0", end=" ")
    print()

Den 2 - Vnořené cykly - Úkol 3

Vykreslení domku

— Martin Křížek 2021/09/08 15:01

Jako první získáme požadovanou výšku domu a zkontrolujeme, zda splňuje obě podmínky (liché číslo, větší nebo rovno 5).

vyska = int(input("Zadej vysku domu: "))
if (vyska < 5) or (vyska%2==0):
    print("Vyska musi byt liche cislo vetsi nez 5")

Když známe výšku (a tedy i šířku) začneme vypisovat střechu. Nejdříve vykreslíme špičku střechy přesně v polovině šířky domu.

else:
    print((vyska//2)*" " + "#")

Pro každé další “patro” střechy

for a in range (0, int((vyska//2)-1)):

vypíšeme dostatečné odsazení od začátku řádku.

print(((vyska//2)-1-a)*" ", end="")

Poté vykreslíme část střechy.

print("#", end="")

Výstup v terminálu nebude barevný :)

Vytvoříme mezeru uprostřed (štít střechy).

print((2*a+1)*" ", end="")

Nakonec vykreslíme část střechy na konci řádku a přeskočíme na další řádek.

print("#")

Přesuneme se k “tělu” domku. Vykreslíme horní řadu.

print("#"*vyska)

Vykreslíme stěny po řádcích stylem “znak + mezery + znak”. Vykreslíme o dva řádky méně než je výška (všechny kromě horního a dolního, ty se vykreslují samostatně).

for c in range (vyska-2):
    print("#" + " "*(vyska-2) + "#")

Jako poslední vykreslíme dolní řadu.

print("#"*vyska)

Kompletní kód

# Vojta
vyska = int(input("Zadej vysku domu: "))
if (vyska < 5) or (vyska%2==0):
    print("Vyska musi byt liche cislo vetsi nez 5")
else:
    print((vyska//2)*" " + "#")
 
    for a in range (0, int((vyska//2)-1)):
            print(((vyska//2)-1-a)*" ", end="")
            print("#", end="")
            print((2*a+1)*" ", end="")
            print("#")  
 
print("#"*vyska)
for c in range (vyska-2):
    print("#" + " "*(vyska-2) + "#")            
print("#"*vyska)

Den 2 - Volitelný úkol 1

# Vojta
predpred = 1
pred = 1
souc = 0
cislo = int(input("Zadej prirozene cislo: "))  
for i in range (cislo-3):
    souc = predpred + pred
    predpred = pred
    pred = souc
print(souc)

Den 2 - Volitelný úkol 2

# Vojta, fixed by LaSer
a = int(input("Zadej prirozene cislo a: "))    
b = int(input("Zadej prirozene cislo b: "))    
 
for i in range (1, b + 1):
    if (a % i == 0) and (b % i == 0):
        cislo = i
print(cislo)

Den 2 - Volitelný úkol 3

# Honza
 
prvni_cislo = int(input("Zadejte prvni cislo: "))
druhe_cislo = int(input("Zadejte druhe cislo: "))
 
if prvni_cislo > druhe_cislo:
        # prohodime hodnoty cisel, aby prvni cislo bylo mensi
	prvni_cislo, druhe_cislo = druhe_cislo, prvni_cislo 
 
soucet = 0
for i in range(prvni_cislo, druhe_cislo + 1):
	soucet += i
 
print(soucet)

Den 2 - Volitelný úkol 4

# Honza
 
zaklad = int(input("Zadejte zaklad: "))
exponent = int(input("Zadejte exponent: "))
 
if exponent == 0:
	if zaklad == 0:
		# nula na nultou
		print("Hodnota je nedefinovana.")
	else:
		# cokoliv na nultou je jedna
		print(str(zaklad) + "^0 = 1") 
elif zaklad == 0:
	# nula na cokoliv (krome nuly) je nula
	print("0^" + str(exponent) + " = 0")
else:
	vysledek = 1
	for i in range(exponent):
		vysledek *= zaklad
	print(str(zaklad) + "^" + str(exponent) + " = " + str(vysledek))

Den 2 - Volitelný úkol 5

# Honza
 
import random
 
pocet_cisel = 10 # ze zadani
 
nejvetsi_cislo = 0
druhe_nejvetsi_cislo = 0
prumer = 0
pocet_sudych = 0
pocet_lichych = 0
 
print("Pocitac vygeneroval: ", end = "")
for i in range(pocet_cisel):
	nahodne_cislo = random.randint(1, 100)
 
	if i == pocet_cisel - 1:
		print(nahodne_cislo)
	else:
		print(nahodne_cislo, end=", ")
 
	prumer += nahodne_cislo
 
	if nahodne_cislo % 2 == 0:
		pocet_sudych += 1
	else:
		pocet_lichych += 1
 
	if nahodne_cislo > nejvetsi_cislo:
		druhe_nejvetsi_cislo = nejvetsi_cislo
		nejvetsi_cislo = nahodne_cislo
	elif nahodne_cislo == nejvetsi_cislo or nahodne_cislo > druhe_nejvetsi_cislo:
		druhe_nejvetsi_cislo = nahodne_cislo
 
prumer /= pocet_cisel
print("Pocet sudych cisel ve vygenerovane posloupnosti je " + str(pocet_sudych))
print("Pocet lichych cisel ve vygenerovane posloupnosti je " + str(pocet_lichych))
print("Ve vygenerovane posloupnosti je " + str(nejvetsi_cislo) + " nejvetsim cislem.")
print("Ve vygenerovane posloupnosti je " + str(druhe_nejvetsi_cislo) + " druhym nejvetsim cislem.")
print("Prumer vygenerovane posloupnosti je " + str(prumer))

Den 3 - Úkol 1

# Vasek
a = int(input("Zadejte diferenci: "))
b = int(input("Zadejte prvni clen: "))
 
for i in range(b,a*20,a):
    print(i)

Den 3 - Úkol 2

# Jirka
 
suma = 0 # vnitrek zavorky z rovnice
 
# 10000 iteraci cyklu dava pomerne hezke reseni
# s vetsim poctem opakovani je hodnota pi presnejsi
for i in range(0,1000):
 
    clen = 1/(2*i+1) # aktualni clen posloupnosti v zavorce
 
    # rozhodovani o znamenku
    if(i%2 == 0):
        suma = suma + clen
    else:
        suma = suma - clen
 
pi = 4*suma
 
print(pi)

Den 3 - Vnořené cykly - Úkol 1

# Cvicici (Jirka)
 
size = 5 # VOLITELNE, velikost matice
 
# prvni matice 
for i in range(0, size):
    for j in range(0, size):
        # kdyz ke radek sudy, tak na nem jsou jednicky, jinak nuly
        if(i%2==0): 
            print("1 ", end="")
        else:
            print("0 ", end="")
    # zalomeni radku    
    print("")
 
# prazdny radek mezi maticemi
print("")
 
# druha matice
for i in range(0, size):
    for j in range(0, size):
        # kdyz je soucet indexu (i+j) sudym vypis jednicku, jinak nulu
        if((i+j)%2==0):
            print("1 ", end="")
        else:
            print("0 ", end="")
    # zalomeni radku    
    print("")

Den 3 - Vnořené cykly - Úkol 2

#Lukas Halaska
for i in range(1, 11):
    for j in range(1, 11):
        x = i*j
        if j==1:
            if (len(str(x))==2):
                print(end=str(x))
            else:
                print(" ", end=str(x))
        elif j==10:
            if (len(str(x))==3):
                print(" ", x, sep="")
            elif (len(str(x))==2):
                print("  ", x, sep="")
            else:
                print("   ", x, sep="")
        else:
            if (len(str(x))==2):
                print("  ", end=str(x))
            else:
                print("   ", end=str(x))

#Vojta J.
for k in range (1,10):
    for l in range (1,10):
        print("%2d" % (k*l), end=" ")
 
    print(" ")

Den 3 - Vnořené cykly - Úkol 3

# Cvicici (Jirka)
 
size = 5 # VOLITELNE, velikost matice
 
# prvni obrazec
for i in range(0, size):
    # vypis tolik "X", kolikaty mam radek
    # (nejhornejsi radek je prvni)
    #                   |
    #                   V 
    for j in range(0, i+1):
        print("X ", end="")
    # VOLITELNE, zbytek radku vypln mezerami
    for j in range(0,size-i):
        print("  ", end="")
    # zalomeni radku    
    print("")
 
# volny radek mezi obrazci
print("")
 
# druhy obrazec
for i in range(0, size):
    # vypis tolik mezer, kolikaty mame radek
    # (nejhornejsi radek je nulty)
    for j in range(0, i):
        print("  ", end="")
    # zbytek radku vypln "X"
    for j in range(0,size-i):
        print("X ", end="")
    print("")
 
# volny radek mezi obrazci
print("")
 
# treti obrazec
for i in range(0, size):
    for j in range(0, size):
        # "X" jsou v prvnim a poslednim radku a take v prvnim a poslednim sloupci
        # plati-li alespon jedno, vypis "X"
        if(i==0) or (i==size-1) or (j==0) or (j==size-1):
            print("X ", end="")
        else:
            print("  ", end="")
    print("")

Den 3 - While cyklus - Úkol 1

# Jan Tosner
 
y = 0
x = 1
z = 0
l = 0
n = 0
s = 0
while x != 0:
	x = int(float(input("Zadejte číslo: ")))
	y = y+x
	z = z+1
	if x%2 != 0:
		l = l+1
	if x > n:
		s = n
		n = x
	elif (x > s):
		s = x
print("Součet je "+str(y)+".")
print("Délka posloupnosti je "+str(z-1)+".")
print("Lichých čísel je "+str(l)+".")
print("Největší číslo je "+str(n)+".")
print("Druhé největší číslo je "+str(s)+".")

Den 3 - While cyklus - Úkol 2

# Jan Tosner
 
A = float(input("Zadejte číslo A: "))
B = float(input("Zadejte číslo B: "))
x = 1
while x != 0:
	A = A+1
	x = A%B
print("Nejmenší číslo dělitelné číslem B a je větší než číslo A je: "+str(A)+".")

Den 3 - While cyklus - Úkol 3

# @tamburinek
 
x = int(input("Zadejte cislo: "))
retezec = ""
 
while x>0:
    if x%2==0:
        retezec = "0" + retezec
    else:
        retezec = "1" + retezec
    x = x//2
print(retezec)

Den 3 - While cyklus - Úkol 4

#Lukas Halaska
import random
a = int(100 * random.random()) + 1
b = int(input("Zkus uhadnout cislo: "))
while b!=a:
    if b>a:
        print("Moje cislo je mensi")
    else:
        print("Moje cislo je vetsi")
    b = int(input("Zkus uhadnout cislo: "))
print("Uhodl jsi")

Den 3 - While cyklus - Úkol 5

# Jirka a Honza
dolni = 1
horni = 100
 
while horni != dolni:
    stred = ((horni+dolni)//2)
    c = input("Je tvoje cislo vetsi nez " + str(stred) + "? (y/n)")
    if c == "y":
        dolni = stred + 1
    else:
        horni = stred
 
print("Tvoje cislo je: " + str(horni))

Den 3 - While cyklus - Úkol 6

# proposed by jiri.moravcik
 
import math
 
x = int(input('Zadejte cele cislo '))
cislo = x
while True:
    cislo = cislo + 1
    je_prvocislo = True
    for i in range(2, int(math.sqrt(abs(cislo)) + 1)):
        if cislo % i == 0:
            je_prvocislo = False
    if je_prvocislo:
        print('Hledane cislo je', cislo)
        break

Den 3 - Seznamy - Úkol 1

# Jan Tosner
 
seznam = []
for i in range(0,10):
	x = int(float(input("Zadejte číslo: ")))
	seznam.insert(0,x)
print(seznam)

Den 3 - Seznamy - Úkol 2

# Stepan
 
numbers = []
y = 5
for i in range (0, 5):
    x = input ("zadejte " + str(y) + " cisel")
    x = int (x)
    numbers.append(x)
numbers.sort ()
z = len (numbers)
if z%2 == 0:
    med = (numbers[z/2]+numbers[(z/2)+1])/2
    print (med)
else:
    med = numbers[(int(z/2))]
    print (med)

Den 3 - Seznamy - Úkol 3

# Jan Tosner
 
seznam = []
for i in range(0,10):
	x = int(float(input("Zadejte číslo: ")))
	seznam.append(x)
seznam.sort()
print("Jsou to tato čísla:",seznam[-1], "a", seznam[0])

Den 3 - Seznamy - Úkol 4

# Jan Tosner
 
seznam = []
for i in range(0,10):
	x = int(float(input("Zadejte číslo: ")))
	seznam.append(x)
seznam.sort()
z = seznam[1]-seznam[0]
for i in range(0,9):
	if (seznam[i+1]-seznam[i]) <= z:
		x = seznam[i+1]
		y = seznam[i]
		z = x-y
print("Jsou to tato čísla:",x, "a", y)

Den 3 - Seznamy - Úkol 5

# Jan Tosner
 
seznam = []
for i in range(0,10):
	x = int(float(input("Zadejte číslo: ")))
	seznam.append(x)
for i in range(9,0,-1):
	for j in range(9,0,-1):
		if seznam[j] < seznam[j-1]:
			z = seznam.pop(j)
			seznam.insert(j-1,z)
print(seznam)

Den 4 - Úkol 1

Monte Carlo π

— Martin Křížek 2021/08/30 21:49

Tento algoritmus se skládá ze čtyř kroků:

Čtverci o straně 1 se vepíše kvadrant kružnice o poloměru 1
Náhodně se umístí daný počet bodů dovnitř čtverce
Sečte se počet bodů umístěných dovnitř kvadrantu kružnice
Poměr počtu bodů umístěných dovnitř kvadrantu kružnice k počtu všech bodů ve čtverci se vynásobí čtyřmi a získá se tak požadovaná aproximace π

Funguje pouze, pokud mají body rovnoměrné rozdělení. Kvadrant zabírá π/4 z jednotkové plochy čtverce, proto by měl poměr počtu bodů v kvadrantu kružnice k počtu bodů ve čtverci být také π/4, a proto násobíme v posledním kroku čtyřmi.

Implementace

Jako první importujeme moduly math a random kvůli přesné konstantě π a funkci random().

import math, random

Získáme počet požadovaných přesných desetinných míst.

digits = int(input('Zadej presnost vypoctu (pocet desetinnych mist)'))

Založíme proměnné: celkový počet bodů uvnitř čtverce, počet bodů v kvadrantu kružnice, hodnotu naší aproximace π a seznam pro uchovávání průběžných výsledků.

total_count = 0
in_circle_count = 0
my_pi = 0
approximations = []

Dále vytvoříme podmínku, která ukončí výpočet po dosažení požadované přesnosti aproximace. Dokud není rozdíl mezi naší aproximací my_pi a skutečnou hodnotou math.pi menší než např. 10^(−5). (abs() značí absolutní hodnotu)

while abs(my_pi−math.pi) > 10**−digits:

Pomocí funkce random() z modulu random vygenerujeme souřadnice nového bodu (x,y) (v rozmezí od 0 do 1) a přičteme nový bod k celkovému počtu bodů ve čtverci.

x = random.random()
y = random.random()
total_count += 1

U každého bodu zkontrolujeme, zda leží v kvadrantu kružnice (jeho vzdálenost od počátku je menší nebo rovna 1). Využijeme funkci pro druhou odmocninu sqrt() z modulu math.

if math.sqrt(x * x + y * y) <= 1:
    in_circle_count += 1

Vypočteme a vypíšeme aproximaci π podle čtvrtého kroku algoritmu.

my_pi = 4 * in_circle_count / total_count
print(my_pi)

Pokud máme v seznamu approximations uloženo méně než 100 prvků, tak pomocí funkce append() přidáme aktuální aproximaci na konec seznamu.

if len(approximations) <= 100:
    approximations.append(my_pi)

Po splnění podmínky while cyklu výslednou aproximaci vypíšeme a také všechny mezivýsledky uložené v seznamu approximations.

print("konecny vysledek", my_pi)
 
print("prvnich sto aproximaci")
for value in approximations:
    print(value)

Kompletní kód

import math, random
 
# proposed by LaSer
 
digits = int(input("Zadej presnost vypoctu (pocet desetinnych mist)"))
 
total_count = 0
in_circle_count = 0
my_pi = 0
 
approximations = []
 
while abs(my_pi - math.pi) > 10 ** -digits:
    x = random.random()
    y = random.random()
    total_count += 1
    if math.sqrt(x * x + y * y) <= 1:
        in_circle_count += 1
    my_pi = 4 * in_circle_count / total_count
    print(my_pi)
    # save the first 100 results to list
    if len(approximations) <= 100:
        approximations.append(my_pi)
 
print("konecny vysledek", my_pi)
 
print("prvnich sto aproximaci")
for value in approximations:
    print(value)

import random
import math
 
# proposed by poliape2
 
CIRCLE_CENTER = (0.5, 0.5)
 
def distance(a: (float, float), b : (float, float)) -> float:
  a1, a2 = a
  b1, b2 = b
  diff1 = a1 - b1
  diff2 = a2 - b2
  return math.sqrt((diff1 ** 2) + (diff2 ** 2))
 
digits = int(input("Input the desired number of digits precision: "))
 
total = 0
inside = 0
pi = 0
error = 0
precision = 0
while precision < digits:
  for t in range(100 ** ((digits + 1) // 2)):
    total += 1
    point = (random.random(), random.random())
    inside += distance(point, CIRCLE_CENTER) <= 0.5
  pi = 4 * inside / total
  error = abs(math.pi - pi)
  precision = math.log(total / 0.49, 100)
  print("points inside: %10d, outside: %10d" % (inside, total))
  print("computed pi: %.5f, lib pi: %.5f, error: %.5f" % (pi, math.pi, error))
  print("expected precision with 95%% confidence: %.2f" % precision)

Den 4 - Úkol 2a

Kalendář

— Martin Křížek 2021/08/31 13:46

Tuto úlohu rozdělíme na menší podproblémy, které postupně vyřešíme:

Funkce pro výpis do terminálu - na závěr vypíše požadovaný výstup do terminálu
Funkce pro zjištění velikosti posunu vůči konkrétnímu datu - v podstatě informuje funkci pro výpis o tom, jakým dnem vypisovaný měsíc začíná
Funkce pro identifikaci přestupného roku - identifikuje zda je daný rok přestupný nebo ne

Příprava

Pro lepší přehlednost a výpis se vytvoří tři seznamy. Seznam se jmény dnů, seznam se jmény měsíců a seznam s počty dní v korespondujících měsících.

days = ("PO", "UT", "ST", "CT", "PA", "SO", "NE")
months = ("Leden", "Unor", "Brezen", "Duben", "Kveten", "Cerven", "Cervenec", "Srpen", "Zari", "Rijen","Listopad","Prosinec")
monthsLen = (31,28,31,30,31,30,31,31,30,31,30,31)

Výpis do terminálu

Výstup v terminálu nebude barevný :)

Vstupem fukce je rok a měsíc, který má být vypsán. Poslední vstup je den, který je v daném měsíci první (středa, sobota atd.).

def printCalendary(year, month, beginDay):

Vypsání hlavičky obsahující měsíc a rok. Jako index je použit month-1, protože se indexuje od nuly (Leden - 0, Únor - 1 atd.).

print(months[month−1],year)

Vypsání jmen dní pomocí seznamu vytvořeného v přípravě.

for i in range(0,7):
   print(days[i]+" ",end="")
print()

Vytovření odsazení před prvním dnem v měsíci.

for i in range(0,beginDay):
   print("   ",end="")

Vypsání jednotlivých čísel dnů a nových řádků po konci/na začátku týdne. Formát výpisu je zde volen tak, aby jednociferná čísla zabírala stejně prostoru jako dvouciferná a výpis vypadal přehledně. Jako druhý argument range() je číslo o jedna větší než počet dní měsíce, aby byl vypsán i poslední den (range() vygeneruje seznam čísel včetně spodní a bez horní hranice).

for i in range(1,monthsLen[month-1]+1):
   print("%2d " % (i), end="")
 
   # zalomeni u nedele		
   if ((i+beginDay)%7 == 0):
      print()

Vypsání extra dne v přestupném roce na konci února.

if (month == 2 and isleapyear(year) == 1):
   print("29 ", end="")

Velikost posunu

Vstupem je požadovaný rok a měsíc.

def countBeginning(year, month):

Celkový posun budeme počítat ve dnech. Referenční datum bylo zvoleno jako 1.1.2018 (pondělí). Nejdříve tedy přepočteme počet let mezi zadaným a referenčním rokem (není to absolutní posun, záleží na směru +/-).

dr = year−2018
dd = dr*365

Dále započteme do posunu dny z měsíců (které nedají dohromady celý rok) podle zadaného měsíce. (horní hranice range() je zadaný měsíc, jeho dny tedy nezapočítáváme). Tato část vždy posouvá ve směru času, proto se zde vždy jen přičítá.

for i in range(0,month-1):
   dd += monthsLen[i]

Následně posuneme ve správném směru podle počtu přestupných roků. (ještě se nebere v úvahu zadaný rok)

if year > 2018:
   for y in range(2018,year):
      dd += isleapyear(y) 
 
   if year < 2018:
      for y in range(year+1,2018):
         dd -= isleapyear(y)

V případě, že je zadaný rok přestupný, posuneme dny o jeden nebo neděláme nic podle toho, jestli je zadaný měsíc před nebo po prodlouženém únoru.

if year > 2018:
   if isleapyear(year):
      if month <= 2:
         pass
      if month > 2:
         dd += 1
 
if year < 2018:
   if isleapyear(year):
      if month <= 2:
         dd −= 1
      if month > 2:
         pass

Na konci v podstatě vydělíme posun celým týdnem (7 dní) a podle zbytku zjistíme první den zadaného měsíce (0 - pondělí, 1 - úterý atd. protože naším referenčním dnem bylo pondělí) a tento zbytek je výstupem funkce.

dd %= 7
 
return dd

Identifikace přestupného roku

Tato funkce je velmi přímá. Vstupem je zadaný rok a výstupem je 0 (není přestupný) nebo 1 (je přestupný).

def isleapyear(year):

Rok je přestupný, pokud splňuje následující podmínky: každý rok, který je beze zbyku dělitelný čtyřmi, s výjimkou celých století, která nejsou beze zbytku dělitelná 400. Tyto podmínky jsou vyjádřeny zde a, pokud jsou splněny, je vrácena 1.

if (year % 4 == 0 and ((year % 100 != 0) or (year % 400 == 0))):
   return 1

Jinak je vrácena 0.

else:
   return 0

Získání vstupu a volání funkcí

Uživatelský vstup načteme do proměnných z terminálu pomocí input().

year = int(input("Zadejte rok: "))
month = int(input("Zadejte mesic: "))

Poté je zavolána funkce pro výpočet posunu zadaného měsíce vůči referenčnímu datu, ze které získáme první den zadaného měsíce.

diff = countBeginning(year,month)

Nakonec zavoláme funkci pro výpis do terminálu, která podle zadaného roku a měsíce a získaného posunu vytvoří přehled daného měsíce.

printCalendary(year,month,diff)

Kompletní kód

Řešení - Bez ošetření přestupných roků

# Kvant
days = ("PO", "UT", "ST", "CT", "PA", "SO", "NE")
months = ("Leden", "Unor", "Brezen", "Duben", "Kveten", "Cerven", "Cervenec", "Srpen", "Zari", "Rijen","Listopad","Prosinec")
monthsLen = (31,28,31,30,31,30,31,31,30,31,30,31)
 
# je rok prestupny?
def isleapyear(year):
    # rok je pres
    if (year % 4 == 0 and ((year % 100 != 0) or (year % 400 == 0))):
       return 1
    else:
       return 0 
 
def printCalendary(year, month, beginDay):
 
   # hlavicka jmeno mesice a rok
   print(months[month-1],year)
 
   # tisknuti zkratek jmen dnu
   for i in range(0,7):
      print(days[i]+" ",end="")
   print()
 
   # tisknuti mezer -- odsazeni 1. dne mesice
   for i in range(0,beginDay):
      print("   ",end="")
 
   # tisknuti dnu v mesici
   for i in range(1,monthsLen[month-1]+1):
      print("%2d " % (i), end="")
 
      # zalomeni u nedele		
      if ((i+beginDay)%7 == 0):
         print()
 
   # pridatani 29 v pripade, ze je rok prestupny a vypisovany mesic je unor
   if (month == 2 and isleapyear(year) == 1):
      print("29 ", end="")
 
   print()
   print()
 
def countBeginning(year, month):
   # rozdil v rocich od referencniho data
   dr = year-2018
 
   # rozdil v dnech na zaklade roku
   dd = dr*365 
 
   # rozdil ve dnech na zaklade mesicu
   for i in range(0,month-1):
      dd += monthsLen[i]
 
   # reseni dny za prestupne roky
   if year > 2018:
      for y in range(2018,year):
         dd += isleapyear(y) 
 
   if year < 2018:
      for y in range(year+1,2018):
         dd -= isleapyear(y)    
 
   if isleapyear(year):
      dd += 1
 
   dd %= 7
 
   return dd
 
year = int(input("Zadejte rok: "))
month = int(input("Zadejte mesic: "))
 
diff = countBeginning(year,month)
printCalendary(year,month,diff)

Den 4 - Úkol 2b

Pascalův trojúhelník

— Martin Křížek 2021/08/31 13:46

Tato úloha obsahuje dvě hlavní části. Nejdříve vypočteme hodnoty pro požadovanou velikost Pascalova trojúhelníku a poté naformátujeme konečný výpis.

Výpočet

Jednotlivé prvky trojúhelníku vypočteme po řádcích. Využijeme k tomu vztah C(n,k+1) = C(n,k) * (n-k)/(k+1), kde C() je označení pro kombinační číslo. Souvislost mezi kombinačními čísly a hodnotami trojúhelníku je vidět na obrázku.

Jako první získáme požadovaný počet řádků trojúhelníku.

n = int(input('Zadejte vysku Pascalova trojuhelniku: '))

Připravíme seznam rows, do kterého budeme ukládat další seznamy reprezentující jednotlivé řádky trojúhelníku. Sestavíme také cyklus, který bude iterovat od 1 do počtu řádků (včetně).

rows = []
for line in range(1, n + 1):

Proměnná num bude postupně obsahovat hodnoty jednotlivých prvků řádku a nejdříve je její hodnota 1, protože každý řádek začíná hodnotou 1. Seznam row bude obsahovat prvky daného řádku.

num = 1
row = []

Tímto cyklem iterujeme přes pozice v řádku. Aktuální hodnotu přidáme pomocí funkce append() na konec seznamu row.

for i in range(1, line + 1):
    row.append(num)

Pro samotný výpočet dalšího prvku v řádku využijeme vzorec C(n,k+1) = C(n,k) * (n-k)/(k+1), kde n nahradíme line, k nahradíme i a obě kombinační čísla (nové i předchozí) proměnnou num.

POZOR! n a k pro kombinační čísla v trojúhelníku začínají nulou (viz obrázek), ale naše line a i začínají na hodnotě 1. Musíme tedy vzorec C(n,k+1) = C(n,k) * (n-k)/(k+1) upravit tak, aby hodnoty na místech n a k začínaly na nule (odečteme jedničku od n i od k). Získáme tedy upravený vzorec pro naši potřebu C(n-1,k) = C(n-1,k-1) * (n-k)/(k).

Nyní stačí ve vzorci nahradit n, k pomocí line, i a kombinační čísla nahradit proměnnou num.

num = int(num * (line - i) / i)

Nakonec se seznam hodnot daného řádku trojúhelníku připojí na konec seznamu rows pomocí append().

rows.append(row)

Formátování výpisu

Jako první zjistíme délku posledního řádku trojúhelníku, abychom věděli, jak velké odsazení zvolit u předchozích řádků. Zároveň musíme ale poslední řádek vytvořit pomocí funkcí map() a join().

map() - první argument je funkce a druhý argument je “iterovatelný” objekt. Funkce map() vykoná funkci, která byla zadána jako argument, na všech prvcích druhého argumentu (např. seznam).

join() - vloží znak mezi každé sousední prvky iterovatelného objektu. Funkce join() pracuje jen s typem string.

V tomto případě se všechny hodnoty posledního řádku trojúhelníku rows[-1] přetypují na string pomocí funkce map(). Dále funkce join() vloží mezi sousední prvky znak mezery (' '). Následně se pomocí funkce len() získá délka řádku.

last_row_length = len(' '.join(map(str, rows[-1])))

Délka není jen počet hodnot v řádku. Započítat se musí každý jeden znak včetně mezer (přetypovali jsme na string)

Následující část kódu pouze zajišťuje lepší vycentrování výpisu (rozdíl je hlavně při větším počtu řádků).

if last_row_length % 2 != 0:
    last_row_length += 1

Pro každý seznam row (reprezentující hodnoty řádku trojúhelníku) ze seznamu rows se nejprve sestaví string pomocí funkcí map(), join() stejně jako v předchozím případě. Získá se opět také délka stringu pomocí len().

for row in rows:
    row_to_print = ' '.join(map(str, row))
    row_length = len(row_to_print)

Opět vycentrovat.

if row_length % 2 != 0:
    row_length += 1

Chceme zjistit, kolik mezer se musí vložit před první hodnotu v řádku (stejný počet jako za poslední hodnotu), aby se doplnilo na úroveň délky posledního řádku. Je to tedy rozdíl počtu znaků posledního a aktuálního řádku rozdělen na dvě poloviny.

spaces_to_print = (last_row_length - row_length) // 2

Vypíši první polovinu mezer pro vycentrování (s argumentem end=“” abychom zůstali na stejném řádku).

for i in range(spaces_to_print):
    print(" ", end="")

Poté se vypíší samotné hodnoty.

print(row_to_print, end="")

Vypsání druhé poloviny mezer není nutné, ale zde je uvedeno.

for i in range(spaces_to_print):
    print(" ", end="")

Nakonec přesun na nový řádek.

print("")

Výstup v terminálu nebude barevný :)

Kompletní kód

# 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 LaSer
 
n = int(input('Zadejte vysku Pascalova trojuhelniku: '))
 
# classical solution, sum of neighbours from previous row
 
rows = [[1]]
for row_num in range(n - 1): # to explain -1
    actual_row = []
    upper_row = rows[row_num]
    actual_length = len(upper_row) + 1
    for i in range(actual_length):
        if i == 0:
          num = upper_row[i]
        elif i == actual_length - 1: # to explain -1
          num = upper_row[i - 1]
        else:
          num = upper_row[i - 1] + upper_row[i]
        actual_row.append(num)
    rows.append(actual_row)
 
# simple (ugly) print
 
for row in range(0, len(rows)):
  for num in rows[row]:
    print(num, end=" ")
  print("")
 
print('---')
 
# a naive attempt for better formatting - will break for 3 and more digit numbers
 
last_row_count = len(rows[-1])
for row in range(0, len(rows)):
  start_pos = last_row_count - row - 1
  print(" " * start_pos, end="")
  for num in rows[row]:
    print(num, end=" ")
  print("")

Den 4 - Úkol 3

# proposed by jiri.moravcik
 
import random, itertools
 
def vygeneruj_vektor(dimenze):
    return [round(random.uniform(-100, 100), 2) for i in range(dimenze)]
 
def skalarni_soucin(v1, v2):
    seznam_dvojic = itertools.zip_longest(v1, v2, fillvalue=0)
    return sum([x[0] * x[1] for x in seznam_dvojic])
 
def nacti_vektor(poradi):
    return list(map(float, input('Zadejte cisla ' + str(poradi) + '. vektoru oddelena mezerou: ').split(' ')))
 
def vytiskni_vysledek(v1, v2, sk_soucin):
    print(str(v1) + '.' + str(v2) + ' = ' + str(sk_soucin))
 
volba = input('Pro nahodne vektory zadejte 1, pro rucni zadani 2: ')
if volba == '1':
    dimenze = int(input('Zadejte dimenzi (rozmer) vektoru: '))
    v1 = vygeneruj_vektor(dimenze)
    v2 = vygeneruj_vektor(dimenze)
    vytiskni_vysledek(v1, v2, skalarni_soucin(v1, v2))
elif volba == '2':
    v1 = nacti_vektor(1)
    v2 = nacti_vektor(2)
    vytiskni_vysledek(v1, v2, skalarni_soucin(v1, v2))

Alternativní řešení

import random
 
# propsed by poliape2
 
vec_length = int(input("Zadejte dimenzi (rozmer) vektoru: "))
vec_a = []
for i in range(vec_length):
    vec_a.append(random.randint(0,100)/10)
 
vec_b = [random.randint(0,100)/10 for _ in range(vec_length)]
 
dot_product = 0
for i in range(vec_length):
    dot_product += vec_a[i] * vec_b[i]
 
# alternativne funkce zip
#dot_product = 0
#for (a, b) in zip(vec_a, vec_b):
#    dot_product += a * b
 
# alternativne 2
#import operator
#dot_product = sum(map(operator.mul, vec_a, vec_b))
 
print(vec_a,".", vec_b, "=", dot_product)

Den 4 - Úkol 4

# Mirek M
 
import random
 
# vstup uzivatele
n = int(input("Zadejte dimenzi matic: "))
 
# generace dvou nahodnych matic o velikonsti n x n
# vytvor pole pro jednotlive radky matice
matice_1 = []
matice_2 = []
for i in range(n):
    # vytvor pole pro jeden radek matice, napln ho a pridej do matice
    radek_1 = []
    radek_2 = []
    for j in range(n):
        # generace nahodneho floatu v rozsahu a zaokrouhleni na 1 des misto
        radek_1.append(round(random.uniform(0.0, 5.0), 1))
        radek_2.append(round(random.uniform(0.0, 5.0), 1))
    matice_1.append(radek_1)
    matice_2.append(radek_2)
 
# vstup uzivatele
znamenko = input("Zadejte operaci (+/-/*): ")
 
# print zadani vypoctu
for i in range(n):
    for j in range(n):
        # formatovani floatu na jedno desetinne misto a celkem 4 charaktery
        print("%4.1f " % matice_1[i][j], end="")
    print()
 
print(znamenko)
 
for i in range(n):
    for j in range(n):
        print("%4.1f " % matice_2[i][j], end="")
    print()
 
print("=")
 
# vypocet dle znamenka a print vysledku
if znamenko == "+":
    for i in range(n):
        for j in range(n):
            print("%4.1f " % (matice_1[i][j] + matice_2[i][j]), end="")
        print()
 
elif znamenko == "-":
    for i in range(n):
        for j in range(n):
            print("%4.1f " % (matice_1[i][j] - matice_2[i][j]), end="")
        print()
 
elif znamenko == "*":
    # pro vypocet nutno ukladat mezivysledek
    # zkraceny zapis dvou vnorenych cyklu pro naplneni cele matice nulami
    vysledek = [[0 for i in range(n)] for j in range(n)]
    for i in range(n):
        for j in range(n):
            for k in range(n):
                vysledek[i][j] += matice_1[i][k] * matice_2[k][j]
    # print
    for i in range(n):
        for j in range(n):
            print("%4.1f " % vysledek[i][j], end="")
        print()
 
else:
    print("Chybny vstup")

Den 4 - Úkol 5

Selection sort

— Martin Křížek 2021/08/31 17:00

Selection sort má seznam rozdělený na seřazenou (od začátku seznamu až po určitý index) a neseřazenou (zbytek seznamu) část. Selection sort seřadí seznam opakováním tří kroků:

Nalezne nejmenší prvek v neseřazené části
Prohodí nejmenší nalezený prvek s prvním prvkem neseřazené části
Zařadí první pozici v neseřazené části do seřazené části

Vytvoříme pole, které chceme řadit a vypíšeme ho.

pole = [64, 25, 12, 22, 11, 3, 4, 53, 42]
print("Pred serazenim: " + str(pole))

Následující cyklus provede iteraci za každý prvek v poli.

for i in range(len(pole)):

V proměnné idx_nejmensiho bude index prvku s nejmenší hodnotou z neseřazené části.

idx_nejmensiho = i

V této části porovnám všechny prvky v neseřazené části (od indexu i až do konce seznamu včetně) a naleznu nejmenší prvek.

for j in range(i + 1, len(pole)):
    if pole[j] < pole[idx_nejmensiho]:
        idx_nejmensiho = j

Po nalezení nejmenšího prvku si vytvoříme dočasnou proměnnou tmp a pomocí ní prohodíme hodnoty na prvním místě neseřazené části (místo v seznamu s indexem i) a na místě s nejmenším prvkem (v seznamu s indexem idx_nejmensiho).

tmp = pole[i]
pole[i] = pole[idx_nejmensiho]
pole[idx_nejmensiho] = tmp

Nakonec vypíšeme seřazený seznam.

print("Po serazeni: " + str(pole))

Třetí krok jsme nevynechali. Začátek neseřazené části je na indexu i a proměnná i se po každé iteraci inkrementuje o 1 (tím se vždy zařadí první pozice v neseřazené části do seřazené části).

Kompletní kód

# proposed by LaSer
 
numbers = [5, 6, -11, 7, 3, 0, -5]
 
print("pred:", numbers)
 
first_index_of_unordered_part = 0
while first_index_of_unordered_part < len(numbers) - 1:
    for index in range(first_index_of_unordered_part, len(numbers)):
        if numbers[first_index_of_unordered_part] > numbers[index]:
            numbers[first_index_of_unordered_part], numbers[index] = numbers[index], numbers[first_index_of_unordered_part]
    first_index_of_unordered_part += 1
 
print("po:", numbers)

# Mirek M
 
# --- varianta 1 ---
 
pole = [64, 25, 12, 22, 11, 3, 4, 53, 42]
print("Pred serazenim: " + str(pole))
 
# SELECTION SORT
# Postupne navysuj index
for i in range(len(pole)):
    # Neserazena cast je vzdy od i do konce, v ramci ni vyber nejmensi prvek
    idx_nejmensiho = i
    for j in range(i + 1, len(pole)):
        if pole[j] < pole[idx_nejmensiho]:
            idx_nejmensiho = j
 
    # Vymen nejmensi prvek za prvni prvek v neserazene casti
    tmp = pole[i]
    pole[i] = pole[idx_nejmensiho]
    pole[idx_nejmensiho] = tmp
 
print("Po serazeni: " + str(pole))
 
 
# --- varianta 2 ---
 
def selection_sort(pole):
    # Postupne navysuj index
    for i in range(len(pole)):
        # Neserazena cast je vzdy od i do konce, v ramci ni vyber nejmensi prvek
        idx_nejmensiho = i
        for j in range(i + 1, len(pole)):
            if pole[j] < pole[idx_nejmensiho]:
                idx_nejmensiho = j
 
        # Vymen nejmensi prvek za prvni prvek v neserazene casti
        tmp = pole[i]
        pole[i] = pole[idx_nejmensiho]
        pole[idx_nejmensiho] = tmp
 
 
pole = [64, 25, 12, 22, 11, 3, 4, 53, 42]
print("Pred serazenim: " + str(pole))
selection_sort(pole)
print("Po serazeni: " + str(pole))

Den 4 - Funkce - Úkol 1

### proposed by mareddan ###
 
def compute_BMI(weight, height):
	BMI = weight / (height ** 2)
	return BMI
 
def print_text_output_BMI(BMI):
	if BMI < 18:
		print("Podvyziveny")
	elif BMI > 30:
		print("Trpi nadvahou")
	else:
		print("V poradku")
 
result = compute_BMI(80, 2)
print(result)
print_text_output_BMI(result)

Den 4 - Funkce - Úkol 2

# Simon
def read_input():
    pole=[]
    a=float(input("Zadej cenu produktu: "))
    while a!=0:
        castka.append(a)
        a=float(input("Zadej cenu produktu: "))
    return(pole)
 
def get_sum(pole):
    soucet=0
    for i in range(0, len(pole)):
        soucet=soucet+pole[i]
    return soucet
 
def get_max(pole):
    pole.sort()
    return pole[len(pole)-1]
 
def get_min(pole):
    pole.sort()
    return pole[0]
 
def get_avg(pole):
    soucet=0
    for i in range(0, len(pole)):
        soucet=soucet+pole[i]
    return soucet/len(pole)
 
def array_contains(pole, cislo):
    for i in range(0, len(pole)):
        if pole[i]-cislo==0:
            final=pole[i]
            return True
            break
        if i==len(pole)-1:
            return False       
            break
 
def do_payment(pole):
    print("Utrata dela "+str(get_sum(pole))+"Kc.")
    print("Nejlevnejsi polozka je za "+str(get_min(pole))+"Kc.")
    print("Nejdrazsi polozka je za "+str(get_max(pole))+"Kc.")
    print("Prumerna cena polozky je "+str(get_avg(pole))+"Kc.")

Den 4 - Funkce - Úkol 3

### proposed by mareddan ###
 
def switch_positions_array(array, first, second):
	# Osetreni aby index nevyskocil z pole a nenastala vyjimka
	if first < 0 or second < 0 or first >= len(array) or second >= len(array):
		print("neplatny index")
		return
	tmp = array[first]
	array[first] = array[second]
	array[second] = tmp
 
numbers = [5, 7, 6, 8]
switch_positions_array(numbers, 1, 2)
print(numbers)

Den 4 - Funkce - Úkol 4

# Mirek M
 
def nejmensi(pole):
    zatim_nejmensi = pole[0]
    index_nejmensiho = 0
    for i in range(1, len(pole)):
        if (pole[i] < zatim_nejmensi):
            zatim_nejmensi = pole[i]
            index_nejmensiho = i
    return index_nejmensiho

Den 4 - Funkce - Úkol 5

# Mirek M
 
from ukol4_reseni import nejmensi
 
# Napr opet za pomoci selection sort
def serad(pole):
	# Navysuj i
	for i in range(len(pole)): 
		# V ramci i-teho az posledniho prvku vyber nejmensi
		idx_nejmensiho = i + nejmensi(pole[i:]) # predej funkci zbyvajici cast pole
 
		# Vymen nejmensi prvek za prvni prvek v neserazene casti    
		tmp = pole[i]
		pole[i] = pole[idx_nejmensiho]
		pole[idx_nejmensiho] = tmp
 
pole = [64, 25, 12, 22, 11, 3, 4, 53, 42] 
print("Pred serazenim: " + str(pole))
serad(pole)
print("Po serazeni: " + str(pole))

Den 4 - Volitelný úkol 1

### Proposed by mareddan ###
 
from random import randint
 
def generate_random_array(length):
	return add_to_array_recursion([], length)
 
def add_to_array_recursion(my_list, length):
	if length <= 0:
		return my_list
	my_list.append(randint(1, 100))
	return add_to_array_recursion(my_list, length - 1)
 
 
if __name__ == "__main__":
	my_length = 10
	generated_array = generate_random_array(my_length)
	print("Nahodne generovane pole o", my_length, "prvcich:", generated_array)

Den 4 - Volitelný úkol 2

### Proposed by mareddan ###
 
def factorial(x):
	if x <= 1:
		return 1
	return x * factorial(x-1)
 
 
if __name__ == "__main__":
	number = 5
	result = factorial(number)
	print("Faktorial cisla", number, "je:", result)

Den 4 - Volitelný úkol 3

# Jirka 
def fibonacci(x):
	if x <= 0:
		return 0
	elif x <= 2:
		return 1
	return fibonacci(x - 1) + fibonacci(x - 2)
 
 
number = int(input("Zadej poradi ve fibonacciho posloupnosti"))
result = fibonacci(number)
print("Vysledek je ", result)

Den 4 - Volitelný úkol 4

Matice rekurzivně

— Martin Křížek 2021/09/01 13:53

V této úloze vytvoříme v podstatě dvě velmi podobné funkce. Jedna bude vytvářet pole číselných hodnot a druhá vytvoří pole polí pomocí rekurze.

Jako první ale vytvoříme funkci generate_matrix(size), která se shoduje s požadovaným tvarem ze zadání (jméno_funkce(matice)). Její vstup size určí velikost matice. Tato funkce pouze zavolá funkci create_matrix().

def generate_matrix(size):
	return create_matrix(size, max_number, [])

Nyní vytvoříme funkci create_matrix(), která má vygenerovat matici (2D pole/pole polí) požadované velikosti a vyplnit ji čísly sestupně až k nule. Argument size určí velikost matice (5×5, 2×2 atd.), max_number je první a největší číslo v podmatici (maticí se zde myslí pole polí a podmatice jsou ta pole, co jsou v poli :) ) takové, aby nejmenší prvek matice vyšel přesně nula a matrix je pole, ze kterého bude vytvořena požadovaná matice.

def create_matrix(size, max_number, matrix):

Ve funkci určíme base case (podmínka, která určí, kdy se začít vracet z rekurze). Rekurze přestane, pokud by prvky matice měly jít do záporných hodnot (zde vyjádřeno pomocí nejvyššího prvku podmatice).

if max_number <= 0:
        return matrix

Pokud jsme se stále nedostali na nulu, tak vytvoříme novou podmatici sub_array (pole čísel) pomocí funkce create_sub_arrays() (vytvoříme později) a přidáme toto pole do matice matrix pomocí funkce append().

sub_array = create_sub_arrays(size, max_number, [])
matrix.append(sub_array)

Nakonec se rekurzivně zavolá funkce create_matrix(size, max_number - size, matrix) s tím rozdílem, že nejvyšší hodnota pro další podmatici (max_number) se snížila o jednu délku řádku (size) matice oproti poslednímu zavolání, protože jsme pomocí funkce create_sub_arrays() jeden nový řádek vytvořili, a proto jich už zbývá vytvořit o jeden méně.

return create_matrix(size, max_number - size, matrix)

Zde je na příkladu matice 3×3 vidět postupné rekurzivní volání funkcí a následné vracení výsledků “cestou z rekurze” (base case zastaví rekurzi při max_number = -1). Každé zavolání funkce má svůj výstup na stejné úrovni odsazení.

create_matrix(size=3, max_number=8, matrix=[])
 → create_matrix(size=3, max_number=5, matrix=[[8,7,6]])
  → create_matrix(size=3, max_number=2, matrix=[[8,7,6],[5,4,3]])
   → create_matrix(size=3, max_number=-1, matrix=[[8,7,6],[5,4,3],[2,1,0]])
   → [[8,7,6],[5,4,3],[2,1,0]]
  → [[8,7,6],[5,4,3],[2,1,0]]
 → [[8,7,6],[5,4,3],[2,1,0]]
→ [[8,7,6],[5,4,3],[2,1,0]]

Ještě tedy zbývá doplnit funkci create_sub_arrays(size, max_number, array). Její výstup bude pole sestupně seřazených čísel (podmatice - jeden řádek výsledné matice). Vstupy i fungování má obdobné předchozí funkci. Vstup size určuje délku požadovaného pole, max_number určuje první a nejvyšší číslo pole a array je pole, do kterého budou hodnoty ukládány.

def create_sub_arrays(size, max_number, array):

Opět jako první přijde base case. Pokud by délka pole měla být záporná (už máme dostatek hodnot), rekurze se zastaví.

if size <= 0:
	return array

Pokud se ještě nedosáhlo požadované délky pole, tak přidáme další hodnotu funkcí append a opět rekurzivně zavoláme funkci create_sub_arrays(size - 1, max_number - 1, array), kde snížíme délku size (počet ještě zbývajících hodnot) a hodnotu přístího prvku max_number o 1.

Je to obdobné, jako když jsme volali rekurzivně předchozí funkci vždy “o řádek matice kratší”, tak nyní voláme vždy “o číslo kratší”. První funkce vytváří pole polí a druhá pole čísel, způsob je naprosto stejný.

array.append(max_number)
return create_sub_arrays(size - 1, max_number - 1, array)

Zde je opět na příkladu matice 3×3 vidět postupné rekurzivní volání funkcí a následné vracení výsledků “cestou z rekurze”, když se berou v úvahu obě funkce (spíše pro zajímavost/co se za tím abstraktním popisem představit). Každé zavolání funkce má svůj výstup na stejné úrovni odsazení.

create_matrix(size=3, max_number=8, matrix=[])
 → create_sub_arrays(size=3, max_number=8, [])
  → create_sub_arrays(size=2, max_number=7, [8])
   → create_sub_arrays(size=1, max_number=6, [8,7])
    → create_sub_arrays(size=0, max_number=5, [8,7,6])
    → [8,7,6]
   → [8,7,6]
  → [8,7,6]
 → [8,7,6]
 → create_matrix(size=3, max_number=5, matrix=[[8,7,6]])
  → create_sub_arrays(size=3, max_number=5, [])
   → create_sub_arrays(size=2, max_number=4, [5])
    → create_sub_arrays(size=1, max_number=3, [5,4])
     → create_sub_arrays(size=0, max_number=2, [5,4,3])
     → [5,4,3]
    → [5,4,3]
   → [5,4,3]
  → [5,4,3]
  → create_matrix(size=3, max_number=2, matrix=[[8,7,6],[5,4,3]])
   → create_sub_arrays(size=3, max_number=2, [])
    → create_sub_arrays(size=2, max_number=1, [2])
     → create_sub_arrays(size=1, max_number=0, [2,1])
      → create_sub_arrays(size=0, max_number=-1, [2,1,0])
      → [2,1,0]
     → [2,1,0]
    → [2,1,0]
   → [2,1,0]
   → create_matrix(size=3, max_number=-1, matrix=[[8,7,6],[5,4,3],[2,1,0]])
   → [[8,7,6],[5,4,3],[2,1,0]]
  → [[8,7,6],[5,4,3],[2,1,0]]
 → [[8,7,6],[5,4,3],[2,1,0]]
→ [[8,7,6],[5,4,3],[2,1,0]]

Nakonec se kód vykoná následujícím způsobem, kde size určí velikost matice, max_number je nejvyšší číslo ze všech prvků v matici (je o 1 menší než počet prvků v matici, protože nejmenší číslo je nula) a result je výsledná matice.

OFFTOPIC.

if __name__ == "__main__":

v tomto případě není nutné. Pokud bychom ale vytvořené funkce z tohoto souboru chtěli použít jinde a tento soubor bychom pomocí import přidali jako modul, pak vše pod tímto výrazem nebude vykonáno a budou vykonány pouze definice funkcí (jinak by se při importu vykonal i tento zbytek kódu a vygenerovala a vypsala by se matice).

if __name__ == "__main__":
	size = 5
	max_number = size * size - 1
	result = generate_matrix(size)
	print(str(size) + "x" + str(size) + " matrix is:", result)

Kompletní kód

### Proposed by mareddan ###
 
def generate_matrix(size):
	return create_matrix(size, max_number, [])
 
def create_matrix(size, max_number, matrix):
	if max_number <= 0:
		return matrix
	sub_array = create_sub_arrays(size, max_number, [])
	matrix.append(sub_array)
	return create_matrix(size, max_number - size, matrix)
 
def create_sub_arrays(size, max_number, array):
	if size <= 0:
		return array
	array.append(max_number)
	return create_sub_arrays(size - 1, max_number - 1, array)
 
 
if __name__ == "__main__":
	size = 5
	max_number = size * size - 1
	result = generate_matrix(size)
	print(str(size) + "x" + str(size) + " matrix is:", result)

Den 4 - Volitelný úkol 5

Šachovnice

— Martin Křížek 2021/09/05 13:15

Naše šachovnice má 9×9 políček oproti normálním 8×8. (aby existoval střed)

2D pole (pole polí) chessboard bude reprezentovat naši šachovnici. Každá nula (nebo jednička) reprezentuje jedno políčko.

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]
]

Definujeme si všechny možné pohyby jezdcem. Pohyby jsou uloženy ve 2D poli knightMovesList jako dvojice čísel. První číslo určuje posun v řádcích a druhé číslo posun ve sloupcích. Jak je vyznačeno na obrázku, záporné posuny přibližují jezdce směrem “nahoru vlevo” k bodu [0, 0] a kladné posuny k bodu [8, 8]. Indexujeme od nuly.

U kódu jsou navíc vyznačeny příslušné posuny.

knightMovesList = [
    [-1, -2],     ↑ ← ←
    [-2, -1],     ↑ ↑ ←
    [-1, 2],      ↑ → →
    [-2, 1],      ↑ ↑ →
    [1, -2],      ↓ ← ←
    [2, -1],      ↓ ↓ ←
    [1, 2],       ↓ → →
    [2, 1]        ↓ ↓ →
]

Jako další vytvoříme funkci knight_move(). Tato funkce vloží do našeho 2D pole chessboard hodnotu 1 na každé místo, které je dosažitelné jezdcem do požadovaného počtu tahů. Vstupy row a column udávají startovní souřadnice jezdce (pro nás (4,4)) a move_count je počet povolených tahů (pro nás 3).

def knight_move(row, column, move_count):

Funkce označí vždy hodnotou 1 aktuální pozici.

chessboard[row][column] = 1

Pokud zbývá alespoň jeden povolený tah (move_count), tak vypočítáme všechny dosažitelné pozice (k aktuálním souřadnicím (row, column) se přičte posun z knightMovesList). Souřadnice nové pozice jsou uloženy v to_row a to_column.

Je zde použit for cyklus v mírně modifikovaném tvaru.

for by_row, by_column in knightMovesList:

Při každé iteraci se vezme nové pole (které má dva prvky…posun v řádcích a posun ve sloupcích) z knightMovesList a první prvek nového pole se uloží do by_row a druhý do by_column.

if move_count > 0:
    for by_row, by_column in knightMovesList:
        to_row = row + by_row
        to_column = column + by_column

Nakonec se zkontroluje, zda se nová pozice nachází stále na naší šachovnici (souřadnice řádků i sloupců mohou být pouze v intervalu <0,8>). Pokud je nová pozice stále na šachovnici, zavolá se znovu funkce knight_move(), ale tentokrát bude jako startovní pozice zadána nově vypočtená pozice a počet zbývajících tahů move_count bude snížen o jedna (protože jsme zrovna jeden tah použili na vypočtení/dosažení nové pozice).

if 0 <= to_row <= 8 and 0 <= to_column <= 8:
    knight_move(to_row, to_column, move_count - 1)

Sice zde není explicitně uveden return, pokud je dosažen base case. Nicméně rekurze skončí, pokud není splněna podmínka move_count > 0 (funkce proběhne, ale bez dalšího rekurzivního volání). Požadavek na base case je tedy splněn.

Následující funkce print_chessboard() nemá žádné vstupní parametry. Tato funkce vypíše šachovnici v požadovaném formátu. Výpíše každou řadu na jeden řádek s pomocí argumentu end=“ ”, který po vytištění znaku přidá pouze mezeru a print(“”) přidá na konci řádku odskočení na nový řádek.

def print_chessboard():
    for row in chessboard:
        for square in row:
            print(square, end=" ")
        print("")

Nakonec vyplníme šachovnici zavoláním funkce knight_move(4, 4, moves - 1) (-1, protože tah na (4,4) už se taky počítá) a vypíšeme pomocí funkce print_chessboard().

moves = 3
knight_move(4, 4, moves - 1)
print_chessboard()

Kompletní kód

# 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
#
# 8
# .
# .
# .
# 2
# 1
# 0
#  0 1 2 ... 8
 
# 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()

Table of Contents

Řešení úkolů

Den 1

Den 1 dop. - Úkol 1

Den 1 dop. - Úkol 2

Den 1 dop. - Úkol 3

Den 1 dop. - Úkol 4

Den 1 dop. - Úkol 5

Den 1 dop. - Úkol 6

Aritmetické prohazování bez použití pomocné proměnné

Python magie

Den 1 odp. - Úkol 1

Den 1 odp. - Úkol 2

Den 1 odp. - Úkol 3

Den 1 odp. - Úkol 4

Den 1 odp. - Úkol 5

Den 1 odp. - Úkol 6

Den 1 odp. - Úkol 7

Den 1 - Volitelný úkol 1

Den 1 - Volitelný úkol 2

Den 1 - Volitelný úkol 3

Den 1 - Volitelný úkol 4

Den 1 - Volitelný úkol 5

Den 2 - Opakování - Úkol 1

Den 2 - Rozcvička

Den 2 - Úkol 1

Den 2 - Úkol 2

Den 2 - Úkol 3

Den 2 - Úkol 4

Den 2 - Úkol 5

Den 2 - Vnořené cykly - Úkol 1

Den 2 - Vnořené cykly - Úkol 2

Den 2 - Vnořené cykly - Úkol 3

Vykreslení domku

Kompletní kód

Den 2 - Volitelný úkol 1

Den 2 - Volitelný úkol 2

Den 2 - Volitelný úkol 3

Den 2 - Volitelný úkol 4

Den 2 - Volitelný úkol 5

Den 3 - Úkol 1

Den 3 - Úkol 2

Den 3 - Vnořené cykly - Úkol 1

Den 3 - Vnořené cykly - Úkol 2

Den 3 - Vnořené cykly - Úkol 3

Den 3 - While cyklus - Úkol 1

Den 3 - While cyklus - Úkol 2

Den 3 - While cyklus - Úkol 3

Den 3 - While cyklus - Úkol 4

Den 3 - While cyklus - Úkol 5

Den 3 - While cyklus - Úkol 6

Den 3 - Seznamy - Úkol 1

Den 3 - Seznamy - Úkol 2

Den 3 - Seznamy - Úkol 3

Den 3 - Seznamy - Úkol 4

Den 3 - Seznamy - Úkol 5

Den 4 - Úkol 1

Monte Carlo π

Implementace

Kompletní kód

Den 4 - Úkol 2a

Kalendář

Příprava

Výpis do terminálu

Velikost posunu

Identifikace přestupného roku

Získání vstupu a volání funkcí

Kompletní kód

Den 4 - Úkol 2b

Pascalův trojúhelník

Výpočet

Formátování výpisu

Kompletní kód

Den 4 - Úkol 3

Den 4 - Úkol 4

Den 4 - Úkol 5

Selection sort

Kompletní kód

Den 4 - Funkce - Úkol 1

Den 4 - Funkce - Úkol 2