Polygon

[Klingel89]

Hey Leutz;
habe ein Problem. Ich soll folgende Aufgabe lösen.

1. Entwickle einen Algorithmus, um den Punkt auszugeben, der am weitesten rechts liegt.

2. Löse programmtechnisch folgende Teilaufgaben:
a) berechne alle Ecken des umschließenden Rechtecks eines Polygons
b) ermittle die kürzeste Verbindung der miteinander verbundenen Punkte des Polygons
c) ermittle den Punkt, der am dichtesten am Schwerpunkt liegt.
Gib die Ergebnisse jeweils aus.

jetzt hänge ich an der ersten Aufgabe mit dem weitesten Punkt rechts. Ich finde ja den X-Wert raus, aber wie bekomm ich den dazugehörigen Y?

[JAVA=42]
public class Polygon {

public static void main(String[] args) {
double xmin, ymax,xmax,ymin, rechts;
xmin=0; ymax=0; xmax=0; ymin=0; rechts=0;
double [][] polygon =
{
{0 , 0},
{1 , 4},
{2 , 2},
{3 , 3},
{4 , 1}
};
rechts= polygon[1][0];
for (int i=1;i<polygon.length;i++) {
if (rechts < polygon [1])rechts=polygon[1];
}

System.out.println("Anzahl der Punkte: "+polygon.length);
for (int i=0; i< polygon.length;i++) {
double x = polygon[0];
double y = polygon[1];
if (xmax < polygon[0])xmax = polygon[0]; //Bounting Box rechts oben
if (ymax < polygon[1])ymax = polygon[1]; //Bounting Box rechts unten
if (xmin > polygon[0])xmin = polygon[0]; //Bounting Box links oben
if (ymin > polygon[1])ymin = polygon[1]; //Bounting Box links unten
}

System.out.println("Rechts: "+rechts);
System.out.println("Bounting Box rechts oben X;Y : "+xmax+" ; "+ymax);
System.out.println("Bounting Box rechts unten X;Y : 0.0 ; "+ymax);
System.out.println("Bounting Box links oben X;Y : "+xmin+" ; "+ymax);
System.out.println("Bounting Box links unten X;Y : "+xmin+" ; "+ymin);

}
}
[/code]

 

[SlaterB]

du brauchst den größen/ kleinsten x-Wert und den größten/ kleinsten y-Wert,
hier etwas ungünstig, ist jeweils 0 und 4, kann zu nicht-bemerkten Verwechslungen der Variablen führen, nimm lieber ein eindeutigeres Beispiel,

das umschließende Rechteck hat dann als Punkte die Kombinationen aus den 4 Werten draus,
mal das doch auf Papier auf

 

[Klingel89]

na meine Bounting Box ist ja richtig, mir gehts nur um den weitesten Punkt rechts bestimmen.

1. Entwickle einen Algorithmus, um den Punkt auszugeben, der am weitesten rechts liegt.

habe ja so angefangen, was aber glaube ich totaler quatsch ist.

public class Polygon {

  public static void main(String[] args) {
    double xmin, ymax,xmax,ymin, rechts;
    xmin=0; ymax=0; xmax=0; ymin=0; rechts=0;
    double [][] polygon =
    {
      {0 , 0},
      {1 , 4},
      {2 , 2},
      {3 , 3},
      {4 , 1}
    };
    rechts= polygon[1][0];
    for (int i=1;i<polygon.length;i++) {
      if (rechts < polygon [i][1])rechts=polygon[1][i];
    }
    System.out.println("Rechts: "+rechts);

 

[SlaterB]

ich dachte jetzt an ein rechtwinkliges normalorientiertes Rechteck
0,0, 0,4 4,4 4,0

ist es das? dann immer noch wie im letzten Post beschieben,

mit mehr Aufwand könnte man natürlich auch ein schräges Rechteck um das Polygon bauen, dann wirds komplizierter

edit:
ach ich bin bei 2.) a), nicht bei 1.)
ich schreib dann bald ne neue Antwort wenn mir dazu was einfällt

 

[SlaterB]

so, 2 min. später

also das kann doch nur einer der Eckpunkte sein,
während du dir das größte x suchst, musst du auch immer den dazugehörigen Punkt, also nur noch das fehlende y mit abspeichern,
kommt später ein besseres x, dann sowohl rechtsx als auch rechtsy überschreiben

 

[Klingel89]

erstmal danke schonmal für die Anworten

ja genau darum geht es mir, zum größten x, dass dazugehörige y anzeigen lassen. und da scheiter ich^^
den x wert bekomm ich ja raus mit Rechts= 4

 

[SlaterB]

Heute, 15:54 gelesen?

 

[Klingel89]

ich habe jetzt die ersten Aufgaben gelöst bekommen, aber nun frag ich mich, wie ich am besten die Strecken der Punkte berechne und vergleiche.

Mein Programm bisher...

public class NEU {

