Interface Stabilität Klötze-Turm

[calvados]

Hallo ich habe wie der Titel schon sagt eine Hausaufgabe in Informatik . Ich habe einfach sowas von gar keinen Plan. Es geht um Schnittstellen und die eigentliche Aufgabe geht darum dass es mehrere Klötze gibt die übereinander gestapelt werden, die linken kanten stehen immer übereinander, sodass es also möglich ist dass die klätze nach rechts umkippen könnten.Und das ist auch de knackpunkt man soll imemr berechnen ob der turm instabil ist . sprich erster klotz liegt dann kommt 2ter drauf => fällt klotz um mithilfe von moment berechnen > moment gleich null turm stabil. 3ter klotz rauf > moment größer null instabil oder gleich null stabil usw usw. Die längen der einzelnen Klötze variiert, die höhe bleibt immer gleich

Um ehrlich zu sein hab ich keine ahnung ob hier jemand diese aufgabe pberhaupt nachvollziehen kann so wie ich es hier erklärt habe . aber vielleicht hab ich ja glück

ich habe zur zeit das system mit klötze und turm
schnittstellen IKlotz2D, ITurm, IPunkt2D ( die müssen vorhanden sein)
und noch anwendung.
da fehlt sicher noch iwas wie listenelement oder so . aber ich hab gar keine ahnung davon ^^

wäre cool wenn hier irgendwer helfen kann

 

[SlaterB]

dein vorheriger Titel 'Hausaufgabe' ist ja bemerkenswert aussagelos in diesem Bereich,
was hälst du davon, wenn wir einfach alle bisherigen 10.000 durchnummerien oder alle denselben Titel 'X' geben,
siehst du nicht die Funktion eines Titels zur Unterscheidung ein?

das Tag Interface und deine angelegten Schnittstellen helfen leider auch nicht so viel weiter,
man muss aufpassen vor lauter Systematik und Buzzwords nicht den Blick fürs Wesentliche zu verlieren,

selbst Java ist strenggenommen nicht so wichtig, kannst du auf dem Papier alles ausrechnen wenn du nur die Zahlen, nicht die Klötze selber zur Verfügung hast?

der Kern des Programms ist eine Untersuchung der Klötze,
was sich da mathematisch anbietet ist vielleicht im Internet ausführlich zu finden,

mir schwant gerade auch was vor, aber das wird ja soviel zu tippen, das gibts bestimmt schon,
gegebenenfalls melde ich mich noch später

 

[AndiE]

Der Ansatz ist so nicht richtig. Meines Wissens fällt ein Körper genau dann um, wenn sich der Schwerpunkt außerhalb der Grundfläche befindet. Die Formel, den Schwerpunkt zu berechnen, ist angesichts der angegebenen Nebenbedingungen ziemlich einfach- kann man ergooglen.

Wie sieht denn sowas wie ein Klassendiagramm aus von dem, was du bisher hast (Beziehungen, Eigenschaften, Multiplizitäten)? Wo stehen die Interfaces?

 

[calvados]

hallo leute ich hab nun iwie den größtteil zusammengefummelt mit hilfe von freunden und so . absolut kein plan da überhaupt was richtig von ist auf jeden fall ist nichts rot oder gelb ;D für mich immer ein gutes zeichen

nun hapere ich am klotzturm. der soll ja dann die klötze übergeben bekommen und dort denke ich mal sollen dann die berechnungen geschrieben werden ob der turm umkippt oder nicht. jedoch hab ich da keine ahnung wie ichd as machen soll. ich hab auch listen geschrieben und so

 

[SlaterB]

mit 'größtteil zusammengefummelt', 'listen geschrieben und so ' brauchst du gar nicht groß erzählen,
mag sein dass das für deine Aufgabe mit Interface & Co. relevant ist, hier im Forum aber weitgehend auszklammern

die Berechnung des Turms ist anscheinend immer noch keinen Milimter angefangen,
hier mal ein 'genauso weit fortgeschrittenes' Rahmenprogramm:

public class Test2
{
    public static void main(String[] args)
    {
        int hoeheKlotz = 1;
        int[] breiteKlotz = new int[] {3, 5, 4, 6};
        
        
    }
}

das sagt aus, dass jeder Klotz die nominale Höhe 1 hat, der erste 3 (belibige Längeneinheiten) breit ist, der darüber 5, dann 5, dann 6
fällt dieser Turm um, ja oder nein? Berechnung fehlt

also das drumherum ist egal, die Rechnung muss gehen

