关于算法
def num():
return [lambda x: i*x for i in range(4)]
print([m(2) for m in num()]) # 输出: [6, 6, 6, 6]
思路：
这题涉及到了闭包延时绑定，当循环执行完了之后才会执行传参，循环四次，每一次循环完 i=3 然后再和x相乘 所以结果是6，6，6，6。 如果把 [ lambda x: ix for i in range(4) ] 改成 （ lambda x: ix for i in range(4) ）这样就变成了一个生成器 自动实现迭代器协议，一边循环一边计算的机制， 这样结果就是 0，2，4，6.
两数之和
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
思路：
这里可以使用字典来解题，通过enumerate方法遍历获取数据的下标包括对应值，然后以key，value形式把该数据的下标和对应值存入字典，然后再出通过enumerate方法遍历数据，每一次获取数据就从字典拿出一个值，用目标值减去从字典拿出的这个值得到一个结果值，如果结果值存在字典当中，那么返回两个数的下标，如果为None，说明字典中没有这个值。
实现代码：
def get_index_list(nums, target):
# Todo 作为一个方法来实现，批量解决这个获取索引的问题
"""
:params nums：传的参数的列表
:params target: 目标值
:return: 返回索引
"""
dic = {}
for a, b in enumerate(nums): # a是下标 b是对应值
dic[b] = a # 对应值存入字典
for i, b in enumerate(nums):
j = dic.get(target-b) # 从字典中拿出对应值 用目标值减去对应值
if j is not None: # 判断如果减去的对应值不为空，则返回下标
return [i, j]
数组中重复的数字
示例：
输入:
[2,3,1,0,2,5,3]
输出: 2 或 3
思路：
实现代码：
def get_number(nums):
"""
:params nums：传的参数的数组
:return: 返回重复数字
"""
nub = []
for i in nums:
if nums.count(i) >= 2:
if str(i) not in nub:
nub.append(str(i))
print('或'.join(nub))
if __name__ == "__main__":
get_number([2, 3, 1, 0, 2, 5, 3])
队列实现一个栈
思路：
使用一个队列，实现栈的一些基本操作，栈（后进先出）的特性。
实现代码：
# 队列实现一个栈 （栈：后进先出）
class Stack(object):
def __init__(self):
# 定义一个队列
self.lst = []
def is_None(self):
# 判断栈是否为空 返回 ture false
return self.lst == []
def push(self, i):
# 加入元素
self.lst.append(i)
def pop(self):
# 出栈
return self.lst.pop()
def stack_top(self):
# 返回栈顶元素
return self.lst[-1]
def size(self):
# 栈的大小
return len(self.lst)
if __name__ == "__main__":
stack = Stack()
print(stack.is_None())
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.lst)
print(stack.pop())
print(stack.stack_top())
print(stack.size())
回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例1：
输入: 121
输出: true
示例2：
输入: -121
输出: false
解释: 从左向右，为 -121 。 从右向左读，为121- 。 因此它不是一个回文数
示例3：
输入: 10
输出: false
解释: 从右向左读，为 01 。 因此它不是一个回文数
思路：
这题可以使用字符串 双指针的方法 将数据转化为字符串 首先定义好第一个元素下标和最后一个元素下标，while循环 只要条件不满足 一直循环 循环判断第一个和最后一个元素是否相等 不相等返回false 相等继续循环，如果循环条件满足之后都相等，返回 false
实现代码：
def palindromic_number(x):
"""
:params x：传的参数的列表
:return: 返回Ture False
"""
lst = list(str(x))
print(lst)
L, R = 0, len(lst)-1
while L <= R:
print(L, R)
if lst[L] != lst[R]:
return False
L += 1
R -= 1
return True
if __name__ == "__main__":
print(palindromic_number(1231))
分别用生成器和迭代器生成斐波那契数列
示例：
输出: 1 1 2 3 5 8 13
# 使用迭代器生成斐波那契数列
class Fibonacii(object):
def __init__(self,all_num):
self.all_num = all_num
self.cur_idx = 0
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
if self.cur_idx >= self.all_num:
raise StopIteration
ret = self.a
self.a, self.b = self.b, self.a + self.b
self.cur_idx += 1
return ret
fibo = Fibonacii(10)
for i in fibo:
print(i)
# 使用生成器生成斐波那契数列
def fibnacii(count):
num = 0
a, b = 0, 1
while num < count:
yield a
a, b = b, a+b
num += 1
fi = fibnacii(10)
for i in fi:
print(i)
反转字符数组
思路：
直接使用反转
实现代码：
# 反转字符串
def reverseString(s):
s[0::] = s[::-1]
print(s)
if __name__ == "__main__":
reverseString(['b', '', 'a', 'r'])
# 一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
# 思路
# 根据题意， 需要计算10次反弹的距离， 所以进行循环10次， 但是第一次他是直接落下去距离为100米，如果他是第一次落下去就把第一次距离添加到
# 列表中， 因为落下去弹回来是之前距离的一半， 所以需要除以二来计算距离， 知道循环结束， 然后统计10次的总和， 此时height的高度为第10次的高度
def ballBounce():
height = 100
ball_bounce = []
# num = 0
# while num < 10:
# if num == 0:
# ball_bounce.append(height)
# else:
# ball_bounce.append(height*2)
# height = height / 2
# num += 1
# return sum(ball_bounce), height
for i in range(10):
if i == 0:
ball_bounce.append(height)
else:
ball_bounce.append(height*2)
height = height / 2
print(sum(ball_bounce))
print(height)
# if __name__ == '__main__':
# ballBounce()
# print(ballBounce())
# 冒泡排序
def bubbleSort(arr):
n = len(arr)
# 遍历所有数组元素
for i in range(n):
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
arr = [64, 34, 25, 12, 22, 11, 90]
if __name__ == '__main__':
bubbleSort(arr)
print(arr)
for i in arr:
print(i)
# "Let's take LeetCode contest"
# 输出: "s'teL ekat edoCteeL tsetnoc"
# 思路
# 先把字符串按照空格切割(字符串切割后变成列表)，把切割后的列表进行反转 输出 ['contest', 'LeetCode', 'take', "Let's"] 类型为list
# 反转后的列表按照空格进行拼接， 然后进行反转 输出 s'teL ekat edoCteeL tsetnoc
s = "Let's take LeetCode contest"
a = s.split(' ')[::-1]
b = ' '.join(a)
c = b[::-1]
print(a)
print(b)
print(c)
#
# def reverseStr(s):
# return ' '.join(s.split(' ')[::-1])[::-1]
# if __name__ == '__main__':
# print(reverseStr(s))
