Addieren von Arrays

[faz]

Hallo,
ich versuche mit meinem Code zwei Arrays zu addieren und wenn nötig ein kürzeres Array vorher auf die Länge des längeren Arrays zubringen, mit Hilfe eines Hilfsarray. Am Schluss soll noch das Ergebnisarray ausgegeben werden.

addsequences --> wird von einer main Funktion aufgerufen
seqA u. seqB --> ebenfalls von main Funktion aufgerufen

hinter ergebnisliste, seqA u. seqB steht meistens ein [ i ], wird hier aber nicht angezeigt.

    static int[] addSequences (int[] seqA, int[] seqB) {

        int[] hilfsarrayA = new int[seqA.length];
        int[] hilfsarrayB = new int[seqB.length];
        int max = 0;
        if ((seqA.length) == (seqB.length)) {
            max = seqA.length;
        }
        if (seqA.length > seqB.length) {
            max = seqA.length;
        }
        if (seqA.length < seqB.length) {
            max = seqB.length;
        }
        int[] ergebnisliste = new int [max];

        if ((seqA.length) == (seqB.length)) {
            ergebnisliste = new int [seqA.length];
                for (int i = 0; i < seqA.length; i++) {
                    ergebnisliste[i] = seqA[i] + seqB[i];
                }
            }
        if (seqA.length > seqB.length) {
            ergebnisliste = new int [seqA.length];
                for (int i = 0; i < seqB.length; i++) {
                    hilfsarrayA[i] = seqB[i];
            }
                for (int i = 0; i < seqA.length; i++) {
                    ergebnisliste[i] = seqA[i] + hilfsarrayA[i];
                    }
                }
        if (seqA.length < seqB.length) {
            ergebnisliste = new int [seqB.length];
                for (int i = 0; i < seqA.length; i++) {
                    hilfsarrayB[i] = seqA[i];
            }
                for (int i = 0; i < seqB.length; i++) {
                    ergebnisliste[i] = seqB[i] + hilfsarrayB[i];
                    }
                }
        return ergebnisliste;
    }

 

[Robat]

Poste den Code bitte in Code-Tags Entweder wie in meiner Signatur steht oder im Editor den "Einfügen"-Button klicken (4. von rechts) und dann "Code einfügen".
Dann weiß man auch an welcher Stelle du [i] geschrieben hast und wo nicht

 

[MoxxiManagarm]

Mi persönlich fehlt noch eine Fragestellung...

 

[Xyz1]

ich versuche mit meinem Code zwei Arrays zu addieren und wenn nötig ein kürzeres Array vorher auf die Länge des längeren Arrays zubringen, mit Hilfe eines Hilfsarray. Am Schluss soll noch das Ergebnisarray ausgegeben werden.

Habe ich verstanden, aber was wär die Fragestellung?
Außerdem Code vernünftig in Code-Tags hier einfügen.
Außerdem wie viele Eingabe-, Zwischen- und Ausgabearrays soll s denn geben?

 

[faz]

Also die Fragestellung wäre warum er dies nicht macht...

Es werden zwei Eingabearrays geliefert und ausgeben soll er ein Array. Die Werte sollen dabei die zusammen addierten Werte der Eingabearrays entsprechen.

Danke an den Moderator der mir mein Code bearbeitet hat, ich werde es mir für das nächste mal merken!

 

[Robat]

Dein Code ist zwar sehr Umständlich formuliert aber so wie er oben steht macht er das, was er soll.
Daher kann ich deine Frage nicht so recht nachvollziehen.

 

[faz]

In Verbindung mit meiner Main Funktion macht er das ja tatsächlich nicht.

Das ist die main Funktion:

public static void main (String[] args) {
        // example uses of the functions operating on int sequences
        int[] sampleSeq = { 12, 25, 30, 32, 37, 42, 77, 101 };
        int[] emptySeq = new int[0];
        int[] result;

        Out.println("-- Teste Funktion addSequences");
        result = addSequences(sampleSeq, new int[] { 6, -6, 5, -5, 4, -4, 3, -3 });
        printSequence(result);
        result = addSequences(sampleSeq, new int[] { 7, -3, 5 });
        printSequence(result);
        result = addSequences(new int[] { -11, 9, 4, 2 }, sampleSeq);
        printSequence(result);
        result = addSequences(emptySeq, sampleSeq);
        printSequence(result);
        result = addSequences(sampleSeq, emptySeq);
        printSequence(result);
    }

