01-查找排序编程题

1. 给两个字符串s和t，判断t是否为s的重新排列后组成的单词。
   s = “anagram”, t = “nagaram”, return true.
   s = “rat”, t = “car”, return false

# function 1  O(nlogn)  排序
def func1(s, t):
	s = list(s)
	t = list(t)
	s.sort()
	t.sort()
	return s == t
	
# function 2  O(nlogn)  排序
def func2(s, t):
	return sorted(s) == sorted(t)
	
# function 3  O(n)      计数
def func3(s, t):
	dict1 = dict()
	dict2 = dict()
	for i in s:
		dict1[i] = dict1.get(i, 0) + 1
	for j in t:
		dict2[j] = dict2.get(j, 0) + 1
	return dict1 == dict2

2. 给定一个m*n的二位列表，查找一个数是否存在。列表有下列特性：
   每一行的列表从左到有已经排序好。
   每一行第一个数比上一行最后一个数大。
   [
   [ 1, 3, 5, 7],
   [10, 11, 16, 20],
   [23, 30, 34, 50]
   ]

# function 1 O(n^2)
def func1(matrix, target):
	for line in matrix:
		if target in line:
			return True
	return False

# function 2  O(logn)
def func2(matrix, target):
	h, w = len(matrix), len(matrix[0])
	'''
	0,1,2
	3,4,5
	6,7,8
	'''
	if h == 0:
		return False
	if w == 0:
		return False
		
	left = 0
	right = w * h - 1
	while left <= right:
		mid = (left + right)
		i = mid // w
		j = mid % w
		if matrrix[i][j] == target:
			return True
		elif matrix[i][j] > target:
			right = mid - 1
		else:
			left mid + 1
	else:
		return False

3. 给定一个列表和一个整数，设计算法找到两个数的下标，使得两个数之和为给定的整数。保证肯定仅有一个结果。
   例如，列表[1,2,5,4]与目标证书3， 1+2=3,结果为（0,1）。

## list 是有序的
def binary_search(li, left, right, target):
	while left <= right:
		mid = (left+right) // 2
		if li[mid] == target:
			return mid
		elif li[mid] > target:
			right = mid - 1
		else:
			left = mid + 1
	else:
		return None
	
def func(li, target):
	for i in range(len(li)):
		a = li[i]
		b = target - a
		if b >= a:
			j = binary_search(li, i+1, len(li)-1, b)
		else:
			j = binary_search(li, 0, i-1, b)
	return sorted([i, j])

## list 是无序的
def binary_search(li, left, right, target):
	while left <= right:
		mid = (left+right) // 2
		if li[mid][0] == target:
			return mid
		elif li[mid][0] > target:
			right = mid - 1
		else:
			left = mid + 1
	else:
		return None
	
def func(li, target):
	new_li = [[val, index] for index, value in li]
	new_li.sorted(key=lambda x:x[0])
	
	for i in range(len(li)):
		a = li[i][0]
		b = target - a
		if b >= a:
			j = binary_search(new_li, i+1, len(li)-1, b)
		else:
			j = binary_search(new_li, 0, i-1, b)
	return sorted([new_li(i)[i], new_li(j)[j]])
### O(nlogn)