# Hauptdiagonale Matrix berechnen



## MrLong (7. Jun 2010)

Hey,

ich bin dabei ein Programm zu schreiben, welches erst zufallszahlen entwickelt, diese dann als string hintereinander schreibt und damit eine nxn matrix bildet. bsp eingabe 3 (3x3 matrix soll gebildet werden). damit erstellt das programm 9 zufallszahlen. 
diese werden als ein string dann von der methode bildung an eine methode hauptdiagonale weiter gegeben. diese berechnet dann die hauptdiagonale.
Den quelltext füge ich gleich darunter ein, nachdem ich mein problem geschildert habe 
also wenn ich das programm komplett mit den verschiedenen methoden laufen lasse kommt nur blödsinn raus. die einzelnen methoden sind aber richtig. wenn ich dieses alles in einer mainmethode laufen lassen funktioniert es. nur ist es dann total unübersichtliche. vllt könnt ihr mir helfen, dass ich das doch in verschiedenen methoden laufen lassen kann. 


```
public class test1 {

	public static int eingabe(){
    	double anzahl=4 ;
    	double zeichen=Math.pow(anzahl,2);
    	int b=0;
    	b=(int)zeichen;
    	return b;
    }
			
			
			
	public static String bildung() { 

		
		String matrix=new String("");
		String b=new String("");
		int a=0;
		double i=eingabe();
		int zeichen=(int)i;
		while(a<zeichen){
		
		double dezimalZahl = Math.random(); 
		dezimalZahl=dezimalZahl*100-1;
	
		int ganzZahl = (int)Math.round( dezimalZahl);
		b= String.valueOf(ganzZahl+" ");
		matrix=matrix+b;
		a++;
		}
return matrix;
	}

		
	public static int hauptdiagonale() {
		String Matrix= new String("");
		Matrix=bildung();
		double zeichen=eingabe();
		zeichen=Math.pow(zeichen, 0.5);
		zeichen=(int)zeichen;
		int d=0;
		int summe=0;
		int b=0;
		int lauf=0;
		String[] test= Matrix.split("[ ]");
	
			while (lauf < test.length ) {				
						
				b=Integer.parseInt(test[lauf]);
				if (lauf==d*(zeichen+1)){
				summe=summe+b;
				d++;
				}
				else{}			
				
			lauf++;
			
		} 
		return summe;
		
	}
	
	public static int nebendiagonale(){
		String Matrix= new String("");
		Matrix=bildung();
	

		int zeichen=eingabe();
		int d=1;
		int summe=0;
		int b=0;
		int lauf=0;
		String[] test= Matrix.split("[ ]");
	
			while (lauf < test.length ) {				
						
				b=Integer.parseInt(test[lauf]);
				if (lauf==d*(zeichen-1)&&(d<=zeichen)){
				summe=summe+b;
				d++;
				}
				else{}			
				
			lauf++;
			
		} return summe;
	}
	
	public static void main(String[] args){
				
				int Summe=hauptdiagonale();
				System.out.println("Summe der Hauptdiagonalen: "+Summe);
				
				int nebensumme=nebendiagonale();
				System.out.println("Summe der Nebendiagonalen: "+nebensumme);
				
				String Matrix= new String("");
				Matrix=bildung();
				System.out.println(Matrix);
				double h=eingabe();
				int lauf=0;
				double d=1;
				String c= new String ("");
				String[] test=Matrix.split("[ ]");
				
				while (lauf<test.length){
					c=test[lauf];
			if (c.length()==1){
			
				if(lauf==d*(Math.pow(h, 0.5))-1){		
					
					System.out.println(test[lauf]+"  ");
			
					d=d+Math.pow(h, 1/2);
				}
				else System.out.print(test[lauf]+"  ");
				
				
				lauf++;
			}
			else {		
			if(lauf==d*(Math.pow(h, 0.5))-1){		
				
				System.out.println(test[lauf]+" ");
		
				d=d+Math.pow(h, 1/2);
			}
			else System.out.print(test[lauf]+" ");
			
			
			lauf++;}
		}	
	}
		}
```

also dann danke sehr

lg mrlong


----------



## Michael... (7. Jun 2010)

Für Code bitte Java Tags benutzten.
Dass Da nur "Blödsinn" raus kommt kann durchaus sein ;-) Du verwendest keine Objekte sondern nur statische Methoden und, dass für die Berechnung von Haupt- und Nebendiagonale jedesmal eine neue Matrix erzeugt wird, ist vermutlich auch nicht gewollt.


----------



## MrLong (7. Jun 2010)

hey, danke für die antwort. 

asso, praktisch verwendet er für die haupt- und nebendiagonalen immer eine andere matrix? dachte er erstellt nur einen string mit den zahlen und dann kann man das an andere methoden weiter geben. 
was könnte man deiner meinung nach ändern, damit es funktioniert?

