====== Řešení úkolů ======

===== Den 1 =====

==== Den 1 dop. - Úkol 1 ====

<code python>
# Jana

a = float(input("Zadejte stranu ctverce: "))

obvod = 4*a
obsah = a*a

print("Obvod je: " + str(obvod))
print("Obsah je: " + str(obsah))
</code>

Volné autorské řešení:
{{:courses:pri-bootcamp:mm_day1_dop_ukloha_1.py|Miroslav Müller }}

----

==== Den 1 dop. - Úkol 2 ====

<code python>
# 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))
</code>

Volné autorské řešení:

{{:courses:pri-bootcamp:mm_day1_dop_ukloha_2.py|Miroslav Müller}}

----

==== Den 1 dop. - Úkol 3 ====

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

</code>

Volné autorské řešení:

{{:courses:pri-bootcamp:mm_day1_dop_ukloha_3.py|Miroslav Müller}}

----

==== Den 1 dop. - Úkol 4 ====

<code python>
# 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))
</code>

Volné autorské řešení:

{{:courses:pri-bootcamp:mm_day1_dop_ukloha_4.py|Miroslav Müller}}

----

==== Den 1 dop. - Úkol 5 ====

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

</code>

Volné autorské řešení:

{{:courses:pri-bootcamp:mm_day1_dop_ukloha_5.py|Miroslav Müller}}

----

==== Den 1 dop. - Úkol 6 ====

<code python>
# 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)
</code>

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

<code python>
# 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)
</code>

==== Python magie ====

<code python>
# 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)
</code>


Volné autorské řešení:

{{:courses:pri-bootcamp:mm_day1_dop_ukloha_6.py|Miroslav Müller}}

----

==== Den 1 odp. - Úkol 1 ====

<code python>
# 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)
</code>

----

=== Den 1 odp. - Úkol 2 ===

<code python>
# 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)
</code>

----

=== Den 1 odp. - Úkol 3 ===

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

</code>

----

=== Den 1 odp. - Úkol 4 ===

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

Volné autorské řešení:

{{:courses:pri-bootcamp:mm_day1_odp_uloha_4.py|Miroslav Müller}}

----

=== Den 1 odp. - Úkol 5 ===

<code python>
# 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.")
</code>

Volné autorské řešení:

{{:courses:pri-bootcamp:mm_day1_odp_uloha_5.py|Miroslav Müller}}

----

=== Den 1 odp. - Úkol 6 ===

<code python>
# 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")
</code>

----

=== Den 1 odp. - Úkol 7 ===

<code python>
# 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")
</code>

----

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

<code python>
# 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")            
</code>

----

=== Den 1 - Volitelný úkol 2 ===

<code python>
# 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)
    
</code>

----

=== Den 1 - Volitelný úkol 3 ===

<code python>
# 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)))
</code>

----

=== Den 1 - Volitelný úkol 4 ===

<code python>
# 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.")
</code>

----

=== Den 1 - Volitelný úkol 5 ===

<code python>
# 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.") 
</code>

----

=== Den 2 - Opakování - Úkol 1 ===

<code python>
# 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)
</code>

----

=== Den 2 - Rozcvička ===

<code python>
# 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))
</code>

----

=== Den 2 - Úkol 1 ===

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

----

=== Den 2 - Úkol 2 ===

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

----

=== Den 2 - Úkol 3 ===

<code python>
# 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)
</code>

----

=== Den 2 - Úkol 4 ===

<code python>
# 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.")
</code>

----

=== Den 2 - Úkol 5 ===

<code python>
# 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)    
</code>

----

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

<code python>
# 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()
</code>

----

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

<code python>
# 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()
</code>

----

=== 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).
<code python>
vyska = int(input("Zadej vysku domu: "))
if (vyska < 5) or (vyska%2==0):
    print("Vyska musi byt liche cislo vetsi nez 5")
