Java: Stringtokenizer To Array

Question

给定一个多项式，我正在尝试编写代码来创建一个多项式，该多项式的次数，并将相似的项加在一起，例如…给定的

String term = "323x^3+2x+x-5x+5x^2" //Given
What I'd like = "323x^3+5x^2-2x" //result

到目前为止，我已经将给定的多项式标记为...

    term = term.replace("+" , "~+");
    term = term.replace("-", "~-");
    System.out.println(term);
    StringTokenizer multiTokenizer = new StringTokenizer(term, "~");
    int numberofTokens = multiTokenizer.countTokens();
    String[] tokensArray = new String[numberofTokens];
    int x=0;
    while (multiTokenizer.hasMoreTokens())
    {

        System.out.println(multiTokenizer.nextToken());

    }

结果是

323x^3~+2x~+x~-5x~+5x^2
323x^3
+2x
+x
-5x
+5x^2

我如何从x值中拆分系数，将每个系数保存在一个数组中，然后将度数放在一个不同的数组中，并使用与其系数相同的索引？然后，我将使用此算法添加相似的术语...

for (i=0;i<=biggest_Root; i++)
     for(j=0; j<=items_in_list ; j++)
          if (degree_array[j] = i)
               total += b1[j];
     array_of_totals[i] = total;

任何帮助都是非常感谢的！

Answer 1

您还可以更新术语，使它们都具有系数：

s/([+-])x/\11/g

所以+x^2变成+1x^2。

您的各个系数可以通过简单的正则表达式提取出来。这样的代码应该就足够了：

/([+-]?\d+)x/     // match for x
/([+-]?\d+)x\^2/   // match for x^2
/([+-]?\d+)x\^3/   // match for x^3
/([+-]?\d+)x\^4/   // match for x^4

然后

sum_of_coefficient[degree] += match

其中“parseInt”是正则表达式匹配的匹配(特殊情况下，系数是1并且没有数字，例如。+x)

sum_of_coefficient[3] = 323
sum_of_coefficient[1] = +2+1-5 = -2
sum_of_coefficient[2] = 5

Answer 2

使用“正则表达式”模式简化解析的

(并使代码更酷、更简洁)

这是一个工作示例，它根据您到目前为止解析过的术语来解析每个术语的系数、变量和度数。它只是将显示在示例中的术语插入到字符串列表中，然后以相同的方式处理每个字符串。

这个程序运行并产生输出，如果你喜欢它，你可以将它拼接到你的程序中。要尝试，请执行以下操作：

$ javac parse.java

$ java解析

限制和潜在的改进：

从技术上讲，系数和度数可以是小数，因此可以很容易地更改正则表达式来处理这些类型的数字。然后，您可以使用Float.parseFloat()将匹配值转换为可以使用的变量，而不是使用Integer.parseInt()。

import java.util.*;
import java.util.regex.*;

public class parse {
    public static void main(String args[]) {

        /* 
         * Substitute this List with your own list or
         * array from the code you've written already...
         *
         * vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */

        List<String>terms = new ArrayList<String>();
        terms.add("323x^3");
        terms.add("+2x");
        terms.add("+x");
        terms.add("-5x");
        terms.add("+5x^2");

        /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */

        for (String term : terms) {

            System.out.print("Term: " + term + ": \n");

            Pattern pattern = Pattern.compile("([+-]*\\d*)([A-Za-z]*)\\^*(\\d*)"); 
            Matcher matcher = pattern.matcher(term);

            if (matcher.find()) {

                int coefficient = 1;
                try {
                    coefficient = Integer.parseInt(matcher.group(1));
                } catch (Exception e) {}

                String variable = matcher.group(2);

                int degree = 1;
                try { 
                    degree = Integer.parseInt(matcher.group(3));
                } catch (Exception e) {}

                System.out.println("   coefficient = " + coefficient);
                System.out.println("   variable    = " + variable);
                System.out.println("   degree      = " + degree);

                /* 
                 * Here, do what you need to do with
                 *     variable, coefficient and degree 
                 */ 

            } 
        }
    }
}

