python最新笔试题

Posted 2021-01-26 雨轩恋i

这是笔者面试小十家公司后呕心沥血总结的一些笔试编程题~具体公司就不透露了。哎，说多了都是泪啊。

1.二分法查找：

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
find_num = int(input(\'请输入一个数字：\'))
start = 0
end = len(l) - 1

while True:
    middle = (start + end) // 2
    if find_num == l[middle]:
        print(\'找到了！索引是：\', middle)
        break
    elif find_num > l[middle]:
        start = middle + 1
    elif find_num < l[middle]:
        end = middle - 1
    if start > end:
        print(\'没找到!\', find_num)
        break

2.二分法查找序列

#一个有序数列类似[1,2,3,3,4,4,5,5,5,6,7,8,8]
#输入5 用二分法 输出 5 的起始下标和 末尾下标

def searchRange(nums, target):
    if len(nums) == 0:
        return [-1,-1]
    elif target < nums[0] or target > nums[-1]:
        return [-1,-1]
    else:
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = (l + r) // 2
            if target > nums[mid]:
                l = mid + 1
            elif target < nums[mid]:
                r = mid - 1
            elif target == nums[mid]:
                l = r = mid
                while l-1 >= 0 and nums[l-1] == target:
                    l -= 1
                while r+1 <= len(nums)-1 and nums[r+1] == target:
                    r += 1
                return [l,r]
    return [-1,-1]

nums = [1,3,4,6,8,8,9,10]
a = searchRange(nums,8)
print(a)

3.冒泡排序

\'\'\'
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名“冒泡排序”。
\'\'\'

import random
# 步骤2：创建一个空列表，用于存放待排序随机数据集
data = [random.randint(0, 100) for i in range(10)]
print(\'待排序的随机数列: {0}\'.format(data))
# 步骤3：使用嵌套循环实现冒泡排序
# 外层循环控制排序的次数
for i in range(10):
    # 内层循环控制每次对比的次数
    for j in range(len(data)-1-i):
        # 如果前项值大于后项值则对位交换，将大的在列表中后移1位
        if data[j] > data[j+1]:
            temp = data[j]
            data[j] = data[j+1]
            data[j+1] = temp
            pass
# 步骤4：输出排序后的结果
print(\'排序后的有序序列: {0}\'.format(data))


#交换排序.冒泡排序
L = [1, 3, 2, 32, 5, 4]
def Bubble_sort(L):
    for i in range(len(L)):
        for j in range(i+1,len(L)):
            if L[i]>L[j]:
                # temp = L[j]
                # L[j] = L[i]
                # L[i] = temp
                L[i], L[j] = L[j], L[i]#交换顺序

    print (L)
Bubble_sort(L)

4.列表去重

ids = [1,2,3,3,4,2,3,4,5,6,1,6,4,3,2,3,]
news_ids = []
for id in ids:
    if id not in news_ids:
        news_ids.append(id)
print (news_ids)
#python 列表去重(数组)的几种方法 - 朝阳的向日葵 - 博客园  https://www.cnblogs.com/zknublx/p/6042295.html
ids = list(set(ids))
print(ids)  #一句话列表去重

#lambda 一句话列表去重
a=(lambda x,y:x if y in x else x + [y], [[],] + ids)
print(a)

5.列表嵌套

l=[1,2,[3,4,[5,6],[7,8],9],10]
l1=[]
#递归函数实现：
def getitem(l):
    for item in l:
        if isinstance(item,list):
            getitem(item)
        else:
            print(item)
            l1.append(item)

getitem(l)
print(l1)
#python利用递归函数输出嵌套列表的每个元素 - lincappu - 博客园  https://www.cnblogs.com/lincappu/p/8146055.html

6.统计列表数值出现次数

a=[1,2,3,3,3,3,7,7,8,8,10]
print(a)
news_ids = []
for id in a:
    if id not in news_ids:
        news_ids.append(id)
print (news_ids)
for i in news_ids:
    if a.count(i) >= 1:
        print(\'%s 出现了%d 次!\'%(i, a.count(i)))

#纯手写

7.列表逆输出

a=[0,1,2,3,4,5,6,7,8,9,10]
b=[]
print(a[::-1]) #逆输出

#手写代码
count=len(a)
for i in range(len(a),0,-1):
    count-=1
    b.append(a[count])
print(b)

8.字符串统计

str=\'mynameisbobiamfromchina嘿嘿嘿嘿\'
str=\',\'.join(str) #以逗号分隔字符串
print(str)
li=str.split(\',\')
print(li) #变成列表了
#统计每一个字符出现的次数:
for i in set(li):
    if li.count(i) >= 1:
        print(\'%s 出现了%d 次!\'%(i, li.count(i)))

print(\'*\'*50)
#方式二
from collections import Counter
res = Counter(li)
print(res)

9.字节型字典

dic=b\'{"name":"ltf","school":"tyut"}\'
str(dic, encoding="utf-8")
print(dic)
dicBytes = dic.decode(\'utf-8\')
print(dicBytes)
print(eval(dicBytes)) #字符串转换为字典
print(eval(dicBytes).keys())

#修改key
dict = {\'a\':\'ltf\',\'b\':\'fjf\'}
dict.update({\'1\':dict.pop("a")})
dict.update({\'2\':dict.pop("b")})
print(dict)

10.快速排序

#coding:utf-8
#author:徐卜灵
#交换排序.快速排序
# 虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数+分治法：
# import sys
# sys.setrecursionlimit(150000)
L = [6, 3, 2, 32, 5, 4]

def Fast_sort(L, left,right):
    if left >= right:
        return L
    key = L[left]
    low = left
    high = right
    while left < right:
        # if L[right] > key:
        #     right-=1
        # else:
        #     L[left] = L[right]
        # if L[left] <= key:
        #     left += 1
        # else:
        #     L[right] = L[left]
        # L[left] = key
        while left < right and L[right] >= key:
            right -= 1
        L[left] = L[right]
        while left < right and L[left] <= key:
            left += 1
        L[right] = L[left]
    L[left] = key
    Fast_sort(L, low, left - 1)
    Fast_sort(L,left + 1,high)
    return L
print (Fast_sort(L,0,5))

#1.高质量代码
def quick_sort(lists, left, right):
    # 快速排序
    if left >= right:
        return lists
    key = lists[left]
    low = left
    high = right
    while left < right:
        while left < right and lists[right] >= key:
            right -= 1
        lists[left] = lists[right]
        while left < right and lists[left] <= key:
            left += 1
        lists[right] = lists[left]
    lists[left] = key
    quick_sort(lists, low, left - 1)
    quick_sort(lists, left + 1, high)
    return lists
print (quick_sort(L,0,5))


#2.高质量代码
# # 设置最低位和最高位
# def quickSort(nums, low, high):
#     # 设置一个比较基准key
#     key = nums[low]
#     while low<high:
#         # 如果最高位的数 大于等于 key则向前走
#         while low<high and nums[high] >= key:
#             high -= 1
#         # 如果最低位的数 小于等于 key则向后走
#         while low<high and nums[low] <= key:
#             low += 1
#         # 交换值
#         nums[low], nums[high] = nums[high], nums[low]
#
#     #最后low=high, 此时交换key和high位上的值, 使小于key的值在key左边, 大的在key右边
#     nums[nums.index(key)], nums[low] = nums[low], nums[nums.index(key)]
#     # 返回最低位的位置
#     return low
#
#
# # 进行重复操作
# def interval(nums, low, high):
#     if low<high:
#         # 进行排序并得到最低位位置以循环操作
#         key_index = quickSort(nums, low, high)
#         interval(nums, low, key_index)
#         interval(nums, key_index+1, high)
#
#
# nums = [64,3,9,2,4,7,0,12,45,]
# interval(nums, 0, len(nums)-1)
# print nums
#

11.打印三角形

for i in range(10):
    for j in range(0, 10 - i):
        print(end=" ")
    for k in range(10 - i, 10):
        print("*", end=" ")

    print("")

for l in range(10):
    for m in range(l):
        print(" ",end="")
    for n in range(10-l):
        print("*",end=" ")
    print("")

12.数字转中文输出

num=[1,2,3,4,5,6,7,8,9,0]
cn=[\'壹\',\'贰\',\'叁\',\'肆\',\'伍\',\'陆\',\'柒\',\'捌\',\'玖\',\'零\']
dw=[\'元\',\'十\',\'百\',\'千\',\'万\',\'十\',\'百\',\'千\']
n=str(input(\'请输入数字:\'))
c=len(n)-1
# print c
ln=\'\'
c1=0
for i in n:
    nb = int(i) - 1
    if i==\'0\' and c1==0:
        c1=1
        pass
    else:
        if c1==1:
           c1=0
        ln=ln+ cn[nb]+dw[c]
        print(ln)
    c=c-1
print(ln)

13.数字逆输出

# num=input(\'请输入一个数:\')
# a=[]
# li=list(num)
# print(li)
# count=len(li)
# for i in range(len(li),0,-1):
#     count-=1
#     a.append(li[count])
# print(a)

num=input(\'请输入一个数:\')
a=[]
str=\'\'
print(num)
count=len(num)
for i in range(len(num),0,-1):
    count-=1
    a.append(num[count])
b=str.join(a)
print(int(b))

14.斐波那契数列

#最简单的方法为数组，其次为循环，最垃圾的为递归，到了40就算好久。。日后再琢磨数组

a=[1,1]
def fn(n):
    count=0
    f0=1
    f1=1
    f2=0
    while count<n:
        count+=1
        f2=f1+f0
        f0=f1
        f1=f2
        a.append(f2)
    print(\'第%s项的项数为:%s\'%(b,f2))
    print(\'斐波那契数列为:\')
    print(a)
b=int(input(\'请输入项数:\'))
fn(b-2)

15.有序数组合并

def merge_sort(a, b):
    ret = []
    i = j = 0
    while len(a) >= i + 1 and len(b) >= j + 1:
        if a[i] <= b[j]:
            ret.append(a[i])
            i += 1
        else:
            ret.append(b[j])
            j += 1
    if len(a) > i:
        ret += a[i:]
    if len(b) > j:
        ret += b[j:]
    return ret

if __name__ == \'__main__\':
    a = [1,3,4,6,7,78,97,190]
    b = [2,5,6,8,10,12,14,16,18]
    print(merge_sort(a, b))

16.生成器

#如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？
# 这样就不必创建完整的list，从而节省大量的空间。
# 在Python中，这种一边循环一边计算的机制，称为生成器（Generator）

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
fib(8)
#生成器调用方法，其实是

17.装饰器

#装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景。
def outer(func):
    def inner(*args,**kwargs):
        print("认证成功！")
        result = func(*args,**kwargs)
        print("日志添加成功")
        return result
    return inner

@outer
def f1(name,age):
    print("%s 正在连接业务部门1数据接口......"%name)

# 调用方法
f1("jack",18)
#装饰器调用方法，其实是把函数 f1 当成 outer的参数 

18.直接插入排序

#1.直接插入排序
L = [1, 3, 2, 32, 15, 5, 4]
def Insert_sort(L):
    for i in range(1,len(L)):
        for j in range(0,i):#这里面其实也是从前向后比较
            if L[i]<L[j]:
                L.insert(j,L[i])#在不大于的位置插入L[i],这个时候，列表加长了1位,L[i]插入到指定位置了，但它的值也向后移动了一位
                L.pop(i+1)#把原来L[i]的值删除。
    print(L)
    #空间复杂度为O（1），时间复杂度为O（n*n）
Insert_sort(L)
# print sorted(L)#自带的两种排序
# L.sort()
# print L

19.简单选择排序

L = [6, 3, 2, 32, 5, 4]
def Select_sort(L):
    for i in range(0,len(L)):
        for j in range(i,len(L)):
            if L[i] > L[j]:         #打擂台的形式
                # temp = L[i]
                # L[i] = L[j]
                # L[j] = temp
                L[i],L[j] = L[j],L[i]
    return  L
print (Select_sort(L))

20.驼峰命名规则

\'\'\'
bob_ltf 输出 bobLtf
\'\'\'
s=\'bob_ltf_lsq_fjf\'
s1=\'\'
s2=\'\'
arr=s.split(\'_\') #列表
print(arr)
s1=s1.join(arr[1:])
print(s1.capitalize())
s2=s2.join(arr[:1])
s3=s2+s1.capitalize()
print(s3)
\'\'\'
输出结果
[\'bob\', \'ltf\', \'lsq\', \'fjf\']
Ltflsqfjf
bobLtflsqfjf
\'\'\'

暂时总结这么多，以后的面试或者笔试题我也会加入到这里面。。。笔试的时候全部要求手写代码，而且不能用第三方库的方法。。。这就很难受了

以上源码GitHub地址：

https://github.com/tyutltf/python_bishi/tree/master