Question

我需要从String形式的二项式表达式中提取正整数和负整数。然后将这些数字分配给一个数组。

此字符串：

"(-22x+43)^2"

将成为此数组：

[-22, 43, 2]

或者，

此字符串：

"(x-22)^-2"

将成为此数组：

[1, -22, -2]

我对数组很熟悉，但是不知道如何提取数字。我研究了正则表达式，这个过程似乎很神秘。可以不使用正则表达式吗？解决此类问题的最佳方法是什么？

Answer 1

您可以尝试通过此正则表达式进行匹配： “ [-\ d ++ \ d +]”

Answer 2

有无正则表达式：-

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

输出

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

然后，您可以根据需要将List转换为int数组。

Answer 3

您应该通过检查每个字符的条件来做到这一点。

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

考虑到字符串的表达式形式为(ax-b)^n，您将需要系数[a , b, n]

可以为此编写一个自定义解析器，而我可以用Java来实现（您可以使用任何其他语言，但是逻辑几乎相同）

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

这里我正在计算每个变量的索引，但是如果您认为将其拆分为数组会有所帮助，则也可以使用该方法。该字符串不会那么长，因此我们可以使用这些方法中的任何一种。

Answer 5

您可以尝试

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

使用字符串函数，试试这个

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

    }  
 }

输入

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

输出：

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

Answer 7

您可以使用此正则表达式（以及其他替换项）：

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

替换为：[$1, $2$3, $4]。然后，将x替换为1

Demo （针对第一部分）

代码：

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

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

输出：

[-1，-99，-9]

正则表达式解释如下：

\(                   # 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

如何从字符串中提取正整数和负整数

7 个答案: