Initial commit

oppgavetekster/oving1/Account.md

@@ -0,0 +1,27 @@
+# Tilstand og oppførsel – Account
+
+Oppgaven handler om en `Account`-klasse, som håndterer data i en konto.
+Tilstanden i `Account`-objekter er som følger:
+
+- `balance` - et desimaltall som angir beløpet som er på kontoen
+- `interestRate` - et desimaltall som angir rentefot som prosentpoeng.
+
+`Account`-klassen har fem metoder, med følgende oppførsel:
+
+- `deposit(double)` - øker konto-beløpet med den angitte argument-verdien (et desimaltall), men kun dersom det er positivt
+- `addInterest()` - beregner renta og legger det til konto-beløpet
+- `getBalance()` - returnerer beløpet som er på kontoen. 
+- `getInterestRate()` - returnerer rentefoten
+- `setInterestRate(double)` - oppdaterer renten til å være den nye verdien
+
+## Del 1 - Tilstandsdiagram
+
+Tegn et objekttilstandsdiagram for en tenkt bruk av `Account`-klassen. Velg selv en passende start-tilstand for `Account`-objektet og sekvens av kall.
+
+## Del 2 - Java-kode
+
+Skriv Java-kode for `Account`-klassen med oppførsel som er beskrevet over.
+
+Lag en passende `toString()`-metode og en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme start-tilstand og sekvens av kall)
+
+Testkode for denne oppgaven finner du her: [src/test/java/stateandbehavior/AccountTest.java](../../src/test/java/stateandbehavior/AccountTest.java).

oppgavetekster/oving1/Digit.md

@@ -0,0 +1,32 @@
+# Tilstand og oppførsel – Digit
+
+Oppgaven handler om en `Digit`-klasse, som representerer ett siffer i et gitt tallsystem.
+
+Tilstanden i `Digit`-objekter er todelt:
+
+- en `int` som angir tallsystemet, f.eks. 10 for titallssystemet, som oppgis i konstruktøren
+- en `int`-verdi, som representerer siffer-verdien i det angitt tallsystem og må være fra og med 0 til (men ikke med) tallsystem-verdien
+
+Konstruktøren tar inn en `int`, som initialiserer tallsystem-verdien, mens siffer-verdien settes til 0.
+
+`Digit`-tilstanden leses og oppdateres med følgende metoder:
+
+- `int getValue()` - returnerer siffer-verdien
+- `boolean increment()` - øker siffer-verdien med én. Dersom den da når tallsystem-verdien, så (re)settes den til 0 og metoden returnerer `true`, ellers returnerer den `false`.
+- `int getBase()` - returnerer tallsystemet. 
+
+## Del 1 - Tilstandsdiagram
+
+Tegn et objekttilstandsdiagram for en tenkt bruk av `Digit`-klassen. Sekvensen av kall må illustrere hele oppførselen til `increment()`-metoden.
+
+## Del 2 - Java-kode
+
+Skriv Java-kode for `Digit`-klassen med oppførsel som er beskrevet over. Lag også en `toString()`-metode som returnerer siffer-verdien som en `String`, hvor sifrene 0-9 etterfølges av A-Z. F.eks. skal siffer-verdien 10 i sekstentallssystemet gi "A" som returverdi.
+
+Lag en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme sekvens av kall).
+
+Testkode for denne oppgaven finner du her: [src/test/java/stateandbehavior/DigitTest.java](../../src/test/java/stateandbehavior/DigitTest.java).
+
+## Ekstraoppgave
+
+La hovedprogrammet opprette tre `Digit`-objekter, som fungerer som sifre i et tre-sifret tall. Lag en løkke som teller fra 0 til høyest mulig verdi som kan representeres i tallsystemet. Legg så til 1 så verdien av det tre-sifrede tallet igjen blir 0.

oppgavetekster/oving1/LineEditor.md

