软件测试面试题整理(十)之算法编程集—python版

最新推荐文章于 2024-02-26 13:59:52 发布

_冬日的阳光_

最新推荐文章于 2024-02-26 13:59:52 发布

阅读量35

点赞数

文章标签：算法数据结构

原文链接：https://blog.csdn.net/weixin_45912307/article/details/109544168

版权

https://blog.csdn.net/weixin_45912307/article/details/109544168
1_1. 斐波那契数列

"""
程序分析：斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……。
"""

def fib(lenght):
    a, b = 0, 1
    n = 0
    while n < lenght:
        yield b
        a, b = b, a + b
        n += 1


gen = fib(9)
for i in gen:
    print(i, end=' ')

# 输出：1 1 2 3 5 8 13 21 34

1_1. 斐波那契数列

"""
程序分析：递归和非递归实现求解斐波那契数列第N项的数，如输入：5，输出：5；输入：10，输出：55；
"""
# 递归方式
def fid_1(n):
    if n ==0:
        return 0
    if n==1:
        return 1
    return fid_1(n-1)+fid_2(n-2)

# 非递归方式
def fid_2(n):
    if n<=1: return (n,0)
    res = [0,1]
    for i in  range(2,n+1):
        res.append(res[i-1]+res[i-2])
    return res[n]

2. 输出 9*9 乘法口诀表。

"""
程序分析：分行与列考虑，共9行9列，i控制行，j控制列。
"""
for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{} = {}".format(i,j,i*j),end=' ')
    print()

3. 判断101-200之间有多少个素数，并输出所有素数。

"""
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。 　　
"""
from math import sqrt
h = 0
leap = 1
for m in range(101, 201):
    k = int(sqrt(m + 1))
    for i in range(2, k + 1):
        if m % i == 0:
            leap = 0
            break
    if leap == 1:
        print('%-4d' % m,end=' ')
        h += 1
        if h % 10 == 0:
            print(' ')
    leap = 1
print()
print('The total is %d' % h)

# 输出结果
"""
101  103  107  109  113  127  131  137  139  149   
151  157  163  167  173  179  181  191  193  197   
199  
The total is 21
"""

4. 打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。

"""
例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
"""

for n in range(100,1000):
    i = n // 100
    j = n // 10 % 10
    k = n % 10
    if n == i*i*i + j*j*j + k*k*k:
        print(n)
        
# 输出结果
"""
153
370
371
407
"""

5. 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

"""
程序分析：利用 while 或 for 语句,条件为输入的字符不为 '\n'。
"""
import string
s = input('请输入一个字符串:\n')
letters = 0
space = 0
digit = 0
others = 0
for c in s:
    if c.isalpha():
        letters += 1
    elif c.isspace():
        space += 1
    elif c.isdigit():
        digit += 1
    else:
        others += 1
print('char = %d,space = %d,digit = %d,others = %d' % (letters,space,digit,others))


"""
输入：aafsaf fas52  523230.21 ~~~?
输出：char = 9,space = 4,digit = 10,others = 5
"""

6. 打印出如下图案（菱形）

  *
  ***
 *****
*******
 *****
  ***
   *


"""
程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重for循环，第一层控制行，第二层控制列。
"""
from sys import stdout

for i in range(4):
    for j in range(2 - i + 1):
        stdout.write(' ')
    for k in range(2 * i + 1):
        stdout.write('*')
    print()

for i in range(3):
    for j in range(i + 1):
        stdout.write(' ')
    for k in range(4 - 2 * i + 1):
        stdout.write('*')
    print()

7. 求1+2!+3!+…+100!的和

n = 0
s = 0
t = 1
for n in range(1,101):
    t *= n
    s += t
print('1! + 2! + 3! + ... + 100! = %d' % s)

# 输出：
"""
1! + 2! + 3! + ... + 100! = 94269001683709979260859834124473539872070722613982672442938359305624678223479506023400294093599136466986609124347432647622826870038220556442336528920420940313
"""

8. 从键盘输入一个数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

