public class Person {
    private String eier;
    private String bilnummer;


    public Person(String eier, String bilnummer){
        this.eier = eier;
        this.bilnummer = bilnummer;
    }

    public void skrivUt(){
        System.out.println(eier + ": " + bilnummer);
    }
}


public class BilBruk3 {
    public static void main(String[] args){
        Bil3 bil = new Bil3("AG34343");
        Person person = new Person("Espen", bil.hentNummer());
        person.skrivUt();
    }
}


public class Bil3 {
    private String bilnummer;

    public Bil3(String bilnummer){
        this.bilnummer = bilnummer;
    }

    public void skrivUt(){
        System.out.println(bilnummer);
    }

    public String hentNummer(){
        return bilnummer;
    }
}


public class BilBruk2 {
    public static void main(String[] args){
        Bil2 bil = new Bil2("111111");
        bil.skrivUt();
    }
}


public class Bil1{
    public void skrivUt(){
        System.out.println("Jeg er en bil");
    }
}

public class BilBruk1 {
    public static void main(String[] args){
        Bil1 bil = new Bil1();
        bil.skrivUt();
    }
    
}


Oblig-0-IN1010

IN1010 Objektorientert programmering

Oblig 0 IN1010

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

public class Oblig5Hele {
    public static void main(String[] args) {

        Monitor2 mSyk = new Monitor2();
        Monitor2 mFrisk = new Monitor2();
        // NOTE: Du endrer denne variablen hvis du onsker aa endre sykdomskravet
        // for aa skrive ut naar du sammenligner filer. Eks testData.csv = minst 5
        // fler syke enn friske
        int sykKrav = 5;
        int antallTrader = 8;
        ArrayList<String> filesSyk = new ArrayList<>();
        ArrayList<String> filesFrisk = new ArrayList<>();
        ArrayList<Thread> threads = new ArrayList<>();

        try {
            Scanner sc = new Scanner(new File(args[0]));

            while (sc.hasNext()) {
                String[] linje = sc.next().trim().split(",");

                if (linje[1].equals("False")) {
                    filesFrisk.add(linje[0]);
                } else {
                    if (linje[1].e

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

public class SubsekvensRegister {
    protected ArrayList<HashMap<String, Subsekvens>> hashBeholder = new ArrayList<>();

    public void settInnHashMap(HashMap h) {
        hashBeholder.add(h);
    }

    public HashMap hentHashMap(int pos) {
        return hashBeholder.get(pos);
    }

    public HashMap hentOgFjernHashMap(int pos) {
        return hashBeholder.remove(pos);
    }

    public void printHeleHashbeholder() {
        for (HashMap<String, Subsekvens> hashMap : hashBeholder) {
            System.out.println(hashMap.values());
        }
    }

    public int hentStoerrelse() {
        return hashBeholder.size();
    }

    public static HashMap<String, Subsekvens> lesFilOgOpprettHashMap(String fil) {
        HashMap<String, Subsekvens> nyHashMap = new HashMap<>();

        try {
            Scanner sc = new Scanner(new File(fil));

    

import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Monitor1 extends SubsekvensRegister {
    Lock laas = new ReentrantLock(true);
    ArrayList<String> files = new ArrayList<>();

    // Laaser og setter inn
    public void settInnHashMap(HashMap h) {
        laas.lock();
        try {
            hashBeholder.add(h);
        } finally {
            laas.unlock();
        }
    }

    // Legger til filer
    public void leggTilFiler(ArrayList<String> filer) {
        files = filer;
    }

    public ArrayList<String> hentFiler() {
        return files;
    }

    public String hentUtFil(ArrayList<String> filer) {
        laas.lock();
        try {
            // Returnerer en fil saalenge det finnes filer aa returnerer
            while (filer.size() > 0) {
                return filer.remove(0);
            }
            return null;
        } finally {
            laas.unlock();


import java.util.HashMap;

public class FletteTrad implements Runnable {
    Monitor2 monitor;

    public FletteTrad(Monitor2 monitor) {
        this.monitor = monitor;
    }

    @Override
    public void run() {
        try {
            // Slaar sammen hasmaps, saalenge det finnes maps aa slaa sammen
            while (monitor.hentStoerrelse() > 1) {
                HashMap[] hash = monitor.hentToHashmap();
                if (hash != null) {
                    monitor.settInnHashMap(monitor.slaaSammenHashMap(hash[0], hash[1]));
                }
            }

        } catch (InterruptedException e) {
            System.err.println(e);
        }
    }
}



import java.util.ArrayList;
import java.util.HashMap;

public class LeseTrad implements Runnable {
    ArrayList<String> filer;
    Monitor1 monitor;

    public LeseTrad(ArrayList<String> filer, Monitor1 monitor) {
        this.filer = filer;
        this.monitor = monitor;
    }

    @Override
    public void run() {
        try {
            // Leser og oppretter hasmaps, saalengde det finnes filer aa lese
            while (filer.size() > 0) {
                String fil = monitor.hentUtFil(filer);
                if (fil != null) {
                    HashMap<String, Subsekvens> h = monitor.lesFilOgOpprettHashMap(fil);
                    monitor.settInnHashMap(h);
                }
            }
        } catch (Exception e) {
            System.err.println(e);
        }

    }

}


import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Monitor2 extends Monitor1 {
    Condition minst2 = laas.newCondition();

    public HashMap[] hentToHashmap() throws InterruptedException {
        // Laaser forst
        laas.lock();
        try {
            // Saalenge det er mindre enn 2 i beholderen, returneres null
            while (hashBeholder.size() < 2) {
                return null;

            }
            // Fjerner to objekter fra beholderen og returnerer.
            HashMap[] hasjMaper = new HashMap[2];
            hasjMaper[0] = hashBeholder.remove(0);
            hasjMaper[1] = hashBeholder.remove(0);
            return hasjMaper;
        } finally {
            laas.unlock();
        }
    }

}


public class Subsekvens {
    public final String subsekvens;
    private int antall;

    public Subsekvens(String subsekvens, int antall) {
        this.subsekvens = subsekvens;
        this.antall = antall;
    }

    public int hentAntallForekomster() {
        return antall;
    }

    public void endreAntallForekomster(int tall) {
        antall = tall;
    }

    public String toString() {
        return "(" + subsekvens + "," + antall + ")";
    }

}


Oblig-5-IN1010

Oblig 5 IN1010

import java.awt.*;
import java.awt.event.*;
import java.io.Console;

import javax.swing.*;
import javax.swing.text.rtf.RTFEditorKit;

public class GUI {
    private Controller controller;
    private JFrame vindu;
    private JPanel panel, brett;
    private JPanel info;
    private JButton avslutt;
    private JPanel styreflate;
    private JLabel poengsum;
    private JLabel[][] ruter;

    public GUI(Controller controller) {
        this.controller = controller;

        ruter = new JLabel[12][12];
        vindu = new JFrame("Slangespillet");
        vindu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        panel = new JPanel();
        panel.setLayout(new BorderLayout());
        vindu.add(panel);
        lagInfo();
        lagBrett();

        vindu.pack();
        vindu.setLocationRelativeTo(null);

        vindu.setVisible(true);
    }

    private void lagInfo() {
        info = new JPanel();
        info.setLayout(new BorderLayout());
        // Avslutt spillet
        avs

public class Controller {
    private GUI gui;
    private Model model;
    public Retning retning = Retning.NORD;
    private int hastighet = 500;
    public boolean slutt = false;

    public Controller() {
        gui = new GUI(this);
        model = new Model(gui, 12, 12, this);
        Thread traad = new Thread(new Teller());
        traad.start();
    }

    public void endreHastighet(int hastighet) {
        this.hastighet = hastighet;
    }

    class Teller implements Runnable {
        @Override
        public void run() {
            while (!slutt) {
                try {
                    Thread.sleep(hastighet);
                } catch (Exception e) {
                    return;
                }
                flytt();
            }
        }
    }

    public void flytt() {
        model.flytt(retning);
    }

    public void settSlutt() {
        slutt = true;
        System.exit(0);
    }

    public static void main(String[] args) {
        new Controller();
    }


import java.io.Console;
import java.util.ArrayList;
import java.util.LinkedList;

public class Model {
    private GUI gui;
    private int lengde, bredde;
    private Controller controller;
    private int slangePosX, slangePosY;
    private static int poeng = 1;

    private LinkedList<ArrayList<Integer>> slangen = new LinkedList<>();
    private ArrayList<ArrayList<Integer>> skatter = new ArrayList();

    public Model(GUI gui, int lengde, int bredde, Controller controller) {
        this.controller = controller;
        this.gui = gui;
        this.lengde = lengde;
        this.bredde = bredde;

        slangePosX = 6;
        slangePosY = 4;

        gui.tegnHode(slangePosX, slangePosY);
        leggTilParSlangen(slangePosX, slangePosY);

        for (int i = 0; i < 10; i++) {
            leggTilSkatter();
        }
    }

    public void leggTilParSlangen(int x, int y) {
        ArrayList<Integer> par = new ArrayList<>();
        par.add(x);
        par.add(y);
        slangen.ad

public enum Retning {
    NORD, SOR, OST, VEST;
}


Oblig-7-IN1010

Oblig 7 IN1010

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Labyrint {

    ArrayList<ArrayList<Rute>> listeMedRuteObjekter = new ArrayList<>();
    private int antallRader;
    private int antallKolonner;
    private static int radTeller = -1;
    private static int kolonneTeller = 0;

    public Labyrint(String fil) {
        try {

            if (!filnavn.contains(".in")) {
                throw new FileNotFoundException();
            }

            Scanner sc = new Scanner(new File(fil));

            while (sc.hasNext()) {
                String linje = sc.nextLine();
                // Finner forst antall rader og kolonner
                if (linje.contains(" ")) {
                    String[] linjeMedRaderOgKolonner = linje.split(" ");
                    int rad = Integer.parseInt(linjeMedRaderOgKolonner[0]);
                    int kolonne = Integer.parseInt(linjeMedRaderOgKolonner[1]);
                    antallRader = rad;
           

public abstract class Rute {

    protected int radNummer;
    protected int kolonneNummer;
    protected Labyrint labyrint;

    protected Rute naboNord;
    protected Rute naboSyd;
    protected Rute naboVest;
    protected Rute naboOest;

    protected Rute(int radNummer, int kolonneNummer, Labyrint labyrint) {
        this.radNummer = radNummer;
        this.kolonneNummer = kolonneNummer;
        this.labyrint = labyrint;
    }

    public abstract void finn(Rute fra);

    public void settNaboNord(Rute rute) {
        this.naboNord = rute;
    }

    public void settNaboSyd(Rute rute) {
        this.naboSyd = rute;
    }

    public void settNaboVest(Rute rute) {
        this.naboVest = rute;
    }

    public void settNaboOeast(Rute rute) {
        this.naboOest = rute;
    }

}


import java.util.Scanner;

public class Oblig6 {
    public static void main(String[] args) {
        String fil = "labyrinter/" + args[0];
        Labyrint testLab = new Labyrint(fil);

    }
}


public class HvitRute extends Rute {

    public HvitRute(int radNummer, int kolonneNummer, Labyrint labyrint) {
        super(radNummer, kolonneNummer, labyrint);
    }

    @Override
    public String toString() {
        return ".";
    }

}


public class SortRute {

    public SortRute(int radNummer, int kolonneNummer, Labyrint labyrint) {
        super(radNummer, kolonneNummer, labyrint);
    }

    @Override
    public String toString() {
        return "#";
    }

}


public class Aapning extends HvitRute {

    public Aapning(int radNummer, int kolonneNummer, Labyrint labyrint) {
        super(radNummer, kolonneNummer, labyrint);
    }
}


Oblig-6-IN1010

Oblig 6 IN1010

public class TestLegemiddel {
    public static void main(String[] args) {
        Legemiddel hasj = new Narkotiske("hasj", 100, 5, 4 );
        Legemiddel viagra = new Vanedannende("viagra", 250, 50, 6 );
        Legemiddel paracet = new VanligLegemiddel("paracet", 50, 20 );

        System.out.println(hasj.hentId() == 1);
        System.out.println(viagra.hentId() == 2);
        System.out.println(paracet.hentId() == 3);

        System.out.println(hasj.hentVirkestoff() == 5);
        System.out.println(viagra.hentVirkestoff() == 50);
        System.out.println(paracet.hentVirkestoff() == 20);

        System.out.println(hasj.hentNavn().equals("hasj"));
        System.out.println(viagra.hentNavn().equals("viagra"));
        System.out.println(paracet.hentNavn().equals("paracet"));

        System.out.println(hasj.hentPris() == 100);
        System.out.println(viagra.hentPris() == 250);
        System.out.println(paracet.hentPris() == 50);

        if (hasj instanceof Narkotiske nyHas

public class TestResepter {
    public static void main(String[] args) {
        Lege nyLege = new Spesialist("Joshu", "ABC124");

        Legemiddel viagra = new Vanedannende("viagra", 250, 50, 6 );
        Legemiddel paracet = new VanligLegemiddel("paracet", 200, 20 );

        Resepter resept1 = new MilResept(viagra, nyLege, 1);
        Resepter resept2 = new PResept(paracet, nyLege, 2, 2);
        Resepter resept3 = new BlaaResepter(viagra, nyLege, 3, 3);

        System.out.println(resept1.hentId() == 1);
        System.out.println(resept2.hentId() == 2);
        System.out.println(resept3.hentId() == 3);

        System.out.println(resept1.hentPassientId() == 1);
        System.out.println(resept2.hentPassientId() == 2);
        System.out.println(resept3.hentPassientId() == 3);

        System.out.println(resept1.hentPassientId() == 1);
        System.out.println(resept2.hentPassientId() == 2);
        System.out.println(resept3.hentPassientId() == 3);

        System.out.printl

public class Integrasjonstest {

    public static void main(String[] args) {
        Lege nyLege1 = new Spesialist("Joshu", "ABC124");
        Lege nyLege2 = new Lege("Joshu");
        Legemiddel viagra = new Vanedannende("viagra", 250, 50, 6 );
        Legemiddel paracet = new VanligLegemiddel("paracet", 200, 20 );
        Legemiddel hasj = new Narkotiske("hasj", 100, 5, 4);
        MilResept resept1 = new MilResept(viagra, nyLege1, 1);
        PResept resept2 = new PResept(paracet, nyLege1, 2, 5);
        PResept resept3 = new PResept(hasj, nyLege2, 2, 5);
        BlaaResepter resept4 = new BlaaResepter(viagra, nyLege2, 3, 10);

        System.out.println("\n**Lege**\n" + nyLege1);
        System.out.println("\n**Lege**\n" + nyLege2);
        System.out.println("\n**Legemiddel**\n" + viagra);
        System.out.println("\n**Legemiddel**\n" + paracet);
        System.out.println("\n**Legemiddel**\n" + hasj);
        System.out.println("\n**Resept**\n" + resept1);
        System.out.p

public class Spesialist extends Lege implements Godkjenningsfritak {
    String kontrollID;

    public Spesialist(String navn, String kontrollID) {
        super(navn);
        this.kontrollID = kontrollID;
    }

    public String hentKontrollID() {
        return kontrollID;
    }

    @Override
    public String toString() {
        return "Navn: " + navn + "\nKontroll ID: " + kontrollID;
    }

}


public class MilResept extends HviteResepter {
    
    public MilResept(Legemiddel legemiddel, Lege lege, int passientId){
        // Siden reit alltid skal vaere 3, setter jeg den til det i super.
        super(legemiddel, lege, passientId, 3);

    }

    
}


public class BlaaResepter extends Resepter{
        
    public BlaaResepter(Legemiddel legemiddel, Lege lege, int passientId, int reit){
        super(legemiddel, lege, passientId, reit);
    }

    public String farge(){
        return "Blaa";
    }

    public int prisAaBetale(){
        // Caster en dobule til en int, dermed blir utregningen riktig
        return (int) Math.round((double) legemiddel.hentPris()/100*25);
    }

    @Override
    public String toString(){
        return(
            "ID: " + id + 
            "\nLegemiddel: " + legemiddel.hentNavn()+ 
            "\nLege: " + lege + 
            "\nPassient ID: " + passientId +
            "\nReit: " + reit +
            "\nPris aa betale: " + prisAaBetale() +
            "\nFarge: " + farge()
            );
    }

}





public class PResept extends HviteResepter{
    private int rabatt = 108;

    public PResept(Legemiddel legemiddel, Lege lege, int passientId, int reit){
        super(legemiddel, lege, passientId, reit);
    }  

    public int prisAaBetale(){
        if(legemiddel.hentPris() - rabatt <= 0){
            return 0;
        }
        else{
            return(legemiddel.hentPris() - rabatt);
        }
    }
}


public abstract class Resepter {
    private static int teller = 1;
    protected int id;
    protected Legemiddel legemiddel;
    protected Lege lege;
    protected int passientId;
    protected int reit;

    public Resepter(Legemiddel legemiddel, Lege utskrivendeLege, int passientId, int reit){
        this.legemiddel = legemiddel;
        lege = utskrivendeLege;
        this.passientId = passientId;
        this.reit = reit;
        id = teller ++;
    }

    public int hentId(){
        return id;
    }

    public Legemiddel hentLegemiddel(){
        return legemiddel;
    }

    public Lege hentLege(){
        return lege;
    }

    public int hentPassientId(){
        return passientId;
    }

    public int hentReit(){
        return reit;
    }

    public boolean bruk(){
        if(reit - 1 > -1){
            reit = reit - 1;
            return true;
        }
        return false;
    }

    public abstract String farge();

    public abstract int prisAaBetale();

   

}


public class Lege {
    protected String navn;

    public Lege(String navn){
        this.navn = navn;
    }

    public String hentNavn(){
        return navn;
    }

    @Override
    public String toString(){
        return "Navn: " + navn;
    }    
}


public class HviteResepter extends Resepter{

    public HviteResepter(Legemiddel legemiddel, Lege lege, int passientId, int reit){
        super(legemiddel, lege, passientId, reit);
    }

    public String farge(){
        return "Hvit";
    }

    public int prisAaBetale(){
        return 0;
    }
   
    @Override
    public String toString(){
        return(
            "ID: " + id + 
            "\nLegemiddel: " + legemiddel.hentNavn()+ 
            "\nLege: " + lege + 
            "\nPassient ID: " + passientId +
            "\nReit: " + reit +
            "\nPris aa betale: " + prisAaBetale() +
            "\nFarge: " + farge()
            );
    }

    
}


public class Narkotiske extends Legemiddel{
    private int styrke;

    public Narkotiske(String navn,  int pris, double mgVirkestoff, int styrke){
        super(navn, pris, mgVirkestoff);
        this.styrke = styrke;
    }

    public int hentNarkotiskStyrke(){
        return styrke;
    }

    @Override
    public String toString(){
        return "Id: " + id + 
        "\nNavn: " + navn + 
        "\nPris: " +  pris + 
        "\nMengde virkestoff: " + mgVirkestoff +
        "\nVanedannende styke: " + hentNarkotiskStyrke();
    }

}


public class Vanedannende extends Legemiddel{
    private int styrke;

    public Vanedannende(String navn,  int pris, double mgVirkestoff, int styrke){
        super(navn, pris, mgVirkestoff);
        this.styrke =  styrke;
    }

    public int hentVanedannendeStyrke(){
        return styrke;
    }

    @Override
    public String toString(){
        return "Id: " + id + 
        "\nNavn: " + navn + 
        "\nPris: " +  pris + 
        "\nMengde virkestoff: " + mgVirkestoff +
        "\nVanedannende styke: " + hentVanedannendeStyrke();
    }
}


public abstract class Legemiddel {
    protected String navn;
    protected int pris = 0;
    protected double mgVirkestoff;
    protected int id;
    private static int teller = 1;

    protected Legemiddel(String navn, int pris, double mgVirkestoff){
        this.navn = navn;
        this.pris = pris;
        this.mgVirkestoff = mgVirkestoff;
        id = teller ++;
    }

    public int hentId(){
        return id;
    }

    public String hentNavn(){
        return navn;
    }
    public int hentPris(){
        return pris;
    }

    public double hentVirkestoff(){
        return mgVirkestoff;
    }

    public void settNyPris(int nyPris){
        pris = nyPris;
    }

    @Override
    public String toString(){
        return "Id: " + id + 
        "\nNavn: " + navn + 
        "\nPris: " +  pris + 
        "\nMengde virkestoff: " + mgVirkestoff;
    }

    
}


public class VanligLegemiddel extends Legemiddel{
    public VanligLegemiddel(String navn,  int pris, double mgVirkestoff ){
        super(navn, pris, mgVirkestoff);
    }
}


public interface Godkjenningsfritak {
    // Interface
    public String hentKontrollID();    
}


Oblig-2-IN1010

Oblig 2 IN1010

public abstract class LenkeListe <T> implements Liste<T>{
    @SuppressWarnings("unchecked")
    protected T[] data = (T[]) new Object[10];
    protected int iBruk = 0;


    public int stoerrelse(){
        return iBruk;
    }

    @Override
    public void leggTil(T x) throws UgyldigListeindeks{
        if(iBruk >= data.length){
            throw new UgyldigListeindeks(iBruk + 1);
        }
        data[iBruk] = x;
        iBruk++;
    }

    @Override
    public T hent() throws UgyldigListeindeks{
        if(iBruk < 1){
            throw new UgyldigListeindeks(iBruk);   
        }
        return data[0];
    }

    @Override
    public T fjern() throws UgyldigListeindeks{
        if(iBruk < 1){
            throw new UgyldigListeindeks(iBruk);   
        }
        T res = data[0];
        for (int i = 1; i < iBruk; i++) {
            data[i-1] = data[i];
            //Fjerner det bakerste elementet.
            data[i] = null;
        }
        iBruk--;
        return res;
    }

   

public class IndeksertListe<T> extends LenkeListe<T>{

    public void leggTil (int pos, T x) throws UgyldigListeindeks{
        if(pos >= 0 || pos <= stoerrelse()){
            for (int i = stoerrelse(); i > pos ; i--){
                if(data[i-1] != null){
                    data[i] = data[i-1];
                }
            }
            data[pos] = x;
            iBruk++;
        }
        else{
            throw new UgyldigListeindeks(pos);
        }
    }

    public void sett (int pos, T x) throws UgyldigListeindeks{
        if(pos <= 0 || pos < stoerrelse()){
            data[pos] = x;
        }
        else{
            throw new UgyldigListeindeks(pos);
        }
    }

    public T hent (int pos) throws UgyldigListeindeks{
        if(pos <= 0 || pos < stoerrelse()){
            return data[pos];
        }
        else{
            throw new UgyldigListeindeks(pos);
        }

    }

    public T fjern (int pos) throws UgyldigListeindeks{
        if(pos <= 0 || pos < stoerr

class TestIndeksertListe {
    private static void info (int nr, String tekst) {
	System.out.print("Test " + nr + " " + tekst + " ... ");
    }
    
    private static void p (String s) {
	System.out.println(s);
    }

    private static boolean test (int nr, String tekst, 
				 IndeksertListe<Integer> k, int[] fasit) {
	info(nr, tekst);
	int fLen = fasit.length;
	int kLen = k.stoerrelse();
	if (kLen != fLen) {
	    p("stoerrelse() gir " + kLen + " og ikke " + fLen);
	    return false;
	}
	
	for (int i = 0;  i < fLen;  ++i) {
	    int fElem = fasit[i];
	    Integer kElem = k.fjern();
	    if (kElem == null) {
		p("fjern() gir null for element nr " + i);
		return false;
	    }
	    if (fElem != kElem) {
		p("fjern() for element nr " + i + " gir " + kElem +
		  " og ikke " + fElem);
		return false;
	    }
	}

	kLen = k.stoerrelse();
	if (kLen != 0) {
	    p("stoerrelse() etter fjerning gir " + kLen + " og ikke 0");
	    return false;
	}
	return true;
    }

    public static void main (S

class TestStabel {
    private static void info (int nr, String tekst) {
	System.out.print("Test " + nr + " " + tekst + " ... ");
    }

	// Egen test er paa linje 58 :)))
    
    private static boolean test (int nr, String tekst, Stabel<String> k, String[] fasit) {
	info(nr, tekst);
	int fLen = fasit.length;
	int kLen = k.stoerrelse();
	if (kLen != fLen) {
	    p("stoerrelse() gir " + kLen + " og ikke " + fLen);
	    return false;
	}
	
	for (int i = 0;  i < fLen;  ++i) {
	    String fElem = fasit[i];
	    String kElem = k.fjern();
	    if (kElem == null) {
		p("fjern() gir null for element nr " + i);
		return false;
	    }
	    if (! fElem.equals(kElem)) {
		p("fjern() for element nr " + i + " gir \"" + kElem +
		  "\" og ikke \"" + fElem + "\"");
		return false;
	    }
	}

	kLen = k.stoerrelse();
	if (kLen != 0) {
	    p("stoerrelse() etter fjerning gir " + kLen + " og ikke 0");
	    return false;
	}
	return true;
    }

    private static void p (String s) {
	System.out.println(s);

class TestKoe {
    private static void info (int nr, String tekst) {
	System.out.print("Test " + nr + " " + tekst + " ... ");
    }

	// Egen test er paa linje 56 :)))
    
    private static boolean test (int nr, String tekst, Koe<String> k, 
				 String[] fasit) {
	info(nr, tekst);
	int fLen = fasit.length;
	int kLen = k.stoerrelse();
	if (kLen != fLen) {
	    p("stoerrelse() gir " + kLen + " og ikke " + fLen);
	    return false;
	}
	
	for (int i = 0;  i < fLen;  ++i) {
	    String fElem = fasit[i];
	    String kElem = k.fjern();
	    if (kElem == null) {
		p("fjern() gir null for element nr " + i);
		return false;
	    }
	    if (! fElem.equals(kElem)) {
		p("fjern() for element nr " + i + " gir \"" + kElem +
		  "\" og ikke \"" + fElem + "\"");
		return false;
	    }
	}

	kLen = k.stoerrelse();
	if (kLen != 0) {
	    p("stoerrelse() etter fjerning gir " + kLen + " og ikke 0");
	    return false;
	}
	return true;
    }

    private static void p (String s) {
	System.out.println(s);

class TestPrioritetskoe {
    private static void info (int nr, String tekst) {
	System.out.print("Test " + nr + " " + tekst + " ... ");
    }
    
    private static boolean test (int nr, String tekst, Prioritetskoe<String> k, String[] fasit) {
	info(nr, tekst);
	int fLen = fasit.length;
	int kLen = k.stoerrelse();
	if (kLen != fLen) {
	    p("stoerrelse() gir " + kLen + " og ikke " + fLen);
	    return false;
	}
	
	for (int i = 0;  i < fLen;  ++i) {
	    String fElem = fasit[i];
	    String kElem = k.fjern();
	    if (kElem == null) {
		p("fjern() gir null for element nr " + i);
		return false;
	    }
	    if (! fElem.equals(kElem)) {
		p("fjern() for element nr " + i + " gir \"" + kElem +
		  "\" og ikke \"" + fElem + "\"");
		return false;
	    }
	}

	kLen = k.stoerrelse();
	if (kLen != 0) {
	    p("stoerrelse() etter fjerning gir " + kLen + " og ikke 0");
	    return false;
	}
	return true;
    }

    private static void p (String s) {
	System.out.println(s);
    }

    public sta

public class Prioritetskoe<T extends Comparable<T>> extends LenkeListe<T> {

    
    @Override
    public void leggTil(T x){
        if(stoerrelse() == 0){
            super.leggTil(x);
            return;
        }
        for (int i = 0; i < stoerrelse(); i++) {
            if(data[i].compareTo(x) > 0){
                super.leggTil(null);
                for (int j = stoerrelse()-2; j >= i; j--) {
                    data[j+1] = data[j];
                }
            data[i] = x;
            return;
            }
        }
        super.leggTil(x);
    }
}


public class Stabel<T> extends LenkeListe <T>{

    @Override
    public void leggTil(T x) throws UgyldigListeindeks{
        if(iBruk >= data.length){
            throw new UgyldigListeindeks(iBruk + 1);
        }
        // Saalenge i er storre enn null, kommer denne lokken til aa sette index[x] lik index[x-1]. 
        // Til slutt setter jeg index null lik x.
        for (int i = data.length; i > 0; i--) {
            if (data[i - 1] != null){
                data[i] = data[i-1];
            }
        }
        data[0] = x;
        iBruk ++;
    }
    
}





public class Tester {
    public static void main(String[] args){
        LenkeListe<Integer> testLenkeListe = new LenkeListe<>();
        testLenkeListe.leggTil(1);
        testLenkeListe.leggTil(2);
        testLenkeListe.leggTil(3);
        System.out.println(testLenkeListe.toString());
        System.out.println(testLenkeListe.fjern());
        System.out.println(testLenkeListe.toString());
        System.out.println(testLenkeListe.stoerrelse());


        Stabel<Integer> testStabel = new Stabel<>();

        IndeksertListe<Integer> testIL = new IndeksertListe<>();

        testIL.leggTil(0, 1);
        testIL.leggTil(1, 2);
        testIL.leggTil(2, 3);
        testIL.leggTil(3, 4);

        System.out.println(testIL.toString());
        testIL.leggTil(1, 4);

        System.out.println(testIL.toString());

    
    

    }
    
}


import javax.xml.crypto.Data;

public class Koe<T> extends LenkeListe<T> {
    // Tror ikke jeg trenger aa skrive noen nye klasser.
    // Den lenkede listen jeg lagde fungerer nemlig som en koe?
    
}


public interface Liste<T> {
    int stoerrelse() ;
    void leggTil(T x) throws UgyldigListeindeks;
    T hent() throws UgyldigListeindeks;
    T fjern() throws UgyldigListeindeks;
}

public class UgyldigListeindeks extends RuntimeException {
    UgyldigListeindeks(int indeks) {
        super("Ugyldig indeks: "+ indeks);
    }
}


Oblig-3-IN1010

Oblig 3 IN1010

public class Dataklynge {
    private Rack[] klynge = new Rack[2000];
    private int noderPerRack;
    private int setInnNodeTeller = 0;

    public Dataklynge(int noderPerRack){
    /**
    * Konstruktoren til classen. Setter hvor mange noder det skal vere i hver rack
    */
        this.noderPerRack = noderPerRack;
    }

    public void settInnNode( Node node){
     /** * Fyller opp de forskjellige rackene i klyngen. Hvis det ikke finnes noen rack, lages det en. * Hvis en rack er full, lages det en ny en.
    */
        if(setInnNodeTeller == 0){
            Rack nyRack = new Rack();
            nyRack.settInn(node);
            klynge[setInnNodeTeller] = nyRack;
        }
        else{
            for (Rack rack : klynge) {
               if(rack != null){
                if(rack.getAntNoder() < noderPerRack){
                    rack.settInn(node);

                    setInnNodeTeller ++;
                    return;
                }
                else{
                    Rac

public class Rack {
    private Node[] rackListe = new Node[12];
    private int teller = 0;

    public void settInn(Node node){
    /**
    * Setter inn en node i listen med noder,
    * inkrementerer ogsaa teller, for a fa oversikt over hvilken index neste node skal plassers i.
    */
        rackListe[teller] = node;
        teller++;
    }

    public int getAntNoder(){
    /**
    * Returnerer antall noder i racken (Liste med noder.)
    * Bruker mye forEach, fordi den er mye mer clean enn forI.
    */
        int teller = 0;
        for (Node node : rackListe) {
                teller ++;
        }
        return teller;
    }

    public int antProsessorer(){
    /**
    * Returnerer det sama antalle prosessorer i racken.
    */
        int alleRackPros = 0;

        for (Node node : rackListe) {
            if(node != null){

                alleRackPros += node.antProsessorer();
            }
        }
        return alleRackPros;
    }

    public Node[] noderMedNokMinne(int

import java.io.File;
import java.util.Scanner;

public class Hovedprogram {
    public static void main(String[] args)throws Exception {
    /**
    * Hovedprogram som tar inn dataklynger fra en .txt fil.
    * Deretter leses informasjonen i .txt-filen, og noder blir opprettet med dataen,
    * salenge informasjonen som leses ikke er ulovelig. Da kuttes programmet, og det printes ut en feilmelding.
    */
        Dataklynge saga = new Dataklynge(12);
        String dataklyngeFil = "dataklynge.txt";
        Scanner fil = new Scanner(new File(dataklyngeFil));
        String linje = "";
        boolean feilmelding = false;

        while(fil.hasNextLine() && !feilmelding){
            linje = fil.nextLine();
            String[] splitted = linje.split("\\s+");

            if (Integer.parseInt(splitted[1] ) <= 16 || Integer.parseInt(splitted[2]) <= 1024){
                for (int i = 0; i < Integer.parseInt(splitted[0]); i++) {
                    Node nyNode = new Node(Integer.parseInt(s


public class GammeltHovedprogram {

    public static void main(String[] args) {
 
        Dataklynge saga = new Dataklynge(12);

        int teller1 = 0;
        int teller2 = 0;

        while (teller1 < 450){
            Node nyNode = new Node(4, 512);
            saga.settInnNode(nyNode);
            teller1++;
        }
        while (teller2 < 16){
            Node nyNode = new Node(8, 1024);
            saga.settInnNode(nyNode);
            teller2++;
        }

        int noderMedMinst128GB = saga.noderMedNokMinne(128);
        int noderMedMinst512GB = saga.noderMedNokMinne(512);
        int noderMedMinst1024GB = saga.noderMedNokMinne(1024);



        System.out.println("Noder med minst 128 GB minne: " + noderMedMinst128GB);
        System.out.println("Noder med minst 512 GB minne: " + noderMedMinst512GB);
        System.out.println("Noder med minst 1024 GB minne: " + noderMedMinst1024GB);
        System.out.println();
        System.out.println("Antall prosessorer: " + saga

public class Node {
     /**
    * Under er instansvariablene
    */
    private int prosessorer;
    private int minnestorrelse;

    public Node(int prosessorer, int minnestorrelse){
    /**
    * Returnerer antall prosessorer en node har.
    */
        this.prosessorer = prosessorer;
        this.minnestorrelse = minnestorrelse;
    }

    public int antProsessorer(){
    /**
    * Returnerer antall prosessorer en node har.
    */
        return prosessorer;
    }

    public boolean nokMinne(int paakrevdMinne){
        
    /**
    * Sjekker om en node har nok minne i forhold til paakrevd minne.
    */
        return minnestorrelse >= paakrevdMinne;
  
    }

    
}