====== Ř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í:
{{:courses:pri-bootcamp:mm_day1_dop_ukloha_1.py|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í:
{{:courses:pri-bootcamp:mm_day1_dop_ukloha_2.py|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í:
{{:courses:pri-bootcamp:mm_day1_dop_ukloha_3.py|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í:
{{:courses:pri-bootcamp:mm_day1_dop_ukloha_4.py|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í:
{{:courses:pri-bootcamp:mm_day1_dop_ukloha_5.py|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í:
{{:courses:pri-bootcamp:mm_day1_dop_ukloha_6.py|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í:
{{:courses:pri-bootcamp:mm_day1_odp_uloha_4.py|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í:
{{:courses:pri-bootcamp:mm_day1_odp_uloha_5.py|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 [[https://cs.wikipedia.org/wiki/Kosinová_věta|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 ==
--- //[[krizema3@fel.cvut.cz|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="")
{{ :courses:pri-bootcamp:colhouse.png?nolink&200 |}}
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)
/*
#Lucka
cislo=int(input("Zadej cislo v desitkove soustave: "))
retezec=""
while cislo>0:
if cislo%2==0:
retezec=retezec+"0"
else:
retezec=retezec+"1"
cislo=cislo//2
retezec2=""
for i in range(len(retezec)):
retezec2=retezec2+retezec[len(retezec)-1-i]
print(retezec2)
#Vojta, amended by poliape2
deka = int(input("Zadej cislo v desitkove soustave: "))
zbytek = deka
exp = 0
cislo = 0
while (zbytek > 0):
cislo += (zbytek % 2) * 10 ** exp
exp += 1
zbytek = zbytek // 2
print(cislo)
*/
----
=== 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 π ==
--- //[[krizema3@fel.cvut.cz|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.
{{ :courses:pri-bootcamp:montecarlopi.jpg?200 |}}
== 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ář ==
--- //[[krizema3@fel.cvut.cz|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 ==
{{ :courses:pri-bootcamp:4_2_a_color.png?nolink&200 |}}
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 ==
--- //[[krizema3@fel.cvut.cz|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.
{{ :courses:pri-bootcamp:pascal_comb.png?nolink&400 |}}
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("")
{{ :courses:pri-bootcamp:pascal_color.png?nolink&200 |}}
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 ==
--- //[[krizema3@fel.cvut.cz|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
{{ :courses:pri-bootcamp:selsor.jpg?nolink&200 |}}
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ě ==
--- //[[krizema3@fel.cvut.cz|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 (5x5, 2x2 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 3x3 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 3x3 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 ==
--- //[[krizema3@fel.cvut.cz|Martin Křížek]] 2021/09/05 13:15//
Naše šachovnice má 9x9 políček oproti normálním 8x8. (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.
{{ :courses:pri-bootcamp:row_col.png?nolink&300 |}}
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()
----