</code>
Když známe výšku (a tedy i šířku) začneme vypisovat střechu. Nejdříve vykreslíme <fc #ff0000>špičku střechy</fc> přesně v polovině šířky domu.
<code python>
else:
    print((vyska//2)*" " + "#")
</code>
Pro každé další "patro" střechy
<code python>
for a in range (0, int((vyska//2)-1)):
</code>
vypíšeme dostatečné <fc #00ff00>odsazení od začátku</fc> řádku.
<code python>
print(((vyska//2)-1-a)*" ", end="")
</code>
Poté vykreslíme <fc #0000ff>část střechy</fc>.
<code python>
print("#", end="")
</code>

{{ :courses:pri-bootcamp:colhouse.png?nolink&200 |}}
<note>Výstup v terminálu nebude barevný :)</note>

Vytvoříme <fc #fc6a03>mezeru uprostřed</fc> (štít střechy).
<code python>
print((2*a+1)*" ", end="")
</code>
Nakonec vykreslíme <fc #0000ff>část střechy</fc> na konci řádku a přeskočíme na další řádek.
<code python>
print("#")
</code>
Přesuneme se k "tělu" domku. Vykreslíme <fc #ff00ff>horní řadu</fc>.
<code python>
print("#"*vyska)
</code>
Vykreslíme <fc #652a0e>stěny po řádcích stylem "znak + mezery + znak"</fc>. Vykreslíme o dva řádky méně než je výška (všechny kromě horního a dolního, ty se vykreslují samostatně).
<code python>
for c in range (vyska-2):
    print("#" + " "*(vyska-2) + "#")
</code>
Jako poslední vykreslíme <fc #ffff00>dolní řadu</fc>.
<code python>
print("#"*vyska)
</code>







== Kompletní kód ==

<code python>
# 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)
</code>

----

=== Den 2 - Volitelný úkol 1 ===

<code python>
# 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)
</code>

----

=== Den 2 - Volitelný úkol 2 ===

<code python>
# 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)
</code>

----

=== Den 2 - Volitelný úkol 3 ===

<code python>
# 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)
</code>

----

=== Den 2 - Volitelný úkol 4 ===

<code python>
# 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))
</code>

----

=== Den 2 - Volitelný úkol 5 ===

<code python>
# 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))
</code>

----

=== Den 3 - Úkol 1 ===

<code python>
# Vasek
a = int(input("Zadejte diferenci: "))
b = int(input("Zadejte prvni clen: "))

for i in range(b,a*20,a):
    print(i)
</code>

----

=== Den 3 - Úkol 2 ===

<code python>
# 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)
</code>

----

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

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

----

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

<code python>
#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))
</code>

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

----

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

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

----

=== Den 3 - While cyklus - Úkol 1 ===

<code python>
# 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)+".")
</code>

----

=== Den 3 - While cyklus - Úkol 2 ===

<code python>
# 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)+".")
</code>

----

=== Den 3 - While cyklus - Úkol 3 ===

<code python>
# @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)
</code>

/*
<code python>
#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)
</code>

<code python>
#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)
</code>
*/

----

=== Den 3 - While cyklus - Úkol 4 ===

<code python>
#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")
</code>

----

=== Den 3 - While cyklus - Úkol 5 ===

<code python>
# 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))    
</code>

----

=== Den 3 - While cyklus - Úkol 6 ===

<code python>
# 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
</code>

----

=== Den 3 - Seznamy - Úkol 1 ===

<code python>
# Jan Tosner

seznam = []
for i in range(0,10):
	x = int(float(input("Zadejte číslo: ")))
	seznam.insert(0,x)
print(seznam)
</code>

----

=== Den 3 - Seznamy - Úkol 2 ===

<code python>
# 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)
</code>

----

=== Den 3 - Seznamy - Úkol 3 ===

<code python>
# 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])
</code>

----

=== Den 3 - Seznamy - Úkol 4 ===

<code python>
# 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)
</code>

----

=== Den 3 - Seznamy - Úkol 5 ===

<code python>
# 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)
</code>

----

=== 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()//.
<code python>
import math, random
</code>
Získáme počet požadovaných přesných desetinných míst.
<code python>
digits = int(input('Zadej presnost vypoctu (pocet desetinnych mist)'))
</code>
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ů.
<code python>
total_count = 0
in_circle_count = 0
my_pi = 0
approximations = []
</code>
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)
<code python>
while abs(my_pi−math.pi) > 10**−digits:
</code>
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.
<code python>
x = random.random()
y = random.random()
total_count += 1
</code> 
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//.
<code python>
if math.sqrt(x * x + y * y) <= 1:
    in_circle_count += 1
</code>
Vypočteme a vypíšeme aproximaci π podle čtvrtého kroku algoritmu.
<code python>
my_pi = 4 * in_circle_count / total_count
print(my_pi)
</code>
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.
<code python>
if len(approximations) <= 100:
    approximations.append(my_pi)
</code>
Po splnění podmínky //while// cyklu výslednou aproximaci vypíšeme a také všechny mezivýsledky uložené v seznamu //approximations//.
<code python>
print("konecny vysledek", my_pi)
 
print("prvnich sto aproximaci")
for value in approximations:
    print(value)
</code>

== Kompletní kód ==


<code python>
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)
</code>

<code python>
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)
</code>

----

=== 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.
<code python>
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)
</code>

== Výpis do terminálu ==

{{ :courses:pri-bootcamp:4_2_a_color.png?nolink&200 |}}
<note>Výstup v terminálu nebude barevný :)</note>

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.).
<code python>
def printCalendary(year, month, beginDay):
</code>
Vypsání <fc #FF0000>hlavičky</fc> 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.).
<code python>
print(months[month−1],year)
</code>
Vypsání <fc #CD853F>jmen dní</fc> pomocí seznamu vytvořeného v přípravě.
<code python>
for i in range(0,7):
   print(days[i]+" ",end="")
print()
</code>
Vytovření <fc #FFFF00>odsazení</fc> před prvním dnem v měsíci.
<code python>
for i in range(0,beginDay):
   print("   ",end="")
</code>
Vypsání <fc #00FF00>jednotlivých čísel dnů</fc> a <fc #0000FF>nových řádků</fc> 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).
<code python>
for i in range(1,monthsLen[month-1]+1):
   print("%2d " % (i), end="")
 
   # zalomeni u nedele		
   if ((i+beginDay)%7 == 0):
      print()
</code>
Vypsání extra dne v přestupném roce na konci února.
<code python>
if (month == 2 and isleapyear(year) == 1):
   print("29 ", end="")
</code>

== Velikost posunu ==

Vstupem je požadovaný rok a měsíc.
<code python>
def countBeginning(year, month):
</code>
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 +/-).
<code python>
dr = year−2018
dd = dr*365
</code>
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á.
<code python>
for i in range(0,month-1):
   dd += monthsLen[i]
