[从头学数学] 第110节 整式的加减

剧情提要：
[机器小伟]在[工程师阿伟]的陪同下进入了筑基初期的修炼，
这次要修炼的目标是[整式的加减]。

正剧开始：

星历2016年02月26日 11:57:30, 银河系厄尔斯星球中华帝国江南行省。
[工程师阿伟]正在和[机器小伟]一起研究[整式的加减]。

经过一大堆的例子后，[人叫板老师]终于指出了一个叫做单项式的东西，这个单项式还有一些概念性的描述。

于是[工程师阿伟]就给[机器小伟]做了一个单项式的工具。

<span style="font-size:18px;">###
# @usage   单项式相关概念
# @author  mw
# @date    2016年02月26日  星期五  10:00:14 
# @param
# @return
#
###
#单项式
#可以有**， ^号，暂时只能处理代号为一个字母的式子，像x_1, x_n, ...这种还不能处理。
def monomial(s):
    #原始复本
    s0 = s;
    
    s = s.replace('**', '^');
    s = s.replace('*', '');

    if (s.find('+') != -1 or (s.find('-') != -1 and s.find('-')!=0)):
        print(s0, '不是单项式。');
        return;
        
    try:
        #系数
        sign = 1;
        if s[0] == '-':
            #负号
            sign = -1;
            s = s[1:];
        coefficient = 1;

        #字符串长度
        length = len(s);
        index = 0;
        while (not s[index].isalpha()):
            index+=1;
            if index >= length:
                index = length;
                break;

        if (index > 0):
            coefficient = float(s[:index]);
            if abs(int(coefficient)-coefficient) < 0.001:
                coefficient = int(coefficient);        
            s = s[index:];
            
        coefficient = sign * coefficient;
        #print(coefficient, s);

        length = len(s);
        array = [];
        if (length > 0):
            index = 0;
            index2 = 0;
            name = '';
            degree = 0;
            while index < length:        
                if s[index].isalpha():
                    if (name != ''):
                        array.append([name, degree]);
                        name = '';
                        degree = 0;
                    name = s[index];
                    degree = 1;
                    index += 1;
                else:
                    index2 = index;
                    tmp = '';
                    while (not s[index2].isalpha()):
                        index2+=1;
                        if (index2 >= length):
                            index2 = length;
                            break;
                    tmp = s[index:index2];
                    tmp = tmp.replace('^', '');
                    degree = float(tmp);
                    if abs(int(degree)-degree) < 0.001:
                        degree = int(degree);

                    index = index2;
            if (name != ''):
                array.append([name, degree]);
                name = '';
                degree = 0;
                
            #print(array);

            #所有字母，去除重复的
            setA = set();
            size = len(array);
            #单项式的次数
            totalDegree = 0;
            for i in range(size):
                setA.add(array[i][0]);
                totalDegree += array[i][1];

            listA = list(setA);
            listA.sort();
            size2 = len(listA);
            result = [];
            for i in range(size2):
                #计算每个字母的次数(degree)
                tmp = 0;
                for j in range(size):
                    if listA[i] == array[j][0]:
                        tmp += array[j][1];

                result.append([listA[i], tmp]);

            print('单项式{0} 的系数是{1}， 次数是{2}，详细是{3}。'.format(\
                s0, coefficient, totalDegree, result));
        else:
            totalDegree = 0;
            if (coefficient != 0):
                print('单项式{0} 的系数是{1}， 次数是{2}，'.format(\
                    s0, coefficient, 0));
            else:
                print('这个数是0, 暂无规定。');
        #返回单项式的次数
        return [coefficient, totalDegree, array];
    except:
        print(s0, '有误，无法正确计算。');</span>

话说牵扯到了手工的写法，所有的东西都不会太简单，既然工具出炉，还是看看怎么用吧，细节什么的就不用在意了。

来看看[人叫板老师]上面的例子：

