# Oppgaver 1, 2, 3 og 5 fra IN1000 eksamen h?sten 2018

# Oppgave 1
# 1a) 1 poeng
# Hva er verdien til tall etter at f?lgende kode er utf?rt?

tall = (3 + 1) * 2
tall = tall - 5

# Svar
print("\n1a", tall)

# 1b) 1 poeng
# Hva er verdien til variabelen tekst etter at f?lgende kode er utf?rt?

tall = 7
tekst = "a"
if tall > 10:
    tekst = tekst + "b"
elif tall < 5:
    tekst = tekst + "c"
else:
    tekst = tekst + "d"

# Svar
print("\n1b", tekst)

# 1c) 2 poeng
# Hva er verdien til variabelen a etter at f?lgende kode er utf?rt?

a = 0
for b in [2, 4, 1]:
    a = 2 * a + b

# Svar
print("\n1c", a)

# 1d) 2 poeng
# Hva skrives ut p? skjermen n?r f?lgende kode utf?res?

print("\n1d")

tallene = []
a = 0
b = 1
while a < 4:
    tallene.append(b)
    b = b * 2
    a = a + 1
print(tallene[0] + tallene[3])

# 1e) 2 poeng
# Hva skrives ut p? skjermen n?r f?lgende kode utf?res?

print("\n1e")


def kalkuler(tall):
    tall = tall + 1
    return tall * 2


print(kalkuler(2) + kalkuler(4))

# 1f) 3 poeng
# Hva skrives ut p? skjermen n?r f?lgende kode utf?res?

print("\n1f")


class Tall:
    def __init__(self, a):
        self._a = a

    def m1(self, c):
        self._a = self._a + c

    def m2(self):
        self._a = self._a * 2

    def m3(self):
        return self._a + 10


t1 = Tall(5)
t2 = Tall(2)
t1.m2()
t2.m1(t1.m3())
print(t2.m3())

# Oppgave 2
# 2a) 2 poeng
# Hva skrives ut n?r f?lgende kode kj?res?

print("\n2a")


class Person:
    def __init__(self, navn, alder):
        self._navn = navn
        self._alder = alder

    def bursdag(self):
        self._alder += 1

    def hent_alder(self):
        return self._alder

    def sett_alder(self, ny_alder):
        self._alder = ny_alder


far = Person("Gjert", 48)
trener = far
trener.bursdag()
print(far.hent_alder())

# 2b) 1 poeng
# Hva skrives ut n?r f?lgende kode kj?res?

print("\n2b")

far = Person("Gjert", 48)
trener = far
trener.sett_alder(60)
print(far.hent_alder())

# 2c) 1 poeng
# Hva skrives ut n?r f?lgende kode kj?res?

print("\n2c")

far = Person("Gjert", 48)
trener = far
trener.bursdag()
trener = Person("Tone", 60)
print(far.hent_alder())

# 2d) 1 poeng
# Hva skrives ut n?r f?lgende kode kj?res?

print("\n2d")


def feiring(person):
    person.bursdag()


far = Person("Gjert", 48)
feiring(far)
print(far.hent_alder())

# Oppgave 3
# 3a) 5 poeng
# Skriv en funksjon vinnerlag(hjemmelag, bortelag, hjemmem?l, bortem?l) som tar som argument navn og antall m?l for
# hjemme- og bortelag, og returnerer navnet p? laget som vant (h?yest antall m?l). Om de to lagene har likt antall m?l
# skal funksjonen returnere strengen "uavgjort" . Du kan g? ut fra at argumentene til hjemmelag og bortelag er strenger
# (type str), og at argumentene til hjemmemaal og bortemaal er heltall (type int). For eksempel skal kallet
# vinnerlag("Brann", "Molde", 2, 3) returnere "Molde", mens kallet vinnerlag("Brann", "Molde", 2, 2) skal returnere
# "uavgjort".

print("\n3a")


def vinnerlag(hjemmelag: str, bortelag: str, hjemmem?l: int, bortem?l: int) -> str:
    if hjemmem?l > bortem?l:
        return hjemmelag
    if bortem?l > hjemmem?l:
        return bortelag
    return "uavgjort"


assert vinnerlag("Brann", "Molde", 2, 3) == "Molde"
assert vinnerlag("Brann", "Molde", 2, 2) == "uavgjort"


