Leetcode算法-排序-简单

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"

输出: true

示例 2:

输入: s = "rat", t = "car"

输出: false

说明:

你可以假设字符串只包含小写字母。

进阶:

如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        return sorted(s) == sorted(t)

349. 两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]

输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]

输出：[9,4]
 
说明：

输出结果中的每个元素一定是唯一的。

我们可以不考虑输出结果的顺序。

class Solution:
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        return list(set(nums1) & set(nums2))

350. 两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]

输出: [2,2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]

输出: [4,9]

说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。

我们可以不考虑输出结果的顺序。

进阶:

如果给定的数组已经排好序呢？你将如何优化你的算法？

如果 nums1 的大小比 nums2 小很多，哪种方法更优？

如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        '''
        res = []
        for num in nums1:
            if num in nums2:
                nums2.remove(num)
                res.append(num)
        retun res
        '''
        nums1.sort()
        nums2.sort()
        res = []
        left, right = 0, 0
        while left < len(nums1) and right < len(nums2):
            if nums1[left] < nums2[right]:
                left += 1
            elif nums1[left] > nums2[right]:
                right += 1    
            else:
                res.append(nums1[left])
                left += 1
                right += 1
        return res

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] 也会被接受。

class Solution(object):
    def sortArrayByParityII(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        res = [0] * len(A)
        i,j = 0,1
        for k in range(len(A)):
            if A[k] % 2 == 0:
                res[i] = A[k]
                i += 2
            else:
                res[j] = A[k]
                j += 2
        return res

976. 三角形的最大周长

给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。

如果不能形成任何面积不为零的三角形，返回 0。

示例 1：

输入：[2,1,2]

输出：5

示例 2：

输入：[1,2,1]

输出：0

示例 3：

输入：[3,2,3,4]

输出：10

示例 4：

输入：[3,6,2,3]

输出：8

class Solution(object):
    def largestPerimeter(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        A = sorted(A)
        for i in range(len(A)-1,1,-1):
            a = A[i]
            b = A[i-1]
            c = A[i-2]
            if a<b+c:
                return a+b+c
        else:
            return 0

1030. 距离顺序排列矩阵单元格

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。

另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。

返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2) 之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）

示例 1：

输入：R = 1, C = 2, r0 = 0, c0 = 0

输出：[[0,0],[0,1]]

解释：从 (r0, c0) 到其他单元格的距离为：[0,1]

示例 2：

输入：R = 2, C = 2, r0 = 0, c0 = 1

输出：[[0,1],[0,0],[1,1],[1,0]]

解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]

[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。

示例 3：

输入：R = 2, C = 3, r0 = 1, c0 = 2

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

解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]

其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。

class Solution(object):
    def allCellsDistOrder(self, R, C, r0, c0):
        """
        :type R: int
        :type C: int
        :type r0: int
        :type c0: int
        :rtype: List[List[int]]
        """
        distance = {}
        for r in range(R):
            for c in range(C):
                dis = abs(r-r0) + abs(c-c0)
                if dis not in distance:
                    distance[dis] = []
                distance[dis].append([r,c])
        dis_list = sorted(distance.items())
        res = []
        for each in dis_list:
            res.extend(each[1])
        return res

1122. 数组的相对排序

给你两个数组，arr1 和 arr2，

arr2 中的元素各不相同

arr2 中的每个元素都出现在 arr1 中

对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

示例：

输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]

输出：[2,2,2,1,4,3,3,9,6,7,19]

提示：

arr1.length, arr2.length <= 1000

0 <= arr1[i], arr2[i] <= 1000

arr2 中的元素 arr2[i] 各不相同

arr2 中的每个元素 arr2[i] 都出现在 arr1 中

class Solution(object):
    def relativeSortArray(self, arr1, arr2):
        """
        :type arr1: List[int]
        :type arr2: List[int]
        :rtype: List[int]
        """
        arr3 = [0] * 1001
        res = []
        for i in arr1:
            arr3[i] += 1
        for i in arr2:
            res += [i] * arr3[i]
            arr3[i] = 0
        for i in range(len(arr3)):
            res += [i] * arr3[i]
        return res

