几道笔试题

最近开始用python了，正好公司过段时间研发人员考试，整几个校招笔试题练手吧。

第一题

如何在排序数组中，找出给定数字出现次数？ 比如：{0,1,2,3,3,3,3,3,3,3,3,4,5,6,7,13,19}

解法非常多，但是要考虑最坏情况下也要有较好的性能，抓住排好序的属性。下面使用的是稍加修改的二分查找，两次二分分别找到上下界，直接相减即可。

def binFindUp(arr, key):
    low = 0
    high = len(arr) -1
    while(low < high): 
        print "%d,%d" % (low, high)
        mid = (low + high) / 2       
        if (arr[mid] <= key):
            low = mid
        else:
            high = mid - 1             
    return low               

def binFindDown(arr, key):
    low = 0
    high = len(arr) -1
    while(low < high): 
        print "%d,%d" % (low, high)
        mid = (low + high) / 2       
        if (arr[mid] >= key):
            high = mid
        else:
            low = mid + 1             
    return high    

第二题

如何计算两个有序整形数组的交集,比如：
a=0,1,2,3,4
b=1,3,5,7,9

由于求交集，交集一定是集合之间的运算，所以说a,b是集合，即它们本身不含重复元素，参考归并排序的方法即可。

def interset(a, b)
    i = 0
    j = 0
    c = []
    while i < len(a) and b < len(b):
        if a[i] == b[j]:
            c.add(a[i])
            i++
            j++
        else if a[i] > b[j]:
            i++
        else:
            j++
    return c

下面两题是评估字符串相似度的，在工程上都有广泛的应该用。解决思路基本一致，都用的动态规划的思想：

第三题

求最长公共子串

def lcs(str1, str2):
    dp = [[0 for col in range(len(str2) + 1)] for row in range(len(str1) + 1)]
    for i in range(1, len(str1) + 1):
        for j in range(1, len(str2) + 1):
            dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1] + (1 if str1[i-1] == str2[j-1] else 0))     
    return dp[len(str1)][len(str2)]

第四题

字符串编辑距离

def leven(str1, str2):
    dp = [[0 for col in range(len(str2) + 1)] for row in range(len(str1) + 1)]
    for i in range(0, len(str1) + 1):
        for j in range(0, len(str2) + 1):
            if i == 0 or j == 0:
                dp[i][j] = i + j
            else:           
                dp[i][j] = min(dp[i-1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + (0 if str1[i-1] == str2[j-1] else 1))     
    return dp[len(str1)][len(str2)]    

第五题

求无序数组的第n小值。如果排序再求，那么是nlgn的时间复杂度，下面是一个n的线性复杂度，可用来求最大值，最小值，中位数等。

def npos(lst, n):
    index = random.randint(0, len(lst) - 1)
    big = [l for l in lst if l > lst[index]]
    little = [l for l in lst if l < lst[index]]
    equal = [l for l in lst if l == lst[index]]
    if len(little) > n - 1:
        return npos(little, n)
    if len(little) <= n - 1:
        if len(little) + len(equal) >= n:
            return lst[index]
        return npos(big, n - len(little) - len(equal))