# Addieren von Arrays



## faz (30. Apr 2018)

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.



		Java:In die Zwischenablage kopieren


    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 (30. Apr 2018)

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 (30. Apr 2018)

Mi persönlich fehlt noch eine Fragestellung...


----------



## Xyz1 (30. Apr 2018)

faz hat gesagt.:


> 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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

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


----------



## Xyz1 (1. Mai 2018)

Und wo haperts?


----------



## MoxxiManagarm (1. Mai 2018)

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 (1. Mai 2018)

MoxxiManagarm hat gesagt.:


> 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:
> 
> ...




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 (1. Mai 2018)

faz hat gesagt.:


> 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 (1. Mai 2018)

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 (1. Mai 2018)

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 (1. Mai 2018)

@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 (1. Mai 2018)

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


----------



## Javinner (1. Mai 2018)

faz hat gesagt.:


> 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 (1. Mai 2018)

faz hat gesagt.:


> 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...




Javinner hat gesagt.:


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


An welcher Stelle siehst du das denn?


----------



## Javinner (1. Mai 2018)

mrBrown hat gesagt.:


> An welcher Stelle siehst du das denn?


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


----------



## mrBrown (1. Mai 2018)

Javinner hat gesagt.:


> 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 (2. Mai 2018)

mrBrown hat gesagt.:


> 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 (2. Mai 2018)

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 (2. Mai 2018)

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 (2. Mai 2018)

faz hat gesagt.:


> 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 (2. Mai 2018)

faz hat gesagt.:


> 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 (2. Mai 2018)

$ javac IntSequenceFunctions.java
$ java IntSequenceFunctions

IntSequenceFunctions ist die public class


----------



## DrZoidberg (2. Mai 2018)

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


----------



## faz (2. Mai 2018)

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


----------

