2D Array

[P83x]

Hallo!

Wir haben als Hausaufgabe aufbekommen, einen 2D Array zu programmieren. Zuerst einen 10x10 und dann einen 100x100 array. Die Struktur soll so aussehen:

...0 1 2 3 4 5 6 7 8 9 10
0 1
1 1 1
2 1 1 1
3 1 1 2 1
4 1 1 2 3 1
5 1 1 2 3 5 1
6 1 1 2 3 5 8 1
7 1 1 2 3 5 8 13 1
8 1 1 2 3 5 8 13 21 1
9 1 1 2 3 5 8 13 21 34 1

Das heißt, eine diagonale mit 1 als ergebnis, und links von den diagonalen müssen die 2 nächsten zahlen zusammen gezählt werden. Da wo keine zahl steht soll 0 als ergebniss kommen.

-------------------------------------------------------

Um erstmal dorthin zukommen wollte ich erstmal, nachdem ich mich informiert habe, mein erstes 2d array programieren, der einfach ganz strikt 1 2 3 4 5 6... pro zeile ausgibt, doch leider gibt er nichts aus.
Könnt ihr mir nur bei diesem Aspekt helfen?? Das obere will ich dann später, nachdem ich das Prinzip verstanden hab, alleine ausprobieren.

[Java]
/**
*
* Beschreibung
*
* @version 1.0 vom 14.04.2011
* @author
*/

public class array2d {

public static void main(String[] args) {
int[][] arrayD = new int[10][10];

berechne(arrayD);

for(int l=0; l == arrayD.length; l++){
for(int i=0; i == arrayD.length; i++){
System.out.print("Position "+l+"und "+i+": "+arrayD[l]);
}
}


}

public static void berechne(int[][] x){

for(int l=0; l == x.length; l++){
for(int i=0; i == x.length; i++){
x[l] = i+1;
System.out.println(l+"+"+i);
}
}

}

}[/code]

Danke schonmal!

Edit: sogar mein println in der methode gibt er nicht aus :S

 

[Volvagia]

l == x.length, i == x.length.

 

[Final_Striker]

Deine Abbruchbedingungen der for-Schleifen sind falsch.

for(int l=0; l < x.length; l++)

 

[P83x]

ich seh den fehler immer noch nicht, ich hab doch in der 2. methode x.length und in der main methode arrayD.length

edit: aah danke, aber jetzt läuft das programm nur bis 9:9.
ich hab gedacht mit == läuft es bis 10:10 und es müsste doch sogar bis 10:10 laufen?

 

[Final_Striker]

Dein Array hat die Länge 10. Läuft also von 0 bis 9.

 

[Volvagia]

Kaut doch nicht immer alles vor. Hab doch schon gesagt, wo die Fehler liegen.
Da die Adresse des ersten Feldes eines Arrays 0 ist, ist die letzte Adresse natürlich lenght - 1.

 

[P83x]

ich komm einfach nicht mehr weiter :>

public class array2d {

   public static void main(String[] args) {
   int[][] arrayD = new int[10][10];

   berechne(arrayD);

   for(int l=0; l < arrayD.length; l++){
    for(int i=0; i < arrayD.length; i++){
     System.out.println("Punkt "+l+":"+i+": "+arrayD[l][i]);
    }
   }


}

  public static void berechne(int[][] x){

    for(int l=0; l < x.length; l++){
      for(int i=0; i < x.length; i++){

          if(l == i){ 
           x[l][i] = 1;     // Wenn l und i gleich sind dann ist das ergebniss 1. Wollte jetzt mit i=0 erreichen, der pc für die restlichen i's nur noch 0er verteilt, da die werte rechts von unserer diagonale ist.
           i = 0;
          }
          if(i < l){
           x[l][i]= (x[l][i-1])+(x[l][i-2]); 
           if(x[l][i] >= 0){
             x[l][i] = 1; // Wollte damit erreichen, das geprüft wird das i < als l ist. Wenn das eintrifft
//werden die 2 vorherigen zahlen miteinander addiert, falls das ergebniss nicht größer als 0 sein sollte, ist x[l][i] = 1. Wenn i nicht < als i ist, dann ist die lösung 0.
             }
          }
          else{
           x[l][i] = 0;
          }
          System.out.println("Punkt "+l+":"+i+": "+x[l][i]);
      }
    }



   }

  }

