Как извлечь положительные и отрицательные целые числа из строки

Question

Мне нужно извлечь как положительные, так и отрицательные целые числа из биномиального выражения в строковой форме.Тогда эти числа будут присвоены массиву.

Эта строка:

"(-22x+43)^2"

станет этим массивом:

[-22, 43, 2]

Или

Эта строка:

"(x-22)^-2"

станет этим массивом:

[1, -22, -2]

Я знаком с массивами, но не знаю, как извлечь числа.Я посмотрел на регулярные выражения, и этот процесс кажется загадочным.Можно ли это сделать без регулярных выражений?Как лучше всего думать о решении этого типа проблемы?

Answer 1

с использованием строковых функций, попробуйте это

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 2

Вы можете использовать это регулярное выражение (и дополнительную замену):

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

Заменить на: [$1, $2$3, $4].Затем замените x на 1

Демо (для первой части)

Код:

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

Answer 3

Можно попробовать

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

Вы должны сделать это, проверив условие для каждого символа.

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 6

С регулярным выражением и без него : -

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 7

Вы можете попробовать сопоставить его с помощью этого регулярного выражения: "[- \ d ++ \ d +]"