算法题

获取指定和的对应索引

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],5))

为何输出为6，6，6，6

def num():
    '''
    :param i=i  外面每循环一次就把i赋值一次   最后可以得到不同的值  如没有 则等外面的循环完毕 i就赋值一个固定的值 3
    :return: 返回的是一个列表推导式，里面是一个函数
    '''
    return [lambda x,i=i:i*x for i in range(4)]
if __name__ == '__main__':
    print([m(2) for m in num()])

当我们执行 m(2) 时，运行到num()内部函数，发现变量 i 并不是num()中的变量，于是就到外部函数num中寻找变量 i ，但此时外部的 for 已经循环完毕，最后的 i =3 。所以，每次

执行m(2)，i 的值都是 3 ，因此，最终结果会是 [6, 6, 6, 6]

生成器斐波那契

def fib(max):
    a,b = 0,1
    while max > 0:
        a,b = b,a+b
        max-=1
        yield a


for i in fib(10):
    print(i) 

迭代器斐波那契

class fibonacci(object):

    def __init__(self,n):
        
        self.n = n
        self.current = 0
        self.a = 0
        self.b = 1

    def __next__(self):
        if self.current < self.n:
            self.a,self.b = self.b,self.a+self.b
            self.current += 1
            return self.a

        else:
            raise StopIteration

    def __iter__(self):
        return self
            

fib = fibonacci(15)
for num in fib:
    print(num)

可迭代对象去重

class Solution():
    def isUnique(self,astr:str)->bool:
        mes_dict={}
        for i in astr:
            if mes_dict.get(i,""):
                return False
            else:
                mes_dict[i] =1
        return True

s=Solution()
print(s.isUnique('1233'))

回文数

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

示例1：

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

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

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

代码

def Palindrome():
    
    num = input()
    if num == num[::-1]:
        print('true')
    else:
        print('flase')
        print('从左向右读, 为 %s 。 从右向左读, 为 %s 。因此它不是一个回文数' % (num,num[::-1]))

队列实现栈

栈需要有四个方法

push(x) 入栈

pop() 移除栈顶元素

top() 获取栈顶元素

empty() – 返回栈是否为空

class Stack():


    def __init__(self):
        #初始化一个空列表
        self.stack = []
    
    def push(self,x):
        '''
        :param x :要添加的元素
        '''
        #列表尾部添加元素
        self.stack.append(x)
    
    def top(self):
        #获取列表尾部元素
        return self.stack[-1]

    def pop(self):
        #获取列表尾部元素并将这个元素从列表中删除
        return self.stack.pop()

    def empty(self):
        if not self.stack:  #如果列表中没有元素，返回True
            return True
        else:               #如果列表中有元素，返回False
            return False


#实例化一个栈
mystack = Stack()

#尾部添加
mystack.push(1)
mystack.push(2)

# 获取列表尾部元素
print(mystack.top())

#获取栈的尾部元素并将这个元素从栈中删除
print(mystack.pop())

#判断栈是否为空 空返回True 非空返回False
print(mystack.empty())

一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

a = [100]  #每个‘反弹落地’过程经过的路程，第1次只有落地（100米）
h = 100  #每个‘反弹落地’过程，反弹的高度，第1次为100米
print('第1次从%s米高落地，走过%s米，之后又反弹至%s米。' % (h, a[0], h/2))
for i in range(2,11):  #第1次已初始化，再循环9次
    a.append(h)  #先计算路程，再高度减半，因为一个‘反弹落地’为2个高度
    h = h / 2
    print('第%s次从%s米高落地，共走过%s米，之后又反弹至%s米。' % (i, h, sum(a), h / 2))

反转字符串中的单词

输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”

方法一

def reverseWords(s):
    l = s.split()
    for i in range(len(l)):
        l[i] = l[i][::-1]
    
    return ' '.join(l)

print(reverseWords("Let’s take LeetCode contest"))

方法二

def reverseWords(s):
    return " ".join(s.split()[::-1])[::-1]
print(reverseWords("Let’s take LeetCode contest"))