und er gibt mir das Ergebnis aus:
Sequence of length 8: 6, -6, 5, -5, 4, -4, 3, -3
Sequence of length 8: 7, -3, 5, 0, 0, 0, 0, 0
Sequence of length 8: -11, 9, 4, 2, 0, 0, 0, 0
Sequence of length 8: 0, 0, 0, 0, 0, 0, 0, 0
Sequence of length 8: 0, 0, 0, 0, 0, 0, 0, 0

Für mich sieht das aus als würde er sampleSeq immer als einen leeren Array Liste ansehen.

 

[Xyz1]

Aber so ist das schon etwas schlampig...
Ich helfe mal gerad:

    static int[] addSequences(int[] seqA, int[] seqB) {
        int[] hilfsarrayA = new int[seqA.length];
        int[] hilfsarrayB = new int[seqB.length];
        int max = 0;
        if ((seqA.length) == (seqB.length)) {
            max = seqA.length;
        }
        if (seqA.length > seqB.length) {
            max = seqA.length;
        }
        if (seqA.length < seqB.length) {
            max = seqB.length;
        }
        int[] ergebnisliste = new int[max];

        if ((seqA.length) == (seqB.length)) {
            ergebnisliste = new int[seqA.length];
            for (int i = 0; i < seqA.length; i++) {
                ergebnisliste[i] = seqA[i] + seqB[i];
            }
        }
        if (seqA.length > seqB.length) {
            ergebnisliste = new int[seqA.length];
            for (int i = 0; i < seqB.length; i++) {
                hilfsarrayA[i] = seqB[i];
            }
            for (int i = 0; i < seqA.length; i++) {
                ergebnisliste[i] = seqA[i] + hilfsarrayA[i];
            }
        }
        if (seqA.length < seqB.length) {
            ergebnisliste = new int[seqB.length];
            for (int i = 0; i < seqA.length; i++) {
                hilfsarrayB[i] = seqA[i];
            }
            for (int i = 0; i < seqB.length; i++) {
                ergebnisliste[i] = seqB[i] + hilfsarrayB[i];
            }
        }
        return ergebnisliste;
    }

 

[faz]

War das jetzt eine reine Schönheitskorrektur? zugegeben ich mache noch recht viele Einrückfehler, das macht aber in Java zum Glück nicht soviel wie zb. in Haskell . Aber ich werde auch da in Zukunft drauf Achten!

 

[Xyz1]

Ich muss überlegen, wie das ging, denn das erste Semester liegt schon etwas länger zurück...
Also erstmal das Verständnis auffrischen denn ein Array ist keine Liste.
Das sind zwei paar Schuhe (Variablennamen).

Dann brauchst du zum Zddieren nur ein Hilfsarray aber.
Und zwar muss das um 1 länger sein als das längere der beiden "Eingabe"arrays.
999 und
99
= 1098 (eine Stelle mehr).

Hilft das vielleicht dir schon?

 

[faz]

Das hilft mir leider nicht. Ich habe sie eins länger gemacht aber das Ergebnis bleibt das selbe.
Ich könnte mir vorstellen das, wenn sie zu kurz sind ich die Fehlermeldung bekommen würde Out of bounce oder so...
btw. ist nicht erstes Semester

 

[Xyz1]

Hilft denn das etwas:


Mir ist da ne Klammer verrutscht.

Nicht im ersten Semester , müsstest Du das aber können oder drauf haben.

 

[faz]

Leider hilft mir das nicht weiter, kann dem Schaubild nicht wirklich etwas entnehmen das mir weiterhelfen könnte

 

[Xyz1]

Und wo haperts?

 

[MoxxiManagarm]

Mich verwirren deine Hilfearrays absolut. Muss denn alles in dieser einen Methode passieren? Ansonsten könntest du doch eine Methode machen, die bereits geordnete Arrays sortiert und eine, die diese Methode entsprechend der Arrays aufruft. Ich wette das würde dir deutlich einfacher fallen.

Signatur:

    /**
    * Addiert die Elementer zweier Arrays. Ein Array kann dabei kürzer sein als das andere.
    * Ruft intern addSequenzesSafe auf.
    * @param seqA Erster Summand
    * @param seqB Zweiter Summand
    * @return Summe
    */
    public int[] addSequenzesUnsafe(int[] seqA, int[] seqB);

    /**
    * Addiert die Elementer zweier Arrays. Ein Array kann dabei kürzer sein als das andere.
    * @param laenger Erster Summand. Ist länger als der zweite Summand (oder gleich lang)
    * @param kuerzer Zweiter kürzerer Summand.
    * @return Summe
    */
    private int[] addSequenzesSafe(int[] laenger, int[] kuerzer);

 

[faz]

