Ergebnisse in Arrays ausgeben?

[Der_Julian]

Ein neuer Tag, ein neues Problem.
Die Aufgabenstellung lautet wie folgt: Schreibe ein Programm, dass einen String vom Nutzer annimmt und alle Positionen, an denen der String eine Zahl enthält, als ein Array wieder zurückgibt.
Wie man den String überprüft weiß ich bereits, da kann ich einen Code-Schnipsel von einem anderen Programm umfunktionieren (Danke an die Leute vom Java-Forum, die mir dabei geholfen haben). Wie man das Ergebnis in einen Array speichert weiß ich allerdings nicht, und konnte ich auch nicht herausfinden.
Hier ist immerhin schon mal ein Programm, dass die Positionen in die Konsole ausgibt.

import java.util.Scanner;

public class LeetSpeechConverter {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in) ;
  
    String Digits = ("0123456789") ;
  
    String Eingabe = scanner.nextLine() ;  
  
    for (int k = 0; k < Eingabe.length(); k++) {
        char zeichenE = Eingabe.charAt(k) ; //Beinhaltet das Symbol des Eingabe-Strings, das gerade vom Programm verwendet wird
        for (int i = 0; i < Digits.length(); i++) {
            char zeichenD = Digits.charAt(i) ; //Das gleiche für das Symbol des Digits-String, damit einzeln verglichen werden kann.
          
            if(zeichenD == zeichenE) {
                System.out.println(k+1);
            }
        }
    }
  
    scanner.close();
  }
}

 

[kneitzel]

Also erst einmal lese ich nichts von wegen als String speichern. Du hast da ja int Werte und die sollst Du in einem Array speichern.

Also musst Du ein int Array erzeugen. Aber leider verlangt so ein Array eine feste Größe, daher gibt es zwei Möglichkeiten:
a) Du gehst einmal durch und zählst dabei die Zeichen um dann das Array zu erzeugen.
b) Du erstellst ein Array, das groß genug ist (also z.B. Eingabe.length()).

Hast Du rekursive Aufrufe schon gehabt? Dann ließe sich die Schleife durch rekursive Aufrufe ersetzen und dann könnte man darüber vor dem Rekursiven Aufruf zählen, am Rekursionsende das Array erzeugen und dann das Array im Bereich nach dem rekursiven Aufruf füllen.

 

[mihe7]

Wie man das Ergebnis in einen String speichert weiß ich allerdings nicht, und konnte ich auch nicht herausfinden.

Mal abgesehen davon, dass (wie @kneitzel treffend bemerkt hat) in der Aufgabe nichts von einer Ausgabe in einem String steht, wäre die naive Variante:

String s = "";
for (int i = 1; i < 10; i++) {
    s = s + " " + i;
}
System.out.println(s);

Übrigens kannst Du Dir die innere Schleife sparen, dafür gibt's in Java bereits eine Methode: String#indexOf.

 

[Der_Julian]

Also erst einmal lese ich nichts von wegen als String speichern. Du hast da ja int Werte und die sollst Du in einem Array speichern.

Also musst Du ein int Array erzeugen. Aber leider verlangt so ein Array eine feste Größe, daher gibt es zwei Möglichkeiten:
a) Du gehst einmal durch und zählst dabei die Zeichen um dann das Array zu erzeugen.
b) Du erstellst ein Array, das groß genug ist (also z.B. Eingabe.length()).

Hast Du rekursive Aufrufe schon gehabt? Dann ließe sich die Schleife durch rekursive Aufrufe ersetzen und dann könnte man darüber vor dem Rekursiven Aufruf zählen, am Rekursionsende das Array erzeugen und dann das Array im Bereich nach dem rekursiven Aufruf füllen.

Ich meinte auch in einem Array, war aber abgelenkt und hab nicht bemerkt, dass ich Quark geschrieben habe. Ich korrigier das mal kurz

 

[mihe7]

OK, dann versuche Dich mal an vier Aufgaben:
a) und b) wie bei @kneitzel
c) wie b) nur, dass Du im Anschluss noch mal ein Array in der richtigen Größe erstellst
d) Du erzeugst während den Iterationen Arrays, die jeweils die richtige Größe haben.

 

[Der_Julian]

