import stopaj
def najvecji_element1(sez):
maksi, maksi_i = None, None # O(1)
for i, x in enumerate(sez): # n * O(1) = O(n)
if maksi is None or x > maksi: # O(1)
maksi = x
maksi_i = i
return maksi_i # O(1)
# -------------------
# O(n)
def najvecji_element2(sez):
for i, x in enumerate(sez): # n * O(n) = O(n^2)
if x == max(sez):
return i
def najvecji_element3(sez):
maks = max(sez)
for i, x in enumerate(sez): # n * O(1) = O(n)
if x == maks:
return i
stopaj.izmeri_case_poskusov(
[stopaj.nakljucen_narascajoc_seznam(100 * n) for n in range(1, 20)],
[najvecji_element1, najvecji_element3])
import stopaj
def sled_matrike1(matrika):
sled = 0
for i, vrstica in enumerate(matrika):
for j, element in enumerate(vrstica):
if i == j:
sled += element
return sled
def sled_matrike2(matrika):
sled = 0
for i, vrstica in enumerate(matrika):
sled += vrstica[i]
return sled
def sled_matrike3(matrika):
sled = 0
for i in range(len(matrika)):
sled += matrika[i][i]
return sled
stopaj.izmeri_case_poskusov(
[stopaj.nakljucna_matrika(50 * n) for n in range(1, 20)],
[sled_matrike1, sled_matrike2, sled_matrike3],
)
najvecji_element5 = max
def isci(seznam, x, od=0, do=None):
'''Poisci, ali x nastopa v rezini seznam[od:do]'''
if do is None:
do = len(seznam)
if do <= od:
return False
else:
indeks_sredine = (od + do) // 2
sredina = seznam[indeks_sredine]
if x == sredina:
return True
elif x < sredina:
return isci(seznam, x, od, indeks_sredine)
else: # x > sredina
return isci(seznam, x, indeks_sredine + 1, do)
def isci_dolzino(seznam):
return isci(seznam, -42)
stopaj.izmeri_case_poskusov(
[stopaj.narascajoc_seznam(10000 * n + 1) for n in range(100)], [
isci_dolzino,
])
elif x > n:
return False
return False
def bisekcija(seznam, x, od, do):
'''Ali seznam[od:do] vsebuje x'''
if od == do:
return False
else:
i = (od + do) // 2
if seznam[i] == x:
return True
elif seznam[i] > x:
return bisekcija(seznam, x, od, i)
elif seznam[i] < x:
return bisekcija(seznam, x, i + 1, do)
def poisci_z_bisekcijo(seznam):
n = len(seznam) // 2
return bisekcija(seznam, n, 0, len(seznam))
def poisci_vgrajen(seznam):
return len(seznam) in seznam
stopaj.izmeri_case_poskusov(
[stopaj.nakljucen_narascajoc_seznam(n) for n in range(1000, 100000, 5000)],
[poisci_nas, poisci_v_urejenem, poisci_vgrajen, poisci_z_bisekcijo])
return poisci_v_urejenem(sez, x, sredina + 1, j)
else:
assert False
def poisci_v_urejenem_brez_potratne_rekurzije(sez, x):
i = 0
j = len(sez)
while i < j:
sredina = (i + j) // 2
if x == sez[sredina]:
return True
elif x < sez[sredina]:
j = sredina
elif x > sez[sredina]:
i = sredina + 1
else:
assert False
return False
stopaj.izmeri_case_poskusov(
[stopaj.nakljucen_narascajoc_seznam(5000 * n) for n in range(1, 20)],
[
lambda sez: poisci1(sez, sez[-1]),
lambda sez: poisci2(sez, sez[-1]),
lambda sez: poisci_v_urejenem(sez, sez[-1], 0),
lambda sez: poisci_v_urejenem_brez_potratne_rekurzije(sez, sez[-1]),
],
)
# stopaj.izmeri_case_poskusov(
# [stopaj.nakljucen_seznam(5000 * n) for n in range(1, 20)],
# [
# lambda sez: poisci_v_neurejenem(sez, 0),
# ],
# )
# stopaj.izmeri_case_poskusov(
# [stopaj.nakljucen_narascajoc_seznam(2**n) for n in range(10, 20)],
# [
# lambda sez: poisci_v_urejenem(sez, 0),
# ],
# )
stopaj.izmeri_case_poskusov(
[set(stopaj.nakljucen_seznam(2**n)) for n in range(10, 20)],
[
lambda sez: poisci_v_mnozici(sez, 0),
],
)
# stopaj.izmeri_case_poskusov(
# [stopaj.nakljucen_seznam(500 * n) for n in range(1, 20)],
# [
# lambda sez: naredi_neurejenega(sez),
# ],
# )
# stopaj.izmeri_case_poskusov(
# [stopaj.nakljucen_seznam(500 * n) for n in range(1, 20)],
# [
# lambda sez: naredi_urejenega(sez),
# ],
sled = 0
for i in range(len(mat)):
for j in range(len(mat)):
if i == j:
sled += mat[i][j]
return sled
def isci(seznam, x):
if len(seznam) == 0:
return False
else:
indeks_sredine = len(seznam) // 2
sredina = seznam[indeks_sredine]
if x == sredina:
return True
elif x < sredina:
return isci(seznam[:indeks_sredine], x)
else: # x > sredina
return isci(seznam[indeks_sredine + 1:], x)
def isci_dolzino(seznam):
return isci(seznam, len(seznam))
stopaj.izmeri_case_poskusov(
[stopaj.nakljucen_narascajoc_seznam(10000 * n) for n in range(20)],
[isci_dolzino]
)
def neumna_sled(mat):
sled = 0
for i in range(len(mat)):
for j in range(len(mat)):
if i == j:
sled += mat[i][j]
return sled
def isci(seznam, x):
if len(seznam) == 0:
return False
else:
indeks_sredine = len(seznam) // 2
sredina = seznam[indeks_sredine]
if x == sredina:
return True
elif x < sredina:
return isci(seznam[:indeks_sredine], x)
else: # x > sredina
return isci(seznam[indeks_sredine + 1:], x)
def isci_dolzino(seznam):
return isci(seznam, len(seznam))
stopaj.izmeri_case_poskusov(
[stopaj.nakljucen_narascajoc_seznam(10000 * n) for n in range(20)],
[isci_dolzino])
najvecji_element5 = max
def isci(seznam, x, od=0, do=None):
'''Poisci, ali x nastopa v rezini seznam[od:do]'''
if do is None:
do = len(seznam)
if do <= od:
return False
else:
indeks_sredine = (od + do) // 2
sredina = seznam[indeks_sredine]
if x == sredina:
return True
elif x < sredina:
return isci(seznam, x, od, indeks_sredine)
else: # x > sredina
return isci(seznam, x, indeks_sredine + 1, do)
def isci_dolzino(seznam):
return isci(seznam, -42)
stopaj.izmeri_case_poskusov(
[stopaj.narascajoc_seznam(10000 * n + 1) for n in range(100)],
[
isci_dolzino,
]
)
def dodaj_pare(slovar, pari):
for k, v in pari:
slovar[k] = v
def nakljucen_dict(n):
d = {}
dodaj_pare(d, nakljucni_pari(n))
return d
def nakljucen_slovar(n):
d = Slovar()
dodaj_pare(d, nakljucni_pari(n))
return d
stopaj.izmeri_case_poskusov(
[nakljucen_dict(2**n) for n in range(10, 20)],
[
lambda slovar: poisci(slovar, 0),
],
)
stopaj.izmeri_case_poskusov(
[nakljucen_slovar(2**n) for n in range(10, 20)],
[
lambda slovar: poisci(slovar, 0),
],
)