hilfe?^^

 

[Volvagia]

x[l]= (x[l][i-1])+(x[l][i-2]);
Du musst natürlich zuerst prüfen, ob das Feld überhaupt noch im Array ist. (>= 0, <= (lenght - 1))

 

[Crian]

Klassennamen sollte man vorn groß schreiben. *einwerf*


Und eine konsistente Einrückung schafft auch eine Übersichtlichkeit. Wenn man das selbst nicht hin bekommt, kann auch eine Entwicklungsumgebung wie etwa Eclipse per Knopfdruck Teile oder eine ganze Datei formatieren.


Ich hab mir mal die Mühe gemacht, das ganze etwas schöner zu machen (Fehler noch nicht behoben):

package forumProblems;

public class Array2D {

    private int[][] arrayD;

    public Array2D(int size) {
        arrayD = new int[size][size];
        berechne();
        gibAus();
    }

    private void berechne() {
        for (int l = 0; l < arrayD.length; ++l) {
            for (int i = 0; i < arrayD.length; ++i) {
                if (l == i) {
                    arrayD[l][i] = 1; // Wenn l und i gleich sind dann ist das
                                      // ergebniss 1. Wollte jetzt mit i=0
                                      // erreichen, der pc für die restlichen
                                      // i's nur noch 0er verteilt, da die werte
                                      // rechts von unserer diagonale ist.
                    i = 0;
                }
                if (i < l) {
                    arrayD[l][i] = (arrayD[l][i - 1]) + (arrayD[l][i - 2]);
                    if (arrayD[l][i] >= 0) {
                        arrayD[l][i] = 1; // Wollte damit erreichen, das geprüft
                                          // wird das i < als l ist. Wenn das
                                          // eintrifft
                        // werden die 2 vorherigen zahlen miteinander addiert,
                        // falls das ergebniss nicht größer als 0 sein sollte,
                        // ist x[l][i] = 1. Wenn i nicht < als i ist, dann ist
                        // die lösung 0.
                    }
                }
                else {
                    arrayD[l][i] = 0;
                }
                System.out
                        .println("Punkt " + l + ":" + i + ": " + arrayD[l][i]);
            }
        }
    }

    private void gibAus() {
        for (int l = 0; l < arrayD.length; ++l) {
            for (int i = 0; i < arrayD.length; i++) {
                System.out
                        .println("Punkt " + l + ":" + i + ": " + arrayD[l][i]);
            }
        }
    }

    public static void main(String[] args) {
        new Array2D(10);
    }
}

Ausgabe:

Punkt 0:0: 0
Punkt 0:1: 0
Punkt 0:2: 0
Punkt 0:3: 0
Punkt 0:4: 0
Punkt 0:5: 0
Punkt 0:6: 0
Punkt 0:7: 0
Punkt 0:8: 0
Punkt 0:9: 0
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1
	at forumProblems.Array2D.berechne(Array2D.java:25)
	at forumProblems.Array2D.<init>(Array2D.java:9)
	at forumProblems.Array2D.main(Array2D.java:55)

Da solltest du selbst den Fehler finden, oder?

 

[P83x]

dankeeschöööön )
es hat funktioniert bzw. es funktioniert!!! Nur jetzt möchte ich ein bisschen an der Optik pfeilen. Kann man es irgendwie so hinbekommen, das java es so wie ganz oben ausgibt?

hier ist das funktionierende java prog.:

/**
  *
  * Beschreibung
  *
  * @version 1.0 vom 14.04.2011
  * @author
  */

public class array2d {

   public static void main(String[] args) {
   int[][] arrayD = new int[10][10];

   berechne(arrayD);

   for(int l=0; l < arrayD.length; l++){
    for(int i=0; i < arrayD.length; i++){
     System.out.println("Punkt "+l+":"+i+": "+arrayD[l][i]);
    }
   }


}

  public static void berechne(int[][] x){

    for(int l=0; l < x.length; l++){
      for(int i=0; i < x.length; i++){

          if((l == i)||(i < 3)){
            x[l][i] = 1;

           }
          
          if((i-2 >= 0)&&(i<l)){

           x[l][i]= (x[l][i-1])+(x[l][i-2]);

          }
          if(i>l){
           x[l][i] = 0;
          }
          
      }
    }



   }

  }

 

[Crian]

