web-dev-qa-db-fra.com

Java; Chaîne de remplacement (en utilisant des expressions régulières)?

Dans le cadre d'un projet pour l'école, je dois remplacer une chaîne de la forme:

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

à quelque chose comme:

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

Je crois 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?

P.S. L’affectation réelle consiste à implémenter une application de traitement polynomial Java, et je l’utilise pour passer polynomial.toString () du modèle à la vue, et je souhaite l’afficher à l’aide de balises HTML dans une jolie façon.

javaregex
111
Dan Burzo
str.replaceAll("\\^([0-9]+)", "<sup>$1</sup>");
157
Can Berk Güder
private String removeScript(String content) {
    Pattern p = Pattern.compile("<script[^>]*>(.*?)</script>",
            Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
    return p.matcher(content).replaceAll("");
}
32
Florian
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>");
16
Hubbison
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
}
9
Lieven Keersmaekers
"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 rationnelle/remplacement serait un mauvais choix car des expressions plus générales telles que x^3 - 6 * x échoueraient.

8
vit123

Si cela est autorisé pour toute expression mathématique générale et que les expressions entre parenthèses sont autorisées, il sera très difficile (voire impossible) de le faire avec des expressions régulières.

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

3
Michael Myers

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

Je lance simplement une façon de penser différente. Je ne suis pas sûr de ce qui se passe dans votre application.

3
Adam Jaskiewicz
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);
    }
}
1
BigGinDaHouse

Essayez ceci, peut-être pas le meilleur moyen. 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);
0
user5915163

Vous voudrez peut-être vous intéresser à la capture dans regex pour gérer l’enveloppement des 3 en ^ 3.

0
Ryan Graham

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.

0
cdmckay

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

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 lors de la construction de l'arborescence.

0
Geoffrey Ritchey