Oppgave 1

Bil   0,1   -  0,1  P- Plass   mange  -   1  P-Hus

  |          \

HandicapBil     Buss


Oppgave 2.

class PHhus {
  int antall;
  PPlass [ ] plasser ;
  PHus (int ant) { plasser = new PPlass [ant]; antall = ant;}
}

class PPlass {
  int bredde, lengde; Bil bilen; boolean ledig = false;
  PPlass (int ln, int br) {bredde = br; lengde = ln;}
}

class Bil {
  String regNo; int hoyde, bredde, lengde;
   Bil  (int ho, int ln, int br, String st) {hoyde = ho; bredde = br;
lengde = ln; regNo = st;}
}

HandicapBil extends Bil {
   int ident;
    HandicapBil  (int ho, int ln, int br, String st, int id) {
         super(ho, ln, br, st); ident = id;
    }
 }

Buss extends Bil {
   int antall;
    Buss (int ho, int ln, int br, String st, int ant) {
         super(ho, ln, br, st); antall = ant;
    }
 }


Oppgave 3.

IngenMinibussException extends Exception { }

MiniBuss extends Buss {
MiniBuss (int ho, int ln, int br, String st, int ant) throws
IngenMinibussException {
             super(ho, ln, br, st, ant);
             if ( antall > 16) throw new IngenMinibussException ( );
}


Oppgave 4

i class PPlass:

boolean plassOK(Bil bln) {
    xBredde = 20; xLengde = 20;
     if (bln instanceof HCPBil) xBredde = 100;
     return (lengde > bln.lengde + xLengde  &  bredde > bln.bredde +
xBredde);
  }

boolean parker (Bil bln) {
if (ledig & (! (bln instanceof  Buss   &  ! bln.instanceof MiniBuss)  &
plassOK(bln )
   { ledig = false; bilen = bln; return true;} else return false;
  }


class HCPPlass extends PPlass {
  PPlass (int ln, int br) {super (ln, br);}
   boolean parker (Bil bln) {
   if (ledig & bln instanceof  HCBil & plassOK(bln) )
   { ledig = false; bilen = bln; return true;} else return false;
  }
}


class BussPPlass extends PPlass {
  PPlass (int ln, int br) {super(ln,br);}
 boolean parker (Bil bln) {
   if (ledig & bln instanceof  Buss & plassOK(bln) )
   { ledig = false; bilen = bln; return true;} else return false;

}



Oppgave 5.


class IkkeLedigPlassException extends Exception { }

I class PHus

int parker (Bil bl) throws IkkeLedigPlassException { boolean funnet =
false; int i ;
   for (i = 0;  i < antPlasser & ! funnet ; i ++)
      funnet = plasser [i]. parker(bl);
   if  (! funnet )  throw new IkkeLedigPlassException ( );
   return i-1;
}

Oppgave 6

interface Reservert {
  String harReservert ( ) ;
}
interface HoydeBegrenset {
  int tillattHoyde ( ) ;
}


Oppgave 7


class HC_HB_Res extends HcPPlass implements Hoydebegrensning, Reservert {
  int maxHøyde;
  String reservator;
  String harReservert ( ) { return reservator; }
  int tillattHoyde ( ) { return maxHoyde; }

  HAC_HB_Res ( int ln, int br, String res; int hoyde) {
    super (ln, br); reservator = res; maxHoyde = hoyde;
  }

NEI:
  boolean parker (Bil bl);
  return
     (bl.regNummer.equals(reservator) && bl.hoyde < maxHoyde  &&
super.reserver(bl));
  }



Oppgave 8


HasMap finnIkkeReservert ( ) {
HashMap kart = new HashMap ( );
for (int ind = 0 , ind < antall ; ind ++) {
  PPlass pl = parkering[ind];
  if ( ! pl.ledig) {
    // reservert:
    if (pl instanceof   Reservert) {
      if  (!((Rservert)pl).harReservert.equals(bilen.regNo))
             kart.put(bilen.regNo, bilen);
    }
     return kart;
}

################## TELEFONNUMMER ###############################
################################################################

class Tlfnr {

  public static void main(String[] args) {
    String argument = args[0];
    Nummer n = new Nummer(argument);
    System.out.println("Antall siffer er " + n.antallSiffer);
    System.out.println("Nummer-arrayen følger her:");
    n.skrivUtNr();
    n.genererOrdAvskj(0);
    n.skrivUtOrdListe();
  }

}

class Uqbarsk {
  public boolean erOrd (char [] ord) { return true; };
  public boolean erStartPaaOrd (char [] ord) { 
    if (ord[0] == 'h') return false;
    else return true;
  };
}    
  

class Ord {
  String ordet;
  Ord neste;

  Ord (String s){
    ordet = s;
    neste = null;
  }

  String hentOrd() {return ordet; };
}

// ############## OPPGAVE 9 ##############

class Nummer {
  int forste; long resten; //gammel, ikke brukt struktur
  int [] nr;               //nummeret siffer for siffer
  int antallSiffer;        //antall siffer i nummerert

  char [] tekststreng;     //bokstavarray som brukes for
                           //å generere ordkandidater

  char [] ordSaaLangt;     //bokstavarray for starten av et mulig ord

  Ord ordliste;            //peker til listen av ord som
                           //dette nummeret svarer til

  Uqbarsk uqb = new Uqbarsk(); //objekt med sjekkemetodene.

  Nummer (String tlfnr) {
    antallSiffer = tlfnr.length();
    nr = new int[antallSiffer];
    tekststreng = new char[antallSiffer];
    
    for (int j=0; j<antallSiffer; j++) {
      int ascii = (int) tlfnr.charAt(j);
      nr[j] = ascii - 48;
    }
  }

// Enda enklere blir det om nr er av type char. Da må metoden
// siffer_til_string skrives om (endre type for parameter).

  void tungvindt_Nummer (long tlfnr) {
    // konstruktøren blir litt mer fiklete hvis telfunnummeret er
    // et heltall. Dessuten blir det vanskelig med evt ledende nuller
    // Er med her fordi jeg laget den først.

    int k = 0;
    long n = tlfnr;
    while ( n/10 != 0 ) {
      n/= 10 ;
      k++ ;
    }
    antallSiffer = k + 1;
    nr = new int[antallSiffer];
    tekststreng = new char[antallSiffer];
    long nummeret = tlfnr;
    long tierpotens = 1;
    for (int j=0; j<antallSiffer; j++) {
      nr[j] = (int) (nummeret % 10);
      nummeret /= 10;
    }

    forste = (int) n;
    tierpotens = 1;
    while ( k-- != 0 ) tierpotens *= 10;
    resten = tlfnr - forste*tierpotens;
  }

  //Hjelpemetode som skriver ut arrayen nr[]
  public void skrivUtNr() {
    for (int i = 0; i < antallSiffer; i++)
      System.out.println("nr["+i+"]="+nr[i]);
  }
  

  String siffer_til_string (int i) {
    String s = "";
       switch (i) {
       case 0: s = new String (""); break;
       case 1: s = new String ("æøå"); break;
       case 2: s = new String ("abc"); break;
       case 3: s = new String ("def"); break;
       case 4: s = new String ("ghi"); break;
       case 5: s = new String ("jkl"); break;
       case 6: s = new String ("mno"); break;
       case 7: s = new String ("pqrs"); break;
       case 8: s = new String ("tuv"); break;
       case 9: s = new String ("wxyz"); break;
    }
    return s;
  }

// ############## OPPGAVE 10 ##############

  public void leggOrdTilListe(String s) {
    Ord nyttord = new Ord(s);
    nyttord.neste = ordliste;
    ordliste = nyttord;
  }

// ############## OPPGAVE 11 ##############

  public void genererOrd(int k) {
    String bokstaver = siffer_til_string(nr[k]);
    //    Putter en og en bokstav iht nr[k]
    //    ned i teksstreng[k] Hvis dette var
    //    første siffer (basis, k=0) er teksstrengen ferdig og det undersøkes om vi
    //    har et ord og setter evt, inn i liste. Hvis ikke
    //    (k>0, rekursiv gren) generes alle tekststrenger som svarer til resten
    //    av (den første delen) nr[0:k-1].
    for (int j=0; j< bokstaver.length(); j++) {
      tekststreng[k] = bokstaver.charAt(j);
      if (k==0){ 
	// første siffer 
	if ( uqb.erOrd(tekststreng) ) {
	  // legger ordet inn i lista
	  String nyttord = new String(tekststreng);
	  leggOrdTilListe(nyttord);
	} // hvis ikke gjøres ingenting
      }
      else 
	// k > 0; rekursiv gren
	genererOrd(k-1);
    }
  }

// ############## OPPGAVE 12 ##############
	  
  public void genererOrdAvskj(int k) {
    String bokstaver = siffer_til_string(nr[k]);
    //    Putter en og en bokstav iht nr[k] 
    //    ned i teksstreng[k] Hvis dette var 
    //    siste siffer (basis, k=antallSiffer -1) er teksstrengen
    //    ferdig og det undersøkes om vi 
    //    har et ord og setter evt, inn i liste. Hvis ikke 
    //    (k>0, rekursiv gren) generes alle tekststrenger som svarer til resten 
    //    av (den første delen) nr[0:k-1]. 
    for (int j=0; j< bokstaver.length(); j++) {
      tekststreng[k] = bokstaver.charAt(j);
      if (k==antallSiffer-1){
        // k peker ut siste siffer 
        if ( uqb.erOrd(tekststreng) ) {
          // legger ordet inn i lista 
          String nyttord = new String(tekststreng);
          leggOrdTilListe(nyttord);
        } // hvis ikke gjøres ingenting 
      }
      else {
        // k < antallSiffer -1 ; rekursiv gren
	ordSaaLangt = new char [k+1];
	for (int i=0; i<=k; i++) ordSaaLangt[i] = tekststreng[i];
	if ( uqb.erStartPaaOrd(ordSaaLangt) ) genererOrdAvskj(k+1);
      }
    }
  }

  public void skrivUtOrdListe() {
    for (Ord o = ordliste; o != null; o = o.neste)
	    System.out.println(o.hentOrd());
  }

      

} // end class Nummer