Java; String ersetzen (mit regulären Ausdrücken)?

Im Rahmen eines Schulprojekts muss ich eine Zeichenfolge aus dem Formular ersetzen:

5 * x^3 - 6 * x^1 + 1

zu so etwas wie:

5x<sup>3</sup> - 6x<sup>1</sup> + 1

Ich glaube, dass dies mit regulären Ausdrücken möglich ist, aber ich weiß noch nicht, wie ich es machen soll.

Kannst du mir helfen?

PS Die eigentliche Aufgabe besteht darin, eine Java-Anwendung für die Polynomverarbeitung zu implementieren. Ich verwende diese Aufgabe, um polynomial.toString () vom Modell an die Ansicht zu übergeben, und ich möchte sie auf hübsche Weise mithilfe von HTML-Tags anzeigen.

str.replaceAll("\\^([0-9]+)", "<sup>$1</sup>");

private String removeScript(String content) {
    Pattern p = Pattern.compile("<script[^>]*>(.*?)</script>",
            Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
    return p.matcher(content).replaceAll("");
}

String input = "hello I'm a java dev" +
"no job experience needed" +
"senior software engineer" +
"java job available for senior software engineer";

String fixedInput = input.replaceAll("(java|job|senior)", "<b>$1</b>");

import java.util.regex.PatternSyntaxException;

// (:?\d+) \* x\^(:?\d+)
// 
// Options: ^ and $ match at line breaks
// 
// Match the regular expression below and capture its match into backreference number 1 «(:?\d+)»
//    Match the character “:” literally «:?»
//       Between zero and one times, as many times as possible, giving back as needed (greedy) «?»
//    Match a single digit 0..9 «\d+»
//       Between one and unlimited times, as many times as possible, giving back as needed (greedy) «+»
// Match the character “ ” literally « »
// Match the character “*” literally «\*»
// Match the characters “ x” literally « x»
// Match the character “^” literally «\^»
// Match the regular expression below and capture its match into backreference number 2 «(:?\d+)»
//    Match the character “:” literally «:?»
//       Between zero and one times, as many times as possible, giving back as needed (greedy) «?»
//    Match a single digit 0..9 «\d+»
//       Between one and unlimited times, as many times as possible, giving back as needed (greedy) «+»
try {
    String resultString = subjectString.replaceAll("(?m)(:?\\d+) \\* x\\^(:?\\d+)", "$1x<sup>$2</sup>");
} catch (PatternSyntaxException ex) {
    // Syntax error in the regular expression
} catch (IllegalArgumentException ex) {
    // Syntax error in the replacement text (unescaped $ signs?)
} catch (IndexOutOfBoundsException ex) {
    // Non-existent backreference used the replacement text
}

"5 * x^3 - 6 * x^1 + 1".replaceAll("\\W*\\*\\W*","").replaceAll("\\^(\\d+)","<sup>$1</sup>");

Bitte beachten Sie, dass das Zusammenfügen beider Ersetzungen zu einem einzigen regulären Ausdruck / Ersatz eine schlechte Wahl wäre, da allgemeinere Ausdrücke wie z. B. x^3 - 6 * xfehlschlagen würden.

Wenn dies für einen allgemeinen mathematischen Ausdruck gilt und Klammerausdrücke zulässig sind, ist es sehr schwierig (möglicherweise unmöglich), dies mit regulären Ausdrücken zu tun.

Wenn die einzigen Ersetzungen die sind, die Sie gezeigt haben, ist es nicht so schwer zu tun. Zuerst Strip-Outs *, dann Capturing verwenden, wie Can Berk Güder gezeigt hat, um mit den Ss umzugehen ^.

Was ist dein Polynom? Wenn Sie es "verarbeiten", stelle ich mir vor, dass irgendwann eine Art Baum von Unterausdrücken generiert wird, und würde denken, dass es viel einfacher wäre, dies zum Generieren Ihrer Zeichenfolge zu verwenden, als das Raw erneut zu analysieren Ausdruck mit einem regulären Ausdruck.

Wirf einfach eine andere Denkweise da draußen. Ich bin mir nicht sicher, was sonst noch in Ihrer App los ist.

Versuche dies:

String str = "5 * x^3 - 6 * x^1 + 1";
String replacedStr = str.replaceAll("\\^(\\d+)", "<sup>\$1</sup>");

Stellen Sie sicher, dass Sie java.util.regex importieren.

class Replacement 
{
    public static void main(String args[])
    {
        String Main = "5 * x^3 - 6 * x^1 + 1";
        String replaced = Main.replaceAll("(?m)(:?\\d+) \\* x\\^(:?\\d+)", "$1x<sup>$2</sup>");
        System.out.println(replaced);
    }
}

Sie sollten sich mit der Erfassung in Regex befassen, um das Umbrechen der 3 in ^ 3 zu handhaben.

Versuchen Sie dies, möglicherweise nicht der beste Weg. Aber es funktioniert

String str = "5 * x^3 - 6 * x^1 + 1";
str = str.replaceAll("(?x)(\\d+)(\\s+?\\*?\\s+?)(\\w+?)(\\^+?)(\\d+?)", "$1$3<sup>$5</sup>");
System.out.println(str);

Schauen Sie sich antlr4 an. Sie werden beim Erstellen einer Baumstruktur viel weiter kommen als bei regulären Ausdrücken allein.

https://github.com/antlr/grammars-v4/tree/master/calculator (calculator.g4 enthält die Grammatik, die Sie benötigen)

Kurz gesagt, Sie definieren die Grammatik, um einen Ausdruck zu analysieren, verwenden antlr, um Java-Code zu generieren, und fügen Rückrufe hinzu, um die Auswertung beim Erstellen des Baums durchzuführen.