Python常见基础算法题

1.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数.

示例 1:
输入: 121
输出: true

示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

def is_num(num):
    '''
    判断传递的参数是否是回文数
    :param num: 传递的参数
    :return: 是回文数返回True 不是则false
    '''
    num1 = str(num)
    if num1[::-1] == num1:
        return True
    else:
        return False
if __name__ == '__main__':
    print(is_num(121))

2.分别用生成器和迭代器生成斐波那契

示例 1:

输出: 1 1 2 3 5 8 13

# 迭代器
class FibIterator(object):
    def __init__(self,n):
        """实例属性的初始花和赋值"""
        self.n = n      #  数列长度
        self.current = 0    #  设置两个初始值
        self.num1 = 0
        self.num2 = 1   #  初始下标

    def __next__(self):
        """返回迭代器对象的下一位置数据"""
        # 能拿到数据的情况
        if self.current < self.n:
            num = self.num1
            self.num1,self.num2 = self.num2,self.num1+self.num2
            self.current+=1
            return num
        # 拿不到数据的情况
        else:
            raise  StopIteration    #主动抛出异常

    def __iter__(self):
        return self

if __name__ == '__main__':
    fib = FibIterator(10)
    for num in fib:
        print(num)

 # 生成器
def fib(n): # 创建一个函数
    num1,num2 = 1,1
    current = 1    # 初始值
    while current <= n:    # i小于等于n，n次数 循环的控制条件
        yield num1    # 返回a的值，但不结束函数
        num1,num2 = num2 , num1 + num2
        current += 1     # 步长值
for x in fib(10):    # 以for循环来获取yield每次的值
    print(x)

3.字符串相乘：给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式

示例 :
输入: num1 = “123”, num2 = “456”
输出: “56088”

def Func(num1,num2):
    alist1 = ''
    alist2 = ''
    for i in num1:
        if i.isdigit():
           alist1 += i
    for j in num2:
        if  j.isdigit():
            alist2 += j
    str1=str(int(alist1) * int(alist2 ))
    return str1
if __name__ == '__main__':
    print(Func('11qq','zz99xx'))

4.实现一个算法来实现反转字符数组的功能,反转的要求如下：将字符数组的字符进行反转,例如 [‘b’, ’ ', ‘a’, ‘r’],变成 [‘r’, ‘a’, ’ ', ‘b’] , 将字符数组替换为反转后的数组。

解题思路：

常规的解法是创建一个相同长度的新数组，
然后把第一个数组中的元素，按倒序放入新数组中。
但更简单的方法是：利用 Python 交换变量的特性，
不需要新建数组，直接在原数组里即可完成

def reverse(self, chars):
    if chars:
        size = len(chars)
        for i in range(size // 2):
            chars[i], chars[size - 1 - i] = chars[size - 1 - i], chars[i]
        return chars
print(reverse('h','a'))

5.栈：也称下压栈，堆栈，是仅允许在表尾进行插入和删除操作的线性表,

特点：先进后出 后进先出

class Stack(object):
    def __init__(self):
        """初始化"""
        self.stack = []

    def push(self,item):
        """push(item)添加一个新的元素item到栈顶"""
        self.stack.append(item)

    def pop(self):
        """pop()弹出栈顶元素"""
        if self.stack == []:
            return None
        else:
            self.stack.pop()

    def peek(self):
        """peek()返回栈顶元素"""
        if self.stack == []:
            return None
        else:
            return self.stack[-1]

    def isEmpty(self):
        """is_empty()判断栈是否为空"""
        return self.stack == []

    def size(self):
        """size()返回栈的元素个数"""
        return len(self.stack)

if __name__ == '__main__':
    stack = Stack()
    stack.push(1)
    stack.pop()
    print(stack.peek())
    print(stack.isEmpty())
    print(stack.size())

6.队列：是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

特点：先进先出 后进后出

class Queue(object):
    def __init__(self):
        """实例属性的初始化和赋值创建一个空的队列"""
        self.queue = []

    def enqueue(self,item):
        """往队列中添加一个item元素"""
        self.queue.append(item)

    def is_empty(self):
        """判断一个队列是否为空"""
        return self.queue==[]

    def dequeue(self):
        """从队列头部删除一个元素"""
        if self.queue==[]:
            return None
        else:
            return  self.queue.pop(0)

    def size(self):
        """返回队列大小"""
        return  len(self.queue)
if __name__ == '__main__':
    q=Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    q.enqueue(4)
    q.enqueue(5)
    print(q.is_empty())
    print("长度为：",q.size())
    print(q.dequeue())

7.去掉空格

def get_num(par_str):
    """
    :param par_str: 字符串
    :return: num
    """
    par_list = par_str.split(' ')

    print([i for i in par_list if i])
    for i in par_list:
        if "" in par_list:
            par_list.remove("")
    print(par_list)
if __name__ == '__main__':
    get_num('hello, python   hello ,   world')

8.两数之和

方法1：

def get_num_index(llist,target):
       '''
       :param target: 俩个下标值的和
       :param llist: 查看下标所用的列表
       :return: 返回符合条件的两个下标值
       '''
       y = 0
       for x,val in enumerate(llist):
           y += 1
           if llist[x] +llist[y]==target:
               return (x,y)
if __name__ == '__main__':
   print(get_num_index([1,2,3,4,5,6],7))

方法2：

def get_num_index(llist, target):
            '''
            :param target: 给定值
            :param llist: 查看条件列表
            :return: 返回符合条件的下标值
            '''
            for i in llist:
                y = target - i
                if y != 0:
                    if y in llist:
                        if llist.index(i) == llist.index(y):
                            break
                        # if llist.index(i) <= llist.index(y):
                        return llist.index(y), llist.index(i)
                else:
                    return llist.index(i)

if __name__ == '__main__':
    print(get_num_index([1, 2, 3, 4, 5, 6,13],13))

9.比较：取值第三个大的数

def func(num):
    if len(num)>=3:
        alist=[]
        for i in sorted(num):
            try:
                alist.index(i)
            except:
                alist.append(i)
        return alist[-3]
    else:
        return -1
if __name__ == '__main__':
    num=[8,7,4,2,1,6,2,1,1,8]
    print(func(num))

10.反转字符数组

# 反转字符串
def reverseString(s):
    s[0::] = s[::-1]
    print(s)


if __name__ == "__main__":
    reverseString(['b', '', 'a', 'r'])

本文地址：https://blog.csdn.net/weixin_47587864/article/details/107163406