@@ -0,0 +1,42 @@
+# Tilstand og oppførsel – LineEditor
+
+Oppgaven omhandler en `LineEditor`-klasse, som håndterer data for redigering av en linje med tekst (altså tekst uten linjeskift).
+
+`LineEditor`-klassen holder rede på en `String`-verdi og en tekstinnsettingsposisjon og har metoder for å redigere teksten. Tekstinnsettingsposisjonen er et heltall som angir hvor endringer skjer, tilsvarende en (blinkende) cursor som står mellom tegn. Verdien $`0`$ tilsvarer foran første tegn, og høyeste mulige verdi er lengden på teksten, som tilsvarer at cursoren står bak siste tegn. Tilstanden er altså som følger:
+
+- `text` (en `String`-verdi) - teksten
+- `insertionIndex` - heltall som angir hvor i teksten redigeringer vil skje
+
+Klassen har metoder med følgende oppførsel:
+
+- `void left()` - flytter tekstinnsettingsposisjonen ett tegn til venstre (tilsvarende bruk av venstre piltast)
+- `void right()` - flytter tekstinnsettingsposisjonen ett tegn til høyre (tilsvarende bruk av høyre piltast)
+- `void insertString(String s)` - skyter teksten angitt av argumentet `s` inn i teksten på tekstinnsettingsposisjonen og forskyver tekstinnsettingsposisjonen mot høyre tilsvarende
+- `void deleteLeft()` - fjerner tegnet til venstre for tekstinnsettingsposisjonen
+- `void deleteRight()` - fjerner tegnet til høyre for tekstinnsettingsposisjonen
+- `String getText()` - Returnerer teksten
+- `void setText(String)` - oppdaterer teksten til å være den nye teksten
+- `int getInsertionIndex` - returnerer hvor i teksten redigeringer nå skjer 
+- `void setInsertionIndex(int)` - oppdaterer hvor i teksten redigeringer skal skje
+
+## Del 1 - Objekttilstandsdiagram
+
+Tegn et objekttilstandsdiagram for en tenkt bruk av `LineEditor`-klassen, som dekker bruk av alle metodene.
+
+For alle metodene bør du tenke på hva som er fornuftig oppførsel for spesielle tilfeller, f.eks. når tekstinnsettingsposisjonen er helt til venstre eller høyre. Tenk også på hva som bør skje med tekstinnsettingsposisjonen når teksten endres.
+
+## Del 2 - Java-kode
+
+Skriv Java-kode for `LineEditor`-klassen med oppførsel som beskrevet over.
+
+Lag en `toString()`-metode som viser teksten med tegnet `'|'` skutt inn på tekstinnsettingsposisjonen. Lag så en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme start-tilstand og sekvens av kall).
+
+Testkode for oppgaven finner du her: [src/test/java/stateandbehavior/LineEditorTest.java](../../src/test/java/stateandbehavior/LineEditorTest.java).
+
+## Ekstraoppgave - frivillige utvidelser
+
+- Legg til metoden `void insert(Object o)`, som skyter inn en tekstlig representasjon av objektet `o` som gis som argument.
+- Legg til metoden `void left(int n)`, som flytter tekstinnsettingsposisjonen $`n`$ tegn til venstre, og skriv om `left()` til å bruke denne. Hva bør skje dersom tekstinnsettingsposisjonen er mindre enn $`n`$?
+- Legg til metoden `right(int n)`, som flytter tekstinnsettingsposisjonen $`n`$ tegn til høyre, og skriv om `right()` til å bruke denne. Hva bør skje dersom det er færre enn $`n`$ tegn til høyre for tekstinnsettingsposisjonen?
+- Utvid tilstanden og legg til metoder for å håndtere markering av region, tilsvarende bruk av shift og piltaster i en vanlig teksteditor. Husk at også de eksisterende metodene må endres til å håndtere dette riktig.
+ 

oppgavetekster/oving1/Location.md

