Replace symbols in string

Question

How to replace ^ into calling Math.pow() ? For example:

str = "10 + 5.2^12"; // -> "10 + Math.pow(5.2, 12)"
str = "2^(12) + 6";  // -> "Math.pow(2, 12) + 6"

have you tried some code to achieve this? if so please post the same. — Jos, Sep 29 '15 at 14:13
Are the string always of the form `x + y^z` and `x^(y) + z` or can they contain an arithmetic expression of any form and length? — Parker_Halo, Sep 29 '15 at 14:14
It seems like quite easy task. Can we see your attempts? You certainly read regex tutorial, right? — Pshemo, Sep 29 '15 at 14:16
Yes, it may be any expression, but i need a func, to replase only ^ operator — Letfar, Sep 29 '15 at 14:16
it´s a bit vague, are the values allways single number or can they be wrapped around a bracket for example? — SomeJavaGuy, Sep 29 '15 at 14:19
Show me how to get first index position of 5.2 in first case and the rest I'll do myself. — Letfar, Sep 29 '15 at 14:25

Stanislav · Answer 1 · 2015-09-29T15:07:53.847

1

You can do it like this:

str = str.replaceAll("\\(?(\\d+\\.?\\d*)\\)?\\^\\(?(\\d+\\.?\\d*)\\)?", "Math.pow($1,$2)");

In this case, you are looking for 2 groups of digits (\\d+\\.?\\d*), which could be a float value and can be inside of () \$? and \$?. Between this 2 groups, you need to have the ^ sign \\^. If it matches, then replaceAll method replaces all this pattern with Math.pow($1,$2), where $1 and $2 will be replaced with first and second groups of digits.

But one thing, it could lead to wrong results if you have a complicated expression, with 2 multiplications in a row, like a 10.22^31.22^5. In this case, this regular expression should be much more complicated. And may be you should use some other algorithm to parse such expressions.

edited Sep 29 '15 at 15:07

answered Sep 29 '15 at 14:28

Stanislav

27,441
9
87
82

could you explain the RegEx? – Yassin Hajaj Sep 29 '15 at 14:31
was already editing an answer. added the short explanation – Stanislav Sep 29 '15 at 14:45
Who downvoted, and why ? – bvdb Sep 29 '15 at 14:51
I did not if you're asking me... I did upvote btw – Yassin Hajaj Sep 29 '15 at 14:54

Ramchander rao · Accepted Answer · 2015-09-29T14:50:34.633

You can do this with regular expression in java. Use the below code snippet to devide and replace the string.

private static String replaceMatchPow(String pValue) {
    String regEx = "(\\d*\\.*\\d*)\\^\\(*(\\d*\\.*\\d*)\\)*";
    Pattern pattern = Pattern.compile(regEx);
    Matcher m = pattern.matcher(pValue);
    if (m.find()) {
        String value = "Math.pow(" + m.group(1) + "," + m.group(2) + ")";
        pValue = pValue.replaceAll(regEx, value);
    }
    return pValue;
}

How the regex will work? Here is the example for the input "2^(12) + 6" 1st group (\d*\.\d)
\d* -> match a digit [0-9], * -> zero to unlimited \^ -> divide the groups by ^ symbol (* -> left bracket, * means occurrence zero to unlimited 2nd group (\d*\.\d)
)* -> right bracket

Result: 1st group values is 2 and 2nd group values is 12

/(\d*.*\d*)\^(*(\d*.*\d*))*/
1st Capturing group (\d*.*\d*)
\d* match a digit [0-9]
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
.* matches the character . literally
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
\d* match a digit [0-9]
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
\^ matches the character ^ literally
(* matches the character ( literally
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
2nd Capturing group (\d*.*\d*)
\d* match a digit [0-9]
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
.* matches the character . literally
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
\d* match a digit [0-9]
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
)* matches the character ) literally
Quantifier: * Between zero and unlimited times, as many times as possible, giving back as needed [greedy]

eg: 1st group (\\d*\\.*\\d*) \d* -> match a digit [0-9], * -> zero to unlimited — Ramchander rao, Sep 29 '15 at 14:37
Thank you very much :) Is it possible you edit your post by adding the explanation? This will be helpful for the next people who are searching for the same help — Yassin Hajaj, Sep 29 '15 at 14:43

score 0 · Answer 3 · edited May 23 '17 at 11:58

For your special problem you should lookup how the caret character ^ is escaped in Java regular expressions, it should be \^.

Note that:

Backslashes within string literals in Java source code are interpreted as required by The Java™ Language Specification as either Unicode escapes (section 3.3) or other character escapes (section 3.10.6) It is therefore necessary to double backslashes in string literals that represent regular expressions to protect them from interpretation by the Java bytecode compiler.

So you end up with "\\^" as a Java String.

However in general you will write a parser and interpreter for arithmetical expressions.

This subject is known as compiler construction and relies on knowledge of finite automata and formal languages.

A nice example can be found in chapter 10.2 "A Desk Calculator" of "The C++ Programming Language, Fourth Edition" by Bjarne Stroustrup. (Yes, I know you want to code in Java, please continue to read). It features this formal grammar:

program:
  end //end is end-of-input
  expr_list end

expr_list:
  expression print  //pr intis newline or semicolon
  expression print expr_list

expression:
  expression + term
  expression − term
  term

term:
  term / primary
  term ∗ primary
  primary

primary:
  number //number is a ﬂoating-point literal
  name //name is an identiﬁer
  name = expression
  −primary
  ( expression )

Stroustrup shows you how to code this in a similar structure:

double expr(bool get) //add and subtract
{
  double left = term(get);
  for(;;) { //‘‘forever’’
    switch(ts.current().kind) {
    case Kind::plus:
      left += term(true);
      break;
    case Kind::minus:
      left −= term(true);
      break;
    default:
      return left;
    }
  }
}

this code embodies this part of the grammar:

expression:
  expression + term
  expression − term
  term

This technique is called recursive descent, because recursion in the grammar will be implemented as a recursive function call in the corresponding code. The featured relevant C++ code should be understandable to a Java developer as well.

Once you got a bit familiar with grammars and how to implement them, see e.g. Unambiguous grammar for exponentiation operation how to deal with exponentiation in such a way, that the usual operator precedence rules are fulfilled.

Replace symbols in string

3 Answers3