python 面试题目嗯哼

1.不用运算符计算加法

    def Add(self, num1, num2):
        # write code here
        l=[]
        l.append(num1)
        l.append(num2)
        return sum(l)

class Solution {
public:
	int Add(int num1, int num2)
	{
		return num2 > 0 ? Add(num1^num2, (num1&num2) << 1) : num1;
	}
};

class Solution: 
    def Add(self, num1, num2):           
        while(num2): 
            num1,num2 = (num1^num2) & 0xFFFFFFFF,((num1&num2)<<1) & 0xFFFFFFFF
        return num1 if num1<=0x7FFFFFFF else ~(num1^0xFFFFFFFF)

思路：
求和过程分为两部：求各位上的值，求进位值。然后将这两个数当作两个加法项递归进行直到进位制为0.如7 + 5：
各位值2，进位值10， 下一次分别为12，0递归结束，结果为12.
这里要按二进制处理，二进制数求各位值是异或：0111 ^ 0101 = 0010,求进位值是与操作再左移一位。(0111 & 0101)<<1=1010.
然后更新两个加法项0010，1010–》0010^1010=1000, (0010&1010)<<1=0100–> (1000 ^ 0100)=1100, (1000& 0100)=0,递归结束，
结果为1100.

2.python实现 -十进制转二进制

def decToBin(dec_value):
    bin_value =''
    if dec_value > 1:
        decToBin(dec_value//2)
    print(dec_value % 2,end = '')

二转十

def bin2dec(string_num):
    return str(int(string_num, 2))

3.二叉树求深度

class TreeNode:
	def __init__(self,x):
		self.val = x
		self.left = None
		self.right = None
def maxDepth(self, root):
        if not root:
            return 0
        left = self.maxDepth(root.left)+1
        right = self.maxDepth(root.right)+1
        return max(left, right)

def minDepth(self, root):
        if root is None
        	return 0
        if root.left is None
        	return self.minDepth(root.right)+1
        if root.right is None
        	return self.minDepth(root.left)+1
        leftDepth=self.minDepth(root.left)+1
        rightDepth=self.minDepth(root.right)+1
        return self.min(leftDepth,rightDepth)

4.不用中间变量交换两个数

a = a+b
b = a-b
a = a-b

a = a^b
b = a^b
a = a^b

5.数组中出现超过数组一半的数字
建立字典 o(n) o(n)

def findnum(self,numbers):
	dict={}
	for num in numbers:
		dict[num] = 1 if num not in dict else dict[num]+1
		if dict[num] > len(numbers)/2:
			return num
	return 0

快排 找中位数 o(nlogn) o(1)

def quick_sort(array,start,end):
    if(start >= end):
        return array
    left = start
    right = end
    mid = array[left]
    while left < right:
        while array[right] >= mid and left < right:
            right -= 1
        array[left] = array[right]
        while array[left] <= mid and left < right:
            left  += 1
        array[right] = array[left]
    array[left] = mid
    quick_sort(array,start,left-1)
    quick_sort(array,left+1,end)

def findnum(numbers):
    quick_sort(numbers,0,len(numbers)-1)
    left =0
    right = len(numbers) -1
    mid = left + (right - left)//2
    possible_ans = numbers[mid]
    times = 0
    for i in numbers:
        if i == possible_ans:
            times += 1
    if times*2 < len(numbers):
        possible_ans = 0
    return possible_ans

判断素数

def isprime(n):
    if n < 2: return False
    for i in range(2,int(math.sqrt(n))+1):
        if n % i == 0:
            return False
    return True

字符串反转

def rev(s):
    return s[::-1]

def rev2(s):
    l = list(s)
    l.reverse()
    result ="".join(l)
    return l

def func(s):     #递归
    if len(s) < 1:
        return s
    return func(s[1:]) +s[0]

def func2(s): #栈
    l = list(s)
    result = ""
    while len(l) >0:
        result += l.pop()
    return result

def fun3(s): #for
    result = ""
    max_index = len(s) -1
    for index,value in enumerate(s):
        result += s[max_index-index]
    return result

判断回文

if (num[::-1] == num[:])

递归与非递归实现 n!

def fact(n):
    if n==1 or n==0:
        return 1
    else:
        return fact(n-1)*n

def fact2(n):
    m =1
    if n==1 or n==0:
        return 1
    else:
        for i in range(1,n+1):
            m = m*i
    return m

二分

def bin_search(alist,num):
    n = len(alist)
    if n >0:
        mid = n//2
        if alist[mid] == num:
            return True
        elif num < alist[mid]:
            return bin_search(alist[:mid],num)
        else:
            return bin_search(alist[mid+1:],num)
    return False

def bin_search2(alist,num):
    n = len(alist)
    left =0
    right = n-1
    while left <= right:
        mid = right +(right - left)//2
        if alist[mid] == num:
            return True
        elif num < alist[mid]:
            right = mid -1
        else:
            left = mid +1
    return False

树的遍历创建和查找

手电筒过河

分析一下：
那么这时将单独过河所需要时间最多的两个旅行者送到对岸去，有两种方式:

最快的(即所用时间t[0])和次快的过河，然后最快的将船划回来，再次慢的和最慢的过河，然后次快的将船划回来
最快的和最慢的过河,然后最快的将船划回来，再最快的和次慢的过河，然后最快的将船划回来。
这样就将过河所需时间最大的两个人送过了河，而对于剩下的人，采用同样的处理方式，接下来做的就是判断怎样用的时间最少

方案1所需时间为:t[0]+2*t[1]+t[i-1]
方案2所需时间为:2*t[0]+t[i-2]+t[i-1]

def time_sesult(n,time): #先排序
    if n<=2 :
        return time[n-1]
    elif n==3 :
        return time[0] + time[1] + time[2]
    else:
        return time_sesult(n-2) + math.min(time[n-1]+2*time[0]+time[n-2],time[0]+2*time[1]+time[n-1])

编辑距离

def edit_distance(word1, word2):
    len1 = len(word1)
    len2 = len(word2)
    dp = np.zeros((len1 + 1,len2 + 1))
    for i in range(len1 + 1):
        dp[i][0] = i    
    for j in range(len2 + 1):
        dp[0][j] = j
     
    for i in range(1, len1 + 1):
        for j in range(1, len2 + 1):
            delta = 0 if word1[i-1] == word2[j-1] else 1
            dp[i][j] = min(dp[i - 1][j - 1] + delta, min(dp[i-1][j] + 1, dp[i][j - 1] + 1))
    return dp[len1][len2]

最大子序列