</code>
Následně posuneme ve správném směru podle počtu přestupných roků. (ještě se nebere v úvahu zadaný rok)
<code python>
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) 
</code>
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.
<code python>
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
</code>
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.
<code python>
dd %= 7
 
return dd
</code>

== 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ý).
<code python>
def isleapyear(year):
</code>
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.
<code python>
if (year % 4 == 0 and ((year % 100 != 0) or (year % 400 == 0))):
   return 1
</code>
Jinak je vrácena 0.
<code python>
else:
   return 0
</code>

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

Uživatelský vstup načteme do proměnných z terminálu pomocí //input()//.
<code python>
year = int(input("Zadejte rok: "))
month = int(input("Zadejte mesic: "))
</code>
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.
<code python>
diff = countBeginning(year,month)
</code>
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.
<code python>
printCalendary(year,month,diff)
</code>

== Kompletní kód ==


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

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

</code>

----

=== 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.
<code python>
n = int(input('Zadejte vysku Pascalova trojuhelniku: '))
</code>
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ě).
<code python>
rows = []
for line in range(1, n + 1):
</code>
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.
<code python>
num = 1
row = []
</code>
Tímto cyklem iterujeme přes pozice v řádku. Aktuální hodnotu přidáme pomocí funkce //append()// na konec seznamu //row//.
<code python>
for i in range(1, line + 1):
    row.append(num)
