Hilfe bei Praktischen Aufgaben von Arrays

[sporty90]

Hallo,

ich lese hier schon einige Zeit still mit und beschäftige mich seit einigen Wochen mit Java, was mir manchmal doch noch schwer fällt. Vielleicht könnt ihr mir ja bei einer Aufgabe helfen, ohne mir die Lösung zu sagen, möchte das Prinzip dahinter schon verstehen.

Hier die Aufgabe:

Ich soll ein Feld realisieren, dass doppelt so lang ist wie das übergebene Feld und alle Werte des übergebenen Feld sollen dabei zweifach hintereinander enthalten sein. Die Aufgabe soll mit einer for Schleife gelöst werden.

Beispiel: Übergebene Feld enthält die Werte 4,2,1,-7
Zurückgegebene Feld enthält die Werte 4,4,2,2,1,1,-7,-7

Mein Ansatz ist bis jetzt ziemlich dürftig, ich weiß nicht, ob ich die Zahlen aus dem Übergebenen Feld "Klonen" soll oder wie ich ansonsten da rangehen soll.


public class DoppeltWerte {

public static void main(String[] args) {

int[] werte = new int[]{4, 2, 1, -7};
int[] neueWerte = new int[(werte.length) * 2];

for (int i = 0; i < werte.length; i++) {

neueWerte = werte * 2;

System.out.println(neueWerte);

}

}

}

 

[Oneixee5]

neueWerte = werte * 2;

Beide Variablen sind vom Typ Array, also Array * 2 ist nicht gültig. An die Werte im Array kommst du über den Index, also werte[index]

 

[KonradN]

erst einmal der Hinweis: Du solltest Code immer in Code Tags posten - dazu einfach den Knopf </> links oberhalb des Eingabefeldes nutzen.

Dann ist bei so Aufgaben wichtig, dass Du sowas direkt durchspielst um zu verstehen, was zu tun ist. Was hast Du bei dem Beispiel genau gemacht so dass Du bei 4, 2, 1, -7 auf 4, 4, 2, 2, 1, 1, -7, -7 gekommen bist?

Du hast erst einmal das Ziel-Array erzeugt - das ist auch im Code korrekt.
Dann bist Du die Werte im original Array durchgegangen - ist auch korrekt. Aber wo müssen die Werte wie hin geschrieben werden?

Dazu evtl. der Tipp: Wenn Du es auf einem Zettel aufmalst, dann schreib zu den Elementen des Arrays die Indices. Dann kannst Du bei dem Beispiel aufschreiben, was wohin ging.

Element an 0 -> Platz 0
Element an 0 -> Platz 1
Element an 1 -> Platz 2
Element an 1 -> ...

Wenn Du sowas hast, dann kannst Du es formell ausdrücken oder einen Weg formulieren. Formel ausgedrückt wäre eine Formel Element i kommt an die Plätze f(i) und f2(i) (das sind Funktionen, die Du erstellen musst - will ich Dir nicht vorgeben).

Oder Du findest einen Weg. Also z.B. eine Variable ziel, die ist zuerst 0 und dann kommt bei jeder Zuweisung ein +1. Dann ist Element0 wird dann zwei mal zugewiesen ... Sowas geht natürlich auch ..

 

[sporty90]

neueWerte = werte * 2;

Beide Variablen sind vom Typ Array, also Array * 2 ist nicht gültig. An die Werte im Array kommst du über den Index, also werte[index]

Danke für die Antwort. Ich dachte mir, dass ich erst einmal ein leeres Array erstelle, was die doppelte Größe vom ursprünglichen aufweist, habe ich auch getestet und das klappte soweit. Ist das dann trotzdem falsch ?

@Konrad: Werde ich beim nächsten mal berücksichtigen.

Also müsste das doch so sein

Element 0 -> Übergabe Platz 0, 0
Element 1 -> Übergabe Platz 1,1
Element 2 -> Übergabe Platz 2,2
Usw...

Vielleicht habt ihr noch weitere Ideen, ansonsten würde ich jetzt mit euren Vorschlägen weiter machen.

PS: Ich habe das Thema absichtlich "Aufgaben" genannt, da ich bestimmt noch Hilfe bei anderen Array Aufgaben brauche, habe da noch ein paar zu Lösen, auf einem sehr ähnlichen Niveau.