# 3b) 4 poeng
# Skriv en funksjon forkort_lagliste(lagliste) som tar som argument en liste av strenger som er lagnavn og returnerer en
# ny liste hvor ingen lagnavn finnes flere ganger i lista. Med andre ord, dersom samme streng opptrer flere ganger i
# lista som funksjonen mottar som argument, skal denne bare opptre ¨Śn gang i lista som blir returnert. For eksempel skal
# kallet forkort_lagliste(["Brann", "Molde", "Brann"]) returnere en liste ["Brann", "Molde"].

print("\n3b")


def forkort_lagliste(lagliste: list[str]) -> list[str]:
    return list(set(lagliste))


assert set(forkort_lagliste(["Brann", "Molde", "Brann"])) == {"Brann", "Molde"}

# 3c) 3 poeng
# Skriv en funksjon legg_inn_null_m?l(lagliste) som tar som argument en liste av strenger (lagnavn) og returnerer en
# ordbok som har hver streng fra lista (hvert lagnavn) som n?kkelverdi, med heltallsverdien 0 som innholdsverdi. For
# eksempel skal kallet legg_inn_null_m?l(["Brann","Molde"]) returnere en ordbok {"Brann" : 0, "Molde" : 0}.

print("\n3c")


def legg_inn_null_m?l(lagliste: list[str]) -> dict[str, int]:
    lagordbok = {}
    for lag in lagliste:
        lagordbok[lag] = 0
    return lagordbok


assert legg_inn_null_m?l(["Brann", "Molde"]) == {"Brann": 0, "Molde": 0}

# 3d) 6 poeng
# Skriv en funksjon hent_lagliste(filnavn) som tar et filnavn som argument og returnerer en liste med alle lagnavn den
# finner i filen. Funksjonen skal lese gjennom en fil (gitt av filnavnet mottatt som argument) hvor hver linje best?r av
# et navn p? hjemmelag, navn p? bortelag, antall m?l hjemmelag, antall m?l bortelag (separert med mellomrom). Funksjonen
# skal returnere en liste som inneholder alle lagnavn som finnes i filen (som enten hjemmelag eller bortelag i
# ovennevnte format). Det gj?r ikke noe (er uten betydning) om hvert lag opptrer flere ganger i den returnerte lista.
# Rekkef?lgen av lagene i lista som returneres er ogs? uten betydning.
#
# En fil som skal leses gjennom kan alts? se ut for eksempel som f?lger:
# brann molde 2 0
# sarpsborg molde 1 1
#
# Funksjonen skal for dette eksempelet returnere en liste som inneholder lagnavnene brann, molde og sarpsborg, hvor
# eventuelle repetisjoner er uproblematisk - alts? blir b?de
#   ["brann", "molde", "sarpsborg"]
# og
#   ["brann", "molde", "sarpsborg", "molde"]
# godtatt som returverdi.

print("\n3d")


def hent_lagliste(filnavn: str) -> set[str]:
    lagliste = []
    fil = open(filnavn)
    for linje in fil:
        verdier = linje.strip().split()
        if len(verdier) >= 2:
            lagliste.append(verdier[0])
            lagliste.append(verdier[1])
    fil.close()
    return set(lagliste)


# 3e) 7 poeng
# Skriv en funksjon regn _poengsum(filnavn) som tar et filnavn som argument og returnerer en ordbok med antall poeng for
# hvert lag ut fra kampresultat funnet i filen. Filen har samme format som i oppgave 3d, dvs hvor hver linje best?r av
# et navn p? hjemmelag, navn p? bortelag, antall m?l hjemmelag, antall m?l bortelag (separert med mellomrom). Funksjonen
# regn_poengsum skal fortrinnsvis initielt kalle p? funksjonene hent_lagliste, forkort_lagliste og legg_inn_null_m?l
# (fra hhv oppgave 3d, 3b og 3c) for ? konstruere en ordbok med null poeng for alle lag oppf?rt i filen. Deretter skal
# den g? gjennom alle kampresultat (linjer) i filen og gi 3 poeng for vinnende lag, 0 poeng for tapende lag, samt 1
# poeng til hvert lag i tilfeller av uavgjort. Man kan gjerne kalle p? funksjonen vinnerlag fra oppgave 3a for ? hjelpe
# med utregning av poeng, men dette tillegges ikke vekt.

print("\n3e")


