diff --git "a/Oving3/Intro_\303\230ving3.md" "b/Oving3/Intro_\303\230ving3.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9c8f961b04555efe44f93528ff27aa1d76d60266
--- /dev/null
+++ "b/Oving3/Intro_\303\230ving3.md"
@@ -0,0 +1,41 @@
+**Øving 3**
+
+**Læringsmål:**
+
+* Løkker
+* Betingelser
+* Strenger
+* Datamaskiners virkemåte
+
+**Starting Out with Python:**
+
+* Kap. 4: Repetition Structures
+
+**Theory book:**
+
+* Kap. 9: Principles of Computer Operations
+ 
+
+**Godkjenning:**
+
+For å få godkjent øvingen må du gjøre 4 av 11 andre oppgaver. ***1*** av de ***4*** må være en oppgave med vanskelighetsgrad middels.
+
+Oppgavene er markert med vanskelighetsgrad. 
+
+Alle oppgavene skal demonstreres til en læringsassistent på sal. I oppgaver der du skriver programkode skal også denne vises fram. Lykke til!
+
+Alle oppgavene skal demonstreres til en læringsassistent på sal. I oppgaver der du skriver programkode skal også denne vises fram. Lykke til!
+
+Oppgave | Tema | Vanskelighetsgrad
+--- | --- | ---
+[Introduksjon til løkker](Lett/Intro%20til%20løkker.md) |Løkker | Lett
+[Mer om løkker](Lett/Mer%20om%20løkker.md)|Løkker| Lett
+[Intro til nøstede løkker](Lett/Nøstede%20løkker.md)|Nøstede løkker| Lett
+[Kodeforståelse](Lett/Kodeforståelse.md)|Kodeforståelse| Lett
+[Gjett tallet](Lett/Gjett%20tallet.md)|Løkker og betingelse| Lett
+[Tekstbasert Spill 2](Middels/Tekstbasert%20spill%202.md)|Løkker og betingelse|Middels
+[Geometrisk rekke](Middels/Geometrisk%20rekke.md)|Løkker og betingelse|Middels
+[Fibonacci](Middels/Fibonacci.md)|Løkker|Middels
+[Alternerende sum](Middels/Alternerende%20sum.md)|Løkker|Middels
+[Hangman](Middels/Hangman.md)|Løkker| Middels
+[Doble løkker](Middels/Doble%20løkker.md)|Nøstede Løkker| Middels
diff --git a/Oving3/Lett/Gjett tallet.md b/Oving3/Lett/Gjett tallet.md
new file mode 100644
index 0000000000000000000000000000000000000000..a6cbe16f8afd6f54f143a72db0e7f1ea64910b2e
--- /dev/null
+++ b/Oving3/Lett/Gjett tallet.md	
@@ -0,0 +1,56 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+
+# Gjettelek
+
+**Læringsmål:**
+
+* Løkker
+* Betingelser
+* Innebygde funksjoner
+
+**Starting Out with Python:**
+
+* Kap. 4.2-4.3
+
+## OPPGAVER
+
+Alle deloppgaver besvares her: *[Gjett tallet.py](Gjett%20tallet.py)* !
+<br><br>
+I denne oppgaven skal du lage et program som genererer et tilfeldig heltall i et gitt intervall, og deretter lar brukeren gjette på hvilket tall dette er. Dette bør gjøres ved bruk av løkker.
+
+I denne oppgaven må du benytte deg av biblioteket random. Derfor skal koden din starte med `import random`.
+
+Eksempel på bruk av random.randint()
+
+```python
+tilfeldigTall = random.randint(1,50)    #gir deg et tilfeldig tall fra og med 1, til og med 50
+tall = random.randint(a,b)              #gir deg et tilfeldig tall mellom a og b. (Fra og med a, til og med b)
+```
+
+## a)
+Be brukeren om å velge en nedre og en øvre grense for tall han eller hun skal gjette på. Lagre disse to opplysningene i to variabler.
+
+<br>
+
+## b)
+Lag en variabel `TilfeldigTall` som genererer et tilfeldig tall i intervallet mellom den øvre og den nedre grensen som brukeren har satt. Fortsett å skriv i samme kode som i oppgave a.
+
+<br>
+
+## c)
+Skriv en while-løkke som kjører så lenge brukeren ikke har gjettet riktig svar. Brukeren skal få tilbakemelding for hvert gjett om han eller hun gjettet for lavt, for høyt eller riktig. Fortsett å skriv i samme kode som i oppgave a og b.
+
+**Eksempel på kjøring:**
+
+*Gi en nedre grense for det tilfeldige tallet:* 1 <br>
+*Gi en øvre grense for det tilfldige tallete:* 100 <br>
+*Make a guess:* 50 <br>
+*The correct number is lower <br>
+Make a guess:* 25 <br>
+*The correct Number is higher <br>
+Make a guess:* 37 <br>
+*The correct number is lower <br>
+Make a guess:* 32 <br>
+*You guessed correct!* <br>
diff --git a/Oving3/Lett/Gjett tallet.py b/Oving3/Lett/Gjett tallet.py
new file mode 100644
index 0000000000000000000000000000000000000000..5632040bbb5619669def96c8dee7bf83d34cb46b
--- /dev/null
+++ b/Oving3/Lett/Gjett tallet.py	
@@ -0,0 +1,4 @@
+print("Gjett tallet!")
+#TODO løs oppgave a,b og c her:
+
+
diff --git "a/Oving3/Lett/Intro til l\303\270kker.md" "b/Oving3/Lett/Intro til l\303\270kker.md"
new file mode 100644
index 0000000000000000000000000000000000000000..67ed01572b87031ae1ce5b6a28824cc96a7599b7
--- /dev/null
+++ "b/Oving3/Lett/Intro til l\303\270kker.md"	
@@ -0,0 +1,312 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+
+# Intro til løkker
+
+**Læringsmål:**
+
+* Løkker
+* Velge egnet løkkekonstruksjon (for eller while) etter behov
+
+**Starting Out with Python:**
+
+* Kap. 4.1-4.3
+
+<BR>
+
+## INTRODUKSJON
+### **Løkker**
+
+Noe av det datamaskiner er best på, er gjentatte handlinger i høyt tempo. Dette er også et vanlig behov.
+* Et firma skal utbetale lønn til alle sine ansatte hver måned.
+* Et digitalt eksamenssystem skal vise spørsmål til, og motta svar fra, alle studenter som tar eksamen. 
+* Et system som styrer industrielt produksjonsutstyr skal motta informasjon fra en rekke sensorer hvert eneste sekund, om trykk, temperatur, osv., og gjøre handlinger basert på verdiene.
+* Utstyr på et sykehus skal overvåke pasienters hjerterytme osv. sekund for sekund, og kunne slå alarm hvis noe er unormalt.
+* Utstyr for opptak av musikk skal kunne sample lyden tusenvis eller millionvis av ganger per sekund.
+* Et program for å vise video på en mobilskjerm må likeledes kunne oppdatere fargen i hver piksel på skjermen mange ganger i sekundet.
+
+Du har kanskje erfaring med bruk av regneark? Der er det vanlig hvis man skal bruke samme formel på alle radene i en tabell at man **kopierer** formelen nedover.  
+Å kopiere samme kodesetning flere ganger er mulig i Python også, men bare praktisk hvis antall repetisjoner er lavt og kjent på forhånd.
+Eksemplet nedenfor viser et slikt tilfelle, hvor en kodelinje er gjentatt 3 ganger.
+
+```python
+print("Hipp")
+print("Hipp")
+print("Hipp")
+print("Hurra!")
+```
+Samme utskrift kan oppnås med løkke:
+```python
+for i in range(3):
+    print("Hipp!")
+print("Hurra!")
+```
+
+**for &lt;variabel&gt; in range(3)**: gjør at påfølgende kodesetning(er) med innrykk blir repetert 3 ganger.
+
+print("Hurra!") som ikke har innrykk, er ikke del av løkka, og vil derfor bare bli utført en gang, etter at løkka er ferdig.
+
+Det fins to typer løkker i Python, **for**-løkke som vist over, og **while**-løkke. Vi kunne ha klart oss med bare while-løkke, eksemplet ville da ha blitt:
+
+```python
+i = 0
+while i < 3:
+    print("Hipp")
+    i = i + 1  # eller: i += 1
+print("Hurra!")
+```
+
+while er noe mer tungvint her, vi må eksplisitt øke i med 1 for hver runde, som er implisitt i for-løkka. 
+
+while-løkka vil fortsette så lenge betingelsen (her: i < 3) er sann, den vil derfor kjøre når i er 0, 1, 2, men deretter stoppe når i blir 3. Som i for-løkka gjør dette at Hipp skrives 3 ganger.
+
+I andre situasjoner er while-løkke derimot bedre enn  for-løkke. Generelt gjelder følgende:
+
+* **for-løkke** egner seg når vi har et **kjent antall repetisjoner**. Eksempel fra den virkelige verden: hver måned skal et firma utbetale lønn til alle sine ansatte. Firmaet og dets datasystem vet (forhåpentligvis) hvor mange ansatte det har, dermed har løkka "for alle ansatte, beregn og utbetal lønn" et kjent antall repetisjoner når lønningsdagen kommer.
+* **while-løkke** er derimot nødvendig hvis **maks antall repetisjoner er uvisst** når løkka starter og vi først finner ut underveis når løkka skal avsluttes. F.eks.
+ * brukeren bestemmer underveis, f.eks. "Try again" / "Quit" - vi aner ikke hvor mange ganger brukeren vil forsøke. Eller et program for lydopptak: løkka som sampler lyden, starter når brukeren klikker på "Record" og skal fortsette til brukeren trykker "Stop" - og vi aner ikke hvor mange sekunder eller minutter det vil ta.
+ * numerisk løsning av matematiske likninger, hvor stoppkriteriet er at vi skal ha nådd en viss presisjon. Hvis vi ikke aner på forhånd hvor mange iterasjoner som trengs for å nå denne presisjonen, vil while-løkke være best.
+ * produksjonsutstyr i en fabrikk skal kjøre som normalt med mindre sensordata indikerer en krisesituasjon, og da gå over til en alternativ nødprosedyre. Vi aner ikke om det går tusen sekunder, eller millioner av sekunder... kanskje inntreffer krisesituasjonen slett ikke. Dermed vil antall repetisjoner av løkka for normal oppførsel være ukjent når den starter, som tilsier while-løkke.
+
+Under er forskjellen vist ved to ytterligere varianter av Hurra-programmet vårt.
+
+```python
+# hvis brukeren skal bestemme antall på forhånd:
+antall = int(input("Hvor mange Hipp?" ))
+for i in range(antall):
+    print("Hipp")
+print("Hurra!")
+ 
+# hvis brukeren skal bestemme seg for å slutte underveis:
+print("Slå Enter direkte etter Hipp for å legge til flere Hipp,")
+print("eller mellomrom så Enter for å avslutte: ")
+while input("Hipp") == "":
+    pass
+print("Hurra!")
+```
+
+Linje 1-5 viser en variant med **for**-løkke. Siden brukeren gir inn på forhånd antall Hipp som ønskes, er **antall repetisjoner kjent**, og **for-løkke enklest.**
+
+Linje 7-12 viser derimot en variant hvor brukeren bestemmer underveis i løkka om vi skal fortsette eller avslutte, da er det best med **while** siden **antall repetisjoner er ukjent.**
+
+ * brukeren velger å fortsette ved å trykke Enter direkte etter Hipp; dette vil gi en helt tom streng "" som resultat, slik at betingelsen i while vil  være sann. Så lenge den er sann, fortsetter løkka med å gjøre ny input() som gjør at ledeteksten "Hipp" kommer på skjermen på ny.
+ 
+ * brukeren velger å avslutte ved å skrive inn et blankt tegn og deretter slå Enter. Dette vil gi strengen " " som er forskjellig fra "", da blir betingelsen usann, og løkka avsluttes, og programmet går videre med å skrive "Hurra".
+
+I while-løkka er den eneste handlingen vi ønsker å utføre, den input() og sammenligning som står i betingelsen. Da trenger vi egentlig ingen innmat. Man er imidlertid nødt til å ha minst en setning inni ei løkke.
+Derfor **pass**, som er et beskyttet ord i Python for å gjøre ingenting. De fleste løkker vil ha mer kompliserte gjøremål og derfor også trenge en eller flere setninger inni som gjør noe.
+
+<br>
+
+### **for-løkke og range()**
+Som forklart over, er for-løkker egnet for tilfeller hvor antall repetisjoner er kjent. I oppgave (a) startet vi med kode:
+
+```python
+for i in range(3):
+    adj = input("Beskriv deg selv med et adjektiv? ")
+    print("Hah, du", adj + "!? Jeg er mye", adj + "ere!")
+print("Takk for nå!")
+```
+som repeterer 3 ganger. Du byttet deretter ut tallet 3 med en variabel for å kunne repetere et annet (men fortsatt kjent) antall ganger.
+
+I oppgave (a) ble løkkevariabelen i ikke brukt til noe inni selve løkka, den fins kun i for-setningen. Poenget i denne løkka er bare å telle opp at den kjører 3 ganger, i har ingen mening utover det.
+
+I andre tilfeller hvor vi bruker for-løkker kan løkkevariabelen ha en større betydning. Det er da viktig å forstå ikke bare at f.eks. range(3) fører til 3 repetisjoner, men å vite eksakt hvilken tallsekvens en range() representerer.
+Generelt gjelder følgende:
+
+* Hvis vi gir inn bare **ett tall** til range(), tolkes dette som sluttverdien. Startverdien er default 0. Sluttverdien selv er **ikke** med i sekvensen; det er "til", ikke "til og med". Eksempel:
+ * range(3) gir tallsekvensen 0, 1, 2. Løkka over kjører 3 ganger ved å ta først med i=0, så med i=1, så med i=2.
+ * range(5) gir 0, 1, 2, 3, 4
+ * range(0) gir en tom tallsekvens. Samme vil være tilfelle med negative tall; og en løkke for i in range(0): vil kjøre null ganger.
+* Hvis vi gir inn **to tall** til range(), tolkes dette som startverdi (fra og med) og sluttverdi (til, men ikke med). Eksempel:
+ * range(1, 7) gir 1, 2, 3, 4, 5, 6
+ * range(-3, 4) gir -3, -2, -1, 0, 1, 2, 3
+ * range(4, 3) gir en tom  tallsekvens (fordi sluttverdi er mindre enn startverdi)
+* Hvis vi gir inn tre tall til range(), er de to første start og slutt som før, det tredje er stegverdien. Default stegverdi er +1, så vi trenger kun angi den hvis vi ønsker noe annet enn +1. Eksempel:
+ * range(1, 10, 2) gir 1, 3, 5, 7, 9
+ * range(3, 11, 4) gir 3, 7 (men ikke 11, fordi det bare er til sluttverdien, ikke til og med)
+ * range(11, 3, -2) gir 11,  9,  7,  5 - det går altså an å bruke negative tall for stegverdi, da må startverdi være større enn sluttverdi for at løkka skal kjøre
+
+På basis av dette kan vi endre det lille programmet over til et som bruker variabelen i også inne i løkka, f.eks. (**Kopier og kjør gjerne koden selv, og endre på verdiene for å se hva som skjer**)
+```python
+for i in range(7, 14, 3):
+    adj = input("Beskriv deg selv med et adjektiv? ")
+    print("Hah, du", adj + "!? Jeg er", i, "ganger", adj + "ere!")
+print("Takk for nå!")
+```
+
+Her vil  koden fortsatt kjøre 3 ganger fordi den resulterende tallsekvensen har 3 elementer, men bruken av i inni løkka gjør programmet mer og mer skrytende. (Bare range(3) ville ikke ha sett like bra ut her, da sier den "0 ganger...", "1 ganger..." som ikke er særlig imponerende)
+
+Et annet eksempel (kopier og kjør gjerne koden):
+```python
+tall = int(input("Hvilket tall vil du se gangetabellen for? "))
+print(str(tall)+"-gangen går slik:")
+  
+for i in range(1, 11):
+    print(i * tall, end = "  ")
+  
+print("Takk for nå!")
+```
+Merk igjen at sluttverdien er til, men ikke med, så vi må gi 11 som sluttverdi i range() for at den skal få med 70 i resultatet, dersom vi vil se hele 7-gangen.
+
+end = "  " i print-setninga gjør at vi ikke får linjeskift mellom hvert tall men i stedet får dem etter hverandre med blanke mellom.
+
+Problemet kunne alternativt ha vært løst ved å bruke tallet det skal ganges med som stegverdi. Ulempen er at range-uttrykket blir litt mer komplisert, men samtidig slipper vi nå unna med en enkelt multiplikasjon utenfor løkka i stedet for å multiplisere i hver runde av løkka:
+
+```python
+tall = int(input("Hvilket tall vil du se gangetabellen for? "))
+print(str(tall)+"-gangen går slik:")
+ 
+for i in range(tall, tall * 10 + 1, tall):
+    print(i, end = "  ")
+ 
+print("Takk for nå!")
+```
+Dette programmet vil gi eksakt samme utskrift som det foregående, bare oppnådd på en litt annen måte; for 7-gangen vil nå 7 være startverdi og stegverdi, og 71 sluttverdi for range().
+
+<br>
+
+### **Evig while-løkke**
+
+Hvis en while-løkke ikke blir stoppet kan den kjøre evig. Et eksempel er en løkke som starter ***while True*** ; da vil betingelsen alltid være sann uansett hva som skjer inni løkka. Løkka vist under vil printe Jeg elsker ITGK! et uendelig antall ganger.
+
+Det vil vanligvis gå greit å stoppe programmet likevel, enten ved å trykke Ctrl-C eller ved å lukke vinduet der koden kjører... men **lagre for sikkerhets skyld alle filer du jobber med før du eksperimenterer med å kjøre en evig løkke**.
+
+Eksempel på en evig løkke:
+```python
+while True:
+    print("Jeg elsker ITGK!")
+```
+
+<br>
+
+<br>
+
+
+
+
+## OPPGAVER
+
+Alle deloppgaver besvares her: *[Intro til løkker.py](Intro%20til%20løkker.py)* !
+<br><br>
+I denne oppgaven skal du lære å skrive kode hvor handlinger repeteres ved hjelp av løkker.
+
+## a)
+
+Utdelt kode viser en for-løkke som repeterer 3 ganger. For hver runde blir brukeren bedt om å beskrive seg selv med et adjektiv, hvorpå maskinen disser brukeren ved å si at den er snillere, smartere etc.
+
+(Trikset her er bare å legge til "ere" bak adjektivet, så det vil ikke bli grammatisk korrekt for adjektiv som bøyes annerledes.)
+
+***Endre så koden slik at programmet først spør brukeren hvor mange repetisjoner som ønskes, og deretter utfører programmet med ønsket antall repetisjoner av løkka.***
+
+Eksempel på kjøring:
+
+
+*Hvor mange adjektiv vil du gi?* 2 <br>
+*Beskriv deg selv med et adjektiv?* snill <br>
+*Hah, du snill!? Jeg er mye snillere! <br>
+Beskriv deg selv med et adjektiv?* ond <br>
+*Hah, du ond!? Jeg er mye ondere! <br>
+Takk for nå!* <br>
+
+<br>
+
+**Hint:** <br>
+I stedet for tallet 3 i koden, må det stå en variabel for antall repetisjoner, og denne må i forkant leses inn fra bruker med input() og konverteres til et heltall.
+
+<br>
+
+## b)
+
+Utdelt kode under oppgave b, viser en while-løkke som utfører samme type brukerdialog som i (a), med 3 repetisjoner. Kjør den for å se hvordan det virker. **Endre programmet så løkka ikke kjører akkurat 3 ganger, men så mange ganger brukeren vil**, hvor brukeren kan bestemme dette underveis ved å gi et tomt svar (dvs. bare slå Enter) for å slutte. Da vil input()-setningen resultere i en tom streng, "".
+
+Eksempel på kjøring:
+
+*Slå Enter uten å skrive noe når du vil avslutte. <br>
+Beskriv deg selv med et adjektiv?* snill <br>
+*Hah, du snill!? Jeg er mye snillere! <br>
+Beskriv deg selv med et adjektiv?* smart <br>
+*Hah, du smart!? Jeg er mye smartere! <br>
+Beskriv deg selv med et adjektiv?* flittig <br>
+*Hah, du flittig!? Jeg er mye flittigere! <br>
+Beskriv deg selv med et adjektiv? <br>
+Takk for nå!*
+
+
+Fjerde gang spørsmålet om adjektiv ble stilt, slo brukeren her bare Enter uten å skrive inn noen tegn, da avsluttet løkka og programmet gikk videre ved å skrive "Takk for nå".
+
+
+<br>
+
+**Hint:** <br>
+I eksemplet måtte vi sette i = 0 før vi kan utføre testen i < 3, hvis ikke i hadde fått noen verdi, ville testen gi feilmelding. Likeledes, hvis du skal teste på at adj != "" må adj ha fått en verdi før denne testen skjer. Altså må du gjøre den første input til adj før while-løkka  starter.
+
+Inni while-løkka vil det da også være fornuftig å bytte om  rekkefølgen på print-setningen og input-setningen, fordi du allerede har gjort en input før løkka som du kan basere den første "Hah..."-responsen på.
+
+<br>
+
+## c)
+
+Ta igjen utgangspunkt i while-løkka med 3 repetisjoner i den utdelte koden. Endre programmet på følgende måte:
+
+Brukeren starter med 42 bokstaver til disposisjon. For hver runde skal programmet trekke fra antall bokstaver i det adjektivet som ble brukt.
+
+Løkka skal fortsette så lenge det fortsatt er bokstaver til disposisjon (dvs. dette tallet er større enn 0). 
+
+<br>
+
+**Eksempel på kjøring:**
+
+
+*Du har 42 bokstaver til disposisjon. <br>
+Beskriv deg selv med et adjektiv?* snill <br>
+*Hah, du snill!? Jeg er mye snillere! <br>
+Du har 37 bokstaver til disposisjon. <br>
+Beskriv deg selv med et adjektiv?* desperat <br>
+*Hah, du desperat!? Jeg er mye desperatere! <br>
+Du har 29 bokstaver til disposisjon. <br>
+Beskriv deg selv med et adjektiv?* kjempetørst <br>
+*Hah, du kjempetørst!? Jeg er mye kjempetørstere! <br>
+Du har 18 bokstaver til disposisjon. <br>
+Beskriv deg selv med et adjektiv?* megasupereffektiv <br>
+*Hah, du megasupereffektiv!? Jeg er mye megasupereffektivere!* <br>
+*Du har 1 bokstaver til disposisjon. <br>
+Beskriv deg selv med et adjektiv?* o <br>
+*Hah, du o!? Jeg er mye oere! <br>
+Takk for nå!*<br>
+
+___
+<br>
+
+
+
+I siste linje, hvor det bare er 1 bokstav til disposisjon, er brukeren lojal her og skrive bare en bokstav - men du behøver ikke lage programmet slik at det sikrer dette... det er ok om brukeren skriver et lenger ord den siste gangen, så lenge brukeren ikke får lov til å skrive nye ord når antall bokstaver til disposisjon er blitt <= 0.
+
+**Hint:** <br>
+I stedet for tellevariabelen i som starter på 0, og med betingelse < 3 i while-setninga, må du nå ha en variabel som starter på 42, og hvor lengden av hvert nye ord trekkes fra i løkka. Lengde kan finnes med funksjonen len(), dvs. len(adj) gir lengden til strengen adj. Testen i while-setninga må også tilpasses til det vi nå er ute etter, nemlig å fortsette så lenge det fremdeles er bokstaver til disposisjon.
+
+<br>
+
+## d)
+
+I utdelt kode er de to første for-løkkene ferdige og gir riktig utskrift i forhold til den forklarende teksten i print-setningene.
+
+De tre neste er ikke ferdige. Koper koden og bytt ut `range(0)` i disse tre (også merket med #TODO) slik at for-løkkene gir tallsekvenser som passer med det som forklares i print-setningene.
+
+<br>
+
+## e)
+
+Lag et program som skriver ut tallene 1 til 5 ved bruk av en for-løkke.
+
+<br>
+
+## f)
+
+Lag et program som teller nedover fra 15 til 1 ved hjelp av en for-løkke. Skriv ut alle tallene.
+
+
+
+
+
diff --git "a/Oving3/Lett/Intro til l\303\270kker.py" "b/Oving3/Lett/Intro til l\303\270kker.py"
new file mode 100644
index 0000000000000000000000000000000000000000..448f2441bb8decb0be03b52b711181395479bd8d
--- /dev/null
+++ "b/Oving3/Lett/Intro til l\303\270kker.py"	
@@ -0,0 +1,89 @@
+
+print("INTRODUKSJON TIL LØKKER!")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+#Endre koden slik at den kjører som beskrevet i oppgaveteksten.
+
+for i in range(3):
+    adj = input("Beskriv deg selv med et adjektiv? ")
+    print("Hah, du", adj + "!? Jeg er mye", adj + "ere!")
+print("Takk for nå!")
+
+
+print("________________________ \n")
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
+#Endre koden slik at den kjører som beskrevet i oppgaveteksten.
+
+i = 0
+while i < 3:
+    adj = input("Beskriv deg selv med et adjektiv? ")
+    print("Hah, du", adj + "!? Jeg er mye", adj + "ere!")
+    i += 1  # øker i med 1
+print("Takk for nå!")
+
+
+print("________________________ \n")
+
+
+
+print("Oppgave c)")
+#TODO løs oppgave c her:
+#Endre koden slik at den kjører som beskrevet i oppgaveteksten.
+
+i = 0
+while i < 3:
+    adj = input("Beskriv deg selv med et adjektiv? ")
+    print("Hah, du", adj + "!? Jeg er mye", adj + "ere!")
+    i += 1  # øker i med 1
+print("Takk for nå!")
+
+
+print("________________________ \n")
+
+
+print("Oppgave d)")
+#TODO løs oppgave a her:
+#Endre for-løkke 3-5 slik at de fungerer i hendholde til beskrivelsen i printsetningen.
+
+print("Oddetallene fra 1 til 20:")
+for number in range(1, 20, 2):
+    print(number, end = " ")
+print()
+  
+print("Tallene i 3-gangen mellom 12 og 25:")
+for number in range(12, 25, 3):
+    print(number, end = " ")
+print()
+  
+print("Tallene i 5-gangen mellom 20 og 81:")
+for number in range(0): #TODO
+    print(number, end = " ")
+print()
+  
+print("Tallsekvensen 48, 56, 64, 72, 80")
+for number in range(0): #TODO
+    print(number, end = " ")
+print()
+  
+print("Telle baklengs fra 100 til 80, med intervall på -3, dvs. 100, 97, ...:")
+for number in range(0): #TODO
+    print(number, end = " ")
+print()
+
+
+print("________________________ \n")
+
+print("Oppgave e)")
+#TODO løs oppgave b her:
+
+
+
+
+print("________________________ \n")
+
+print("Oppgave f)")
+#TODO løs oppgave c her:
diff --git "a/Oving3/Lett/Kodeforst\303\245else.md" "b/Oving3/Lett/Kodeforst\303\245else.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1c31fa7718dc74a69c4bdf4f1fc5daf7f2335569
--- /dev/null
+++ "b/Oving3/Lett/Kodeforst\303\245else.md"
@@ -0,0 +1,86 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Kodeforståelse
+
+**Læringsmål:**
+
+* Tolke kode
+
+**OPPGAVER**
+
+I disse oppgavene skal du ikke selv skrive noe kode, men derimot analysere og tenke deg fram til hva kodesnuttene skriver ut når de kjøres. Oppgavene besvares ved å skrive hva kodesnuttene gjør som en kommentar i python-fila oppgitt under. 
+
+Alle deloppgaver besvares her: *[Kodeforståelse.py](Kodeforståelse.py)* !
+<br><br>
+Ca. 20% av eksamen er kodeforståelse, så se på dette som god trening! 
+
+## a)
+Hva skrives ut i koden under?
+```python
+a=345
+b=''
+while a or b=='':
+    b=str(a%2)+b
+    a=a//2
+print(b)
+```
+
+<br>
+
+## b)
+ Hva skrives ut i koden under?
+
+```python
+for x in range(0, 10, 2):
+    print(x, end='')
+    if x%4==0:
+        print( ": Dette tallet går opp i 4-gangern")
+    else:
+        print()
+```
+     
+**Tips:** <br>
+`end=''` gjør at det neste som printes ikke printes en linje under, men at det fortsetter på samme linje.
+
+<br>
+
+## c)
+Hva skrives ut i koden under?
+
+```python
+i = 1
+while i<10:
+    i = i*2
+print(i)
+```
+
+<br>
+
+## d)
+Hva skrives ut i koden under?
+```python
+i = 1
+j = 3
+while j>0:
+    i = i*2
+    j = j - 1
+print(i)
+```
+
+<br>
+
+
+## e) 
+Hva skrives ut i koden under?
+
+```python
+i = 5
+for x in range(i):
+    for y in range(x+1):
+        print("*", end="")
+    print()
+```
+    
+Her er det en dobbel løkke, så dette er nok nytt for mange. Prøv likevel! Hvordan fungerer egentlig en løkke i en løkke? Se side 176 i Starting Out with Python.
+
diff --git "a/Oving3/Lett/Kodeforst\303\245else.py" "b/Oving3/Lett/Kodeforst\303\245else.py"
new file mode 100644
index 0000000000000000000000000000000000000000..146b22b460f2e6dc88dcbf1df7bc56af61a452fb
--- /dev/null
+++ "b/Oving3/Lett/Kodeforst\303\245else.py"
@@ -0,0 +1,21 @@
+# Besvar kodeforståelses oppgavene her:
+
+'''
+Her kan du skive tekst, fordi området er kommentert ut.
+
+Oppgave a:
+
+
+Oppgave b:
+
+
+Oppgave c:
+
+
+Oppgave d:
+
+
+Oppgave e:
+
+
+'''
\ No newline at end of file
diff --git "a/Oving3/Lett/Mer om l\303\270kker.md" "b/Oving3/Lett/Mer om l\303\270kker.md"
new file mode 100644
index 0000000000000000000000000000000000000000..84a9268a4d25a2738cc6ee5327e802862ca4ebc3
--- /dev/null
+++ "b/Oving3/Lett/Mer om l\303\270kker.md"	
@@ -0,0 +1,122 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Mer om løkker - oppsamlingsløkker
+
+**Læringsmål:**
+
+* Løkker
+
+**Starting Out with Python:**
+
+* Kap. 4.2-4.3
+
+<BR>
+
+## INTRODUKSJON
+
+### **Oppsamlingsløkker**
+
+Ofte brukes løkker til å samle opp et resultat (f.eks. en tallverdi) som vi er interessert i å finne. Et enkelt eksempel på en oppsamlingsløkke, er følgende som summerer alle tallene fra og med 1 til og med 100:
+
+```python
+summen = 0
+for i in range(1, 101):
+    summen += i       # summen = summen + i
+print("Summen av tallene 1-100:", summen)
+```
+
+range() må ha 101 som sluttverdi hvis tallet 100 skal være med i summen, fordi den er til, men ikke med. Variabelen **summen** er den som brukes til å samle opp resultatet underveis. Det kunne ha vært fristende å kalle variabelen bare sum, men dette er navnet på en standardfunksjon i Python og dermed ikke lurt å bruke som variabelnavn. Merk deg at summen må defineres **før** løkka, og der gis verdien 0 (fordi vi ikke har summert inn noen av tallene ennå). Dette fordi vi inni løkka ønsker å utføre summen = summen + 1 (som kortere kan skrives summen += 1), og et slikt uttrykk hvor summen også fins på høyre side av = kan bare fungere hvis den allerede har fått en verdi. Måten dette programmet funker på, er altså at vi starter med å gi summen verdi 0. Så begynner løkka, med i = 1, og vi legger til i (dvs. 1) til summen som da blir 1. Så blir i 2, som legges til summen, som nå blir 3. Så i=3, summen = 6. Så i=4, summen = 10, osv. Siste gang løkka kjøres er i=100 og summen blir 5050, så avslutter løkka og vi printer resultatet på skjermen.
+
+Tilsvarende hvis vi skulle gange sammen alle tallene 1-20:
+
+```python
+produktet = 1
+for i in range(1, 20):
+    produktet *= i         # produktet = produktet * i
+print("Produktet av tallene 1-20:", produktet)
+```
+
+Strukturelt er dette temmelig likt - en viktig forskjell er at når vi skal gange, blir riktig startverdi 1 (som er det tallet som ikke påvirker et produkt) mens det var 0 for summering.
+
+Til slutt et lite eksempel der det passer bedre med while enn med for, fordi vi ikke aner antall repetisjoner:
+
+```python
+print("Skriv inn ett og ett positivt heltall.")
+print("For å avslutte, skriv et negativt tall (dette telles ikke med).")
+tall = int(input("Tall: "))
+storst = tall  # første tall er størst, inntil annet bevist
+antall = 0
+  
+while tall >= 0:
+    if tall > storst:
+        storst = tall
+    antall += 1
+    tall = int(input("Tall: "))
+  
+print("Du skrev inn", antall, "tall.")
+print("Det største var", storst)
+```
+
+Her skriver brukeren inn en serie tall fra tastaturet - og gir et negativt tall for å avslutte - og programmets oppgave til slutt er å kunne fortelle hvor mange tall som ble skrevet inn (bortsett fra det negative), og hva som var det største av tallene. For å telle opp antallet, har vi variabelen antall som settes til 0 før løkka, og deretter økes med 1 for hver runde av løkka. For å finne det største tallet, antar vi før løkka at det første tallet også er det største. (Vi må uansett lese det første tallet før løkka, for at while-testen skal funke). Deretter tester vi for hver runde av løkka om det sist innleste tallet er større enn det som var størst hittil, i så fall gis variabelen storst verdien til dette nye tallet i stedet. Variabelen storst vil dermed til en hver tid inneholde den største verdien hittil.
+
+## OPPGAVER 
+Alle deloppgaver besvares her: *[Mer om løkker.py](Mer%20om%20løkker.py)* !
+<br><br>
+
+I denne oppgaven ser vi spesielt på løkker som samler opp et resultat underveis.
+
+
+## a)
+Lag et program som ved hjelp av en løkke ber brukeren om å taste inn 7 heltall, som vist i eksemplet på kjøring under. Til slutt skal programmet skrive ut hva summen av tallene ble.
+
+*Eksempel på kjøring:*
+
+*Skriv inn et heltall:* 6 <br>
+*Skriv inn et heltall:* 4 <br>
+*Skriv inn et heltall:* 7 <br>
+*Skriv inn et heltall:* 3 <br>
+*Skriv inn et heltall:* 2 <br>
+*Skriv inn et heltall:* 456 <br>
+*Skriv inn et heltall:* 99 <br>
+*Summen av tallene ble 577* <br>
+
+
+**Hint:**<br>
+Du vil trenge en variabel til å summere inn ett og ett nytt tall for hver runde av løkka. Husk at denne variabelen må være opprettet og gitt en passende startverdi før løkka, ellers vil du ikke klare å bruke den i løkka.
+
+<br>
+
+## b)
+
+Lag et program som multipliserer sammen alle tallene fra 1,2,3,... og avslutter når produktet er større enn 1000.
+
+**Hint:**<br>
+Du vet ikke på forhånd hvor lenge du kan multiplisere tallene før du får et produkt større enn 1000, så her kan det være lurt å bruke en while-løkke med produkt mindre enn 1000 som betingelse.
+
+<br>
+
+## c)
+
+Lag et program som stiller brukeren det samme spørsmålet, om og om igjen, helt til det korrekte svaret blir skrevet. Da skal programmet fortelle hvor mange forsøk som ble brukt. Eksempel på kjøring vist nedenfor, men du kan godt bytte ut med et spørsmål med annen tematikk, noe du selv er interessert i. Se **Hint** dersom du står fast.
+
+**Eksempel på kjøring:**
+
+
+*Hva heter hovedstaden til Niue?* Niue City <br>
+*Det var feil, prøv igjen. <br>
+Hva heter hovedstaden til Niue?* Niuania <br>
+*Det var feil, prøv igjen. <br>
+Hva heter hovedstaden til Niue?* Apia <br>
+*Det var feil, prøv igjen. <br>
+Hva heter hovedstaden til Niue?* Alofi <br>
+*Korrekt!! Du brukte 4 forsøk.* <br>
+
+<br>
+
+**Hint:**<br>
+Du vet ikke hvor mange ganger brukeren svarer feil så det kan være lurt med en while-løkke hvor betingelsen er at brukerens svar != riktig svar.
+
+
+
+
diff --git "a/Oving3/Lett/Mer om l\303\270kker.py" "b/Oving3/Lett/Mer om l\303\270kker.py"
new file mode 100644
index 0000000000000000000000000000000000000000..3bb8692f1a5f66ed498fd8fff0fb9cd2154a939e
--- /dev/null
+++ "b/Oving3/Lett/Mer om l\303\270kker.py"	
@@ -0,0 +1,14 @@
+print("Mer om løkker!")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
+
+
+
+print("Oppgave c)")
+#TODO løs oppgave c her:
diff --git "a/Oving3/Lett/N\303\270stede l\303\270kker.md" "b/Oving3/Lett/N\303\270stede l\303\270kker.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d0706a84e8cbf01119c9055b561aade708b422a2
--- /dev/null
+++ "b/Oving3/Lett/N\303\270stede l\303\270kker.md"	
@@ -0,0 +1,123 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Intro til nøstede løkker
+
+**Læringsmål:**
+
+* Nøstede løkker
+
+**Starting out with python:**
+
+* Kap. 4.7
+
+
+## INTRODUKSJON
+
+### **Nøstede løkker**
+Nøstede løkker vil si løkker som er inni andre løkker. Et eksempel på en nøstet løkke er en dobbel løkke, som vil si at det er en løkke inni en annen løkke. Doble løkker brukes mye i programmering, typisk når man skal løse problemer som på en eller annen måte er todimensjonale, f.eks. knyttet til matriser eller todimensjonale tabeller med tall. Todimensjonal her kan bety rent visuelt (f.eks. at man skal tegne noe på en skjerm og må oppdatere fargen i hvert punkt i et rutenett av piksler), men behøver ikke å ha noen visuell betydning. Det kan være snakk om dimensjoner av informasjon på en mer abstrakt måte. F.eks. kan de to dimensjonene være tall og verdier i kortstokken, vi kan da generere en hel kortstokk ved en dobbel løkke som følger:
+
+```python
+for farge in ['♠', '♣', '♥', '♦']:
+    for verdi in ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']:
+        print(farge+verdi, end=" ")
+    print()
+```
+
+Den innerste løkka går 13 runder hver gang den kjører fordi det er 13 elementer i sekvensen som gis til for-løkka. Den printer de 13 kortene i en farge; end=" " i print-setninga gjør at vi ikke skifter linje men bare setter en blank mellom hvert kort.
+
+print() nederst tilhører den ytre løkka (merk innrykk), denne sørger for at vi skifter linje etter hver rekke. Den ytre løkka går 4 ganger, en for hver farge i kortstokken
+
+
+
+<br>
+
+## OPPGAVER
+Alle deloppgaver besvares her: *[Nøstede løkker.py](Nøstede%20løkker.py)* !
+<br><br> 
+
+
+I denne oppgaven skal du lære hvordan vi kan benytte oss av en løkke inne i en annen løkke.
+
+## a)
+
+**Eksempel på nøstet løkke:**
+
+```python
+for x in range(5):
+    for y in range(3):
+        print("Jeg elsker ITGK! ", end=" ")
+    print()
+```
+
+Koden over vil skrive ut “Jeg elsker ITGK!” tre ganger ved siden av hverandre fem ganger nedover.
+
+Kopier koden i eksemplet "Jeg elsker ITGK!" over og kjør programmet. Denne utskriften trenger man strengt tatt ikke dobbel løkke for å få til; selve utskriften gir riktig nok et todimensjonalt inntrykk, men siden den underliggende informasjonen ikke er todimensjonal men derimot konstant (samme utskrift "Jeg elsker ITGK!" i alle tilfeller), er det også greit mulig å klare dette med enkel løkke, eller helt uten løkker, som følger:
+
+```python
+# Løsning med enkel løkke:
+for x in range(5):
+    print("Jeg elsker ITGK!  Jeg elsker ITGK!  Jeg elsker ITGK!")
+
+# Løsning uten løkker; "\n" er tegnet for linjeskift (newline på engelsk)
+print((("Jeg elsker ITGK!  " * 3) + "\n") * 5)
+```
+
+Hvis vi derimot endrer litt på kravene til programmet, så det skal handle om flere studenter enn "Jeg" og flere emner enn "ITGK", vil vi ha et genuint todimensjonalt problem (én dimensjon er studenter, en annen emner) hvor dobbel løkke vil være klart enkleste løsning. **Din oppgave: kopier og endre programmet så det gir utskrift som vist nedenfor**. Fra forrige oppgave skal altså Jeg byttes ut med Stud &lt;nummer>, og ITGK skal byttes ut med Emne &lt;nummer>. Brukeren skal angi ønsket antall for både studenter og emner, 4 og 3 er bare eksempler.
+
+**Eksempel på kjøring:** <br>
+*Hvor mange studenter?* 4 <br>
+*Hvor mange emner?* 3 <br>
+*Stud 1 elsker Emne 1 ; Stud 1 elsker Emne 2 ; Stud 1 elsker Emne 3 ; <br>
+Stud 2 elsker Emne 1 ; Stud 2 elsker Emne 2 ; Stud 2 elsker Emne 3 ; <br>
+Stud 3 elsker Emne 1 ; Stud 3 elsker Emne 2 ; Stud 3 elsker Emne 3 ; <br>
+Stud 4 elsker Emne 1 ; Stud 4 elsker Emne 2 ; Stud 4 elsker Emne 3 ;* <br>
+
+<br>
+
+**EKSTRA UTFORDRING** <br> (ikke nødvendig for å få godkjent (a)): For å gjøre programmet litt mindre tørt og abstrakt, kan du prøve å endre så det skriver fornavn på personer i stedet for "Stud x", og navn på faktiske emner i stedet for Emne y - jfr eksempel med kortstokk i introduksjonen "Nøstede løkker" øverst i denne oppgaven. For å gjøre det mindre forutsigbart, kan du dessuten bruke funksjonen random() for å generere tilfeldige tall for hver runde av løkka, og ha en if-setning for å velge verb basert på verdien av dette. F.eks. "elsker" bare hvis tallet ble > 0.9, og gradvis litt mer beskjedne verb til lavere tallverdien var.
+
+## b)
+
+Bruk en dobbel løkke til å skrive ut en liste over alle klokkeslett i løpet av et døgn på en fin måte. Du trenger kun å tenke på timer og minutter. Klokkeslettene skal gå fra 0:0 til 23:59 som vist nedenfor.
+
+Eksempel på kjøring av kode:
+
+
+*0:0 <br>
+0:1 <br>
+0:2* <br>
+. <br>
+. <br>
+.  # Alle klokkeslett i mellom her skal skrives ut <br>
+. <br>
+. <br>
+*23:58 <br>
+23:59*
+
+<br>
+
+## c)
+
+Bruk doble løkker til å skrive ut alle tallene i den lille gangetabellen, dvs. lag to for-løkker opp til 11 og multipliser variabelen x fra den ene løkken med variabelen y fra den andre løkken og skriv det ut i den innerste løkken. Du trenger ikke å tenke på formatet til utskriften.
+
+Eksempel på kjøring:
+
+1 <br>
+2 <br>
+3 <br>
+4 <br>
+5 <br>
+. <br>
+. <br>
+. <br>
+60 <br>
+70 <br>
+80 <br>
+90 <br>
+100 <br>
+
+<br>
+
+**Bonus**: <br>
+Forsøk å legg inn en tom print() etter den innerste løkken i c) har kjørt (dvs. på samme innrykk som innerste for, men nedenfor print-funksjonen som skriver ut tallene). Legg også til end = '  ' på slutten av print-funksjonen som printer ut tallene. Ser du nå at det ligner mer på en gangetabell?
\ No newline at end of file
diff --git "a/Oving3/Lett/N\303\270stede l\303\270kker.py" "b/Oving3/Lett/N\303\270stede l\303\270kker.py"
new file mode 100644
index 0000000000000000000000000000000000000000..bfb6ff3fe546a3389fc2aaaa4d4bd62b8ee5f447
--- /dev/null
+++ "b/Oving3/Lett/N\303\270stede l\303\270kker.py"	
@@ -0,0 +1,15 @@
+
+print("Nøstede løkker!")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
+
+
+
+print("Oppgave c)")
+#TODO løs oppgave c her:
diff --git a/Oving3/Middels/Alternerende sum.md b/Oving3/Middels/Alternerende sum.md
new file mode 100644
index 0000000000000000000000000000000000000000..bfcc593a1edd5969e08910d2a78c701f7b39b1ca
--- /dev/null
+++ b/Oving3/Middels/Alternerende sum.md	
@@ -0,0 +1,34 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+
+# Alternerende sum
+
+**Læringsmål:**
+
+* Løkker
+
+**Starting Out with Python:**
+
+* Kap. 4.2-4.3
+
+**OPPGAVER**
+
+Alle deloppgaver skal besvares her: *[Alternerende sum.py](Alternerende%20sum.py)* !
+
+I denne oppgaven skal du ved hjelp av løkker summere sammen tall, basert på brukerinput. 
+
+## a)
+Skriv et program som leser inn et heltall n fra bruker og legger sammen tallserien under.
+
+**1<sup>2</sup> - 2<sup>2</sup> + 3<sup>2</sup> - 4<sup>2</sup> + 5<sup>2</sup> - . . . +/- n<sup>2**
+
+Legg merke til at alle partallene har negativt fortegn og alle oddetallene har positivt fortegn. Husk at navnet på variabelen din ***ikke*** kan være **sum**, ettersom dette er navnet på en funksjon i python. Husk også at range() bare går til et tall og ikke til og med.
+
+## b)
+Skriv et nytt program slik at det avslutter iterasjonen **før** summen av tallene er større enn det positive heltallet k. Dette vil si at resultatet som skal skrives ut er summen på siste ledd før summen går over tallet k.
+
+Hold styr på hvor mange ledd fra tallserien som er brukt i summen og skriv dette ut sammen med resultatet.
+
+
+
diff --git a/Oving3/Middels/Alternerende sum.py b/Oving3/Middels/Alternerende sum.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ded323da88cae408839c6b999eed3c2cf5b103d
--- /dev/null
+++ b/Oving3/Middels/Alternerende sum.py	
@@ -0,0 +1,10 @@
+print("Alternerende sum!")
+print("______________________ \n")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
diff --git "a/Oving3/Middels/Doble l\303\270kker.md" "b/Oving3/Middels/Doble l\303\270kker.md"
new file mode 100644
index 0000000000000000000000000000000000000000..45e50891e045ba6cbe7ec8008df413a10386c675
--- /dev/null
+++ "b/Oving3/Middels/Doble l\303\270kker.md"	
@@ -0,0 +1,99 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Doble løkker - til dels vanskelig
+
+**Læringsmål:**
+
+* Nøstede løkker
+
+**Starting Out with Python:**
+
+* Kap. 4.7
+
+## OPPGAVER
+
+Alle deloppgaver skal besvares her: *[Doble løkker.py](Doble%20løkker.py)* !
+
+## a)
+Skriv et program som benytter seg av en dobbel for-løkke og skriver ut følgende:
+
+
+>1 <br>
+1 2 <br>
+1 2 3 <br>
+1 2 3 4 <br>
+1 2 3 4 5 <br>
+
+<br>
+
+## b)
+Skriv et program som benytter seg av en dobbel for-løkke og skriver ut følgende:
+
+```
+X X
+X  X
+X   X
+X    X
+X     X
+```
+
+<br>
+
+## c)
+
+Skriv et program som lar brukeren gi som input fra tastaturet et positivt heltall. Programmet skal da skrive ut primtallsfaktoriseringen til tallet, eller evt. at det allerede er et primtall. Eksempel på et par kjøringer:
+
+>*Skriv inn et positivt heltall*: 2 <br>
+2 er et primtall
+
+>*Skriv inn et positivt heltall:* 38 <br>
+38 = 2*19
+
+>*Skriv inn et positivt heltall:* 1000 <br>
+1000 = 2*2*2*5*5*5
+
+>*Skriv inn et positivt heltall:* 73727 <br>
+73727 er et primtall
+
+>*Skriv inn et positivt heltall:* 123456789 <br>
+123456789 = 3*3*3607*3803
+
+
+Dette er et problem som peker i retning av dobbel løkke fordi samme tall kan være faktor flere ganger, som f.eks. i `1000  = 2*2*2*5*5*5`. Den ytre løkka trengs for å prøve ut stadig nye faktorer, den indre for å prøve om igjen samme faktor, i tilfelle den inngår flere ganger i tallet.
+
+<br>
+
+## d)
+Du skal hjelpe frøken Bernsen med å lage et enkelt program hvor elevene kan øve seg på den lille gangetabellen. Eleven skal stadig møte på nye gangestykker, og får 3 forsøk på hvert spørsmål. Benytt deg av randint(0,9) for å få tilfeldige tall for hvert gangestykke. Programmet skal fortsette frem til eleven gir beskjed om noe annet.
+
+**Eksempel på kjøring:**
+
+
+>*Hva blir 2 * 0?* 0 <br>
+*Gratulerer, det er helt riktig! <br>
+Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei:* 1 <br><br>
+*Hva blir 8 * 6?* 42 <br>
+*Dessverre ikke riktig. Du har 2 forsøk igjen. <br>
+Hva blir 8 * 6?* 48 <br>
+*Gratulerer, det er helt riktig! <br>
+Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei:* 1 <br><br>
+*Hva blir 8 * 9?* 73 <br>
+*Dessverre ikke riktig. Du har 2 forsøk igjen. <br>
+Hva blir 8 * 9?* 74 <br>
+*Dessverre ikke riktig. Du har 1 forsøk igjen. <br>
+Hva blir 8 * 9?* 78 <br>
+*Dessverre ikke riktig. Du har 0 forsøk igjen. <br>
+Dessverre klarte du ikke dette regnestykket, men vent så får du et nytt et:) <br>
+Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei:* 1 <br> <br>
+*Hva blir 9 * 1?* 9 <br>
+*Gratulerer, det er helt riktig! <br>
+Er det ønskelig med flere spørsmål? Skriv 1 for ja og 0 for nei:* 0 <br>
+
+<br>
+
+## e) frivillig
+
+Du skal endre programmet ditt fra d) slik at eleven først får veldig lette gangestykker ved å bruke randint(0,5) (fra random-biblioteket). Dersom eleven klarer å svare rett på 5 spørsmål på rad (eleven kan fremdeles bruke 3 forsøk), skal vanskelighetsgraden øke ved å bruke randint(0,10). Dette intervallet skal altså øke med 5 for hver gang eleven svarer korrekt på 5 spørsmål på rad. 
+
+
diff --git "a/Oving3/Middels/Doble l\303\270kker.py" "b/Oving3/Middels/Doble l\303\270kker.py"
new file mode 100644
index 0000000000000000000000000000000000000000..e28bc256f4f15cbcc6458b95d064de986ecd265a
--- /dev/null
+++ "b/Oving3/Middels/Doble l\303\270kker.py"	
@@ -0,0 +1,20 @@
+print("Doble løkker!")
+print("______________________ \n")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
+
+
+
+print("Oppgave c)")
+#TODO løs oppgave c her:
+
+
+
+print("Oppgave d og e(frivillig))")
+#TODO løs oppgave d og e(frivillig) her:
\ No newline at end of file
diff --git a/Oving3/Middels/Fibonacci.md b/Oving3/Middels/Fibonacci.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc49c0f52e6b6af7ee3ec5475a5da742fb1b75f4
--- /dev/null
+++ b/Oving3/Middels/Fibonacci.md
@@ -0,0 +1,39 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Fibonacci
+
+**Læringsmål:**
+
+* Løkker
+
+**Starting Out with Python:**
+
+* Kap. 4.3
+
+<br>
+
+## OPPGAVER
+
+Alle deloppgaver skal besvares her: *[Fibonacci.py](Fibonacci.py)* !
+<br>
+
+I denne oppgaven skal du bruke løkker til å regne ut fibonaccitall.  
+Fibonaccitallene er definert som følger: 
+
+* **f(0)=0**
+* **f(1)=1**
+* **f(k)=f(k−1)+f(k−2)**
+
+Det vil si at de to første tallene i rekken er 0 og 1, deretter er det neste tallet summen av de to forrige tallene. Starten på rekken ser derfor slik ut: 0 1 1 2 3 5 8 13 ...
+
+## a) 
+Lag et program som regner ut og returnerer det k-te fibonaccitallet f(k) ved hjelp av iterasjon. Har du gjort det rett skal det 10-ende Fibonaccitallet bli 34. **Husk at det første tallet i rekken er tall nummer 0**
+
+## b)
+Skriv om programmet i deloppgave a) slik at det også regner ut summen av alle fibonaccitallene. Har du gjort det rett det rett skal summen av Fibonaccitallene opp til 10 bli 88.
+
+## c) Frivillig, vanskeligere oppgave
+Modifiser programmet til å returnere en liste med alle fibonaccitallene opp til og med f(k).
+
+Husk å skrive ut svarene til skjerm.
\ No newline at end of file
diff --git a/Oving3/Middels/Fibonacci.py b/Oving3/Middels/Fibonacci.py
new file mode 100644
index 0000000000000000000000000000000000000000..def7e17c77e9c99edd2603dbf176a43b8831053b
--- /dev/null
+++ b/Oving3/Middels/Fibonacci.py
@@ -0,0 +1,15 @@
+print("Fibonacci!")
+print("______________________ \n")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
+
+
+
+print("Oppgave c)")
+#TODO løs oppgave c her (FRIVILLIG):
diff --git a/Oving3/Middels/Geometrisk rekke.md b/Oving3/Middels/Geometrisk rekke.md
new file mode 100644
index 0000000000000000000000000000000000000000..da65c4738836b394a1058b81be2103ab6169a093
--- /dev/null
+++ b/Oving3/Middels/Geometrisk rekke.md	
@@ -0,0 +1,61 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Geometrisk rekke
+
+**Læringsmål:**
+
+* Løkker
+
+**Starting Out with Python:**
+
+* Kap. 4.2-4.3
+
+<br>
+
+
+## OPPGAVER
+
+Alle deloppgaver besvares her: *[Geometrisk rekke.py](Geometrisk%20rekke.py)* !
+
+
+En geometrisk rekke er en sum som kan skrives på formen under: 
+
+$\sum_{i=0}^{n}r^{i}=r^{0}+r^{1}+r^{2}+r^{3}+\cdot \cdot \cdot +r^{n}$  
+$r \in (-1,1)$
+
+
+## a)
+
+Lag et program som summerer en geometrisk rekke fra 0 til n ved hjelp av en while løkke.
+
+Sjekk: r = 0.5 og n = 4 skal gi sum = 1.9375
+
+<br>
+
+## b)
+
+Skriv om programmet ditt slik at løkken avsluttes når din sum er innenfor en toleranse tol til grenseverdien av summen.
+
+Test dette med tol = 0.001, r = 1/2, som vist i eksempelet under.
+
+**Hint:** <br>
+Summen til en geometrisk rekke er $\frac{1-r^{n+1}}{1-r}$
+. For rekken i b) blir grenseverdien $\frac{1}{1-r}$ = 2.
+
+<br>
+
+## c)
+
+La programmet gi ut antall iterasjoner som trengs for å være innenfor toleransen. Gi også ut den virkelige differansen mellom summen du fant og grenseverdien.
+
+<br>
+
+**Eksempel på kjøring av kode a, b, og c:**
+
+a)  
+*Summen av rekken er 1.9375*
+ 
+b & c)  
+*For å være innenfor toleransegrensen: 0.001 , kjørte løkken  11 ganger.  <br>
+Differansen mellom virkelig og estimert verdi var da 0.0009765625*
diff --git a/Oving3/Middels/Geometrisk rekke.py b/Oving3/Middels/Geometrisk rekke.py
new file mode 100644
index 0000000000000000000000000000000000000000..161f10e6f69dc7427808a1b8941d2c2f5b897908
--- /dev/null
+++ b/Oving3/Middels/Geometrisk rekke.py	
@@ -0,0 +1,15 @@
+print("Geometrisk rekke!")
+print("______________________ \n")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
+
+
+
+print("Oppgave c og d)")
+#TODO løs oppgave c og d her:
\ No newline at end of file
diff --git a/Oving3/Middels/Hangman.md b/Oving3/Middels/Hangman.md
new file mode 100644
index 0000000000000000000000000000000000000000..b37c50aaf57b8716e100054de66942ec79a2a1e2
--- /dev/null
+++ b/Oving3/Middels/Hangman.md
@@ -0,0 +1,74 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Hangman
+
+**Læringsmål:**
+
+* Betingelser
+* While-løkker
+
+**Starting Out with Python:**
+
+* Kap. 3.4 
+* Kap. 4.2
+
+<br>
+
+## OPPGAVER
+
+Alle deloppgaver besvares her: *[Hangman.py](Hangman.py)* !
+
+
+Kapittel fire introduserer repetisjonsstrukturer. Dette er en mye brukt programmeringsteknikk som brukes når et program skal utføre den samme oppgaven mange ganger etter hverandre. I denne oppgaven bruker vi en enkel while-løkke for å lage et hangman-spill i Python. 
+
+Lag et program som tar inn et ord (tekststreng) og antall liv (heltall) fra en bruker, og lar en annen (eller samme) bruker gjette på bokstaver i ordet. 
+
+## a)
+Start med å hente inn data fra bruker. Lagre dette i to variabler "hemmelig_ord" og "antall_liv".
+
+<br>
+
+## b)
+Under vises skallet til en while-løkke som kjører evig. Din oppgave er å utvide programmet fra **a)** ved å fylle inn manglende logikk inne i løkken. Ting som må gjøres er:
+
+* Hent inn en bokstav fra bruker
+* Sjekk om denne er i det hemmelige ordet 
+  * Trekk fra et liv dersom brukeren tipper feil
+ * Hvis brukeren ikke har flere liv skal løkken avsluttes (HINT: bruk "break" for å avslutte en løkke) 
+
+```python
+while True:
+    # do something
+```
+
+PS: Husk å skrive ut resultatet til brukeren. 
+
+<br>
+
+**Eksempel på kjøring av kode:**
+
+
+*Skriv inn det hemmelige ordet:* hemmelig <br>
+*Hvor mange forsøk får brukeren?* 2 <br>
+*Gjett på én bokstav i ordet:* f <br>
+*Bokstaven f er ikke i ordet. <br>
+Du har  1 liv igjen, prøv på nytt. <br>
+Gjett på én bokstav i ordet:* h <br>
+*Stemmer, bokstaven er i ordet <br>
+Gjett på én bokstav i ordet:* e <br>
+*Stemmer, bokstaven er i ordet <br>
+Gjett på én bokstav i ordet:* r <br>
+*Bokstaven r er ikke i ordet. <br>
+Du har ingen liv igjen.* <br>
+
+
+<br>
+
+## c) FRIVILLIG vanskeligere oppgave
+Fyll inn logikk for å fullføre spillet. Ting som kan implementeres er:
+
+* Avslutt løkken hvis brukeren har gjettet alle bokstavene i løsningsordet.
+* For hvert gjett, print ut maskert løsningsord med stjerner for hver bokstav som fortsatt ikke er gjettet. `(Eks.: lø*ning*ord)`
+
+Du kan utvide koden fra **a** og **b**.
\ No newline at end of file
diff --git a/Oving3/Middels/Hangman.py b/Oving3/Middels/Hangman.py
new file mode 100644
index 0000000000000000000000000000000000000000..151528f0227f031743916af14c963779d00682b3
--- /dev/null
+++ b/Oving3/Middels/Hangman.py
@@ -0,0 +1,6 @@
+print("HANGMAN!")
+print("______________________ \n")
+
+#TODO løs oppgave a,b c(frivillig) her:
+
+
diff --git a/Oving3/Middels/Tekstbasert spill 2.md b/Oving3/Middels/Tekstbasert spill 2.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8d8a03433ca434c25d6f564ebc261f798a79558
--- /dev/null
+++ b/Oving3/Middels/Tekstbasert spill 2.md	
@@ -0,0 +1,85 @@
+### **[Intro øving 3](../Intro_Øving3.md)**
+<br>
+
+# Tekstbasert spill 2
+
+**Læringsmål:**
+
+* Løkker
+* Betingelser
+
+<br>
+
+## OPPGAVER
+
+Alle deloppgaver besvares her: *[Tekstbasert spill 2.py](Tekstbasert%20spill%202.py)* !
+<br><br>
+
+I denne oppgaven skal vi utvide spillet vi begynte på i øving 2. Du må ikke ha gjort oppgaven i øving for å gjøre denne, men det kan være lurt å ta en kikk [her](../../Oving2/Middels/Tekstbasert%20spill.md) for å forstå hva oppgaven går ut på. 
+
+## a)
+
+Ved hjelp av en while løkke, la brukeren skrive inn kommando, og gjenta tilstanden dersom brukeren gir inn en ugyldig kommando. Se forrige oppgave for oppførsel ellers. 
+
+**Eksempel:**
+
+>*Du står utenfor en dør.* sadasd <br>
+*Forstår ikke kommando, prøv noe annet. <br>
+Du står utenfor en dør.* Gå inn <br>
+*Du går inn døren.* <br>
+
+<br>
+
+
+
+
+
+
+## b)
+
+Ved hjelp av løkker ønsker vi nå at visse kommandoer skal ta brukeren tilbake til utgangspunktet i spillet.  Dersom en bruker skriver inn en kommando som ikke skal ta brukeren ut av spillet (eller en ugyldig kommando), ønsker vi at den opprinnelige meldingen brukeren får skal gjentas, ellers går spilleren ut av løkken. **Altså, for alle andre kommandoer enn en spesifikk skal løkka gjentas.** I eksempelet under gjentas tilstanden helt til brukeren skriver noe som endrer den.
+
+**Eksempel:** <br>
+
+>*Du står utenfor en dør med en postkasse.* Bank på <br>
+*Du får ingen respons. <br>
+Du står utenfor en dør med en postkasse.* Gå andre veien <br>
+*Du snur deg og vandrer hjem igjen. Du hører en skummel lyd og løper tilbake.* <br>
+*Du står utenfor en dør med en postkasse.* Åpne døren <br>
+*Du går inn døren.* <br>
+
+<br>
+
+
+## c)
+
+Ved hjelp av løkker og variabler skal du nå la visse kommandoer brukeren skriver inn endre tilstanden i spillet (altså variablene) **selv om vi ikke går ut av løkka**. Ved å sjekke tilstanden til disse variablene skal en kommando kunne gjøre to ting, utifra hva tilstanden til en variabel er satt til.
+
+**Eksempel:** <br>
+
+>*Du står utenfor en dør med en postkasse.* Åpne døren <br>
+*Døren er låst. <br>
+Du står utenfor en dør med en postkasse.* Åpne postkassen <br>
+*Du finner en nøkkel. <br>
+Du står utenfor en dør med en postkasse.* Åpne døren <br>
+*Du låser opp døren og går inn.* <br>
+
+<br>
+
+
+## d)
+
+Legg til muligheten for brukeren til å gå ut av spillet uansett tilstand vet å kun trykke enter uten å skrive inn noe. Legg inn en avslutningsmelding.
+
+**Eksempel:** <br>
+
+>*Du står utenfor en dør med en postkasse. <br>
+Ha en fin dag!*
+
+<br>
+
+**Hint:** <br>
+Du kan bruke break for å hoppe ut av en løkke.
+
+
+
diff --git a/Oving3/Middels/Tekstbasert spill 2.py b/Oving3/Middels/Tekstbasert spill 2.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e2876c9baf8c8aae2f765c0e1ad296e80a5886e
--- /dev/null
+++ b/Oving3/Middels/Tekstbasert spill 2.py	
@@ -0,0 +1,18 @@
+print("TEKSTBASERT SPILL!")
+print("______________________ \n")
+
+print("Oppgave a)")
+#TODO løs oppgave a her:
+
+
+
+print("Oppgave b)")
+#TODO løs oppgave b her:
+
+
+
+print("Oppgave c og d)")
+#TODO løs oppgave c og d her:
+
+
+