PSS: "Oder Du findest einen Weg. Also z.B. eine Variable ziel, die ist zuerst 0 und dann kommt bei jeder Zuweisung ein +1. Dann ist Element0 wird dann zwei mal zugewiesen ... Sowas geht natürlich auch .."

Ich bin doch gerade dabei, die zweite Variante umzusetzen, oder sehe ich das falsch ?

Danke für eure Hilfe.

 

[KonradN]

Also müsste das doch so sein

Element 0 -> Übergabe Platz 0, 0
Element 1 -> Übergabe Platz 1,1
Element 2 -> Übergabe Platz 2,2
Usw...

Nein, mal es Dir auf!

Ich kann es Dir nicht ausdrücklich genug sagen: Nimm Stift und Papier.

Und dann hast Du das Ursprungs-Array - das sind dann 4 Kästchen. In die 4 Kästchen schreibst Du die Zahlen, die im Array sind. Drunter oder drüber schreibst Du die Indices ... also 0...3

Dann hast Du gesagt: Du erstellst ein doppelte so großes Arrays - also 8 Kästchen nebeneinander. Da steht dann aber noch nichts drin. Aber die Indices kannst Du schon dran schreiben.

Und nun willst Du das Ergebnis füllen - welche Zahl aus welchem Kästchen kommt in welches Kästchen des Zielarrays?

Ich bin doch gerade dabei, die zweite Variante umzusetzen, oder sehe ich das falsch ?

Nein, bisher sehen wir nur den Code aus dem ersten Post und da machst Du weder das eine noch das andere.

 

[Blender3D]

Also müsste das doch so sein

Element 0 -> Übergabe Platz 0, 0
Element 1 -> Übergabe Platz 1,1
Element 2 -> Übergabe Platz 2,2
Usw...

Wohl eher..
0 1 2 3 4 5
a = [ 3, 5, 8 ]
b = [ 3, 3, 5, 5, 8, 8 ]
size(b) = 2*size(a)

Element 0 -> Übergabe Platz 0, 1
Element 1 -> Übergabe Platz 2,3
Element 2 -> Übergabe Platz 4,5

 

[sporty90]

 

[KonradN]

Genau. Und daraus folgt dann ja, was bereits auch geschrieben wurde - die Indices an den Pfeilen ist somit
0 -> 0
0 -> 1
1 -> 2
2 -> 3
...

Und da ist dann die Frage: Siehst Du da eine Gesetzmäßigkeit? Kannst Du für i also etwas schreiben?
i -> ?
i -> ?

Das zweite ist erst einmal das erste +1 - das vereinfacht es evtl.:

i -> ?
i -> ? + 1

Dann müssen wir nur noch das erste von den doppel-Elementen betrachten:
0 -> 0
1 -> 2
2 -> 4
...

Siehst Du da eine Gesetzmäßigkeit? Kannst Du das für beliebige Zahlen direkt berechnen? Was ist bei 50 -> ? oder bei 100 -> ?

 

[sporty90]

Also so ?

Ursprung

Index 0 * 2 -----> Ziel Index 0
Index 0 * 2+1 ------> Ziel Index 1

Index 1 * 2 -----> Ziel Index 2
Index 1 * 2 + 1 ------> Ziel Index 3

 

[KonradN]

Ja genau!

Nun hast Du ja die Schleife über die Elemente des ursprungs-Arrays - da musst Du dann diese Überlegung einbauen. Da hast Du dann ja in der Schleife zwei Zuweisungen zu machen.

 

[sporty90]

Also umgangssprachlich:

Wenn Index Ursprung 0 = 0 Index ziel ist, dann packe die Zahl aus dem Ursprung in das Ziel und ein Feld weiter

Wenn Index Ursprung != Index Ziel, dann nehme die Zahl aus dem Ursprung, erhöhe den Zähler vom Ziel um eins und lege die Zahl dort ab und dasselbe für ein Feld weiter.

 

[KonradN]

Nein Umgangssprachlich hast Du doch:
Gehe die Indices des original Arrays durch und für jeden Index:

• Kopiere das Element aus index des original Arrays in 2 * index des ZielArrays
• Kopiere das Element aus index des original Arrays in (2 * index + 1) des ZielArrays

Edit: Rechtschreibung und Wortwahl

 

[sporty90]

public class DoppeltWerte {

