Programy a algoritmy pracující s čísly
IB111 Úvod do programování
2016
1 / 56
Dnešní přednáška
práce s čísly v Pythonu
ukázky programů, ilustrace použití základních konstrukcí
ukázky jednoduchých algoritmů, ilustrace rozdílu v
efektivitě
2 / 56
Číselné typy
int – celá čísla
float
čísla s plovoucí desetinnou čárkou
reprezentace: báze, exponent
nepřesnosti, zaokrouhlování
( complex – komplexní čísla )
3 / 56
Nepřesnosti
Přesná matematika:
((1 +
1
x
) − 1) · x = 1
Nepřesné počítače:
>>> x = 2**50
>>> ((1 + 1 / x) - 1) * x
1.0
>>> x = 2**100
>>> ((1 + 1 / x) - 1) * x
0.0
4 / 56
Číselné typy – poznámky
explicitní přetypování: int(x), float(x)
automatické „nafukování typu int:
viz např. 2**100
pomalejší, ale korektní
rozdíl od většiny jiných prog. jazyků (běžné je
„přetečení )
v Python2.7 dělení: rozdíl 3/2 a 3/2.0
v Python3 dělení intuitivní
5 / 56
Pokročilejší operace s čísly
Některé operace v knihovně math:
použití knihovny: import math
zaokrouhlování: round, math.ceil, math.floor
absolutní hodnota: abs
math.exp, math.log, math.sqrt
goniometrické funkce: math.sin, math.cos, . . .
konstanty: math.pi, math.e
6 / 56
Ciferný součet
vstup: číslo x
výstup: ciferný součet čísla x
příklady:
8 → 8
15 → 6
297 → 18
11211 → 6
7 / 56
Ciferný součet: základní princip
opakovaně provádíme:
dělení 10 se zbytkem – hodnota poslední cifry
celočíselné dělení – „okrajování čísla
8 / 56
Ciferný součet – nevhodná pasáž
if n % 10 == 0:
f = 0 + f
elif n % 10 == 1:
f = 1 + f
elif n % 10 == 2:
f = 2 + f
elif n % 10 == 3:
f = 3 + f
elif n % 10 == 4:
f = 4 + f
...
9 / 56
Ciferný součet – řešení
def digit_sum(n):
result = 0
while n > 0:
result += n % 10
n = n // 10
return result
10 / 56
Collatzova posloupnost
vezmi přirozené číslo:
pokud je sudé, vyděl jej dvěma
pokud je liché, vynásob jej třemi a přičti jedničku
tento postup opakuj, dokud nedostaneš číslo jedna
11 / 56
Collatzova posloupnost: xkcd
htts://xkcd.com/710/
12 / 56
Collatzova posloupnost: výpis
def collatz_sequence(n):
while n != 1:
print(n, end=", ")
if n % 2 == 0:
n = n // 2
else:
n = 3*n + 1
print(1)
13 / 56
Collatzova posloupnost: příklady graficky
14 / 56
Bonus: Vykreslení grafu v Pythonu
Využívá seznamy a knihovnu pylab
import pylab
def collatz(n):
sequence = []
while n != 1:
sequence.append(n)
if n % 2 == 0:
n = n // 2
else:
n = 3*n + 1
sequence.append(1)
return sequence
pylab.plot(collatz(27))
pylab.show()
15 / 56
Collatzova posloupnost: délka posloupnosti
def collatz_length(n):
length = 1
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3*n + 1
length += 1
return length
def collatz_table(count):
for i in range(1, count+1):
print(i, collatz_length(i))
16 / 56
Collatzova posloupnost: délka posloupnosti I
17 / 56
Collatzova posloupnost: délka posloupnosti II
18 / 56
Collatzova hypotéza
Hypotéza: Pro každé počáteční číslo n, posloupnost
narazí na číslo 1.
experimentálně ověřeno pro velká n (∼ 1018
)
důkaz není znám
19 / 56
Logistická diferenční rovnice
xn+1 = 4 · xn · (1 − xn)
jednoduchý úkol: výpis členů posloupnosti
chaotické chování – citlivost k počátečním podmínkám
(viz ukázka)
zajímavé souvislosti: modelování populací, chaos, fraktály
20 / 56
Zdroj: Wikipedia
21 / 56
Největší společný dělitel
vstup: přirozená čísla a, b
výstup: největší společný dělitel a, b
příklad: 180, 504
Jak na to?
22 / 56
Naivní algoritmus I
projít všechny čísla od 1 do min(a, b)
pro každé vyzkoušet, zda dělí a i b
vzít největší
23 / 56
Naivní algoritmus II
„školní algoritmus
najít všechny dělitele čísel a, b
projít dělitele, vybrat společné, vynásobit
příklad:
180 = 22 · 32 · 5
504 = 23 · 32 · 7
NSD = 22 · 32 = 36
24 / 56
Euklidův algoritmus: základ
základní myšlenka: pokud a > b, pak:
NSD(a, b) = NSD(a − b, b)
příklad:
krok a b
1 504 180
2 324 180
3 180 144
4 144 36
5 108 36
6 72 36
7 36 36
8 36 0
25 / 56
Euklidův algoritmus: vylepšení
vylepšená základní myšlenka: pokud a > b, pak:
NSD(a, b) = NSD(a mod b, b)
krok a b
1 504 180
2 180 144
3 144 36
4 36 0
26 / 56
Euklidův algoritmus: program
varianta s odčítáním, bez rekurze
def nsd(a,b):
if a == 0:
return b
while b != 0:
if a > b:
a = a - b
else:
b = b - a
return a
27 / 56
Euklidův algoritmus: program
modulo varianta, rekurzivně
def nsd(a,b):
if b == 0:
return a
else:
return nsd(b, a % b)
28 / 56
Euklidův algoritmus – vizualizace
http://en.wikipedia.org/wiki/Euclidean_algorithm
29 / 56
Efektivita algoritmů
proč byly první dva algoritmy označeny jako „naivní ?
časová náročnost algoritmu:
naivní: exponenciální vůči počtu cifer
Euklidův: lineární vůči počtu cifer
různé algoritmy se mohou výrazně lišit svou efektivností
často rozdíl použitelné vs nepoužitelné
více později (a v dalších předmětech)
30 / 56
Výpočet odmocniny
vstup: číslo x
výstup: přibližná hodnota
√
x
Jak na to?
31 / 56
Výpočet odmocniny
vstup: číslo x
výstup: přibližná hodnota
√
x
Jak na to?
Mnoho metod, ukázka jedné z nich (rozhodně ne nejvíce
efektivní)
31 / 56
Výpočet odmocniny: binární půlení
horní odhadspodní odhad
0 1 20.5 1.5
0 1 20.5 1.5
0 1 20.5 1.5
0 1 20.5 1.5
0 1 20.5 1.5
střed
32 / 56
Výpočet odmocniny: binární půlení
def square_root(x, precision = 0.01):
upper = x
lower = 0
middle = (upper + lower) / 2
while abs(middle**2 - x) > precision:
if middle**2 > x:
upper = middle
if middle**2 < x:
lower = middle
middle = (upper + lower) / 2
return middle
33 / 56
Výpočet odmocniny – chyba
Drobný problém: Program není korektní.
Kde je chyba?
34 / 56
Výpočet odmocniny – poznámky
Funguje korektně jen pro čísla ≥ 1.
Co program udělá pro čísla < 1?
Proč?
Jak to opravit?
35 / 56
Vsuvka: Obecný kontext
problém
⇓
algoritmus
⇓
program
⇓
ladění
36 / 56
Poznámka o ladění
laděním se nebudeme (na přednáškách) příliš zabývat
to ale neznamená, že není důležité...
Ladění je dvakrát tak náročné, jak psaní vlastního kódu. Takže
pokud napíšete program tak chytře, jak jen umíte, nebudete
schopni jej odladit. (Brian W. Kernighan)
37 / 56
Postřeh k ladění
Do průšvihu nás nikdy nedostane to, co nevíme. Dostane nás
tam to, co víme příliš jistě a ono to tak prostě není. (Y. Berry)
38 / 56
Ladění
ladící výpisy
např. v každé iteraci cyklu vypisujeme stav proměnných
doporučeno vyzkoušet na ukázkových programech ze
slidů
použití debuggeru
dostupný přímo v IDLE
sledování hodnot proměnných, spuštěných příkazů,
breakpointy, ...
více: cvičení, pozdější přednáška
39 / 56
Součet druhých mocnin
Lze zapsat zadané číslo jako součet druhých mocnin?
Příklad: 13 = 22
+ 32
Která čísla lze zapsat jako součet druhých mocnin?
40 / 56
Součet druhých mocnin: řešení I
def sum_of_squares_test(n):
for i in range(n+1):
for j in range(n+1):
if i**2 + j**2 == n:
print(n, "=", i**2, "+", j**2)
Program je zbytečně neefektivní. Proč?
Výpis čísel, která lze zapsat jako součet čtverců
41 / 56
Součet druhých mocnin: řešení II
def is_square(n):
square_root = int(n**0.5)
return square_root**2 == n
def is_sum_of_squares(n):
for i in range(int(n**0.5) + 1):
rest = n - i**2
if is_square(rest):
return True
return False
def print_sums_of_squares(count):
for i in range(count):
if is_sum_of_squares(i):
print(i, end=", ")
42 / 56
Podobné náměty
variace: součet tří druhých mocnin, součet dvou třetích
mocnin, ...
další náměty na posloupnosti: The On-Line Encyclopedia
of Integer Sequences, http://oeis.org/
43 / 56
Náhodná čísla
přesněji: pseudo-náhodná čísla
opravdová náhodná čísla: http://www.random.org/
bohaté využití v programování: výpočty, simulace, hry, ...
Python
import random
random.random() – float od 0 do 1
random.randint(a,b) – celé číslo mezi a, b
mnoho dalších funkcí
44 / 56
Náhodná čísla: xkcd
htts://xkcd.com/221/
htts://xkcd.com/1277/
45 / 56
Náhodná čísla: průměr vzorku
Vygenerujeme náhodná čísla a vypočítáme průměrnou
hodnotu:
def random_average(count, maximum = 100):
total = 0
for i in range(count):
total += random.randint(0, maximum)
return total / count
Jakou očekáváme hodnotu na výstupu? Jak velký bude rozptyl
hodnot? (Názorná ukázka centrální limitní věty)
46 / 56
Simulace volebního průzkumu
volební průzkumy se často liší; jaká je jejich přesnost?
přístup 1: matematické modely, statistika
přístup 2: simulace
program:
vstup: preference stran, velikost vzorku
výstup: preference zjištěné v náhodně vybraném vzorku
47 / 56
Simulace volebního průzkumu
def survey(size, pref1, pref2, pref3):
count1 = 0
count2 = 0
count3 = 0
for i in range(size):
r = random.randint(1,100)
if r <= pref1: count1 += 1
elif r <= pref1 + pref2: count2 += 1
elif r <= pref1 + pref2 + pref3: count3 += 1
print("Party 1:", 100.0 * count1 / size)
print("Party 2:", 100.0 * count2 / size)
print("Party 3:", 100.0 * count3 / size)
48 / 56
Poznámky ke zdrojovému kódu
uvedené řešení není dobré:
„copy & paste kód
funguje jen pro 3 strany
lepší řešení – využití seznamů
49 / 56
Kámen, nůžky, papír
http://cs.wikipedia.org/wiki/Kámen,_nůžky,_papír
50 / 56
KNP: strategie
def strategy_uniform():
r = random.randint(1,3)
if r == 1:
return "R"
elif r == 2:
return "S"
else:
return "P"
def strategy_rock():
return "R"
51 / 56
KNP: vyhodnocení tahu
def evaluate(symbol1, symbol2):
if symbol1 == symbol2:
return 0
if symbol1 == "R" and symbol2 == "S" or \
symbol1 == "S" and symbol2 == "P" or \
symbol1 == "P" and symbol2 == "R":
return 1
return -1
52 / 56
KNP: sehrání západu
def rsp_game(rounds):
points = 0
for i in range(1, rounds+1):
print("Round ", i)
symbol1 = strategy_uniform()
symbol2 = strategy_uniform()
print("Symbols:", symbol1, symbol2)
points += evaluate(symbol1, symbol2)
print("Player 1 points:", points)
53 / 56
KNP: obecnější strategie
def strategy(weightR, weightS, weightP):
r = random.randint(1, weightR + weightS + weightP)
if r <= weightR:
return "R"
elif r <= weightR + weightS:
return "S"
else:
return "P"
54 / 56
KNP: rozšiřující náměty
turnaj různých strategií
strategie pracující s historií
kopírování posledního tahu soupeře
analýza historie soupeře (hraje vždy kámen? → hraj
papír)
rozšíření na více symbolů (Kámen, nůžky, papír, ještěr,
Spock)
55 / 56
Shrnutí
operace s čísly, náhoda
ukázky programů
ukázky algoritmů, efektivita
Příště: Seznamy, řetězce a trocha šifer
56 / 56