Java; Reemplazo de cadena (proyecto escolar)?

Question 1

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.

¿Puedes echarme una mano?

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

Question 2

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

Question 3

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

Question 4

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

Question 5

"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 expresiones más generales como x^3 - 6 * x fallaría.

Question 6

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
}

Question 7

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

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

Question 8

¿Cuál es tu polinomio? Si lo está “procesando”, imagino 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 crudo 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.

¿Ha sido útil esta solución?