# 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
# 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í:
# 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í:
# 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í:
# 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í:
# 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)
# 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)
# 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í:
# 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)
# 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)
# 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)
#Luka a = int(input("Zadejte cislo:")) if a%2==0: print("cislo je sude") else: print("cislo je liche")
Volné autorské řešení:
# 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í:
# 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")
# 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")
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")
# 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)
# 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)))
# 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.")
# 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.")
# 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)
# 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))
# Vojta cislo = int(input("Zadej cislo N: ")) if cislo>0: for i in range(1, cislo): print (str(i) + ", ", end='') print (cislo)
# Vojta cislo = int(input("Zadej cislo N: ")) if cislo>0: for i in range(cislo, 1, -1): print (str(i) + ", ", end='') print ("1")
# 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)
# 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.")
# 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)
# 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()
# 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()
— 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="")
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)
# 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)
# 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)
# 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)
# 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)
# 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))
# 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))
# Vasek a = int(input("Zadejte diferenci: ")) b = int(input("Zadejte prvni clen: ")) for i in range(b,a*20,a): print(i)
# 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)
# 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("")
#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(" ")
# 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("")
# 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)+".")
# 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)+".")
# @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)
#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")
# 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))
# 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
# Jan Tosner seznam = [] for i in range(0,10): x = int(float(input("Zadejte číslo: "))) seznam.insert(0,x) print(seznam)
# 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)
# 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])
# 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)
# 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)
— Martin Křížek 2021/08/30 21:49
Tento algoritmus se skládá ze čtyř kroků:
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.
Jako první importujeme moduly math a random kvůli přesné konstantě π a funkci random().
import math, randomZí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 += 1U 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 += 1Vypoč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)
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)
— Martin Křížek 2021/08/31 13:46
Tuto úlohu rozdělíme na menší podproblémy, které postupně vyřešíme:
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)
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="")
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*365Dá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: passNa 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
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 1Jinak je vrácena 0.
else: return 0
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)
Ř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)
— 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.
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.
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)
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().
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])))
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 += 1Pro 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 += 1Chceme 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) // 2Vypíš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("")
# 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("")
# 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)
# 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")
— 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ů:
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 = jPo 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] = tmpNakonec vypíšeme seřazený seznam.
print("Po serazeni: " + str(pole))
# 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))
### 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)
# 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.")
### 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)
# 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
# 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))
### 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)
### 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)
# 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)
— 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 matrixPokud 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)
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 arrayPokud 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.
array.append(max_number) return create_sub_arrays(size - 1, max_number - 1, array)
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.
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)
### 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)
— Martin Křížek 2021/09/05 13:15
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.
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] = 1Pokud 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.
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_columnNakonec 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)
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()
# 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()