Felder - Feldwerte verdoppeln

[parrot]

Ich brauche Hilfe bitte.

Ich muss eine Methode int[] doppelte(int[] werte) schreiben, welche das Feld werte verdoppeln soll.

Bspw. Soll aus 4,2,1,-7 dann 4,4,2,2,1,1,-7,-7

 

[mrBrown]

Hast du schon irgendwas versucht oder zumindest irgendwelche Ideen?

 

[parrot]

Hast du schon irgendwas versucht oder zumindest irgendwelche Ideen?

Ich weiß leider nicht wie ich anfangen soll

 

[mrBrown]

Wie würdest du es machen, wenn du es „per Hand“ machen müsstest?

 

[BestGoalkeeper]

Da die Länge von Arrays fix ist... müsstest du jetzt die neue Länge des neuen Arrays im Voraus berechnen. Ein ungeheurer mathematischer Spagat. 😉

 

[kneitzel]

Die Hinweise, die eingegangen sind, sind ja schon recht gut. Mir bleibt dann nur - wie so oft - der Hinweis, die Problematik doch einmal von Hand durchzuführen mit Stift und Papier....

Dazu gibst Du Dir einfach einmal ein Beispielarray - 4, 2, 1, -7 hast Du ja schon genannt. Damit hast Du also eine Array mit 4 Elementen. Das gewünschte Ergebnis hast Du auch schon genannt - das ist dann ein Array mit einer bestimmten Anzahl Elemente ...

Dann hast Du ja Indices - die 4 steht an Index 0, die 2 an Index 1 u.s.w.
In welche Felder des Ziels hast Du diese geschrieben?

Siehst Du irgendwelche Regeln?
Aus 4 Feldern wurden wieviele Felder?
Wert aus Feld 0 wurde in Felder .... geschrieben.
Wert aus Feld 1 wurde in Felder ... geschrieben...

Siehst Du eine Regel? Aus einem Array mit x Feldern wird ein neues Array aus ??? Feldern?
Der Wert aus Feld y wird in die Felder .... geschrieben?

Ansonsten einfach noch etwas Spaß - das ignorierst du, @parrot, aber bitte.

Da die Länge von Arrays fix ist... müsstest du jetzt die neue Länge des neuen Arrays im Voraus berechnen. Ein ungeheurer mathematischer Spagat. 😉

Ja, das sind mathematische Probleme, die ich nicht lösen konnte. Da diese höhere Mathematik zu viel für mich ist, suche ich dann immer Lösungen, die ohne auskommen:

    public static int[] doppelte(int[] werte) {
        return Arrays.stream(werte).flatMap(wert -> IntStream.of(wert, wert)).toArray();
    }

 

[BestGoalkeeper]

ich dann immer Lösungen, die ohne auskommen

Aber das greift intern vielleicht auf Listen zurück; ein Werkzeug, das sie vielleicht noch gar nicht kennen 😉

 

[kneitzel]

Aber das greift intern vielleicht auf Listen zurück; ein Werkzeug, das sie vielleicht noch gar nicht kennen 😉

Unabhängig davon, ob Listen Verwendung finden oder nicht: Da sind ja viele Elemente, die noch weniger bekannt sind (Streams und Lambda Expression würde mir da direkt einfallen). Also definitiv keine Lösung für den TE.

 

[mihe7]

Ich weiß leider nicht wie ich anfangen soll

Zumindest solltest Du im Forum irgendwas liefern, an dem man Deine Gedankengänge halbwegs nachvollziehen kann. Das kann eine Zeichnung sein, ein Algorithmus, Pseudocode, ... spielt alles keine Rolle. Hintergrund ist, dass man Dir hier Hilfe zur Selbsthilfe zukommen lassen will (Du sollst ja in der Lage sein, derlei Probleme selbst zu lösen), d. h. man muss erst einmal sehen, wo es hakt.

 

[BestGoalkeeper]

Anfang:
[CODE lang="java" highlight="2"] public static int[] doppelte(int[] werte) {
int[] werte_b =
for (int i = 0; i < werte_b.length; i += 2) {
werte_b = werte[i / 2];
werte_b[i + 1] = werte[i / 2];
}
return werte_b;
}

public static void main(String[] args) {
System.out.println(Arrays.toString(doppelte(new int[] { 1, 2, 3 })));
}[/CODE]

 

[parrot]

Anfang:
[CODE lang="java" highlight="2"] public static int[] doppelte(int[] werte) {
int[] werte_b = new int werte_b [];
for (int i = 0; i < werte_b.length; i += 2) {
werte_b = werte[i / 2];
werte_b[i + 1] = werte[i / 2];
}
return werte_b;
}

public static void main(String[] args) {
System.out.println(Arrays.toString(doppelte(new int[] { 1, 2, 3 })));
}[/CODE]

 

[BestGoalkeeper]

Du musst die Größe des neuen Felds noch festlegen!

 

[Flown]

Ich würde in die andere Richtung gehen (ist reine Geschmackssache) und über die Indizes des Eingabearrays iterieren. Dann den Index via Formel 2 * i (gerade Index) respektive 2 * i + 1 (ungerader Index) berechnen.

public static int[] doppelte(int[] werte) {
  Objects.requireNonNull(werte, "werte sind null");
  int[] doubled = new int[werte.length * 2];
  for (int i = 0; i < werte.length; i++) {
    doubled[2 * i] = werte[i];
    doubled[2 * i + 1] = werte[i];
  }
  return doubled;
}

 

[BestGoalkeeper]

Ginge auch. Dafür spräche, man hätte die unheimlich komplizierte Rechnung nur auf einer Seite...

 

[Flown]

Ginge auch. Dafür spräche, man hätte die unheimlich komplizierte Rechnung nur auf einer Seite...

  for (int i = 0, j = 0; i < werte.length; i++) {
    doubled[j++] = werte[i];
    doubled[j++] = werte[i];
  }

Keine "komplizierte" Rechnung mehr

 

[mrBrown]

  for (int i = 0, j = 0; i < werte.length; i++) {
    doubled[j++] = werte[i];
    doubled[j++] = werte[i];
  }

Keine "komplizierte" Rechnung mehr

Dafür allerdings dieses „versteckte“ j++

 

[Flown]

Dafür allerdings dieses „versteckte“ j++

Naja zählen oder berechnen, dass sind die 2 Optionen. Wenn eine Berechnung schon kompliziert ist, was ist dann zählen? Die Frage ist, was ist dann einfach?

 

[kneitzel]

  for (int i = 0, j = 0; i < werte.length; i++, j+=2) {
    doubled[j] = werte[i];
    doubled[j+1] = werte[i];
  }

Dann wäre sowas denkbar. Aber ich würde die Version mit der Berechnung bevorzugen.

 

[BestGoalkeeper]

Wenn eine Berechnung schon kompliziert ist

Rechnen? Was war das nochmal? 😁🤣