Dokumentation zur Spezifikation 3077
Thomas Laner
E-Mail:thomas.laner@aon.at
Mnr: 0125355

Packages werden importiert...
import eprog.*;
import java.lang.Math.*;
enthält die verwendeten mathematischen Funktionen (wie z.B.:sqrt, abs, min max...)

public class Dreieck extends EprogIO
{
Bemerkung zu den einzelnen Methoden: es wurde ueberall wie verlangt eine Toleranz von 0.3 angenommen
	Methode zur Flaechenberechnung...
public static float getFlaeche(float[] Dreieck)
{	float Flaeche;
	Flaeche=Dreieck[1]*Dreieck[2]/2;
	return Flaeche;
}

	Methode zur Ueberpruefung des Rechten Winkels...
public static boolean checkRW (float Seite[])
{
boolean check=false;
float d;
d = Math.abs((Seite[3]*Seite[3])-(Seite[2]*Seite[2])-(Seite[1]*Seite[1]));  //Hypothenuse[3]- Katheten[1],[2](egal welche größer!weil Abolutbetrag)
	abs ist der Absolutbertrag, da ich nicht weis ob Kath1 oder Kath2 größer ist...
	und deshalb ist z.B. auch -0.1 korrekt
if(d<=0.3)check=true;
return check;}