----------

jetzt hätte gut ein Link mit der Rechnung weiteres gespart, habe aber nicht viel gefunden
Standfestigkeit ? Wikipedia
mit

Dies ist zum Beispiel bei einem Körper, der mit einer Aufstandsfläche auf einer Ebene aufliegt, der Fall, wenn das Lot durch den Massenschwerpunkt des Körpers die Ebene innerhalb der Aufstandsfläche schneidet.

sieht bisschen danach aus, aber kein Link auf schöne komplette Betrachtung..

wenn es hier sein muss, dann mit Überlegungen:

----------
|    5    |
---------
|  3  |
------

wie sieht es mit nur zwei Klötzen aus, wird das so stehenbleiben, kannst du das ohne Ausprobieren beantworten?
ab welcher Länge/ Breite des zweiten Klötzchens (bei immer gleicher Höhe, wie ja auch in der Aufgabe) wird es kritisch?

schon mehr zu drei Klötzchen usw. nachgedacht?
bevor es an den Java-Code geht muss erstmal das Konzept mathematisch stehen,
wenn du das schon hast, ruhig nicht verschweigen

 

[pappawinni]

Kritisch wird es hier wohl spätestens dann, wenn der gemeinsame Schwerpunkt der oberen Klötze über die rechten Kante des jeweils darunter liegenden Klotzes hinaus wandert.
Standfestigkeit ? Wikipedia
Wie man Schwerpunkte zusammenfassen kann, muss man dazu dann auch noch wissen:
Geometrischer Schwerpunkt ? Wikipedia
und.. "Ist ein Körper homogen (besteht er also aus einem Material, das überall die gleiche Dichte hat), so fällt sein Massenmittelpunkt mit seinem geometrischen Volumenschwerpunkt zusammen. Besteht der Körper aus Teilen verschiedener Dichte, kann der Massenmittelpunkt vom Volumenschwerpunkt abweichen"

 

[Marco13]

Ich find' das eigentlich eine interssante Aufgabe. Vielleicht helfen die Informationen, dass man den Schwerpunkt (2D) eines Turms berechnen muss - und dass ein Klotz schon einen Turm bilden kann.

 

[ARadauer]

ich würd JBox2D: A Java Physics Engine super einfache api...

 

[Marco13]

Ich glaub' darum ging es nicht direkt ...

 

[pappawinni]

nicht schön, aber selten:

import java.util.*;

public class TowerStability {

	public static void main(String[] args) {
		Turm tower = new Turm();
		Klotz stein1 = new Klotz(4,5);
		Klotz stein2 = new Klotz(9,7);
		Klotz stein3 = new Klotz(1,1);
		tower.add(stein1);
		tower.add(stein2);
		tower.add(stein3);
		System.out.print(tower);
		System.out.printf("Der Turm ist%s stabil%n",(tower.isStable()?"":" nicht"));
	}

}

class Punkt{
	double x;
	double y;
	public Punkt(){
	}
	public Punkt(double x,double y){
		this.x = x;
		this.y = y;		
	}
	public Punkt(double[] point){
		this.x = point[0];
		this.y = point[1];		
	}
	public double getX(){
		return x;
	}
	public double getY(){
		return y;
	}
	public void setX(double x){
		this.x = x;
	}	
	public void setY(double y){
		this.y = y;
	}	
	@Override
	public String toString(){
		return("("+x+";"+y+")");
	}
}

class Klotz{
	Punkt breitehoehe;
	public Klotz(){
		breitehoehe=new Punkt();
	}
	public Klotz(double breite,double hoehe){
		breitehoehe=new Punkt(0,0);
		if (breite > 0){ 
			breitehoehe.setX(breite);
		}
		else{
			breitehoehe.setX(0);
		}
		if (hoehe > 0){ 
			breitehoehe.setY(hoehe);		
		}
		else{
			breitehoehe.setY(0);		
		}			
	}
	public Klotz(Punkt eckpunkt){
		breitehoehe=new Punkt(0,0);
		double b = eckpunkt.getX();
		double h = eckpunkt.getY();
		if (b > 0){ 
			breitehoehe.setX(b);
		}
		else{
			breitehoehe.setX(0);
		}
		if (h > 0){ 
			breitehoehe.setY(h);		
		}
		else{
			breitehoehe.setY(0);		
		}			
	}
	public double getBreite(){
		return breitehoehe.getX();		
	}
	public double getHoehe(){
		return breitehoehe.getY();		
	}
	public void setBreite(double breite){
		if (breite > 0){ 
			breitehoehe.setX(breite);
		}
		else{
			breitehoehe.setX(0);
		}
	}	
	public void setHoehe(double hoehe){
		if (hoehe > 0){ 
			breitehoehe.setY(hoehe);		
		}
		else{
			breitehoehe.setY(0);		
		}			
	}		
	public Punkt getCOG(){
		// Center of Gravity
		return new Punkt(breitehoehe.getX()/2,breitehoehe.getY()/2);
	}
	@Override
	public String toString(){
		return (breitehoehe.getX()+" x "+breitehoehe.getY());
	}
}

