To delo je na voljo pod pogoji slovenske licence Creative Commons 2.5:

priznanje avtorstva - nekomercialno - deljenje pod enakimi pogoji.

Celotna licenca je na voljo na spletu na naslovu http://creativecommons.org/licenses/by-nc-sa/2.5/si/. V skladu s to licenco je dovoljeno vsakemu uporabniku delo razmnoževati, distribuirati, javno priobčevati, dajati v najem in tudi predelovati, vendar samo v nekomercialne namene in ob pogoju, da navede avtorja oziroma avtorje in izdajatelja tega dela. Če uporabnik delo predela, kar pomeni, da ga spremeni, preoblikuje, prevede ali uporabi to delo v svojem delu, lahko predelavo dela ponudi na voljo le pod pogoji, ki so enaki pogojem iz te licence oziroma pod enako licenco.

def Izpisi(h):
  kljuci = [kljuc for kljuc in h]
  kljuci.sort()
  for kljuc in kljuci:
    print(str(kljuc) + ": " + str(h[kljuc]))

Izpisi({"ena": 1, "dve": 2, "tri": 3})

Rešitev (a):

def Najpogostejsi(t):
  # Pripravimo si slovar, v katerem kot ključe uporabimo elemente seznama t,
  # pripadajoča vrednost pa bo število pojavitev tistega ključa v seznamu.
  pogostost = {}
  for x in t:
    pogostost[x] = pogostost.get(x, 0) + 1

  # S pomočjo tega slovarja poglejmo, kateri ključ je najpogostejši.
  najPogostost = 0; najX = None
  for x in pogostost:
    if pogostost[x] > najPogostost:
      najPogostost = pogostost[x]
      najX = x

  return (najPogostost, najX)

Rešitev (b):

# Če prvotne tabele še vedno ne smemo spreminjati in tudi ne smemo
# uporabljati slovarja, lahko nalogo rešimo tako, da naredimo kopijo
# tabele in jo uredimo; tako pridejo vse kopije posameznega elementa
# skupaj in jih je lahko prešteti.
def Najpogostejsi2(t):
  tt = t[:] # Naredimo kopijo tabele t
  tt.sort() # in jo uredimo.
  najPogostost = 0; najX = None
  i = 0; n = len(tt)

  while i < n:
    # Poiščimo prvi naslednji element, ki je različen od tt[i].
    j = i + 1
    while j < n and tt[j] == tt[i]:
      j += 1

    # Zdaj torej vemo, da se element tt[i] v vhodni tabeli
    # pojavlja (j - i)-krat.
    if j - i > najPogostost:
      najPogostost = j - i
      najX = tt[i]

    # Nadaljujmo pri prvem naslednjem elementu z drugačno vrednostjo.
    i = j

  return (najPogostost, najX)

# Slovar za pomnjenje rešitev.
h = {}

def Fib2(n):
  # Če imamo rešitev za ta n že v slovarju, jo le preberimo od tam.
  if n in h: return h[n]
  # Sicer jo izračunajmo zdaj.
  if n == 0: rezultat = 0
  elif n == 1: rezultat = 1
  else: rezultat = Fib2(n - 2) + Fib2(n - 1)
  # Shranimo rezultat v slovar in ga vrnimo.
  h[n] = rezultat
  return rezultat

for n in range(100):
  print("f(" + str(n) + ") = " + str(Fib2(n)))

# Prvotna rešitev SteviloZBesedami iz učne enote o nizih ima veliko klicev
# return. Načeloma bi morali zdaj pri vsakem od njih še poskrbeti, da se
# rezultat najprej tudi shrani v slovar. Temu se lahko elegantno izognemo
# tako, da razdelimo funkcijo na dva dela: ena funkcija (spodaj se imenuje
# _SteviloZBesedami) izračuna rezultat, druga (spodaj se imenuje
# SteviloZBesedami – to je tista, ki jo bo uporabnik zares poklical) pa ga
# shrani v slovar in posreduje uporabniku.

# Slovar za pomnjenje rešitev.
h = {}

# "Interna" funkcija _SteviloZBesedami je čisto enaka kot funkcija
# SteviloZBesedami iz rešitve 9. naloge v učni enoti o nizih, le ime smo ji
# spremenili. Paziti moramo na to, da pri rekurzivnih klicih še vseeno kliče
# funkcijo SteviloZBesedami (ki bo znala izkoristiti rezultate iz slovarja,
# če so na voljo).
def _SteviloZBesedami(n, dve = True):
  enice = ["nic", "ena", "dva", "tri", "stiri", "pet", "sest",
           "sedem", "osem", "devet"]
  if n == 2 and dve:
    return "dve"
  if n < 10:
    return enice[n]
  if n < 100:
    if n == 10:
      return "deset"
    elif n == 20:
      return "dvajset"
    elif n % 10 == 0:
      return enice[n // 10] + "deset"
    elif n == 11:
      return "enajst"
    elif n < 20:
      return enice[n % 10] + "najst"
    else:
      return enice[n % 10] + "in" + SteviloZBesedami(n - n % 10, False)
    if n < 1000:
    c = n // 100
    s = "sto"
    if c > 1:
      s = SteviloZBesedami(c) + s
    if n % 100:
      s += " " + SteviloZBesedami(n % 100, dve)
    return s
  m = n // 1000
  if m == 1:
    s = ""
  else:
    s = SteviloZBesedami(m, False) + " "
  s += "tisoc"
  if n % 1000:
    s += " " + SteviloZBesedami(n % 1000)
  return s

def SteviloZBesedami(n, dve = True):
  # Če imamo rešitev v slovarju, jo preberimo od tam. Ker ima funkcija dva
  # parametra, moramo paziti na to, da kot ključ v slovarju uporabimo oba
  # skupaj, saj je rezultat lahko odvisen od obeh, ne le od n.
  if (n, dve) in h: return h[n, dve]
  # Sicer jo izračunajmo zdaj.
  rezultat = _SteviloZBesedami(n, dve)
  # Shranimo jo v slovar in jo vrnimo.
  h[n, dve] = rezultat
  return rezultat

print(SteviloZBesedami(2002))
print(SteviloZBesedami(102002))
print(SteviloZBesedami(102102))
#for n in range(1, 10**6):
#  print(SteviloZBesedami(n + 1))