function stringlengths 18 3.86k | intent_category stringlengths 5 24 |
|---|---|
def tree_sort(arr):
# Build BST
if len(arr) == 0:
return arr
root = Node(arr[0])
for i in range(1, len(arr)):
root.insert(arr[i])
# Traverse BST in order.
res = []
inorder(root, res)
return res | sorts |
def wiggle_sort(nums: list) -> list:
for i, _ in enumerate(nums):
if (i % 2 == 1) == (nums[i - 1] > nums[i]):
nums[i - 1], nums[i] = nums[i], nums[i - 1]
return nums | sorts |
def bubble_sort(list_data: list, length: int = 0) -> list:
length = length or len(list_data)
swapped = False
for i in range(length - 1):
if list_data[i] > list_data[i + 1]:
list_data[i], list_data[i + 1] = list_data[i + 1], list_data[i]
swapped = True
return list_data if... | sorts |
def slowsort(sequence: list, start: int | None = None, end: int | None = None) -> None:
if start is None:
start = 0
if end is None:
end = len(sequence) - 1
if start >= end:
return
mid = (start + end) // 2
slowsort(sequence, start, mid)
slowsort(sequence, mid + 1, end)... | sorts |
def __init__(self, filename):
self.filename = filename
self.block_filenames = [] | sorts |
def write_block(self, data, block_number):
filename = self.BLOCK_FILENAME_FORMAT.format(block_number)
with open(filename, "w") as file:
file.write(data)
self.block_filenames.append(filename) | sorts |
def get_block_filenames(self):
return self.block_filenames | sorts |
def split(self, block_size, sort_key=None):
i = 0
with open(self.filename) as file:
while True:
lines = file.readlines(block_size)
if lines == []:
break
if sort_key is None:
lines.sort()
... | sorts |
def cleanup(self):
map(os.remove, self.block_filenames) | sorts |
def select(self, choices):
min_index = -1
min_str = None
for i in range(len(choices)):
if min_str is None or choices[i] < min_str:
min_index = i
return min_index | sorts |
def __init__(self, files):
self.files = files
self.empty = set()
self.num_buffers = len(files)
self.buffers = {i: None for i in range(self.num_buffers)} | sorts |
def get_dict(self):
return {
i: self.buffers[i] for i in range(self.num_buffers) if i not in self.empty
} | sorts |
def refresh(self):
for i in range(self.num_buffers):
if self.buffers[i] is None and i not in self.empty:
self.buffers[i] = self.files[i].readline()
if self.buffers[i] == "":
self.empty.add(i)
self.files[i].close()
if l... | sorts |
def unshift(self, index):
value = self.buffers[index]
self.buffers[index] = None
return value | sorts |
def __init__(self, merge_strategy):
self.merge_strategy = merge_strategy | sorts |
def merge(self, filenames, outfilename, buffer_size):
buffers = FilesArray(self.get_file_handles(filenames, buffer_size))
with open(outfilename, "w", buffer_size) as outfile:
while buffers.refresh():
min_index = self.merge_strategy.select(buffers.get_dict())
o... | sorts |
def get_file_handles(self, filenames, buffer_size):
files = {}
for i in range(len(filenames)):
files[i] = open(filenames[i], "r", buffer_size)
return files | sorts |
def __init__(self, block_size):
self.block_size = block_size | sorts |
def sort(self, filename, sort_key=None):
num_blocks = self.get_number_blocks(filename, self.block_size)
splitter = FileSplitter(filename)
splitter.split(self.block_size, sort_key)
merger = FileMerger(NWayMerge())
buffer_size = self.block_size / (num_blocks + 1)
merger.me... | sorts |
def get_number_blocks(self, filename, block_size):
return (os.stat(filename).st_size / block_size) + 1 | sorts |
def parse_memory(string):
if string[-1].lower() == "k":
return int(string[:-1]) * 1024
elif string[-1].lower() == "m":
return int(string[:-1]) * 1024 * 1024
elif string[-1].lower() == "g":
return int(string[:-1]) * 1024 * 1024 * 1024
else:
return int(string) | sorts |
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-m", "--mem", help="amount of memory to use for sorting", default="100M"
)
parser.add_argument(
"filename", metavar="<filename>", nargs=1, help="name of file to sort"
)
args = parser.parse_args()
sorter = E... | sorts |
def heapify(unsorted, index, heap_size):
largest = index
left_index = 2 * index + 1
right_index = 2 * index + 2
if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
largest = left_index
if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
larg... | sorts |
def heap_sort(unsorted):
n = len(unsorted)
for i in range(n // 2 - 1, -1, -1):
heapify(unsorted, i, n)
for i in range(n - 1, 0, -1):
unsorted[0], unsorted[i] = unsorted[i], unsorted[0]
heapify(unsorted, 0, i)
return unsorted | sorts |
def exchange_sort(numbers: list[int]) -> list[int]:
numbers_length = len(numbers)
for i in range(numbers_length):
for j in range(i + 1, numbers_length):
if numbers[j] < numbers[i]:
numbers[i], numbers[j] = numbers[j], numbers[i]
return numbers | sorts |
def strand_sort(arr: list, reverse: bool = False, solution: list | None = None) -> list:
_operator = operator.lt if reverse else operator.gt
solution = solution or []
if not arr:
return solution
sublist = [arr.pop(0)]
for i, item in enumerate(arr):
if _operator(item, sublist[-1]):
... | sorts |
def quick_sort(data: list) -> list:
if len(data) <= 1:
return data
else:
return [
*quick_sort([e for e in data[1:] if e <= data[0]]),
data[0],
*quick_sort([e for e in data[1:] if e > data[0]]),
] | sorts |
def __lt__(self, other):
return self[-1] < other[-1] | sorts |
def __eq__(self, other):
return self[-1] == other[-1] | sorts |
def patience_sort(collection: list) -> list:
stacks: list[Stack] = []
# sort into stacks
for element in collection:
new_stacks = Stack([element])
i = bisect_left(stacks, new_stacks)
if i != len(stacks):
stacks[i].append(element)
else:
stacks.append(new... | sorts |
def partition(a, left_index, right_index):
pivot = a[left_index]
i = left_index + 1
for j in range(left_index + 1, right_index):
if a[j] < pivot:
a[j], a[i] = a[i], a[j]
i += 1
a[left_index], a[i - 1] = a[i - 1], a[left_index]
return i - 1 | sorts |
def quick_sort_random(a, left, right):
if left < right:
pivot = random.randint(left, right - 1)
a[pivot], a[left] = (
a[left],
a[pivot],
) # switches the pivot with the left most bound
pivot_index = partition(a, left, right)
quick_sort_random(
... | sorts |
def main():
user_input = input("Enter numbers separated by a comma:\n").strip()
arr = [int(item) for item in user_input.split(",")]
quick_sort_random(arr, 0, len(arr))
print(arr) | sorts |
def bead_sort(sequence: list) -> list:
if any(not isinstance(x, int) or x < 0 for x in sequence):
raise TypeError("Sequence must be list of non-negative integers")
for _ in range(len(sequence)):
for i, (rod_upper, rod_lower) in enumerate(zip(sequence, sequence[1:])):
if rod_upper > r... | sorts |
def comb_sort(data: list) -> list:
shrink_factor = 1.3
gap = len(data)
completed = False
while not completed:
# Update the gap value for a next comb
gap = int(gap / shrink_factor)
if gap <= 1:
completed = True
index = 0
while index + gap < len(data):... | sorts |
def pigeon_sort(array: list[int]) -> list[int]:
if len(array) == 0:
return array
_min, _max = min(array), max(array)
# Compute the variables
holes_range = _max - _min + 1
holes, holes_repeat = [0] * holes_range, [0] * holes_range
# Make the sorting.
for i in array:
index =... | sorts |
def comp_and_swap(array: list[int], index1: int, index2: int, direction: int) -> None:
if (direction == 1 and array[index1] > array[index2]) or (
direction == 0 and array[index1] < array[index2]
):
array[index1], array[index2] = array[index2], array[index1] | sorts |
def bitonic_merge(array: list[int], low: int, length: int, direction: int) -> None:
if length > 1:
middle = int(length / 2)
for i in range(low, low + middle):
comp_and_swap(array, i, i + middle, direction)
bitonic_merge(array, low, middle, direction)
bitonic_merge(array, ... | sorts |
def bitonic_sort(array: list[int], low: int, length: int, direction: int) -> None:
if length > 1:
middle = int(length / 2)
bitonic_sort(array, low, middle, 1)
bitonic_sort(array, low + middle, middle, 0)
bitonic_merge(array, low, length, direction) | sorts |
def alphanum_key(key):
return [int(s) if s.isdigit() else s.lower() for s in re.split("([0-9]+)", key)] | sorts |
def double_sort(lst):
no_of_elements = len(lst)
for _ in range(
0, int(((no_of_elements - 1) / 2) + 1)
): # we don't need to traverse to end of list as
for j in range(0, no_of_elements - 1):
if (
lst[j + 1] < lst[j]
): # applying bubble sort algorith... | sorts |
def __init__(self, order: int) -> None:
self.order = order
# a_{0} ... a_{k}
self.a_coeffs = [1.0] + [0.0] * order
# b_{0} ... b_{k}
self.b_coeffs = [1.0] + [0.0] * order
# x[n-1] ... x[n-k]
self.input_history = [0.0] * self.order
# y[n-1] ... y[n-k]
... | audio_filters |
def set_coefficients(self, a_coeffs: list[float], b_coeffs: list[float]) -> None:
if len(a_coeffs) < self.order:
a_coeffs = [1.0, *a_coeffs]
if len(a_coeffs) != self.order + 1:
raise ValueError(
f"Expected a_coeffs to have {self.order + 1} elements for {self.orde... | audio_filters |
def process(self, sample: float) -> float:
return 0.0 | audio_filters |
def get_bounds(
fft_results: np.ndarray, samplerate: int
) -> tuple[int | float, int | float]:
lowest = min([-20, np.min(fft_results[1 : samplerate // 2 - 1])])
highest = max([20, np.max(fft_results[1 : samplerate // 2 - 1])])
return lowest, highest | audio_filters |
def show_frequency_response(filter_type: FilterType, samplerate: int) -> None:
size = 512
inputs = [1] + [0] * (size - 1)
outputs = [filter_type.process(item) for item in inputs]
filler = [0] * (samplerate - size) # zero-padding
outputs += filler
fft_out = np.abs(np.fft.fft(outputs))
fft_... | audio_filters |
def make_lowpass(
frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2) # noqa: B008 | audio_filters |
def make_highpass(
frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2) # noqa: B008 | audio_filters |
def make_bandpass(
frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2) # noqa: B008 | audio_filters |
def make_allpass(
frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2) # noqa: B008 | audio_filters |
def make_peak(
frequency: int,
samplerate: int,
gain_db: float,
q_factor: float = 1 / sqrt(2), # noqa: B008 | audio_filters |
def make_lowshelf(
frequency: int,
samplerate: int,
gain_db: float,
q_factor: float = 1 / sqrt(2), # noqa: B008 | audio_filters |
def make_highshelf(
frequency: int,
samplerate: int,
gain_db: float,
q_factor: float = 1 / sqrt(2), # noqa: B008 | audio_filters |
def bb84(key_len: int = 8, seed: int | None = None) -> str:
# Set up the random number generator.
rng = np.random.default_rng(seed=seed)
# Roughly 25% of the qubits will contribute to the key.
# So we take more than we need.
num_qubits = 6 * key_len
# Measurement basis for Alice's qubits.
a... | quantum |
def store_two_classics(val1: int, val2: int) -> tuple[qiskit.QuantumCircuit, str, str]:
x, y = bin(val1)[2:], bin(val2)[2:] # Remove leading '0b'
# Ensure that both strings are of the same length
if len(x) > len(y):
y = y.zfill(len(x))
else:
x = x.zfill(len(y))
# We need (3 * numb... | quantum |
def full_adder(
circuit: qiskit.QuantumCircuit,
input1_loc: int,
input2_loc: int,
carry_in: int,
carry_out: int,
):
circuit.ccx(input1_loc, input2_loc, carry_out)
circuit.cx(input1_loc, input2_loc)
circuit.ccx(input2_loc, carry_in, carry_out)
circuit.cx(input2_loc, carry_in)
circ... | quantum |
def ripple_adder(
val1: int,
val2: int,
backend: Backend = qiskit.Aer.get_backend("aer_simulator"), # noqa: B008 | quantum |
def quantum_entanglement(qubits: int = 2) -> qiskit.result.counts.Counts:
classical_bits = qubits
# Using Aer's simulator
simulator = qiskit.Aer.get_backend("aer_simulator")
# Creating a Quantum Circuit acting on the q register
circuit = qiskit.QuantumCircuit(qubits, classical_bits)
# Adding ... | quantum |
def single_qubit_measure(
qubits: int, classical_bits: int
) -> qiskit.result.counts.Counts:
# Use Aer's simulator
simulator = qiskit.Aer.get_backend("aer_simulator")
# Create a Quantum Circuit acting on the q register
circuit = qiskit.QuantumCircuit(qubits, classical_bits)
# Map the quantum m... | quantum |
def quantum_fourier_transform(number_of_qubits: int = 3) -> qiskit.result.counts.Counts:
if isinstance(number_of_qubits, str):
raise TypeError("number of qubits must be a integer.")
if number_of_qubits <= 0:
raise ValueError("number of qubits must be > 0.")
if math.floor(number_of_qubits) !=... | quantum |
def superdense_coding(bit_1: int = 1, bit_2: int = 1) -> qiskit.result.counts.Counts:
if isinstance(bit_1, str) or isinstance(bit_2, str):
raise TypeError("inputs must be integers.")
if (bit_1 < 0) or (bit_2 < 0):
raise ValueError("inputs must be positive.")
if (math.floor(bit_1) != bit_1) o... | quantum |
def single_qubit_measure(
qubits: int, classical_bits: int
) -> qiskit.result.counts.Counts:
# Use Aer's simulator
simulator = qiskit.Aer.get_backend("aer_simulator")
# Create a Quantum Circuit acting on the q register
circuit = qiskit.QuantumCircuit(qubits, classical_bits)
# Apply X (NOT) Gat... | quantum |
def half_adder(bit0: int, bit1: int) -> qiskit.result.counts.Counts:
# Use Aer's simulator
simulator = qiskit.Aer.get_backend("aer_simulator")
qc_ha = qiskit.QuantumCircuit(4, 2)
# encode inputs in qubits 0 and 1
if bit0 == 1:
qc_ha.x(0)
if bit1 == 1:
qc_ha.x(1)
qc_ha.barrie... | quantum |
def dj_oracle(case: str, num_qubits: int) -> qiskit.QuantumCircuit:
# This circuit has num_qubits+1 qubits: the size of the input,
# plus one output qubit
oracle_qc = qiskit.QuantumCircuit(num_qubits + 1)
# First, let's deal with the case in which oracle is balanced
if case == "balanced":
#... | quantum |
def dj_algorithm(
oracle: qiskit.QuantumCircuit, num_qubits: int
) -> qiskit.QuantumCircuit:
dj_circuit = qiskit.QuantumCircuit(num_qubits + 1, num_qubits)
# Set up the output qubit:
dj_circuit.x(num_qubits)
dj_circuit.h(num_qubits)
# And set up the input register:
for qubit in range(num_qub... | quantum |
def deutsch_jozsa(case: str, num_qubits: int) -> qiskit.result.counts.Counts:
# Use Aer's simulator
simulator = qiskit.Aer.get_backend("aer_simulator")
oracle_gate = dj_oracle(case, num_qubits)
dj_circuit = dj_algorithm(oracle_gate, num_qubits)
# Execute the circuit on the simulator
job = qisk... | quantum |
def quantum_teleportation(
theta: float = np.pi / 2, phi: float = np.pi / 2, lam: float = np.pi / 2
) -> qiskit.result.counts.Counts:
qr = QuantumRegister(3, "qr") # Define the number of quantum bits
cr = ClassicalRegister(1, "cr") # Define the number of classical bits
quantum_circuit = QuantumCircu... | quantum |
def quantum_full_adder(
input_1: int = 1, input_2: int = 1, carry_in: int = 1
) -> qiskit.result.counts.Counts:
if (
isinstance(input_1, str)
or isinstance(input_2, str)
or isinstance(carry_in, str)
):
raise TypeError("inputs must be integers.")
if (input_1 < 0) or (inpu... | quantum |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.