用Python写一个一元多项式简单的计算器

好的，下面是一个简单的一元多项式计算器的Python代码：

print("请输入一元多项式的系数，例如输入 3 4 5 表示 3x^2 + 4x + 5")

coefficients = input().split()
coefficients = [int(c) for c in coefficients]

x = int(input("请输入 x 的值："))

result = 0
for i in range(len(coefficients)):
    result += coefficients[i] * x ** (len(coefficients) - i - 1)

print(f"计算结果为：{result}")

这个计算器通过输入一元多项式的系数和自变量 x 的值，计算并输出计算结果。你可以根据自己的需要对代码进行修改和扩展。

相关问题

设计一个一元稀疏多项式简单计算器

输入：一元稀疏多项式，操作符（加、减、乘、除、求导、积分）

输出：结果多项式

算法：

1. 定义一元稀疏多项式的数据结构，包括项数、系数、指数等信息。

2. 读入一元稀疏多项式。

3. 根据操作符进行相应计算，具体实现如下：

- 加法：将两个多项式合并，相同指数的项系数相加。

- 减法：将两个多项式合并，相同指数的项系数相减。

- 乘法：将两个多项式相乘，得到新的多项式。

- 除法：将两个多项式相除，得到商和余数。

- 求导：对多项式的每一项求导，指数减1，系数乘以指数。

- 积分：对多项式的每一项求积分，指数加1，系数除以指数+1。

4. 输出结果多项式。

代码实现：

class Polynomial:
    def __init__(self, terms=None):
        self.terms = terms or []
    
    def add_term(self, coefficient, exponent):
        self.terms.append((coefficient, exponent))
    
    def __add__(self, other):
        result = Polynomial()
        i, j = 0, 0
        while i < len(self.terms) and j < len(other.terms):
            if self.terms[i][1] == other.terms[j][1]:
                result.add_term(self.terms[i][0] + other.terms[j][0], self.terms[i][1])
                i += 1
                j += 1
            elif self.terms[i][1] < other.terms[j][1]:
                result.add_term(self.terms[i][0], self.terms[i][1])
                i += 1
            else:
                result.add_term(other.terms[j][0], other.terms[j][1])
                j += 1
        while i < len(self.terms):
            result.add_term(self.terms[i][0], self.terms[i][1])
            i += 1
        while j < len(other.terms):
            result.add_term(other.terms[j][0], other.terms[j][1])
            j += 1
        return result
    
    def __sub__(self, other):
        result = Polynomial()
        i, j = 0, 0
        while i < len(self.terms) and j < len(other.terms):
            if self.terms[i][1] == other.terms[j][1]:
                result.add_term(self.terms[i][0] - other.terms[j][0], self.terms[i][1])
                i += 1
                j += 1
            elif self.terms[i][1] < other.terms[j][1]:
                result.add_term(self.terms[i][0], self.terms[i][1])
                i += 1
            else:
                result.add_term(-other.terms[j][0], other.terms[j][1])
                j += 1
        while i < len(self.terms):
            result.add_term(self.terms[i][0], self.terms[i][1])
            i += 1
        while j < len(other.terms):
            result.add_term(-other.terms[j][0], other.terms[j][1])
            j += 1
        return result
    
    def __mul__(self, other):
        result = Polynomial()
        for c1, e1 in self.terms:
            for c2, e2 in other.terms:
                result.add_term(c1*c2, e1+e2)
        return result
    
    def __truediv__(self, other):
        q = Polynomial()
        r = self
        while len(r.terms) > 0 and r.terms[0][1] >= other.terms[0][1]:
            c = r.terms[0][0] / other.terms[0][0]
            e = r.terms[0][1] - other.terms[0][1]
            t = Polynomial([(c, e)])
            q += t
            r -= t * other
        return q, r
    
    def differentiate(self):
        result = Polynomial()
        for c, e in self.terms:
            if e > 0:
                result.add_term(c * e, e - 1)
        return result
    
    def integrate(self, constant=0):
        result = Polynomial()
        for c, e in self.terms:
            result.add_term(c / (e + 1), e + 1)
        result.add_term(constant, 0)
        return result
    
    def __str__(self):
        result = ""
        for i, (c, e) in enumerate(self.terms):
            if i > 0:
                if c > 0:
                    result += "+"
            if c != 1 or e == 0:
                result += str(c)
            if e > 0:
                result += "x"
                if e > 1:
                    result += "^" + str(e)
        return result

p1 = Polynomial([(3, 2), (-2, 1), (1, 0)])
p2 = Polynomial([(1, 1), (2, 0)])
print(p1 + p2)
print(p1 - p2)
print(p1 * p2)
print(p1 / p2)
print(p1.differentiate())
print(p1.integrate(1))

参考资料：

[1] https://en.wikipedia.org/wiki/Polynomial

[2] https://en.wikipedia.org/wiki/Sparse_polynomial

[3] https://en.wikipedia.org/wiki/Dividend#Polynomial_long_division

数据结构设计一个一元稀疏多项式简单计算器

数据结构设计一个一元稀疏多项式的简单计算器，通常会涉及使用哈希表（如映射或字典）来存储系数和对应的变量指数。以下是基本的设计思路：

1. **项类** (Term): 创建一个项类，它包含两个属性：`coefficient`(系数) 和 `exponent`(指数)，用于表示多项式中的每个项。

class Term:
    def __init__(self, coefficient, exponent):
        self.coefficient = coefficient
        self.exponent = exponent

2. **稀疏多项式类** (SparsePolynomial): 这是一个容器类，内部维护一个哈希表，键是变量名称（字符串），值是一个列表，列表元素是`Term`对象，表示该变量的所有非零系数及其对应的指数。

class SparsePolynomial:
    def __init__(self):
        self.polynomial = defaultdict(list)

    def add_term(self, term):
        if term.exponent > 0:
            self.polynomial[term.exponent].append(term)

    # 其他方法如计算、显示等
    def evaluate(self, variable_value):
        result = 0
        for exp, terms in self.polynomial.items():
            result += variable_value ** exp * sum(term.coefficient for term in terms)
        return result

3. **操作方法**: 提供一些常见的数学运算方法，例如加法(`add`)、减法(`subtract`)、乘法(`multiply`)以及简单的求值(`evaluate`):

# 实现加法
def add(self, other):
    combined = SparsePolynomial()
    for exp, terms in itertools.chain(self.polynomial.items(), other.polynomial.items()):
        combined.add_term(Term(sum(t.coefficient for t in terms), exp))
    return combined

# ...类似地实现其他方法