Mich verwirren deine Hilfearrays absolut. Muss denn alles in dieser einen Methode passieren? Ansonsten könntest du doch eine Methode machen, die bereits geordnete Arrays sortiert und eine, die diese Methode entsprechend der Arrays aufruft. Ich wette das würde dir deutlich einfacher fallen.

Signatur:

    /**
    * Addiert die Elementer zweier Arrays. Ein Array kann dabei kürzer sein als das andere.
    * Ruft intern addSequenzesSafe auf.
    * @param seqA Erster Summand
    * @param seqB Zweiter Summand
    * @return Summe
    */
    public int[] addSequenzesUnsafe(int[] seqA, int[] seqB);

    /**
    * Addiert die Elementer zweier Arrays. Ein Array kann dabei kürzer sein als das andere.
    * @param laenger Erster Summand. Ist länger als der zweite Summand (oder gleich lang)
    * @param kuerzer Zweiter kürzerer Summand.
    * @return Summe
    */
    private int[] addSequenzesSafe(int[] laenger, int[] kuerzer);

Es ist nicht so, dass mich der Code verwirrt, ich finde ihn relativ gut überschaubar. Die Hilfsarrays erfüllen ihren Job, heißt die kürzeren Arrays werden auf die passende Länge gebracht.

Mein Problem ist warum der Code beim Aufruf durch die main Methode mir nur das Hilfsarray ausgibt bestehend aus dem ursprünglich kürzerem Array und das erweitert auf die Länge des anderen mit Nullen

 

[mrBrown]

Es ist nicht so, dass mich der Code verwirrt, ich finde ihn relativ gut überschaubar. Die Hilfsarrays erfüllen ihren Job, heißt die kürzeren Arrays werden auf die passende Länge gebracht.

Mein Problem ist warum der Code beim Aufruf durch die main Methode mir nur das Hilfsarray ausgibt bestehend aus dem ursprünglich kürzerem Array und das erweitert auf die Länge des anderen mit Nullen

Ehrlich gesagt finde ich das auch total verwirrend, da muss ich @MoxxiManagarm zustimmen. Gefühlt kommt alles in dem Code dreifach vor...



Dein Code macht aber genau das, was er sollte. In den Ergebnissen steht an keiner Stelle irgendwo eine 0, sondern die beiden Arrays sind passend aufsummiert.

Spoiler

Ohne die ganzen Hilfsarrays, if und Schleifen:

static int[] addSequences(int[] seqA, int[] seqB) {
        int max = seqA.length;
        if (seqB.length > seqA.length) {
            max = seqB.length;
        }
        int[] ergebnisliste = new int[max];

        for (int i = 0; i < seqA.length; i++) {
            ergebnisliste[i] += seqA[i];
        }
        for (int i = 0; i < seqB.length; i++) {
            ergebnisliste[i] += seqB[i];
        }
       
        return ergebnisliste;
    }

 

[faz]

jetzt bin ich gerade echt ein wenig überfragt. Dein Code gibt mir das gleiche aus wie meiner und zwar:

6, -6, 5, -5, 4, -4, 3, -3
7, -3, 5, 0, 0, 0, 0, 0
-11, 9, 4, 2, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0

das ist ja nicht korrekt. Weis jetzt aber auch nicht mehr weiter

 

[mrBrown]

Der Fehler liegt auf jeden Fall nicht an diesem Code, der funktioniert einwandfrei.

result ist bei mir:

[18, 19, 35, 27, 41, 38, 80, 98]
[19, 22, 35, 32, 37, 42, 77, 101]
[1, 34, 34, 34, 37, 42, 77, 101]
[12, 25, 30, 32, 37, 42, 77, 101]
[12, 25, 30, 32, 37, 42, 77, 101]

 

[Javinner]

@faz
Da das Geheimnis bereits gelüftet wurde, poste ich meine Version.

static int[] addSequences(int[] array_a, int[] array_b) {
        int[] x = new int[Math.max(array_a.length, array_b.length)];
        array_addition(x, array_a, array_b);
        return x;
    }
/** Hier kann man es wesentlich unübersichtlicher und komplizierter gestalten */
private static void array_addition(int[] x, int[] array_a, int[] array_b) {
        for (int i = 0; i < array_a.length; i++) {
            x[i] += array_a[i];
        }
        for (int i = 0; i < array_b.length; i++) {
            x[i] += array_b[i];
        }
}

/** Konsolenausgabe */
18, 19, 35, 27, 41, 38, 80, 98
19, 22, 35, 32, 37, 42, 77, 101
1, 34, 34, 34, 37, 42, 77, 101
12, 25, 30, 32, 37, 42, 77, 101
12, 25, 30, 32, 37, 42, 77, 101

 

[faz]

