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)