@@ -0,0 +1,27 @@
+# Tilstand og oppførsel – Location
+
+Oppgaven handler om en `Location`-klasse, som holder rede på $`(x,y)`$-posisjonen til en figur som beveger seg i et rutenett.
+
+`Location`-klassen har følgende metoder:
+
+- `up()` - beveger figuren en rute opp
+- `down()` - beveger figuren en rute ned
+- `left()` - beveger figuren en rute til venstre
+- `right()` - beveger figuren en rute til høyre
+- `getX()` - returnerer x-posisjonen til figuren
+- `getY()`  - returnerer y-posisjonen til figuren
+
+Merk at konvensjonen innen datagrafikk og rutenettbaserte spill er at $`x`$ øker mot høyre (som i matte) og $`y`$ nedover (altså motsatt av i matte).
+
+## Del 1 - Tilstandsdiagram
+
+Tegn et tilstandsdiagram for en tenkt bruk av Location-klassen. Velg selv passende tilstandsvariable for $`(x,y)`$-posisjonen.
+
+## Del 2 - Java-kode
+
+Skriv Java-kode for `Location`-klassen med oppførsel som beskrevet over.
+
+Lag en passende `toString()`-metode og en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme start-tilstand og sekvens av kall).
+ 
+Testkode for oppgaven finner du her: [src/test/java/stateandbehavior/LocationTest.java](../../src/test/java/stateandbehavior/LocationTest.java).
+

oppgavetekster/oving1/README.md

