如何将字符串转换为多项式并添加或减去它们？

Question

我有权代表多项式作为arrayslist.How从一个txt文件，看起来像这样

P1;5;3;-4;1;8;0 
P2;6;5;-2;2;7;1;-4;0 

接受输入并把它变成一个多项式看起来像这样

P1(X) = 5X^3 –4X +8 
P2(X) = 6X^5 -2X^2 +7X -4. 

怎么可能我解决这两个多项式之间的加法和减法问题？如P1 + P2？

这里是我有：

import java.io.File; 
import java.io.FileNotFoundException; 
import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.Scanner; 


public class PolyProcessor { 
    static int polyNum = 0; 
public static void main(String[] args) throws FileNotFoundException{ 

    PolyCalc c = new PolyCalc(); 
    File polyfile = new File("polyinput.txt"); 
    Scanner read = new Scanner(polyfile); 
    while (read.hasNextLine()){ 
     String j = read.nextLine(); 
     c.add(j); 
     } 


    } 
    } 


class PolyCalc{ 
    static int polyCount = 0; 

    static ArrayList polynomials = new ArrayList(); 

    static void add(String j){ 

     polynomials.add(j); 
     polyCount++;} 

    static Object get(int i){ 
     return polynomials.get(i);} 


    } 

Answer 1

我能想到的最简单的办法是给系数存储在数组中，并让数组的索引对应的x长期的权力。这样的阵列：

{2, 4, -1, 1}

将转化为：

x^3 - x^2 + 4x + 2

然后添加和减法将仅仅是将对应的索引的两个阵列之间，并且将结果存储在一个的事新阵列。你也必须跟踪多项式的最高次项，这样你才能知道如何做出表示它的数组。因此，订单n的多项式将有一个大小为n + 1的数组来表示它。

Answer 2

下面是有关如何实现多项式一个想法：基于对polynomial定义

：

在数学中，多项式是由变量（或不定元）和系数的表达，这是仅涉及加法，减法，乘法和非负整数指数的操作。

所以，你可以通过减少问题的一个术语开始：

class Term { 
    //making it immutable 
    final double power; 
    final double coefficient; 
    final String variable; 
    //constructor 
    public Term(double power, double coefficient, String variable) { 
     //assign variables and such 
     this.power = power; 
     //... 
    } 
    //getters for your class 
} 

现在，创建一个Polynomial类的术语的List并定义必要的方法来添加和删除方面：

class Polynomial { 
    final String variable; 
    List<Term> terms; 
    public Polynomial(String variable) { 
     //this will allow you to accept only "X" or "Y" or terms with this variable only 
     this.variable = variable; 
     terms = new ArrayList<Terms>(); 
    } 
    public void add(Term term) { 
     /* 
      implement this... 
     */ 
    } 
} 

有了这个基本的模型，你可以想出更多的想法来增强设计。例如，Term可以实现​​以支持术语之间的比较，类似于Polynomial和其他元素。

Answer 3

多项式加法如何工作？

答案： - 通过添加相同的功率的系数

SO P1 = 5X^3 - 4X + 8

和P2 = 6X^5 -2X^2 + 7X^1 + -4

变得

P1 = 0X^5 + 5X^3 + 0X^2 - 4X^1 + 8X^0

P2 = 6X^5 + 0X^3 -2X^2 + 7X^1 - 4X^0

____________________________________

SUM = 6X^5 + 5X^3 -2X^2 + 3X^1 + 4X^0

____________________________________

您可以将电源作为重点和系数的值在Map.Then迭代的地图，并添加系数的值

import java.io.File; 
import java.io.FileNotFoundException; 
import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import java.util.Scanner; 

class SumOfPolynomials { 

/** 
* @param args 
* @throws FileNotFoundException 
*/ 
public static void main(String[] args) throws FileNotFoundException { 

    List<Map<Integer, Integer>> listOfPolynomials = new ArrayList<Map<Integer, Integer>>(); 
    File polyfile = new File("polyinput.txt"); 
    Scanner read = new Scanner(polyfile); 
    while (read.hasNextLine()){ 
     String LINE = read.nextLine(); 
     String[] lineSpillted =LINE.split(";"); 
     Map<Integer, Integer> poynomial = new HashMap<Integer, Integer>(); 
     for(int i =1;i<lineSpillted.length-1;i=i+2){    //i starts from ignores P1,P2 etc 

      poynomial.put(Integer.parseInt(lineSpillted[i+1]), Integer.parseInt(lineSpillted[i])); 

     } 
     listOfPolynomials.add(poynomial); 
     } 

    read.close(); 

    Map<Integer, Integer> result = polynomialSum(listOfPolynomials.get(0), listOfPolynomials.get(1)); 

    if(listOfPolynomials.size()>2){ 

     for(int i=2;i<listOfPolynomials.size()-1;i++){ 

      result = polynomialSum(result,listOfPolynomials.get(i)); 
     } 
    } 
    // print out the SUM as VALUEX^KEY 
    System.out.println(); 
    int c = 0; 
    for (Map.Entry<Integer, Integer> entry : result.entrySet()) { 

     System.out.print(entry.getValue() + "X^" + entry.getKey()); 
     c++; 
     if (c != result.size()) { 
      System.out.print("+"); 
     } 
    } 

} 

public static Map<Integer, Integer> polynomialSum(Map<Integer, Integer> arg1, 
     Map<Integer, Integer> arg2) { 

    Map<Integer, Integer> SUM = new HashMap<Integer, Integer>(); 

    for (Map.Entry<Integer, Integer> entry : arg1.entrySet()) { 

     Integer power = entry.getKey(); 
     Integer coeff1 = entry.getValue(); 
     Integer coefficient; 
     if (arg2.containsKey(power)) { 
      coefficient = arg2.get(power) + coeff1; 
     } else { 
      coefficient = coeff1; 
     } 
     SUM.put(power, coefficient); 
    } 

    for (Map.Entry<Integer, Integer> entry : arg2.entrySet()) { 

     if (SUM.containsKey(entry.getKey())) { 
      continue; 
     } else { 
      SUM.put(entry.getKey(), entry.getValue()); 
     } 

    } 

    return SUM; 
} 

}

编辑的多个Polynomials.Multiple多项式在一个列表中加入，然后总和被计算通过遍历列表

输出： -

Answer 4

对不起，关于变量名没有任何接近数学标准，也没有经过测试，但这应该给你一些想法。

import java.util.ArrayList; 
public class Poly { 

    private String[] numbers; 
    private ArrayList<Variable> func; 

    public Poly(String poly, double valueOfX) { 
     numbers = poly.split(";"); 
     func = new ArrayList<>(); 
     for (int i = 1; i < numbers.length - 1; i+=2) { 
      double exp = (numbers[i+1] == "0") ? 1 : Double.parseDouble(numbers[i++]); 
      double x = (numbers[i+1] == "0") ? 1 : valueOfX; 
      func.add(new Variable(Double.parseDouble(numbers[i]), exp, x)); 
     } 
    } 

    public ArrayList<Variable> getFunc() { 
     return func; 
    } 

} 
public class Variable { 

    private double value; 
    private double exponent; 
    private double x; 

    public Variable(double value, double exponent, double x) { 
     this.value = value; 
     this.exponent = exponent; 
     this.x = x; 
    } 

    public double getValue() { 
     return value; 
    } 

    public double getExponent() { 
     return exponent; 
    } 

    public double getX() { 
     return x; 
    } 
} 

由此，您可以获得想要的变量，并通过获取数组列表的索引来计算值，并发挥一定的魔力。