时间空间效率的平衡（1-4）--re

最新推荐文章于 2024-09-15 21:58:12 发布

qq_turn

最新推荐文章于 2024-09-15 21:58:12 发布

阅读量155

点赞数

分类专栏：剑指offer--知识点

本文链接：https://blog.csdn.net/qq_38441207/article/details/89282218

版权

剑指offer--知识点专栏收录该内容

22 篇文章 0 订阅

订阅专栏

题目描述1：丑数

把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

python测试：

// An highlighted block
import sys

def isUglyNumber(num):
    if num<=0:
        return False
    elif num>=1:
        for i in [2,3,5]:
            while num%i==0:
                num = num / i
        if num == 1:
            return True
        else:
            return False

def getUglyNumber(N):
    count = 0
    if N<=0:
        return 0
    else:
        num = 1
        while (count<N):
            if isUglyNumber(num) == True:
                count = count + 1
            num = num + 1
    return num-1

if __name__ == '__main__':
    try:
        while True:
            arr = int(input())
            print(getUglyNumber(arr))
    except:
        pass

题目描述2：第一个只出现一次的字符

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.

python测试：

// An highlighted block
class Solution:
    def FirstNotRepeatingChar(self,s):
        if len(s)< 0:
            return -1
        for i in s:
            if s.count(i)==1:
                return s.index(i)
                break
        return -1

if __name__ == '__main__':
    a = Solution()
    b = [1,1,1,2,3]
    print(a.FirstNotRepeatingChar(b))

题目描述3：数组中的逆序对

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

Python测试：

// An highlighted block
class Solution:
    def InversePairs(self,data):
        return self.inverseCount(data[:],0,len(data)-1,data[:])%1000000007

    def inverseCount(self,tmp,start,end,data):
        if end-start <1:
            return 0
        if end - start == 1:
            if data[start]<=data[end]:
                return  0
            else:
                tmp[start],tmp[end] = data[end], data[start]
                return 1
        mid = (start+end)//2
        cnt = self.inverseCount(data,start,mid,tmp) + self.inverseCount(data,mid+1,end,tmp)

        i = start
        j = mid + 1
        ind = start

        while(i <= mid and j <= end):
            if data[i] <= data[j]:
                tmp[ind] = data[i]
                i += 1
            else:
                tmp[ind] =data[j]
                cnt += mid - i +1
                j += 1
            ind += 1
        while(i<=mid):
            tmp[ind] = data[i]
            i += 1
            ind += 1
        while(j<end):
            tmp[ind] = data[j]
            j += 1
            ind += 1
        return cnt


if __name__ == '__main__':
    s = Solution()
    seq = [7,5,6,4]
    print(s.InversePairs(seq))