剑指offer 刷题 十六 排序（45 61）

剑指 Offer 45. 把数组排成最小的数
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

非常冗余的代码。我自己写的，但是题目理解错了，我把每个数字都拆分了，题目的要求是不能拆分。。。所以[20,1]，我的代码输出102.答案是120.。。。

def minNumber(self, nums: List[int]) -> str:
        li = []
        for num in nums:
            if 10 <= num <= 100:
                li += self.divide(num)
            else:
                li.append(num)
        count = 0
        for i in li:
            if i == 0:
                count += 1
        li.sort()
        first_val = li[count]
        del li[count]
        ss = str(first_val)
        for i in li:
            ss = str(ss) + str(i)
        return ss

    def divide(self, num):
        li = []
        while num > 0:
            c = num % 10
            li.append(c)
            num = num // 10
        return li

下面是大佬的思路和代码：






大佬代码：

class Solution:
    def minNumber(self, nums: List[int]) -> str:
        def quick_sort(l , r):
            if l >= r: return
            i, j = l, r
            while i < j:
                while strs[j] + strs[l] >= strs[l] + strs[j] and i < j: j -= 1
                while strs[i] + strs[l] <= strs[l] + strs[i] and i < j: i += 1
                strs[i], strs[j] = strs[j], strs[i]
            strs[i], strs[l] = strs[l], strs[i]
            quick_sort(l, i - 1)
            quick_sort(i + 1, r)
        
        strs = [str(num) for num in nums]
        quick_sort(0, len(strs) - 1)
        return ''.join(strs)

根据大佬的思路，写了一个冒泡排序

def minNumber(self, nums: List[int]) -> str:
        for i in range(len(nums)-1):
            for j in range(i+1, len(nums)):
                if str(nums[j]) + str(nums[i]) < str(nums[i]) + str(nums[j]):
                    nums[j], nums[i] = nums[i], nums[j]
        return "".join([str(i) for i in nums])

这道题的关键还是字符串相加比大小，大佬的证明如下：

剑指 Offer 61. 扑克牌中的顺子
从若干副扑克牌中随机抽 5 张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。

自己写的代码，比较冗余：

def isStraight(self, nums: List[int]) -> bool:
        cur, count = 0, 0
        nums.sort()
        while cur < len(nums) - 1:
            if nums[cur] == 0:
                count += 1
                cur += 1
            elif nums[cur] == nums[cur+1]:
                return False
            elif nums[cur] + 1 == nums[cur+1]:
                cur += 1
            elif nums[cur] + 1 + count >= nums[cur+1]:
                count -= 1
                cur += 1
            else:
                return False
        if cur == len(nums) - 1:
            return True
        else:
            return False

下面是大佬的思路和代码：










根据大佬思路，自己写了一遍代码，和下面对照了一下，代码思路用法差不多：

def isStraight(self, nums: List[int]) -> bool:
        mi, ma = 14, 0
        repeat = set()
        for num in nums:
            if num != 0 and num not in repeat:
                repeat.add(num)
            elif num in repeat:
                return False
            elif num == 0:
                continue
            mi = min(mi, num)
            ma = max(ma, num)

        if ma - mi < 5:
            return True
        else: return False

大佬代码：

class Solution:
    def isStraight(self, nums: List[int]) -> bool:
        repeat = set()
        ma, mi = 0, 14
        for num in nums:
            if num == 0: continue # 跳过大小王
            ma = max(ma, num) # 最大牌
            mi = min(mi, num) # 最小牌
            if num in repeat: return False # 若有重复，提前返回 false
            repeat.add(num) # 添加牌至 Set
        return ma - mi < 5 # 最大牌 - 最小牌 < 5 则可构成顺子 

接下来是方法二，和我的思路比较像。








下面是大佬的代码，思路和我一样，但是代码实在是太简单了。。。

class Solution:
    def isStraight(self, nums: List[int]) -> bool:
        joker = 0
        nums.sort() # 数组排序
        for i in range(4):
            if nums[i] == 0: joker += 1 # 统计大小王数量
            elif nums[i] == nums[i + 1]: return False # 若有重复，提前返回 false
        return nums[4] - nums[joker] < 5 # 最大牌 - 最小牌 < 5 则可构成顺子