program Java, aby wyodrębnić coefficents z równania kwadratowego

Question

Problem: program Java, aby podzielić współczynniki z równania kwadratowego np jeżeli ciąg wejściowy jest:

String str1; 
str1 = "4x2-4x-42=0" 

Więc muszę podzielić współczynniki z danego ciągu wejściowego i aby uzyskać dane wyjściowe jako

a = 4 b = -4 c = -42 

próbowałem to:

String equation = "ax2+bx-c=0"; 
String[] parts = equation.split("\\+|-|="); 
for (int i = 0; i < parts.length - 2; i++) { 
    String part = parts[i].toLowerCase(); 
    System.out.println(part.substring(0, part.indexOf("x"))); 
} 
System.out.println(parts[2]); 

Ale mam wyjście jako 23x2 i 4x i 4. Rzeczywiste wyjście potrzebne jest 23 ,- 4 , 4.

Answer 1

użyć wyrażenia regularnego, następujący wzór będzie działać:

([+-]?\d+)[Xx]2\s*([+-]?\d+)[Xx]\s*([+-]?\d+)\s*=\s*0 

To będzie pasował kwadratowe i wyodrębnij parametry, sprawdź, jak działa:

• (...) to grupy
• [+-]?\d+ wychwytywania może dopasować liczbę cyfr, poprzedzonego ewentualnie przez + lub -
• [Xx] Dopasowuje „X” lub „X”
• \s* to zero lub więcej miejsc

Więc

• ([+-]?\d+) odpowiada "a" argumentu
• [Xx]2 pasuje "X2" lub "x2"
• \s* dopasowania opcjonalnie odstępy
• ([+-]?\d+) odpowiada "b" argumentu
• [Xx] dopasowania "X" lub "X"
• \s* mecze opcjonalnie odstępu
• ([+-]?\d+) mecze "c" argumentu
• \s*=\s*0 mecze "= 0" z niektórych opcjonalnych przestrzeniach

Pozwala owinąć to w class:

private static final class QuadraticEq { 
    private static final Pattern EQN = Pattern.compile("([+-]?\\d+)[Xx]2\\s*([+-]?\\d+)[Xx]\\s*([+-]?\\d+)\\s*=\\s*0"); 
    private final int a; 
    private final int b; 
    private final int c; 

    private QuadraticEq(int a, int b, int c) { 
     this.a = a; 
     this.b = b; 
     this.c = c; 
    } 

    public static QuadraticEq parseString(final String eq) { 
     final Matcher matcher = EQN.matcher(eq); 
     if (!matcher.matches()) { 
      throw new IllegalArgumentException("Not a valid pattern " + eq); 
     } 
     final int a = Integer.parseInt(matcher.group(1)); 
     final int b = Integer.parseInt(matcher.group(2)); 
     final int c = Integer.parseInt(matcher.group(3)); 
     return new QuadraticEq(a, b, c); 
    } 

    @Override 
    public String toString() { 
     final StringBuilder sb = new StringBuilder("QuadraticEq{"); 
     sb.append("a=").append(a); 
     sb.append(", b=").append(b); 
     sb.append(", c=").append(c); 
     sb.append('}'); 
     return sb.toString(); 
    } 
} 

zanotować \\ jest to wymagane przez Java.

Szybki test:

System.out.println(QuadraticEq.parseString("4x2-4x-42=0")); 

wyjściowa:

QuadraticEq{a=4, b=-4, c=-42} 

Answer 2

Jeśli używasz tylko quadratics:

int xsqrd = equation.indexOf("x2"); 
int x = equation.indexOf("x", xsqrd); 
int equ = equation.indexOf("="); 
String a = equation.subString(0,xsqrd); 
String b = equation.subString(xsqrd+1,x); 
String c = equation.subString(x,equ); 

może mam pomieszane podciągów ale masz ogólne pojęcie.

Answer 3

Można użyć wyrażenia regularnego, co następuje:

final String regex = "([+-]?\\d+)x2([+-]\\d+)x([+-]\\d+)=0"; 
Pattern pattern = Pattern.compile(regex); 

final String equation = "4x2-4x-42=0"; 
Matcher matcher = pattern.matcher(equation); 

if (matcher.matches()) { 
    int a = Integer.parseInt(matcher.group(1)); 
    int b = Integer.parseInt(matcher.group(2)); 
    int c = Integer.parseInt(matcher.group(3)); 
    System.out.println("a=" + a + " b=" + b + " c=" + c); 
} 

wyjściowa:

a=4 b=-4 c=-42 

Answer 4

Pierwsza uwaga: jeśli używasz jako symbol separatora w regexp, będzie tracić go w elementach slpitted. Proponuję użyć wyrażenia regularnego folllowing:

"x2|x|=" 

Następnie może masz tylko cyfry. Pełne fragment kodu:

public class Main { 
    private static final char[] varNames = {'a', 'b', 'c'}; 

    public static void main(String[] args) { 
     String equation = "4x2-4x-42=0"; 
     String[] parts = equation.split("x2|x|="); 
// you will get 4 elements, but the last element is always 0 
     for(int i=0; i<parts.length - 1; i++){ 
      System.out.println(varNames[i] + " = " + Integer.parseInt(parts[i])); 
     } 
    } 
} 

Ale w tym przypadku trzeba będzie się symbole „+” na wyjściu. Aby tego uniknąć, możesz użyć Integer.parseInt(parts[i]) zamiast parts[i].

Answer 5

for (int i = 0 ; i < str.length ; ++i){ 
    if(asciiOf(str.charAt(i)) == asciiOfIntegerValue){ 
    addCharInArrayList(str.charAt(i)); 
    }else{ 
     addInFuncList(); 
     addCharInArrayList("_"); 
    } 


    // join numbers which are not separated by _ and apply BODMAS rule and solve it 
    // fyi : apologies - very inefficient pseudocode, wrote in a haste