programma Java per estrarre coefficienti di un'equazione di secondo grado

Question

Problema: programma Java per dividere i coefficienti da un'equazione di secondo grado ad esempio se stringa di input è:

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

quindi ho bisogno di dividere i coefficienti dalla data stringa di input e per ottenere l'output come

a = 4 b = -4 c = -42 

ho provato questo:

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]); 

Ma ho ottenuto l'output come 23x2 e 4x e 4. L'effettiva uscita necessaria è 23 ,- 4 , 4.

Answer 1

Usa Regex, il seguente schema funziona:

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

Ciò corrisponderà al quadratica e estrai i parametri, lascia che funzioni come funziona:

• (...) questo è catturare gruppo
• [+-]?\d+ questo corrisponde a un numero di cifre, preceduta eventualmente da un + o -
• [Xx] questo corrisponde a "X" o "x"
• \s* questo corrisponde a zero o più spazi

Così

• ([+-]?\d+) corrisponde la "a" argomento
• [Xx]2 partite "X2" o "x2"
• \s* partite spazi
• ([+-]?\d+) opzionale corrisponde al "b" argomento
• [Xx] partite "X" o "x"
• \s* partite spazi bianchi
• ([+-]?\d+) opzionale partite l'argomento "c"
• \s*=\s*0 partite "= 0" con alcuni spazi opzionali

Consente avvolgere questo in un 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(); 
    } 
} 

nota la \\, questo è richiesto da Java.

Un test rapido:

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

uscita:

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

Answer 2

Se si utilizzano solo quadratiche:

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

forse ho incasinato le sottostringhe ma si ottiene l'idea generale.

Answer 3

È possibile utilizzare un'espressione regolare come segue:

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

uscita:

a=4 b=-4 c=-42 

Answer 4

La prima nota: se si utilizza il simbolo come delimitatore in regexp, si perde in elementi slpitted. Suggerisco di utilizzare la seguente espressione regolare:

"x2|x|=" 

Quindi, è possibile ottenere solo numeri. Il frammento pieno di codice è:

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

Ma in questo caso si avrà i simboli '+' in uscita. Per evitarlo, è possibile utilizzare Integer.parseInt(parts[i]) anziché 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