def keymap_data_clean(keyconfig_data: typing.List, *, relaxed: bool) -> None: """ Order & sanitize keymap data so the result from the hand written Python script is comparable with data exported & imported. """ keyconfig_data.sort(key=lambda a: a[0]) for _, _, km_items_data in keyconfig_data: items = km_items_data["items"] for i, (item_op, item_event, item_prop) in enumerate(items): if relaxed: # Prevent "alt": False from raising an error. defaults = { "alt": False, "ctrl": False, "shift": False, "any": False } defaults.update(item_event) item_event.update(defaults) if item_prop: properties = item_prop.get("properties") if properties: properties[:] = keymap_item_property_clean(properties) else: item_prop.pop("properties") # Needed so: `{"properties": ()}` matches `None` as there is no meaningful difference. # Wruting `None` makes the most sense when explicitly written, however generated properties # might be empty and it's not worth adding checks in the generation logic to use `None` # just to satisfy this check. if not item_prop: items[i] = item_op, item_event, None
def fourSum(self, nums: List[int], target: int) -> List[List[int]]: length = len(nums) result = [] List.sort(nums, reverse=False) if (length < 4): return result i = 0 j = length - 1 while (i < j): newTarget = target - nums[i] - nums[j] p = i + 1 q = j - 1 print("i,j", i, j) while (p < q): print("p,q", p, q) if (nums[p] + nums[q] == newTarget): result.append([nums[i], nums[p], nums[q], nums[j]]) old_p = p old_q = q while (p < q and nums[p] == nums[old_p]): p = p + 1 if (p == q): p = old_p while (p < q and nums[q] == nums[old_q]): q = q - 1 if (p == q): q = old_q if (p == old_p and q == old_q): break old_i = i old_j = j while (nums[i] == nums[old_i] and i < j): i = i + 1 if (i == j): i = old_i while (nums[j] == nums[old_j] and i < j): j = j - 1 if (i == j): j = old_j if (i == old_i and j == old_j): break return result
def collate_fn(self, batch: typing.List): src_tensors = [] trg_tensors = [] batch.sort(key=lambda x: len(x[1])) pad_idx = 0 max_seq_len = 0 for src_tokens, trg_tokens in batch: src_len = len(src_tokens) trg_len = len(trg_tokens) max_seq_len = max(max_seq_len, src_len, trg_len) src_max_seq_len = max_seq_len trg_max_seq_len = max_seq_len + 1 # длинна src должна быть на один меньше, чем длинна таргета # потому что потом тагрет нужно будет сдвинуть batch_size = len(batch) src_padded = torch.full((batch_size, src_max_seq_len), pad_idx, dtype=torch.long) trg_padded = torch.full((batch_size, trg_max_seq_len), pad_idx, dtype=torch.long) for i, src_trg in enumerate(batch): src_tokens, trg_tokens = src_trg src_padded[i, :len(src_tokens)] = torch.LongTensor(src_tokens) trg_padded[i, :len(trg_tokens)] = torch.LongTensor(trg_tokens) trg_y_padded = trg_padded[:, 1:] trg_padded = trg_padded[:, :-1] src_mask = (src_padded != pad_idx).unsqueeze(-2) trui_tensor = (torch.triu(torch.ones(batch_size, max_seq_len, max_seq_len), diagonal=1) == 0) trg_mask = (trg_y_padded != pad_idx).unsqueeze(-2) & trui_tensor num_target_tokens = (trg_y_padded != pad_idx).sum() return TransformerBatchedSequencesWithMasks(src_padded, src_mask, trg_padded, trg_y_padded, trg_mask, num_target_tokens)
def min_difference(a_list: typing.List, b_list: typing.List) -> typing.List: """ 计算两个列表的最小正数差值 b-a :param a_list: 数值列表1 :param b_list: 数值列表2 :return: """ # 排序 a_list.sort() b_list.sort() # 没有数据 终止 if len(a_list) == 0 or len(b_list) == 0: return [] # 没有一个a小于b if a_list[0] > b_list[-1]: return [] ret_dict = {} # 遍历b数组 for _b in b_list: for _a in a_list: _diff = _b - _a # 计算差值 # 如果差值合理 if _diff > 0: # 记录数值组合 if _diff in ret_dict: ret_dict[_diff].append((_a, _b)) else: ret_dict[_diff] = [(_a, _b)] # 字典键排序 _key_list = sorted(ret_dict) # 获取差值最小的数据组 可能有多个 ret_list = ret_dict[_key_list[0]] # 清除以选中的数据组 for _a, _b in ret_list: a_list.remove(_a) b_list.remove(_b) # 如果两个列表都有数据 if len(a_list) > 0 and len(b_list) > 0: ret_list += min_difference(a_list=a_list, b_list=b_list) # 递归 ret_list.sort(key=lambda _a: _a[0]) # 按a数据排序 return ret_list else: ret_list.sort(key=lambda _a: _a[0]) # 按a数据排序 return ret_list # 返回最小的额组合
def solution() -> List[str]: # File load json_file = open("pokemon_data.json", "r", encoding="UTF-8") pokemonLists = json.load(json_file) json_file.close List = [] # Extract condiion 1,2,3 for pokemon in pokemonLists: if ('くさ' in pokemon["types"]) \ and (pokemon["stats"]["hp"] >= 80)\ and (len(pokemon["abilities"]) + len(pokemon["hiddenAbilities"]) >= 3): List.append(pokemon["name"]) # Sort List.sort() return List
def __init__(self, data: typing.List, ctx: Context): self.ctx = ctx data.sort(key=lambda x: x.id) super().__init__(data, per_page=5)