def hex_add(d: deque, c: deque) -> deque:
"""
сложение в столбик
:param d: первое слагаемое
:param c: второе слагаемое
:return: результат
"""
a = d.copy()
b = c.copy()
a.reverse()
b.reverse()
if len(a) < len(b):
a, b = b, a
if len(a) != len(b):
for _ in range(len(a) - len(b)):
b.append('0')
res = deque([])
trans = 0
for i in range(len(a)):
spam = ORDER.index(a[i]) + ORDER.index(b[i]) + trans
trans = spam // 16
res.appendleft(ORDER[spam % 16])
if trans:
res.appendleft(ORDER[trans])
return res
def recursive_combat(p1: deque, p2: deque):
previous_rounds_1 = list()
previous_rounds_2 = list()
while len(p1) > 0 and len(p2) > 0:
if p1 in previous_rounds_1 and p2 in previous_rounds_2:
return 1
previous_rounds_1.append(p1.copy())
previous_rounds_2.append(p2.copy())
card1 = p1.pop()
card2 = p2.pop()
winner_n = 0
if len(p1) >= card1 and len(p2) >= card2:
winner_n = recursive_combat(
deque(p1[-i] for i in range(card1, 0, -1)),
deque(p2[-i] for i in range(card2, 0, -1)))
else:
if card1 > card2:
winner_n = 1
elif card2 > card1:
winner_n = 2
if winner_n == 1:
p1.appendleft(card1)
p1.appendleft(card2)
elif winner_n == 2:
p2.appendleft(card2)
p2.appendleft(card1)
return 1 if len(p2) == 0 else 2
def play_game(p1: deque, p2: deque) -> (deque, deque):
p1, p2 = p1.copy(), p2.copy()
while p1 and p2:
c1, c2 = p1.popleft(), p2.popleft()
if c1 > c2:
p1.append(c1), p1.append(c2)
else:
p2.append(c2), p2.append(c1)
return p1, p2
def hex_mul(hex_0: deque, hex_1: deque) -> deque:
hex_0, hex_1 = hex_0.copy(), hex_1.copy()
result = deque()
while hex_1:
spam = deque()
for _ in range(HEX_DICT[hex_1.pop()]):
spam = hex_sum(spam, hex_0)
while len(spam) - len(
result) < 1: # мы за "столбики": сдвиг spam влево
spam.append('0') # freq += 1 != const; динамика
result = hex_sum(result, spam)
return result
def hex_sum(hex_0: deque, hex_1: deque, result=None, tail=0) -> deque:
hex_0, hex_1 = hex_0.copy(), hex_1.copy()
if not result: # обнуляем res при каждом вызове func ( -//- за нумером 2)
result = deque()
if len(hex_0) != len(hex_1): # выравниваем списки при необходимости
hex_0, hex_1 = hex_eq_len(hex_0, hex_1)
if not hex_0:
if tail:
result.appendleft('1') # добавляем 1 при переполнении
return result
spam = HEX_DICT[hex_0.pop()] + HEX_DICT[hex_1.pop()] + tail
result.appendleft(DEC_DICT[spam]) if spam < BASIS else \
result.appendleft(DEC_DICT[spam - BASIS])
tail = 0 if spam < BASIS else 1
return hex_sum(hex_0, hex_1, result, tail)
def __update_prob_recursive(self, start: GraphNode, probs: dict,
previous_words: deque):
fixed_previous_words = previous_words
for next_node in start.next:
previous_words = fixed_previous_words.copy()
pre_len = len(previous_words)
next_node: GraphNode = next_node # just for type declaration
# prior probability
prior_prob = probs[pre_len].probability(" ".join(previous_words))
# union probability
words = list(previous_words.copy())
words.append(next_node.value)
union_prob = probs[pre_len + 1].probability(" ".join(words))
local_prob = union_prob / prior_prob
accumulative_prob = local_prob * start.accumulative_prob
if next_node.best_previous is None or accumulative_prob > next_node.accumulative_prob:
next_node.accumulative_prob = accumulative_prob
next_node.best_previous = start
if start == self.end:
start.next.append(self.end)
self.end.previous.append(start)
return
# update previous words and continue recursion
previous_words.append(next_node.value)
if len(previous_words) >= self.ngram_size:
previous_words.popleft()
self.__update_prob_recursive(next_node, probs, previous_words)
def _add_most_similar_tokens(self, q: deque):
'''
Assumes proper query
Given a list of tokens, for each token in tokens, append the
most similar
'''
q1 = q.copy()
q2 = deque()
# Initialize by checking first element
token = q1.popleft()
q2.append(token)
if not (token in '()' or token in self.rdp.operators):
self._similar_adder(q2, token)
for token in q1:
q2.append(token)
if token in '()' or token in self.rdp.operators:
continue
# Dont add extra tokens if NOT operator
if q2[-2] == self.rdp.difference_operator:
continue
self._similar_adder(q2, token)
return q2
def deal(d: deque, count: int = 0) -> None:
if count == 0:
d.reverse()
return
_d: deque = d.copy()
while len(_d):
d[0] = _d.popleft()
d.rotate(-count)
def hex_sum(number1: deque, number2: deque) -> deque:
n1 = number1.copy()
n2 = number2.copy()
result = deque()
overhead = False
for i in range(max(len(n1), len(n2))):
d1 = n1.pop() if len(n1) > 0 else '0'
d2 = n2.pop() if len(n2) > 0 else '0'
spam = hex_digit_to_int(d1) + hex_digit_to_int(d2)
if overhead:
spam += 1
# print(d1, d2, hex_digit_to_int(d1), hex_digit_to_int(d2), spam, overhead)
# print(spam % 16)
overhead = spam // 16
result.appendleft(int_to_hex(spam % 16))
if overhead:
result.appendleft('1')
return result
def most_recent(buffer: deque, n: Union[None, int] = None):
"""Returns the most recent sequence of experience from a deque buffer."""
if n is None:
return buffer[0]
buffer_copy, vals = buffer.copy(), []
for _ in range(n):
vals.append(buffer_copy.popleft())
return vals
def recurrency_solution(numbers: deque, target):
global count
if len(numbers) == 0:
if target == 0:
count += 1
return count
else:
now_number = numbers.popleft()
temp_numbers1 = numbers.copy()
temp_numbers2 = numbers.copy()
recurrency_solution(temp_numbers1, target - now_number)
recurrency_solution(temp_numbers2, target + now_number)
def hex_mull(n1: deque, n2: deque) -> deque:
_num1 = n1.copy()
_num1.reverse()
_num2 = n2.copy()
_num2.reverse()
result = deque()
for i in _num1:
row = deque()
overhead = 0
for j in _num2:
spam = hex_digit_to_int(i) * hex_digit_to_int(j)
spam += overhead
row.appendleft(int_to_hex(spam % 16))
overhead = spam // 16
if overhead > 0:
row.appendleft(int_to_hex(overhead))
result = hex_sum(result, row)
_num2.appendleft('0')
if result.count('0') == len(result):
result = deque('0')
return result
def hex_mul(d: deque, c: deque) -> deque:
"""
умножение в столбик
:param d: первый множитель
:param c: второй множитель
:return: результат
"""
a = d.copy()
b = c.copy()
res = deque([])
array = []
add_zero = 0
b.reverse()
for i in b:
spam = hex_mul_one(a, i)
for _ in range(add_zero):
spam.append('0')
array.append(spam)
add_zero += 1
for j in range(len(array)):
res = hex_add(res, array[j])
return res
def hex_mul_one(d: deque, b: str) -> deque:
"""
вспомогательная операция умножения числа на одну цифру для умножения в столбик
:param d: число
:param b: цифра
:return: результат
"""
a = d.copy()
res = deque([])
trans = 0
a.reverse()
for i in a:
spam = (ORDER.index(i) * ORDER.index(b)) + trans
trans = spam // 16
res.appendleft(ORDER[spam % 16])
if trans:
res.appendleft(ORDER[trans])
return res
def parenthesis_handler(self, querytokens: deque):
'''
Expects proper query
Turns deque
retarded OR (white AND (woman NOT man))
to
['retarded', 'OR', ['white', 'AND', ['woman','NOT','man']]]
'''
q1 = querytokens.copy()
q2 = deque()
while len(q1) > 0:
token = q1.popleft()
if token == '(':
q_temp: deque = self._get_in_parenthesis(q1)
q2.append(self.parenthesis_handler(q_temp))
else:
q2.append(token)
return q2
def convert_letter(spam: deque, key='indigit'):
num = spam.copy()
if not num:
return deque([0])
for i, item in enumerate(num):
num[i] = str(item)
if key == 'indigit':
for count, item in enumerate(num):
if item in 'ABCDEF':
num[count] = LETTER_DICT[item]
else:
num[count] = int(item)
else:
for count, item in enumerate(num):
if item in ('10', '11', '12', '13', '14', '15'):
num[count] = list(LETTER_DICT.keys())[int(item) - 10]
else:
num[count] = str(item)
return num
def assert_query(self, querytokens: deque, errmsgs: list) -> bool:
'''
Check if query is properly formatted. Returns True if everything is ok,
else False.
'''
q = querytokens.copy()
p_list = []
p_counter = 0
flag = True
curr = q.popleft()
##### Initialize by checking the first token #####
# Stray closing parenthesis
if curr == ')':
p_counter -= 1
p_list.append(p_counter)
flag = False
if curr == '(':
p_counter += 1
p_list.append(p_counter)
# If query is starting with an operator
if curr in self.operators:
errmsgs.append(f'SyntaxError: First token "{curr}" is an operator')
flag = False
# If querytokens consisted of only a single token
if len(q) == 0:
if p_counter != 0:
errmsgs.append(f'SyntaxError: Stray parenthesis')
flag = False
return flag
##################################################
prev = curr
# Runs if more than one token left
while len(q) > 0:
curr: str = q.popleft()
if curr == '(':
p_counter += 1
p_list.append(p_counter)
if curr == ')':
p_counter -= 1
p_list.append(p_counter)
# If curr is operator
if curr in self.operators:
# Two succeeding operators
if prev in self.operators:
errmsgs.append(
f'SyntaxError: Two succeeding operators "{prev} {curr}"'
)
flag = False
prev = curr
# Should only be one token left when interpreter is here
# If ending with an operator
if prev in self.operators:
errmsgs.append(f'SyntaxError: Last token "{prev}" is an operator')
flag = False
###### Check paranthesis' #####
# If unbalanced number of parenthesis'
if p_counter > 0:
errmsgs.append(f'SyntaxError: Found stray opening parenthesis')
flag = False
# Check if any negative values in p_list, implies stray closing
# parenthesis
if any((x < 0 for x in p_list)):
errmsgs.append(f'SyntaxError: Found stray closing parenthesis')
flag = False
###############################
return flag
def __init__(self, deque_1: deque, deque_2: deque):
self.deque_1 = deque_1.copy()
self.deque_2 = deque_2.copy()
self.deque_1_history = []
self.deque_2_history = []
