Python：基础入门练习161 - 170

最新推荐文章于 2024-10-06 07:39:55 发布
玩转测试开发
最新推荐文章于 2024-10-06 07:39:55 发布
阅读量142
点赞数
分类专栏： Python学习文章标签： python 排序算法
本文链接：https://blog.csdn.net/hzblucky1314/article/details/125058714
版权
Python学习专栏收录该内容
121 篇文章 14 订阅
订阅专栏
# -*- coding: utf-8 -*-
# 161: 数组中第 K 个独一无二的字符串
# 独一无二的字符串 指的是在一个数组中只出现过 一次 的字符串。
# 给你一个字符串数组 arr 和一个整数 k ，请你返回 arr 中第 k 个 独一无二的字符串 。
# 如果 少于 k 个独一无二的字符串，那么返回 空字符串 "" 。
# 注意，按照字符串在原数组中的 顺序 找到第 k 个独一无二字符串。
# 示例 1:
# 输入：arr = ["d","b","c","b","c","a"], k = 2
# 输出："a"
# 解释：
# arr 中独一无二字符串包括 "d" 和 "a" 。
# "d" 首先出现，所以它是第 1 个独一无二字符串。
# "a" 第二个出现，所以它是 2 个独一无二字符串。
# 由于 k == 2 ，返回 "a" 。
# 示例 2:
# 输入：arr = ["aaa","aa","a"], k = 1
# 输出："aaa"
# 解释：
# arr 中所有字符串都是独一无二的，所以返回第 1 个字符串 "aaa" 。
# 示例 3：
# 输入：arr = ["a","b","a"], k = 3
# 输出：""
# 解释：
# 唯一一个独一无二字符串是 "b" 。由于少于 3 个独一无二字符串，我们返回空字符串 "" 。


class Solution161:
    def kthDistinct(self, arr, k: int) -> str:
        # 次数为1的字符串。
        # 统计次数。初始1
        count = 0
        result = []
        for i in arr:
            if arr.count(i) == 1:
                result.append(i)
            if len(result) == k:
                break
        if len(result) < k:
            return ""
        else:
            return result[k - 1]


s161 = Solution161()
data161 = ["d", "b", "c", "b", "c", "a"]
r161 = s161.kthDistinct(data161, 2)
print(r161)  # a


# 162: 两句话中的不常见单词
# 句子 是一串由空格分隔的单词。每个 单词 仅由小写字母组成。
# 如果某个单词在其中一个句子中恰好出现一次，在另一个句子中却 没有出现 ，那么这个单词就是 不常见的 。
# 给你两个 句子 s1 和 s2 ，返回所有 不常用单词 的列表。返回列表中单词可以按 任意顺序 组织。
# 示例 1：
# 输入：s1 = "this apple is sweet", s2 = "this apple is sour"
# 输出：["sweet","sour"]
# 示例 2：
# 输入：s1 = "apple apple", s2 = "banana"
# 输出：["banana"]


class Solution162:
    def uncommonFromSentences(self, s1: str, s2: str):
        # 拆分空格成为列表
        # 转元素次数统计的字典
        # 分别遍历加入集合。
        # 集合转列表
        from collections import Counter
        r1 = s1.split(" ")
        r2 = s2.split(" ")
        d1 = dict(Counter(r1))
        d2 = dict(Counter(r2))
        set1 = set()
        for k, v in d1.items():
            if k not in d2 and v == 1:
                set1.add(k)

        for k, v in d2.items():
            if k not in d1 and v == 1:
                set1.add(k)

        return list(set1)


s162 = Solution162()
r162 = s162.uncommonFromSentences("apple peach", "banana orange apple")
print(r162)  # ['orange', 'banana', 'peach']


# 163: 剑指 Offer 65. 不用加减乘除做加法
# 写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。
# 示例:
# 输入: a = 1, b = 1
# 输出: 2


class Solution163:
    def add(self, a: int, b: int) -> int:
        import operator
        return operator.add(a, b)


s163 = Solution163()
r163 = s163.add(3, 5)
print(r163)  # 8