示例代码中正则表达式的解释：

下面是使用的正则表达式：

([+-]*\\d*)([A-Za-z]*)\\^*(\\d*)

每个带括号的部分代表我想要匹配并提取到结果中的术语的一部分。它将匹配的内容放在与括号集相对应的组中。第一组括号进入组1，第二组进入组2，依此类推...

1. 第一个匹配器(按( )分组)是([+-]*\\d*)，其设计用于匹配(例如，提取)系数(如果有)并将其放入组1。它期望出现零个或多个'+‘或'-’字符，后跟零个或多个数字。我可能应该用匹配0个或1个大写字母或小写字母的[+-]?\\d*写，下一个分组匹配器是-，([A-Za-z]*)表示匹配0个或多个大写字母或小写字母。这是试图提取变量名并将其放入组2。
2. 之后，有一个未分组的\\^*，它匹配0个或更多个^字符。它没有放在括号中，因为我们想说明文本中的^字符，而不是把它放在任何地方。我们对它后面的指数很感兴趣。注意:两个反斜杠是在Java字符串中生成一个反斜杠的方式。我们尝试表示的真实正则表达式是\^*。在这里转义的原因是因为未转义的^在正则表达式中有特殊的含义，但我们只是想匹配/允许在我们正在解析的代数术语中的那个位置出现实际的插入符号^的可能性。
3. 最后的模式组是(\\d*)。在字符串字面值之外，就像大多数自然的正则表达式一样，它将只是\d*。它被转义是因为，在默认情况下，在正则表达式中，d未转义，表示匹配文本中当前位置的文字d，但是，转义后，\d是一个特殊的正则表达式模式，它匹配任何数字[0-9] (正如模式javadoc所解释的那样)。*表示期望(匹配)该点的零个或多个数字。或者，+意味着在当前位置的文本中期望1个或更多数字，而?将意味着在当前位置的文本中期望0或1个数字。因此，本质上，最后一组被设计为匹配并提取可选插入符号后面的指数(如果有)，将该数字放入组3。

记住，( ) (带括号的)分组只是为了让我们可以提取那些解析成单独的组的区域。

如果这一切都不是很有意义，那么可以研究一下正则表达式，并在线阅读Java模式类javadoc。它们并不像第一眼看起来那么可怕，对于任何程序员来说都是非常值得学习的，因为它跨越了最流行的脚本语言和编译器，所以学习它一次，你就拥有了一个极其强大的生活工具。

Answer 3

这看起来像一个家庭作业问题，所以我不会在这里透露完整的答案，但这是我如何开始的

public class Polynomial {

private String rawPolynomial;
private int lastTermIndex = 0;
private Map<Integer, Integer> terms = new HashMap<>();

public Polynomial(String poly) {
    this.rawPolynomial = poly;
}

public void simplify() {
    while(true){
        String term = getNextTerm(rawPolynomial);
        if ("".equalsIgnoreCase(term)) {
            return;
        }
        Integer degree = getDegree(term);
        Integer coeff = getCoefficient(term);
        System.out.println(String.format("%dx^%d", coeff, degree));
        terms.merge(degree, coeff, Integer::sum);
    }
}

private String getNextTerm(String poly) {
...
}

private Integer getDegree(String poly) {
    ...
}

private Integer getCoefficient(String poly) {
    ...
}

@Override public String toString() {
    return terms.toString();
}
}

还有一些测试让你上手-

public class PolynomialTest {
    @Test public void oneTermPolynomialRemainsUnchanged() {
        Polynomial poly = new Polynomial("3x^2");
        poly.simplify();
        assertTrue("3x^2".equalsIgnoreCase(poly.toString()));
    }

}

你应该能够填空，希望这对你有帮助。如果你被困在什么地方，我很乐意为你提供进一步的帮助。