Methoden Zwei Arrays abwechselnd zusammenführen

[Neoline]

Hallo,
und zwar hatte ich zuerst die Aufgabe zwei Arrays aneinander zuhängen das habe ich noch gelöst bekommen nun soll ich aber zwei Arrays abwechselnd mit einander verbinden.

Nun dachte ich mir das ich ja einfach nur hingehen muss und dafür sorgen muss, dass das Array a nur an gerade Positionen ins Array c geschrieben wird und Array b nur an ungerade Positionen. Allerdings will mir das nicht so ganz gelingen. Ist das überhaupt möglich? Falls ja hätte hier jmd. einen Denkanstoß?

package test;

import java.util.Arrays;

public class test6_4 {

    public static void main(String[] args) {

        System.out.println(Arrays.toString(merge(new int[3], new int[5])));
    }// main

    public static int[] merge(int[] a1, int[] a2) {

        int[] combinedArray = new int[a1.length + a2.length];

        for (int index = 0; index < combinedArray.length; index++, index++) {
            combinedArray[index] = a1[index];
        } // for

        for (int index = 1; index < combinedArray.length; index++, index++) {
            combinedArray[index] = a2[index];
        } // for

        return combinedArray;

    }// merge
}// class

Grüße
Neoline

 

[httpdigest]

Die Idee ist schon sehr gut, aber schaue einmal genauer hin, von welcher Position du die Werte in der ersten Schleife aus dem a1 Array liest. Hier liest du ja auch nur jedes zweite Element, weil du sowohl für das Lesen als auch für das Schreiben denselben Index verwendest, den du ja doppelt inkrementierst.
Auch die zweite Schleife über das a2 Array ist falsch, da du ja erst bei dem zweiten Arrayelement anfängst, aus dem a2 Array zu lesen (und der erste genannte Fehler mit dem Lesen und Schreiben über denselben Index hier auch drin ist).
Also Hinweis: Benutze zum Lesen und zum Schreiben zwei unterschiedliche Indizes. Das müssen nicht zwangsweise zwei unterschiedliche Variablen sein. Du kannst den Index zum Schreiben aus dem Index zum Lesen per einfacher Arithmetik berechnen.

 

[Neoline]

Erstmal danke für deine Antwort. Ich habe nun etwas was funktioniert allerdings gibs da bestimmt noch optimerungsbedarf. Hätte da jmd ansätze das ganze schlanker zu gestallten ?

package test;

import java.util.Arrays;

public class test6_4 {

    public static void main(String[] args) {

        System.out.println(Arrays.toString(merge(new int[] { 1, 3, 5, 7, 9 }, new int[] { 2, 4, 6, 8, 10 })));
    }// main

    public static int[] merge(int[] a1, int[] a2) {

        int[] combinedArray = new int[a1.length + a2.length];
        int i = 0;
        int j = 1;
        for (int index = 0; index < combinedArray.length; index++) {
            if (i < combinedArray.length) {
                combinedArray[i] = a1[index];
                i++;
                i++;
            } // if
        } // for

        for (int index = 0; index < combinedArray.length; index++) {
            if (j < combinedArray.length) {
                combinedArray[j] = a2[index];
                j++;
                j++;
            } // if
        } // for

        return combinedArray;

    }// merge
}// class

Ausgabe:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Grüße
Neoline

 

[Blender3D]

import java.util.Arrays;

public class test6_4 {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(merge(new int[] { 1, 3, 5, 7, 9 }, new int[] { 2, 4, 6, 8, 10 })));
    }// main

    public static int[] merge(int[] a1, int[] a2) {
        int[] combinedArray = new int[a1.length + a2.length];

        int len = Math.max(a1.length, a2.length);
        int idx = 0;
        for (int i = 0; i < len; i++) {
            if (i < a1.length)
                combinedArray[idx] = a1[i];
            if (i < a2.length )
                combinedArray[idx + 1] = a2[i];
            idx += 2;
            // if
        } // for
        return combinedArray;
    }// merge
}// class

😉

 

[httpdigest]

Wie gesagt, du brauchst keine zwei Variablen für lesenden und schreibenden Arrayzugriff 🙂