1356. 根据数字二进制下 1 的数目排序

给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。

如果存在多个数字二进制中 1 的数目相同，则必须将它们按照数值大小升序排列。

请你返回排序后的数组。

示例 1：

输入：arr = [0,1,2,3,4,5,6,7,8]

输出：[0,1,2,4,8,3,5,6,7]

解释：[0] 是唯一一个有 0 个 1 的数。

[1,2,4,8] 都有 1 个 1 。

[3,5,6] 有 2 个 1 。

[7] 有 3 个 1 。

按照 1 的个数排序得到的结果数组为 [0,1,2,4,8,3,5,6,7]

示例 2：

输入：arr = [1024,512,256,128,64,32,16,8,4,2,1]

输出：[1,2,4,8,16,32,64,128,256,512,1024]

解释：数组中所有整数二进制下都只有 1 个 1 ，所以你需要按照数值大小将它们排序。

class Solution(object):
    def sortByBits(self, arr):
        """
        :type arr: List[int]
        :rtype: List[int]
        """
        def dec2bin(num):
            if num == 0:
                return 0
            res = 1
            if num / 2 != 0:
                res = dec2bin(num // 2) * 10 + num % 2
            return res
            
        tmp = []
        for each in arr:
            count = dec2bin(each)
            tmp.append([each,count])
        tmp2 = sorted(tmp,key=lambda x:(str(x[1]).count('1'),x[0]))
        res = []
        for each in tmp2:
            res.append(each[0])
        return res

# 另一个方法
class Solution:
    def sortByBits(self, arr: List[int]) -> List[int]:
        def cnt(n):
            return bin(n).count('1')
        return sorted(arr, key=lambda x: (cnt(x), x) )

1370. 上升下降字符串

给你一个字符串 s ，请你根据下面的算法重新构造字符串：

从 s 中选出 最小 的字符，将它 接在 结果字符串的后面。

从 s 剩余字符中选出 最小 的字符，且该字符比上一个添加的字符大，将它 接在 结果字符串后面。

重复步骤 2 ，直到你没法从 s 中选择字符。

从 s 中选出 最大 的字符，将它 接在 结果字符串的后面。

从 s 剩余字符中选出 最大 的字符，且该字符比上一个添加的字符小，将它 接在 结果字符串后面。

重复步骤 5 ，直到你没法从 s 中选择字符。

重复步骤 1 到 6 ，直到 s 中所有字符都已经被选过。

在任何一步中，如果最小或者最大字符不止一个 ，你可以选择其中任意一个，并将其添加到结果字符串。

请你返回将 s 中字符重新排序后的 结果字符串 。

示例 1：

输入：s = "aaaabbbbcccc"

输出："abccbaabccba"

解释：第一轮的步骤 1，2，3 后，结果字符串为 result = "abc"

第一轮的步骤 4，5，6 后，结果字符串为 result = "abccba"

第一轮结束，现在 s = "aabbcc" ，我们再次回到步骤 1

第二轮的步骤 1，2，3 后，结果字符串为 result = "abccbaabc"

第二轮的步骤 4，5，6 后，结果字符串为 result = "abccbaabccba"

示例 2：

输入：s = "rat"

输出："art"

解释：单词 "rat" 在上述算法重排序以后变成 "art"

class Solution(object):
    def sortString(self, s):
        """
        :type s: str
        :rtype: str
        """
        r = ''
        l = sorted(s)
        while l:
            last = ''
            n = len(l)
            i = 0
            while i < n:
                x = l[i]
                if x != last:
                    r += x
                    last = x
                    l.remove(x)
                    n = len(l)
                else:
                    i += 1
            last = ''
            j = len(l) - 1
            while 0 <= j < n:
                y = l[j]
                if y != last:
                    r += y
                    last = y
                    l.remove(y)
                    n = len(l)
                j -= 1
        return r

class Solution:
    def sortString(self, s: str) -> str:
        h = [0] * 26
        for ch in s:
            h[ord(ch) - 97] += 1

        def appendChar(ret, p):
            if h[p] > 0:
                h[p] -= 1
                ret.append(chr(p + 97))
        
        def haveChar():
            return any(h[i] > 0 for i in range(26))
        
        ret = list()
        while True:
            if not haveChar():
                break
            for i in range(26):
                appendChar(ret, i)
            for i in range(26):
                appendChar(ret, 25 - i)
        return "".join(ret)

# 另一个方法
class Solution:
    def sortString(self, s: str) -> str:
        str_counter = collections.Counter(s)
        result = []
        flag = False
        while str_counter:
            keys = list(str_counter.keys())
            keys.sort(reverse=flag)
            flag = not flag
            result.append(''.join(keys))
            str_counter -= collections.Counter(keys)
        return ''.join(result)

1403. 非递增顺序的最小子序列

给你一个数组 nums，请你从中抽取一个子序列，满足该子序列的元素之和 严格 大于未包含在该子序列中的各元素之和。

如果存在多个解决方案，只需返回 长度最小 的子序列。如果仍然有多个解决方案，则返回 元素之和最大 的子序列。

与子数组不同的地方在于，「数组的子序列」不强调元素在原数组中的连续性，也就是说，它可以通过从数组中分离一些（也可能不分离）元素得到。

注意，题目数据保证满足所有约束条件的解决方案是 唯一 的。同时，返回的答案应当按 非递增顺序 排列。

示例 1：

输入：nums = [4,3,10,9,8]

输出：[10,9]

解释：子序列 [10,9] 和 [10,8] 是最小的、满足元素之和大于其他各元素之和的子序列。但是 [10,9] 的元素之和最大。

示例 2：

输入：nums = [4,4,7,6,7]

输出：[7,7,6]

解释：子序列 [7,7] 的和为 14 ，不严格大于剩下的其他元素之和（14 = 4 + 4 + 6）。因此，[7,6,7] 是满足题意的最小子序列。注意，元素按非递增顺序返回。

class Solution(object):
    def minSubsequence(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        l = sorted(nums,reverse=True)
        for i in range(len(l)):
            x1 = l[:i+1]
            x2 = l[i+1:]
            if sum(x1) > sum(x2):
                return x1

# 另一个方法
class Solution(object):
    def minSubsequence(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        l = sorted(nums,reverse=True)
        half=int(sum(nums)/2)
        for i in range(len(l)):
            res = l[:i+1]
            if sum(res) > half:
                return res

1491. 去掉最低工资和最高工资后的工资平均值

给你一个整数数组 salary ，数组里每个数都是 唯一 的，其中 salary[i] 是第 i 个员工的工资。

请你返回去掉最低工资和最高工资以后，剩下员工工资的平均值。

示例 1：

输入：salary = [4000,3000,1000,2000]

输出：2500.00000

解释：最低工资和最高工资分别是 1000 和 4000 。

去掉最低工资和最高工资以后的平均工资是 (2000+3000)/2= 2500

示例 2：

输入：salary = [1000,2000,3000]

输出：2000.00000

解释：最低工资和最高工资分别是 1000 和 3000 。

去掉最低工资和最高工资以后的平均工资是 (2000)/1= 2000

示例 3：

输入：salary = [6000,5000,4000,3000,2000,1000]

输出：3500.00000

class Solution(object):
    def average(self, salary):
        """
        :type salary: List[int]
        :rtype: float
        """
        res = sorted(salary)[1:-1]
        res = sum(res)*1.0/len(res)
        return res

1502. 判断能否形成等差数列

给你一个数字数组 arr 。

如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。

如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。

示例 1：

输入：arr = [3,5,1]

输出：true

解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。

示例 2：

输入：arr = [1,2,4]

输出：false

解释：无法通过重新排序得到等差数列。

class Solution(object):
    def canMakeArithmeticProgression(self, arr):
        """
        :type arr: List[int]
        :rtype: bool
        """
        arr2 = sorted(arr)
        n = arr2[1] - arr2[0]
        for i in range(2,len(arr2)):
            if arr2[i] - arr2[i-1] != n:
                return False
        else:
            return True

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-anagram
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。