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 = []