  public static void main(String[] args) {

    int[] werte = new int[]{4, 2, 1, -7};
    int[] neueWerte = new int[werte.length * 2];

    for (int i = 0; i < werte.length; i++) {

      neueWerte[i * 2] = werte[i];
      neueWerte[i * 2 + 1] = werte[i];
      System.out.println(neueWerte[i * 2]);
      System.out.println(neueWerte[i * 2 + 1]);

    }

  }

}

 

[sporty90]

Endlich, da saß ich seit heute morgen um 8 Uhr dran.... Klausurvorbereitung läuft, habe anscheinend noch einiges zu machen....

 

[KonradN]

Super!

Diesen Ansatz sieht man übrigens oft auch "umgedreht". Das hatte ich nur erst etwas außen vor gelassen, damit Du nicht verwirrt bist:
Du willst ja das Ziel-Array füllen. Daher läuft man dann von 0 bis neueWerte.length (Grenze ist auch hier exklusive) und hat dann natürlich die Werte immer geteilt durch 2:

    for (int i = 0; i < neueWerte.length; i++) {
      neueWerte[i] = werte[i/2];
    }

Durch die Integer-Division entfällt halt das 0,5 bei jedem 2ten Element:
0 / 2 = 0
1 / 2 = 0
2 / 2 = 1
3 / 2 = 1
...

Die zweite Variante kann man dann auch skizzieren. Hier hat man dann eine zusätzliche lokale Variable:

int zielIndex = 0;
for (int i = 0; i < werte.length; i++) {
      neueWerte[zielIndex] = werte[i];
      zielIndex++;
      neueWerte[zielIndex] = werte[i];
      zielIndex++;
}

Hier hast Du halt eine Variable zielIndex, die immer den Index angibt, an dem der nächste Wert eingefügt wird. Nach dem Einfügen des Wertes wird die Variable daher 1 hoch gesetzt.
Damit hast Du in der Schleife zwei mal das Einfügen.

Aber da man den zielIndex berechnen kann, ist das natürlich die elegantere Variante.

Das wären dann in Kürze noch andere Alternativen, die man als Lösung hätte machen können.

Ich hoffe aber der Weg über das Aufzeichnen und überlegen, was wirklich die einzelnen Schritte sind, ist etwas deutlich geworden. Da evtl. deutlich mehr in Umgangssprache schreiben, was zu tun ist.

 

[sporty90]

Danke dir! Ja ist mir deutlicher geworden, allerdings habe ich da doch noch eine Frage.

Wenn ich in der Zeile 10 die * 2 entferne, warum kommt da dann genau diese Zahlenfolge heraus (4,4,0,2,0,1,0,-7) ?

 

[KonradN]

Wenn ich in der Zeile 10 die * 2 entferne, warum kommt da dann genau diese Zahlenfolge heraus (4,4,0,2,0,1,0,-7) ?

Aufpassen! Das ist nur die Ausgabe - das ist nicht der Inhalt des Arrays!

Bauen wir erst einmal nach der Schleife noch eine Ausgabe des Arrays - und erklären dann, was abläuft.

Der Code sieht dann so aus:

    public static void main(String[] args) {
        int[] werte = new int[]{4, 2, 1, -7};
        int[] neueWerte = new int[werte.length * 2];

        for (int i = 0; i < werte.length; i++) {
            neueWerte[i] = werte[i];
            neueWerte[i * 2 + 1] = werte[i];
            System.out.println(neueWerte[i * 2]);
            System.out.println(neueWerte[i * 2 + 1]);
        }
        System.out.println(Arrays.toString(neueWerte));
    }

Was passiert?
Erster Schleifendurchlauf: Index 0 wird auf 4 gesetzt und Index 1 wird auf 4 gesetzt. Dann wird ausgegeben: Wert an Index 0 und Index 1
Wir haben also im Array: 4, 4, 0, 0, .... und Ausgabe: 4 4

Zweiter Schleifendurchlauf: Index 1 wird auf 2 gesetzt und Index 3 wird auf 2 gesetzt. Dann wird Ausgegeben: Wert an Index 2 und Index 3:
Wir haben also im Array: 4, 2, 0, 2, .... Und Ausgabe: 4 4 0 2

Das kann man so weiter durchspielen. Du überschreibst also immer Werte, die schon richtig gesetzt wurden. Und gibst dann bei der Ausgabe in der Schleife Werte aus von Feldern, die nicht gesetzt wurden.

Daher hast Du die Ausgabe, die Du schon gezeigt hast, aber das Array hat am Ende:
[4, 2, 1, -7, 0, 1, 0, -7]

 

[sporty90]

Danke dir, ich habs geschnallt, ich mache mich an die nächste Aufgabe, ich Poste die hier schon einmal, Fragen werden bestimmt später oder morgen kommen.

Realisieren Sie eine Methode, die zählt, wie häufig der übergebene Wert in den einzelnen Feldern
der übergebenen Matrix vorkommt und diese Zählwerte in einem neuen Feld zurückgibt.
    
    Beispiel: Es sei m wie folgt deklariert und initialisiert.

 int[][] m = new int[3][];
 m[0] = new int[]{5,7,2,-1,5,0};
 m[1] = new int[]{0,1,2};
 m[2] = new int[]{5,5,5};

Beim Aufruf von haeufigkeiten(m,5) hat das zurückgegebene Feld die Länge 3 mit den Werten 2,0,3
denn die Zahl 5 kommt in m[0] zweimal, in m[1] kein mal und in m[2] dreimal vor.

 

[sporty90]

Kann ich mir das Array folgendermaßen vorstellen ?

 

[KonradN]

Nein. Das Array ist nicht rechteckig. Du hast drei Zeilen, die oberste stimmt, aber die beiden unteren haben nur jeweils 3 Felder. Es gibt da also keine weiteren Elemente.

Das ist möglich, da ein 2D Array in Java ein Array von Arrays ist. Die Arrays können dabei jedes mal eine beliebige Länge haben.

 

[httpdigest]

Kann ich mir das Array folgendermaßen vorstellen ?

Nein, eher so:

 

[sporty90]

Okay, also kann ich mir das Array wie ein Koordinaten System vorstellen.

Ich habe noch ein paar Verständnis Fragen.

public class Haeufigkeiten {

  public static int haeufigkeiten(int[][] m, int wert) {
 
 
    for(int i = 0; i < m.length; i++ ){
      for(m = 0; m < wert; m++){
   
     
      }
    }

  }

  public static void main(String[] args) {

    int[][] m = new int[3][];
    m[0] = new int[]{5, 7, 2, -1, 5, 0};
    m[1] = new int[]{0, 1, 2};
    m[2] = new int[]{5, 5, 5};
 
 

  }

}

Fragen:

1: Die erste Eckige Klammer, in der Zeile 10, steht doch für die Anzahl unserer M, also unserer Zeilen, die zweite Eckige Klammer dann für unsere Spalten, und diese ist leer ?

2: Was ist mit dem "int wert" dahinter gemeint ?

3: Meine Grundidee ist, dass ich alle Zeilen ( also unsere M´s ) von Links nach rechts durchlaufe, immer wenn ich die gesuchte Zahl, also in diesem Fall die 5, treffe, soll diese in ein neues Feld als Zählerstand gespeichert werden, also würden wir für unser erstes M ein neues Feld erstellen und dort würde der Zähler dann auf 2 stehen, nachdem es durchgelaufen ist.

 

[httpdigest]

1: Die erste Eckige Klammer, in der Zeile 10, steht doch für die Anzahl unserer M, also unserer Zeilen, die zweite Eckige Klammer dann für unsere Spalten, und diese ist leer ?

In dem von dir zuletzt im selben Beitrag geposteten Code ist bei Zeile 10 kein sinnvoller Code, sondern eine geschlossene geschweifte Klammer.

Wenn du das int[][] m = new int[3][]; meinst, dann bedeutet das, dass hier eine Variable vom Type "int Array Array" oder "Array von Array von int" deklariert wird und initialisiert wird mit einem Array der Länge 3, dessen Elemente jeweils beliebige int-Arrays enthalten/referenzieren können.
Dieses Array hat also die Länge 3 und jedes dieser drei Elemente ist erst einmal null und kann aber potenziell jeweils beliebig und unterschiedlich lange int-Arrays enthalten.

 

[Jw456]

Erstmal sagt deine Aufgabe das du eine Methode erstellen sollst die ein int Array zurück gibt und nicht nur einen int.

