2605. 从两个数字数组里生成最小数字

诸神缄默不语-个人CSDN博文目录
力扣刷题笔记

1. 我自己写的

解法：如果有重复数字就直接输出最小的重复数字，如果没有就直接把两个列表里最小的数字拼在一起

（Python 3和Java的具体实现逻辑稍微有点差异，因为Java没有Python 3那么方便的API）

Python 3版：

class Solution:
    def minNumber(self, nums1: List[int], nums2: List[int]) -> int:
        #判断是否存在重复
        repetition_numbers=[]
        for number in nums1:
            if number in nums2:
                repetition_numbers.append(number)
        
        if len(repetition_numbers)>0:
            return min(repetition_numbers)
        else:
            nums1.sort()
            nums2.sort()
            
            if nums1[0]>nums2[0]:
                min_number=nums2[0]
                max_number=nums1[0]
            else:
                min_number=nums1[0]
                max_number=nums2[0]
            
            return int(str(min_number)+str(max_number))

Java版：

class Solution {
    public int minNumber(int[] nums1, int[] nums2) {
        int[] helper=new int[10];
        int min1=9,min2=9;
        for(int number:nums1){
            helper[number]+=1;
            min1=Math.min(min1,number);
        }
        for(int number:nums2){
            helper[number]+=1;
            min2=Math.min(min2,number);
        }

        //找重复值
        for(int number=1;number<=9;number++){
            if(helper[number]==2){
                return number;
            }
        }
        
        if(min1>min2){
            return min1+min2*10;
        }else{
            return min1*10+min2;
        }
    }
}

2. 题解

2.1 用哈希表来判断重复数字

class Solution {
    public int minNumber(int[] nums1, int[] nums2) {
        int s = same(nums1, nums2);
        if (s != -1) {
            return s;
        }
        
        int x = Arrays.stream(nums1).min().getAsInt();
        int y = Arrays.stream(nums2).min().getAsInt();
        return Math.min(x * 10 + y, y * 10 + x);
    }

    public int same(int[] nums1, int[] nums2) {
        Set<Integer> s = new HashSet<Integer>();
        for (int num : nums1) {
            s.add(num);
        }
        int x = 10;
        for (int num : nums2) {
            if (s.contains(num)) {
                x = Math.min(x, num);
            }
        }
        return x == 10 ? -1 : x;
    }
}

class Solution:
    def minNumber(self, nums1: List[int], nums2: List[int]) -> int:
        def same() -> int:
            s = set(nums1) & set(nums2)
            return -1 if not s else min(s)
        
        if (x := same()) != -1:
            return x
        
        x = min(nums1)
        y = min(nums2)
        return min(x * 10 + y, y * 10 + x)

2.2 用位运算判断重复数字

class Solution {
    public int minNumber(int[] nums1, int[] nums2) {
        int a = 0, b = 0;
        for (int num : nums1) a |= 1 << num;
        for (int num : nums2) b |= 1 << num;
        int c = a & b;
        if (c != 0)
            return Integer.numberOfTrailingZeros(c);
        int min1 = Integer.numberOfTrailingZeros(a);
        int min2 = Integer.numberOfTrailingZeros(b);
        return min1 < min2 ? min1 * 10 + min2 : min2 * 10 + min1;
    }
}

class Solution:
    def minNumber(self, nums1: List[int], nums2: List[int]) -> int:
        mask1 = mask2 = 0
        for x in nums1:
            mask1 |= 1 << x
        for x in nums2:
            mask2 |= 1 << x
        mask = mask1 & mask2
        if mask:
            return (mask & -mask).bit_length() - 1
        a = (mask1 & -mask1).bit_length() - 1
        b = (mask2 & -mask2).bit_length() - 1
        return min(a * 10 + b, b * 10 + a)

2.3 快排

对两个数组分别排序后可以用合并排序（也可以说双指针）的思路比较两者的共同值，排序后也可以直接得到两个数组的最小值，这样时间复杂度是nlogn，空间复杂度是1

（但是这个题目给的数字太小了，所以这么干意义不大……）