Java; String vervangen (gebruik van reguliere uitdrukkingen)?

Als onderdeel van een project voor school moet ik een tekenreeks vervangen van het formulier:

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

Naar zoiets:

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

Ik geloof dat dit kan worden gedaan met reguliere uitdrukkingen, maar ik weet niet hoe ik het nog moet doen.

Kunt u mij een hand lenen?

P.S. De daadwerkelijke opdracht is om een ​​Polynomial Processing Java-applicatie te implementeren, en ik gebruik dit om Polynomial.ToString () uit het model naar de weergave te passeren, en ik wil het doen met HTML-tags op een mooie manier.

Antwoord 1, Autoriteit 100%

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

Antwoord 2, Autoriteit 22%

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

Antwoord 3, Autoriteit 10%

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

Antwoord 4, Autoriteit 6%

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

houd er rekening mee dat het samenvoegen van beide vervangingen in een enkele regex/vervanging een slechte keuze zou zijn, omdat meer algemene uitdrukkingen zoals x^3 - 6 * xzouden mislukken.

Antwoord 5, autoriteit 5%

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
}

Antwoord 6

Als dit voor een algemene wiskundige uitdrukking is en uitdrukkingen tussen haakjes zijn toegestaan, zal het erg moeilijk (misschien onmogelijk) zijn om dit met reguliere uitdrukkingen te doen.

Als de enige vervangingen degene zijn die je hebt laten zien, is het niet zo moeilijk om te doen. Verwijder eerst de *‘s en gebruik dan capture zoals Can Berk Güder liet zien om de ^‘s af te handelen.

Antwoord 7

Wat is uw polynoom? Als je het “verwerkt”, stel ik me een soort boom van sub-expressies voor die op een bepaald moment wordt gegenereerd, en ik zou denken dat het veel eenvoudiger zou zijn om dat te gebruiken om je string te genereren dan om de onbewerkte expressie met een regex.

Gewoon een andere manier van denken naar buiten brengen. Ik weet niet zeker wat er nog meer in je app gebeurt.

Antwoord 8

Probeer dit:

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

Zorg ervoor dat u java.util.regex importeert.

Antwoord 9

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

Antwoord 10

U wilt kijken naar het vastleggen in regex om de 3 in ^3 te verpakken.

Antwoord 11

Probeer dit, dit is misschien niet de beste manier. maar het werkt

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

Antwoord 12

Kijk eens naar antlr4. Het zal je veel verder brengen in het maken van een boomstructuur dan alleen reguliere expressies.

https://github.com/antlr/grammars-v4/tree/ master/calculator(calculator.g4 bevat de grammatica die je nodig hebt)

In een notendop, u definieert de grammatica om een uitdrukking te ontleden, gebruikt antlr om Java-code te genereren en voegt callbacks toe om de evaluatie af te handelen wanneer de structuur wordt gebouwd.