Die Laufvariablen in der zweiten for sollte nicht wie das Array heißen. Verwechslungs Gefahr.

In der inneren for willst du doch die einzelnen Array Blöcke duch gehen.

Um zb zu erfaren wie gross ein Block ist. In etwa so

m[i].length

so solltest du einmal 6 und zweimal 3 bekomnen.

Nun kannst du das Array duchgehen.

 

[Blender3D]

1: Die erste Eckige Klammer, in der Zeile 10, steht doch für die Anzahl unserer M, also unserer Zeilen, die zweite Eckige Klammer dann für unsere Spalten, und diese ist leer ?

Ja das bedeutet Du erzeugts 3 Zeilen von noch unbestimmter Länge.
Z.B. Die Zuweisung

m[0] = new int[]{5, 7, 2, -1, 5, 0};

erzeugt die Zeile 0 mit der Länge 6.

2: Was ist mit dem "int wert" dahinter gemeint ?

Allen Anschein nach soll die Funktion die Häufigkeit dieses Wert im Array zählen und zurückgeben.
Damit erübrigt sich dann Deine 3te Frage.
Ich würde an Deiner Stelle den laufenden Variablen sprechende Namen geben.

 

[temi]

Okay, also kann ich mir das Array wie ein Koordinaten System vorstellen.

@mihe7 hat mal einen guten Beitrag zu Arrays geschrieben:
https://www.java-forum.org/thema/von-datentypen-und-mehrdimensionalen-arrays.189506/

 

[sporty90]

@httpdigest : Okay, dass habe ich jetzt, dank deiner Erklärung und Recherche, verstanden.

@temi: Werde ich mir sofort reinziehen, dass wollte ich gerade sowieso fragen, habt ihr gute Internetseiten, Artikel, Bücher oder YouTube Kanäle zu den folgenden Themen ?

• Rekursion
• Objekte und Klassen
• Arrays
• Mehrdimensionale Arrays
• Binärbäume

Ich schreibe euch einmal meine Grundidee, ich will nur wissen, ob ich ganz grob auf dem richtigen Weg bin. Ich wollte jedes Array durchlaufen ( also diese Ms, dabei soll dann für jede 5, die ja im Beispiel gesucht wird, eine 0 oder eine 1 auf unseren Ursprungszähler, der mit 0 vorgelegt wird, drauf addiert werden, dann müsste also unser "Zähler" Array die Länge 3 haben und durch den Zähler hätten wir dann unsere Anzahl der gefundenen Ziffern)

Habt ihr noch gute Ideen, wie ich mir die Themen gut beibringen kann ? Ich habe das Gefühl, dass ich die meiste Zeit damit verbringe, gute Quellen zu recherchieren und nicht damit, wirklich Zeit mit dem Thema zu verbringen.

Danke auch an alle, die ich hier nicht explizit erwähnt habe, manche Informationen müssen auch erst bei mir "Sacken", so das ich noch nicht auf alles eingehen kann.

Ich werde euch wahrscheinlich noch eine ganze Zeit nerven müssen

​

 

[KonradN]

Wenn es um ein Nachlesen geht, dann kann man immer schauen, ob "Java ist auch eine Insel" das Thema behandelt. Ansonsten ist eine Suche tatsächlich immer wichtig. Und ja, am Anfang ist es oft recht beschwerlich, aber das ist auch eine Frage der Erfahrung. Daher da wirklich dran bleiben.

Ich schreibe euch einmal meine Grundidee, ich will nur wissen, ob ich ganz grob auf dem richtigen Weg bin. Ich wollte jedes Array durchlaufen ( also diese Ms, dabei soll dann für jede 5, die ja im Beispiel gesucht wird, eine 0 oder eine 1 auf unseren Ursprungszähler, der mit 0 vorgelegt wird, drauf addiert werden, dann müsste also unser "Zähler" Array die Länge 3 haben und durch den Zähler hätten wir dann unsere Anzahl der gefundenen Ziffern)

Ich würde Dir raten, dass Du wirklich viel mehr Dinge aktiv durchspielst. Deine Idee macht den Eindruck, dass dies ein Code ist, der entstanden ist und der halt nicht wirklich durchdacht wurde.

Ich habe ja schon sehr viel gemacht. Aber bewusst 0 addiert habe ich nie? Also wenn dieses oder jedes zutrifft, dann gebe ich Dir 0€. Das macht doch keinen Sinn. In Worten wird das auch schnell deutlich.

