Python-Leetcode(169.187.189.283.287.290.292.326.412.414)

169.多数元素

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/majority-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def majorityElement(nums):
    nums.sort()
    size = len(nums) / 2
    i = 0
    while i < size:
        if nums[i] == nums[i+int(size)]:
            return nums[i]
        else:
            i += 1

def majorityElement2(nums):
    size = len(nums) / 2
    setnums = set(nums)
    for i in setnums:
        if nums.count(i) > size:
            return i

187.重复的DNA序列

DNA序列 由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'.。

例如，"ACGAATTCCG" 是一个 DNA序列 。
在研究 DNA 时，识别 DNA 中的重复序列非常有用。

给定一个表示 DNA序列 的字符串 s ，返回所有在 DNA 分子中出现不止一次的 长度为 10 的序列(子字符串)。你可以按 任意顺序 返回答案。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/repeated-dna-sequences
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def repeatStr(s):
    L = 10
    res = []
    cnt = defaultdict(int)
    for i in range(len(s) - L + 1):
        sub = s[i: i + L]
        cnt[sub] += 1
        if cnt[sub] == 2:
            res.append(sub)
    return res

※：defaultdict(int) 用来计数且防止KeyError

189.轮转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

def rotate(nums):
    if k :=(k % len(nums)):
        nums[:k], nums[k:] = nums[-k:],nums[:-k]

※：:=符号的作用是在表达式内获取变量值并赋给新变量。

这里带上if ，如果为0，原值不变，如果非0，则轮转

283.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

def moveZeroes(self, nums: List[int]) -> None:
    i = 0
    for num in nums:
        if num != 0: # num != 0
            nums[i] = num  # 不为0的从0位置开始放
            i += 1
            
    n = len(nums)
    for j in range(i,n):  # 剩余位置放0
        nums[j] = 0
    
    return nums

287.寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。

你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-the-duplicate-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def dinfDuplicate(nums):
    nums.sort()
    i = 0
    while nums[i] != nums[i + 1]:
        i += 1
    return nums[i]

290.单词规律

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/word-pattern
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def wordPattern(pattern, s):
    s= s.split()
    return list(map(pattern.index, pattern)) == list(map(s.index, s))

※：map(obj.index, obj) 返回格式信息，map结果不同，需要用list包装一下

292.Nim游戏

你和你的朋友，两个人一起玩 Nim 游戏：

桌子上有一堆石头。
你们轮流进行自己的回合， 你作为先手 。
每一回合，轮到的人拿掉 1 - 3 块石头。
拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/nim-game
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def canWinNim(n):
    return n % 4 != 0

326.3的幂

给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。

整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3x

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/power-of-three
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def isPowerOfThree(n):
    while n and n % 3 == 0:
        n //= 3
    return n == 1

※：n大于0且能被3整除，则处于3，循环下去，最后判断是否为1

412.Fizz Buzz

给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1 开始）返回结果，其中：

answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。
answer[i] == "Fizz" 如果 i 是 3 的倍数。
answer[i] == "Buzz" 如果 i 是 5 的倍数。
answer[i] == i （以字符串形式）如果上述条件全不满足。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/fizz-buzz
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def fizzBuzz(n):
    res = []
    for i in range(1,n+1):
        if i % 3 == 0 and i % 5 == 0:
            res.append('FizzBuzz')
        elif i % 3 == 0 and i % 5 != 0:
            res.append('Fizz')
        elif i % 3 != 0 and i % 5 == 0:
            res.append('Buzz')
        else:
            res.append(str(i))
    return res

414.第三大的数

给你一个非空数组，返回此数组中 第三大的数 。如果不存在，则返回数组中最大的数。

def thirdMax(self, nums: List[int]) -> int:
    if len(nums) <= 2:
        return sorted(nums)[-1]
    else:
        lis = sorted(list(set(nums)))
        if len(lis) >= 3:
            return lis[-3]
        else:
            return lis[-1]