# -*- coding: utf-8 -*-
# 171: 找出数组中的第一个回文字符串
# 给你一个字符串数组 words ，找出并返回数组中的 第一个回文字符串 。如果不存在满足要求的字符串，返回一个 空字符串 "" 。
# 回文字符串 的定义为：如果一个字符串正着读和反着读一样，那么该字符串就是一个 回文字符串 。
# 示例 1：
# 输入：words = ["abc","car","ada","racecar","cool"]
# 输出："ada"
# 解释：第一个回文字符串是 "ada" 。
# 注意，"racecar" 也是回文字符串，但它不是第一个。
# 示例 2：
# 输入：words = ["notapalindrome","racecar"]
# 输出："racecar"
# 解释：第一个也是唯一一个回文字符串是 "racecar" 。
# 示例 3：
# 输入：words = ["def","ghi"]
# 输出：""
# 解释：不存在回文字符串，所以返回一个空字符串。
class Solution171:
def firstPalindrome(self, words) -> str:
# 遍历。如果a=a[::-1]停止。否则，""
result = ""
for i in words:
if i == i[::-1]:
result = i
break
return result
s171 = Solution171()
r171 = s171.firstPalindrome(["notapalindrome", "racecar"])
print(r171) # racecar
# 172: 根据给定数字划分数组
# 给你一个下标从 0 开始的整数数组 nums 和一个整数 pivot 。请你将 nums 重新排列，使得以下条件均成立：
# 所有小于 pivot 的元素都出现在所有大于 pivot 的元素 之前 。
# 所有等于 pivot 的元素都出现在小于和大于 pivot 的元素 中间 。
# 小于 pivot 的元素之间和大于 pivot 的元素之间的 相对顺序 不发生改变。
# 更正式的，考虑每一对 pi，pj ，pi 是初始时位置 i 元素的新位置，pj 是初始时位置 j 元素的新位置。对于小于
# pivot 的元素，如果 i < j 且 nums[i] < pivot 和 nums[j] < pivot 都成立，那么 pi < pj 也成立。类似的，
# 对于大于 pivot 的元素，如果 i < j 且 nums[i] > pivot 和 nums[j] > pivot 都成立，那么 pi < pj 。
# 请你返回重新排列 nums 数组后的结果数组。
# 示例 1：
# 输入：nums = [9,12,5,10,14,3,10], pivot = 10
# 输出：[9,5,3,10,10,12,14]
# 解释：
# 元素 9 ，5 和 3 小于 pivot ，所以它们在数组的最左边。
# 元素 12 和 14 大于 pivot ，所以它们在数组的最右边。
# 小于 pivot 的元素的相对位置和大于 pivot 的元素的相对位置分别为 [9, 5, 3] 和 [12, 14] ，它们在结果数组中的相对顺序需要保留。
# 示例 2：
# 输入：nums = [-3,4,3,2], pivot = 2
# 输出：[-3,2,4,3]
# 解释：
# 元素 -3 小于 pivot ，所以在数组的最左边。
# 元素 4 和 3 大于 pivot ，所以它们在数组的最右边。
# 小于 pivot 的元素的相对位置和大于 pivot 的元素的相对位置分别为 [-3] 和 [4, 3] ，它们在结果数组中的相对顺序需要保留。
class Solution172:
def pivotArray(self, nums, pivot: int):
# 分三块。小于等于大于
less_list = []
eq_list = []
more_list = []
for i in nums:
if i < pivot:
less_list.append(i)
elif i > pivot:
more_list.append(i)
else:
eq_list.append(i)
return less_list + eq_list + more_list
s172 = Solution172()
r172 = s172.pivotArray([9, 5, 3, 10, 10, 12, 14], 8)
print(r172) # [5, 3, 9, 10, 10, 12, 14]
# 173: 交替合并字符串
# 给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。
# 如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。
# 返回 合并后的字符串 。
# 示例 1：
# 输入：word1 = "abc", word2 = "pqr"
# 输出："apbqcr"
# 解释：字符串合并情况如下所示：
# word1： a b c
# word2： p q r
# 合并后： a p b q c r
# 示例 2：
# 输入：word1 = "ab", word2 = "pqrs"
# 输出："apbqrs"
# 解释：注意，word2 比 word1 长，"rs" 需要追加到合并后字符串的末尾。
# word1： a b
# word2： p q r s
# 合并后： a p b q r s
# 示例 3：
# 输入：word1 = "abcd", word2 = "pq"
# 输出："apbqcd"
# 解释：注意，word1 比 word2 长，"cd" 需要追加到合并后字符串的末尾。
# word1： a b c d
# word2： p q
# 合并后： a p b q c d
class Solution173:
def mergeAlternately(self, word1: str, word2: str) -> str:
# 判断。如果A的长度大于等于B，则直接交替
# 如果B的长度大于A，则A的长度+B的长度 + B[lenA:(B的长度- A的长度)]
# 如果A的长度大于B。则A
# 循环的长度在于谁更短。再判断剩余拼接
w1_len = len(word1)
w2_len = len(word2)
number = w2_len if w1_len > w2_len else w1_len
w = ""
for i in range(number):
w += str(word1[i])
w += str(word2[i])
if w1_len < w2_len:
w += str(word2[w1_len:])
else:
w += str(word1[w2_len:])
return w
s173 = Solution173()
r173 = s173.mergeAlternately("hello", "world")
print(r173) # hweolrllod
# 174: 最富有客户的资产总量
# 给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。
# 返回最富有客户所拥有的 资产总量 。
# 客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
# 示例 1：
# 输入：accounts = [[1,2,3],[3,2,1]]
# 输出：6
# 解释：
# 第 1 位客户的资产总量 = 1 + 2 + 3 = 6
# 第 2 位客户的资产总量 = 3 + 2 + 1 = 6
# 两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。
# 示例 2：
# 输入：accounts = [[1,5],[7,3],[3,5]]
# 输出：10
# 解释：
# 第 1 位客户的资产总量 = 6
# 第 2 位客户的资产总量 = 10
# 第 3 位客户的资产总量 = 8
# 第 2 位客户是最富有的，资产总量是 10
# 示例 3：
# 输入：accounts = [[2,8,7],[7,1,3],[1,9,5]]
# 输出：17
class Solution174:
def maximumWealth(self, accounts) -> int:
result_list = []
for each in accounts:
result_list.append(sum(each))
return max(result_list)
s174 = Solution174()
r174 = s174.maximumWealth([[1, 5], [7, 3], [3, 5]])
print(r174) # 10
# 175: 剑指 Offer 64. 求1+2+…+n
# 求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
# 示例 1：
# 输入: n = 3
# 输出: 6
# 示例 2：
# 输入: n = 9
# 输出: 45
class Solution175:
def sumNums(self, n: int) -> int:
# from functools import reduce
# return reduce(lambda x, y: x + y, range(1, n + 1))
return sum(range(1, n + 1))
s175 = Solution175()
r175 = s175.sumNums(8)
print(r175) # 36
# 176: 剑指 Offer II 079. 所有子集
# 给定一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
# 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
# 示例 1：
# 输入：nums = [1,2,3]
# 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
# 示例 2：
# 输入：nums = [0]
# 输出：[[],[0]]
class Solution176:
def subsets(self, nums):
new_list = [[], nums]
import itertools
for i in range(1, len(nums)):
for j in itertools.combinations(nums, i):
new_list.append(list(j))
return new_list
s176 = Solution176()
r176 = s176.subsets([3, 4])
print(r176) # [[], [3, 4], [3], [4]]
# 177: 拆分数位后四位数字的最小和
# 给你一个四位 正 整数 num 。请你使用 num 中的 数位 ，将 num 拆成两个新的整数 new1 和 new2 。
# new1 和 new2 中可以有 前导 0 ，且 num 中 所有 数位都必须使用。
# 比方说，给你 num = 2932 ，你拥有的数位包括：两个 2 ，一个 9 和一个 3 。一些可能的 [new1, new2]
# 数对为 [22, 93]，[23, 92]，[223, 9] 和 [2, 329] 。
# 请你返回可以得到的 new1 和 new2 的 最小 和。
# 示例 1：
# 输入：num = 2932
# 输出：52
# 解释：可行的 [new1, new2] 数对为 [29, 23] ，[223, 9] 等等。
# 最小和为数对 [29, 23] 的和：29 + 23 = 52 。
# 示例 2：
# 输入：num = 4009
# 输出：13
# 解释：可行的 [new1, new2] 数对为 [0, 49] ，[490, 0] 等等。
# 最小和为数对 [4, 9] 的和：4 + 9 = 13 。
class Solution177:
def minimumSum(self, num: int) -> int:
# 转成列表。
# 排序+ 13、24最小
new = [i for i in str(num)]
new.sort()
one_number = int(new[0] + new[2])
two_number = int(new[1] + new[3])
return one_number + two_number
s177 = Solution177()
r177 = s177.minimumSum(5927)
print(r177) # 86
# 178: 可以形成最大正方形的矩形数目
# 给你一个数组 rectangles ，其中 rectangles[i] = [li, wi] 表示第 i 个矩形的长度为 li 、宽度为 wi 。
# 如果存在 k 同时满足 k <= li 和 k <= wi ，就可以将第 i 个矩形切成边长为 k 的正方形。
# 例如，矩形 [4,6] 可以切成边长最大为 4 的正方形。
# 设 maxLen 为可以从矩形数组 rectangles 切分得到的 最大正方形 的边长。
# 请你统计有多少个矩形能够切出边长为 maxLen 的正方形，并返回矩形 数目 。
# 示例 1：
# 输入：rectangles = [[5,8],[3,9],[5,12],[16,5]]
# 输出：3
# 解释：能从每个矩形中切出的最大正方形边长分别是 [5,3,5,5] 。
# 最大正方形的边长为 5 ，可以由 3 个矩形切分得到。
# 示例 2：
# 输入：rectangles = [[2,3],[3,7],[4,3],[3,7]]
# 输出：3
class Solution178:
def countGoodRectangles(self, rectangles) -> int:
# 遍历数组，找到最小的放入一个列表
# 转 元素对应个数，排序保证最大在前
# 找出最大的长度。
temp = [min(i) for i in rectangles]
import collections
r = [(k, v) for k, v in collections.Counter(temp).items()]
r.sort(reverse=True)
return r[0][1]
s178 = Solution178()
r178 = s178.countGoodRectangles([[2, 3], [3, 7], [4, 3], [3, 7]])
print(r178) # 3
# 179: 统计是给定字符串前缀的字符串数目
# 给你一个字符串数组 words 和一个字符串 s ，其中 words[i] 和 s 只包含 小写英文字母 。
# 请你返回 words 中是字符串 s 前缀 的 字符串数目 。
# 一个字符串的 前缀 是出现在字符串开头的子字符串。子字符串 是一个字符串中的连续一段字符序列。
# 示例 1：
# 输入：words = ["a","b","c","ab","bc","abc"], s = "abc"
# 输出：3
# 解释：
# words 中是 s = "abc" 前缀的字符串为：
# "a" ，"ab" 和 "abc" 。
# 所以 words 中是字符串 s 前缀的字符串数目为 3 。
# 示例 2：
# 输入：words = ["a","a"], s = "aa"
# 输出：2
# 解释：
# 两个字符串都是 s 的前缀。
# 注意，相同的字符串可能在 words 中出现多次，它们应该被计数多次。
class Solution179:
def countPrefixes(self, words, s: str) -> int:
# 遍历。如果startswith 次数+1
return sum([1 for i in words if s.startswith(i)])
s179 = Solution179()
r179 = s179.countPrefixes(["he", "h", "o", "a"], "hello world")
print(r179) # 2
# 180: 将找到的值乘以 2
# 给你一个整数数组 nums ，另给你一个整数 original ，这是需要在 nums 中搜索的第一个数字。
# 接下来，你需要按下述步骤操作：
# 如果在 nums 中找到 original ，将 original 乘以 2 ，得到新 original（即，令 original = 2 * original）。
# 否则，停止这一过程。
# 只要能在数组中找到新 original ，就对新 original 继续 重复 这一过程。
# 返回 original 的 最终 值。
# 示例 1：
# 输入：nums = [5,3,6,1,12], original = 3
# 输出：24
# 解释：
# - 3 能在 nums 中找到。3 * 2 = 6 。
# - 6 能在 nums 中找到。6 * 2 = 12 。
# - 12 能在 nums 中找到。12 * 2 = 24 。
# - 24 不能在 nums 中找到。因此，返回 24 。
# 示例 2：
# 输入：nums = [2,7,9], original = 4
# 输出：4
# 解释：
# - 4 不能在 nums 中找到。因此，返回 4 。
class Solution180:
def findFinalValue(self, nums, original: int) -> int:
result = original
while True:
if original in nums:
original *= 2
result = original
else:
break
return result
s180 = Solution180()
r180 = s180.findFinalValue([5, 3, 6, 1, 12], 3)
print(r180) # 24
微信公众号：玩转测试开发
欢迎关注，共同进步，谢谢！
扫一扫
919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