Ja könnte man. Dein Code sieht ja immer noch so wild aus.
Aber wenn wir dir hier eine Lösung hinschreiben, lernst du dabei weniger, als wenn du das selbst durchdringst.

 

[P83x]

Ich hab dein beitrag davor nicht gesehn und habe es jetzt versucht es schöner und übersichtlicher zu gestalten so sieht es jetzt aus:

/**
  *
  * Beschreibung
  *
  * @version 1.0 vom 14.04.2011
  * @author
  */

public class array2d {

        public static void main(String[] args) {
         int u = 0;
         
         System.out.println("Geben Sie eine Zahl ein, um einen 2Dimensionalen Array, nach Pascal'scher Art zu bekommen.");
         u = Input.readInt();
         int[][] arrayD = new int[u][u];

         berechne(arrayD);


                          for(int l=0; l < arrayD.length; l++){
                                  for(int i=0; i < arrayD.length; i++){
                                          System.out.println("Punkt "+l+":"+i+": "+arrayD[l][i]);
                                  }
                          }
        }

        public static void berechne(int[][] x){

                           for(int l=0; l < x.length; l++){
                                   for(int i=0; i < x.length; i++){

                                           if((l == i)||(i < 3)){
                                           
                                             x[l][i] = 1;
                                           }
          
                                           if((i-2 >= 0)&&(i<l)){

                                            x[l][i]= (x[l][i-1])+(x[l][i-2]);
                                           }
                                           
                                           if(i>l){
                                           
                                            x[l][i] = 0;
                                           }
                                   }
                                   
                           }


        }



  }

 

[AmunRa]

Hierfür ist die Methode System.out.printf sehr hilfreich.

for(int l=0; l < arrayD.length; l++){
	System.out.print(l+": ");
    for(int i=0; i < arrayD.length; i++){
     System.out.printf("%3s",arrayD[l][i]);
    }
    System.out.println();
   }

Dir fehlt da jetzt nur noch die erste Zeile. Schau dir dazu am besten meinen Code an und überlege wie du diese Zeile noch richtig hinbekommst. Das solltest du auch schaffen. Lies dir vl dazu auch noch ein kleines Tutorial zu String.format druch google findet da sicher etwas dazu

 

[Crian]

Sowas in der Art hab ich auch gebastelt:

    private void gibAus() {
        for (int l = 0; l < array.length; ++l) {
            System.out.printf("%3d: ", l);
            for (int i = 0; i < array.length; ++i) {
                System.out.printf("%3d ", array[l][i]);
            }
            System.out.println("");
        }
    }

Die Ausgabe bei mir sieht mit

    private void berechne() {
        for (int l = 0; l < array.length; ++l) {
            for (int i = 0; i < array.length; ++i) {
                if (l == i || i < 3)
                    array[l][i] = 1;
                else if (i < l) {
                    array[l][i] = (array[l][i - 1]) + (array[l][i - 2]);
                    if (array[l][i] >= 0)
                        array[l][i] = 1;
                }
                else
                    array[l][i] = 0;
            }
        }
    }

nun so aus:

  0:   1   1   1   0   0   0   0   0   0   0 
  1:   1   1   1   0   0   0   0   0   0   0 
  2:   1   1   1   0   0   0   0   0   0   0 
  3:   1   1   1   1   0   0   0   0   0   0 
  4:   1   1   1   1   1   0   0   0   0   0 
  5:   1   1   1   1   1   1   0   0   0   0 
  6:   1   1   1   1   1   1   1   0   0   0 
  7:   1   1   1   1   1   1   1   1   0   0 
  8:   1   1   1   1   1   1   1   1   1   0 
  9:   1   1   1   1   1   1   1   1   1   1

Da ist also wohl noch einiges falsch *schmunzelt*

 

[AmunRa]

Bei mir ist natürlich noch ein Kleiner Fehler (Unschönheit) gewesen, der mir jetzterst nach deinem Post aufgefallen ist.

im Format string muss es natürlich

%3d

heißen und nicht

%3s

 

[Crian]

Ich hab nun als Ergebnis

    |  0   1   2   3   4   5   6   7   8   9 
