展开嵌套的list
def spread_list(lst):
'''
>>> spread_list([1, 3,[5, 6, [9, 10], [11,[12, [13, 14]]], 15]])
[1, 3, 5, 6, 9, 10, 11, 12, 13, 14, 15]
'''
return sum([spread_list(x) if type(x) is list else [x] for x in lst],[])
# [[1], [3], [[5], [6], [[9], [10]], [[11], [[12], [[13], [14]]]], [15]]]
print(spread_list([1, 3,[5, 6, [9, 10], [11,[12, [13, 14]]], 15]]))
艾氏筛法求质数
import itertools
def _odd_iter():
n =1
# while True:
# n = n+2
# yield n
return itertools.count(3,2)
def not_divisable(n):
return lambda x:x %n>0
def primes():
yield 2
it = _odd_iter()
while True:
n = next(it)
yield n
it = filter(not_divisable(n),it)
p = primes()
for t in range(10):
print(next(p))
求大于n的最小整数
import math
def get_prime_than(n):
if isprime(n+1):
return n+1
return get_prime_than(n+1)
def isprime(m):
if m <=1:
return False
for i in range(2,int(math.sqrt(m))+1):
if m % i == 0:
return False
return True
# l1 = filter(isprime,range(2,100))
# print(list(l1))
print(get_prime_than(101))
def bubble_sort2(ary):
n = len(ary)
for i in range(n):
flag = True #标记
for j in range(1,n-i):
if ary[j-1] > ary[j] :
ary[j-1],ary[j] = ary[j],ary[j-1]
flag = False
if flag : #全排好序了，直接跳出
break
return ary
不用循环和条件打印1~1000
import sys
sys.setrecursionlimit(1005)
def printnum(n):
print(n);
return (n-1000) and printnum(n+1);
printnum(1)
不同范围的随机数转换
def Rand3():
x = -1
while not 0 <= x < 3:
x = Rand5()
return x
def Rand7():
x = -1
while not 0 <= x < 21:
x = Rand5() * 5 + Rand5()
return x % 7
有两个序列a,b，大小都为n,序列元素的值任意整形数，无序；要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
原理：通过排序倒序找到每一个值last,通过sum大小判断放入small_list中，这其中有可能某个list先添加满，所以要判断length
def diff(sorted_list, length):
if not sorted_list:
return (([],[]))
last = sorted_list[-1]
big_list, small_list = diff(sorted_list[:-1],length)
big_list_sum = sum(big_list)
small_list_sum = sum(small_list)
if big_list_sum > small_list_sum:
if len(small_list) >= length:
big_list.append(last)
else:
small_list.append(last)
return ((big_list, small_list))
else:
if len(big_list) >= length:
small_list.append(last)
else:
big_list.append(last)
return ((small_list, big_list))
a = [1,13,4,9]
b = [3,44,800,700]
c= []
c.extend(a)
c.extend(b)
p = sorted(c,reverse=True)
w = diff(p, len(a))
print(w)
链表相加进位
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 0 -> 8
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
class Solution(object):
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
head = ListNode(0)
l = head
carry = 0
while l1 or l2 or carry:
v1 = v2 = 0
if l1:
v1 = l1.val
l1 = l1.next
if l2:
v2 = l2.val
l2 = l2.next
carry, val = divmod(v1+v2+carry, 10)
l.next = ListNode(val)
l = l.next
return head.next
链表成对调换
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
# @param a ListNode
# @return a ListNode
def swapPairs(self, head):
if head != None and head.next != None:
next = head.next
head.next = self.swapPairs(next.next)
next.next = head
return next
return head
合并两个有序列表
def loop_merge_sort(l1, l2):
tmp = []
while len(l1) > 0 and len(l2) > 0:
if l1[0] < l2[0]:
tmp.append(l1[0])
del l1[0]
else:
tmp.append(l2[0])
del l2[0]
tmp.extend(l1)
tmp.extend(l2)
return tmp
交叉链表求交点
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
def node(l1, l2):
length1, lenth2 = 0, 0
# 求两个链表长度
while l1.next:
l1 = l1.next
length1 += 1
while l2.next:
l2 = l2.next
length2 += 1
# 长的链表先走
if length1 > lenth2:
for _ in range(length1 - length2):
l1 = l1.next
else:
for _ in range(length2 - length1):
l2 = l2.next
while l1 and l2:
if l1.next == l2.next:
return l1.next
else:
l1 = l1.next
l2 = l2.next