编程能力提升_16

 

 

 

1.给出一个字符串数组words组成的一本英语词典。从中找出最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。若其中有多个可行的答案，则返回答案中字典序最小的单词。

若无答案，则返回空字符串。

示例 1:

输入: 
words = ["w","wo","wor","worl", "world"]
输出: "world"
解释: 
单词"world"可由"w", "wo", "wor", 和 "worl"添加一个字母组成。

示例 2:

输入: 
words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
输出: "apple"
解释: 
"apply"和"apple"都能由词典中的单词组成。但是"apple"得字典序小于"apply"。

class Solution:
    def longestWord(self, words: List[str]) -> str:
        words.sort()
        sets=set()
        retr=''
        for i in words:
            if len(i)==1 or i[:-1] in sets:
                if len(retr)<len(i):
                    retr=i
                sets.add(i)
        return retr

2.给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。

我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。

如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

示例 1:

输入: 
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释: 
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。

示例 2:

输入: 
nums = [1, 2, 3]
输出: -1
解释: 
数组中不存在满足此条件的中心索引。

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        if nums==[]:
            return -1
        sums=sum(nums)
        count=0
        for i in range(len(nums)):            
            if count==sums-count-nums[i]:
                return i
            else:
                count+=nums[i]
        return -1

3.自除数 是指可以被它包含的每一位数除尽的数。

例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。

还有，自除数不允许包含 0 。

给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除数。

示例 1：

输入： 
上边界left = 1, 下边界right = 22
输出： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]

class Solution:
    def selfDividingNumbers(self, left: int, right: int) -> List[int]:
        retr=[]
        for i in range(left,right+1):
            temp=str(i)
            if '0' not in temp:
                flag=True
                for s in temp:
                    if i%int(s)!=0:
                        flag=False
                        break
                if flag:
                    retr.append(i)
        return retr

4.给定一个只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。

数组里字母的顺序是循环的。举个例子，如果目标字母target = 'z' 并且有序数组为 letters = ['a', 'b']，则答案返回 'a'。

示例:

输入:
letters = ["c", "f", "j"]
target = "a"
输出: "c"

输入:
letters = ["c", "f", "j"]
target = "c"
输出: "f"

class Solution:
    def nextGreatestLetter(self, letters: List[str], target: str) -> str:
        for i in range(len(letters)):
            if letters[i]>target:
                return letters[i]
            elif i==len(letters)-1:
                return letters[0]

5.数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost[i](索引从0开始)。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

示例 1:

输入: cost = [10, 15, 20]
输出: 15
解释: 最低花费是从cost[1]开始，然后走两步即可到阶梯顶，一共花费15。

 示例 2:

输入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出: 6
解释: 最低花费方式是从cost[0]开始，逐个经过那些1，跳过cost[3]，一共花费6。

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        #因为最终要爬出去，所以step的长度len(cost)+1
        step = [0 for i in range(len(cost)+1)]
        for j in range(2,len(cost)+1):
            step[j] = min(step[j-1]+cost[j-1], step[j-2]+cost[j-2])
        return step[-1] 

class Solution(object):
    def minCostClimbingStairs(self, cost):
        """
        :type cost: List[int]
        :rtype: int
        """
        #到达当前台阶时判断下从前一个台阶过来省事，还是从前一个的前一个过来省事，
        #一直累加到最后一个台阶完，最小值就是最省体力的。 
        #用p1和p2表示前两个和前一个台阶所耗费的体力，一遍循环就可以了
        p1,p2 = 0, 0
        for i in range(2, len(cost)+1):
            p1,p2 =p2, min(p2 + cost[i-1], p1 + cost[i-2])
        return p2

6.在一个给定的数组nums中，总是存在一个最大元素 。

查找数组中的最大元素是否至少是数组中每个其他数字的两倍。

如果是，则返回最大元素的索引，否则返回-1。

示例 1:

输入: nums = [3, 6, 1, 0]
输出: 1
解释: 6是最大的整数, 对于数组中的其他整数,
6大于数组中其他元素的两倍。6的索引是1, 所以我们返回1.

 

示例 2:

输入: nums = [1, 2, 3, 4]
输出: -1
解释: 4没有超过3的两倍大, 所以我们返回 -1.

class Solution:
    def dominantIndex(self, nums: List[int]) -> int:
        if len(nums)==1:
            return 0
        sort=sorted(nums)
        if sort[-2]*2<=sort[-1]:
            return nums.index(sort[-1])
        return -1

class Solution(object):
    def dominantIndex(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums)==1:
            return 0
        index=0
        maxnum=float('-inf')
        minum=float('-inf')
        for i in range(len(nums)):
            if nums[i]>maxnum:    
                index=i
                maxnum,minum=nums[i],maxnum
            elif nums[i]>minum:
                minum=nums[i]
        if maxnum>=minum*2:
            return index
        return -1

7.

 

 

8.

 

 

9.