python面试题

求100以内的质数

# 质数是指大于1且只能被1和其自身整除的数
第一种方法：
s=[]
for i in range(2,100):
    for j in range(2,i):
        if i!=j and i%j==0:
            break
    else:
        s.append(i)
print(s)
"""
for......else......的执行顺序为：
当迭代对象完成所有迭代后且此时的迭代对象为空时，如果存在else子句则执行else子句，没有则继续执行后续代码；如果迭代对象因为某种原因（如带有break关键字）提前退出迭代，则else子句不会被执行，程序将会直接跳过else子句继续执行后续代码"""

第二种方法：
s = list(range(3, 101))
for i in range(2, 101):
    for k in range(2, i):
        if i % k == 0:
            s.remove(i)
            break
        else:
            continue
print(s)

给定一个字符串,找出不含有重复字符的最长子串的长度

如下图所示:

def func(s):
    new_dict={}
    if len(s)==0:
        return 0
    elif s.isspace():
        return 1
    elif len(s)==1:
        return len(s)
    for i in range(len(s) - 1):
        for j in range(i + 1, len(s)+1):
            str = s[i:j]
            if len(str) == len(set(str)):
                new_dict[str]=len(str)
    for i in new_list:
        dict[i] = len(i)
    lens = max(dict.items(), key=lambda x: x[1])
    return lens


print(func("hdeifgryifbtigtibvihiadyrgyfedgegdyrgfygryfguhduihdiwgfygr"))
print(func('hdeifgryifbtancvsqgigtibvihiadyrgyfedgegdyrgfygryfguhduihdiwgfygr'))
print(func("abcabcbb"))
print(func("pwwkewhg"))
print(func("pwwkhg"))

#思路:判断字符是否在列表里,不是,就将该字符加到列表里,是的话就将该列表加到外层列表,并清空该列表
def func(s):
    t=[]
    f=[]
    i=0
    while i < len(s):
        for j in range(i,len(s)):
            if s[j] not in t:
                t.append(s[j])
            else:
                c=[a for a,b in enumerate(s) if b==s[j]] #该字符在列表中,找到字符串中该字符所有的索引,并找到该字符当前索引的前一个相同字符索引+1,开始进行循环,或得下一个列表
                d=c[c.index(j)-1]
                f.append(t)
                f=copy.deepcopy(f)
                t.clear()
                i=d+1
                break  #必须加,否则for循环会从当前索引的下一个索引开始,不会重新开始
        else:  #这个else的目的是直到最后一个字符都没有相同时,那就直接添加到列表中,并且终止所有循环
            f.append(t)
            f = copy.deepcopy(f)
            t.clear()  #列表属于可变类型,一旦清空,会导致s里面的列表内容也被清空,所以通过深拷贝进行复制,这里也可以不使用列表而使用字符串
            i =len(s)
            break
    t = {}
    for i in f:
        h = ''
        for j in range(len(i)):
            h += i[j]
        t[h] = len(h)
    print(sorted(t.items(), key=lambda x: x[1], reverse=True))
func("hdeifgryifbtigtibvihiadyrgyfedgegdyrgfygryfguhduihdiwgfygr")
func('hdeifgryifbtancvsqgigtibvihiadyrgyfedgegdyrgfygryfguhduihdiwgfygr')
func("abcabcbb")
func("pwwkew")

写一个冒泡排序

"""思考过程：总共是n个数，那么，共需要排序n-1次，每次排序次数：
第一次   n-1    最后一个数确定
第二次    n-1-1=n-2    倒数第二个确定
。。。
第i次     n-i
例：列表中有五个数的话   那么n=5
第一次对比次数     4     最大的数确定
第二次对比次数     3     第二大的确定
第三次。。。。     2       三大
第四次             1     全部确定 
故总共对比n-1次      每次对比n-i次
"""
第一种，未进行优化：循环次数105
def input_num(s):
    count = 0
    for i in range(len(s) - 1):  # len(s)-1    就是n-1次       i的值是(0,（n-1))
        for j in range(len(s) - 1 - i):  # 由于i是可以为0的    第一次  i=0    故循环（n-i-1）次
            count += 1
            if s[j] > s[j + 1]:
                s[j + 1], s[j] = s[j], s[j + 1]
    print(count)
    print(s)


l = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
input_num(l)
第二种，优化：循环次数95
def func(l):
    b = 0
    for i in range(len(l) - 1):  # 这个循环负责设置冒泡排序进行的次数
        # （比如说n个数，则只要进行n-1次冒泡，就可以把这个n个数排序好，对吧）
        ex_flag = False  # 改进后的冒泡，设置一个交换标志位
        for j in range(len(l) - i - 1):
            b+=1
            if l[j] > l[j + 1]:
                ex_flag=True
                l[j], l[j + 1] = l[j + 1], l[j]

        if not ex_flag:
            break # 这里代表计算机偷懒成功 (〃'▽'〃)
    print(b)
    print(l)
#
#
l = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
func(l)

第三种，优化：循环次数77
def bubble_sort3(collection):
    """
    bubble_sort2的基础上再优化。
    优化思路：在排序的过程中，数据可以从中间分为两段，一段是无序状态，另一段是有序状态。
    每一次循环的过程中，记录最后一个交换元素的公交车，它便是有序和无序状态的边界
    下一次仅循环到边界即可，从而减少循环次数，达到优化。
    """
    compare_count=0
    length = len(collection)
    last_change_index = 0 #最后一个交换的位置
    border = length-1 #有序和无序的分界线
    for i in range(length-1):
        swapped = False
        # print(collection)

        for j in range(0,border):
            compare_count+=1
            if collection[j] > collection[j+1]:
                swapped = True
                collection[j], collection[j+1] = collection[j+1], collection[j]
                last_change_index = j
        if not swapped:
            break  # Stop iteration if the collection is sorted.

        border = last_change_index # 最后一个交换的位置就是边界

    print(f"总循环次数{compare_count}")
    return collection
l = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
print(bubble_sort3(l))
print("bubble_sort3 begin.")
unsorted = [3,4,2,1,5,6,7,8]
print("bubble_sort3 end:",*bubble_sort3(unsorted))

斐波那契数列

def f(s):
   a,b=0,1
    for i in range(s-1):
        a,b=b,a+b
    return a
print(f(10))

第二种:使用迭代器

class iterNext():
    def __iter__(self):
        self.a=0
        self.b=1
        self.count=0
        return self
    def __next__(self):
        self.count+=1
        if self.count==1:
            return self.a
        if self.count<=10:
            self.a,self.b=self.b,self.a+self.b
            return self.b
        else:
            raise StopIteration
myClass=iterNext()
myIter=iter(myClass)
for i in myIter:
    print(i)

#用一行代码计算0-100的值
第一种用reduce

from functools import reduce

print(reduce(lambda x, y: x + y, [i for i in range(1,101)]))

第二种用sum

print(sum(range(1,101)))

如果a=1,b=2,请问怎样是a,b的值进行交换

#第一种
a=1
b=2
a,b=b,a
#第二种
a=a+b
b=a-b
a=a-b
#第三种
c=a
a=b
b=c
#第四种   只针对二进制
a=a^b
b=a^b
a=a^b

按规律写出下一个数1, 11, 21, 1211, 111221

第一种:

def func(a):
    for i in range(9):
        li=[]
        temp=''
        for i in a:
            if temp=='':
                temp+=i
            else:
                if i ==temp[-1]:
                    temp+=i
                else:
                    li.append(temp)
                    temp=i
        else:
            if len(temp):
                li.append(temp)
        new_str = ''
        for j in li:
            new_str+=str(len(j))+j[0]

        a=new_str
        print(a)
func('1')

第二种:使用迭代器

class iterNext:
    def __iter__(self):
        self.a = '1'
        self.count = 0
        return self  # 创建一个特殊的迭代器对象,这个迭代器对象实现了__next__() 方法并通过 StopIteration 异常标识迭代的完成。

    def __next__(self):  # 返回下一个迭代器对象
        self.count += 1
        if self.count == 1:
            return self.a
        temp_list = []
        temp_str = ''
        for i in self.a:
            if temp_str == '':
                temp_str += i
            else:
                if i == temp_str[-1]:
                    temp_str += i
                else:
                    temp_list.append(temp_str)
                    temp_str = i
        else:  #for循环结束后执行这句，最后的temp需添加过去
            if len(temp_str):
                temp_list.append(temp_str)
        new_str = ''
        for j in temp_list:
            new_str += str(len(j)) + j[0]
        self.a = new_str
        if self.count <= 10:
            return self.a
        else:
            raise StopIteration  # 标志迭代完成


myClass = iterNext()
myIter = iter(myClass)
for i in myIter:
    print(i)

100个人围一圈编号1-100，依次开始报数报到3的退出

a = list(range(1, 101))
n = 3
while len(a) >= n:
    if n-2 >= 0:
        a = a[n:] + a[:n-1]
print(sorted(a))