while True:
    a = int(input("请输入一个数字:\n"))
    x = str(a)
    flag = True

    for i in range(len(x) // 2):
        if x[i] != x[-i - 1]:
            flag = False
            break
    if flag:
        print("%d 是一个回文数!" % a)

    else:
        print("%d 不是一个回文数!" % a)
# 输出：
"""
请输入一个数字:
12321
12321 是一个回文数!
请输入一个数字:
123123
123123 不是一个回文数!
请输入一个数字:
243342
243342 是一个回文数!
请输入一个数字:
24355342
24355342 是一个回文数!
请输入一个数字:
"""

9. 将一个数组逆序输出。

"""
程序分析：用第一个与最后一个交换。
"""
while True:
    try:
        a = list(map(int,input().split(' ')))
        N = len(a)
        print(a)
        for i in range(len(a) // 2):
            a[i], a[N - i - 1] = a[N - i - 1], a[i]
        print(a)
    except Exception as e:
        print(e)

# 输出：
"""
9 6 5 4 1
[9, 6, 5, 4, 1]
[1, 4, 5, 6, 9]

1 5 8 9 6 3
[1, 5, 8, 9, 6, 3]
[3, 6, 9, 8, 5, 1]
"""

10. 给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
示例1：
输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”

class Solution(object):
    def reverseWords(self, s):
        s = s.split()
        l = []
        for i in range(len(s)):
            l.append(s[i][::-1])
        return " ".join(l)


if __name__ == '__main__':
    s1 = "Let's take LeetCode contest"
    S = Solution().reverseWords(s1)
    print(S)

11. 编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”。

"""
示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
"""

def longestCommonPrefix(strs):
    """
    :type strs: List[str]
    :rtype: str
    """
    if not strs:
        return ''
    s1 = min(strs)
    s2 = max(strs)
    for i, c in enumerate(s1):
        if c != s2[i]:
            return s1[:i]
    return s1
str1 = ['flow', 'flowers', 'flight']
s = longestCommonPrefix(str1)
print(s)

12. 一行代码实现1~100的和

print(sum([i for i in range(1, 101)]))

13. 用递归函数查看/home目录下所有文件名

import os
def copy(src, target):
    file_list = os.listdir(src)  # 1. 获取文件夹里面内容
    print(file_list)
    for file in file_list:  # 2. 变量列表
        path = os.path.join(src, file)  # 3.拼接路径
        if os.path.isdir(path):  # 4. 判断是文件夹还是文件 path = /home            # 5. 是文件夹进行递归调用copy
            copy(path, target)
        else:  # 6. 不是文件夹直接复制
            with open(path, 'rb') as r_stream:
                container = r_stream.read()
                path1 = os.path.join(target, file)
            with open(path1, 'wb') as w_stream:
                w = w_stream.write(container)


src_path = r'/home'
target_path = r'home01'
copy(src_path, target_path)

14. 冒泡算法

while True:
    try:
        l = list(map(int,input("请输入一个需要排序的列表:").split(' ')))
        i = 0
        for i in range(len(l) - 1):
            for j in range(len(l) - 1 - i):
                if l[j] > l[j + 1]:
                    l[j + 1], l[j] = l[j], l[j + 1]
        print(l)
    except Exception as e:
        print(e)     
"""
请输入一个需要排序的列表:10 5 8 6 9 2
[2, 5, 6, 8, 9, 10]
请输入一个需要排序的列表:10 5 i 9 6
invalid literal for int() with base 10: 'i'
请输入一个需要排序的列表:  
"""

15. 获取列表最后一个元素

while True:
    try:
        l = list(map(str,input().split()))
        ele = l[-1]
        print(ele)
    except :
        pass
"""
输入：12 3451 65123 6132 6132  
输出：6132
"""

16. 逆序输出一个字符串

while True:
    try:
        s = (input(''))
        # print(s[::-1]) # 法1：切片
        # print(''.join(reversed(s)))  # 法2：(一行代码：先翻转后拼接）
        # print(''.join(sorted(s,reverse=True))) # 法3 （一行代码：先逆向排序再拼接）
        # 法4：先把字符串转化为列表，然后倒序，再循环输出
        l = list(s)
        l.reverse()
        for i in l:
            print(i, end='')
    except :
        pass
"""
输入：fagajgka 爱福家欧昂 54120fasgas
输出：sagsaf02145 昂欧家福爱 akgjagaf
"""

17. 打印出杨辉三角形（任意输入一个整数）

massage = '''
杨辉三角，本质上是二项式(a+b)的n次方展开后各项的系数排成的三角形。其性质包括：每行的端点数为1， 一个数也为1；每个数等于它左上方和上方的两数之和。
'''
l = [[0] * i for i in range(1, 31)]
for i in range(30):
    for j in range(i + 1):
        if j == 0 or i == j:
            l[i][j] = 1
        else:
            l[i][j] = l[i - 1][j - 1] + l[i - 1][j]

n = int(input())
for i in range(n):
    for j in range(i + 1):
        print('{:>5d}'.format(l[i][j]), end='')
    print()

"""
输入：10
输出：
1
1    1
1    2    1
1    3    3    1
1    4    6    4    1
1    5   10   10    5    1
1    6   15   20   15    6    1
1    7   21   35   35   21    7    1
1    8   28   56   70   56   28    8    1
1    9   36   84  126  126   84   36    9    1
"""

18. 打印金字塔图案

massage = '''
打印用“*”组成的金字塔图案。
输入描述:
多组输入，一个整数（2~20），表示金字塔边的长度，即“*”的数量，也表示输出行数。

输出描述:
针对每行输入，输出用“*”组成的金字塔，每个“*”后面有一个空格。
'''
while True:
    try:
        n = int(input())
        for i in range(n):
            print(' ' * (n - i-1) + '* ' * (i + 1))

    except:
        break
# 打印结果
'''
   5
    * 
   * * 
  * * * 
 * * * * 
* * * * * 
'''

19. 将一个四位数反向输出

massage = '''
将一个四位数，反向输出
'''

N = input()
print(int(N[::-1]))
"""
# 输入：	1245
# 输出 ：5421
"""

20. 对一个列表中整数去重

massage = '''
题目描述:
输入n个整数的序列，要求对这个序列进行去重操作。所谓去重，是指对这个序列中每个重复出现的整数，只保留该数第一次出现的位置，删除其余位置。
输入描述:
输入包含两行，第一行包含一个正整数n（1 ≤ n ≤ 1000），表示第二行序列中数字的个数；第二行包含n个整数（范围1~5000），用空格分隔。
输出描述:
输出为一行，按照输入的顺序输出去重之后的数字，用空格分隔。
'''
解法一：传统方法
while True:
    try:
        n = int(input())
        l = list(map(int,input().split(' ')))
        new_l = []
        for i in range(len(l)):
            if l[i] not in new_l:
                new_l.append(l[i])
        print(new_l)
    except:
        pass

"""
输入：
5
100 20 50 20 80
输出：
100 20 50 80
"""
解法二：集合去重
while True:
    try:
        n = int(input())
        l = list(map(int,input().split(' ')))
        new_l = list(set(l))
        print(new_l)
    except:
        pass
解法三：列表推导式
while True:
    try:
        n = int(input())
        l = list(map(int, input().split(' ')))
        l2 = []
        [l2.append(i) for i in l if i not in l2]
        print(l2)
    except:
        pass

21. 统计字符串中每个字母出现的次数

# 法1：字典推导式
while True:
    try:
        s = str(input())
        print({i: s.count(i) for i in s})
    except:
        pass
"""
sggg abcdq1ss sdgggss22585852
{'s': 6, 'g': 6, ' ': 2, 'a': 1, 'b': 1, 'c': 1, 'd': 2, 'q': 1, '1': 1, '2': 3, '5': 3, '8': 2}
"""
# 法2： counter
import collections
while True:
    try:
        s =str(input())
        print(collections.Counter(s))
    except:
        pass
# 法3：set去重
while True:
    try:
        s =str(input())
        for i in set(s):
            print(i,s.count(i))
    except:
        pass

22. 对某英文文章的单词，进行词数统计

while True:
    try:
        file_name = input()
        word_counts = 0
        with open(file_name, 'r', encoding='utf-8') as f:
            for line in f:
                words = line.split(' ')
                word_counts += len(words)
        print("word_counts:", word_counts)
    except:
        print("输入文件名称有误或文本内容为空")
        pass

23. python字典合并
法1：update

while True:
    try:
        n = int(input())
        d1 = dict([map(str, input().split()) for x in range(n)])
        d2 = dict([map(str, input().split()) for x in range(n)])
        d1.update(d2)
        print(d1)
    except:
        pass
"""
3
a 1
c 3
e 5 
姓名 张三 
年龄 18
性别 男
{'a': '1', 'c': '3', 'e': '5', '姓名': '张三', '年龄': '18', '性别': '男'}
"""

法2：使用**

def Merge(dict1,dict2):
    dict3  = {**dict1,**dict2}
    print(dict3)
    return dict3
if __name__ == '__main__':
    d1 = {'a':1,'b':2,'c':3}
    d2 = {'name':'lili','age':18}
    Merge(d1,d2)

24. 返回字符串中第一个不重复的字母和位置

import collections

while True:
    try:
        s = str(input())
        fre = collections.Counter(s)
        print(fre)
        for i, char in enumerate(s):
            print(i)
            if fre[char] <= 1:
                print(char,":",i)
                break
        else:
            print(-1)
    except:
        pass

25. 两个列表如何生成一个对应的字典

while True:
    try:
        l1 = list(map(str,input().split()))
        l2 = list(map(str,input().split()))
        d = dict(zip(l1,l2))
        print(d)
    except:
        pass
"""
a b c d e f
1 2 5 7
{'a': '1', 'b': '2', 'c': '5', 'd': '7'}
"""

26. 一行代码实现字典排序

while True:
    try:
        print(sorted(dict([map(str,input().split()) for i in range(3)]).items(),key = lambda x:x[0],reverse=True))  # key排序
        # print(sorted(dict([map(str, input().split()) for i in range(3)]).items(), key=lambda x: x[1], reverse=True))  # value排序
    except:
        pass
"""
ab 12
cde 456
FG 01
[('cde', '456'), ('ab', '12'), ('FG', '01')]
"""

27. 一行代码实现字典的key和value反转

法1：字典推导式
print({v:k for k,v in dict([map(str, input().split()) for x in range(3)]).items()})
"""
a 1
张三 姓名
age 18
{'1': 'a', '姓名': '张三', '18': 'age'}
"""
法2：zip
d1 = dict([map(str, input().split()) for x in range(3)])
print(dict(zip(d1.values(),d1.keys())))

28. python如何实现单例模式

""" 
1、定义一个类属性，来记录该类是否创建过对象 instance = None 
2、在_new_方法中对类属性做判断 
  - 2.1没有创建过对象。那就创建一个(保存起来)，并且修改类属性的值 
  - 2.2创建过了，就将之前创建的返回出去 
"""
# 1. 简单模式：一个类只有单个对象被创建
class MyClass(object):
    __isinstance=None
    def __new__(cls, *args, **kwargs):
        if not cls.__isinstance:
            cls.__isinstance = super().__new__(cls) # 方法1
            # cls.__isinstance = object.__new__(cls) # 方法2
            return cls.__isinstance
        else:
            return cls.__isinstance
t1 = MyClass()
t2 = MyClass()
print(t1 is t2) # True

# 2. 装饰器实现单例模式
def single(cls):
    __isinstance = {}
    def wrapper(*args,**kwargs):
        if cls in __isinstance:
            return __isinstance[cls]
        else:
            __isinstance[cls] = cls(*args,**kwargs)
            return __isinstance[cls]
    return wrapper
@single
class CustomClass:
    pass
cc1 = CustomClass()
cc2 = CustomClass()
print(cc1 is cc2)

28. 给定一个32位的有符号整数num，将num中的数字部分反转，最后返回反转的结果

'''
1.只反转数字部分，符号位部分不反转
2.反转后整数num超过 32 位的有符号整数的范围 [−231,  231 − 1] ，返回 0
3.假设本题不允许存储 64 位整数(有符号或无符号，即C++不能使用long long ，Java不能使用long等)
数据范围:
-231 <= x <= 231-1
输入：12
返回值：21
输入：-120
输出：-21
输入：-123
返回值：-321
'''
class Solution:
    def reverse(self , x: int) -> int:
        # write code here
        if x==0:
            return 0
        if x>0:
            a = int(str(x)[::-1])
        else:
            # a = -int(str(-x)[::-1])
            a = -int(str(x)[1:][::-1])
        if a> 2**31 or a<-2**31:
            return 0
        else:
            return a
                   
s = Solution()
s = s.reverse(-1200)
print(s)