Question

我正在编写一个程序，可以将一串数字作为一个字符串接收，然后使用一个数学过程来查找该数字序列的多项式函数。我有两节课。好三但是这两个对于这个问题很重要。这些类是序列和术语，如下所示。

序列：

import java.util.ArrayList;
import java.util.Arrays;
import java.lang.Math;

public class Sequence
{
   // the numbers in the sequence
   private double[] sequence;

   // sets up sequence by parsing s 
   // the numbers in s will be separated by commas 
   public Sequence(String s)
   {
       sequence = new double[] {1, 4, 19, 52};
   }

   // returns sequence 
   public double[] getSequence()
   {
       return sequence;
   }

   // returns 1 * 2 * ... * (x-1) * x 
   public double factorial(double x)
   {
       for (double i=1;i<=x;i++){
            x = x*i;
        }
        return x;
   }

   // returns true iff all of the items on sequence are equal 
   public boolean allEqual(double[] sequence)
   {
       boolean checker = true;
       double first = sequence[1];
       for (int i = 1; i<sequence.length ; i++) {
           if(sequence[i] == first) {
               checker = true;
           }
       }
       return checker;
   }

   // returns a new array holding the differences between adjacent items on sequence 
   public double[] differences(double[] sequence)
   {
       double[] diffs = new double[sequence.length - 1];
       for(int i = 0;i<=sequence.length;i++) {
           diffs[i] = sequence[i+1]- sequence[i];
       }
       return diffs;
   }

   // subtracts from each item in sequence the effect of the term t 
   // implements Step 4 of the algorithm description on the project web page 
   public void updateSequence(Term t)
   {
       for(int i=0;i<=sequence.length;i++) {
         sequence[i] = sequence[i] - t.getCoefficient()*Math.pow(i,t.getExponent());
       }
   }

   // returns the next term in the simplest polynomial that generates sequence 
   // implements Steps 1-3 of the algorithm description on the project web page 
   public Term nextTerm()
   {
       double[] lastSequence = sequence;
       int steps = 0;
       while ( !allEqual(lastSequence)) {
          lastSequence = differences(lastSequence);
          steps++;
       }
       return new Term(lastSequence[1]/factorial(steps), steps); 
   }

   // returns the simplest polynomial that generates sequence and displays      the polynomial as a String 
   // implements the algorithm description on the project web page 
   public  Polynomial solveSequence()
   {
       // TODO
       return null;
   }

}

和术语：

public class Term
{
    // the term = coefficient * x ^ exponent
    private double coefficient;
    private int    exponent;

    public Term(double c, int e)
    {
        coefficient = c;
        exponent = e;
    }

    // returns the coefficient
    public double getCoefficient()
    {
        return coefficient;
    }

    // returns the exponent
    public int getExponent()
    {
        return exponent;
    }

    // returns the term as a String for display 
    // see the sample file for the layout required 
    public String display()
    {
       // TODO
       String tocompile="tocompile";
       return tocompile ;
    }
}

多项式：

import java.util.ArrayList;

public class Polynomial
{
    // the terms making up the polynomial
    private ArrayList<Term> polynomial;

    // creates a zero polynomial
    public Polynomial()
    {
        polynomial = new ArrayList<>();
    }

    // returns the number of terms in polynomial
    public int numberOfTerms()
    {
        return polynomial.size();
    }

    // adds a new term to the end of polynomial
    public void addTerm(Term t)
    {
        polynomial.add(t);
    }

    // returns the indicated term of polynomial
    public Term getTerm(int k)
    {
        if (0 <= k && k < numberOfTerms()) 
             return polynomial.get(k);
        else return null;
    }

    // returns polynomial as a String for display 
    // see the sample file for the layout required 
    public String display()
    {
        // TODO
        return "";
    }
}

我现在需要使用一种方法一遍又一遍地执行某些操作。所以基本上。重复创建术语并将其添加到结果中，直到序列上的所有数字相等。得到它打印出多项式，以便您可以看到结果。调用allEqual，nextTerm和updateSequence以实现此目的。我已经编写了allEqual，nextTerm，updateSequence（这里有来自这个很棒社区的极大帮助）

另外，我需要创建一个构造函数，这样我就可以拆分一个字符串，其中的数字用逗号分隔，所以字符串可能是1,2,3,4,5并将它分开，所以我只有数字，将它们转换为double和然后存储在一个名为sequence的数组中。我根本不知道这可以做到。我认为String.split和Double.parseDouble可能是我可以使用的东西，但我不知道如何使用它。

提供帮助。我想知道是否有人可以帮我解决这个问题。我真的不知道从哪里开始。

谢谢你们，

基本上，solveSequence方法假设一遍又一遍地执行以下步骤，直到我们得到一个可以描述我们的数字序列的多项式。

我想要实现的算法是迭代的。每次迭代导出多项式的一个项。例如，从数字序列[1,1,5,13,25]开始：

1）重复计算序列中相邻数字之间的差异，直到序列中的每个数字相同：

[1,1,5,13,25]⇒[0,4,8,12]⇒[4,4,4]

2）新术语的指数是上面的步数，即2。

新术语的系数是最终序列上的数字除以指数的阶乘，即4/2！因此，新术语是2x ^ 2.

3）从原始序列的每个元素中减去新项。从第一个元素减去2 * 1 ^ 2，从第二个减去2 * 2 ^ 2，从第三个减去2 * 3 ^ 2，等等。这留下[-1，-7，-13，-19，-25 ]，这是开始下一次迭代的数字序列。

使用此示例的第二次迭代产生项-6x，并保留序列[5,5,5,5,5]。现在序列中的所有数字都是相同的，因此迭代终止。多项式中的最后一项是最终序列上的数字，即5，完整的多项式是

2x ^ 2 - 6x + 5

因此，solveSequence应该使用方法allEqual，nextTerm和updateSequence，然后查找整个多项式并返回或打印它。

请帮忙。有点绝望了。

Answer 1

import java.util.ArrayList;
import java.util.List;

public class Main {
  public static void main(String Args[]) {
    parse("1,2,3,4");
  }

  public static void parse(String s) {
    String[] parts = s.split(",");
    List<Double> list = new ArrayList<>();
    for (String string : parts) {
      list.add(Double.parseDouble(string));
    }
    for (double d : list) {
      System.out.println(d);
    }
  }
}

我认为你的解决sequnece方法应该是这样的事情

While(!allEqual(sequence))
{
do other operation 
}

所有equal方法都应该返回false或true标志，具体取决于是否所有顺序相同或不同正如我所看到的那样，所有相等的方法总是返回true。请以这样的方式编写逻辑：如果所有元素都不相同则返回false。

循环，方法和一些新手问题

谢谢你们，

1 个答案: