剑指offer之Python练习一

1.在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        n = len(array)
        flag = 'false'
        if array == [[]]:
            return flag
        i = n-1
        j = 0
         
        while i >= 0 and j <= n-1:
            if target < array[i][j]:
                i = i - 1
            elif target > array[i][j]:
                j = j + 1
            else:
                flag = 'true'
                break
        return flag
     
while True:
    try:
        S = Solution()
        L = list(eval(raw_input()))
        array = L[1]
        target = L[0]
        print(S.Find(target,array))
    except:
        break

2. 请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        s=s.split(' ')
        return '%20'.join(s)

3. 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。

class Solution:
    def Fibonacci(self, n):
        # write code here
        a,b=0,1
        s=0
        if n <= 1:
            return n
        while n>1:
            s=a+b
            a=b
            b=s
            n-=1
        return s

4. 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution:
    def jumpFloor(self, number):
        # write code here
        a,b=1,2
        s=0
        if number <= 2:
            return number
        while number > 2:
            s=a+b
            a=b
            b=s
            number-=1
        return s

5. 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution:
    def jumpFloorII(self, number):
        # write code here
        if number <= 1:
        	return number
        else:
            return 2**(number-1)

6. 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

class Solution:
    def rectCover(self, number):
        # write code her
        a,b=1,2
        s=0
        if number <= 2:
            return number
        while number > 2:
            s=a+b
            a=b
            b=s
            number-=1
        return s

7. 输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

class Solution:
    def NumberOf1(self, n):
        # write code here
        if n >= 0:
            return bin(n).count('1')
        else:
            n=n&0xFFFFFFFF #把负号去掉
            return bin(n).count('1')

8. 给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

class Solution:
    def Power(self, base, exponent):
        # write code here
        if base == 0:
            return 0
        elif base == 1:
            return 1
        elif exponent == 0:
            return 1
        elif exponent == 1:
            return base
        else:
            return pow(base, exponent)

9. 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

class Solution:
    def reOrderArray(self, array):
        # write code here
        tmp1=[]
        tmp2=[]
        for i in array:
            if i%2==0:
                tmp2.append(i)
            else:
                tmp1.append(i)
        tmp1.extend(tmp2)
        return tmp1

10. 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        if matrix == [[]]:
            return []
        if len(matrix)==1:
            return matrix[0]
        target = []
        while(1):
            target.extend(matrix[0])
            del matrix[0]
            if len(matrix) == 0:
                break
            temp = []
            for j in range(1,len(matrix[0])+1):
                temp.append([m[-j] for m in matrix])
            
            matrix = temp
        return target

11. 输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

class Solution:
    def Permutation(self, ss):
        # write code here
        import itertools
        if not ss:
        	return []
        return sorted(list(set(map(''.join, itertools.permutations(ss)))))

12. 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        for i in list(set(numbers)):
            if numbers.count(i)>len(numbers)/2:
                return i
        return 0