How to Extract Positive and Negative Integers from a String

Question

I need to extract both positive and negative integers from a binomial expression in String form. Then those numbers will be assigned to an array.

This string:

"(-22x+43)^2"

would become this array:

[-22, 43, 2]

Or,

This string:

"(x-22)^-2"

would become this array:

[1, -22, -2]

I'm familiar with arrays, but have no idea how to extract numbers. I've looked into regular expressions and that process seems mysterious. Can this be done without regular expressions? What is the best way to think about solving this type of problem?

Answer 1

With and without regex:-

public static void main(String[] args) {
    String test = "(-22x+43)^2";
    System.out.println(extractNumbers(test));
    System.out.println(extractNumbersRegexStyle(test));
}

private static List<Integer> extractNumbers(String str) {
    str += " ";
    List<String> arr = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    for (char c : str.toCharArray()) {
        if (Character.isDigit(c) || (sb.length() == 0 && c == '-')) {
            sb.append(c);
        } else if (Character.isLetter(c) && sb.length() == 0) {
            sb.append(1);
        } else {
            if (Character.isLetter(c) && sb.toString().equals("-")) {
                sb.append(1);
            }
            if (sb.length() > 0) {
                arr.add(sb.toString());
                sb = new StringBuilder();
            }
            if (c == '-') {
                sb.append(c);
            }
        }
    }
    return arr.stream()
            .map(Integer::parseInt)
            .collect(Collectors.toList());
}

private static List<Integer> extractNumbersRegexStyle(String str) {
    List<String> arr = new ArrayList<>();
    Pattern p = Pattern.compile("-?\\d+");
    Matcher m = p.matcher(str);
    while (m.find()) {
        arr.add(m.group());
    }
    return arr.stream()
            .map(Integer::parseInt)
            .collect(Collectors.toList());
}

Output

[-22, 43, 2]
[-22, 43, 2]

You can then convert List to int array if you want.

Answer 2

You can try matching it through this regex : "[-\d++\d+]"

Answer 3

You should do this by checking condition on each characters.

public static void main(String[] args) {
        String exp="(x-y)^-2";
        String arr[]=new String[5];
        int i=0;
        String input1="";
        for(int x=0;x<exp.length();x++){
            char ch=exp.charAt(x);
            if(ch=='-'||(ch>=48&&ch<=57)){
                input1 += String.valueOf(ch);
            }
            else{
                if((ch>=65&&ch<=90)||(ch>=97&&ch<=122)||ch=='^'){
                    if(input1.equals("")){
                        input1="0";
                    }
                    if(!input1.equals("-")){
                    arr[i]=input1;

                    i++;
                    }
                    input1="";
                    }
            }

        }
        if(!input1.equals("")){
            arr[i]=input1;
        }
        System.out.println("Array IS");
        for(String c:arr){
            System.out.println(c);
        }
    }

Answer 4

Considering the string has expression of form (ax-b)^n and you require the coefficients [a , b, n]

A custom parser could be written for this and I would do it in Java.(You could use any other language, but logic would be pretty much same)

public static int[] getBinomialCoefficients(String exp){

     int l=exp.length();
     // "(x-22)^-2" for example

     int obIndex = exp.indexOf('('); //opening bracket Index
     int xIndex  = exp.indexOf('x'); // x index
     int cbIndex = exp.indexOf(')'); // closing bracket Index

     int a=0,b=0,n=1;
     if(obIndex+1!=xIndex){
          a = Integer.parseInt(exp.substring(obIndex+1,xIndex));
     }
     if(cbIndex-1!=xIndex){
          b = Integer.parseInt(exp.substring(xIndex+1,cbIndex));
     }
     if(cbIndex!=l-1){
          n = Integer.parseInt(exp.substring(cbIndex+2,l));
     }


    return new int[] {a,b,n};
}

Here I am calculating indexes of each variable, but if you think splitting it into array would help, you can use that approach as well. The string wont be that much long, so we could use any of these approaches.

Answer 5

You can try

import java.util.ArrayList;

public class NumberExtraction
{
    private static String oneNumber ="";
    private static ArrayList<Integer> ar = new ArrayList<Integer>();
    public static void main(String[] args)
    {
        String exp = "(-22x+43)^2";
        char[] cr = exp.toCharArray();
        for(char c : cr)
        {
            doCheck(c);
        }
        doCheck('e');
        System.out.println(ar);
    }
    static void doCheck(char c)
    {
        if((c>=48 && c<=57) || c==45)
        {
            oneNumber +=c;
        }else if(((c>=97 && c<=122) || (c>=65 && c<=90) ) &&("".equalsIgnoreCase(oneNumber)||"-".equalsIgnoreCase(oneNumber) ))
        {
            oneNumber +=0;
        }else if(!"".equalsIgnoreCase(oneNumber))
        {
            ar.add(Integer.parseInt(oneNumber));
            oneNumber="";
        }

    }
}

Answer 6

using string functions, try this one

import java.io.*;
 import java.util.*;
 public class Series
 {
  public static void main(String [] args) {
      String str = "(x-22)^-2";  
      String[] arstr = str.replaceFirst("\\)","").split("[x^]"); // replacing ")", with "" and splitting at x and ^ 
      if(arstr[0].equals("("))   // checking for coefficient
            arstr[0]="0";
       else
           arstr[0]=arstr[0].substring(1);
       if(arstr[1].contains("+"))         // checking sign "+" to remove
           arstr[1]=arstr[1].substring(1);
      System.out.println(Arrays.toString(arstr));   // printing result

    }  
 }

input

String str = "(x-22)^-2"; 
String str2 =  "(-22x+43)^2"

output:

[0, -22, -2]
[-22, 43, 2]

Answer 7

You may use this regex (and an extra replacement):

\((-?(?:\d+|x))x?(?:\+(\d+)|(-\d+))\)\^(-?\d+)

Replace by: [$1, $2$3, $4]. Then, replace x by 1

Demo (for the first part)

Code:

String str = "(-x-99)^-9";

str = str.replaceAll("\\((-?(?:\\d+|x))x?(?:\\+(\\d+)|(-\\d+))\\)\\^(-?\\d+)", "[$1, $2$3, $4]")
         .replaceAll("x", "1");

Output:

[-1, -99, -9]

The regex, explained:

\(                   # Literal '('
  (-?(?:\d+|x))      # First capturing group: Either digits or single x
  x?                 # Followed by an optional x
  (?:\+(\d+)|(-\d+)) # Match either: positive number on 2nd capturing group (without + sign)
                     # or negative number on 3rd capturing group (with - sign)
\)                   # Literal ')'
\^                   # Literal '^'
(-?\d+)              # Exponent, 4th capturing group