@@ -0,0 +1,47 @@
+# Øving 1: Objekter og klasser, tilstand og oppførsel
+
+__Øvingsmål__:
+
+- Bli kjent med Java-syntaks og bruk av Eclipse
+- Lære (enkel) objektorientert tankegang
+- Lære å lage enkle Java-klasser og -programmer
+
+__Øvingskrav__:
+
+- Kunne tegne enkle tilstandsdiagrammer
+- Kunne deklarere klasser, med data og kode, iht. oppgavespesifikasjon
+- Kunne skrive main-metoder for å teste objekter
+- Kunne bruke standardtyper og -metoder (e.g. toString()-metoden)
+
+## NB: Viktig beskjed!
+
+For å få testene og eventuell kode til øvingene lokalt brukes systemet git. I Eclipse kan du klikke på Git --> Pull i menylinja for å hente den nye øvingen ved hjelp av dette. Om du ikke har denne i menylinjen, er det også mulig å høyreklikke på en av prosjektmappene og velge Team --> Pull.
+
+## Dette må du gjøre
+
+Oppgavene for denne øvingenskal du lagre i `ovinger/src/main/java/stateandbehavior`. Test-filene som kjøres for å versifisere ligger i `ovinger/src/test/java/stateandbehavior`.
+
+Hvis du ikke allerede har gjort det, må du installere Eclipse med det ferdigkonfigurerte oppsettet for TDT4100. Se [denne](https://www.ntnu.no/wiki/display/tdt4100/Installasjon+av+Eclipse) wikisiden. 
+
+Du skal velge og gjennomføre minst tre av de følgende oppgavene angående [Tilstand og oppførsel](https://www.ntnu.no/wiki/pages/viewpage.action?pageId=65937373).
+
+- [Account (Lett)](./Account.md)
+- [Location (Lett)](./Location.md)
+- [Digit (Lett)](./Digit.md)
+- [UpOrDownCounter (Medium)](./UpOrDownCounter.md)
+- [LineEditor (Vanskelig)](LineEditor.md)
+- [Stopwatch (Vanskelig)](Stopwatch.md)
+- [Rectangle (Vanskelig)](Rectangle.md)
+
+Oppgavene er merket med en vanskelighetsgrad relativt til hverandre. Det er en god idé å begynne med de lettere oppgavene dersom du ikke er komfortabel med pensum så langt, men det er anbefalt å prøve seg på de vanskeligere oppgavene om du synes de første oppgavene er uproblematiske. Dersom du allerede føler deg trygg på punktene i øvingskravene kan du forsøke å gå rett på de vanskeligere oppgavene. Du er selvfølgelig velkommen til å løse flere oppgaver enn minstekravet, hvilket lurt gjøres med tanke på eksamen og et langt liv som programmerende.
+
+Før du setter i gang kan det vært lurt å lese wiki-siden om [Tilstand og oppførsel](https://www.ntnu.no/wiki/pages/viewpage.action?pageId=65937373) nøye, samt ta en titt på det tilhørende `Counter`-eksempelet. Forelesningene og tilhørende øvingsforelesning er selvsagt også lure å få med seg
+
+Det finnes også masse ressurser på [wikien](https://www.ntnu.no/wiki/display/tdt4100/Faginnhold) om hvordan ulike metoder skal fungere. F.eks `toString`-metoden og metoder for teksthåndtering. Naviger deg litt rundt om du lurer på noe.
+
+### Hjelp/Mistanke om bugs
+Ved spørsmål eller behov for hjelp konsulter studassen din i saltiden hans / hennes. Du kan også oppsøke andre studasser på sal eller legge ut et innlegg på Piazza.
+
+### Godkjenning
+Last opp kildekode på Blackboard innen den angitte innleveringsfristen. Innlevert kode skal demonstreres for stud.ass innen én uke etter innleveringsfrist. Se for øvrig Blackboard-sidene for informasjon rundt organisering av øvingsopplegget og det tilhørende øvingsreglementet.
+

oppgavetekster/oving1/Rectangle.md

@@ -0,0 +1,65 @@
+# Tilstand og oppførsel – Rectangle
+
+Oppgaven handler om en `Rectangle`-klasse, som håndterer et firkantet område i et koordinatsystem, med sider parallelle med koordinataksene.
+
+Tilstanden i `Rectangle`-objekter er ikke spesifisert eksplisitt, men må velges slik at metodene nedenfor kan implementerers. Merk at alle metodene jobber med heltallsstørrelser.
+
+`Rectangle`-klassen har metoder for å spørre om tilstanden og endre tilstanden. Spørremetodene dekker høyde og bredde og koordinatene til øverste venstre og nederste høyre hjørne og om rektanglet inneholder spesifikke punkt(er). Endringsmetodene dekker utviding ved å legge til punkter.
+
+**Merk**: `Rectangle`-klassen fungerer som om du krysser ut et rutenett, altså at et punkt ("kryss") har en lengde og bredde på 1, ikke som i matematikk der punkter ikke har størrelser. Bildeserien under viser et eksempel på hvordan bredde og høyde endres når man legger til punkter i rektangelet.
+
+<img alt="Tomt rektangel" src="fig/rectangle/step1.png" width="500px" />
+<br />
+
+<img alt="Rektangel med et punkt" src="fig/rectangle/step2.png" width="500px" />
+<br />
+
+<img alt="Rektangel steg 3" src="fig/rectangle/step3.png" width="500px" />
+<br />
+
+<img alt="Rektangel steg 4" src="fig/rectangle/step4.png" width="500px" />
+<br />
+
+Logikken til metodene må tilfredsstille følgende krav:
+
+- et `Rectangle`-objekt er tomt i starten
+- et tomt `Rectangle`-objekt skal returnere $`0`$ for alle `get`-metodene (`minX`, `minY`, `maxX`, `maxY`), `true` for `isEmpty` og `false` for `contains`-metodene.
+- et punkt har bredde og høyde lik $`1`$, så dersom en legger punktet $`(x,y)`$ til et tomt `Rectangle`-objekt, så skal `getMinX` og `getMaxX` returnere $`x`$, `getMinY` og `getMaxY` skal returnere $`y`$ og `getWidth` og `getHeight` skal returnere $`1`$.
+- når en utvider et `Rectangle`-objekt med en av `add`-metodene, så skal ikke rektanglet bli større enn nødvendig.
+
+Spørremetoder:
+
+- `int getMinX()` og `int getMinY()` - returnerer henholdsvis $`x`$- og $`y`$-koordinatene til punktet med lavest $`(x,y)`$-verdier som er inneholdt i dette rektanglet. Dersom dette rektanglet er tomt, så skal $`0`$ returneres.
+- `int getMaxX()` og `int getMaxY()` - returnerer henholdsvis $`x`$- og $`y`$-koordinatene til punktet med høyest $`(x,y)`$-verdier som er inneholdt i dette rektanglet. Dersom dette rektanglet er tomt, så skal $`0`$ returneres.
+- `int getWidth()` og `int getHeight()` - returnerer henholdsvis bredden og høyden til rektanglet. Begge skal returnere $`0`$, dersom dette rektanglet er tomt.
+- `boolean isEmpty()` - returnerer `true` om rektanglet er tomt, dvs. om bredden og/eller høyden er $`0`$.
+- `boolean contains(int x, int y)` - returnerer `true` om punktet $`(x,y)`$ er inneholdt i dette rektanglet, og `false` ellers.
+- `boolean contains(Rectangle rect)` - returnerer `true` om hele `rect`, dvs. alle punktene i `rect`, er inneholdt i dette rektanglet, og false ellers. Dersom `rect` er tomt, så skal `false` returneres.
+
+Endringsmetoder:
+
+- `boolean add(int x, int y)` - utvider (om nødvendig) dette rektanglet slik at det (akkurat) inneholder punktet $`(x,y)`$. Etter kallet skal altså `contains(x, y)` returnere `true`. Returnerer `true` om dette rektanglet faktisk ble endret, ellers `false`.
+- `boolean add(Rectangle rect)` - utvider (om nødvendig) dette rektanglet slik at det (akkurat) inneholder hele `rect`-argumentet. Returnerer `true` om dette rektanglet faktisk ble endret, ellers `false`. Dersom `rect` er tomt, så skal dette rektanglet ikke endres.
+
+Andre metoder:
+
+- `Rectangle union(Rectangle rect)` - returnerer et nytt `Rectangle`-objekt som tilsvarer kombisjonen av dette rektanglet og `rect`-argumentet. Alle punktene som finnes i ett av rektanglene skal altså være inneholdt i rektanglet som returneres.
+
+## Del 1 - Tilstandsdiagram
+
+Tegn et objekttilstandsdiagram for en tenkt bruk av `Rectangle`-klassen. Velg en sekvens av kall som bruker alle fire endringsmetoder.
+
+## Del 2 - Java-kode
+
+Skriv Java-kode for `Rectangle`-klassen med oppførsel som er beskrevet over.
+
+Lag en passende `toString()`-metode og et hovedprogram, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme sekvens av kall).
+
+Testkode for denne oppgaven finner du her: [src/test/java/stateandbehavior/RectangleTest.java](../../src/test/java/stateandbehavior/RectangleTest.java).
+
+## Ekstraoppgave
+
+Implementer følgende metoder:
+
+- `Rectangle intersection(Rectangle rect)` - returnerer et nytt `Rectangle`-objekt som tilsvarer overlappet mellom dette rektanglet og `rect`-argumentet. Alle punktene som finnes i begge rektanglene skal altså være inneholdt i rektanglet som returneres.
+- `boolean intersects(Rectangle rect)` - returnerer `true` om dette rektanglet og `rect`-argumentet overlapper, dvs. om det finnes ett eller flere punkter som er inneholdt i begge disse rektanglene.

oppgavetekster/oving1/Stopwatch.md

@@ -0,0 +1,48 @@
+# Tilstand og oppførsel – Stopwatch
+
+Oppgaven handler om en `StopWatch`-klasse, som implementerer en stoppeklokke med funksjoner for å starte, ta rundetider og stoppe.
+
+Klassen skal implementere logikken ofte funnet på stoppeklokker på smarttelefoner.
+
+<img alt="Stopwatch" src="fig/stopwatch.gif" width="250px" style="float: right" />
+
+For å holde styr på tiden som går vil `StopWatch`-klassen bli kalt utenfra (altså noe du slipper å implementere i denne oppgaven) på en `tick(int)`-metode. I dataverdenen er et tick (tikk på norsk) minste målbare diskret tidsenhet. I denne oppgaven er 1 tikk = 1 millisekund. F.eks. vil et kall `tick(3)` fortelle en `StopWatch`-instans at $`3`$ tikk har gått siden sist gang `tick()` ble kalt.
+
+StopWatch skal fungere på følgende måte:
+
+- Klokken startes når man ønsker å starte tidtakningen.
+- Alle tikk etter at klokken har blitt startet skal medregnes i tidtakningen.
+- Klokken stoppes når man ønsker å stoppe tidtakningen. Da er tidtakningen helt ferdig. Det er ikke en pause i tidtakningen - klokken skal ikke startes igjen.
+- Det skal være mulig å ta rundetider.
+- Første rundetid startes når klokken starter.
+- Under tidtakningen kan man starte en ny rundetid, og dermed implisitt avslutte den nåværende.
+- Siste rundetid avsluttes når klokken stoppes.
+
+`StopWatch`-klassen må ha metoder for å spørre om tilstanden og metoder for å endre tilstanden.
+
+Klassen skal ha følgende spørremetoder:
+
+- `boolean isStarted()` - returnerer `true` om klokken har blitt startet eller `false` om den ikke har blitt startet
+- `boolean isStopped()` - returnerer `true` om klokken har blitt stoppet eller `false` om den ikke har blitt stoppet. Merk at her snakker vi om at klokken har blitt stoppet, ikke om klokken går eller ikke.
+- `int getTicks()` - returnerer det totale antall tikk (millisekunder) som har gått i levetiden til klokken uavhengig om klokken har vært startet eller stoppet.
+- `int getTime()` - returnerer antall tikk som har gått under tidtakningen. Hvis tidtakningen ikke har startet returner $`-1`$. Merk at hvis klokken er startet, men ikke stoppet, skal metoden returnere antall tikk som har gått siden klokken ble startet til nå. Hvis klokken er stoppet skal metoden returnere antall tikk som har gått fra klokken ble startet til klokken ble stoppet.
+- `int getLapTime()` - returnerer antall tikk som har gått under nåværende rundetid til nå. Hvis tidtakningen ikke har startet returner $`-1`$.
+- `int getLastLapTime()` - returnerer lengden på forrige avsluttede rundetid. Hvis det ikke er noen tidligere rundetider returner $`-1`$.
+
+Klassen skal ha følgende metoder for å endre tilstanden:
+
+- `void tick(int ticks)` - forteller klokken at `ticks` antall tikk har gått.
+- `void start()` - starter klokken.
+- `void lap()` - avslutter nåværende rundetid og starter en ny.
+- `void stop()` - stopper klokken.
+
+## Del 1 - Tilstandsdiagram
+
+Tegn et objekttilstandsdiagram for en tenkt bruk av `StopWatch`-klassen. Velg en sekvens av kall som både starter klokken, tar rundetider og stopper klokken.
+
+## Del 2 - Java-kode
+Skriv Java-kode for `StopWatch`-klassen med oppførsel som er beskrevet over.
+
+Lag en passende `toString()`-metode og en `main`-metode, slik at du kan sjekke at oppførselen stemmer med tilstandsdiagrammet (bruk samme sekvens av kall).
+
+Testkode for denne oppgaven finner du her: [src/test/java/stateandbehavior/StopWatchTest.java](../../src/test/java/stateandbehavior/StopWatchTest.java).

oppgavetekster/oving1/UpOrDownCounter.md

@@ -0,0 +1,14 @@
+# Tilstand og oppførsel – UpOrDownCounter
+
+I denne oppgaven skal du programmere en teller, ikke ulik den som er beskrevet i [Tilstand og oppførsel](https://www.ntnu.no/wiki/pages/viewpage.action?pageId=65937373) og kodet i [Tilstand og oppførsel - Java-kode for Counter-eksempel](https://www.ntnu.no/wiki/pages/viewpage.action?pageId=65937823), som også skal håndtere tilfellet hvor slutt-verdien er lavere enn start-verdien ved å telle nedover.
+
+## Del 1 - Java-kode
+
+`UpOrDownCounter`-klassen skal altså ha de samme konstruktørene/metodene:
+
+- `UpOrDownCounter(int start, int end)` - initialiserer objektet med angitte start- og slutt-verdier, hvor altså slutt kan være større eller mindre enn start, slik at telleren teller henholdsvis opp eller ned. Lik start og slutt-verdi skal utløse unntak av typen `IllegalArgumentException` (se [Koding av valideringsmetoder](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+valideringsmetoder)).
+- `int getCounter()` - returnerer telleren
+- `boolean count()` - beveger telleren i retning av slutt-verdien og returnerer true så lenge den ikke har nådd den, altså om telleren har mer igjen, og false ellers.
+ 
+Testkode for oppgaven finner du her: [src/test/java/stateandbehavior/UpOrDownCounterTest.java](../../src/test/java/stateandbehavior/UpOrDownCounterTest.java)
+