Klar - wenn etwas nicht konkret ist, dann kann es zu sowas kommen: Ich gebe Dir das Geld aus der Spardose - ups, die ist leider leer, dahher bekommst Du leider nichts.

Daher mein Tipp:
a) Spiel sowas durch und beschreibe es in Worte. Und wenn es nicht für Dich trivial ist: Dann mal es auf!
b) Wenn Du sowas aufmalst; Dann überlege Dir: Was ist die Eingabe? Und das ist die Ausgabe? Du hast also ein Array von 3 Arrays. Und du willst was haben? Das muss als erstes klar heraus finden.
c) Dann überlege Dir: Wie kommst Du von der Eingabe zur Ausgabe? Kriegst Du das hin? Erst einmal selbst schauen: Findest Du die Lösung?
d) Dann kannst Du überlegen: Was genau hast Du gemacht?
=> Hier hast Du ein klares Ergebnis! Du hast etwas, das Du jedem geben können musst und der kennt nur Deine Beschreibung und nicht die Aufgabe und wenn er der Beschreibung folgt, dann kommt das Richtige raus.

Wenn Du bei Punkt c bist: Teile und Herrsche! Du kannst Schritte komplex beschreiben!

Also mein Motor ist defekt. der muss repariert werden. Und das muss ich jetzt machen...

• Motor ausbauen
• Motor zerlegen bis ...... (Klare Beschreibung. Evtl. muss ich nicht alles ganz zerlegen.)
• Defektes Teil mit Ersatzteil tauschen
• Motor zusammen bauen
• Motor einbauen
• Tests durchführen

Das beschreibt die Reparatur natürlich nicht ... damit kann ein unbedarfter Mensch nichts anfangen. Aber wir haben das große Problem in kleinere Probleme zerteilt. Und die werden nun weiter beschrieben:

==> Ist es trivial den Motor auszubauen? Leider nicht ... also
Motor ausbauen

• Auto vorbereiten (Auto auf Schacht stellen, Zündung aus, .... keine Ahnung.. Hier auch ega!) Auto wird vorbereitet!
• Motor an Kran hängen, damit er beim Lösen nicht runter fallen kann.
• Schrauben lösen
• Verbindungen zu Motor lösen
• Motor herausheben und auf Werkbank abglegen

So kann man immer weiter beschreiben ... Schrauben lösen - das kann richtig heftig werden. Also wie löst man die Schrauben? Ggf. bis hin zum Aufbohren und neues Gewinde erzeugen oder so....

Und dieses Aufteilen eines Problems in Teilprobleme ist übrigens genau das, was ein Software Entwickler macht.

Das kannst Du da auch auf Dein Problem anwenden:
Für jedes Array zählst Du die Anzahl der werte und speicherst dieses Ergebnis. Eigentlich ganz trivial!

 

[sporty90]

Hatte jetzt noch einmal ein paar Stunden Zeit und habe mich weiter eingelesen, ich bekomme das Programm noch immer nichts ans laufen und weiß nicht ganz, wo mein Fehler liegt.

Ich habe die Variable neu vorher nicht belegt, weil ich nicht genau weiß, mit welchen Werten.

public class Haeufigkeiten {

  public static int[][] haeufigkeiten(int[][] m, int wert) {

    for (int i = 0; i < m.length; i++) {
      int zaehler = 0;
      for (int j = 0; j < m[i].length; j++) {
        if (m[i][j] == wert) {
          zaehler++;
        }
        neu[i] = zaehler;
      }

    }

  }

  public static void main(String[] args) {

    int[][] m = new int[3][];
    m[0] = new int[]{5, 7, 2, -1, 5, 0};
    m[1] = new int[]{0, 1, 2};
    m[2] = new int[]{5, 5, 5};
    System.out.println(3);
  }
}




Ich hoffe einfach, dass meine Grundidee jetzt einigermaßen passt.

 

[KonradN]

Was für einen Typ muss denn neu haben? Was willst Du denn da zurück geben? Die Zuweisung hast Du ja und da sieht es so aus, als wäre es ein Array. Und Du willst da int Werte zuweisen. Wie groß muss das Array sein? Welche Indices willst Du denn da nutzen?