public static int[] merge(int[] a1, int[] a2) {
  int[] combinedArray = new int[a1.length + a2.length];
  for (int i = 0; i < a1.length; i++)
    combinedArray[i*2] = a1[i];
  for (int i = 0; i < a2.length; i++)
    combinedArray[i*2+1] = a2[i];
  return combinedArray;
}

EDIT: Funktioniert jedoch nur, wenn beide Arrays gleichlang sind...

 

[httpdigest]

Folgender Code funktioniert auch für beliebig unterschiedlich lange Arrays und auch leere Arrays. Es versucht, solange die Elemente abwechselnd zu vermischen, bis eines der Arrays endet, und dann wird das restliche Array noch bis zum Ende nacheinander geschrieben:

public static int[] merge(int[] a1, int[] a2) {
    int[] combinedArray = new int[a1.length + a2.length];
    for (int i = 0, j = 0; i < a1.length; i++, j++)
        combinedArray[i < a2.length ? j++ : j] = a1[i];
    for (int i = 0, j = 0; i < a2.length; i++, j++)
        combinedArray[i < a1.length ? ++j : j] = a2[i];
    return combinedArray;
}

 

[Blender3D]

    public static int[] merge(int[] a1, int[] a2) {
        int[] combinedArray = new int[a1.length + a2.length];
        int idx = 0;
        for (int i = 0; i < Math.max(a1.length, a2.length); i++) {
            if (i < a1.length)
                combinedArray[idx] = a1[i];
            else
                idx--;
            if (i < a2.length)
                combinedArray[idx + 1] = a2[i];
            else
                idx--;
            idx += 2;           
        }
        return combinedArray;
    }

1 Schleife und möglicher unterschiedlicher Arraygröße.

 

[Flown]

Ich mag auch mitspielen bei diesem Codegolf:

/**
 * Creates a new combined array with alternating values from array {@code a} and {@code b}.
 *
 * @param a first array
 * @param b second array
 * @return an empty array, if {@code a} and {@code b} are {@code null} or empty.
 * Or a copy of the other array if one is {@code null} or empty.
 * Or a combined array with alternating values {@code {a[0], b[0], a[1], b[1], ...}}.
 */
public static int[] zip(int[] a, int[] b) {
  if (a == null || a.length == 0) {
    return b == null ? new int[0] : b.clone();
  }
  if (b == null || b.length == 0) {
    return a.clone();
  }
  int[] result = new int[a.length + b.length];
  for (int i = 0, x = 0, y = 0; i < result.length; ) {
    if (x < a.length) {
      result[i++] = a[x++];
    }
    if (y < b.length) {
      result[i++] = b[y++];
    }
  }
  return result;
}

 

[Flown]

Einen hab ich noch, dann ist schluss:

public int[] zip(int[] a, int[] b) {
  if (a == null || a.length == 0) {
    return b == null ? new int[0] : b.clone();
  }
  if (b == null || b.length == 0) {
    return a.clone();
  }
  return zip0(a, b);
}

private static int[] zip0(int[] a, int[] b) {
  int[] result = new int[a.length + b.length];
  int minLength = 2 * Math.min(a.length, b.length);
  int x = 0, y = 0;
  for (int i = 0; i < minLength;) {
    result[i++] = a[x++];
    result[i++] = b[y++];
  }
  System.arraycopy(a, x, result, minLength, a.length - x);
  System.arraycopy(b, y, result, minLength, b.length - y);
  return result;
}

 

[Neoline]

Vielen dank für die vielen Antworten und Ideen.
Habe mich für folgendes entschieden da es nur um gleichlange Arrays ging.

import java.util.Arrays;

public class test6_4 {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(merge(new int[] { 1, 3, 5, 7, 9 }, new int[] { 2, 4, 6, 8, 10 })));
    }// main

    public static int[] merge(int[] a1, int[] a2) {
        int[] combinedArray = new int[a1.length + a2.length];
        for (int index = 0; index < a1.length; index++) {
            combinedArray[index * 2] = a1[index];
        } // for
        for (int index = 1; index < a2.length; index++) {
            combinedArray[index * 2] = a2[index];
        } // for
        return combinedArray;
    }// merge
}// class

 

[httpdigest]

