Jawa; Ganti string (menggunakan ekspresi reguler)?

Sebagai bagian dari proyek untuk sekolah, saya perlu mengganti string dari formulir:

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

menjadi sesuatu seperti:

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

Saya yakin ini bisa dilakukan dengan ekspresi reguler, tetapi saya belum tahu bagaimana melakukannya.

Bisakah Anda membantu saya?

PS Tugas sebenarnya adalah untuk mengimplementasikan aplikasi Java Pemrosesan Polinomial, dan saya menggunakan ini untuk meneruskan polynomial.toString () dari model ke tampilan, dan saya ingin menampilkannya menggunakan tag html dengan cara yang cantik.

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

harap dicatat bahwa menggabungkan kedua pengganti dalam satu regex / pengganti akan menjadi pilihan yang buruk karena ekspresi yang lebih umum seperti x^3 - 6 * xakan gagal.

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
}

Jika ini untuk ekspresi matematika umum dan ekspresi tanda kurung diperbolehkan, akan sangat sulit (mungkin tidak mungkin) untuk melakukan ini dengan ekspresi reguler.

Jika satu-satunya penggantinya adalah yang Anda tunjukkan, itu tidak sulit dilakukan. Pertama strip keluar *, kemudian gunakan pengambilan seperti yang ditunjukkan Can Berk Güder untuk menangani ^itu.

Apa polinomial Anda? Jika Anda "memproses", saya membayangkan semacam pohon sub-ekspresi yang dihasilkan di beberapa titik, dan akan berpikir bahwa akan lebih mudah menggunakannya untuk menghasilkan string Anda daripada mengurai ulang mentah ekspresi dengan regex.

Hanya melemparkan cara berpikir yang berbeda di luar sana. Saya tidak yakin apa lagi yang terjadi di aplikasi Anda.

Coba ini:

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

Pastikan untuk mengimpor 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);
    }
}

Anda akan ingin melihat menangkap dalam ekspresi reguler untuk menangani pembungkusan 3 dalam ^ 3.

Coba ini, mungkin bukan cara terbaik. tetapi berhasil

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

Lihatlah antlr4. Ini akan membawa Anda lebih jauh dalam membuat struktur pohon daripada ekspresi reguler saja.

https://github.com/antlr/grammars-v4/tree/master/calculator (calculator.g4 berisi tata bahasa yang Anda butuhkan)

Singkatnya, Anda menentukan tata bahasa untuk mengurai ekspresi, menggunakan antlr untuk menghasilkan kode java, dan menambahkan callback untuk menangani evaluasi saat pohon sedang dibuat.