----+-----------------------------------------
  0 |  1   0   0   0   0   0   0   0   0   0 
  1 |  1   1   0   0   0   0   0   0   0   0 
  2 |  1   1   1   0   0   0   0   0   0   0 
  3 |  1   1   2   1   0   0   0   0   0   0 
  4 |  1   1   2   3   1   0   0   0   0   0 
  5 |  1   1   2   3   5   1   0   0   0   0 
  6 |  1   1   2   3   5   8   1   0   0   0 
  7 |  1   1   2   3   5   8  13   1   0   0 
  8 |  1   1   2   3   5   8  13  21   1   0 
  9 |  1   1   2   3   5   8  13  21  34   1

Ist das das, was du haben möchtest? Und willst du basteln? Oder soll ich die Lösung zeigen?

Edit: Ich hab nun zwei Berechnungsmethoden geschrieben. Eine davon berechnet die Fibonaccifolge nur einmal, die andere für jede Zeile neu. Wie gesagt, auf Wunsch zeig ich sie auch gern, aber das Problem selbst zu lösen ist eigentlich immer lehrreicher.

 

[P83x]

das problem ist, das wir in der shcule nur system.out.println als ausgabetyp hatten. Deshalb wäre es net wenn du die lösung posten könntest

 

[P83x]

und?

 

[Final_Striker]

Wie wäre es mit selbst machen? Ist ja schließlich deine Hausaufgabe. ;-)

 

[Crian]

das problem ist, das wir in der shcule nur system.out.println als ausgabetyp hatten. Deshalb wäre es net wenn du die lösung posten könntest

Hier ist sie. Zwei Varianten der Berechnung, siehe oben.

package forumProblems;

public class Array2D {

    /** Das Array. */
    private int[][] array;

    /**
     * Konstruktor.
     *
     * @param size
     *            Größe des Arrays (beide Richtungen).
     */
    public Array2D(int size) {
        array = new int[size][size];
        boolean fast = true;
        if (fast)
            berechne2();
        else
            berechne1();
        gibAus();
    }

    /** Erste Berechnungsmethode (einfacher, aber langsamer). */
    private void berechne1() {
        for (int row = 0; row < array.length; ++row) {
            for (int col = 0; col < array.length; ++col) {
                if (col > row)
                    array[row][col] = 0;
                else if (col < 2 || col == row)
                    array[row][col] = 1;
                else
                    array[row][col] = array[row][col-1] + array[row][col-2];
            }
        }
    }

    /** Zweite Berechnungsmethode (schneller, aber etwas komplizierter). */
    private void berechne2() {
        int[] fibo = calculateFibonacci(array.length);

        for (int row = 0; row < array.length; ++row) {
            for (int col = 0; col < array.length; ++col) {
                if (col > row)
                    array[row][col] = 0;
                else if (col == row)
                    array[row][col] = 1;
                else
                    array[row][col] = fibo[col];
            }
        }
    }

    /**
     * Berechnet die Fibonaccifolge bis zur angebenen Stelle.
     *
     * @param length Länge der zu berechnenden Fibonacci-Folge.
     * @return Array mit den ersten Elementen der Fibonacci-Folge.
     */
    private int[] calculateFibonacci(int length) {
        int[] fibo = new int[length];
        if (length > 0)
            fibo[0] = 1;
        if (length > 1)
            fibo[1] = 1;
        for (int i=2; i<length; ++i)
            fibo[i] = fibo[i-2] + fibo[i-1];
        return fibo;
    }

    /** Gibt die Daten des Arrays in schöner, menschenlesbarer Form aus. */
    private void gibAus() {
        /* Titelzeile: */
        System.out.print("    |");
        for (int col = 0; col < array.length; ++col)
            System.out.printf("%3d ", col);
        System.out.println("");
        System.out.print("----+");
        for (int col = 0; col < array.length; ++col)
            System.out.print("----");
        System.out.println("-");

        /* Datenzeilen: */
        for (int row = 0; row < array.length; ++row) {
            System.out.printf("%3d |", row);
            for (int col = 0; col < array.length; ++col)
                System.out.printf("%3d ", array[row][col]);
            System.out.println("");
        }
    }

    /** Startpunkt des Programms. */
    public static void main(String[] args) {
        new Array2D(10);
    }

}

 

[P83x]

Danke für die lösung und sry für meine späte antwort, war nämlich im urlaub.
Hab es mir mal angeguckt, doch es blieben manche sachen unklar für mich:

