Matrix, Nachbarelemente

[Al3xand3r01]

Hallo zusammen, ich habe als Aufgabe bekommen eine Funktion zu schreiben, die ein zweidimensionales Array und zwei Kooardinaten übergeben bekommt und die Nachbarn des Elements retouniert. Natürlich könnte man das mit Schleifen lösen, aber ich finde irgendwie die Methode mit den Abfragen "besser" bzw eher dem Gefragten entsprechend. Leider bekomme ich aber immer falsche Werte raus, ich bin mir sicher, dass ich irgenwo eine Kleinigkeit übersehen habe (oder auch was Grundlegendes nicht bedacht habe ), hoffentlich kann mir jemand weiterhelfen. Btw: ich lerne Java noch nicht lange (bin 15), also seid bitte gnädig

Lg und danke im Voraus!

Hier mein Code:

public class neighbours {
    public static void main(String[] args) {
        //Aufruf
        int[][] arr2d = {{1,2,3},{4,5,6},{7,8,9}};
        System.out.println(nachbarn(arr2d, 0, 0));
    }
    static int nachbarn(int[][] arr, int x, int y){
        int result = 0;
        if (x <= 0){
            result += arr[y][x] + arr[y][x+1];

        }
        else if (x >= arr[y].length-1) {
            result += arr[y][x] + arr[y][x-1];
        }

        else {
            result += arr[y][x] + arr[y][x-1] + arr[y][x+1];
        }


        if (y <= 0) {
            result += arr[y][x] + arr[y+1][x];
        }
        else if (y >= arr.length-1){
            result += arr[y][x] + arr[y-1][x];
        }
        else {
            result += arr[y][x] + arr[y + 1][x] + arr[y + 1][x];
        }
        return result;
    }

EDIT: ups, zweimal gepostet - sorry

 

[kneitzel]

Du zählst das eigentliche Element an Position x/y doppelt.

 

[Al3xand3r01]

Danke für Deine Antwort! Könntest du mir bitte schreiben was genau Du meinst (bzw. nur welche Zeile)? Das Interessante ist, dass die Ergebnisse manchmal zu niedrig, manchmal zu hoch ausfallen.

 

[MoxxiManagarm]

und die Nachbarn des Elements retouniert.

Nur um sicher zu gehen. Sollst du die Nachbarn, die Summe der Nachbarn oder die Anzahl der Nachbarn zurückgeben? Das sind völlig verschiedene Dinge, dein Text sagt das eine, der Code das andere.

 

[Al3xand3r01]

Äh ja, tut mir leid, ich hätte mich klarer ausdrücken sollen.
Ich soll die Summe der Nachbarelemente zurückgeben.

 

[MoxxiManagarm]

Ich soll die Summe der Nachbarelemente zurückgeben.

Ok, was sind denn Nachbarelemente? Du verwendest oben ja nur N O W S. In den meisten derartigen Aufgaben, welche ich kenne, werden allerdings auch NO, SO, SW und NW als Nachbarelemente angenommen. Könnte das eventuell noch zu deinen falschen Ergebnissen führen?

Bist du dir außerdem sicher, dass y der erste Index und x der zweite Index ist? Ich würde meinen es sollte umgekehrt sein

 

[Al3xand3r01]

Ja es sollte auch No, So, Sw und Nw genommen werden - das wollte ich mit dem x+1 und y +1 und y -1 und x-1 erreichen - hab ich da einen Denkfehler?
X und Y hab ich auch noch vertauscht...
Aber irgendwie sind die Ergebnisse komplett suspekt, einmal niedriger einmal höher.
Meinst Du sollte ich das ganze vielleicht nicht nur mit Abfragen machen sondern mit Schleifen? Wir werden dazu angehalten perfomant zu programmieren, kostet mich das viel Performance?

 

[kneitzel]

Also vermutlich will er die diagonalen Elemente auch sonst wäre das Ergebnis nicht mal zu klein und mal zu groß... will er das Ursprungselement denn auch?

Zähl die Felder doch bitte mal auf für den Fall, dass es kein Randelement ist. Du hast ja ein Beispiel angegeben mit dem 3x3 Feld gefüllt mit den Zahlen von 1-9 ....
Was soll berechnet werden, wenn das Element ganz in der Mitte angegeben wird?

Und genereller Lösungsansatz:
Formuliere es erst mal als Summe aller Felder als wenn es alle Felder geben würde.
Den Feldzugriff machst Du aber dann als Methode z.B. getValueOrNull(int[][] Matrix, ist x, int y) was dann x/x auf Gültigkeit prüft und dann entweder den arrayinhalt der Position oder 0 zurück gibt.

 

[Al3xand3r01]

Also wenn das Elemtent in der Mitte liegt, dann würden alles restlichen Elemnte zusammengerechnet (in dem 3x3 Beispiel). Das Ursprungselement soll nicht gezählt werden.

Dein Lösungansatz gefällt mir gut, den werde ich auch umsetzen! Damit ich es richtig verstehe: Eine Methode die den Inhalt der Felder abruft, wenn das Element nicht existiert wird 0 zurcükgegeben. Diese Methode rufe ich dann in einer Schleife auf. Stimmt das so?

Danke für die Anregung!

 

[M.L.]

Auf die Schnelle: da nur die Nachbarelemente aufaddiert werden sollen, kann man die Feldanweisung [y][x] ignorieren, bzw. auskommentieren. Und in der letzten Bedingung sollte es an einer Stelle wohl "y-1" heissen.
Mit einer Teständerung könnte es passen:

public static void main(String[] args) {
        //Aufruf
        int[][] arr2d = {{1,2,3},{4,5,6},{7,-8,9}};  // -8
        System.out.println(nachbarn(arr2d, 2, 2));  // 2,2   statt 0,0
    }
    static int nachbarn(int[][] arr, int x, int y){
        int result = 0;
        if (x <= 0){
            //result += arr[y][x] + arr[y][x+1];
            result +=  arr[y][x+1];
            //  result +=   arr[x][y+1];
        }
        else if (x >= arr[y].length-1) {
            result += /*arr[y][x] + */ arr[y][x-1];
        }

        else {
            result += /*arr[y][x] + */ arr[y][x-1] + arr[y][x+1];
        }


        if (y <= 0) {
            result +=   arr[y+1][x];
            //result += arr[y][x] + arr[y+1][x];
            //result +=   arr[x+1][y];
        }
        else if (y >= arr.length-1){
            result += /*arr[y][x] + */ arr[y-1][x];
        }
        else {
            result += /*arr[y][x] +*/ arr[y - 1][x] + arr[y + 1][x];
        }
        return result;
}

 

[kneitzel]

Bei sowas würde ich Dir empfehlen, dir das aufzuzeichnen.

Also mal Dir deine Matrix auf mit drei mal drei Feldern:

x-1, y-1 | x, y-1 | x+1, y-1
x-1, y | x,y | x+1, y
x-1, y+1 | x, y+1 | x+1,y+1

Und dann geh den Code von Hand durch. Dann erkennst Du dass du in jedem if / else if / else Konstrukt das Feld x,y addierst (Das hast Du also doppelt - willst Du es überhaupt haben?)

Und in jedem Konstrukt addierst Du nur 3 Zahlen, also hast Du maximal 6 Felder von den 9 Feldern. Aber da eins doppelt ist, hast Du nur 5 Felder berücksichtigt.

Die Frage nach Schleife oder nicht spielt aus Performance Gründen keine Rolle. So minimal, dass es keine Rolle spielt.
Das ist nur eine Frage des Lesbarkeit. Du kannst also drei Array Elemente addieren (Beispiel mit einem int Array mit Namen a - Beispiel unabhängig von Deinem Problem!):

int result = a[0] + a[1] + a[2];

Oder Du kannst eine Schleife machen die halt von 0 bis 2 durchzählt.

Bei Dir wären es zwei verschachtelte Schleifen und da Du das mittlere Element nicht willst noch eine if Abfrage.

Das geht prinzipiell auch. Das sind zwei Ansätze, die ich sehe:
a) Du hast diese "Hilfsmethode", die prüft, ob ein Feld existiert. Dann brauchst Du keine Schleife um 8 Elemente zu addieren. Die Addition finde ich besser leslich.
b) Du baust es mit Schleifen. Da können Anfang und Ende dynamisch sein. Du hast dann vor den Schleifen die Festlegung der Grenzen um dann die Schleifen durchlaufen zu lassen. Das wäre dann sogar ganz ohne diese Hilfsmethode.


