用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 的值，计算并输出计算结果。你可以根据自己的需要对代码进行修改和扩展。

相关问题

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

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

import re

def calculate(expression, x):
    # 将表达式中的系数和指数分离出来，存入字典中
    terms = {}
    pattern = r'([-+]?\d*)(?:x(?:\^(\d+))?)?'
    for coefficient, exponent in re.findall(pattern, expression):
        if coefficient == '':
            coefficient = '+1'
        elif coefficient == '-':
            coefficient = '-1'
        exponent = int(exponent) if exponent else 0
        terms[exponent] = int(coefficient)

    # 计算多项式在给定的x处的值
    result = 0
    for exponent, coefficient in terms.items():
        result += coefficient * x ** exponent
    return result

expression = input("请输入一个一元多项式（如3x^2+2x-1）：")
x = float(input("请输入x的值："))
print("该多项式在x={}处的结果为：{}".format(x, calculate(expression, x)))

这个代码可以读入一个一元多项式的表达式和$x$的值，然后计算该多项式在给定的$x$处的值。例如，输入"3x^2+2x-1"和$x=2$，则输出结果为$3\times2^2+2\times2-1=11$。注意，这个代码没有对输入的表达式进行严格的语法检查，使用时需要保证输入的表达式是一个合法的一元多项式。

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

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

输出：结果多项式

算法：

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