<span style="font-size:18px;">if __name__ == '__main__':
    a = ['0.8p', 'mn', 'a3h', '-n', 'v+2.5', 'v-2.5',\
         '3x+5y+2z', '0.5ab-3.14r2', 'x2+2x+18'];

    for i in range(len(a)):
        monomial(a[i]);</span>

会得到些什么结论呢？

<span style="font-size:18px;">>>> 
单项式0.8p 的系数是0.8， 次数是1，详细是[['p', 1]]。
单项式mn 的系数是1， 次数是2，详细是[['m', 1], ['n', 1]]。
单项式a3h 的系数是1， 次数是4，详细是[['a', 3], ['h', 1]]。
单项式-n 的系数是-1， 次数是1，详细是[['n', 1]]。
v+2.5 不是单项式。
v-2.5 不是单项式。
3x+5y+2z 不是单项式。
0.5ab-3.14r2 不是单项式。
x2+2x+18 不是单项式。</span>

单项式还没有看仔细呢，多项式又出来了：

这个密码要放在平时，小伟还是想解一下的，但今天这层功法貌似很难，所以就放过它吧。

好了，现在知道了同类项和多项式，小伟就又有新工具了：

<span style="font-size:18px;">###
# @usage   多项式相关概念
# @author  mw
# @date    2016年02月26日  星期五  10:30:37 
# @param   如果有括号，需要先自行去除，
# @return
#
###
def polynomial(s):
    #预留复本
    s0 = s;

    #只能有+或-号连接各项，不能有括号，分数要先化成小数
    s = s.replace('-', '+-');
    if (s[0] == '+'):
        s = s[1:];
    #各项
    terms = s.split('+');
    

    print('多项式{0} 具有以下的项： {1}\n其中各单项分别是：'.format(s0, terms));

    try:
        size = len(terms);
        array = [];
        for i in range(size):
            #此处也可扩展单项的合法性检查。
            if (terms[i] == ''):
                pass;
            else:
                array.append(monomial(terms[i]));
        #print(array);

        size2 = len(array);

        for i in range(size2):
            #判断系数是否是0
            if array[i][0] == 0:
                continue;
            for j in range(i+1, size2):
                if array[j][0] == 0:
                    continue;
                else:
                    if (sameTerm(array[i], array[j])):
                        #合并同类项
                        array[i][0]+=array[j][0];
                        array[j][0] = 0;

        result = [];
        for i in range(size2):
            #判断系数是否是0
            if array[i][0] == 0:
                continue;
            else:
                result.append(array[i]);

        print('合并同类项后详细情况是：', result);
        sResult = '';
        size3 = len(result);
        for i in range(size3):
            tmp1 = result[i][0];
            if (tmp1 >= 0):
                if (tmp1 != 1):
                    sResult += '+'+str(tmp1);
                else:
                    sResult += '+';
            if (tmp1 < 0):
                if (tmp1!=-1):
                    sResult += str(tmp1);
                else:
                    sResult += '-';

            tmp2 = result[i][2];
            length = len(tmp2);
            for j in range(length):
                if tmp2[j][1] != 1:
                    sResult += tmp2[j][0]+str(tmp2[j][1]);
                else:
                    sResult += tmp2[j][0];
        if sResult[0] == '+':
            sResult = sResult[1:];
        print('合并同类项后是:{0}\n\n'.format(sResult));
    except:
        print(s0, '有误，无法进行多项式操作。');
    return;

                

#同类项判断
def sameTerm(a, b):
    #由于a, b具有以下格式[1, 1, [['v', 1]]] [系数, 次数, 详细元素]
    if (a[1] == 0 and b[1] == 0):
        return True;
    
    if (a[1] != b[1]):
        #次数不同
        return False;
    if (len(a[2]) != len(b[2])):
        #元素个数不同
        return False;

    a1 = a[2];
    b1 = b[2];
    size = len(a1);
    for i in range(size):
        if a1[i][0] != b1[i][0] or a1[i][1] != b1[i][1]:
            return False;

    return True;
        </span>