class Turm {
	List<Klotz> aufbau;
	public Turm(){
		aufbau = new ArrayList<Klotz>();
	}
	public void add(Klotz stein){
		aufbau.add(stein);
	}
    public boolean isStable(){
		boolean answer = true;
		if (aufbau.isEmpty() ||aufbau.size()==1){
			return answer;
		}
		double breite;
		double hoehe;
		double sumMom = 0;
		double sumArea = 0;
		for(int i=aufbau.size()-1;i>0;i--){
			breite = aufbau.get(i).getBreite();
			hoehe = aufbau.get(i).getHoehe();
			sumArea += breite*hoehe; 
			sumMom += aufbau.get(i).getCOG().getX()*breite*hoehe;
			if (sumMom/sumArea > aufbau.get(i-1).getBreite()) answer=false;
		}
    	return answer;
    }
	@Override
	public String toString(){
		String strOut = "";
		if (aufbau.isEmpty()){
			return strOut;
		}
		int breite;
		int hoehe;
		String strmid;
		for(int i=aufbau.size()-1;i>=0;i--){
			breite =(int) (aufbau.get(i).getBreite());
			hoehe =(int) (aufbau.get(i).getHoehe()+1);
			strmid = String.format("%"+(breite+1)+"s","").substring(1);
		    strOut += String.format("+%s%s%n",breite<2?"":strmid.replace(' ','-'),breite>0?"+":"");
			for (int j = 1;j<hoehe-1;j++){
				strOut += String.format("|%s%s%n",breite<2?"":strmid,breite>0?"|":"");				
			}
			if (hoehe>1) strOut += String.format("+%s%s%n",breite<2?"":strmid.replace(' ','-'),breite>0?"+":"");						
		}
		return (strOut);
	}
}

 

[pappawinni]

Ich hab jetzt noch ne Klasse mit Klötzen fester Höhe rein gebaut.
Auch wenn das Programm nicht schöner geworden ist, der Output macht es.

import java.util.*;

public class TowerStability {

	public static void main(String[] args) {
		double[][] ecken = {{3,3},{9,4},{4,5},{6,7}};
		
		Turm tower = new Turm();
		Klotz[] stein = new Klotz[ecken.length];
		for (int i=0;i<ecken.length;i++){
			stein[i]=new Klotz(ecken[i]);
			tower.add(stein[i]);
		}
		System.out.print(tower);
		System.out.printf("Der Turm ist%s stabil%n",( tower.isStable() ? "" : " nicht" ));
		stein[0].setBreite(4);
		System.out.print(tower);
		System.out.printf("Der Turm ist%s stabil%n",( tower.isStable() ? "" : " nicht" ));

		Turm stapel = new Turm();
		KlotzFixH[] block = new KlotzFixH[ecken.length];
		for (int i=0;i<ecken.length;i++){
			block[i]=new KlotzFixH(ecken[i][0]-1);
			stapel.add(block[i]);
		}
		KlotzFixH.setHoehe(4);
		System.out.print(stapel);
		System.out.printf("Der Stapel ist%s stabil%n",( stapel.isStable() ? "" : " nicht" ));
		block[0].setBreite(4);
		System.out.print(stapel);
		System.out.printf("Der Stapel ist%s stabil%n",( stapel.isStable() ? "" : " nicht" ));
	}

}

interface iKlotz{
	public double getBreite();
	public double getHoehe();
    public Punkt getCOG();
}

class Punkt{
	double x;
	double y;
	public Punkt(){
	}
	public Punkt(double x,double y){
		this.x = x;
		this.y = y;		
	}
	public Punkt(double[] point){
		this.x = point[0];
		this.y = point[1];		
	}
	public double getX(){
		return x;
	}
	public double getY(){
		return y;
	}
	public void setX(double x){
		this.x = x;
	}	
	public void setY(double y){
		this.y = y;
	}	
	@Override
	public String toString(){
		return("("+x+";"+y+")");
	}
}

