Przykłady obiektowe

/* Punkty.java */

class Punkt
{
  int x;
  int y;
  
  Punkt(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
  
  double odleglosc(Punkt pt)
  {
    return Math.sqrt((x - pt.x)*(x - pt.x) + (y - pt.y)*(y - pt.y));
  }
}

public class Punkty
{
  public static void main(String[] args)
  {
    Punkt A = new Punkt(2,2);
    Punkt B = new Punkt(3,3);
    
    double d = A.odleglosc(B);
    
    System.out.println("A = (" + A.x + "," + A.y + ")");
    System.out.println("B = (" + B.x + "," + B.y + ")");
    System.out.println("d(A,B) = " + d);
  }
}

A = (2,2)
B = (3,3)
d(A,B) = 1.4142135623730951
Press any key to continue...

/* LiczbyZespolone.java */

class LiczbaZespolona
{
  double re;
  double im;
  
  LiczbaZespolona(double re, double im)
  {
    this.re = re;
    this.im = im;
  }
  
  LiczbaZespolona suma(LiczbaZespolona z)
  {
    double re = this.re + z.re;
    double im = this.im + z.im;
    
    return new LiczbaZespolona(re, im);
  }
  
  LiczbaZespolona iloczyn(LiczbaZespolona z)
  {
    double re = this.re * z.re - this.im * z.im;
    double im = this.im * z.re + this.re * z.im;
    
    return new LiczbaZespolona(re, im);
  }
  
  double modul()
  {
    return Math.sqrt(re*re + im*im);
  }
}

public class LiczbyZespolone
{
  public static void main(String[] args)
  {
    LiczbaZespolona z1 = new LiczbaZespolona(1,1);
    LiczbaZespolona z2 = new LiczbaZespolona(1,0);
    
    System.out.println("z1 = (" + z1.re + "," + z1.im + ")");
    System.out.println("z2 = (" + z2.re + "," + z2.im + ")");
    
    LiczbaZespolona suma = z1.suma(z2);
    
    System.out.println("suma = (" + suma.re + "," + suma.im + ")");
    System.out.println("|suma| = " + suma.modul());
    
    LiczbaZespolona iloczyn = z1.iloczyn(z2);
    
    System.out.println("iloczyn = (" + iloczyn.re + "," + iloczyn.im + ")");
    System.out.println("|iloczyn| = " + iloczyn.modul());
  }
}

z1 = (1.0,1.0)
z2 = (1.0,0.0)
suma = (2.0,1.0)
|suma| = 2.23606797749979
iloczyn = (1.0,1.0)
|iloczyn| = 1.4142135623730951
Press any key to continue...

/* Wielomian.java */

public class Wielomian
{
  private double[] wsp;
  
  public Wielomian(double[] wsp)
  {
    this.wsp = wsp;
  }
  
  public String toString()
  {
    String row = "";
    
    for (int i = 0; i < wsp.length; i++)
    {
      if (wsp[i] != 0)
      {
        row += wsp[i] < 0 ? row.equals("") ? "-" : " - " : row.equals("") ? "" : " + ";
        row += Math.abs(wsp[i]) + (i == 0 ? "" : i == 1 ? "x" : "x^" + i);
      }
    }
    
    return row + (row.equals("") ? "0" : "");
  }
  
  public double wartosc(double x)
  {
    double suma = wsp[wsp.length - 1];
    
    for (int i = wsp.length - 2; i >= 0; i--)
    {
      suma = wsp[i] + x*suma;
    }
    
    return suma;
  }
  
  public Wielomian suma(Wielomian w)
  {
    double[] w1 = wsp;
    double[] w2 = w.wsp;
    
    int max = Math.max(w1.length, w2.length);
    
    double[] suma = new double[max];
    
    for (int i = 0; i < max; i++)
    {
      double wsp1 = i < w1.length ? w1[i] : 0;
      double wsp2 = i < w2.length ? w2[i] : 0;
      
      suma[i] = wsp1 + wsp2;
    }
    
    return new Wielomian(suma);
  }
  
  public Wielomian iloczyn(Wielomian w)
  {
    int st = wsp.length + w.wsp.length - 1;
    
    double[] w1 = wsp;
    double[] w2 = w.wsp;
    
    double[] iloczyn = new double[st];
    
    for (int i = 0; i < w1.length; i++)
    {
      for (int j = 0; j < w2.length; j++)
      {
        iloczyn[i+j] = iloczyn[i+j] + w1[i]*w2[j];
      }
    }
    
    return new Wielomian(iloczyn);
  }
  
