Recursiv dekomprimieren eines Strings

Question

Ich habe diese Zuordnung, die mich braucht, um eine zuvor komprimierte Zeichenfolge zu dekomprimieren. Beispiele hierfür wäre

i4a --> iaaaa 
q3w2ai2b --> qwwwaaibb 
3a --> aaa 

Hier ist, was ich bisher geschrieben:

public static String decompress(String compressedText) 
{ 
    char c; 
    char let; 
    int num; 
    String done = ""; 
    String toBeDone = ""; 
    String toBeDone2 = ""; 

    if(compressedText.length() <= 1) 
    { 
     return compressedText; 
    } 
    if (Character.isLetter(compressedText.charAt(0))) 
    { 
     done = compressedText.substring(0,1); 
     toBeDone = compressedText.substring(1); 

     return done + decompress(toBeDone); 
    } 
    else 
    { 
     c = compressedText.charAt(0); 
     num = Character.getNumericValue(c); 
     let = compressedText.charAt(1); 
     if (num > 0) 
     { 
      num--; 
      toBeDone = num + Character.toString(let); 
      toBeDone2 = compressedText.substring(2); 
      return Character.toString(let) + decompress(toBeDone) + decompress(toBeDone2); 
     } 
     else 
     { 
      toBeDone2 = compressedText.substring(2); 
      return Character.toString(let) + decompress(toBeDone2); 
     } 
    } 
} 

Meine Rückgabewerte sind absolut horrend.

"ab" yields "babb" somehow. 
"a" or any 1 letter string string yields the right result 
"2a" yields "aaaaaaaaaaa" 
"2a3b" gives me "aaaabbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbb" 

Der einzige Ort, wo ich einen Fehler sehen kann wäre wahrscheinlich der letzte Abschnitt sonst, da ich nicht ganz sicher war, was auf einmal tut die Zahl 0 erreicht und ich muß mit der Rekursion auf dem Schreiben aufhören Danach. Ansonsten kann ich nicht wirklich ein Problem sehen, das solch schreckliche Ergebnisse liefert.

Answer 1

Ich rechne damit so etwas wie dies funktionieren würde:

public static String decompress(String compressedText) { 
    if (compressedText.length() <= 1) { 
     return compressedText; 
    } 

    char c = compressedText.charAt(0); 

    if (Character.isDigit(c)) { 
     return String.join("", Collections.nCopies(Character.digit(c, 10), compressedText.substring(1, 2))) + decompress(compressedText.substring(2)); 
    } 

    return compressedText.charAt(0) + decompress(compressedText.substring(1)); 
} 

Wie Sie sehen können, das Basismodell ist, wenn die komprimierten String eine Länge von weniger als oder gleich 1 ist (wie Sie es in Ihrem Programm haben) .

Dann überprüfen wir, ob das erste Zeichen eine Ziffer ist. Wenn dies der Fall ist, ersetzen wir die korrekte Anzahl von Zeichen und fahren mit dem rekursiven Prozess fort, bis wir den Basisfall erreichen.

Wenn das erste Zeichen keine Ziffer ist, fügen wir es einfach an und fahren fort.

Beachten Sie, dass dies nur mit Zahlen von 1 bis 9 funktioniert; Wenn Sie höhere Werte benötigen, lassen Sie es mich wissen!

EDIT 1: Wenn die Collections#nCopies Methode zu komplex ist, ist hier eine gleichwertige Methode:

if (Character.isDigit(c)) { 
    StringBuilder sb = new StringBuilder(); 

    for (int i = 0; i < Character.digit(c, 10); i++) { 
     sb.append(compressedText.charAt(1)); 
    } 

    return sb.toString() + decompress(compressedText.substring(2)); 
} 

EDIT 2: Hier ist eine Methode, die eine rekursive Helfer-Methode verwendet eine String zu wiederholen:

public static String decompress(String compressedText) { 
    if (compressedText.length() <= 1) { 
     return compressedText; 
    } 

    char c = compressedText.charAt(0); 

    if (Character.isDigit(c)) { 
     return repeatCharacter(compressedText.charAt(1), Character.digit(c, 10)) + decompress(compressedText.substring(2)); 
    } 

    return compressedText.charAt(0) + decompress(compressedText.substring(1)); 
} 

public static String repeatCharacter(char character, int counter) { 
    if (counter == 1) { 
     return Character.toString(character); 
    } 

    return character + repeatCharacter(character, counter - 1); 
}