# 164: 按奇偶排序数组
# 给你一个整数数组 nums，将 nums 中的的所有偶数元素移动到数组的前面，后跟所有奇数元素。
# 返回满足此条件的 任一数组 作为答案。
# 示例 1：
# 输入：nums = [3,1,2,4]
# 输出：[2,4,3,1]
# 解释：[4,2,3,1]、[2,4,1,3] 和 [4,2,1,3] 也会被视作正确答案。
# 示例 2：
# 输入：nums = [0]
# 输出：[0]


class Solution164:
    def sortArrayByParity(self, nums):
        z_list = [i for i in nums if i % 2 == 0]
        o_list = [i for i in nums if i % 2 == 1]
        return z_list + o_list


s164 = Solution164()
r164 = s164.sortArrayByParity([2, 5, 8, 3, 6, 9])
print(r164)  # [2, 8, 6, 5, 3, 9]


# 165: 按奇偶排序数组 II
# 给定一个非负整数数组 nums，  nums 中一半整数是 奇数 ，一半整数是 偶数 。
# 对数组进行排序，以便当 nums[i] 为奇数时，i 也是 奇数 ；当 nums[i] 为偶数时， i 也是 偶数 。
# 你可以返回 任何满足上述条件的数组作为答案 。
# 示例 1：
# 输入：nums = [4,2,5,7]
# 输出：[4,5,2,7]
# 解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。
# 示例 2：
# 输入：nums = [2,3]
# 输出：[2,3]


class Solution165:
    def sortArrayByParityII(self, nums):
        z_list = [i for i in nums if i % 2 == 0]
        o_list = [i for i in nums if i % 2 == 1]
        temp = []
        for i in range(len(z_list)):
            temp.append(z_list[i])
            temp.append(o_list[i])
        return temp


s165 = Solution165()
r165 = s165.sortArrayByParityII([2, 5, 8, 3, 6, 9])
print(r165)  # [2, 5, 8, 3, 6, 9]


# 166: 前K个高频单词
# 给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
# 返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
# 示例 1：
# 输入: words = ["i", "love", "leetcode", "i", "love", "coding"], k = 2
# 输出: ["i", "love"]
# 解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
#     注意，按字母顺序 "i" 在 "love" 之前。
# 示例 2：
# 输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
# 输出: ["the", "is", "sunny", "day"]
# 解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词，
#     出现次数依次为 4, 3, 2 和 1 次。


class Solution166:
    def topKFrequent(self, words, k: int):
        import collections
        m = collections.Counter(words)
        lst = [(k, v) for k, v in m.items()]
        lst.sort(key=lambda x: (-x[1], x[0]))
        return [lst[i][0] for i in range(k)]


