Über den Ausdruck ein Polynom

Question

Dies ist Teil einer Klasse ist, die ein Polynom Eingangsnummer speichern und auswerten Und hier ist die Methode

public class Polynomial{ 
int coef,power; 

public Polynomial(int maxPower){ 
} 

public void setTerm(int coefficient, int power) { 
    this.coef = coefficient; 
    this.power = power; 
} 

Und die Eingangsparameter in main-Methode

public static void main(String[] args){ 
    Polynomial q = new Polynomial(2); 
    q.setTerm(2, 0); 
    q.setTerm(0, 1); 
    q.setTerm(3, 2); 
    System.out.println(q); 
} 

und es gibt eine Methode toString wie dies ich

public String toString(){ 
    return 
} 

aus dem Polynom Aussehen drucken ke pt begegnet dem Problem, dass die setTerm-Methode nur die letzten Eingabeparameter gelesen hat, nämlich q.setTerm (3,2), und ich denke, die ersten beiden wurden ersetzt. Was kann ich tun?

Answer 1

Also in Ihrem Beispiel müssen wir uns an die zuvor gesehenen Begriffe erinnern.

Ich werde es über eine Karte wie folgt tun.

import java.util.HashMap; 
import java.util.Map; 

/** 
* Created by arunavs on 9/28/16. 
*/ 
public class Polynomial { 

    // Key is power, value is coeff. 
    private Map<Integer, Integer> powerToCoeffMap = new HashMap<>(); 

    // Maximal power allowed for polynomial. 
    private int maxPower; 


    public Polynomial(int maxPower){ 
     this.maxPower = maxPower; 
    } 

    public void setTerm(int coefficient, int power) { 
     if (power > maxPower) { 
      // throw some exception here. 
     } 
     powerToCoeffMap.put(power, coefficient); 
    } 

    // terms may be rearranged in output. 
    public String toString() { 
     StringBuilder builder = new StringBuilder(); 
     powerToCoeffMap.forEach((power, coeff) -> {builder.append(coeff + "x^" + power+ " ");}); 
     return builder.toString(); 
    } 

     public static void main(String args[]) { 
      Polynomial q = new Polynomial(2); 
      q.setTerm(2, 0); 
      q.setTerm(0, 1); 
      q.setTerm(3, 2); 
     System.out.println(q); 
    } 
} 

Ausgänge: 2x^0 0x^1 3x^2

Ich hoffe, das hilft.

Answer 2

Sie haben nur eine Coef und eine Power gespeichert. Am einfachsten ist es, ein Array von Koeffizienten zu haben, die nach Leistung indiziert sind.

public class Polynomial { 

    final int[] coefficients; 

    public Polynomial(int maxPower) { 
     coefficients = new int[maxPower + 1]; // All zero. 
    } 

    public void setTerm(int coefficient, int power) { 
     coefficients[power] = coefficient; 
    } 

    @Override 
    public String toString() { 
     StringBuilder sb = newStringBuilder(); 
     for (int power = 0; power < coefficients.length; ++power) { 
      if (coefficients[power] != 0) { 
       if (coefficients[power] > 0 && sb.length() > 0) { 
        sb.append('+'); 
       } 
       sb.append(coefficients[power]); 
       if (power > 0) { 
        sb.append('x'); 
        if (power > 1) { 
         sb.append('^').append(power); 
        } 
       } 
      } 
     } 
     return sb.toString(); 
    } 
} 

Answer 3

Eine weitere mögliche Implementierung mit der Möglichkeit, gleichzeitig mehrere Bedingungen der Ergänzung könnte wie folgt aussehen:

package de; 

import java.util.TreeMap; 

public class Polynomial { 
    //Private Fields 
    private TreeMap<Integer, Integer> polys = new TreeMap<>(); 

    public Polynomial() { 

    } 
    public Polynomial(int... args){ 
     if(args.length < 2) polys.put(0, args[0]); 

     for(int i= 0; i < args.length && i+1 < args.length; i = i+2){ 
      //      coeff      power 
     polys.put(Integer.valueOf(args[i+1]), Integer.valueOf(args[i])); 
     } 
     if((args.length % 2) != 0){ 
      polys.put(0, args[args.length-1]); 
     } 
    } 
    public void setTerm(int coeff, int power){ 
     polys.put(Integer.valueOf(power),Integer.valueOf(coeff)); 
    } 

    public void setTerms(int... args){ 
     if(args.length < 2) polys.put(0, args[0]); 

     for(int i= 0; i < args.length && i+1 < args.length; i = i+2){ 
      //      coeff      power 
     polys.put(Integer.valueOf(args[i+1]), Integer.valueOf(args[i])); 
     } 
     if((args.length % 2) != 0){ 
      polys.put(0, args[args.length-1]); 
     } 
    } 
    @Override 
    public String toString(){ 
     StringBuilder sb = new StringBuilder(); 
     for(Integer key : polys.descendingKeySet()){ 
      Integer value = polys.get(key); 
      if(value == 0) continue; 
      if(value > 0 && sb.length() != 0) sb.append("+"); 

      sb.append(value.toString()); 
      if(key == 1) sb.append("x"); 
      if(key > 1) sb.append("x^" + key); 

      } 
      return sb.toString(); 
     } 


    public static void main(String[] args) { 
     Polynomial p = new Polynomial(1, 1, -2, 2, -3, 3, 7, 0); 
     p.setTerm(17, 5); 
     p.setTerms(23, 4, 0, 6); 
     System.out.println(p.toString()); 
    } 
} 

Ausgang: 17x^5 + 23x^4-3x^3-2x^2 + 1x + 7

Es wird von der höchsten Potenz zur niedrigsten Potenz geordert, druckt x anstelle von x^1 und druckt nicht x^0.