OK, dann versuche Dich mal an vier Aufgaben:
a) und b) wie bei @kneitzel
c) wie b) nur, dass Du im Anschluss noch mal ein Array in der richtigen Größe erstellst
d) Du erzeugst während den Iterationen Arrays, die jeweils die richtige Größe haben.

Variante b) hab ich bereits hinbekommen, bevor ich deine Nachricht gelesen hatte.
Mir fehlt nur noch ein Befehl, der das Array ausgibt.
Nach Möglichkeit ein bisschen schöner, als jedes Mal eine neue Zeile anzufangen.

import java.util.Scanner;

public class getDigitPosition {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in) ;
  
    String Digits = ("0123456789") ;
    String Eingabe = scanner.nextLine() ;
    int x = 0;
    int [] Ergebnisse = new int [Eingabe.length()];
  
    for (int k = 0; k < Eingabe.length(); k++) {
        char zeichenE = Eingabe.charAt(k) ; //Beinhaltet das Symbol des Eingabe-Strings, das gerade vom Programm verwendet wird
        for (int i = 0; i < Digits.length(); i++) {
            char zeichenD = Digits.charAt(i) ; //Das gleiche für das Symbol des Digits-String, damit einzeln verglichen werden kann.
          
            if(zeichenD == zeichenE) {
                //System.out.println(k+1);
                Ergebnisse [x] = k+1;
                x++;
            }
        }
    }
    scanner.close();
  }
}

 

[Robat]

Nützlich ist hier ggf auch die Methode Character#isDigit
Damit kann sich den Zahlen-String sparen

 

[mihe7]

Mir fehlt nur noch ein Befehl, der das Array ausgibt.

System.out.println(java.util.Arrays.toString(Ergebnisse));

 

[Der_Julian]

OK, dann versuche Dich mal an vier Aufgaben:
a) und b) wie bei @kneitzel
c) wie b) nur, dass Du im Anschluss noch mal ein Array in der richtigen Größe erstellst
d) Du erzeugst während den Iterationen Arrays, die jeweils die richtige Größe haben.

Und hier ist dann auch nochmal eine Variante, die vorher einmal die Anzahl der Zahlen abzählt und die Anzahl nutzt, um das Array zu deklarieren

import java.util.Scanner;

public class getDigitPosition {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in) ;
    
    String Digits = ("0123456789") ;
    String Eingabe = scanner.nextLine() ;
    int x = 0;
    int counter = 0;
    for (int k = 0; k < Eingabe.length(); k++) {
        char zeichenE = Eingabe.charAt(k) ; //Beinhaltet das Symbol des Eingabe-Strings, das gerade vom Programm verwendet wird
        for (int i = 0; i < Digits.length(); i++) {
            char zeichenD = Digits.charAt(i) ; //Das gleiche für das Symbol des Digits-String, damit einzeln verglichen werden kann.
            
            if(zeichenD == zeichenE) {
                counter++;
            }
        }
    }
    int [] Ergebnisse = new int [counter];
    
    for (int k = 0; k < Eingabe.length(); k++) {
        char zeichenE = Eingabe.charAt(k) ; //Beinhaltet das Symbol des Eingabe-Strings, das gerade vom Programm verwendet wird
        for (int i = 0; i < Digits.length(); i++) {
            char zeichenD = Digits.charAt(i) ; //Das gleiche für das Symbol des Digits-String, damit einzeln verglichen werden kann.
            
            if(zeichenD == zeichenE) {
                //System.out.println(k+1);
                Ergebnisse [x] = k+1;
                x++;
            }
        }
    }
    scanner.close(); 
  }
}

 

[Der_Julian]

System.out.println(java.util.Arrays.toString(Ergebnisse));

Schankedöhn

 

[mihe7]

Das sieht doch alles schon sehr gut aus. Du kannst beim Zählen noch den Tipp von @Robat mit einbauen. Dann sparst Du Dir die innere Schleife.

 

[kneitzel]

Das sind doch schon super Ergebnisse! Damit hast Du dann schon zwei Lösungen für das Problem geschrieben!

Wichtig bei der ersten Lösung ist aber bei der Ausgabe, dass Du nur den Bereich ausgibst, der auch gefüllt wurde.