s166 = Solution166()
r166 = s166.topKFrequent(["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k=4)
print(r166)  # ['the', 'is', 'sunny', 'day']


# 167: 前 K 个高频元素
# 给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
# 示例 1:
# 输入: nums = [1,1,1,2,2,3], k = 2
# 输出: [1,2]
# 示例 2:
# 输入: nums = [1], k = 1
# 输出: [1]


class Solution167:
    def topKFrequent(self, nums, k: int):
        lst = list(set([(nums.count(i), i) for i in nums]))
        lst.sort(reverse=True)
        return [lst[i][1] for i in range(k)]


s167 = Solution167()
r167 = s167.topKFrequent([1, 1, 1, 2, 2, 3], k=2)
print(r167)  # [1, 2]


# 168: 最接近原点的 K 个点
# 给定一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点，并且是一个整数 k ，
# 返回离原点 (0,0) 最近的 k 个点。
# 这里，平面上两点之间的距离是 欧几里德距离（ √(x1 - x2)2 + (y1 - y2)2 ）。
# 你可以按 任何顺序 返回答案。除了点坐标的顺序之外，答案 确保 是 唯一 的。
# 示例 1：
# 输入：points = [[1,3],[-2,2]], k = 1
# 输出：[[-2,2]]
# 解释：
# (1, 3) 和原点之间的距离为 sqrt(10)，
# (-2, 2) 和原点之间的距离为 sqrt(8)，
# 由于 sqrt(8) < sqrt(10)，(-2, 2) 离原点更近。
# 我们只需要距离原点最近的 K = 1 个点，所以答案就是 [[-2,2]]。
# 示例 2：
# 输入：points = [[3,3],[5,-1],[-2,4]], k = 2
# 输出：[[3,3],[-2,4]]
# （答案 [[-2,4],[3,3]] 也会被接受。）


class Solution168:
    def kClosest(self, points, k: int):
        # 平方和。排序
        points.sort(key=lambda x: (x[0] ** 2 + x[1] ** 2))
        return points[:k]


s168 = Solution168()
r168 = s168.kClosest([[3, 3], [5, -1], [-2, 4]], k=2)
print(r168)  # [[3, 3], [-2, 4]]


# 169: 数组中最大数对和的最小值
# 一个数对 (a,b) 的 数对和 等于 a + b 。最大数对和 是一个数对数组中最大的 数对和 。
# 比方说，如果我们有数对 (1,5) ，(2,3) 和 (4,4)，最大数对和 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8 。
# 给你一个长度为 偶数 n 的数组 nums ，请你将 nums 中的元素分成 n / 2 个数对，使得：
# nums 中每个元素 恰好 在 一个 数对中，且
# 最大数对和 的值 最小 。
# 请你在最优数对划分的方案下，返回最小的 最大数对和 。
# 示例 1：
# 输入：nums = [3,5,2,3]
# 输出：7
# 解释：数组中的元素可以分为数对 (3,3) 和 (5,2) 。
# 最大数对和为 max(3+3, 5+2) = max(6, 7) = 7 。
# 示例 2：
# 输入：nums = [3,5,4,2,4,6]
# 输出：8
# 解释：数组中的元素可以分为数对 (3,5)，(4,4) 和 (6,2) 。
# 最大数对和为 max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8 。


class Solution169:
    def minPairSum(self, nums) -> int:
        # 先排序。然后各取头和尾直到一半。这样的情况下应该是最小的。
        nums.sort()
        temp = set()
        a = int(len(nums) / 2)
        for i in range(a):
            temp.add(nums[i] + nums[-1 - i])
        return max(temp)


s169 = Solution169()
r169 = s169.minPairSum([3, 5, 4, 2, 4, 6])
print(r169)  # 8


# 170: 按符号重排数组
# 给你一个下标从 0 开始的整数数组 nums ，数组长度为 偶数 ，由数目相等的正整数和负整数组成。
# 你需要 重排 nums 中的元素，使修改后的数组满足下述条件：
# 任意 连续 的两个整数 符号相反
# 对于符号相同的所有整数，保留 它们在 nums 中的 顺序 。
# 重排后数组以正整数开头。
# 重排元素满足上述条件后，返回修改后的数组。
# 示例 1：
# 输入：nums = [3,1,-2,-5,2,-4]
# 输出：[3,-2,1,-5,2,-4]
# 解释：
# nums 中的正整数是 [3,1,2] ，负整数是 [-2,-5,-4] 。
# 重排的唯一可行方案是 [3,-2,1,-5,2,-4]，能满足所有条件。
# 像 [1,-2,2,-5,3,-4]、[3,1,2,-2,-5,-4]、[-2,3,-5,1,-4,2] 这样的其他方案是不正确的，因为不满足一个或者多个条件。
# 示例 2：
# 输入：nums = [-1,1]
# 输出：[1,-1]
# 解释：
# 1 是 nums 中唯一一个正整数，-1 是 nums 中唯一一个负整数。
# 所以 nums 重排为 [1,-1] 。


class Solution170:
    def rearrangeArray(self, nums):
        # 正整数列表
        # 负整数列表
        a_list = [i for i in nums if i >= 0]
        b_list = [i for i in nums if i < 0]
        temp = []
        for i in range(len(a_list)):
            temp.append(a_list[i])
            temp.append(b_list[i])
        return temp


s170 = Solution170()
r170 = s170.rearrangeArray([1, 2, -2, -1])
print(r170)  # [1, -2, 2, -1]