[2022/7/17]科研整理

Posted 2023-02-28 lyz_fish

BERT两个预训练任务

• Masked LM
• Next Sentence Prediction

class Solution(object):
    def numberOfPairs(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        hash_map = collections.defaultdict(int)
        front,last = 0,0
        for i in nums:
            hash_map[i] += 1
        for i in hash_map:
            if hash_map[i] % 2 != 0:
                last += 1
                front += hash_map[i] //2
            else:
                front += hash_map[i]//2
        return [front,last]

6164. 数位和相等数对的最大和 :给你一个下标从 0 开始的数组 nums ，数组中的元素都是 正 整数。请你选出两个下标 i 和 j（i != j），且 nums[i] 的数位和 与 nums[j] 的数位和相等。

请你找出所有满足条件的下标 i 和 j ，找出并返回 nums[i] + nums[j] 可以得到的 最大值 .

输入：nums = [18,43,36,13,7]
输出：54
解释：满足条件的数对 (i, j) 为：
- (0, 2) ，两个数字的数位和都是 9 ，相加得到 18 + 36 = 54 。
- (1, 4) ，两个数字的数位和都是 7 ，相加得到 43 + 7 = 50 。
所以可以获得的最大和是 54 。

输入：nums = [10,12,19,14]
输出：-1
解释：不存在满足条件的数对，返回 -1 。

Leetcode周赛，AC一道题

## 代码超时
class Solution(object):
    def maximumSum(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        list_ = list()
        for i in nums:
            #计算数位和
            temp_num = i
            tem_bit = i % 10
            while(temp_num != 0):
                temp_num //= 10
                tem_bit += temp_num % 10
            list_.append(tem_bit)
        res_lsit = list()
        left,right=0,1
        n = len(list_)
        print(list_)
        while left<n-1:
            right = left + 1
            while right < n:
                if list_[left] == list_[right]:
                    res_lsit.append(nums[left]+nums[right])
                right += 1
            left += 1
        if res_lsit != []:
            return max(res_lsit)
        else:
            return -1

##大神代码
#建立哈希表，然后键值为位数和，然后存储对应位数和的list到其中。
class Solution:
    def maximumSum(self, nums: List[int]) -> int:
        cor=defaultdict(list)
        for num in nums:
            c=0
            for i in str(num):
                c+=ord(i)-ord('0')
            cor[c].append(num)
        ans=-1
        for c,l in cor.items():
            if len(l)>=2:
                ans=max(ans,sum(sorted(l)[-2:]))
        return ans

裁剪数字后查询第 K 小的数字

给你一个下标从 0 开始的字符串数组 nums ，其中每个字符串 长度相等 且只包含数字。

再给你一个下标从 0 开始的二维整数数组 queries ，其中 queries[i] = [ki, trimi] 。对于每个 queries[i] ，你需要：

• 将 nums 中每个数字 裁剪 到剩下 最右边 trimi 个数位。
• 在裁剪过后的数字中，找到 nums 中第 ki 小数字对应的 下标 。如果两个裁剪后数字一样大，那么下标 更小 的数字视为更小的数字。
• 将 nums 中每个数字恢复到原本字符串。

请你返回一个长度与 queries 相等的数组 answer，其中 answer[i]是第 i 次查询的结果。

提示：

• 裁剪到剩下 x 个数位的意思是不断删除最左边的数位，直到剩下 x 个数位。

• nums 中的字符串可能会有前导 0 。

  例子

  输入：nums = ["102","473","251","814"], queries = [[1,1],[2,3],[4,2],[1,2]]
  输出：[2,2,1,0]
  解释：
  1. 裁剪到只剩 1 个数位后，nums = ["2","3","1","4"] 。最小的数字是 1 ，下标为 2 。
  2. 裁剪到剩 3 个数位后，nums 没有变化。第 2 小的数字是 251 ，下标为 2 。
  3. 裁剪到剩 2 个数位后，nums = ["02","73","51","14"] 。第 4 小的数字是 73 ，下标为 1 。
  4. 裁剪到剩 2 个数位后，最小数字是 2 ，下标为 0 。
     注意，裁剪后数字 "02" 值为 2 。
  

  例子2

  输入：nums = ["24","37","96","04"], queries = [[2,1],[2,2]]
  输出：[3,0]
  解释：
  1. 裁剪到剩 1 个数位，nums = ["4","7","6","4"] 。第 2 小的数字是 4 ，下标为 3 。
     有两个 4 ，下标为 0 的 4 视为小于下标为 3 的 4 。
  2. 裁剪到剩 2 个数位，nums 不变。第二小的数字是 24 ，下标为 0 。
  

class Solution:
    def smallestTrimmedNumbers(self, nums: List[str], queries: List[List[int]]) -> List[int]:
        arr = list()
        for k, trim in queries:
            ans = sorted((zip([num[-trim:] for num in nums],range(len(nums)))))
            arr.append(ans[k-1][1])
        return arr

https://leetcode.cn/contest/weekly-contest-302/problems/minimum-deletions-to-make-array-divisible/

class Solution:
    def minOperations(self, nums: List[int], numsDivide: List[int]) -> int:
        map_num = Counter(sorted(nums))
        print(map_num)
        ans = 0
        longs = dict(Counter(numsDivide))
        for short in map_num:
            temp_counter =0
            print('short is \\t',short)
            for long in longs:#和所有的互素
                # print('short\\t',short)
                if gcd(short,long) == short:# 可整除
                    temp_counter += 1
                    print("可以整除\\t",long,short,temp_counter,gcd(short,long))
                    
                elif gcd(short,long) != short:# 不可整除
                    ans += map_num[short]
                    print('不可整除\\t',long,short,ans)
                    break
                if temp_counter == len(longs):
                    return ans
                    
        return -1