从零开始刷Leetcode——数组（896.905.914.922）

896. 单调数列

如果数组是单调递增或单调递减的，那么它是单调的。

如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。

当给定的数组 A 是单调数组时返回 true，否则返回 false。

1.两次for循环

class Solution:
    def isMonotonic(self, A: List[int]) -> bool:
        return (all(A[i] >= A[i+1] for i in range(len(A)-1))  or all(A[i] <= A[i+1] for i in range(len(A)-1)))

递减和递增分别判断一下。这里运用了all()函数，all函数讲解见all函数。 604ms， 19.6MB

2.一次for循环

class Solution(object):
    def isMonotonic(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        flagI = 0
        flagD = 0
        for i in range(len(A) - 1):
            if A[i + 1] > A[i]:
                flagI = 1
            if A[i + 1] < A[i]:
                flagD = 1
        return flagI + flagD != 2

其他人的解法。656ms， 19.6MB

905. 按奇偶排序数组

给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。

1.双指针+辅助数组

class Solution:
    def sortArrayByParity(self, A: List[int]) -> List[int]:
        left = 0
        right = len(A)-1
        ans = [0]*len(A)
        i=0
        while(i<len(A)):
            if A[i]%2 == 0:
                ans[left] = A[i]
                left += 1
            else:
                ans[right] = A[i]
                right -= 1
            i += 1
        return ans

排序时间较长就不写了。第一个指针从前往后放偶数，第二个指针从后往前放奇数。96ms， 14.4MB

2.输出两遍数组

class Solution(object):
    def sortArrayByParity(self, A):
        return ([x for x in A if x % 2 == 0] +
                [x for x in A if x % 2 == 1])

一个数组输出偶数一个输出奇数首尾相连。 104ms， 14.4MB

3.原地解法

class Solution(object):
    def sortArrayByParity(self, A):
        i, j = 0, len(A) - 1
        while i < j:
            if A[i] % 2 > A[j] % 2:
                A[i], A[j] = A[j], A[i]

            if A[i] % 2 == 0: i += 1
            if A[j] % 2 == 1: j -= 1

        return A

两个指针分别将前面的奇数和后面的偶数做交换。92ms，14.1MB

914. 卡牌分组

给定一副牌，每张牌上都写着一个整数。

此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：

• 每组都有 X 张牌。
• 组内所有的牌上都写着相同的整数。

仅当你可选的 X >= 2 时返回 true。

1.暴力法略

2.最大公约数

class Solution:
    def hasGroupsSizeX(self, deck: List[int]) -> bool:
        hashmap = {
     }
        count = 1
        for i in range(len(deck)):
            if deck[i] not in hashmap.keys():
                count = 1
                hashmap[deck[i]] = 1
            else:
                hashmap[deck[i]] += 1
        min_value = min(hashmap.values())
        for m in range(2, min_value+1):
            if all( j%m == 0 for j in hashmap.values()):
                return True
        return False

这里计数可以用collection的Counter类，我用的哈希表，计完数判断是否有最大公约数即可。60ms， 13.8MB

3.Counter类

class Solution:
    def hasGroupsSizeX(self, deck: List[int]) -> bool:
        count = Counter(deck)
        n = len(deck)
        for x in range(2,n+1):
            if n%x == 0:
                if all(v%x==0 for v in count.values()):
                    return True
        return False

用Counter更快。 48ms， 13.5MB

922. 按奇偶排序数组 II

给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。

对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。

你可以返回任何满足上述条件的数组作为答案。

1.双指针+辅助数组

class Solution:
    def sortArrayByParityII(self, A: List[int]) -> List[int]:
        left = 0
        right = 1
        ans = [0]*len(A)
        i=0
        while(i<len(A)):
            if A[i]%2 == 0:
                ans[left] = A[i]
                left += 2
            else:
                ans[right] = A[i]
                right += 2
            i += 1
        return ans

和905题一模一样。 300ms， 16.2MB

2.上面优化

class Solution(object):
    def sortArrayByParityII(self, A):
        j = 1
        for i in range(0, len(A), 2):
            if A[i] % 2:
                while A[j] % 2:
                    j += 2
                A[i], A[j] = A[j], A[i]
        return A

优化的一点是没有额外空间，其次只计算偶数的值可以加快速度。248ms， 15.7MB