Java; Reemplazo de cadena (usando expresiones regulares)?

Como parte de un proyecto para la escuela, necesito reemplazar una cadena del formulario:

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

a algo como:

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

Creo que esto se puede hacer con expresiones regulares, pero aún no sé cómo hacerlo.

¿Me puedes echar una mano?

PD La asignación real es implementar una aplicación Java de procesamiento de polinomios, y estoy usando esto para pasar polynomial.toString () del modelo a la vista, y quiero mostrarlo usando etiquetas html de una manera bonita.

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

tenga en cuenta que unir ambos reemplazos en una sola expresión regular / reemplazo sería una mala elección porque las expresiones más generales como x^3 - 6 * xfallarían.

Si esto es para cualquier expresión matemática general y se permiten expresiones entre paréntesis, será muy difícil (quizás imposible) hacerlo con expresiones regulares.

Si los únicos reemplazos son los que mostró, no es tan difícil de hacer. Primero *elimine los 's, luego use la captura como mostró Can Berk Güder para manejar los ^' s.

¿Cuál es tu polinomio? Si lo está "procesando", estoy imaginando que se generará algún tipo de árbol de subexpresiones en algún momento, y pensaría que sería mucho más simple usar eso para generar su cadena que volver a analizar el raw expresión con una expresión regular.

Simplemente lanzando una forma diferente de pensar por ahí. No estoy seguro de qué más está pasando en su aplicación.

Prueba esto:

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

Asegúrese de importar 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);
    }
}

Querrá examinar la captura en expresiones regulares para manejar envolver el 3 en ^ 3.

Prueba esto, puede que no sea la mejor manera. pero funciona

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

Echa un vistazo a antlr4. Te llevará mucho más lejos en la creación de una estructura de árbol que las expresiones regulares solas.

https://github.com/antlr/grammars-v4/tree/master/calculator (calculator.g4 contiene la gramática que necesita)

En pocas palabras, usted define la gramática para analizar una expresión, usa antlr para generar código java y agrega devoluciones de llamada para manejar la evaluación cuando se está construyendo el árbol.