第二种:

import copy


def func():
    li = [i for i in range(1, 101)]
    new_li = []
    while True:
        temp = copy.deepcopy(li)
        for i in range(1, len(temp) + 1):
            if i % 3 == 0:
                new_li.append(temp[i - 1])
                li.remove(temp[i - 1])
        s = len(temp) % 3
        for j in range(1, s + 1):
            li.remove(temp[-j])
            li.insert(0, temp[-j])
        if len(li) < 3:
            print(li)
            print(new_li)
            break


func()

包含n个整数的数组nums，判断nums中是否存在三个元素,a,b,c，使得a+b+c=0

def func(nums):
    t=[]
    s=[]
    for i in range(len(nums)):
        for j in range(i+1,len(nums)):
            for k in range(j+1,len(nums)):
                if nums[i]+nums[k]+nums[j]==0:
                    s.append(nums[i])
                    s.append(nums[j])
                    s.append(nums[k])
                    if sorted(s) not in t:
                        t.append(sorted(s))
                        t=copy.deepcopy(t)
                    s.clear()

    print(t)
func([0,1,-1,0,1,2,-1,-4,-3])

给一个数组，如果数组中有0，则在0后面追加一个0，整体的数组长度不变

第一种:

def func(nums):
    i=0
    while i<=len(nums):
        if nums[i]==0:
            nums.insert(i+1,0)
            nums.pop()
            print(nums)
            i+=2
        else:
            i+=1
    print(nums)
func([1,2,0,5,3,0,2])

第二种:

def func(index, nums):
    if index >= len(nums) - 1:
        return nums
    for i in range(index, len(nums)):
        if nums[i] == 0:
            nums.insert(i + 1, 0)  # 插入到指定索引位置
            nums.pop()  # 删除列表最后一位
            return func(i + 2, nums)  # 递归


print(func(0, [1, 2, 4, 0, 5, 0, 9, 6]))

英文单词全部都是以首字母大写，逐个反转每个单词

举例
输入：“MyNameIsTom”
输出：“yMemaNsImoT”

def func(str):
    l = []
    new_str = ''
    end_str = ''
    s = 0
    for i in range(len(str)):
        if str[i].isupper():  # 找到所有大写字母的索引
            l.append(i)
    print(l)
    for j in l:
        if s == j:
            pass
        else:
            new_str += str[s:j][::-1] # 找到一组单词并反转
            s = j
            end_str += new_str
            new_str = ''
    end_str += str[l[-1]:][::-1]  # 最后一组大写的
    print(end_str)


func("MyNameIsTom")

字符串消消乐，将字符串中相邻相同的字符一起消掉，最后输出消除完成的字符串

第一种:
示例1：abcccbxezzzrf7788fn
输出：axern
示例2：1jj11j1
输出：j1

def func(str):
    new_list = []
    del_str = ''  # 只有相邻元素一致(最少两个)才会添加到del_str
    for i in str:
        '''
        1.判断新生成的列表中是否有元素
            1)没有元素,判断是否有删除的元素
                (1).没有(代表是首次添加,第一个元素,即str[0]),就添加到列表中
                (2).有,查看i是否和删除元素一致
                    a.一致,那就下一个
                    b.不一致,添加到列表,并将new_str清空
            2)有元素
                (1)如果i和new_str一致,则继续往下走
                (2)如果new_list最后一位和i相等,则弹出最后一位,并将其赋值给new_str,这样下次循环,重新判断上一步
                (3)否则添加new_list,并将new_str清空
        '''
        if len(new_list) == 0:
            if del_str == '':  # 判断是否首次添加
                new_list.append(i)
            else:  # 不是首次添加,列表被删空了
                if i == del_str:
                    continue
                else:
                    new_list.append(i)
                    del_str = ''
        else:
            if i == del_str:
                continue
            elif i == new_list[-1]:
                del_str = new_list.pop(-1)
            else:
                new_list.append(i)
                del_str = ''
    new_str = ''
    for t in new_list:
        new_str += t
    print(new_str)


func('abcccbxezzzrf7788fn')
func('1jj11j1')

第二种:
示例1：abcccbxezzzrf7788fn
输出：axern
示例2：1jj11j1
输出：1j1

