Vaje

Seznami

1. Napiši funkcijo argmax(s), ki prejme seznam in vrne indeks največjega elementa seznama.

def argmax(s):
    max_i = None
    for i, stevilo in enumerate(s):
        if max_i == None or stevilo > s[max_i]:
            max_i = i
    return max_i

2. Ugani, kaj mora narediti funkcija argmin(s) :) in jo napiši.

def argmin(s):
    min_i = None
    for i, stevilo in enumerate(s):
        if min_i == None or stevilo < s[min_i]:
            min_i = i
    return min_i

3. Napiši funkcijo span(s), ki prejme seznam števil in vrne razliko med največjim in najmanjšim členom podanega zaporedja.

def span(s):
    return max(s) - min(s)

4. Napiši funkcijo sami_sodi(s), ki vrne True, če seznam vsebuje sama soda števila in False, če vsebuje tudi kakšno liho. Če je seznam prazen, vrnemo True (saj ne vsebuje nobenega lihega).

def sami_sodi(s):
    for stevilo in s:
        if stevilo % 2 == 1:
            return False
    return True

5. Napiši funkcijo sodi_lihi(s), ki vrne True, če so elementi na sodih indeksih sodi, na lihih pa lihi.

def sodi_lihi(s):
    for i, stevilo in enumerate(s):
        if stevilo % 2 != i % 2:
            return False
    return True

Dražba

1. Napiši funkcijo ponudbe(ime_datoteke, predmet), ki prejme ime datoteke (lahko je "zapisnik.txt", lahko pa je tudi kaj drugega) in ime predmeta. Vrniti mora seznam vseh ponujenih cen za ta predmet.

def ponudbe(ime_datoteke, predmet):
    vse_cene = []
    for vrstica in open(ime_datoteke):
        trenutni_predmet, _, cena = vrstica.split(",")
        if trenutni_predmet == predmet:
            vse_cene.append(int(cena))
    return vse_cene

2. Napiši funkcijo najboljsa_ponudba(ime_datoteke, predmet), ki vrne najvišjo ponujeno ceno za podani predmet.

def najboljsa_ponudba(ime_datoteke, predmet):
    return max(ponudbe(ime_datoteke, predmet))

3. Napiši funkcijo stevilo_ponudb(ime_datoteke, predmet), ki vrne število ponudb za podani predmet.

def stevilo_ponudb(ime_datoteke, predmet):
    return len(ponudbe(ime_datoteke, predmet))

4. Napiši funkcijo visanje(ime_datoteke, predmet), ki vrne razliko med najvišjo in najnižjo ponujeno ceno za podani predmet.

def visanje(ime_datoteke, predmet):
    vse_cene = ponudbe(ime_datoteke, predmet)
    return vse_cene[-1] - vse_cene[0]

5. Napiši funkcijo ponudniki(ime_datoteke), ki vrne slovar, katerega ključi so imena oseb, ki so sodelovale na dražbi, pripadajoče vrednosti pa število ponudb, ki jih je dala ta oseba.

def ponudniki(ime_datoteke):
    osebe_ponudbe = defaultdict(int)
    for vrstica in open(ime_datoteke):
        predmet, oseba, cena = vrstica.split(",")
        osebe_ponudbe[oseba] += 1
    return osebe_ponudbe

Collatzovo zaporedje

Vsak člen Collatzovega zaporedja računamo tako, da prejšnji člen

• v primeru, da je sod, delimo z 2,
• v primeru, da je lih pa pomnožimo s 3 in prištejemo 1.

1. Napišite funkcijo collatz(n), ki kot argument prejme začetno število, kot rezultat pa vrne seznam števil v Collatzovem zaporedju, ki se začnejo s podanim številom. Če, recimo, pokličemo funkcijo s collatz(12), mora vrniti seznam [12, 6, 3, 10, 5, 16, 8, 4, 2, 1].

def collatz(n):
    s = [n]
    while n != 1:
        if n % 2 == 0:
            n //= 2
        else:
            n = n * 3 + 1
        s.append(n)
    return s

2. Napišite funkcijo collatz_dolzina(n), ki kot argument prejme začetno število, kot rezultat pa vrne dolžino Collatzovega zaporedja, ki se začne s tem številom. Če, recimo pokličemo funkcijo s collatz_dolzina(12), mora vrniti 10.

def collatz_dolzina(n):
    return len(collatz(n))

3. Napišite funkcijo najdaljsi_dolz(n), ki vrne dolžino najdaljšega zaporedje, ki ga lahko dobimo, če začnemo s števili med 1 in (vključno) n. Tako mora, recimo, najdaljsi_dolz(10000) vrniti 262, saj je to najdaljše možno zaporedje med števili do 10000 (dobimo ga, če začnemo s 6171).

def najdaljsi_dolz(n):
    naj = 0
    for i in range(1, n+1):
        t = collatz_dolzina(i)
        if t > naj:
            naj = t
    return naj

4. Napišite funkcijo najdaljsi_stev(n), ki vrne tisto število med 1 in (vključno) n, ki da najdaljše Collatzovo zaporedje. Tako mora, recimo, najdaljsi_stev(10000) vrniti 6171, saj dobimo najdaljše zaporedje, med števili do 10000 takrat, ko začnemo s 6171 (zaporedje ima 262 členov).

def najdaljsi_stev(n):
    naj = naj_t = 0
    for i in range(1, n+1):
        t = collatz_dolzina(i)
        if t > naj_t:
            naj, naj_t = i, t
    return naj