	Methode zur Ueberpruefung der Gleichschenkeligkeit...
public static boolean checkGSCH (float Seite[]) 
{	boolean check=false;
	float d;
	d=Math.abs(Seite[1]-Seite[2]); Differenz der beiden Katheten[1],[2]
	if(d<=0.3){check=true;}
	return check;
}
	Methode zur Ueberpruefung ob 2Dreiecke identisch sind ond somit ein Quadrat bilden...
public static boolean check2D (float[] Dreieck1,float[] Dreieck2)//2id Dreiecke?
{	boolean check=false;
	int idSeiten=0;
	float d;
	for(int i=1;i<=3;i++)
	{for(int ii=1;ii<=3;ii++)
		{	d=Math.abs(Dreieck1[i]-Dreieck2[ii]);
			if(d<=0.3){idSeiten++;break;}}
	}
	if(idSeiten==3){check=true;}
	return check;
}
  	Methode zur Ueberpruefung ob drei Dreiecke ein Quadrat bilden
	dabei gibt es nur eine Moeglichkeit und zwar müssen 2 Dreieck ident sein und 
	zusammengelegt ident mit dem 3. sein
public static boolean check3D(float[] Dreieck1,float[] Dreieck2,float[] Dreieck3)
{	boolean check=false;
	float[] DreieckNeu=new float[4];
	
	
	if(check2D(Dreieck1,Dreieck2)==true||check2D(Dreieck1,Dreieck3)==true)
	{	DreieckNeu[3]=2*Dreieck1[1]; ...Kathete[1] mal 2 (egal welche Kath ich zslege weil GSCH)
		DreieckNeu[1]=Dreieck1[3]; ...beide KathetenNeu sind jeweils die Hypothenusen von 1 und 3	
		DreieckNeu[2]=DreieckNeu[1]; ...gleichschenkelig
					
		if(check2D(Dreieck3,DreieckNeu)==true){check=true;}
	}
	
	else if(check2D(Dreieck2,Dreieck3)==true)
	{	DreieckNeu[3]=2*Dreieck2[1];
		DreieckNeu[1]=Dreieck2[3];
		DreieckNeu[2]=DreieckNeu[1];
			
		if(check2D(Dreieck1,DreieckNeu)==true){check=true;}
	}	
return check;
}
	Methode zur Ueberpruefung von 4Dreiecken....
	mehrere Moeglichkeiten....
public static boolean check4D(float[] Dreieck1,float[] Dreieck2,float[] Dreieck3,float[] Dreieck4)  	
{	boolean check=false;	
  	float d;
  	double a; 
	virtuelle Quadratseite(wuerden die 4 Dreiecke zsgelegt ein Quadrat ergeben waere
	dies die Seite a des Quadrats (siehe Verwendung weiter unten)
	
4gleichschenkelige D, 2id zsg id mit 3.en widerum zsgl id mit 4.en! (I/O File Fall)  	
  	if(check2D(Dreieck1,Dreieck2)==true && check2D(Dreieck3,Dreieck4)==true && check2D(Dreieck2,Dreieck3))
  	{check=true;return check;}//4identischeDreiecke(egal ob GSCH oder nicht!)
  	
  	if(checkGSCH(Dreieck1)==true&&checkGSCH(Dreieck2)==true&&checkGSCH(Dreieck3)==true&&checkGSCH(Dreieck4)==true)	
  	{	if(check3D(Dreieck1,Dreieck2,Dreieck3)==true)
  			{d=Math.abs(getFlaeche(Dreieck1)+getFlaeche(Dreieck2)+getFlaeche(Dreieck3)-getFlaeche(Dreieck4));
  				if(d<=0.3){check=true;return check;}}
  				
  		if(check3D(Dreieck1,Dreieck2,Dreieck4)==true)
  			{d=Math.abs(getFlaeche(Dreieck1)+getFlaeche(Dreieck2)+getFlaeche(Dreieck4)-getFlaeche(Dreieck3));
  				if(d<=0.3){check=true;return check;}}
  		
  		if(check3D(Dreieck1,Dreieck3,Dreieck4)==true)
  			{d=Math.abs(getFlaeche(Dreieck1)+getFlaeche(Dreieck3)+getFlaeche(Dreieck4)-getFlaeche(Dreieck2));
  				if(d<=0.3){check=true;return check;}}
  		
  		if(check3D(Dreieck2,Dreieck3,Dreieck4)==true)
  			{d=Math.abs(getFlaeche(Dreieck2)+getFlaeche(Dreieck3)+getFlaeche(Dreieck4)-getFlaeche(Dreieck1));
  				if(d<=0.3){check=true;return check;}}
	} 
je 2 miteinander identische
dabei muss 1Kathete von allen gleich jedoch gleich sein
die beiden verschieden Katheten von 2 verschiedenen D muss zs gleichlang sein 
wie die gleiche Seite(=Quadratseite)! 	
  	if(checkGSCH(Dreieck1)==false&&checkGSCH(Dreieck2)==false&&checkGSCH(Dreieck3)==false&&checkGSCH(Dreieck4)==false)
  	{	
  		if(check2D(Dreieck1,Dreieck2)&&check2D(Dreieck3,Dreieck4))
  		{  	if(Dreieck1[1]==Dreieck3[1])
  				{d=Math.abs(Dreieck1[2]+Dreieck3[2]-Dreieck1[1]);if(d<=0.3){check=true;return check;}}
  			
  			if(Dreieck1[2]==Dreieck3[2])
  				{d=Math.abs(Dreieck1[1]+Dreieck3[1]-Dreieck1[2]);if(d<=0.3){check=true;return check;}}
  			
  			if(Dreieck1[1]==Dreieck3[2])
  				{d=Math.abs(Dreieck1[2]+Dreieck3[1]-Dreieck1[1]);if(d<=0.3){check=true;return check;}}
  		}
  		if(check2D(Dreieck1,Dreieck3)&&check2D(Dreieck2,Dreieck4)||check2D(Dreieck1,Dreieck4)&&check2D(Dreieck2,Dreieck3))
  		//2.if(check2D...)mit // zsfassbar weil ich trotz andere id Zsstellung die beiden gl D vergleiche!
  		{  	if(Dreieck1[1]==Dreieck2[1])
  				{d=Math.abs(Dreieck1[2]+Dreieck2[2]-Dreieck1[1]);if(d<=0.3){check=true;return check;}}
  			
  			if(Dreieck1[2]==Dreieck2[2])
  				{d=Math.abs(Dreieck1[1]+Dreieck2[1]-Dreieck1[2]);if(d<=0.3){check=true;return check;}}
  			
  			if(Dreieck1[1]==Dreieck2[2])
  				{d=Math.abs(Dreieck1[2]+Dreieck2[1]-Dreieck1[1]);if(d<=0.3){check=true;return check;}}
  		}
  	}
4verschiedene nicht GSCH Dreiecke (virtuelle Quadratseite= die grössere Kathete zweier D)
und bei den anderen beiden Dreiecken gleicht
die Hypothenuse eines D der kleineren Kathete des anderen   	
  	if(checkGSCH(Dreieck1)==false&&checkGSCH(Dreieck2)==false&&checkGSCH(Dreieck3)==false&&checkGSCH(Dreieck4)==false)
  	{	double GesamtFlaeche;
  		GesamtFlaeche=getFlaeche(Dreieck1)+getFlaeche(Dreieck2)+getFlaeche(Dreieck3)+getFlaeche(Dreieck4);
  		a=Math.sqrt(GesamtFlaeche);
  			if(Math.abs(Math.max(Dreieck1[1],Dreieck1[2])-a)<=0.3&&Math.abs(Math.max(Dreieck2[1],Dreieck2[2])-a)<=0.3)
  				if(Math.abs(Dreieck3[3]-Math.min(Dreieck4[1],Dreieck4[2]))<=0.3||Math.abs(Dreieck4[3]-Math.min(Dreieck3[1],Dreieck3[2]))<=0.3)
  					{check=true;return check;}
  		
  			if(Math.abs(Math.max(Dreieck1[1],Dreieck1[2])-a)<=0.3&&Math.abs(Math.max(Dreieck3[1],Dreieck3[2])-a)<=0.3)
  				if(Math.abs(Dreieck2[3]-Math.min(Dreieck4[1],Dreieck4[2]))<=0.3||Math.abs(Dreieck4[3]-Math.min(Dreieck2[1],Dreieck2[2]))<=0.3)
  					{check=true;return check;}
  		
  			if(Math.abs(Math.max(Dreieck1[1],Dreieck1[2])-a)<=0.3&&Math.abs(Math.max(Dreieck4[1],Dreieck4[2])-a)<=0.3)
  				if(Math.abs(Dreieck2[3]-Math.min(Dreieck3[1],Dreieck3[2]))<=0.3||Math.abs(Dreieck3[3]-Math.min(Dreieck2[1],Dreieck2[2]))<=0.3)
  					{check=true;return check;}
  			
  			if(Math.abs(Math.max(Dreieck2[1],Dreieck2[2])-a)<=0.3&&Math.abs(Math.max(Dreieck3[1],Dreieck3[2])-a)<=0.3)
  				if(Math.abs(Dreieck1[3]-Math.min(Dreieck4[1],Dreieck4[2]))<=0.3||Math.abs(Dreieck4[3]-Math.min(Dreieck1[1],Dreieck1[2]))<=0.3)
  					{check=true;return check;}
  
  			if(Math.abs(Math.max(Dreieck2[1],Dreieck2[2])-a)<=0.3&&Math.abs(Math.max(Dreieck4[1],Dreieck4[2])-a)<=0.3)
  				if(Math.abs(Dreieck1[3]-Math.min(Dreieck3[1],Dreieck3[2]))<=0.3||Math.abs(Dreieck3[3]-Math.min(Dreieck1[1],Dreieck1[2]))<=0.3)
  					{check=true;return check;}
 
 	 		if(Math.abs(Math.max(Dreieck3[1],Dreieck3[2])-a)<=0.3&&Math.abs(Math.max(Dreieck4[1],Dreieck4[2])-a)<=0.3)
  				if(Math.abs(Dreieck1[3]-Math.min(Dreieck2[1],Dreieck2[2]))<=0.3||Math.abs(Dreieck2[3]-Math.min(Dreieck1[1],Dreieck1[2]))<=0.3)
  					{check=true;return check;}
  } 
4verschiedene nicht GSCH Dreiecke (virtuelle Quadratseite wie oben) 
bei den anderen beiden gleicht die kleinere Hypothenuse der Quadratseite 
und die grössere gleicht einer der Hypothenusen der beiden D mit 
der größeren Kathete als die virt Quadratseite! 	
  	if(checkGSCH(Dreieck1)==false&&checkGSCH(Dreieck2)==false&&checkGSCH(Dreieck3)==false&&checkGSCH(Dreieck4)==false)
  	{	double GesamtFlaeche;
  		GesamtFlaeche=getFlaeche(Dreieck1)+getFlaeche(Dreieck2)+getFlaeche(Dreieck3)+getFlaeche(Dreieck4);
  		a=Math.sqrt(GesamtFlaeche);
  			if(Math.abs(Math.max(Dreieck1[1],Dreieck1[2])-a)<=0.3&&Math.abs(Math.max(Dreieck2[1],Dreieck2[2])-a)<=0.3)
  				if(Math.abs(Math.min(Dreieck3[3],Dreieck4[3])-a)<=0.3&&Math.abs(Math.max(Dreieck3[3],Dreieck4[3])-Dreieck1[3])<=0.3||Math.abs(Math.max(Dreieck3[3],Dreieck4[3])-Dreieck2[3])<=0.3)
  					{check=true;return check;}
  				
  			if(Math.abs(Math.max(Dreieck1[1],Dreieck1[2])-a)<=0.3&&Math.abs(Math.max(Dreieck3[1],Dreieck3[2])-a)<=0.3)
  				if(Math.abs(Math.min(Dreieck2[3],Dreieck4[3])-a)<=0.3&&Math.abs(Math.max(Dreieck2[3],Dreieck4[3])-Dreieck1[3])<=0.3||Math.abs(Math.max(Dreieck2[3],Dreieck4[3])-Dreieck3[3])<=0.3)
  					{check=true;return check;}
  		
  			if(Math.abs(Math.max(Dreieck1[1],Dreieck1[2])-a)<=0.3&&Math.abs(Math.max(Dreieck4[1],Dreieck4[2])-a)<=0.3)
  				if(Math.abs(Math.min(Dreieck2[3],Dreieck3[3])-a)<=0.3&&Math.abs(Math.max(Dreieck2[3],Dreieck3[3])-Dreieck1[3])<=0.3||Math.abs(Math.max(Dreieck2[3],Dreieck3[3])-Dreieck4[3])<=0.3)
  					{check=true;return check;}
  			
  			if(Math.abs(Math.max(Dreieck2[1],Dreieck2[2])-a)<=0.3&&Math.abs(Math.max(Dreieck3[1],Dreieck3[2])-a)<=0.3)
  				if(Math.abs(Math.min(Dreieck1[3],Dreieck4[3])-a)<=0.3&&Math.abs(Math.max(Dreieck1[3],Dreieck4[3])-Dreieck2[3])<=0.3||Math.abs(Math.max(Dreieck1[3],Dreieck4[3])-Dreieck3[3])<=0.3)
  					{check=true;return check;}
  
  			if(Math.abs(Math.max(Dreieck2[1],Dreieck2[2])-a)<=0.3&&Math.abs(Math.max(Dreieck4[1],Dreieck4[2])-a)<=0.3)
  				if(Math.abs(Math.min(Dreieck1[3],Dreieck3[3])-a)<=0.3&&Math.abs(Math.max(Dreieck1[3],Dreieck3[3])-Dreieck2[3])<=0.3||Math.abs(Math.max(Dreieck1[3],Dreieck3[3])-Dreieck4[3])<=0.3)
  					{check=true;return check;}
  					
 	 		if(Math.abs(Math.max(Dreieck3[1],Dreieck3[2])-a)<=0.3&&Math.abs(Math.max(Dreieck4[1],Dreieck4[2])-a)<=0.3)
  				if(Math.abs(Math.min(Dreieck1[3],Dreieck2[3])-a)<=0.3&&Math.abs(Math.max(Dreieck1[3],Dreieck2[3])-Dreieck3[3])<=0.3||Math.abs(Math.max(Dreieck1[3],Dreieck2[3])-Dreieck4[3])<=0.3)
  					{check=true;return check;}
  }
  	return check;
}
Die Methoden mit den leichter und schwerer verständlichen Fällen der Zusammenlegung
(es sind übrigens alle!!!)
wären geschafft und jetzt die Main...

public static void main (String[] args) throws EprogException
{	boolean EingabeFehler=false;
	boolean ende=false;
	int DAnzahl=0;	//Dreiecksanzahl
	int SeitenZaehler=0;
	float Dreieck1[]=new float[4];
	float Dreieck2[]=new float[4];
	float Dreieck3[]=new float[4];
	float Dreieck4[]=new float[4];
	float d;
	int indexmemo=0;
	float Seitenmemo;	Hilfsvariablen um die Hypothenuse ggfls an die 3. Stelle zu setzen
				siehe Einlesen der Dreiecke....
	do{
	Einlesen der Dreiecksanzahl...
	try
	{DAnzahl+=readInt();
	if(DAnzahl<2||DAnzahl>4)
	{println("FALSCHE EINGABE");System.exit(0);}
	}
	catch(Exception e)
	{EingabeFehler=true;}
	
	sollte das Einlesen der Dreiecksanzahl korrekt gewesen sein gehts hier weiter...
	Einlesen der Dreiecke...
	while(EingabeFehler==false)	
		{for(int i=1;i<=3;i++)	//Ignoranz der Stelle 0 (aus Übersichtlichkeitsgründen)
		{try{Dreieck1[i]=readFloat();}catch(Exception e){println("?");System.exit(0);}		
		if(Dreieck1[i]==Math.max(Dreieck1[1],Math.max(Dreieck1[2],Dreieck1[3]))){indexmemo=i;};
		if(Dreieck1[i]<=0||Dreieck1[i]>30){println("FALSCHE EINGABE");System.exit(0);}
		if(i==3&&indexmemo!=3){Seitenmemo=Dreieck1[3];Dreieck1[3]=Dreieck1[indexmemo];Dreieck1[indexmemo]=Seitenmemo;}
		if(i==3&&checkRW(Dreieck1)==false){println("FALSCHE EINGABE");System.exit(0);}}
		
		for(int i=1;i<=3;i++)
		{try{Dreieck2[i]=readFloat();}catch(Exception e){println("?");System.exit(0);}
		if(Dreieck2[i]==Math.max(Dreieck2[1],Math.max(Dreieck2[2],Dreieck2[3]))){indexmemo=i;};
		if(Dreieck2[i]<=0||Dreieck2[i]>30){println("FALSCHE EINGABE");System.exit(0);} 
		if(i==3&&indexmemo!=3){Seitenmemo=Dreieck2[3];Dreieck2[3]=Dreieck2[indexmemo];Dreieck2[indexmemo]=Seitenmemo;}
		if(i==3&&checkRW(Dreieck2)==false){println("FALSCHE EINGABE");System.exit(0);}}
		if(DAnzahl==2) break;
		
		for(int i=1;i<=3;i++)
		{try{Dreieck3[i]=readFloat();}catch(Exception e){println("?");System.exit(0);}
		if(Dreieck3[i]==Math.max(Dreieck3[1],Math.max(Dreieck3[2],Dreieck3[3]))){indexmemo=i;};
		if(Dreieck3[i]<=0||Dreieck3[i]>30){println("FALSCHE EINGABE");System.exit(0);}
		if(i==3&&indexmemo!=3){Seitenmemo=Dreieck3[3];Dreieck3[3]=Dreieck3[indexmemo];Dreieck3[indexmemo]=Seitenmemo;}
		if(i==3&&checkRW(Dreieck3)==false){println("FALSCHE EINGABE");System.exit(0);}}
		if(DAnzahl==3)break;
		
		for(int i=1;i<=3;i++)
		{try{Dreieck4[i]=readFloat();}catch(Exception e){println("?");System.exit(0);}
		if(Dreieck4[i]==Math.max(Dreieck4[1],Math.max(Dreieck4[2],Dreieck4[3]))){indexmemo=i;};
		if(Dreieck4[i]<=0||Dreieck4[i]>30){println("FALSCHE EINGABE");System.exit(0);}
		if(i==3&&indexmemo!=3){Seitenmemo=Dreieck4[3];Dreieck4[3]=Dreieck4[indexmemo];Dreieck4[indexmemo]=Seitenmemo;}
		if(i==3&&checkRW(Dreieck4)==false){println("FALSCHE EINGABE");System.exit(0);}}
		if(DAnzahl==4)break;}
		
	if(EingabeFehler==true){println("?");System.exit(0);} 
	
alles korrekt eingelesen ...
	switch(DAnzahl)
	{	case 2:	//nur gleichschenkelige Dreiecke werden mit Check2D auf eine mögl Zsl zu Viereck geprüft, sonst "N"!
			if(checkGSCH(Dreieck1)==false||checkGSCH(Dreieck2)==false){println("N");break;}
			if(check2D(Dreieck1,Dreieck2)==true){println("J");}else{println("N");}
			break;
		case 3:	//nur gleichschenkelige Dreiecke werden mit Check3D geprüft, sonst "N"!
			if(checkGSCH(Dreieck1)==false||checkGSCH(Dreieck2)==false||checkGSCH(Dreieck3)==false)
			{println("N");break;}
			if(check3D(Dreieck1,Dreieck2,Dreieck3)==true){println("J");}else{println("N");}
			break;
		case 4:	//alle werden geprüft, in Methode selbst wird zw GSCH und nicht GSCH unterschieden!
			if(check4D(Dreieck1,Dreieck2,Dreieck3,Dreieck4)==true){println("J");}else{println("N");}
			break;
			
	}	 	
	}while(ende);

}
}
endlich das Ende!!!!