Nada

LÖSNING TILL DATALOGIÖVNING 5

//  Rekursiv tanke: n!=n*(n-1)! ...men för n=1 är n!=1.
class Fakultetstabell                       { 
  static long fakultet(int n)               {
    if(n==1) return 1                       ;
    else return n*fakultet(n-1)             ;}
  public static void main(String[] args)    {
    for(int i=1; i<20; i++)                 {
      System.out.println(fakultet(i))       ;}}}

//  Rekursiv tanke: x^n =x*x^(n-1) ...men x^0=1.
class KristiKrona                           { 
  static double potens(double x, int n)     {
    if(n==0) return 1.0                     ;
    else return x*potens(x,n-1)             ;}
  public static void main(String[] args)    {
    System.out.println(potens(1.01,2000))   ;}}
// Det skrivs ut 4.392862050501041E8, alltså 439 miljoner

//  Rekursiv tanke: Antal tecken i filen = antal tecken på första
//  raden + antal tecken i resten av filen ...men tom fil har 0 tecken.
class AntalTecken                           {
  static int tkn()                          {
    if(Mio.EOF()) return 0                  ;
    else return Mio.GetLine().length()+tkn();}
    public static void main(String[] args)  {
      System.out.println("Tecken: "+tkn())  ;}}
// Körs med java AntalTecken < filnamn

//  Rekursiv tanke: Att flytta hela n-brickstornet från pinne f 
//  till pinne t = att först flytta (n-1)-tornet från pinne f till
//  den onämnda pinnen, sedan den största brickan från f till t,
//  sedan (n-1)-tornet från den onämnda pinnen till t ...men 1-torn
//  kan flyttas direkt från f till t.
class Hanoi                                 {
  static void move(int n,int f,int t)       { 
    if(n>1)  move(n-1,f,6-f-t)              ;
    System.out.println("Från "+f+" till "+t);
    if(n>1) move(n-1,6-f-t,t)               ;}	//Antal brickor: 2	
  public static void main(String[] args)    {   //Från 1 till 2
    System.out.print("Antal brickor: ")     ;   //Från 1 till 3
    move(Mio.GetInt(),1,3)                  ;}} //Från 2 till 3

// Rekursiv tanke: Att skriva ut hela stacken = att skriva ut
// topptalet och sedan skriva stacken under topposten ...men
// tom stack skrivs inte alls.
  static void write(Node p)                 {  //Anropas write(top)
    if(p==null) return                      ;
    System.out.println(p.tal)               ;  //Om dessa rader kastas om
    write(top.next)                         ;} //skrivs stacken bakvänt

// Rekursiv tanke: Summan av stackens tal = topptalet + summan
// av talen i stacken under topposten ...men tom stack har summa 0.
  static int sum(Node p)                    {  // sum(top) ger summan
    if(p==null) return 0                    ;
    return p.tal+sum(p.next)                ;}

// Rekursiv tanke: Att sudda varannan post = att sudda post nr 2 och
// sedan varannan post i stacken under den ... men strunta i tom stack.
  static void suddaVarannan(Node p)         {
    if(p==null) return                      ;
    p.next=p.next.next                      ;  //automatisk skräpsamling
    suddaVarannan(p.next)                   ;}