  public Wielomian[] iloraz(Wielomian w) throws Exception
  {
    double[] w1 = wsp;
    double[] w2 = w.wsp;
    
    int st = w1.length - w2.length + 1;
    
    if (st < 1) throw new Exception("dzielenie niewykonalne");
    
    double[] iloraz = new double[st];
    double[] reszta = w1.clone();
    
    for (int k = iloraz.length - 1, i = w1.length - 1; k >= 0; k--, i--)
    {
      iloraz[k] = reszta[i] / w2[w2.length-1];
      
      for (int j = w2.length - 1; j >= 0; j--)
      {
        reszta[k + j] = reszta[k + j] - iloraz[k]*w2[j];
      }
    }
    
    return new Wielomian[]{new Wielomian(iloraz), new Wielomian(reszta)};
  }
  
  public static void main(String[] args) throws Exception
  { 
    Wielomian w1 = new Wielomian(new double[] {3,-4,5,0,2});
    Wielomian w2 = new Wielomian(new double[] {2,3,-7,4});
    
    System.out.println(w1);
    System.out.println("+");
    System.out.println(w2);
    System.out.println("=");
    System.out.println(w1.suma(w2));  
    
    System.out.println();  
        
    System.out.println(w1);
    System.out.println("*");
    System.out.println(w2);
    System.out.println("=");
    System.out.println(w1.iloczyn(w2)); 
      
    System.out.println();    
        
    System.out.println(w1);
    System.out.println(":");
    System.out.println(w2);
    System.out.println("=");
    
    Wielomian[] iloraz = w1.iloraz(w2);
    
    System.out.println(iloraz[0] + " + (" + iloraz[1] + ") / (" + w2 + ")");
        
    System.out.println();
        
    System.out.println("(" + w1 + ")(1) = " + w1.wartosc(1));
    
    System.out.println();
  }
}

3.0 - 4.0x + 5.0x^2 + 2.0x^4
+
2.0 + 3.0x - 7.0x^2 + 4.0x^3
=
5.0 - 1.0x - 2.0x^2 + 4.0x^3 + 2.0x^4

3.0 - 4.0x + 5.0x^2 + 2.0x^4
*
2.0 + 3.0x - 7.0x^2 + 4.0x^3
=
6.0 + 1.0x - 23.0x^2 + 55.0x^3 - 47.0x^4 + 26.0x^5 - 14.0x^6 + 8.0x^7

3.0 - 4.0x + 5.0x^2 + 2.0x^4
:
2.0 + 3.0x - 7.0x^2 + 4.0x^3
=
0.875 + 0.5x + (1.25 - 7.625x + 9.625x^2) / (2.0 + 3.0x - 7.0x^2 + 4.0x^3)

(3.0 - 4.0x + 5.0x^2 + 2.0x^4)(1) = 6.0

Press any key to continue...

/* OdleglosciPunktow.java */

class Punkt
{
  int x;
  int y;

  Punkt(int x, int y)
  {
    this.x = x;
    this.y = y;
  }

  public String toString() // przesłaniamy metodę z klasy Object
  {
    return "(" + x + "," + y + ")";
  }

  double odleglosc(Punkt pt)
  {
    return Math.sqrt((x - pt.x)*(x - pt.x) + (y - pt.y)*(y - pt.y));
  }

  static double odleglosc(Punkt pt1, Punkt pt2)
  {
    return pt1.odleglosc(pt2);
  }

  static Punkt losujPunkt(int obszar)
  {
    int x = (int)(Math.random()*obszar);
    int y = (int)(Math.random()*obszar);

    return new Punkt(x,y);
  }

  static Punkt[] losujPunkty(int ile, int obszar)
  {
    Punkt[] punkty = new Punkt[ile];

    for (int i = 0; i < ile; i++)
      punkty[i] = losujPunkt(obszar);

    return punkty;
  }

  static Punkt[] dwaNajblizszePunkty(Punkt[] punkty)
  {
    Punkt pt1 = punkty[0];
    Punkt pt2 = punkty[1];

    double minOdleglosc = odleglosc(pt1,pt2);

    for (int i = 0; i < punkty.length; i++)
    {
      for (int j = i + 1; j < punkty.length; j++)
      {
        double odleglosc = odleglosc(punkty[i], punkty[j]);

        if (minOdleglosc > odleglosc)
        {
          minOdleglosc = odleglosc;
          pt1 = punkty[i];
          pt2 = punkty[j];
        }
      }
    }

    return new Punkt[] {pt1,pt2};
  }