def func(str):
    new_str = ''
    m = len(str)
    i = 0
    t = []
    s = []
    while i < m - 1:
        if str[i] == str[i + 1]:
            for j in range(i + 1, m):
                if str[j] != str[i]:
                    s.append(i)
                    s.append(j - 1)
                    t.append(s)
                    t = copy.deepcopy(t)
                    s.clear()
                    i = j
                    break
        else:
            i += 1
    print(t)
    if len(t):
        if t[0][0] != 0:
            new_str += str[:t[0][0]]

        for k in range(len(t) - 1):
            new_str += str[t[k][1] + 1:t[k + 1][0]]

        q = str[t[-1][1] + 1:]
        new_str += q
        print(new_str)
        return func(new_str)
    else:
        return new_str


func('abcccbxezzzrf7788fn')
func('1jj11j1')

实现删除字符串中出现次数最少的字符

实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。
输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。

输入描述:
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。

输出描述:
删除字符串中出现次数最少的字符后的字符串。

输入例子:
abcdd

输出例子:
dd

def func(str):
    new_dict = {}
    new_str = ''
    end_str = ''
    for i in str:
        if i in new_dict.keys():  # new_dict.keys()   获取到所有的key 可迭代对象
            new_dict[i] += 1
        else:
            new_dict[i] = 1
    for j in new_dict.keys():
        if new_dict[j] == min(new_dict.values()):  # new_dict.values()   获取到所有的value值
            new_str += j  # 获取到出现次数最少的字符
    for t in new_str:
        end_str = str.replace(t, '')  # 删除出现次数最少的字符

    print(end_str)


func('abcssaces')

连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组

连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述：
连续输入字符串(输入2次,每个字符串长度小于100)
举例：
输入： abc
123456789
输出：
abc00000
12345678
90000000

def func():
    i=0
    while i <3:
        s = input('请输入字符串:')
        if len(s)<8:
            t=(8-len(s))*'0'
            m=s+t
            print(m)
        else:
            l=[]
            if len(s)%8==0:
                m=int(len(s)/8)
                for j in range(1,m+1):
                    l.append(s[(j-1)*8:j*8])
            else:
                t = int(len(s) / 8)
                for j in range(1, t + 1):
                    l.append(s[(j - 1) * 8:j * 8])
                h=s[t*8:]
                k = (8 - len(h)) * '0'
                m = h + k
                l.append(m)
            print(l)
        i+=1

func()

def func():
    i = 0
    new_str = ''
    while i < 3:
        input_str = input('请输入字符串:')
        s = len(input_str) % 8
        d_str = ''
        if s == 0:
            m = input_str
        else:
            m = input_str[:-s]
            d_str = input_str[-s:] + (8 - s) * str(0)
            if len(m) == 0:
                print(d_str)
                i += 1
                continue
        for k in m:
            if len(new_str) < 8:
                new_str += k
            else:
                print(new_str)
                new_str = k
        else:
            if len(new_str)==8:
                print(new_str)
                print(d_str)
        i+=1


func()
a = 'abd'
b = 'anhdeowsldkmxhyskdo'
c = 'snhuodjnsmwksoxindcrsdft'

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”
示例:
输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”
输入：strs = [“dog”,“racecar”,“car”]
输出：“”
解释：输入不存在公共前缀。

 def func(s):
    len_min = min(len(i) for i in s)  # 取出最小的字符串长度
    li = []
    for j in range(len_min):
        temp = ''
        for t in s:  # 将列表中字符串索引一致的放在一起
            if temp == '':
                temp = t[j]
            else:
                temp += t[j]
        li.append(temp)
    temp = ''
    for m in li:
        if len(set(m)) == 1:
            temp += m[0]
    if temp == '':
        print('""')

    print(temp)

def func(strs):
    s = min(strs, key=lambda s: len(s))
    new_list = []
    if len(strs) == 1:
        return strs[0]
    if len(s) == 1:
        new_list.append(s)
    else:
        for i in range(len(s)):
            new_list.append(s[0:i + 1])
    print(new_list)
    for j in sorted(new_list, reverse=True):
        count = 0
        for t in strs:
            if t[0:len(j)] == j:
                count += 1
        if count == len(strs):
            return j
    else:
        return ''
print(func(["flower","flower","flower","flower"]))

字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。 给定两个字符串，编写一个函数判定它们是否只需要一次(或者零次)编辑。

示例 1:

输入:
first = “pale”
second = “ple”
输出: True

示例 2:

输入:
first = “pales”
second = “pal”
输出: False

def func(str1,str2):
	m,n=len(str1),len(str2)
	if abs(m,n)>1:
		return False
	for i in range(min(m,n)):
		if str1[i]!=str2[i]:
			return str1[i:]==str2[i+1:] or str1[i+1:]==str2[i:] or str1[i+1:]==str2[i+1:]
	return True