算法练习--数值相关

整型数组合并

将两个整型数组按照升序合并，并且过滤掉重复数组元素。
输出时相邻两数之间没有空格。

输入描述：
1 输入第一个数组的个数
2 输入第一个数组的所有数值
3 输入第二个数组的个数
4 输入第二个数组的所有数值

输出描述：
输出合并之后的数值字符串

示例1
输入：
3
1 2 5

4
-1 0 3 2

输出：
-101235

python实现：

def merge_arr():
    s0,s1,s3,s2 = input(), input().split(), input(), input().split()
    s = map(str,sorted(map(int, set(s1+s2))))
    print(''.join(s))


merge_arr()

 

质数因子

输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）

示例1
输入：
180

输出：
2 2 3 3 5

python代码：

• 正常约掉的就是质数因子
• 180/2 90/2 45/3 15/3 5/5

import math

def prime_factor():
    n = int(input().strip())
    for i in range(2, int(math.sqrt(n)) + 1):
        while n % i == 0:
            print(i, end=" ")
            n = n // i
    # 不能约掉的
    if n > 2:
        print(n)

 

最小公约数

输入两个正整数a, b；
求它们的最小公约数。

输入：
4 6
输出：
2

最小公倍数

正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求A和B的最小公倍数。

输入描述：
输入两个正整数A和B。

输出描述：
输出A和B的最小公倍数。

示例1
输入：
5 7
输出：
35

示例2
输入：
2 4
输出：
4

python实现：

def min_bei(a, b):
    if a > b:
        a, b = b, a

    if b % a == 0:
        print(b)
        return b
    
    temp = b
    while True:
        temp += b  # +1 只是增加了复杂度
        if temp % a == 0 and temp % b == 0:
            print(temp)
            return temp

a, b = input().strip().split()
a = int(a)
b = int(b)
min_bei(a, b)

• 短除法
  

A, B = map(int, input().split())
T = 1  # 初始1便于不影响乘数结果
for i in range(2, min(A, B) + 1):  # 只需遍历到最小的一个数
    while A % i == 0 and B % i == 0:  # 逐一找公共除数
        T = T * i  # 每找到一个公共除数就累乘
        A = A // i
        B = B // i
print(T * A * B)  

 

解立方根

计算一个浮点数的立方根，不使用库函数。
保留一位小数。

输入描述：
一个double类型（实数）

输出描述：
输出其立方根，保留一位小数。

示例1
输入：
19.9
输出：
2.7

示例2
输入：
2.7
输出：
1.4
 
python实现

• 二分

def binary_split():
    a = float(input().strip())
    epsilon = 0.0001
    low = min(-1.0, a)
    high = max(1.0, a)
    ans = (low + high)/2
    
    while abs(ans**3 - a) >= epsilon:
        if ans**3 < a:
            low = ans
        else:
            high = ans
        ans = (low + high)/2.0
    
    print('%.1f' % ans)

binary_split()

 

四则运算

输入一个表达式（用字符串表示），求这个表达式的值。
保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。

输入描述：
输入一个算术表达式

输出描述：
得到计算结果

示例1
输入：
3+2*{1+2*[-4/(8-6)+7]}
输出：
25 注意数据类型

python，栈实现。

# 将输入的表达式中的数字和符号区分开，并保存到列表中
def group(s):
    num, res = '', []
    for i, c in enumerate(s):
        if c.isdigit():
            num += c # 数字可能有很多位数
        else:
            if num:
                res.append(num)
                num = ''
            if c == '-': # 负数的判断
                if (i == 0) or (s[i-1] in '+-*/([{'):
                    num += c
                    continue
            res.append(c)
    if num:
        res.append(num)
    return res

while True:
    try:
        s = input()
        lst = group(s)
        stack_n, stack_op = [], []
        '''
            遍历数字和符号列表lst：
            1.如果遇到数字，添加到数字栈stack_n中；
            2.如果遇到*/([{这些符号，直接添加到符号栈stack_op中；
            3.如果遇到+-号:
                (1).如果符号栈stack_op为空或栈顶元素是左括号([{的话，直接入栈；
                (2).如果符号栈stack_op不为空，则不断从符号栈stack_op中弹出一个符号，
                    同时从数字栈stack_n中弹出两个数字进行运算，并将运算结果保存到数字栈stack_n中。
                    期间若遇到（不弹栈）左括号([{，则跳出循环，最后再将加号+或者减号-添加到符号栈中。
            4.如果遇到右括号)]}，在栈顶元素不是左括号([{之前，不断地取出数字和符号进行运算，
              同时将结果保存到数字栈stack_n中，最后删除左括号。
        '''
        for i in lst:
            if i not in '+-*/()[]{}': # 数字
                stack_n.append(i)
            elif i in '*/([{':
                stack_op.append(i)
            elif i in '+-':
                if len(stack_op) == 0 or stack_op[-1] in '([{':
                    stack_op.append(i)
                else:
                    while stack_op:
                        if stack_op[-1] in '([{':
                            break
                        op = stack_op.pop()
                        n2, n1 = stack_n.pop(), stack_n.pop()
                        stack_n.append(str(eval(n1 + op + n2)))
                    stack_op.append(i)
            elif i in ')]}':
                while stack_op[-1] not in '([{':
                    op = stack_op.pop()
                    n2, n1 = stack_n.pop(), stack_n.pop()
                    stack_n.append(str(int(eval(n1 + op + n2))))
                stack_op.pop()
        # 对数字栈和符号栈中剩余元素进行运算
        while stack_op:
            op = stack_op.pop()
            n2, n1 = stack_n.pop(), stack_n.pop()
            stack_n.append(str(int(eval(n1 + op + n2))))
        # 弹出并打印数字栈中最后一个数字，即运算结果
        print(stack_n.pop())
    except:
        break