Hilfsmethode klingt schlecht, aber es ist etwas positives. So würde ich die Grenzen auch über Methoden ermitteln. Und wenn man sich das anschaut, dann sind es einfache min / max Entscheidungen. Die untere Grenze ist das Maximum von x-1 und 0 bzw y-1 und 0 und die obere Grenze ist das Minimum von eben x+1 (oder y+1) und der Array-Größe.

Aber das wären die generellen Abläufe, die ich sehen würde.

 

[Al3xand3r01]

@M.L. danke für Deine Antwort! Ich habe den Code gerade getestet, aber er liefert leider auch keine passenden Ergebnisse :/ aber ich glaube, dass ich mit diesem Ansatz sowieso auf dem Holzweg bin, danke trotzdem!

@kneitzel hab ich gerade gemacht, jetzt ist mir der Fehler klar.
Ich werde aufjedenfall die Hilfmethode nehmen, das finde ich auch schöner und ich denke, dass es den Lehrern so auch besser gefällt
Vorallem die Trennung zwischen Überprüfung und tatsächlicher Addition gefällt mir.

Mich fasziniert immer wieder wie viele Potentielle Lösungen es gibt...

Danke an alle die mir geholfen haben, ich denke, dass ich es jetzt fertig bekomme.

Schönen Tag und Gruß aus Österreich!

 