public Array2D(int size) {
        array = new int[size][size];
        boolean fast = true;
        if (fast)
            berechne2();
        else
            berechne1();
        gibAus();
    }

was hat denn das boolean für eine funktion??

private void berechne1() {
        for (int row = 0; row < array.length; ++row) {
            for (int col = 0; col < array.length; ++col) {
                if (col > row)
                    array[row][col] = 0;
                else if (col < 2 || col == row)
                    array[row][col] = 1;
                else
                    array[row][col] = array[row][col-1] + array[row][col-2];
            }
        }
    }

Die 1. methode habe ich verstanden, doch ich verstehe nicht die 2. methode:

private void berechne2() {
        int[] fibo = calculateFibonacci(array.length);

        for (int row = 0; row < array.length; ++row) {
            for (int col = 0; col < array.length; ++col) {
                if (col > row)
                    array[row][col] = 0;
                else if (col == row)
                    array[row][col] = 1;
                else
                    array[row][col] = fibo[col];
            }
        }
    }

ich weiß nicht was das int[] fibo = calculateFibonacci(array.length) bedeutet oder was es macht, noch verstehe ich nicht weshalb man diese methode nicht einfach löschen kann, denn es gibt ja immer noch die 1. methode und mit der alleine sollte es doch funktionieren??

    /**
     * Berechnet die Fibonaccifolge bis zur angebenen Stelle.
     *
     * @param length Länge der zu berechnenden Fibonacci-Folge.
     * @return Array mit den ersten Elementen der Fibonacci-Folge.
     */
    private int[] calculateFibonacci(int length) {
        int[] fibo = new int[length];
        if (length > 0)
            fibo[0] = 1;
        if (length > 1)
            fibo[1] = 1;
        for (int i=2; i<length; ++i)
            fibo[i] = fibo[i-2] + fibo[i-1];
        return fibo;
    }

wieder das fibo, welches ich nicht verstehe.

/** Gibt die Daten des Arrays in schöner, menschenlesbarer Form aus. */
    private void gibAus() {
        /* Titelzeile: */
        System.out.print("    |");
        for (int col = 0; col < array.length; ++col)
            System.out.printf("%3d ", col);
        System.out.println("");
        System.out.print("----+");
        for (int col = 0; col < array.length; ++col)
            System.out.print("----");
        System.out.println("-");

        /* Datenzeilen: */
        for (int row = 0; row < array.length; ++row) {
            System.out.printf("%3d |", row);
            for (int col = 0; col < array.length; ++col)
                System.out.printf("%3d ", array[row][col]);
            System.out.println("");
        }
    }

was heißt denn printf und was soll das "%" sein? ich kann mir denken, dass das %3d der nummerierung dient, doch wie funktioniert das system wenn es stimmt?

 /** Startpunkt des Programms. */
    public static void main(String[] args) {
        new Array2D(10);
    
    }

auch verwirrt mich, dass das am ende steht. muss es nicht am anfang stehen, damit es überhaupt verwertet wird?! und wieso ist es die 10 in () und nicht in [] gesetzt? und muss man bei einem 2d array nicht 2 [] [] haben?!?!

Ich hoffe ihr könnt mir helfen, denn das verwirrt mich gerade sehr.

 

[Dekker]

das problem ist, das wir in der shcule nur system.out.println als ausgabetyp hatten. Deshalb wäre es net wenn du die lösung posten könntest

Na dann musst du wohl erst alle Ergebnisse berechnen und speichern und halt am Ende die Ausgabe erzeugen. Wie man sieht war das eine Hausaufgabe... Und jetzt frag dich selbst: Hast du irgendwas gelernt jetzt?

 

[P83x]

ja, unsere hausaufgabe war ja nur ein 2d array nach pascalscher art zu erschaffen und wir sollten es auch nur mit system.out.print ausgeben, mehr wird auch nicht von uns erwartet. Das kann ich ja auch jetzt und ich verstehe auch wie man das jetzt erstellt, doch weil ich nach einer schöneren optik strebe, hab ich euch gebeten mir zu zeigen wie man dies schafft. Es war mir schon von anfang an klar, das bestimmt etwas kommen wird, was ich nicht verstehe, da wir es auch noch nie im unterricht besprochen haben, doch wenn ich es jetzt verstehe und anwenden kann, dann kann ich zu mir sagen: ja ich habe was gelernt und war sogar noch über der hausaufgabe hinaus