  public static void main(String[] args) {
  
  double xmin, ymax,xmax,ymin, sum;
  xmin=0; ymax=0; xmax=0; ymin=0; sum=0;
  System.out.println("-------------------------------------------------");
  System.out.println("Geben Sie mindestens 2 Punkte ein!");
  System.out.println("-------------------------------------------------");
  int Anzahl=IOTools.readInteger("Wieviel Punkte moechten Sie eingeben?: ");
  double [][] polygon;
  polygon = new double [Anzahl][Anzahl];
  for (int i=0; i<Anzahl;i++){
      polygon[i][0]=IOTools.readDouble("Punkt "+(i+1)+" Geben Sie Ihren X-Wert ein!: ");
      polygon[i][1]=IOTools.readDouble("Punkt "+(i+1)+" Geben Sie Ihren Y-Wert ein!: ");
  }

  System.out.println("-------------------------------------------------");
  System.out.println("Anzahl der Punkte: "+polygon.length);
  System.out.println("-------------------------------------------------");

  for (int i=0; i< polygon.length;i++) {
      double x = polygon[i][0];
      double y = polygon[i][1];
      if (xmax < polygon[i][0])xmax = polygon[i][0];         //Bounting Box rechts oben
      if (ymax < polygon[i][1])ymax = polygon[i][1];         //Bounting Box rechts unten
      if (xmin > polygon[i][0])xmin = polygon[i][0];         //Bounting Box links oben
      if (ymin > polygon[i][1])ymin = polygon[i][1];         //Bounting Box links unten
      }
  double y = polygon[0][1];                                  //Punkt am weitesten Rechts
    for (int i = 0; i<polygon.length; i++) {
      if (xmax == polygon[i][0]) {
        y = polygon[i][1];
      }
    }

    System.out.println("Der Punkt am weitesten rechts ist X;Y : "+xmax+" ; "+y);
    System.out.println("-------------------------------------------------");
    System.out.println("Bounting Box rechts oben  X;Y : "+xmax+" ; "+ymax);
    System.out.println("Bounting Box rechts unten X;Y : 0.0 ; "+ymax);
    System.out.println("Bounting Box links  oben  X;Y : "+xmin+" ; "+ymax);
    System.out.println("Bounting Box links  unten X;Y : "+xmin+" ; "+ymin);

  }
}

 

[SlaterB]

2b oder wie?
eine Möglichkeit wäre, alle Kombinationen durchzuprobieren und die kürzeste zu wählen

 

[agentone]

Du brauchst zwei ineinander verschachtelte for-Schleifen in denen du jeweils allle Punkte durchgehst. Dann guckst du, ob die Punkte verschieden sind. Und wenn ja, dann berechnest du die Entfernung mit Satz des Pythagoras.

Pseudocode:

polygon=neues Polygon; (als liste von punkten)
entfernung=Integer.MAX_VALUE;

for(i : alle punkte aus polygon)
{
 for(j : alle punkte aus polygon)
 {
   wenn(i ungleich j) dann 
    {d=entfernung aus polygon[i] und polygon[j];
     wenn (d kleiner als entfernung) dann {entfernung=d;} }
 }
}

PS: Ich möchte dich darauf hinweisen, dass das "Bounding Box" heißt.

 

[Klingel89]

polygon=neues Polygon; (als liste von punkten)

so viel Ahnung von Java habe ich nun auch noch nicht, daher weiß ich nicht, wie ich das neue polygon als liste von Punkten anlegen soll.

Danke für Bounding Box, wäre peinlich geworden^^

 

[SlaterB]

so wie du es schon hast:

polygon = new double [Anzahl][Anzahl];
for (int i=0; i<Anzahl;i++){
...

 

[Klingel89]

habe das nun so gelöst...

  polygon = new  double [Anzahl][Anzahl];
  entfernung = Integer.MAX_VALUE;
  for(int i=0;i<Anzahl;i++){
    for(int j=0;j<Anzahl;i++){
      if(i != j){
      double d = i-j;
        if (d<entfernung){
          entfernung=d;
        }
      }
   }
  }

aber er macht nix.

 

[SlaterB]

na gelöst ist da doch nix, das double[][] ist leer, ich meinte deine bisherigen Programme, wo es befüllt war
(besser erstmal mit Testwerten statt Benutzereingaben)

in deiner Schleife rechnest du dann nur mit Indexen, das Array wird überhaupt nicht verwendet!
irgendwas musst du mit den Punkten schon machen, wenn es um die geht,

was genau in der Aufgabe gefordert wird, ist aber gewiss noch ein Problem für sich, das hat mit Java/ Programmierung wenig bis gar nichts zu tun,
male dir erstmal ein Beispiel auf Papier auf, und was dann ungefähr berechnet werden soll

 

[Klingel89]

habs nun so gelöst und funktioniert

  double[] abstand = new double[polygon.length];                                                         //kürzesten Abstand berechnen

      for (int i = 0; i<polygon.length-1; i++) {
      double x1 = polygon[i][0], y1 = polygon[i][1];
      double x2 = polygon[i+1][0], y2 = polygon[i+1][1];
      abstand [i] = abstandsp(x1,y1,x2,y2);
      if (i <= polygon.length) {
        x1 = polygon[0][0];
        y1 = polygon[0][1];
        x2 = polygon[polygon.length-1][0];
        y2 = polygon[polygon.length-1][1];
        abstand[i] = abstandsp(x1,y1,x2,y2);
      }
     }
  double kabstand = abstand[0];
    for (int k = 0; k<polygon.length-1; k++) {
      if (abstand[k] < kabstand) {
        kabstand = abstand[k];
      }
    }