代码随想录 day 55额外题目 数组

1365.有多少小于当前数字的数字

力扣题目链接

给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。 (# nums是数组， nums[i]元素， )

换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。

以数组形式返回答案。

示例 1：

输入：nums = [8,1,2,2,3]
输出：[4,0,1,1,3]
解释： 对于 nums[0]=8 存在四个比它小的数字：（1，2，2 和 3）。
对于 nums[1]=1 不存在比它小的数字。
对于 nums[2]=2 存在一个比它小的数字：（1）。
对于 nums[3]=2 存在一个比它小的数字：（1）。
对于 nums[4]=3 存在三个比它小的数字：（1，2 和 2）。
示例 2：

输入：nums = [6,5,4,8]
输出：[2,1,0,3]
示例 3：

输入：nums = [7,7,7,7]
输出：[0,0,0,0]
提示：

2 <= nums.length <= 500
0 <= nums[i] <= 100

思路

2. nums1 = 对nums进行排序， 保留nums本身的顺序，用于输出结果。

2. nums[i]的最大值为 100，定义数组：数值映射到数值个数
valMap = [0 for i in range(101)]
valMap index: nums的val
valMap val: nums的val的个数

4. 更新 valMap ： index: <index的数值的总个数
从nums1最大， 到最小， （不能最小到最大， 会出现覆盖）

4.
使用nums 顺序读取valMap数据 作为结果

code python 1

class Solution:
    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
        n = len(nums)
        nums1 = sorted(nums)   # 小到大排序
        valMap = [0 for i in range(101)]   # index: val, index: nums[i], val <=nums[i]的个数
        for v in nums1:# 先统计 val： val的个数
            valMap[v] += 1
        # 更新个数 val: <val的个数
        count = n - valMap[nums1[n-1]]  # 从右边开始， 重新赋值才不会被左边覆盖掉， 最大的比它小的数为： n - valMap[nums[-1]]
        valMap[nums1[n-1]] = count
        for i in range(len(nums1)-2,-1, -1):
            if nums1[i] == nums1[i+1]: continue         # 相同的数据只计算第最后一个
            count -= valMap[nums1[i]]
            valMap[nums1[i]] = count
        return [valMap[v] for v in nums]

nums = [6,5,4,8]
c = Solution().smallerNumbersThanCurrent(nums)

941.有效的山脉数组

力扣题目链接

给定一个整数数组 arr，如果它是有效的山脉数组就返回 true，否则返回 false。 (#  return True or False)

让我们回顾一下，如果 A 满足下述条件，那么它是一个山脉数组：

arr.length >= 3
在 0 < i < arr.length - 1 条件下，存在 i 使得：   (#　单调增，　再单调减)
arr[0] < arr[1] < ... arr[i-1] < arr[i]
arr[i] > arr[i+1] > ... > arr[arr.length - 1]

示例 1：
输入：arr = [2,1]
输出：false

示例 2：
输入：arr = [3,5,5]
输出：false

示例 3：
输入：arr = [0,3,2,1]
输出：true

提示：
1 <= arr.length <= 104
0 <= arr[i] <= 104

思路

逻辑模拟

##　code python 1

class Solution:
    def validMountainArray(self, arr: List[int]) -> bool:
        n = len(arr)
        if n <= 1: return False   # 一个数
        if arr[1] - arr[0] <= 0: return False
        flag = False
        cur = 1
        final1 = 1
        for i in range(1, n):
            if arr[i] - arr[i-1] == 0: return False
            if arr[i] - arr[i-1] < 0:
                cur = i
                break # 出现了高点
            else:
                final1 = i
        if final1 == n-1: return False

        for i in range(cur, n):
            if arr[i] - arr[i-1] >= 0: return False
        return True

code python 2

class Solution:
    def validMountainArray(self, arr: List[int]) -> bool:
        n = len(arr)
        if n < 3:
            return False
        m = arr.index(max(arr))  # 找到最大值所在索引
        if m == 0 or m == n - 1:
            return False
        for i in range(1, m + 1):   # 前面增
            if arr[i] <= arr[i - 1]:
                return False
        for i in range(m, n - 1):
            if arr[i] <= arr[i + 1]:  #　后面减
                return False
        return True

1207.独一无二的出现次数

力扣题目链接

给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。  (# 次数统计)

如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。 (# 次数的数值独一无二 = 不重复)

示例 1：
输入：arr = [1,2,2,1,1,3]
输出：true
解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。

示例 2：
输入：arr = [1,2]
输出：false

示例 3：
输入：arr = [-3,0,1,-3,1,1,1,-3,10,0]
输出：true

提示：
1 <= arr.length <= 1000
-1000 <= arr[i] <= 1000

思路

class Solution:
    def uniqueOccurrences(self, arr: List[int]) -> bool:
        # 统计次数
        # 1 <= arr.length <= 1000
        # -1000 <= arr[i] <= 1000
        n = len(arr)
        hash1 = {}
        for v in arr:
            hash1[v] = hash1.get(v, 0) + 1

        counts = 0 # 统计不同元素个数
        hash2 = [0 for i in range(20001)]  # arr[i]
        for key, val in hash1.items():
            if hash2[val] != 0:   # 说明 这个val的个数：val 已经出现过
                return False
            hash2[val] = key
        return True

code python 2

from collections import Counter
class Solution:
    def uniqueOccurrences(self, arr: List[int]) -> bool:
        c = Counter(arr)
        return len(c.values()) == len(set(c.values()))

283. 移动零：动态规划：一样的套路，再求一次完全平方数

力扣题目链接

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

示例:

输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明:

必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。

思路

双指针
left: 记录下一个待交换的left的位置
right: 遍历数据

code python 1

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        left, right = 0, 0
        while left < n:      # 找到第一个0的位置
            if nums[left] == 0:
                break
            left += 1

        for right in range(left + 1, n):
            if nums[right] != 0:
                nums[left] = nums[right]
                left += 1
        # left 到 n 赋值为 0
        for i in range(left, n):
            nums[i] = 0
        # print(nums)

code python 2

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        index = 0
        n = len(nums)
        for i in range(n):
            if nums[i]!=0:
                nums[index] = nums[i]
                index+=1
        for j in range(index,n):
            nums[j] = 0

189. 旋转数组

力扣题目链接

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

进阶：
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。 你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释: 向右旋转 1 步: [7,1,2,3,4,5,6]。 向右旋转 2 步: [6,7,1,2,3,4,5]。 向右旋转 3 步: [5,6,7,1,2,3,4]。
示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 向右旋转 1 步: [99,-1,-100,3]。 向右旋转 2 步: [3,99,-1,-100]。

提示：

1 <= nums.length <= 105
-231 <= nums[i] <= 231 - 1
0 <= k <= 105

思路

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        def reverse(left, right):
            while left <= right:
                nums[left], nums[right]= nums[right], nums[left]
                left += 1
                right -= 1
        n = len(nums)
        k = k % n
        if k == 0: return
        reverse(0, (n-k)-1)
        reverse((n-k), n-1)
        reverse(0,n-1)
        return

code python 2

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        length = len(nums)
        k = k%length
        nums[:] = nums[length-k:] + nums[:length-k]

724.寻找数组的中心下标

力扣题目链接

给你一个整数数组 nums ，请计算数组的 中心下标 。

数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。

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

示例 1：

输入：nums = [1, 7, 3, 6, 5, 6]
输出：3
解释：中心下标是 3。左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。
示例 2：

输入：nums = [1, 2, 3]
输出：-1
解释：数组中不存在满足此条件的中心下标。
示例 3：

输入：nums = [2, 1, -1]
输出：0
解释：中心下标是 0。左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。

提示：

1 <= nums.length <= 10^4
-1000 <= nums[i] <= 1000

code python 1

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        # 1 <= nums.length <= 10^4
        # -1000 <= nums[i] <= 1000
        n = len(nums)
        sumLeft = 0   # 左边 = 0
        sumRight = 0
        for i in range(1, n):   # 右边 sum(nums[1:n])
            sumRight += nums[i]
        if sumLeft == sumRight: return 0
        for i in range(1, n):
            sumLeft += nums[i-1]
            sumRight -= nums[i]
            if sumLeft == sumRight:
                return i
        if sumLeft == sumRight: return n-1
        return -1

code python 2

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        numSum = sum(nums) #数组总和
        leftSum = 0
        for i in range(len(nums)):
            if numSum - leftSum -nums[i] == leftSum: #左右和相等
                return i
            leftSum += nums[i]
        return -1

34. 在排序数组中查找元素的第一个和最后一个位置

力扣链接

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。  (# 升序排列， target)

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：你可以设计并实现时间复杂度为 $O(\log n)$ 的算法解决此问题吗？

示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums 是一个非递减数组
-109 <= target <= 109

code python 1

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        left, right = -1, -1
        cur = 0
        n = len(nums)
        for i in range(n):
            if nums[i] == target:
                left = i
                break
            if nums[i] > target:
                return [left, right]
        if left == -1: return [left, right]

        right = left
        for i in range(left, n):
            if nums[i] == target:
                right = i
            else:
                break

        return [left, right]

922. 按奇偶排序数组II

力扣题目链接

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

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

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

示例：

输入：[4,2,5,7]
输出：[4,5,2,7]
解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。

提示：

2 <= nums.length <= 2 * 104
nums.length 是偶数
nums 中一半是偶数
0 <= nums[i] <= 1000

思路

from typing import List

class Solution:
    def sortArrayByParityII(self, nums: List[int]) -> List[int]:
        ## 双指针
        n = len(nums)
        if n <= 1: return nums
        left1, left2, right = 0, 0, 0   # left1 统计 奇数， left 2 统计偶数
        # 找到第一个奇数，偶数不符合情况的index
        cur = 0
        for i in range(0, n, 2):
            if nums[i] % 2:
                left2 = i
        for i in range(1, n, 2):
            if nums[i] % 2 == 0:
                left1 = i
        for i in range(left2, n):
            
# 未完成