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
（但是这个题目给的数字太小了，所以这么干意义不大……）