python基本算法面试_python面试常用算法

展开嵌套的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