def regn_poengsum(filnavn: str) -> dict[str, int]:
    lagliste = hent_lagliste(filnavn)
    resultatsliste = legg_inn_null_m?l(list(lagliste))
    fil = open(filnavn)
    for linje in fil:
        verdier = linje.strip().split()
        if len(verdier) >= 4:
            hjemmelag, bortelag, hjemmem?l, bortem?l = verdier
            vinner = vinnerlag(hjemmelag, bortelag, int(hjemmem?l), int(bortem?l))
            if vinner == hjemmelag:
                resultatsliste[hjemmelag] += 3
            elif vinner == bortelag:
                resultatsliste[bortelag] += 3
            else:
                resultatsliste[hjemmelag] += 1
                resultatsliste[bortelag] += 1
    fil.close()
    return resultatsliste


# 3f) 5 poeng
# Skriv en funksjon gull(lagoversikt) som tar som argument en ordbok med lagnavn og antall m?l (strenger som
# n?kkelverdier og heltall som innholdsverdier) og returnerer navnet p? laget med h?yest poengsum (n?kkelverdien med
# h?yeste tilh?rende innholdsverdi). Du kan anta at ett lag har h?yest poengsum (ikke to lag med samme poengsum), og at
# det finnes noen lag med positiv poengsum i ordboken mottatt som argument. For eksempel skal kallet
# gull({"Brann" : 2, "Molde" : 3}) returnere "Molde".

print("\n3f")


def gull(lagoversikt: dict[str, int]):  # -> str | None: # Python 3.9 og eldre st?tter ikke |
    beste = None
    h?yest_poeng = 0
    for lag in lagoversikt:
        poeng = lagoversikt[lag]
        if poeng > h?yest_poeng:
            beste = lag
            h?yest_poeng = poeng
    return beste


assert gull({"Brann": 2, "Molde": 3}) == "Molde"

# 3g) 3 poeng
# Skriv en prosedyre finn_gull(filnavn) som tar et filnavn som argument og skriver navnet p? laget med flest poeng ut
# til terminalen. Filen har samme format som i oppgave 3d. Poeng regnes ut basert p? vinnende og tapende lag for hver
# kamp som beskrevet i oppg 3e. Som i oppg 3f kan du anta at ett lag har h?yest poengsum (ikke to lag med samme
# poengsum), og at det finnes minst ett lag med positiv poengsum. Du kan benytte deg av kall p? hvilke
# funksjoner/prosedyrer du ?nsker fra deloppgaver 3a-3f for ? lage en enklest mulig l?sning for prosedyren finn_gull (du
# kan kalle p? funksjoner/prosedyrer fra andre deloppgaver ut fra den beskrevne funksjonaliteten, uavhengig av om du
# selv har l?st disse deloppgavene eller ikke).

print("\n3g")


def finn_gull(filnavn: str) -> None:
    vinner = gull(regn_poengsum(filnavn))
    print(vinner)


finn_gull("lagliste")


# Skriv ut resultatsliste
# Ikke en del av eksamen

print()

for lag, poeng in sorted(regn_poengsum("lagliste").items(), key=lambda oversikt: oversikt[1], reverse=True):
    print(f"{lag:20}: {poeng:>2}")

# Oppgave 5
# Skriv en funksjon godkjenn(familier) som tar som argument en liste av lister med aldre for personer i familier. Hver
# familie er representert med en liste av aldre for alle medlemmene i familien i vilk?rlig rekkef?lge. En familie med
# tre medlemmer av alder 30, 10 og 2 ?r, kan dermed f.eks. v?re representert av en liste [10,2,30]. Alle aldre er
# heltall. Funksjonen godkjenn skal ta inn en liste av slike lister (alts? flere familier). Om man i tillegg til nevnte
# familie har en annen familie med aldre 20 og 1, vil dette alts? kunne v?re representert som [ [10,2,30], [20,1] ].
# Skriv funksjonen godkjenn slik at den sjekker at alle familier har minst ¨Śn myndig person, alts? at alle lister har
# minst en verdi som er st?rre eller lik 18. S? lenge alle familier har minst ¨Śn myndig person, skal funksjonen
# returnere True. Dersom ¨Śn eller flere familier mangler myndig person (at det for minst ¨Śn av listene er slik at alle
# verdier er under 18) skal den returnere False. For eksempel skal kallet godkjenn([ [10,2,30], [20,1] ]) returnere
# True, mens kallet godkjenn([ [10,2,30], [10,1] ]) skal returnere False.

print("\n5")


def godkjenn(familier: list[list]) -> bool:
    for familie in familier:
        har_myndig = False
        for medlem in familie:
            if medlem >= 18:
                har_myndig = True
        if not har_myndig:
            return False
    return True


assert godkjenn([[10, 2, 30], [20, 1]])
assert not godkjenn([[10, 2, 30], [10, 1]])