第一题：剑指 Offer 40. 最小的k个数

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]
 
限制：
0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

解法：简单粗暴调用python列表的sort()方法或者sorted()函数，再返回前k个数字即可。

代码：

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        arr.sort()
        return arr[:k]

第二题：2562. 找出数组的串联值

给你一个下标从 0 开始的整数数组 nums 。

现定义两个数字的 串联 是由这两个数值串联起来形成的新数字。

例如，15 和 49 的串联是 1549 。
nums 的 串联值 最初等于 0 。执行下述操作直到 nums 变为空：

如果 nums 中存在不止一个数字，分别选中 nums 中的第一个元素和最后一个元素，将二者串联得到的值加到 nums 的 串联值 上，然后从 nums 中删除第一个和最后一个元素。
如果仅存在一个元素，则将该元素的值加到 nums 的串联值上，然后删除这个元素。
返回执行完所有操作后 nums 的串联值。

示例 1：

输入：nums = [7,52,2,4]
输出：596
解释：在执行任一步操作前，nums 为 [7,52,2,4] ，串联值为 0 。
 - 在第一步操作中：
我们选中第一个元素 7 和最后一个元素 4 。
二者的串联是 74 ，将其加到串联值上，所以串联值等于 74 。
接着我们从 nums 中移除这两个元素，所以 nums 变为 [52,2] 。
 - 在第二步操作中： 
我们选中第一个元素 52 和最后一个元素 2 。 
二者的串联是 522 ，将其加到串联值上，所以串联值等于 596 。
接着我们从 nums 中移除这两个元素，所以 nums 变为空。
由于串联值等于 596 ，所以答案就是 596 。
示例 2：

输入：nums = [5,14,13,8,12]
输出：673
解释：在执行任一步操作前，nums 为 [5,14,13,8,12] ，串联值为 0 。 
- 在第一步操作中： 
我们选中第一个元素 5 和最后一个元素 12 。 
二者的串联是 512 ，将其加到串联值上，所以串联值等于 512 。 
接着我们从 nums 中移除这两个元素，所以 nums 变为 [14,13,8] 。
- 在第二步操作中：
我们选中第一个元素 14 和最后一个元素 8 。
二者的串联是 148 ，将其加到串联值上，所以串联值等于 660 。
接着我们从 nums 中移除这两个元素，所以 nums 变为 [13] 。 
- 在第三步操作中：
nums 只有一个元素，所以我们选中 13 并将其加到串联值上，所以串联值等于 673 。
接着我们从 nums 中移除这个元素，所以 nums 变为空。 
由于串联值等于 673 ，所以答案就是 673 。
 
提示：

1 <= nums.length <= 1000
1 <= nums[i] <= 10^4

解法：写一个循环进行首位数字进行拼接并转为int类型的，最后循环完毕若是元素个数偶数个则直接返回结果，若是奇数个，则再加上一个中间位置的数即可。

代码：

class Solution:
    def findTheArrayConcVal(self, nums: List[int]) -> int:
        sum = 0
        for i in range(len(nums) // 2):
            sum += int(str(nums[i]) + str(nums[len(nums) - i - 1]))
        if len(nums) % 2 == 0:
            return sum    
        else:
            return sum + nums[len(nums) // 2]

第三题：136. 只出现一次的数字

给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。
 

示例 1 ：

输入：nums = [2,2,1]
输出：1
示例 2 ：

输入：nums = [4,1,2,1,2]
输出：4
示例 3 ：

输入：nums = [1]
输出：1
 

提示：

1 <= nums.length <= 3 * 10^4
-3 * 10^4 <= nums[i] <= 3 * 10^4
除了某个元素只出现一次以外，其余每个元素均出现两次。

解法1：若不考虑线性时间复杂度，可以将每个数字都放到字典中存储，元素作为key，出现的次数作为value，遍历完一次列表再返回值为1的对应的键的值即可。

代码1：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        cnt_dict = {}
        for i in nums:
            if i not in cnt_dict.keys():
                cnt_dict[i] = 0
            else:
                cnt_dict[i] += 1
        return min(cnt_dict.items(),key=lambda x:x[1])[0]

解法2：若考虑线性时间复杂度，可以使用异或的原理进行解决。

交换律：a ^ b ^ c <=> a ^ c ^ b

任何数于0异或为任何数 0 ^ n => n

相同的数异或为0: n ^ n => 0

代码2：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        res = 0
        for i in nums:
            res ^= i

        return res

第三题：169. 多数元素

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

 

示例 1：

输入：nums = [3,2,3]
输出：3
示例 2：

输入：nums = [2,2,1,1,1,2,2]
输出：2
 

提示：
n == nums.length
1 <= n <= 5 * 10^4
-10^9 <= nums[i] <= 10^9

解法：如上题思路所述可以将每个数字都放到字典中存储，元素作为key，出现的次数作为value，遍历完一次列表再返回值最大的对应的键的值即可。

代码：

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        num_dict = {}
        
        for ele in nums:
            if ele not in num_dict.keys():
                cnt = 1
                num_dict[ele] = cnt
            else:
                num_dict[ele] += 1
        max_key = max(num_dict.items(), key=lambda x: x[1])[0]
        return max_key