Python算法练习6.18

leetcode 1431 拥有最多糖果的孩子

给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。

对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。

输入：candies = [2,3,5,1,3], extraCandies = 3
输出：[true,true,true,false,true] 
解释：
孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。
孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。
孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。

class Solution(object):
    def kidsWithCandies(self, candies, extraCandies):
        """
        :type candies: List[int]
        :type extraCandies: int
        :rtype: List[bool]
        """
        childNum = len(candies)
        maxCandy = 0
        list = []
        for i in range(childNum):
            maxCandy = max(candies[i], maxCandy)
        for i in range(childNum):
            list.append(candies[i] + extraCandies >= maxCandy)
        return list

有点过于简单

leetcode 605 种花问题

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false 。

输入：flowerbed = [1,0,0,0,1], n = 1
输出：true

 自己写的错误代码: (110/127)

class Solution(object):
    def canPlaceFlowers(self, flowerbed, n):
        """
        :type flowerbed: List[int]
        :type n: int
        :rtype: bool
        """
        if len(flowerbed) == 1:
            if flowerbed[0] == 0 and n <= 1:
                return True
            else:
                return False
        for i in range(len(flowerbed) - 1):
            if i == 0 or i == len(flowerbed) - 2:
                if flowerbed[i] == 0 and flowerbed[i+1] == 0:
                    n -= 1
                    i += 1
            else:
                if flowerbed[i-1] == 0 and flowerbed[i+1] == 0 and flowerbed[i] == 0:
                    n -= 1
                    if i != len(flowerbed)-3:
                        i += 1
                    else:
                        if flowerbed[-1] == 0 and flowerbed[-2] == 0:
                            n -= 1
                            break
        if n <= 0:
            return True
        else:
            return False

大佬的：

防御式编程思想：在 flowerbed 数组两端各增加一个 0， 这样处理的好处在于不用考虑边界条件，任意位置处只要连续出现三个 0 就可以栽上一棵花。

class Solution(object):
    def canPlaceFlowers(self, flowerbed, n):
        tmp = [0]+flowerbed+[0]
        for i in range(1, len(tmp)-1):
            if tmp[i-1] == 0 and tmp[i] == 0 and tmp[i+1] == 0:
                tmp[i] = 1
                n -= 1 
        return n <= 0 

leetcode 345 反转字符串中的元音字母

给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。

元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现不止一次。

输入：s = "hello"
输出："holle"

第一个版本：性能太差版

class Solution(object):
    def reverseVowels(self, s):
        """
        :type s: str
        :rtype: str
        """
        n = len(s)
        arr = ['a','e','i','o','u','A','E','I','O','U']
        arrInS = []
        mark = 0
        for i in range(n):
            if s[i] in arr :
                arrInS.append(s[i])
        for i in range(len(s)-1,-1,-1):
            if s[i] in arr:
                s = s[:i]+arrInS[mark]+s[i+1:]
                mark += 1
        return s

 看题解之后优化：双指针

（数据结构学的都还给课本了。。）

class Solution(object):
    def reverseVowels(self, s):
        """
        :type s: str
        :rtype: str
        """
        n = len(s)
        arr = ['a','e','i','o','u','A','E','I','O','U']
        slist = list(s)
        begin, end = 0, n-1
        while begin < end:
            while slist[begin] not in arr and begin < n-1:
                begin += 1
            while slist[end] not in arr and end > 0:
                end -= 1
            if begin < end:
                slist[begin], slist[end] = slist[end], slist[begin]
                begin += 1
                end -= 1
        return ''.join(slist)