Java; Remplacer la chaîne (à l'aide d'expressions régulières)?

Dans le cadre d'un projet pour l'école, j'ai besoin de remplacer une chaîne du formulaire:

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

à quelque chose comme:

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

Je pense que cela peut être fait avec des expressions régulières, mais je ne sais pas encore comment le faire.

Pouvez-vous me donner un coup de main?

PS La tâche réelle est d'implémenter une application Java de traitement polynomial, et je l'utilise pour passer polynomial.toString () du modèle à la vue, et je veux l'afficher à l'aide de balises html de manière jolie.

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

veuillez noter que joindre les deux remplacements dans une seule expression régulière / remplacement serait un mauvais choix car des expressions plus générales telles que x^3 - 6 * xéchoueraient.

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
}

Si c'est pour une expression mathématique générale et que les expressions entre parenthèses sont autorisées, il sera très difficile (peut-être impossible) de le faire avec des expressions régulières.

Si les seuls remplacements sont ceux que vous avez montrés, ce n'est pas si difficile à faire. Commencez par supprimer *les fichiers, puis utilisez la capture comme l'a montré Can Berk Güder pour gérer les ^.

Quel est votre polynôme? Si vous le «traitez», j'envisage une sorte d'arbre de sous-expressions générées à un moment donné, et je penserais qu'il serait beaucoup plus simple de l'utiliser pour générer votre chaîne que pour réanalyser le brut expression avec une regex.

Juste jeter une autre façon de penser là-bas. Je ne suis pas sûr de ce qui se passe dans votre application.

Essaye ça:

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

Assurez-vous d'importer 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);
    }
}

Vous voudrez examiner la capture dans regex pour gérer l'encapsulation du 3 dans ^ 3.

Essayez ceci, ce n'est peut-être pas la meilleure façon. mais ça marche

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

Jetez un œil à antlr4. Cela vous mènera beaucoup plus loin dans la création d'une structure arborescente que les seules expressions régulières.

https://github.com/antlr/grammars-v4/tree/master/calculator (calculator.g4 contient la grammaire dont vous avez besoin)

En un mot, vous définissez la grammaire pour analyser une expression, utilisez antlr pour générer du code java et ajoutez des rappels pour gérer l'évaluation lorsque l'arborescence est en cours de construction.