Vielen dank für die vielen Antworten und Ideen.
Habe mich für folgendes entschieden da es nur um gleichlange Arrays ging.

import java.util.Arrays;

public class test6_4 {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(merge(new int[] { 1, 3, 5, 7, 9 }, new int[] { 2, 4, 6, 8, 10 })));
    }// main

    public static int[] merge(int[] a1, int[] a2) {
        int[] combinedArray = new int[a1.length + a2.length];
        for (int index = 0; index < a1.length; index++) {
            combinedArray[index * 2] = a1[index];
        } // for
        for (int index = 1; index < a2.length; index++) {
            combinedArray[index * 2] = a2[index];
        } // for
        return combinedArray;
    }// merge
}// class

Hast du das mal ausgeführt? Das funktioniert doch hinten und vorne nicht...
Wenn du schon die Lösung mit den zwei Schleifen nehmen möchtest, dann bitte auch richtig:

public static int[] merge(int[] a1, int[] a2) {
  int[] combinedArray = new int[a1.length + a2.length];
  for (int i = 0; i < a1.length; i++)
    combinedArray[i*2]   = a1[i];
  for (int i = 0; i < a2.length; i++)
    combinedArray[i*2+1] = a2[i];
  return combinedArray;
}

 

[Blender3D]

🙂

 

[Neoline]

Ja klar hab ich das so ausgeführt ist direkt aus Eclipse rauskopiert gewesen. Ist doch das gleiche bis auf das ich um die Anweisung in meiner for schleife ne geschweifte Klammer gesetzt habe und i bei mir index heißt.

 

[mrBrown]

Ja klar hab ich das so ausgeführt ist direkt aus Eclipse rauskopiert gewesen. Ist doch das gleiche bis auf das ich um die Anweisung in meiner for schleife ne geschweifte Klammer gesetzt habe und i bei mir index heißt.

Hast du dir mal genauer angeguckt, welches jeweils die Indizes für das Ziel-Array sind?

erste Schleife: 0,2,4,6,...
zweite Schleife: 2,4,6,8,...

 

[httpdigest]

Ist doch das gleiche bis auf das ich um die Anweisung in meiner for schleife ne geschweifte Klammer gesetzt habe und i bei mir index heißt.

Ähm... nein? Unterschiede:
- Du benutzt in beiden Schleifen index * 2 als Schreibindex, was dazu führt, dass immer nur in jedes zweite Element des Ergebnisarrays geschrieben wird, niemals in ungerade Indizes. Außerdem führt es dazu, dass die zweite Schleife ab dem zweiten Index die Elemente, die die erste Schleife in das Ergebnisarray schreibt, wieder überschreibt.
- Du initialisierst index in der zweiten Schleife mit 1, was dazu führt, dass du erst bei dem zweiten Elemente in dem zweiten Eingabearray anfängst, zu lesen. Außerdem führt es dazu, dass die zweite Schleife erst in die dritte Position in das Ergebnisarray schreibt (durch index * 2, wobei index = 1 ist, also insgesamt = 2).
Heraus kommt in deinem ganz genauen Beispiel: [1, 0, 4, 0, 6, 0, 8, 0, 10, 0]

 

[Neoline]

Ihr habt natürlich recht ^^. Irgendwas ist da durcheinander gekommen... Das fertige Programm war :

Spoiler: Java-Code

package test;

import java.util.Arrays;

public class test6_4 {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(merge(new int[] { 1, 3, 5, 7, 9 }, new int[] { 2, 4, 6, 8, 10 })));
    }// main

    public static int[] merge(int[] a1, int[] a2) {
        int[] combinedArray = new int[a1.length + a2.length];
        for (int index = 0; index < a1.length; index++) {
            combinedArray[index * 2] = a1[index];
        } // for
        for (int index = 0; index < a2.length; index++) {
            combinedArray[index * 2 + 1] = a2[index];
        } // for
        return combinedArray;
    }// merge
}// class

Kann mir gerade ned erklären was da schiefgelaufen ist. Hatte es ja ausgeführt gehabt und da war es richtig. Vllt hab ich ausversehn dran rumngesgpielt zwischen durch. Entschuldigung das ich hier Spaghetticode gepostet habe.