lg


----------



## Michael... (8. Jun 2010)

MrLong hat gesagt.:


> praktisch verwendet er für die haupt- und nebendiagonalen immer eine andere matrix?


Du rufst ja jedesmal
	
	
	
	





```
Matrix=bildung();
```
 auf


MrLong hat gesagt.:


> dachte er erstellt nur einen string mit den zahlen und dann kann man das an andere methoden weiter geben.


Das könnte man, ja. Aber genau das machst Du ja nicht.

Im einfachsten Fall wird die Matrix durch einen einfachen String repräsentiert, den man zur Berechnung an Methoden weitergibt. Aber Java ist eine objektorientierte Sprache. Das kann man sich zu nutze machen - wenn man objektorientiert programmiert. Man kann z.B. für die Matrix eine eigene Klasse definieren, die entsprechende Methoden zur Berechnung von Diagonalensummen usw. bietet.

```
import java.util.Random;

public class MatrixAnalysis {
	
	public static void main(String[] args) {
		Matrix matrix = Matrix.createRandomMatrix(4);
		matrix.printMatrix();
		System.out.println("Summe der Hauptdiagonale: " + matrix.getSumOfMainDiagonal());
		System.out.println("Summe der Nebendiagonale: " + matrix.getSumOfSecondDiagonal());
	}
}

class Matrix {
	int[][] matrix;
	int sumOfMainDiagonal;
	int sumOfSecondDiagonal;
	
	public Matrix(int[][] matrix) {
		this.matrix = matrix;
		calculateMainDiagonal();
		calculateSecondDiagonal();
	}
	
	private void calculateMainDiagonal() {
		sumOfMainDiagonal = 0;
		int row=0, col=0;
		while(row<matrix.length && col<matrix[row].length) {
			sumOfMainDiagonal += matrix[row][col];
			row++;
			col++;
		}
	}
	
	private void calculateSecondDiagonal() {
		sumOfSecondDiagonal = 0;
		int row=0, col=matrix[row].length-1;
		while(row<matrix.length && col<matrix[row].length && col >=0) {
			sumOfSecondDiagonal += matrix[row][col];
			row++;
			col--;
		}
	}
	
	
	public int getSumOfMainDiagonal() {
		return sumOfMainDiagonal;
	}
	
	public int getSumOfSecondDiagonal() {
		return sumOfSecondDiagonal;
	}
	
	public void printMatrix() {
		for (int row=0; row<matrix.length; row++) {
			for(int col=0; col<matrix[row].length; col++)
				System.out.print("[" + matrix[row][col]+ "] ");
			System.out.println();
		}
	}
	
	public static Matrix createRandomMatrix(int size) {
		int[][] matrix = new int[size][size];
		Random rnd = new Random();
		for (int row=0; row<matrix.length; row++) {
			for(int col=0; col<matrix[row].length; col++)
				matrix[row][col] = rnd.nextInt(10);
		}
		return new Matrix(matrix);
	}
}
```


----------



## MrLong (8. Jun 2010)

hey 

danke dir für die viele arbeit. echt super 

da ich ja noch ein bisschen was lernen will, kann ich hoffentlich noch weiter fragen stellen. 

würde das denn eigentlich so funktionieren wie ich mir das gedacht habe. also eine methode programmieren, die eine matrix entwürft und dann diese einfach den string an andere methoden weiter gibt? meine damit, dass es einfach einen ausdruck gibt, der ein weiteres entwickeln eines neuen strings unterbindet?

mir ist gerade eine idee gekommen. praktisch dass man mit zufallszahlen einen string bildet, der diese an eine methode abgibt welche nur den sinn hat den string wiederum an andere methoden zu geben. so wird nur einmal ein string gebildet und ich hab das was ich will. 
besser ist es natürlich wie du es hast, nur muss ich das programm presentieren und da ist es ja immer besser wenn man sein eigenes programm vorstellt 

lg


----------



## Michael... (8. Jun 2010)

Prinzipiell würde das mit einem String auch funktionieren. Den müsste man halt einmal erstellen und global halten - oder in einem globalen Objekt halten. (zumindest in dem Kontext in dem die Methoden aufgerufen werden)
Den kann man dann beliebigen Methoden übergeben. Diese müssen den dann allerdings immer "auswerten". Entscheidend ist hier das Übergeben. In Deinem ursprünglichen Code übergibst Du nichts, sondern erzeugst in jeder Methode einen neuen String.


----------



## MrLong (8. Jun 2010)

super, ich probiere das einfach mal aus  

mal schauen ob ich das hinbekomme 
also danke dir schon mal. echt super dass du mir geholfen hast 

lg


----------

