面试常见程序题python版——持续更新中

# coding:utf8
#冒泡排序
def bubble_sort(lists):
    count=len(lists)
    for i in range(0,count):
        for j in range(i,count):
            if lists[i]>lists[j]:
                t=lists[i]
                lists[i]=lists[j]
                lists[j]=t
    return lists
lists=[2,4,6,7,9]
print lists
#链表打印
def traversal(head):
    curNode=head
    while curNode is not None:
        print curNode.data
        curNode=curNode.next
#binary二分查找
def binary_find(find,lists):
    low=0
    high=len(lists)
    while low<=high:
        mid=(low+high)/2
        if lists[mid]==find:
            return mid
        elif lists[mid]>find:
            high=mid-1
        else:
            low=mid+1
    return -1
lists=[2,4,6,7,9]
print binary_find(9,lists)
#字符串逆序
s="hello"
li=list(s)
li.reverse()
print "".join(li)
#字典按value值逆序
d = {'a':1,'b':4,'c':2}
print  sorted(d.items(),key=lambda x:x[1],reverse=False)

#快速排序
def partition(v,left,right):
    key=v[left]
    low=left
    high=right
    while low<high:
        while (low<high)and(v[high]>=key):
            high -=1
        v[low]=v[high]
        while (low<high)and(v[low]<=key):
            low +=1
        v[high]=v[low]
        v[low]=key
    return low


def quick_sort(v,left,right):
    if left<right:
        p=partition(v,left,right)
        quick_sort(v,left,p-1)
        quick_sort(v,p+1,right)
    return v
v=[2,1,8,4,5,6]
v1=quick_sort(v,0,len(v)-1)
print v1

操作1：

m=s

s=s+s

操作2：

s=s+m

初始化：

s="a"

m=s

给定一个字符串长度n最少需要几次操作才能获得最后的结果

测试用例：

n=4 返回2

number = int(raw_input("Enter a number: "))
def test(number):

    r = []
    while number != 1:

        for i in range(1, number + 1):
            if (number % i) == 0 and i != 1:
                number = number / i
                if number == 1:
                    # print " %d" %i
                    r.append(i)
                else:
                    # print " %d*" %i,
                    r.append(i)
                break
    count = 0
    count1 = 0
    count2 = 0
    for i in r:
        if i == 2:
            count += 1
        elif i == 3:
            count1 += 2
        else:
            count2 += (i-1)
    return (count+count1+count2)
test(number)

KMP字符串匹配。给你两个字符串，寻找其中一个字符串是否包含另一个字符串，如果包含，返回包含的起始位置

思路：将两个字符串a，b转换成列表，以第二个字符串b的长度作为滑动窗口的长度进行滑动，将结果以字典形式存起来，key值是a列表下标，value值就是滑动窗口在a列表上获得的长度为len(b_list)子列表.

#KMP字符串匹配。给你两个字符串，寻找其中一个字符串是否包含另一个字符串，如果包含，返回包含的起始位置
def ngrams(input,n):
    output = {}
    for i in range(len(input)-n+1):
        output.setdefault(i,input[i:i+n])#{i:[]}
    return output
def find(a,b):
    a_list=list(a)
    b_list=list(b)
    n=len(b_list)
    a_dict=ngrams(a_list,n)
    for k,v in a_dict.items():
        if v==b_list:
            return k
        else:
            continue
    return -1
a=raw_input("a:")
b=raw_input("b:")
k=find(a,b)
print k