class Klotz implements iKlotz{
	double breite;
	double hoehe;
	public Klotz(){
		//super();
		setBreite(1);
		setHoehe(1);
	}
	public Klotz(double breite,double hoehe){
        setBreite(breite);
		setHoehe(hoehe);
	}
	public Klotz(Punkt eckpunkt){
		double b = eckpunkt.getX();
		double h = eckpunkt.getY();
        setBreite(b);
		setHoehe(h);
	}
	public Klotz(double[] eckpunkt){
		double b = eckpunkt[0];
		double h = eckpunkt[1];
        setBreite(b);
		setHoehe(h);
	}
	@Override
	public double getBreite(){
		return breite;		
	}
	@Override
	public double getHoehe(){
		return hoehe;		
	}
	public void setBreite(double breite){
		if (breite > 0){ 
			this.breite=breite;
		}
		else{
			this.breite=0;
		}
	}	
	public void setHoehe(double hoehe){
		if (hoehe > 0){ 
			this.hoehe=hoehe;		
		}
		else{
			this.hoehe=0;		
		}			
	}		
	@Override
    public Punkt getCOG(){
    	// Center of Gravity
    	return new Punkt(breite/2,hoehe/2);
    }
	@Override
	public String toString(){
		return (breite + " x " + hoehe);
	}
 }

class KlotzFixH implements iKlotz{
	double breite;
	static double h;
	public KlotzFixH(){
		setBreite(1);
	}
	public KlotzFixH(double breite){
		setBreite(breite);
	}
	@Override
	public double getBreite(){
		return breite;		
	}
	@Override
	public double getHoehe(){
		return getH();		
	}
	public static double getH(){
		return h;		
	}
	public void setBreite(double breite){
		if (breite > 0){ 
			this.breite=breite;
		}
		else{
			this.breite=0;
		}
	}	
	public static void setHoehe(double hoehe){
		if (hoehe > 0){ 
			h=hoehe;		
		}
		else{
			h=0;		
		}			
	}		
	@Override
    public Punkt getCOG(){
	// Center of Gravity
		return new Punkt(breite/2,h/2);
	}
	@Override
	public String toString(){
		return (breite + " x " + h);
	}
}

class Turm {
	List<iKlotz> aufbau;
	public Turm(){
		aufbau = new ArrayList<iKlotz>();
	}
	public void add(iKlotz stein){
		aufbau.add(stein);
	}
    public boolean isStable(){
		boolean answer = true;
		if (aufbau.isEmpty() ||aufbau.size()==1){
			return answer;
		}
		double breite;
		double hoehe;
		double sumMom = 0;
		double sumArea = 0;
		for(int i=aufbau.size()-1;i>0;i--){
			breite = aufbau.get(i).getBreite();
			hoehe = aufbau.get(i).getHoehe();
			sumArea += breite*hoehe; 
			sumMom += aufbau.get(i).getCOG().getX()*breite*hoehe;
			if (sumMom/sumArea > aufbau.get(i-1).getBreite()) answer=false;
		}
    	return answer;
    }
	@Override
	public String toString(){
		String strOut = "";
		if (aufbau.isEmpty()){
			return strOut;
		}
		int breite;
		int breite2=0;
		int breite3;
		int hoehe;
		String strT1,strT2;
		for(int i=aufbau.size()-1;i>=0;i--){
			breite =(int) (aufbau.get(i).getBreite());
			hoehe =(int) (aufbau.get(i).getHoehe()+1);
			breite3 = Math.min(breite,breite2);
			breite2 = Math.max(breite,breite2);
			breite3 = breite2-breite3;
			breite2 = breite2-breite3;
			strT1 = String.format("%"+(breite2+1)+"s+","").substring(2);
			strT2 = String.format("%"+(breite3+1)+"s+","").substring(2);
		    strOut += String.format("+%s%s%n",strT1,strT2).replace(' ','-');
			strT2 = String.format("%"+(breite+1)+"s","");
		    strT1 = String.format("|%s%s%n",breite<2?"":strT2.substring(2),breite>0?"|":"");		    
			for (int j = 1;j<hoehe-1;j++){
				strOut += strT1;				
			}
			breite2 = breite;
			if (i==0 && hoehe>0) 
				strOut += strT1.replace(' ','-').replace('|','+');						
		}
		return (strOut);
	}
}