来试试新工具的效果吧。

<span style="font-size:18px;">>>> 
多项式4x2+2x+7+3x-8x2-2 具有以下的项： ['4x2', '2x', '7', '3x', '-8x2', '-2']
其中各单项分别是：
单项式4x2 的系数是4， 次数是2，详细是[['x', 2]]。
单项式2x 的系数是2， 次数是1，详细是[['x', 1]]。
单项式7 的系数是7， 次数是0，
单项式3x 的系数是3， 次数是1，详细是[['x', 1]]。
单项式-8x2 的系数是-8， 次数是2，详细是[['x', 2]]。
单项式-2 的系数是-2， 次数是0，
合并同类项后详细情况是： [[-4, 2, [['x', 2]]], [5, 1, [['x', 1]]], [5, 0, []]]
合并同类项后是:-4x2+5x+5

if __name__ == '__main__':
    a = ['4x2+2x+7+3x-8x2-2'];

    for i in range(len(a)):
        polynomial(a[i]);</span>

<span style="font-size:18px;">>>> 
多项式xy2-0.2xy2 具有以下的项： ['xy2', '-0.2xy2']
其中各单项分别是：
单项式xy2 的系数是1， 次数是3，详细是[['x', 1], ['y', 2]]。
单项式-0.2xy2 的系数是-0.2， 次数是3，详细是[['x', 1], ['y', 2]]。
合并同类项后详细情况是： [[0.8, 3, [['x', 1], ['y', 2]]]]
合并同类项后是:0.8xy2


多项式-3x2y+2x2y+3xy2-2xy2 具有以下的项： ['-3x2y', '2x2y', '3xy2', '-2xy2']
其中各单项分别是：
单项式-3x2y 的系数是-3， 次数是3，详细是[['x', 2], ['y', 1]]。
单项式2x2y 的系数是2， 次数是3，详细是[['x', 2], ['y', 1]]。
单项式3xy2 的系数是3， 次数是3，详细是[['x', 1], ['y', 2]]。
单项式-2xy2 的系数是-2， 次数是3，详细是[['x', 1], ['y', 2]]。
合并同类项后详细情况是： [[-1, 3, [['x', 2], ['y', 1]]], [1, 3, [['x', 1], ['y', 2]]]]
合并同类项后是:-x2y+xy2


多项式4a2+3b2+2ab-4a2-4b2 具有以下的项： ['4a2', '3b2', '2ab', '-4a2', '-4b2']
其中各单项分别是：
单项式4a2 的系数是4， 次数是2，详细是[['a', 2]]。
单项式3b2 的系数是3， 次数是2，详细是[['b', 2]]。
单项式2ab 的系数是2， 次数是2，详细是[['a', 1], ['b', 1]]。
单项式-4a2 的系数是-4， 次数是2，详细是[['a', 2]]。
单项式-4b2 的系数是-4， 次数是2，详细是[['b', 2]]。
合并同类项后详细情况是： [[-1, 2, [['b', 2]]], [2, 2, [['a', 1], ['b', 1]]]]
合并同类项后是:-b2+2ab

if __name__ == '__main__':
    a = ['xy2-0.2xy2', '-3x2y+2x2y+3xy2-2xy2', '4a2+3b2+2ab-4a2-4b2'];

    for i in range(len(a)):
        polynomial(a[i]);</span>

<span style="font-size:18px;">>>> 
多项式8a+2b+5a-b 具有以下的项： ['8a', '2b', '5a', '-b']
其中各单项分别是：
单项式8a 的系数是8， 次数是1，详细是[['a', 1]]。
单项式2b 的系数是2， 次数是1，详细是[['b', 1]]。
单项式5a 的系数是5， 次数是1，详细是[['a', 1]]。
单项式-b 的系数是-1， 次数是1，详细是[['b', 1]]。
合并同类项后详细情况是： [[13, 1, [['a', 1]]], [1, 1, [['b', 1]]]]
合并同类项后是:13a+b


