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