[MoxxiManagarm]

Mich fasziniert immer wieder wie viele Potentielle Lösungen es gibt...

Es gibt noch eine, aber es lässt sich darüber streiten (Exceptions in Logik einzubinden ist verpöhnt). Du könntest stur auf alle NachbarElemente zugreifen. Bei Randelementen würde dann eine ArrayIndexOutOfBoundsException fliegen, die dann abzufangen wäre.

 

[Al3xand3r01]

Die Idee klingt aber gar nicht so schlecht in dem Fall. Warum ist das denn verpönt?

 

[M.L.]

verpönt?

Ein potentieller Angriff auf das Programm führt dann zu Informationen, die einem unter regulären Umständen nicht zustehen, ein Hacken erleichtern (oder ermöglichen) und zum eigenen Vorteil ausgenutzt werden können. Man stelle sich das mit sensiblen Daten zur Gesundheit oder Kontodaten vor... Kurzgefasst sollte nur die Programmiererseite die Ergebnisse der Exceptions zu sehen bekommen (und geeignet handeln)

 

[Al3xand3r01]

Ah ok, das macht Sinn. Dann werde ich mir das gar nicht falsch angewöhnen und es direkt "richtig" machen
Ist jetzt zwar offtopic, aber mich interessiert wie Angriffe ablaufen, wie man sich davor schützen kann, bzw wie man den Code härtet, kennt ihr ein gutes Buch dazu? Ist jetzt zwar noch früh, aber ich würde gerne von Anfang an "sicheren" Code schreiben oder besser gesagt wenigstens verstehen worum es geht und worauf man achten muss.

 

[kneitzel]

Ein potentieller Angriff auf das Programm führt dann zu Informationen, die einem unter regulären Umständen nicht zustehen, ein Hacken erleichtern (oder ermöglichen) und zum eigenen Vorteil ausgenutzt werden können. Man stelle sich das mit sensiblen Daten zur Gesundheit oder Kontodaten vor... Kurzgefasst sollte nur die Programmiererseite die Ergebnisse der Exceptions zu sehen bekommen (und geeignet handeln)

Also da die Exception ja gefangen würde, ist das kein Argument. Die Exception bleibt somit ja auf der Programmiererseite....

Aber eine Exception zu werfen ist relativ umfangreich, denn es muss ein Stacktrace erstellt werden und so. Daher wäre das Laufzeitverhalten noch ein Grund.

Beim Debuggen kann es problematisch sein, wenn ständig Exceptions fliegen, denn dann kann man nicht einfach bis zur Exception laufen lassen. Das wäre ggf. noch ein praktischer Grund.

Generell hat es sich aber auch aus Clean Code Sicht eingebürgert, dass Exceptions nur für exceptional Behaviour verwendet werden. Also ein "Ich bin zu blöd, es richtig zu machen" soll vermieden werden...

Wenn Du ein Array aufsummieren willst, kannst Du auch mit Exceptions arbeiten. Einfach bei Element 0 anfangen und dann immer weiter machen, biss eine IndexOutOfBoundsException fliegt. Aber das würde man ja auch nicht als gut empfinden.