</code>
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//.

<note important>
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)//**.
</note>

Nyní stačí ve vzorci nahradit //n, k// pomocí //line, i// a kombinační čísla nahradit proměnnou //num//.
<code python>
num = int(num * (line - i) / i)
</code>
Nakonec se seznam hodnot daného řádku trojúhelníku připojí na konec seznamu //rows// pomocí //append()//.
<code python>
rows.append(row)
</code>

== 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()//.

<note>
**//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).
</note>
<note>
**//join()//** - vloží znak mezi každé sousední prvky iterovatelného objektu. Funkce //join()// pracuje jen s typem string.
</note>

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.
<code python>
last_row_length = len(' '.join(map(str, rows[-1])))
</code>
<note important>
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)
</note>
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ů).
<code python>
if last_row_length % 2 != 0:
    last_row_length += 1
</code>
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()//.
<code python>
for row in rows:
    row_to_print = ' '.join(map(str, row))
    row_length = len(row_to_print)
</code>
Opět vycentrovat.
<code python>
if row_length % 2 != 0:
    row_length += 1
</code>
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.
<code python>
spaces_to_print = (last_row_length - row_length) // 2
</code>
Vypíši <fc #0000ff>první polovinu</fc> mezer pro vycentrování (s argumentem //end=""// abychom zůstali na stejném řádku).
<code python>
for i in range(spaces_to_print):
    print(" ", end="") 
</code>
Poté se vypíší samotné hodnoty.
<code python>
print(row_to_print, end="")
</code>
Vypsání <fc #00ff00>druhé poloviny</fc> mezer není nutné, ale zde je uvedeno.
<code python>
for i in range(spaces_to_print):
    print(" ", end="")
</code>
Nakonec přesun na nový řádek.
<code python>
print("")
</code>

{{ :courses:pri-bootcamp:pascal_color.png?nolink&200 |}}
<note>Výstup v terminálu nebude barevný :)</note>







== Kompletní kód ==

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

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

----

=== Den 4 - Úkol 3 ===

<code python>
# 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))
</code>

Alternativní řešení

<code python>
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)
</code>

----

=== Den 4 - Úkol 4 ===

<code python>
# 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")
</code>

----

=== 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 <fc #ff0000>seřazenou</fc> (od začátku seznamu až po určitý index) a <fc #0000ff>neseřazenou</fc> (zbytek seznamu) část. Selection sort seřadí seznam opakováním tří kroků:
  - Nalezne <fc #00ff00>nejmenší prvek</fc> 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.
<code python>
pole = [64, 25, 12, 22, 11, 3, 4, 53, 42]
print("Pred serazenim: " + str(pole))
</code>
Následující cyklus provede iteraci za každý prvek v poli.
<code python>
for i in range(len(pole)):
</code>
V proměnné //idx_nejmensiho// bude index prvku s nejmenší hodnotou z neseřazené části.
<code python>
idx_nejmensiho = i
</code>
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.
<code python>
for j in range(i + 1, len(pole)):
    if pole[j] < pole[idx_nejmensiho]:
        idx_nejmensiho = j
</code>
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//).
<code python>
tmp = pole[i]
pole[i] = pole[idx_nejmensiho]
pole[idx_nejmensiho] = tmp
</code>
Nakonec vypíšeme seřazený seznam.
<code python>
print("Po serazeni: " + str(pole))
</code>

<note>
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).
</note>



== Kompletní kód ==

<code python>
# 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)
</code>

<code python>
# 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))
</code>

----

=== Den 4 - Funkce - Úkol 1 ===

<code python>
### 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)
</code>

----

