Strings und Arrays - Expand

[lu-i]

Hallo, ich habe ein paar Fragen zu einer meiner Übungsaufgaben und hoffe ihr könnt mir vielleicht weiterhelfen!
Und zwar ist die Aufgabe eine Klasse zu schreiben die über die Standareingabe einen Strig bekommt, welcher Zahlen und auch Buchstaben enthalten kann, allerdings keine Leerzeichen, Satzzeichen oder Umlaute vorkommen. Mein Programm soll genau einen String auf der Standardausgabe anzeigen und dabei soll die Zahl durch die Anzahl des nachfolgenden Buchstabens ersetzt werden, also so oft geschrieben werden wie die Zahl. Bsp: 3bz2u wäre dann bbbzuu.
Hier weiß ich leider gar nicht weiter, weil ich auch keinen weg kenne wie man quasi alle zahlen mit einbinden kann. Ich denke mal man muss dazu amm besten ein Array nutzen und mit der replace-methode arbeiten, aber ansonsten hab ich echt keinen plan :/

Das ist alles was ich bis jetzt habe:

import java.util.Scanner;
public class Expand {
  
   public static void main (String [] args) {
   Scanner scanner = new Scanner(System.in);
  
     String eingabe = scanner.nextLine();
     String ersetzterString = eingabe.replace (x,y);
     System.out.println (ersetzterString);

Danke schonmal für eure Hilfe!

 

[dayaftereh]

Bitte nutz den Code Block.....

 

[Jardcore]

Du kannst dir den String als CharSequence geben lassen, also quasi als Array
Dann gehst du jedes Zeichen bis zum Ende durch und schaust ob das aktuelle Zeichen eine Zahl ist.
Wenn es eine Zahl ist, schaust du zusätzlich das nächste Zeichen an (hoffentlich ist das dann ein Buchstabe). Diesen Buchstaben schreibst du dann sooft in einen neuen String wie es die Zahl vorgibt.... und dann das ganze von vorn

Eine Frage: in welchem Zahlenbereich sollen die Zahlen sein? 1-9? oder einfach alle natürlichen Zahlen?

 

[StarSheriff]

Ich würde dir empfehlen das mit Patterns der Regular Expressions zu machen:
https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html
(Für denn Fall dass du beliebig viele Buchstaben/Zahlen pro Paar hast, führt glaub ich auch kein Weg dran vorbei).

Damit kannst du dir ein Patter definieren, alá
- beliebig viele Ziffern (\d+), gefolgt von beliebig vielen Buchstaben (\D+)

Damit bekommst du alle Paare von Zeichenketten die zu replizieren sollst.

Für jedes Paar musst du nun noch die Anzahl und die Zeichenkette selbst extrahieren.
Das kannst du wieder über die beiden oben genannten Patterns machen, nun aber halt einzeln,
also: Anzahl, wie oft du die Zeichenkette aneinanderhängen musst, bekommst du wenn du als Pattern (\d+) verwendest, welche Zeichenkette du replizieren sollst über (\D+)

 

[JStein52]

beliebig viele Ziffern (\d+), gefolgt von beliebig vielen Buchstaben (\D+)

Damit bekommst du alle Paare von Zeichenketten die zu replizieren sollst.

Kann es sein dass du da was falsch verstanden hast. sie müsste doch nach einer Ziffer gefolgt von einem Buchstaben suchen. Oder wie meinst du das mit deinem "Zeichenketten replizieren" ?

 

[Jardcore]

Ich glaube die Idee ist richtig, der Ansatz in Java aber komplizierter.
Man kann durch "(?<=[0-9]+)\\D" alle Buchstaben herausfilter, die einer Zahl folgen.
Dann muss man aber noch die Zahlen filtern. Oder man benutzt den oben genannten regex und filtert sich alle Zahlen-Buchstaben Paare (also sowas wie 9d, 42a, 99999x). Hier muss man dann den gefundenen Token nochmal in Zahl und dazugehörigen Buchstaben splitten.
Der Rest sollte dann einfach sein.

 

[StarSheriff]

nehmen wir mal an die Eingangszeichenfolge ist 12ab3x4c. Dann muss doch als Ergebnis ab
abababababababababababxxxcccc rauskommen.

Deshalb also 12ab3x4c mittels \d+\D+ in
12ab
3x
4c
aufsplitten

Für diese 3 Paare dann jeweils (im Beispiel jetzt für 12ab)
mittels
\d+ die Zahl rausfiltern => 12
mittels
\D+ die Buchstabenfolge => ab
extrahieren.

For-Schleife drüber und Zusammenbau im StringBuilder ist dann selbsterklärend

 

[JStein52]

12ab3x4c

Nein. es mus aaaaaaaaaaaabxxxcccc rauskommen.

 

[StarSheriff]

aso, in dem Fall könnte man, um bei obiger Logik zu bleiben bleiben, die Buchstabenfolge mittels der substring Methode in einen zu replizierenden Teil (nur erster Buchstabe) und einen einfach anzuhängenden Teil (alle übrigen) trennen.

 

[Jardcore]

//...
public String doSomething(String eingabe) {
        String ausgabe = eingabe;
      
        Pattern pattern = Pattern.compile("[0-9]+\\D");
        Matcher matcher = pattern.matcher(eingabe);
      
        // Manipuliere Ausgangsstring
        while(matcher.find()) {
            String group = matcher.group();
            String[] split = group.split("(?<=\\d)(?=\\D)");
          
            String numberAsString = split[NUMBER_INDEX];
            int number = Integer.valueOf(numberAsString);
            String letter = split[LETTER_INDEX];
          
            ausgabe = ausgabe.replaceFirst(numberAsString, "");
            ausgabe = ausgabe.replaceFirst(letter, expandLetter(letter, number));
        }

    return ausgabe;
}

    private String expandLetter(String letter, int number) {
        return number == 0 ? "" : expandLetter(letter, --number) + letter;
    }

Eingabe : 12ab3x4c
Ausgabe : aaaaaaaaaaaabxxxcccc

Ich habe mit replaceFirst, erstmal die gefundene Zahl entfernt und dann den Buchstaben ersetzt.

 

[JStein52]

aso,

Ja genau. Auf dieses Missverständnis bezog sich meine Frage.

 

[StarSheriff]

Da es jetzt schon ne gepostete Lösung gibt, hier noch der Java Code zu meinem geistigen Erguss

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringRegEx {

    public static void main(String[] args) {
        StringRegEx regEx = new StringRegEx();
        regEx.doStuff("h12all3o");
    }

    private void doStuff(String stuff) {

        StringBuilder builder = new StringBuilder();

        Pattern pattern = Pattern.compile("\\d+\\D+");
        Matcher matcher = pattern.matcher(stuff);
        while (matcher.find()) {
            String digitAlpha = matcher.group();
            pattern = Pattern.compile("\\d+");
            Matcher matcher2 = pattern.matcher(digitAlpha);
            matcher2.find();
            String howOften = matcher2.group();

            pattern = Pattern.compile("\\D+");
            matcher2 = pattern.matcher(digitAlpha);
            matcher2.find();
            String stringToAdd = matcher2.group();
            String stringToReplicate = stringToAdd.substring(0, 1);
            String stringRest = "";
            if (stringToAdd.length() > 1) {
                stringRest = stringToAdd.substring(1, stringToAdd.length());
            }

            for (int i = 0; i < Integer.valueOf(howOften); i++) {
                builder.append(stringToReplicate);
            }
            builder.append(stringRest);
        }

        System.out.println(builder.toString());
    }
}

 

[Flown]

Nach dem Urlaub endlich mal ein wenig Zeit Threads aufzuarbeiten.

Also hier sind Regex doch wirklich ein kleiner Overkill?! Einfach über den String iterieren und einen Zustand überwachen:

public static String unfold(String s) {
  StringBuilder builder = new StringBuilder();
  for (int i = 0, num = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (Character.isDigit(c)) {
      num = num * 10 + Character.digit(c, 10);
    } else if (num != 0) {
      for (int j = 0; j < num; j++) {
        builder.append(c);
      }
      num = 0;
    } else {
      builder.append(c);
    }
  }
  return builder.toString();
}