多项式5a-3b-3a2+6b 具有以下的项： ['5a', '-3b', '-3a2', '6b']
其中各单项分别是：
单项式5a 的系数是5， 次数是1，详细是[['a', 1]]。
单项式-3b 的系数是-3， 次数是1，详细是[['b', 1]]。
单项式-3a2 的系数是-3， 次数是2，详细是[['a', 2]]。
单项式6b 的系数是6， 次数是1，详细是[['b', 1]]。
合并同类项后详细情况是： [[5, 1, [['a', 1]]], [3, 1, [['b', 1]]], [-3, 2, [['a', 2]]]]
合并同类项后是:5a+3b-3a2

if __name__ == '__main__':
    a = ['8a+2b+5a-b', '5a-3b-3a2+6b'];

    for i in range(len(a)):
        polynomial(a[i]);</span>

<span style="font-size:18px;">>>> 
多项式2x-3y+5x+4y 具有以下的项： ['2x', '-3y', '5x', '4y']
其中各单项分别是：
单项式2x 的系数是2， 次数是1，详细是[['x', 1]]。
单项式-3y 的系数是-3， 次数是1，详细是[['y', 1]]。
单项式5x 的系数是5， 次数是1，详细是[['x', 1]]。
单项式4y 的系数是4， 次数是1，详细是[['y', 1]]。
合并同类项后详细情况是： [[7, 1, [['x', 1]]], [1, 1, [['y', 1]]]]
合并同类项后是:7x+y


多项式8a-7b-4a+5b 具有以下的项： ['8a', '-7b', '-4a', '5b']
其中各单项分别是：
单项式8a 的系数是8， 次数是1，详细是[['a', 1]]。
单项式-7b 的系数是-7， 次数是1，详细是[['b', 1]]。
单项式-4a 的系数是-4， 次数是1，详细是[['a', 1]]。
单项式5b 的系数是5， 次数是1，详细是[['b', 1]]。
合并同类项后详细情况是： [[4, 1, [['a', 1]]], [-2, 1, [['b', 1]]]]
合并同类项后是:4a-2b

if __name__ == '__main__':
    a = ['2x-3y+5x+4y', '8a-7b-4a+5b'];

    for i in range(len(a)):
        polynomial(a[i]);
</span>

<span style="font-size:18px;">>>> 
多项式2ab+2bc+2ca+6ab+8bc+6ca 具有以下的项： ['2ab', '2bc', '2ca', '6ab', '8bc', '6ca']
其中各单项分别是：
单项式2ab 的系数是2， 次数是2，详细是[['a', 1], ['b', 1]]。
单项式2bc 的系数是2， 次数是2，详细是[['b', 1], ['c', 1]]。
单项式2ca 的系数是2， 次数是2，详细是[['a', 1], ['c', 1]]。
单项式6ab 的系数是6， 次数是2，详细是[['a', 1], ['b', 1]]。
单项式8bc 的系数是8， 次数是2，详细是[['b', 1], ['c', 1]]。
单项式6ca 的系数是6， 次数是2，详细是[['a', 1], ['c', 1]]。
合并同类项后详细情况是： [[8, 2, [['a', 1], ['b', 1]]], [10, 2, [['b', 1], ['c', 1]]], [8, 2, [['c', 1], ['a', 1]]]]
合并同类项后是:8ab+10bc+8ca