  static Punkt[] dwaNajdalszePunkty(Punkt[] punkty)
  {
    Punkt pt1 = punkty[0];
    Punkt pt2 = punkty[1];

    double maxOdleglosc = odleglosc(pt1,pt2);

    for (int i = 0; i < punkty.length; i++)
    {
      for (int j = i + 1; j < punkty.length; j++)
      {
        double odleglosc = odleglosc(punkty[i], punkty[j]);

        if (maxOdleglosc < odleglosc)
        {
          maxOdleglosc = odleglosc;
          pt1 = punkty[i];
          pt2 = punkty[j];
        }
      }
    }

    return new Punkt[] {pt1,pt2};
  }

  static void wypiszPunkty(Punkt[] punkty)
  {
    System.out.println("Punkty.");

    for (int i = 0; i < punkty.length; i++)
      System.out.println("P" + i + " = " + punkty[i]);
  }
}

public class OdleglosciPunktow
{
  public static void main(String[] args)
  {
    Punkt[] punkty = Punkt.losujPunkty(10,100);

    Punkt[] dwaNajblizsze = Punkt.dwaNajblizszePunkty(punkty);
    Punkt[] dwaNajdalsze = Punkt.dwaNajdalszePunkty(punkty);

    Punkt.wypiszPunkty(punkty);

    System.out.println("Dwa najblizsze punkty.");
    System.out.println("A = " + dwaNajblizsze[0]);
    System.out.println("B = " + dwaNajblizsze[1]);

    System.out.println("Dwa najdalsze punkty.");
    System.out.println("C = " + dwaNajdalsze[0]);
    System.out.println("D = " + dwaNajdalsze[1]);
  }
}

Punkty.
P0 = (81,91)
P1 = (20,43)
P2 = (40,79)
P3 = (29,50)
P4 = (45,95)
P5 = (63,72)
P6 = (54,55)
P7 = (46,33)
P8 = (45,12)
P9 = (12,33)
Dwa najblizsze punkty.
A = (20,43)
B = (29,50)
Dwa najdalsze punkty.
C = (81,91)
D = (12,33)
Press any key to continue...

/* KodZwarty.java */

import java.util.TreeSet;

class Wezel implements Comparable
{
  private static TreeSet wezly = new TreeSet();

  private String kod;
  private double prawd;
  private Wezel lewy;
  private Wezel prawy;

  private Wezel(String kod, double prawd, Wezel lewy, Wezel prawy)
  {
    this.kod = kod;
    this.prawd = prawd;
    this.lewy = lewy;
    this.prawy = prawy;
  }

  public int compareTo(Object obj)
  {
    return this == obj ? 0 : (prawd <= ((Wezel)obj).prawd ? -1 : 1);
  }

  public static void podajKodZwarty(String[] kod, double[] prawd)
  {
    for (int i = 0; i < kod.length; i++)
      wezly.add(new Wezel(kod[i], prawd[i], null, null));

    Wezel.utworzDrzewo().wypiszKod("");
  }

  private void wypiszKod(String kod)
  {
    if (lewy == null && prawy == null)
    {
      System.out.println(this.kod + " - " + kod);
    }
    else
    {
      lewy.wypiszKod(kod + "0");
      prawy.wypiszKod(kod + "1");
    }
  }

  private static Wezel utworzDrzewo()
  {
    Wezel lewy = (Wezel)wezly.first(); wezly.remove(lewy);

    if (wezly.isEmpty())
    {
      return lewy;
    }
    else
    {
      Wezel prawy = (Wezel)wezly.first(); wezly.remove(prawy);

      wezly.add(new Wezel(null, lewy.prawd + prawy.prawd, lewy, prawy));

      return utworzDrzewo();
    }
  }
}

public class KodZwarty
{
  public static void main(String[] args)
  {
    String[] kod = {"a", "b", "c", "d"};
    double[] prawd = {1/8.0, 1/4.0, 1/2.0, 1/8.0};

    Wezel.podajKodZwarty(kod, prawd);
  }
}

d - 000
a - 001
b - 01
c - 1
Press any key to continue...

Strona główna