function stringlengths 18 3.86k | intent_category stringlengths 5 24 |
|---|---|
def __init__(self, value: T) -> None:
self._value: T = value
self.left: RandomizedHeapNode[T] | None = None
self.right: RandomizedHeapNode[T] | None = None | data_structures |
def value(self) -> T:
if not root1:
return root2
if not root2:
return root1
if root1.value > root2.value:
root1, root2 = root2, root1
if random.choice([True, False]):
root1.left, root1.right = root1.right, root1.left
root1.left ... | data_structures |
def __init__(self, data: Iterable[T] | None = ()) -> None:
self._root: RandomizedHeapNode[T] | None = None
if data:
for item in data:
self.insert(item) | data_structures |
def insert(self, value: T) -> None:
self._root = RandomizedHeapNode.merge(self._root, RandomizedHeapNode(value)) | data_structures |
def pop(self) -> T | None:
result = self.top()
if self._root is None:
return None
self._root = RandomizedHeapNode.merge(self._root.left, self._root.right)
return result | data_structures |
def top(self) -> T:
if not self._root:
raise IndexError("Can't get top element for the empty heap.")
return self._root.value | data_structures |
def clear(self) -> None:
self._root = None | data_structures |
def to_sorted_list(self) -> list[Any]:
result = []
while self:
result.append(self.pop())
return result | data_structures |
def __bool__(self) -> bool:
return self._root is not None | data_structures |
def __init__(self, val):
self.val = val
# Number of nodes in left subtree
self.left_tree_size = 0
self.left = None
self.right = None
self.parent = None | data_structures |
def merge_trees(self, other):
assert self.left_tree_size == other.left_tree_size, "Unequal Sizes of Blocks"
if self.val < other.val:
other.left = self.right
other.parent = None
if self.right:
self.right.parent = other
self.right = other
... | data_structures |
def __init__(self, bottom_root=None, min_node=None, heap_size=0):
self.size = heap_size
self.bottom_root = bottom_root
self.min_node = min_node | data_structures |
def merge_heaps(self, other):
# Empty heaps corner cases
if other.size == 0:
return None
if self.size == 0:
self.size = other.size
self.bottom_root = other.bottom_root
self.min_node = other.min_node
return None
# Update size
... | data_structures |
def insert(self, val):
if self.size == 0:
self.bottom_root = Node(val)
self.size = 1
self.min_node = self.bottom_root
else:
# Create new node
new_node = Node(val)
# Update size
self.size += 1
# update min_n... | data_structures |
def peek(self):
return self.min_node.val | data_structures |
def is_empty(self):
return self.size == 0 | data_structures |
def delete_min(self):
# assert not self.isEmpty(), "Empty Heap"
# Save minimal value
min_value = self.min_node.val
# Last element in heap corner case
if self.size == 1:
# Update size
self.size = 0
# Update bottom root
self.bottom... | data_structures |
def pre_order(self):
# Find top root
top_root = self.bottom_root
while top_root.parent:
top_root = top_root.parent
# preorder
heap_pre_order = []
self.__traversal(top_root, heap_pre_order)
return heap_pre_order | data_structures |
def __traversal(self, curr_node, preorder, level=0):
if curr_node:
preorder.append((curr_node.val, level))
self.__traversal(curr_node.left, preorder, level + 1)
self.__traversal(curr_node.right, preorder, level + 1)
else:
preorder.append(("#", level)) | data_structures |
def __str__(self):
if self.is_empty():
return ""
preorder_heap = self.pre_order()
return "\n".join(("-" * level + str(value)) for value, level in preorder_heap) | data_structures |
def __init__(self):
self.__heap = [0]
self.__size = 0 | data_structures |
def __swap_up(self, i: int) -> None:
self.__heap.append(value)
self.__size += 1
self.__swap_up(self.__size) | data_structures |
def __swap_down(self, i: int) -> None:
max_value = self.__heap[1]
self.__heap[1] = self.__heap[self.__size]
self.__size -= 1
self.__heap.pop()
self.__swap_down(1)
return max_value | data_structures |
def get_list(self):
return self.__heap[1:] | data_structures |
def permute(nums: list[int]) -> list[list[int]]:
result = []
if len(nums) == 1:
return [nums.copy()]
for _ in range(len(nums)):
n = nums.pop(0)
permutations = permute(nums)
for perm in permutations:
perm.append(n)
result.extend(permutations)
nums.a... | data_structures |
def __init__(self, array: list[int]) -> None:
len_array = len(array)
self.prefix_sum = [0] * len_array
if len_array > 0:
self.prefix_sum[0] = array[0]
for i in range(1, len_array):
self.prefix_sum[i] = self.prefix_sum[i - 1] + array[i] | data_structures |
def get_sum(self, start: int, end: int) -> int:
if start == 0:
return self.prefix_sum[end]
return self.prefix_sum[end] - self.prefix_sum[start - 1] | data_structures |
def contains_sum(self, target_sum: int) -> bool:
sums = {0}
for sum_item in self.prefix_sum:
if sum_item - target_sum in sums:
return True
sums.add(sum_item)
return False | data_structures |
def __init__(self, cur: Deque._Node | None) -> None:
self._cur = cur | data_structures |
def __iter__(self) -> Deque._Iterator:
return self | data_structures |
def __next__(self) -> Any:
if self._cur is None:
# finished iterating
raise StopIteration
val = self._cur.val
self._cur = self._cur.next_node
return val | data_structures |
def __init__(self, iterable: Iterable[Any] | None = None) -> None:
self._front: Any = None
self._back: Any = None
self._len: int = 0
if iterable is not None:
# append every value to the deque
for val in iterable:
self.append(val) | data_structures |
def append(self, val: Any) -> None:
node = self._Node(val, None, None)
if self.is_empty():
# front = back
self._front = self._back = node
self._len = 1
else:
# connect nodes
self._back.next_node = node
node.prev_node = self.... | data_structures |
def appendleft(self, val: Any) -> None:
node = self._Node(val, None, None)
if self.is_empty():
# front = back
self._front = self._back = node
self._len = 1
else:
# connect nodes
node.next_node = self._front
self._front.prev_... | data_structures |
def extend(self, iterable: Iterable[Any]) -> None:
for val in iterable:
self.append(val) | data_structures |
def extendleft(self, iterable: Iterable[Any]) -> None:
for val in iterable:
self.appendleft(val) | data_structures |
def pop(self) -> Any:
# make sure the deque has elements to pop
assert not self.is_empty(), "Deque is empty."
topop = self._back
self._back = self._back.prev_node # set new back
# drop the last node - python will deallocate memory automatically
self._back.next_node = No... | data_structures |
def popleft(self) -> Any:
# make sure the deque has elements to pop
assert not self.is_empty(), "Deque is empty."
topop = self._front
self._front = self._front.next_node # set new front and drop the first node
self._front.prev_node = None
self._len -= 1
return... | data_structures |
def is_empty(self) -> bool:
return self._front is None | data_structures |
def __len__(self) -> int:
return self._len | data_structures |
def __eq__(self, other: object) -> bool:
if not isinstance(other, Deque):
return NotImplemented
me = self._front
oth = other._front
# if the length of the dequeues are not the same, they are not equal
if len(self) != len(other):
return False
wh... | data_structures |
def __iter__(self) -> Deque._Iterator:
return Deque._Iterator(self._front) | data_structures |
def __repr__(self) -> str:
values_list = []
aux = self._front
while aux is not None:
# append the values in a list to display
values_list.append(aux.val)
aux = aux.next_node
return f"[{', '.join(repr(val) for val in values_list)}]" | data_structures |
def __init__(self, initial_capacity: int = 6) -> None:
self.front: Node | None = None
self.rear: Node | None = None
self.create_linked_list(initial_capacity) | data_structures |
def create_linked_list(self, initial_capacity: int) -> None:
current_node = Node()
self.front = current_node
self.rear = current_node
previous_node = current_node
for _ in range(1, initial_capacity):
current_node = Node()
previous_node.next = current_node
... | data_structures |
def is_empty(self) -> bool:
return (
self.front == self.rear
and self.front is not None
and self.front.data is None
) | data_structures |
def first(self) -> Any | None:
self.check_can_perform_operation()
return self.front.data if self.front else None | data_structures |
def enqueue(self, data: Any) -> None:
if self.rear is None:
return
self.check_is_full()
if not self.is_empty():
self.rear = self.rear.next
if self.rear:
self.rear.data = data | data_structures |
def dequeue(self) -> Any:
self.check_can_perform_operation()
if self.rear is None or self.front is None:
return None
if self.front == self.rear:
data = self.front.data
self.front.data = None
return data
old_front = self.front
self.... | data_structures |
def check_can_perform_operation(self) -> None:
if self.is_empty():
raise Exception("Empty Queue") | data_structures |
def check_is_full(self) -> None:
if self.rear and self.rear.next == self.front:
raise Exception("Full Queue") | data_structures |
def __init__(self) -> None:
self.data: Any | None = None
self.next: Node | None = None
self.prev: Node | None = None | data_structures |
def __init__(self):
self.queues = [
[],
[],
[],
] | data_structures |
def enqueue(self, priority: int, data: int) -> None:
try:
if len(self.queues[priority]) >= 100:
raise OverflowError("Maximum queue size is 100")
self.queues[priority].append(data)
except IndexError:
raise ValueError("Valid priorities are 0, 1, and 2") | data_structures |
def dequeue(self) -> int:
for queue in self.queues:
if queue:
return queue.pop(0)
raise UnderFlowError("All queues are empty") | data_structures |
def __str__(self) -> str:
return "\n".join(f"Priority {i}: {q}" for i, q in enumerate(self.queues)) | data_structures |
def __init__(self):
self.queue = [] | data_structures |
def enqueue(self, data: int) -> None:
if len(self.queue) == 100:
raise OverFlowError("Maximum queue size is 100")
self.queue.append(data) | data_structures |
def dequeue(self) -> int:
if not self.queue:
raise UnderFlowError("The queue is empty")
else:
data = min(self.queue)
self.queue.remove(data)
return data | data_structures |
def __str__(self) -> str:
return str(self.queue) | data_structures |
def fixed_priority_queue():
fpq = FixedPriorityQueue()
fpq.enqueue(0, 10)
fpq.enqueue(1, 70)
fpq.enqueue(0, 100)
fpq.enqueue(2, 1)
fpq.enqueue(2, 5)
fpq.enqueue(1, 7)
fpq.enqueue(2, 4)
fpq.enqueue(1, 64)
fpq.enqueue(0, 128)
print(fpq)
print(fpq.dequeue())
print(fpq.de... | data_structures |
def element_priority_queue():
epq = ElementPriorityQueue()
epq.enqueue(10)
epq.enqueue(70)
epq.enqueue(100)
epq.enqueue(1)
epq.enqueue(5)
epq.enqueue(7)
epq.enqueue(4)
epq.enqueue(64)
epq.enqueue(128)
print(epq)
print(epq.dequeue())
print(epq.dequeue())
print(epq.... | data_structures |
def __init__(self, data: bytes) -> None:
self.data = data
# Initialize hash values
self.hashes = [
0x6A09E667,
0xBB67AE85,
0x3C6EF372,
0xA54FF53A,
0x510E527F,
0x9B05688C,
0x1F83D9AB,
0x5BE0CD19,
... | hashes |
def preprocessing(data: bytes) -> bytes:
padding = b"\x80" + (b"\x00" * (63 - (len(data) + 8) % 64))
big_endian_integer = struct.pack(">Q", (len(data) * 8))
return data + padding + big_endian_integer | hashes |
def final_hash(self) -> None:
# Convert into blocks of 64 bytes
self.blocks = [
self.preprocessed_data[x : x + 64]
for x in range(0, len(self.preprocessed_data), 64)
]
for block in self.blocks:
# Convert the given block into a list of 4 byte integers
... | hashes |
def ror(self, value: int, rotations: int) -> int:
return 0xFFFFFFFF & (value << (32 - rotations)) | (value >> rotations) | hashes |
def test_match_hashes(self) -> None:
import hashlib
msg = bytes("Test String", "utf-8")
self.assertEqual(SHA256(msg).hash, hashlib.sha256(msg).hexdigest()) | hashes |
def main() -> None:
# unittest.main()
import doctest
doctest.testmod()
parser = argparse.ArgumentParser()
parser.add_argument(
"-s",
"--string",
dest="input_string",
default="Hello World!! Welcome to Cryptography",
help="Hash the string",
)
parser.... | hashes |
def __init__(self, data):
self.data = data
self.h = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0] | hashes |
def rotate(n, b):
return ((n << b) | (n >> (32 - b))) & 0xFFFFFFFF | hashes |
def padding(self):
padding = b"\x80" + b"\x00" * (63 - (len(self.data) + 8) % 64)
padded_data = self.data + padding + struct.pack(">Q", 8 * len(self.data))
return padded_data | hashes |
def split_blocks(self):
return [
self.padded_data[i : i + 64] for i in range(0, len(self.padded_data), 64)
] | hashes |
def expand_block(self, block):
w = list(struct.unpack(">16L", block)) + [0] * 64
for i in range(16, 80):
w[i] = self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1)
return w | hashes |
def final_hash(self):
self.padded_data = self.padding()
self.blocks = self.split_blocks()
for block in self.blocks:
expanded_block = self.expand_block(block)
a, b, c, d, e = self.h
for i in range(0, 80):
if 0 <= i < 20:
f = ... | hashes |
def testMatchHashes(self): # noqa: N802
msg = bytes("Test String", "utf-8")
self.assertEqual(SHA1Hash(msg).final_hash(), hashlib.sha1(msg).hexdigest()) | hashes |
def main():
# unittest.main()
parser = argparse.ArgumentParser(description="Process some strings or files")
parser.add_argument(
"--string",
dest="input_string",
default="Hello World!! Welcome to Cryptography",
help="Hash the string",
)
parser.add_argument("--file", d... | hashes |
def rotator():
global gear_one_pos
global gear_two_pos
global gear_three_pos
i = gear_one[0]
gear_one.append(i)
del gear_one[0]
gear_one_pos += 1
if gear_one_pos % int(len(alphabets)) == 0:
i = gear_two[0]
gear_two.append(i)
del gear_two[0]
gear_two_pos +=... | hashes |
def engine(input_character):
target = alphabets.index(input_character)
target = gear_one[target]
target = gear_two[target]
target = gear_three[target]
target = reflector[target]
target = gear_three.index(target)
target = gear_two.index(target)
target = gear_one.index(target)
code.app... | hashes |
def elf_hash(data: str) -> int:
hash_ = x = 0
for letter in data:
hash_ = (hash_ << 4) + ord(letter)
x = hash_ & 0xF0000000
if x != 0:
hash_ ^= x >> 24
hash_ &= ~x
return hash_ | hashes |
def text_to_bits(text, encoding="utf-8", errors="surrogatepass"):
bits = bin(int.from_bytes(text.encode(encoding, errors), "big"))[2:]
return bits.zfill(8 * ((len(bits) + 7) // 8)) | hashes |
def text_from_bits(bits, encoding="utf-8", errors="surrogatepass"):
n = int(bits, 2)
return n.to_bytes((n.bit_length() + 7) // 8, "big").decode(encoding, errors) or "\0" | hashes |
def emitter_converter(size_par, data):
if size_par + len(data) <= 2**size_par - (len(data) - 1):
raise ValueError("size of parity don't match with size of data")
data_out = []
parity = []
bin_pos = [bin(x)[2:] for x in range(1, size_par + len(data) + 1)]
# sorted information data for the s... | hashes |
def receptor_converter(size_par, data):
# data position template + parity
data_out_gab = []
# Parity bit counter
qtd_bp = 0
# Counter p data bit reading
cont_data = 0
# list of parity received
parity_received = []
data_output = []
for x in range(1, len(data) + 1):
# Perf... | hashes |
def rearrange(bit_string_32):
if len(bit_string_32) != 32:
raise ValueError("Need length 32")
new_string = ""
for i in [3, 2, 1, 0]:
new_string += bit_string_32[8 * i : 8 * i + 8]
return new_string | hashes |
def reformat_hex(i):
hexrep = format(i, "08x")
thing = ""
for i in [3, 2, 1, 0]:
thing += hexrep[2 * i : 2 * i + 2]
return thing | hashes |
def pad(bit_string):
start_length = len(bit_string)
bit_string += "1"
while len(bit_string) % 512 != 448:
bit_string += "0"
last_part = format(start_length, "064b")
bit_string += rearrange(last_part[32:]) + rearrange(last_part[:32])
return bit_string | hashes |
def get_block(bit_string):
curr_pos = 0
while curr_pos < len(bit_string):
curr_part = bit_string[curr_pos : curr_pos + 512]
my_splits = []
for i in range(16):
my_splits.append(int(rearrange(curr_part[32 * i : 32 * i + 32]), 2))
yield my_splits
curr_pos += 512 | hashes |
def not32(i):
i_str = format(i, "032b")
new_str = ""
for c in i_str:
new_str += "1" if c == "0" else "0"
return int(new_str, 2) | hashes |
def sum32(a, b):
return (a + b) % 2**32 | hashes |
def leftrot32(i, s):
return (i << s) ^ (i >> (32 - s)) | hashes |
def md5me(test_string):
bs = ""
for i in test_string:
bs += format(ord(i), "08b")
bs = pad(bs)
tvals = [int(2**32 * abs(math.sin(i + 1))) for i in range(64)]
a0 = 0x67452301
b0 = 0xEFCDAB89
c0 = 0x98BADCFE
d0 = 0x10325476
s = [
7,
12,
17,
2... | hashes |
def test():
assert md5me("") == "d41d8cd98f00b204e9800998ecf8427e"
assert (
md5me("The quick brown fox jumps over the lazy dog")
== "9e107d9d372bb6826bd81d3542a419d6"
)
print("Success.") | hashes |
def indian_phone_validator(phone: str) -> bool:
pat = re.compile(r"^(\+91[\-\s]?)?[0]?(91)?[789]\d{9}$")
if match := re.search(pat, phone):
return match.string == phone
return False | strings |
def z_function(input_str: str) -> list[int]:
z_result = [0 for i in range(len(input_str))]
# initialize interval's left pointer and right pointer
left_pointer, right_pointer = 0, 0
for i in range(1, len(input_str)):
# case when current index is inside the interval
if i <= right_pointer... | strings |
def go_next(i: int, z_result: list[int], s: str) -> bool:
return i + z_result[i] < len(s) and s[z_result[i]] == s[i + z_result[i]] | strings |
def find_pattern(pattern: str, input_str: str) -> int:
answer = 0
# concatenate 'pattern' and 'input_str' and call z_function
# with concatenated string
z_result = z_function(pattern + input_str)
for val in z_result:
# if value is greater then length of the pattern string
# that mea... | strings |
def remove_duplicates(sentence: str) -> str:
return " ".join(sorted(set(sentence.split()))) | strings |
def create_ngram(sentence: str, ngram_size: int) -> list[str]:
return [sentence[i : i + ngram_size] for i in range(len(sentence) - ngram_size + 1)] | strings |
def is_palindrome(s: str) -> bool:
start_i = 0
end_i = len(s) - 1
while start_i < end_i:
if s[start_i] == s[end_i]:
start_i += 1
end_i -= 1
else:
return False
return True | strings |
def is_palindrome_recursive(s: str) -> bool:
if len(s) <= 1:
return True
if s[0] == s[len(s) - 1]:
return is_palindrome_recursive(s[1:-1])
else:
return False | strings |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.