多项式6ab+8bc+6ca-2ab-2bc-2ca 具有以下的项： ['6ab', '8bc', '6ca', '-2ab', '-2bc', '-2ca']
其中各单项分别是：
单项式6ab 的系数是6， 次数是2，详细是[['a', 1], ['b', 1]]。
单项式8bc 的系数是8， 次数是2，详细是[['b', 1], ['c', 1]]。
单项式6ca 的系数是6， 次数是2，详细是[['a', 1], ['c', 1]]。
单项式-2ab 的系数是-2， 次数是2，详细是[['a', 1], ['b', 1]]。
单项式-2bc 的系数是-2， 次数是2，详细是[['b', 1], ['c', 1]]。
单项式-2ca 的系数是-2， 次数是2，详细是[['a', 1], ['c', 1]]。
合并同类项后详细情况是： [[4, 2, [['a', 1], ['b', 1]]], [6, 2, [['b', 1], ['c', 1]]], [4, 2, [['c', 1], ['a', 1]]]]
合并同类项后是:4ab+6bc+4ca


if __name__ == '__main__':
    a = ['2ab+2bc+2ca+6ab+8bc+6ca', '6ab+8bc+6ca-2ab-2bc-2ca'];

    for i in range(len(a)):
        polynomial(a[i]);</span>

<span style="font-size:18px;">>>> 
多项式0.5x-2x+0.67y2-1.5x+0.33y2 具有以下的项： ['0.5x', '-2x', '0.67y2', '-1.5x', '0.33y2']
其中各单项分别是：
单项式0.5x 的系数是0.5， 次数是1，详细是[['x', 1]]。
单项式-2x 的系数是-2， 次数是1，详细是[['x', 1]]。
单项式0.67y2 的系数是0.67， 次数是2，详细是[['y', 2]]。
单项式-1.5x 的系数是-1.5， 次数是1，详细是[['x', 1]]。
单项式0.33y2 的系数是0.33， 次数是2，详细是[['y', 2]]。
合并同类项后详细情况是： [[-3.0, 1, [['x', 1]]], [1.0, 2, [['y', 2]]]]
合并同类项后是:-3.0x+y2

if __name__ == '__main__':
    a = ['0.5x-2x+0.67y2-1.5x+0.33y2'];

    for i in range(len(a)):
        polynomial(a[i]);</span>

<span style="font-size:18px;">#7
S = 4a2+3.14*a2*0.5
C = 2a*3+3.14*a 
#8
L = (a+y)*3+(a-y)*1.5
#9
C = 2a+n*3a </span>

<span style="font-size:18px;">>>> 100*2.3/2.2
104.54545454545452</span>

也就是说买104本的花费比买100本还要少。

<span style="font-size:18px;">function myDraw() { 
	
    var config = new PlotConfiguration();    
    config.init();    
    config.setPreference();   
	config.setSector(1,1,1,1);
	config.axis2D(0, 0, 180);

	var array = [];

	for (var i = 0; i <=100; i++) {
		array.push([i, -2.3*i/2]);
	}
	
	for (var i = 101; i < 200; i++) {
		array.push([i, -2.2*i/2]);
	}
	
	shape.multiLineDraw(array, 'red');
	

}</span>

这种所有数都相差相同的值的情况，小伟现在也不想仔细看了。

不过，刚才改进了一下同类项的判断，现在像4ca, 4ac这种，就会被判定为同类项了：

<span style="font-size:18px;">#同类项判断
def sameTerm(a, b):
    #由于a, b具有以下格式[1, 1, [['v', 1]]] [系数, 次数, 详细元素]
    if (a[1] == 0 and b[1] == 0):
        return True;
    
    if (a[1] != b[1]):
        #次数不同
        return False;
    if (len(a[2]) != len(b[2])):
        #元素个数不同
        return False;

    a1 = list(a[2]);
    b1 = list(b[2]);
    a1 = sorted(a1, key=lambda num:num[0]);
    b1 = sorted(b1, key=lambda num:num[0]);
    size = len(a1);
    for i in range(size):
        if a1[i][0] != b1[i][0] or a1[i][1] != b1[i][1]:
            return False;

    return True;</span>

本节到此结束，欲知后事如何，请看下回分解。