Python|位运算|数组|动态规划|单选记录：只出现一次的数字|子集|杨辉三角 II

目录

1、只出现一次的数字（位运算，数组）

示例

选项代码

2、子集（位运算，数组）

 示例

选项代码

3、杨辉三角 II（数组，动态规划）

 示例

选项代码

---

1、只出现一次的数字（位运算，数组）

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

Tips：线性时间复杂度是什么？

线性时间复杂度是指执行算法所需要的计算工作量，即度量算法执行的时间长短，它定量描述了该算法的运行时间。常见的线性时间复杂度有：O(1)、O(n)、O(n^2)、O(n^3)、O(2^n)等。

举个例子，如果一个算法的时间复杂度是O(n)，那么当输入规模增大时，所需要的计算时间也会成倍增加。例如，在一个数组中查找元素时，如果使用顺序查找法，则时间复杂度为O(n)；如果使用二分查找法，则时间复杂度为O(log n)。

重新回答

||

示例：

示例 1:

输入: [2,2,1]

输出: 1

示例 2:

输入: [4,1,2,1,2]

输出: 4

选项代码：

from typing import List
class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        nums = sorted(nums)
        i = 0
        while i < len(nums) - 1:
            if nums[i] == nums[i + 1]:
                i += 2
            else:
                return nums[i]
        return nums[i]
if __name__ == '__main__':
    s = Solution()
    print(s.singleNumber( [4,1,2,1,2]))

2、子集（位运算，数组）

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

 示例：

示例 1：

输入：nums = [1,2,3]

输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]

输出：[[],[0]]

 

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10
• nums 中的所有元素 互不相同

选项代码：

class Solution:
    def subsets(self, nums):
        allset = 2 ** len(nums)
        result = []
        for i in range(allset):
            item = []
            for j in range(len(nums)):
                if i & (2 ** j):
                    item.append(nums[j])
            result.append(item)
        return result
if __name__ == "__main__":
        s = Solution()
        print (s.subsets([1,2,3]))

3、杨辉三角 II（数组，动态规划）

给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

Tips：杨辉三角是什么？

杨辉三角是一个由数字排列成的三角形数表。杨辉三角是中国南宋数学家杨辉在1261年所著的《详解九章算法》一书中发现的。在欧洲，帕斯卡（1623----1662）在1654年发现这一规律，所以这个表又叫做帕斯卡三角形。

帕斯卡三角形，也称为杨辉三角、贾宪三角形，是二项式系数在三角形中的一种几何排列。在欧洲，这个表叫做帕斯卡三角形。帕斯卡（1623----1662）是在1654年发现这一规律的，比杨辉要迟393年，比贾宪迟600年。

帕斯卡三角形的每个数字等于它左上方和右上方两个数字之和，形似三角形。例如，第0行有1个数字，第1行有2个数字，第2行有3个数字，以此类推。杨辉三角是最本质的特征是，它的两条斜边都是由数字1组成的，而其余的数则是等于它肩上的两个数之和。

 示例：

示例 1:

输入: rowIndex = 3

输出: [1,3,3,1]

示例 2:

输入: rowIndex = 0

输出: [1]

示例 3:

输入: rowIndex = 1

输出: [1,1]

 

提示:

• 0 <= rowIndex <= 33

 

进阶：

你可以优化你的算法到 O(rowIndex) 空间复杂度吗？

选项代码：

class Solution(object):
    def getRow(self, rowIndex):
        """
        :type rowIndex: int
        :rtype: List[int]
        """
        if rowIndex == 0:
            return [1]
        pas = [1]
        for i in range(rowIndex):
            newLine = list(map(lambda x, y: x + y, [0] + pas, pas + [0]))
            pas = newLine
        return pas
if __name__ == "__main__":
        s = Solution()
        print (s.getRow(3))