python：基础入门练习066 - 075
2021-09-28 本文已影响0人
玩转测试开发
# -*- coding: utf-8 -*-
# 066: 数组中重复的数字
# 找出数组中重复的数字。
# 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，
# 也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
# 示例 1：
# 输入：
# [2, 3, 1, 0, 2, 5, 3]
# 输出：2 或 3
class Solution066:
def findRepeatNumber(self, nums: list[int]) -> int:
hash_set = set()
for i in nums:
if i not in hash_set:
hash_set.add(i)
else:
return i
s066 = Solution066()
r066 = s066.findRepeatNumber([4, 2, 5, 9, 7, 4, 8])
print(r066) # 4
# 067: 统计有序矩阵中的负数
# 给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。
# 请你统计并返回 grid 中 负数 的数目。
# 示例 1：
# 输入：grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
# 输出：8
# 解释：矩阵中共有 8 个负数。
#
# 示例 2：
# 输入：grid = [[3,2],[1,0]]
# 输出：0
#
# 示例 3：
# 输入：grid = [[1,-1],[-1,-1]]
#
# 输出：3
# 示例 4：
# 输入：grid = [[-1]]
# 输出：1
class Solution067:
def countNegatives(self, grid: list[list[int]]) -> int:
number = 0
for i in grid:
for j in i:
if j < 0:
number += 1
return number
s067 = Solution067()
r067 = s067.countNegatives([[1, 2, -2], [3, -1, 9], [-7, 0]])
print(r067) # 3
# 068: 两个数组的交集
# 给定两个数组，编写一个函数来计算它们的交集。
# 示例 1：
# 输入：nums1 = [1,2,2,1], nums2 = [2,2]
# 输出：[2]
#
# 示例 2：
#
# 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
# 输出：[9,4]
class Solution068:
def intersection(self, nums1: list[int], nums2: list[int]) -> list[int]:
res = []
for i in nums1:
if i in nums2:
res.append(i)
res = list(set(res))
return res
s068 = Solution068()
r068 = s068.intersection([1, 2, -2], [3, -1, 2, 1])
print(r068) # [1, 2]
# 069: 好数对的数目
# 给你一个整数数组 nums 。
# 如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。
# 返回好数对的数目。
# 示例 1：
# 输入：nums = [1,2,3,1,1,3]
# 输出：4
# 解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始
#
# 示例 2：
# 输入：nums = [1,1,1,1]
# 输出：6
# 解释：数组中的每组数字都是好数对
# 示例 3：
# 输入：nums = [1,2,3]
# 输出：0
class Solution069:
def numIdenticalPairs(self, nums: list[int]) -> int:
count = 0
for i, v in enumerate(nums):
init_num = v
for j in nums[i + 1:]:
if j == init_num:
count += 1
return count
s069 = Solution069()
r069 = s069.numIdenticalPairs([1, 2, 3, 3, 2, 1, 8, 0])
print(r069) # 3
# 070: 将所有数字用字符替换
# 给你一个下标从 0 开始的字符串 s ，它的 偶数 下标处为小写英文字母，奇数 下标处为数字。
# 定义一个函数 shift(c, x) ，其中 c 是一个字符且 x 是一个数字，函数返回字母表中 c 后面第 x 个字符。
# 比方说，shift('a', 5) = 'f' 和 shift('x', 0) = 'x' 。
# 对于每个 奇数 下标 i ，你需要将数字 s[i] 用 shift(s[i-1], s[i]) 替换。
# 请你替换所有数字以后，将字符串 s 返回。题目 保证 shift(s[i-1], s[i]) 不会超过 'z' 。
#
# 示例 1：
# 输入：s = "a1c1e1"
# 输出："abcdef"
# 解释：数字被替换结果如下：
# - s[1] -> shift('a',1) = 'b'
# - s[3] -> shift('c',1) = 'd'
# - s[5] -> shift('e',1) = 'f'
#
# 示例 2：
# 输入：s = "a1b2c3d4e"
# 输出："abbdcfdhe"
# 解释：数字被替换结果如下：
# - s[1] -> shift('a',1) = 'b'
# - s[3] -> shift('b',2) = 'd'
# - s[5] -> shift('c',3) = 'f'
# - s[7] -> shift('d',4) = 'h'
class Solution070:
def replaceDigits(self, s: str) -> str:
words = "abcdefghijklmnopqrstuvwxyz"
new_word = ""
for i, v in enumerate(s):
if i % 2 == 0:
new_word += v
else:
new_word += words[int(words.index(s[i - 1]) + int(v))]
return new_word
s070 = Solution070()
r070 = s070.replaceDigits("a1s2d3f")
print(r070) # absudgf
# 071: 访问所有点的最小时间
# 平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi] 。请你计算访问所有这些点需要的 最小时间（以秒为单位）。
# 你需要按照下面的规则在平面上移动：
# 每一秒内，你可以：
# 沿水平方向移动一个单位长度，或者
# 沿竖直方向移动一个单位长度，或者
# 跨过对角线移动 sqrt(2) 个单位长度（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
# 必须按照数组中出现的顺序来访问这些点。
# 在访问某个点时，可以经过该点后面出现的点，但经过的那些点不算作有效访问。
#
# 示例 1：
# 输入：points = [[1,1],[3,4],[-1,0]]
# 输出：7
# 解释：一条最佳的访问路径是： [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]
# 从 [1,1] 到 [3,4] 需要 3 秒
# 从 [3,4] 到 [-1,0] 需要 4 秒
# 一共需要 7 秒
#
# 示例 2：
# 输入：points = [[3,2],[-2,2]]
# 输出：5
class Solution071:
def minTimeToVisitAllPoints(self, points: list[list[int]]) -> int:
# x1 - x2 , y1 - y2谁大取谁
time = 0
for i in range(len(points) - 1):
_x = abs(points[i][0] - points[i + 1][0])
_y = abs(points[i][1] - points[i + 1][1])
time += _x if _x > _y else _y
return time
s071 = Solution071()
r071 = s071.minTimeToVisitAllPoints([[0, 0], [6, 8]])
print(r071) # 8
# 072: 设计停车系统
# 请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位：大，中和小，每种尺寸分别有固定数目的车位。
# 请你实现 ParkingSystem 类：
# ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 类，三个参数分别对应每种停车位的数目。
# bool addCar(int carType) 检查是否有 carType 对应的停车位。 carType 有三种类型：大，中，小，
# 分别用数字 1， 2 和 3 表示。一辆车只能停在 carType 对应尺寸的停车位中。如果没有空车位，请返回 false ，
# 否则将该车停入车位并返回 true 。
#
# 示例 1：
# 输入：
# ["ParkingSystem", "addCar", "addCar", "addCar", "addCar"]
# [[1, 1, 0], [1], [2], [3], [1]]
# 输出：
# [null, true, true, false, false]
# 解释：
# ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);
# parkingSystem.addCar(1); // 返回 true ，因为有 1 个空的大车位
# parkingSystem.addCar(2); // 返回 true ，因为有 1 个空的中车位
# parkingSystem.addCar(3); // 返回 false ，因为没有空的小车位
# parkingSystem.addCar(1); // 返回 false ，因为没有空的大车位，唯一一个大车位已经被占据了
class ParkingSystem:
def __init__(self, big: int, medium: int, small: int):
self.big = big
self.medium = medium
self.small = small
def addCar(self, carType: int) -> bool:
last = ""
if carType == 1:
if self.big >= 1:
self.big -= 1
last = True
else:
last = False
elif carType == 2:
if self.medium >= 1:
self.medium -= 1
last = True
else:
last = False
else:
if self.small >= 1:
self.small -= 1
last = True
else:
last = False
return last
s072 = ParkingSystem(1, 0, 1)
r0721 = s072.addCar(1)
r0722 = s072.addCar(2)
r0723 = s072.addCar(3)
print(f"{r0721}, {r0722}, {r0723}") # True, False, True
# 073: 翻转图像
# 给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。
# 水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。
# 反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。
#
# 示例 1：
# 输入：[[1,1,0],[1,0,1],[0,0,0]]
# 输出：[[1,0,0],[0,1,0],[1,1,1]]
# 解释：首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；
# 然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]
#
# 示例 2：
# 输入：[[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
# 输出：[[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
# 解释：首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]；
# 然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
class Solution073:
def flipAndInvertImage(self, image: list[list[int]]) -> list[list[int]]:
new_list = []
for i in image:
init_i = [j for j in i[::-1]]
inner_list = []
for z in init_i:
if z == 0:
inner_list.append(1)
else:
inner_list.append(0)
new_list.append(inner_list)
return new_list
s073 = Solution073()
r073 = s073.flipAndInvertImage([[1, 1, 1, 1], [1, 0, 1, 0]])
print(r073) # [[0, 0, 0, 0], [1, 0, 1, 0]]
# 074: 加一
# 给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
# 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
# 你可以假设除了整数 0 之外，这个整数不会以零开头。
#
# 示例 1：
# 输入：digits = [1,2,3]
# 输出：[1,2,4]
# 解释：输入数组表示数字 123。
#
# 示例 2：
# 输入：digits = [4,3,2,1]
# 输出：[4,3,2,2]
# 解释：输入数组表示数字 4321
#
# 示例 3：
# 输入：digits = [0]
# 输出：[1]
class Solution074:
def plusOne(self, digits: list[int]) -> list[int]:
s = ""
for i in digits:
s += str(i)
number = int(s) + 1
return [int(i) for i in str(number)]
s074 = Solution074()
r074 = s074.plusOne([9, 9, 9])
print(r074) # [1, 0, 0, 0]
# 075: 移动零
# 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
# 示例:
# 输入: [0,1,0,3,12]
# 输出: [1,3,12,0,0]
class Solution075:
def moveZeroes(self, nums: list[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
for i in nums:
if i == 0:
nums.remove(i)
nums.append(i)
s075 = Solution075()
nums075 = [1, 0, 1, 0, 1]
s075.moveZeroes(nums075)
print(nums075) # [1, 1, 1, 0, 0]