Ansonsten sieht es doch schon sehr gut aus.

 

[sporty90]

Die Länge von m muss ja verändert werden, also muss ich das vorher der Variablen neu zuweisen, oder ?

 

[KonradN]

Die Länge von m muss ja verändert werden, also muss ich das vorher der Variablen neu zuweisen, oder ?

Sorry, aber die Aussage verstehe ich nicht. Die Länge eines Arrays kann nicht verändert werden.

 

[sporty90]

Stimmt, ich brauche ja ein neues Array, wo die Anzahl der gefundenen Werte, im Beispiel die Zahl 5, gespeichert werden.

 

[Blender3D]

Stimmt, ich brauche ja ein neues Array, wo die Anzahl der gefundenen Werte, im Beispiel die Zahl 5, gespeichert werden.

Ich denke nicht, dass die Funktion

public static int haeufigkeiten(int[][] m, int wert)

ein neues Array braucht. Schau dir noch einmal Post #25 an.

 

[KonradN]

@Blender3D Die Aufgabenstellung in #18 ist da eindeutig. Und der Rückgabetyp int ist ebenso falsch wie die neue Variante int[][] aus #29.

@sporty90
Du bekommst doch ein Array von Arrays übergeben. Wenn dieses 3 Arrays enthält, dann hat man ein Ergebnis aus 3 int Werten (So gibt es ja das Beispiel vor). Was ist, wenn es 10 Arrays wären? Wie groß ist dann das Ziel-Array?

Und wenn Du ein Array aus int zurück geben willst: Was muss dann der Typ sein? Ein Array von Arrays aus int wohl eher nicht, oder?

 

[sporty90]

Danke für den Hinweis, ich habe das jetzt ergänzt, komme aber nicht drauf, wie ich jetzt die Ausgabe hinbekomme, also wie die Main Methode mit der anderen Methode zusammenarbeiten kann.

public class Haeufigkeiten {

  public static int[] haeufigkeiten(int[][] m, int wert) {

    int[] neu = new int[m.length];

    for (int i = 0; i < m.length; i++) {
      int zaehler = 0;
      for (int j = 0; j < m[i].length; j++) {
        if (m[i][j] == wert) {
          zaehler++;
        }
        neu[i] = zaehler;
      }

    }
    return neu;
  }

  public static void main(String[] args) {

    int[][] m = new int[3][];
    m[0] = new int[]{5, 7, 2, -1, 5, 0};
    m[1] = new int[]{0, 1, 2};
    m[2] = new int[]{5, 5, 5};
    System.out.println(haeufigkeiten(m, 5));
  }
}

 

[KonradN]

Das ist doch schon soweit ganz gut - das Problem dürfte ja jetzt nur noch sein, dass Du die standard Ausgabe eines Arrays bekommst.

Du kannst das Ergebnis in einer Variablen speichern um dann mit eigenem Code eine Ausgabe zu erzeugen
oder Du nutzt eine bestehende Funktionalität. So hat das Java Framework die Klasse Arrays mit der Methode toString, die Du nutzen könntest.

 

[Blender3D]

Die Aufgabenstellung in #18 ist da eindeutig.

Stimmt hatte ich nicht gesehen.

 

[sporty90]

Danke für die Hilfe, ich habe die Aufgabe gelöst bekommen, ich werde jetzt mit der nächsten Aufgabe anfangen.

Realisieren Sie eine Methode void negiere(int[ ][ ]), die alle Komponenten des übergebenen
zweidimensionalen Felds negiert (= Vorzeichen umkehrt).
public static void negiere(int[ ][ ] m)

Okay, ich habe mir die Aufgabe vorerst ein wenig leichter gemacht, indem ich das mit einem Eindimensionalen Array machte, vielleicht kann da mal jemand drüber schauen, ob das so okay ist, funktioniert aufjedenfall.

Wenn das so funktioniert, würde ich mich jetzt an die eigentliche Aufgaben machen

public class Test {

  public static void main(String[] args) {

    int[] ziffern = new int[]{3, 5, 6, -2};
    int[] zifferNeu = new int[ziffern.length];

    for (int i = 0; i < ziffern.length; i++) {
      zifferNeu[i] = ziffern[i] * (-1);

      System.out.println(zifferNeu[i]);

    }

  }

}

 

[Marinek]

Wenn es funktioniert ist es ok.