Giava; Sostituzione di stringhe (utilizzando espressioni regolari)?

Come parte di un progetto per la scuola, devo sostituire una stringa dal modulo:

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

a qualcosa come:

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

Credo che questo possa essere fatto con le espressioni regolari, ma non so ancora come farlo.

Puoi darmi una mano?

PS Il compito effettivo è quello di implementare un'applicazione Java di elaborazione polinomiale, e la sto usando per passare polynomial.toString () dal modello alla vista, e voglio visualizzarlo usando i tag html in un modo carino.

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>");

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

tieni presente che unire entrambe le sostituzioni in una singola regex / sostituzione sarebbe una cattiva scelta perché espressioni più generali come x^3 - 6 * xfallirebbero.

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
}

Se questo è per qualsiasi espressione matematica generale e le espressioni parentetiche sono consentite, sarà molto difficile (forse impossibile) farlo con le espressioni regolari.

Se le uniche sostituzioni sono quelle che hai mostrato, non è così difficile da fare. Prima rimuovi le *s, poi usa la cattura come ha mostrato Can Berk Güder per gestire le ^'s.

Qual è il tuo polinomio? Se lo stai "elaborando", immagino che a un certo punto venga generata una sorta di albero di sottoespressioni e penserei che sarebbe molto più semplice usarlo per generare la tua stringa piuttosto che analizzare nuovamente il grezzo espressione con una regex.

Sto solo lanciando un modo diverso di pensare là fuori. Non sono sicuro di cos'altro stia succedendo nella tua app.

Prova questo:

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

Assicurati di importare java.util.regex.

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);
    }
}

Dovrai esaminare la cattura in regex per gestire il wrapping del 3 in ^ 3.

Prova questo, potrebbe non essere il modo migliore. ma funziona

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);

Dai un'occhiata a antlr4. Ti porterà molto più avanti nella creazione di una struttura ad albero rispetto alle sole espressioni regolari.

https://github.com/antlr/grammars-v4/tree/master/calculator (calculator.g4 contiene la grammatica di cui hai bisogno)

In poche parole, si definisce la grammatica per analizzare un'espressione, si usa antlr per generare codice java e si aggiungono callback per gestire la valutazione quando l'albero viene costruito.