=== Den 4 - Funkce - Úkol 2 ===

<code python>
# 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.")
</code>

----

=== Den 4 - Funkce - Úkol 3 ===

<code python>
### 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)
</code>

----

=== Den 4 - Funkce - Úkol 4 ===

<code python>
# 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
</code>

----

=== Den 4 - Funkce - Úkol 5 ===

<code python>
# 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))
</code>

----

=== Den 4 - Volitelný úkol 1 ===

<code python>
### 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)
</code>

----

=== Den 4 - Volitelný úkol 2 ===

<code python>
### 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)
</code>

----

=== Den 4 - Volitelný úkol 3 ===

<code python>
# 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)
</code>

----

=== 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()//.
<code python>
def generate_matrix(size):
	return create_matrix(size, max_number, [])
</code>
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.
<code python>
def create_matrix(size, max_number, matrix):
</code>
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).
<code python>
if max_number <= 0:
        return matrix
</code>
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()//.
<code python>
sub_array = create_sub_arrays(size, max_number, [])
matrix.append(sub_array)
</code>
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ě.
<code python>
return create_matrix(size, max_number - size, matrix)
</code>
<note important>
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í.
<code python>
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]]
</code>
</note>
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.
<code python>
def create_sub_arrays(size, max_number, array):
</code>
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í.
<code python>
if size <= 0:
	return array
</code>
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.
<note>
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ý.
</note>
<code python>
array.append(max_number)
return create_sub_arrays(size - 1, max_number - 1, array)
</code>

<note important>
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í.
<code python>
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]]
</code>
</note>

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.
<note tip>
OFFTOPIC. <code python>if __name__ == "__main__":</code> 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).
</note>
<code python>
if __name__ == "__main__":
	size = 5
	max_number = size * size - 1
	result = generate_matrix(size)
	print(str(size) + "x" + str(size) + " matrix is:", result)
</code>







== Kompletní kód ==

<code python>
### 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)
</code>

----

=== Den 4 - Volitelný úkol 5 ===

== Šachovnice ==

 --- //[[krizema3@fel.cvut.cz|Martin Křížek]] 2021/09/05 13:15//

<note>Naše šachovnice má 9x9 políček oproti normálním 8x8. (aby existoval střed)</note>

2D pole (pole polí) //chessboard// bude reprezentovat naši šachovnici. Každá nula (nebo jednička) reprezentuje jedno políčko.
<code python>
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]
]
</code>
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 |}}
<note>U kódu jsou navíc vyznačeny příslušné posuny.</note>
<code python>
knightMovesList = [
    [-1, -2],     ↑ ← ←
    [-2, -1],     ↑ ↑ ←
    [-1, 2],      ↑ → →
    [-2, 1],      ↑ ↑ →
    [1, -2],      ↓ ← ←
    [2, -1],      ↓ ↓ ←
    [1, 2],       ↓ → →
    [2, 1]        ↓ ↓ →
]
</code>
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).
<code python>
def knight_move(row, column, move_count):
</code>
Funkce označí vždy hodnotou 1 aktuální pozici.
<code python>
chessboard[row][column] = 1
</code>
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//.
<note tip>
Je zde použit for cyklus v mírně modifikovaném tvaru. <code python>for by_row, by_column in knightMovesList:</code> 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//.
</note>
<code python>
if move_count > 0:
    for by_row, by_column in knightMovesList:
        to_row = row + by_row
        to_column = column + by_column
</code>
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).
<code python>
if 0 <= to_row <= 8 and 0 <= to_column <= 8:
    knight_move(to_row, to_column, move_count - 1)
</code>
<note important>
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.
</note>
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.
<code python>
def print_chessboard():
    for row in chessboard:
        for square in row:
            print(square, end=" ")
        print("")
</code>
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()//.
<code python>
moves = 3
knight_move(4, 4, moves - 1)
print_chessboard()
</code>









== Kompletní kód ==

<code python>
# 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()
</code>

----