Na toll, da kann ich ewig suchen! Dann hat wohl mein compiler ein Fehler. Danke für eure Hilfe!!!

 

[Javinner]

Na toll, da kann ich ewig suchen! Dann hat wohl mein compiler ein Fehler. Danke für eure Hilfe!!!

Dein Compiler funktioniert nach wie vor einwandfrei. Ich sehe das Problem an einer anderen Stelle.
Schau dir die Vorschläge an, mindestens zwei davon (nur kurz überflogen) liefern eine Lösung und mehr als zwei ein Lösungsansatz..

 

[mrBrown]

Na toll, da kann ich ewig suchen! Dann hat wohl mein compiler ein Fehler. Danke für eure Hilfe!!!

wie compilers du denn und führst es aus?
Ich würde nicht davon ausgehen, dass dein Compiler einen Fehler hat...

Dein Compiler funktioniert nach wie vor einwandfrei. Ich sehe das Problem an einer anderen Stelle.

An welcher Stelle siehst du das denn?

 

[Javinner]

An welcher Stelle siehst du das denn?

Persönlicher Erfahrungswert: 99% aller Computerprobleme sitzen vor dem Computer Ab und an auch ich

 

[mrBrown]

Persönlicher Erfahrungswert: 99% aller Computerprobleme sitzen vor dem Computer Ab und an auch ich

Da seh ich das in diesem Fall auch - aber wie helfen da die Lösungen/Lösungsansätze in diesem Thread weiter?

 

[Javinner]

Da seh ich das in diesem Fall auch - aber wie helfen da die Lösungen/Lösungsansätze in diesem Thread weiter?

In der ehemaligen UDSSR gab es ein Banner: "Das Retten der Ertrinkenden liegt in den Händen der Ertrinkenden"
Wie überall auch, es Hilft nur dem, der sich selbst helfen will. Genug Rettungsringe sind geworfen, schwimmen muss der User selbst

 

[DrZoidberg]

Hier noch zwei weiter Lösungen.
Mit Hilfe des ternären Operator

static int[] addSequences(int[] seqA, int[] seqB) {
  int[] ergebnisliste = new int[Math.max(seqA.length, seqB.length)];

  for (int i = 0; i < ergebnisliste.length; i++) {
    ergebnisliste[i] = (i < seqA.length ? seqA[i] : 0) + (i < seqB.length ? seqB[i] : 0);
  }
 
  return ergebnisliste;
}

und mittels Vertauschen der beiden Arrays

static int[] addSequences (int[] seqA, int[] seqB) {
  if(seqA.length < seqB.length) {
    int[] t = seqA;
    seqA = seqB;
    seqB = t;
  }
 
  int[] ergebnisliste = new int[seqA.length];
  int i = 0;
  for(;i < seqB.length; i++) {
    ergebnisliste[i] = seqA[i] + seqB[i];
  }
  for(;i < seqA.length; i++) {
    ergebnisliste[i] = seqA[i];
  }
  return ergebnisliste;
}

 

[faz]

Ich arbeite mit dem Terminal, ich erstelle die class mit javac ... .java und compiliere dann mit java ... . Ist das den Falsch ?! Mir geben auch alle anderen Codes das selbe Ergebnis raus.

 

[Xyz1]

Ich arbeite mit dem Terminal, ich erstelle die class mit javac ... .java und compiliere dann mit java ... . Ist das den Falsch ?! Mir geben auch alle anderen Codes das selbe Ergebnis raus.

Dass der Compiler oder die Laufzeit nicht richtig ist , halte ich für falsch....

 

[mrBrown]

Ich arbeite mit dem Terminal, ich erstelle die class mit javac ... .java und compiliere dann mit java ... . Ist das den Falsch ?! Mir geben auch alle anderen Codes das selbe Ergebnis raus.

Zeig doch mal die genauen Befehle

 

[faz]

$ javac IntSequenceFunctions.java
$ java IntSequenceFunctions

IntSequenceFunctions ist die public class

 

[DrZoidberg]

Da machst du irgendwas falsch.
Ich hab das jetzt auch mal von der Konsole kompiliert und einen Screenshot gemacht.

 

[faz]

Ich habe heute die Lösung für mein Problem gefunden. Tatsächlich saß, wie die meisten es schon erwartet haben, das Problem vor dem Computer.

Da der Code nur ein Teil eines größeren war, und die main Funktion davor noch auf einen anderen Teil zugreift war mein gepostetes Problem ein Folgefehler dessen. In vorheriger bediente ich mich nicht eines Hilfsarrays sondern veränderte das seq Array für das gewünschte Ergebnis... andere Werte andere Ergebnisse.

Trotzdem Danke für eure Hilfe