instruction stringlengths 22 901 | input stringlengths 0 1.25k | output stringlengths 4 3.74k |
|---|---|---|
Fix the following buggy program: """
Bitcount
bitcount
Input:
n: a nonnegative int
Output:
The number of 1-bits in the binary encoding of n
Examples:
>>> bitcount(127)
7
>>> bitcount(128)
1
""" | def bitcount(n):
count = 0
while n:
n ^= n - 1
count += 1
return count | def bitcount(n):
count = 0
while n:
n &= n - 1
count += 1
return count |
Fix the following buggy program: """
Breadth-First Search
Input:
startnode: A digraph node
goalnode: A digraph node
Output:
Whether goalnode is reachable from startnode
""" | from collections import deque as Queue
def breadth_first_search(startnode, goalnode):
queue = Queue()
queue.append(startnode)
nodesseen = set()
nodesseen.add(startnode)
while True:
node = queue.popleft()
if node is goalnode:
return True
else:
queue... | from collections import deque as Queue
def breadth_first_search(startnode, goalnode):
queue = Queue()
queue.append(startnode)
nodesseen = set()
nodesseen.add(startnode)
while queue:
node = queue.popleft()
if node is goalnode:
return True
else:
queu... |
Fix the following buggy program: """
Bucket Sort
Input:
arr: A list of small ints
k: Upper bound of the size of the ints in arr (not inclusive)
Precondition:
all(isinstance(x, int) and 0 <= x < k for x in arr)
Output:
The elements of arr in sorted order
""" | def bucketsort(arr, k):
counts = [0] * k
for x in arr:
counts[x] += 1
sorted_arr = []
for i, count in enumerate(arr):
sorted_arr.extend([i] * count)
return sorted_arr | def bucketsort(arr, k):
counts = [0] * k
for x in arr:
counts[x] += 1
sorted_arr = []
for i, count in enumerate(counts):
sorted_arr.extend([i] * count)
return sorted_arr |
Fix the following buggy program: """
Depth-first Search
Input:
startnode: A digraph node
goalnode: A digraph node
Output:
Whether goalnode is reachable from startnode
""" | def depth_first_search(startnode, goalnode):
nodesvisited = set()
def search_from(node):
if node in nodesvisited:
return False
elif node is goalnode:
return True
else:
return any(
search_from(nextnode) for nextnode in node.successors
... | def depth_first_search(startnode, goalnode):
nodesvisited = set()
def search_from(node):
if node in nodesvisited:
return False
elif node is goalnode:
return True
else:
nodesvisited.add(node)
return any(
search_from(nextnode... |
Fix the following buggy program: """
Linked List Cycle Detection
tortoise-hare
Implements the tortoise-and-hare method of cycle detection.
Input:
node: The head node of a linked list
Output:
Whether the linked list is cyclic
""" | def detect_cycle(node):
hare = tortoise = node
while True:
if hare.successor is None:
return False
tortoise = tortoise.successor
hare = hare.successor.successor
if hare is tortoise:
return True | def detect_cycle(node):
hare = tortoise = node
while True:
if hare is None or hare.successor is None:
return False
tortoise = tortoise.successor
hare = hare.successor.successor
if hare is tortoise:
return True |
Fix the following buggy program: """
Fancy Binary Search
fancy-binsearch
Input:
arr: A sorted list of ints
x: A value to find
Output:
The lowest index i such that arr[i] == x, or -1 if x not in arr
Example:
>>> find_first_in_sorted([3, 4, 5, 5, 5, 5, 6], 5)
2
""" | def find_first_in_sorted(arr, x):
lo = 0
hi = len(arr)
while lo <= hi:
mid = (lo + hi) // 2
if x == arr[mid] and (mid == 0 or x != arr[mid - 1]):
return mid
elif x <= arr[mid]:
hi = mid
else:
lo = mid + 1
return -1 | def find_first_in_sorted(arr, x):
lo = 0
hi = len(arr)
while lo < hi:
mid = (lo + hi) // 2
if x == arr[mid] and (mid == 0 or x != arr[mid - 1]):
return mid
elif x <= arr[mid]:
hi = mid
else:
lo = mid + 1
return -1 |
Fix the following buggy program: """
Binary Search
Input:
arr: A sorted list of ints
x: A value to find
Output:
An index i such that arr[i] == x, or -1 if x not in arr
Example:
>>> find_in_sorted([3, 4, 5, 5, 5, 5, 6], 5)
3
""" | def find_in_sorted(arr, x):
def binsearch(start, end):
if start == end:
return -1
mid = start + (end - start) // 2
if x < arr[mid]:
return binsearch(start, mid)
elif x > arr[mid]:
return binsearch(mid, end)
else:
return mid
... | def find_in_sorted(arr, x):
def binsearch(start, end):
if start == end:
return -1
mid = start + (end - start) // 2
if x < arr[mid]:
return binsearch(start, mid)
elif x > arr[mid]:
return binsearch(mid + 1, end)
else:
return mid
... |
Fix the following buggy program: """
Flatten
Flattens a nested list data structure into a single list.
Input:
arr: A list
Precondition:
The input has no list containment cycles
Output:
A generator for the input's non-list objects
Example:
>>> list(flatten([[1, [], [2, 3]], [[4]], 5]))
[1, 2, 3... | def flatten(arr):
for x in arr:
if isinstance(x, list):
for y in flatten(x):
yield y
else:
yield flatten(x) | def flatten(arr):
for x in arr:
if isinstance(x, list):
for y in flatten(x):
yield y
else:
yield x |
Fix the following buggy program: """
Input:
a: A nonnegative int
b: A nonnegative int
Greatest Common Divisor
Precondition:
isinstance(a, int) and isinstance(b, int)
Output:
The greatest int that divides evenly into a and b
Example:
>>> gcd(35, 21)
7
""" | def gcd(a, b):
if b == 0:
return a
else:
return gcd(a % b, b) | def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b) |
Fix the following buggy program: """
Prime Factorization
Factors an int using naive trial division.
Input:
n: An int to factor
Output:
A list of the prime factors of n in sorted order with repetition
Precondition:
n >= 1
Examples:
>>> get_factors(1)
[]
>>> get_factors(100)
[2, 2, 5, 5]... | def get_factors(n):
if n == 1:
return []
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return [i] + get_factors(n // i)
return [] | def get_factors(n):
if n == 1:
return []
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return [i] + get_factors(n // i)
return [n] |
Fix the following buggy program: """
Towers of Hanoi
hanoi
An algorithm for solving the Towers of Hanoi puzzle. Three pegs exist, with a stack of differently-sized
disks beginning on one peg, ordered from smallest on top to largest on bottom. The goal is to move the
entire stack to a different peg via a series of s... | def hanoi(height, start=1, end=3):
steps = []
if height > 0:
helper = ({1, 2, 3} - {start} - {end}).pop()
steps.extend(hanoi(height - 1, start, helper))
steps.append((start, helper))
steps.extend(hanoi(height - 1, helper, end))
return steps | def hanoi(height, start=1, end=3):
steps = []
if height > 0:
helper = ({1, 2, 3} - {start} - {end}).pop()
steps.extend(hanoi(height - 1, start, helper))
steps.append((start, end))
steps.extend(hanoi(height - 1, helper, end))
return steps |
Fix the following buggy program: """
Nested Parens
Input:
parens: A string of parentheses
Precondition:
all(paren in '()' for paren in parens)
Output:
Whether the parentheses are properly nested
Examples:
>>> is_valid_parenthesization('((()()))()')
True
>>> is_valid_parenthesization(')()(')
... | def is_valid_parenthesization(parens):
depth = 0
for paren in parens:
if paren == '(':
depth += 1
else:
depth -= 1
if depth < 0:
return False
return True | def is_valid_parenthesization(parens):
depth = 0
for paren in parens:
if paren == '(':
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0 |
Fix the following buggy program: """
K-Heapsort
k-heapsort
Sorts an almost-sorted array, wherein every element is no more than k units from its sorted position, in O(n log k) time.
Input:
arr: A list of ints
k: an int indicating the maximum displacement of an element in arr from its final sorted location
Pre... | def kheapsort(arr, k):
import heapq
heap = arr[:k]
heapq.heapify(heap)
for x in arr:
yield heapq.heappushpop(heap, x)
while heap:
yield heapq.heappop(heap) | def kheapsort(arr, k):
import heapq
heap = arr[:k]
heapq.heapify(heap)
for x in arr[k:]:
yield heapq.heappushpop(heap, x)
while heap:
yield heapq.heappop(heap) |
Fix the following buggy program: """
Knapsack
knapsack
You have a knapsack that can hold a maximum weight. You are given a selection of items, each with a weight and a value. You may
choose to take or leave each item, but you must choose items whose total weight does not exceed the capacity of your knapsack.
Input:
... | def knapsack(capacity, items):
from collections import defaultdict
memo = defaultdict(int)
for i in range(1, len(items) + 1):
weight, value = items[i - 1]
for j in range(1, capacity + 1):
memo[i, j] = memo[i - 1, j]
if weight < j:
memo[i, j] = max(
... | def knapsack(capacity, items):
from collections import defaultdict
memo = defaultdict(int)
for i in range(1, len(items) + 1):
weight, value = items[i - 1]
for j in range(1, capacity + 1):
memo[i, j] = memo[i - 1, j]
if weight <= j:
memo[i, j] = max(... |
Fix the following buggy program: """
QuickSelect
This is an efficient equivalent to sorted(arr)[k].
Input:
arr: A list of ints
k: An int
Precondition:
0 <= k < len(arr)
Output:
The kth-lowest element of arr (0-based)
""" | def kth(arr, k):
pivot = arr[0]
below = [x for x in arr if x < pivot]
above = [x for x in arr if x > pivot]
num_less = len(below)
num_lessoreq = len(arr) - len(above)
if k < num_less:
return kth(below, k)
elif k >= num_lessoreq:
return kth(above, k)
else:
return... | def kth(arr, k):
pivot = arr[0]
below = [x for x in arr if x < pivot]
above = [x for x in arr if x > pivot]
num_less = len(below)
num_lessoreq = len(arr) - len(above)
if k < num_less:
return kth(below, k)
elif k >= num_lessoreq:
return kth(above, k - num_lessoreq)
else:... |
Fix the following buggy program: """
Longest Common Substring
longest-common-substring
Input:
s: a string
t: a string
Output:
Length of the longest substring common to s and t
Example:
>>> lcs_length('witch', 'sandwich')
2
>>> lcs_length('meow', 'homeowner')
4
""" | def lcs_length(s, t):
from collections import Counter
dp = Counter()
for i in range(len(s)):
for j in range(len(t)):
if s[i] == t[j]:
dp[i, j] = dp[i - 1, j] + 1
return max(dp.values()) if dp else 0 | def lcs_length(s, t):
from collections import Counter
dp = Counter()
for i in range(len(s)):
for j in range(len(t)):
if s[i] == t[j]:
dp[i, j] = dp[i - 1, j - 1] + 1
return max(dp.values()) if dp else 0 |
Fix the following buggy program: """
Levenshtein Distance
Calculates the Levenshtein distance between two strings. The Levenshtein distance is defined as the minimum amount of single-character edits (either removing a character, adding a character, or changing a character) necessary to transform a source string into... | def levenshtein(source, target):
if source == '' or target == '':
return len(source) or len(target)
elif source[0] == target[0]:
return 1 + levenshtein(source[1:], target[1:])
else:
return 1 + min(
levenshtein(source, target[1:]),
levenshtein(source[1:],... | def levenshtein(source, target):
if source == '' or target == '':
return len(source) or len(target)
elif source[0] == target[0]:
return levenshtein(source[1:], target[1:])
else:
return 1 + min(
levenshtein(source, target[1:]),
levenshtein(source[1:], tar... |
Fix the following buggy program: """
Longest Increasing Subsequence
longest-increasing-subsequence
Input:
arr: A sequence of ints
Precondition:
The ints in arr are unique
Output:
The length of the longest monotonically increasing subsequence of arr
Example:
>>> lis([4, 1, 5, 3, 7, 6, 2])
3
""" | def lis(arr):
ends = {}
longest = 0
for i, val in enumerate(arr):
prefix_lengths = [j for j in range(1, longest + 1) if arr[ends[j]] < val]
length = max(prefix_lengths) if prefix_lengths else 0
if length == longest or val < arr[ends[length + 1]]:
ends[length + 1] = i
... | def lis(arr):
ends = {}
longest = 0
for i, val in enumerate(arr):
prefix_lengths = [j for j in range(1, longest + 1) if arr[ends[j]] < val]
length = max(prefix_lengths) if prefix_lengths else 0
if length == longest or val < arr[ends[length + 1]]:
ends[length + 1] = i
... |
Fix the following buggy program: """
Longest Common Subsequence
Calculates the longest subsequence common to the two input strings. (A subsequence is any sequence of letters in the same order
they appear in the string, possibly skipping letters in between.)
Input:
a: The first string to consider.
b: The seco... | def longest_common_subsequence(a, b):
if not a or not b:
return ''
elif a[0] == b[0]:
return a[0] + longest_common_subsequence(a[1:], b)
else:
return max(
longest_common_subsequence(a, b[1:]),
longest_common_subsequence(a[1:], b),
key=len
... | def longest_common_subsequence(a, b):
if not a or not b:
return ''
elif a[0] == b[0]:
return a[0] + longest_common_subsequence(a[1:], b[1:])
else:
return max(
longest_common_subsequence(a, b[1:]),
longest_common_subsequence(a[1:], b),
key=len
... |
Fix the following buggy program: """
Max Sublist Sum
max-sublist-sum
Efficient equivalent to max(sum(arr[i:j]) for 0 <= i <= j <= len(arr))
Algorithm source: WordAligned.org by Thomas Guest
Input:
arr: A list of ints
Output:
The maximum sublist sum
Example:
>>> max_sublist_sum([4, -5, 2, 1, -1, 3])
... | def max_sublist_sum(arr):
max_ending_here = 0
max_so_far = 0
for x in arr:
max_ending_here = max_ending_here + x
max_so_far = max(max_so_far, max_ending_here)
return max_so_far | def max_sublist_sum(arr):
max_ending_here = 0
max_so_far = 0
for x in arr:
max_ending_here = max(0, max_ending_here + x)
max_so_far = max(max_so_far, max_ending_here)
return max_so_far |
Fix the following buggy program: """
Merge Sort
Input:
arr: A list of ints
Output:
The elements of arr in sorted order
""" | def mergesort(arr):
def merge(left, right):
result = []
i = 0
j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j +=... | def mergesort(arr):
def merge(left, right):
result = []
i = 0
j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j +=... |
Fix the following buggy program: """
Minimum Spanning Tree
Kruskal's algorithm implementation.
Input:
weight_by_edge: A dict of the form {(u, v): weight} for every undirected graph edge {u, v}
Precondition:
The input graph is connected
Output:
A set of edges that connects all the vertices of the input ... | def minimum_spanning_tree(weight_by_edge):
group_by_node = {}
mst_edges = set()
for edge in sorted(weight_by_edge, key=weight_by_edge.__getitem__):
u, v = edge
if group_by_node.setdefault(u, {u}) != group_by_node.setdefault(v, {v}):
mst_edges.add(edge)
group_by_node[... | def minimum_spanning_tree(weight_by_edge):
group_by_node = {}
mst_edges = set()
for edge in sorted(weight_by_edge, key=weight_by_edge.__getitem__):
u, v = edge
if group_by_node.setdefault(u, {u}) != group_by_node.setdefault(v, {v}):
mst_edges.add(edge)
group_by_node[... |
Fix the following buggy program: """
Finds the next palindromic integer when given the current integer
Integers are stored as arrays of base 10 digits from most significant to least significant
Input:
digit_list: An array representing the current palindrome
Output:
An array which represents the next palindrom... | def next_palindrome(digit_list):
high_mid = len(digit_list) // 2
low_mid = (len(digit_list) - 1) // 2
while high_mid < len(digit_list) and low_mid >= 0:
if digit_list[high_mid] == 9:
digit_list[high_mid] = 0
digit_list[low_mid] = 0
high_mid += 1
low_mi... | def next_palindrome(digit_list):
high_mid = len(digit_list) // 2
low_mid = (len(digit_list) - 1) // 2
while high_mid < len(digit_list) and low_mid >= 0:
if digit_list[high_mid] == 9:
digit_list[high_mid] = 0
digit_list[low_mid] = 0
high_mid += 1
low_mi... |
Fix the following buggy program: """
Next Permutation
next-perm
Input:
perm: A list of unique ints
Precondition:
perm is not sorted in reverse order
Output:
The lexicographically next permutation of the elements of perm
Example:
>>> next_permutation([3, 2, 4, 1])
[3, 4, 1, 2]
""" | def next_permutation(perm):
for i in range(len(perm) - 2, -1, -1):
if perm[i] < perm[i + 1]:
for j in range(len(perm) - 1, i, -1):
if perm[j] < perm[i]:
next_perm = list(perm)
next_perm[i], next_perm[j] = perm[j], perm[i]
... | def next_permutation(perm):
for i in range(len(perm) - 2, -1, -1):
if perm[i] < perm[i + 1]:
for j in range(len(perm) - 1, i, -1):
if perm[i] < perm[j]:
next_perm = list(perm)
next_perm[i], next_perm[j] = perm[j], perm[i]
... |
Fix the following buggy program: """
Pascal's Triangle
pascal
Input:
n: The number of rows to return
Precondition:
n >= 1
Output:
The first n rows of Pascal's triangle as a list of n lists
Example:
>>> pascal(5)
[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
""" | def pascal(n):
rows = [[1]]
for r in range(1, n):
row = []
for c in range(0, r):
upleft = rows[r - 1][c - 1] if c > 0 else 0
upright = rows[r - 1][c] if c < r else 0
row.append(upleft + upright)
rows.append(row)
return rows | def pascal(n):
rows = [[1]]
for r in range(1, n):
row = []
for c in range(0, r + 1):
upleft = rows[r - 1][c - 1] if c > 0 else 0
upright = rows[r - 1][c] if c < r else 0
row.append(upleft + upright)
rows.append(row)
return rows |
Fix the following buggy program: """
Making Change
change
Input:
coins: A list of positive ints representing coin denominations
total: An int value to make change for
Output:
The number of distinct ways to make change adding up to total using only coins of the given values.
For example, there are exa... | # Python 3
def possible_change(coins, total):
if total == 0:
return 1
if total < 0:
return 0
first, *rest = coins
return possible_change(coins, total - first) + possible_change(rest, total) | def possible_change(coins, total):
if total == 0:
return 1
if total < 0 or not coins:
return 0
first, *rest = coins
return possible_change(coins, total - first) + possible_change(rest, total) |
Fix the following buggy program: """
Power Set
Input:
arr: A list
Precondition:
arr has no duplicate elements
Output:
A list of lists, each representing a different subset of arr. The empty set is always a subset of arr, and arr is always a subset of arr.
Example:
>>> powerset(['a', 'b', 'c'])
[... | def powerset(arr):
if arr:
first, *rest = arr #python3 just like car and cdr (in this case anyway..)
rest_subsets = powerset(rest)
return [[first] + subset for subset in rest_subsets]
else:
return [[]] | def powerset(arr):
if arr:
first, *rest = arr
rest_subsets = powerset(rest)
return rest_subsets + [[first] + subset for subset in rest_subsets]
else:
return [[]] |
Fix the following buggy program: """
QuickSort
Input:
arr: A list of ints
Output:
The elements of arr in sorted order
""" | def quicksort(arr):
if not arr:
return []
pivot = arr[0]
lesser = quicksort([x for x in arr[1:] if x < pivot])
greater = quicksort([x for x in arr[1:] if x > pivot])
return lesser + [pivot] + greater | def quicksort(arr):
if not arr:
return []
pivot = arr[0]
lesser = quicksort([x for x in arr[1:] if x < pivot])
greater = quicksort([x for x in arr[1:] if x >= pivot])
return lesser + [pivot] + greater |
Fix the following buggy program: """
Reverse Linked List
Reverses a linked list and returns the new head.
Input:
node: The head of a singly-linked list
Precondition:
The input is acyclic
Side effect:
Mutates the list nodes' successor pointers
Output:
The head of the reversed linked list
""" | def reverse_linked_list(node):
prevnode = None
while node:
nextnode = node.successor
node.successor = prevnode
node = nextnode
return prevnode | def reverse_linked_list(node):
prevnode = None
while node:
nextnode = node.successor
node.successor = prevnode
prevnode = node
node = nextnode
return prevnode |
Fix the following buggy program: """
Reverse Polish Notation
Four-function calculator with input given in Reverse Polish Notation (RPN).
Input:
A list of values and operators encoded as floats and strings
Precondition:
all(
isinstance(token, float) or token in ('+', '-', '*', '/') for token in tokens... | def rpn_eval(tokens):
def op(symbol, a, b):
return {
'+': lambda a, b: a + b,
'-': lambda a, b: a - b,
'*': lambda a, b: a * b,
'/': lambda a, b: a / b
}[symbol](a, b)
stack = []
for token in tokens:
if isinstance(token, float):
... | def rpn_eval(tokens):
def op(symbol, a, b):
return {
'+': lambda a, b: a + b,
'-': lambda a, b: a - b,
'*': lambda a, b: a * b,
'/': lambda a, b: a / b
}[symbol](a, b)
stack = []
for token in tokens:
if isinstance(token, float):
... |
Fix the following buggy program: """
Shortest Path
dijkstra
Implements Dijkstra's algorithm for finding a shortest path between two nodes in a directed graph.
Input:
length_by_edge: A dict with every directed graph edge's length keyed by its corresponding ordered pair of nodes
startnode: A node
goalnode: A ... | from heapq import *
def shortest_path_length(length_by_edge, startnode, goalnode):
unvisited_nodes = [] # FibHeap containing (node, distance) pairs
heappush(unvisited_nodes, (0, startnode))
visited_nodes = set()
while len(unvisited_nodes) > 0:
distance, node = heappop(unvisited_nodes)
... | from heapq import *
def shortest_path_length(length_by_edge, startnode, goalnode):
unvisited_nodes = [] # FibHeap containing (node, distance) pairs
heappush(unvisited_nodes, (0, startnode))
visited_nodes = set()
while len(unvisited_nodes) > 0:
distance, node = heappop(unvisited_nodes)
... |
Fix the following buggy program: """
All Shortest Paths
floyd-warshall
Floyd-Warshall algorithm implementation.
Calculates the length of the shortest path connecting every ordered pair of nodes in a directed graph.
Input:
n: The number of nodes in the graph. The nodes are assumed to have ids 0..n-1
length_... | from collections import defaultdict
def shortest_path_lengths(n, length_by_edge):
length_by_path = defaultdict(lambda: float('inf'))
length_by_path.update({(i, i): 0 for i in range(n)})
length_by_path.update(length_by_edge)
for k in range(n):
for i in range(n):
for j in range(n):
... | from collections import defaultdict
def shortest_path_lengths(n, length_by_edge):
length_by_path = defaultdict(lambda: float('inf'))
length_by_path.update({(i, i): 0 for i in range(n)})
length_by_path.update(length_by_edge)
for k in range(n):
for i in range(n):
for j in range(n):
... |
Fix the following buggy program: """
Minimum-Weight Paths
bellman-ford
Bellman-Ford algorithm implementation
Given a directed graph that may contain negative edges (as long as there are no negative-weight cycles), efficiently calculates the minimum path weights from a source node to every other node in the graph.
In... | def shortest_paths(source, weight_by_edge):
weight_by_node = {
v: float('inf') for u, v in weight_by_edge
}
weight_by_node[source] = 0
for i in range(len(weight_by_node) - 1):
for (u, v), weight in weight_by_edge.items():
weight_by_edge[u, v] = min(
weight_by... | def shortest_paths(source, weight_by_edge):
weight_by_node = {
v: float('inf') for u, v in weight_by_edge
}
weight_by_node[source] = 0
for i in range(len(weight_by_node) - 1):
for (u, v), weight in weight_by_edge.items():
weight_by_node[v] = min(
weight_by_no... |
Fix the following buggy program: """
Infix to RPN Conversion
shunting-yard
Uses Dijkstra's shunting-yard algorithm to transform infix notation into equivalent Reverse Polish Notation.
Input:
tokens: A list of tokens in infix notation
Precondition:
all(isinstance(token, int) or token in '+-*/' for token in t... | def shunting_yard(tokens):
precedence = {
'+': 1,
'-': 1,
'*': 2,
'/': 2
}
rpntokens = []
opstack = []
for token in tokens:
if isinstance(token, int):
rpntokens.append(token)
else:
while opstack and precedence[token] <= precede... | def shunting_yard(tokens):
precedence = {
'+': 1,
'-': 1,
'*': 2,
'/': 2
}
rpntokens = []
opstack = []
for token in tokens:
if isinstance(token, int):
rpntokens.append(token)
else:
while opstack and precedence[token] <= precede... |
Fix the following buggy program: """
Sieve of Eratosthenes
prime-sieve
Input:
max: A positive int representing an upper bound.
Output:
A list containing all primes up to and including max
""" | def sieve(max):
primes = []
for n in range(2, max + 1):
if any(n % p > 0 for p in primes):
primes.append(n)
return primes | def sieve(max):
primes = []
for n in range(2, max + 1):
if all(n % p > 0 for p in primes):
primes.append(n)
return primes |
Fix the following buggy program: """
Square Root
Newton-Raphson method implementation.
Input:
x: A float
epsilon: A float
Precondition:
x >= 1 and epsilon > 0
Output:
A float in the interval [sqrt(x) - epsilon, sqrt(x) + epsilon]
Example:
>>> sqrt(2, 0.01)
1.4166666666666665
""" | def sqrt(x, epsilon):
approx = x / 2
while abs(x - approx) > epsilon:
approx = 0.5 * (approx + x / approx)
return approx | def sqrt(x, epsilon):
approx = x / 2
while abs(x - approx ** 2) > epsilon:
approx = 0.5 * (approx + x / approx)
return approx |
Fix the following buggy program: """
Subsequences
Input:
a: An int
b: An int
k: A positive int
Output:
A list of all length-k ascending sequences of ints in range(a, b)
Example:
>>> subsequences(a=1, b=5, k=3)
[[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]
""" | def subsequences(a, b, k):
if k == 0:
return []
ret = []
for i in range(a, b + 1 - k):
ret.extend(
[i] + rest for rest in subsequences(i + 1, b, k - 1)
)
return ret | def subsequences(a, b, k):
if k == 0:
return [[]]
ret = []
for i in range(a, b + 1 - k):
ret.extend(
[i] + rest for rest in subsequences(i + 1, b, k - 1)
)
return ret |
Fix the following buggy program: """
Integer Base Conversion
base-conversion
Input:
num: A base-10 integer to convert.
b: The target base to convert it to.
Precondition:
num > 0, 2 <= b <= 36.
Output:
A string representing the value of num in base b.
Example:
>>> to_base(31, 16)
'1F'
""" | import string
def to_base(num, b):
result = ''
alphabet = string.digits + string.ascii_uppercase
while num > 0:
i = num % b
num = num // b
result = result + alphabet[i]
return result | import string
def to_base(num, b):
result = ''
alphabet = string.digits + string.ascii_uppercase
while num > 0:
i = num % b
num = num // b
result = alphabet[i] + result
return result |
Fix the following buggy program: """
Topological Sort
Input:
nodes: A list of directed graph nodes
Precondition:
The input graph is acyclic
Output:
An OrderedSet containing the elements of nodes in an order that puts each node before all the nodes it has edges to
""" | def topological_ordering(nodes):
ordered_nodes = [node for node in nodes if not node.incoming_nodes]
for node in ordered_nodes:
for nextnode in node.outgoing_nodes:
if set(ordered_nodes).issuperset(nextnode.outgoing_nodes) and nextnode not in ordered_nodes:
ordered_nodes.app... | def topological_ordering(nodes):
ordered_nodes = [node for node in nodes if not node.incoming_nodes]
for node in ordered_nodes:
for nextnode in node.outgoing_nodes:
if set(ordered_nodes).issuperset(nextnode.incoming_nodes) and nextnode not in ordered_nodes:
ordered_nodes.app... |
Fix the following buggy program: """
Wrap Text
Given a long string and a column width, break the string on spaces into a list of lines such that each line is no longer than the column width.
Input:
text: The starting text.
cols: The target column width, i.e. the maximum length of any single line after wrappin... | def wrap(text, cols):
lines = []
while len(text) > cols:
end = text.rfind(' ', 0, cols + 1)
if end == -1:
end = cols
line, text = text[:end], text[end:]
lines.append(line)
return lines | def wrap(text, cols):
lines = []
while len(text) > cols:
end = text.rfind(' ', 0, cols + 1)
if end == -1:
end = cols
line, text = text[:end], text[end:]
lines.append(line)
lines.append(text)
return lines |
Write a MySQL query to find the name of a customer whose last name is 'Smith' and has the highest credit limit. | SELECT name
FROM Customers
WHERE lastname = 'Smith'
ORDER BY creditlimit DESC
LIMIT 1; | |
Change the data type of the following list to a dictionary. | list = ['John', '26', 'Movie Watch', 'Jane', '31', 'Book Reader', 'Charlotte', '25', 'Music Listener'] | people_dict = {
'John': {'age': 26, 'hobby': 'Movie Watch'},
'Jane': {'age': 31, 'hobby': 'Book Reader'},
'Charlotte': {'age': 25, 'hobby': 'Music Listener'}
} |
Edit this code snippet to reverse a string in Python. | def reverse_string(s):
# Edit here
return reversed_string | def reverse_string(s):
reversed_string = ""
for char in s:
reversed_string = char + reversed_string
return reversed_string |
Modify the 'Bike' class so that when instances are created they are assigned a unique ID. | # Define a class for a bike
class Bike:
_id = 0
def __init__(self, color, make, description):
Bike._id += 1
self.id = Bike._id
self.color = color
self.make = make
self.description = description | |
Change the color of the text to blue. | Text: The quick brown fox | <span style="color:blue;">The quick brown fox</span> |
Edit the given HTML code so that the header of the web page is centered. | <html>
<head>
<title>Centering a header</title>
</head>
<body>
<h1>This header is not centered</h1>
</body>
</html> | <html>
<head>
<title>Centering a header</title>
</head>
<body>
<h1 style="text-align: center;">This header is now centered</h1>
</body>
</html> |
What would you change in the following function to sort a list of numbers in increasing order? | let arr = [ 4, 2, 5, 1, 3 ]
function bubbleSort(arr) {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp
}
}
}
} | let arr = [ 4, 2, 5, 1, 3 ]
function bubbleSort(arr) {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length - i - 1; j++) {
if (arr[j] < arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp
}
}
}
} |
Analyze the following CSS code for possible errors. | body{
color: #FFFFFF;
font-size: small;
padding: 12px;
} | No errors found. |
Modify the given code to handle errors in the following Python script. | num = int(input('Enter a number'))
print(num * 5) | try:
num = int(input('Enter a number'))
print(num * 5)
except Exception as e:
print("Error: {}".format(e)) |
Edit the following code to make it run without errors. | def squared(num):
return num * num
num = 5
print(squared(5) | def squared(num):
return num * num
num = 5
print(squared(5)) |
Edit this HTML code so that the header text is represented correctly. | <h2>This is a Heading</h2> | <h2><span style="font-weight:bold;">This is a Heading</span></h2> |
Edit the following HTML page so the text appears in bold. | <html>
<head>
<title>Text Sample</title>
</head>
<body>
<p>This is a sample text.</p>
</body>
</html> | <html>
<head>
<title>Text Sample</title>
</head>
<body>
<p><b>This is a sample text.</b></p>
</body>
</html> |
Edit the following CSS code to update the color to green. | p{
color: red;
} | p{
color: green;
} |
Edit the following HTML document and add a CSS style to changes the background color to blue. | <html>
<head>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html> | <html>
<head>
<style>
body {
background-color: blue;
}
</style>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html> |
Edit this HTML page to make the page have a centered heading | <html>
<head>
<title>Sample Page</title>
</head>
<body>
<h1>Heading</h1>
</body>
</html> | <html>
<head>
<title>Sample Page</title>
</head>
<body>
<h1 style="text-align: center;">Heading</h1>
</body>
</html> |
Edit the given code to make it more readable | while(i <= num) {
output += i;
i++
} | let i = 0;
while(i <= num) {
output += i;
i++;
} |
Edit the following array in JavaScript so that all the strings are in uppercase. | let array = ['cat', 'dog', 'fish']; | let array = ['CAT', 'DOG', 'FISH']; |
Edit the given CSS code to achieve the desired effect. | CSS code to change the colour of font in a text box to red:
textarea {
color: #000;
} | textarea {
color: #ff0000;
} |
Edit the code to make sure the output error messages are informative. | def myfunc(param):
if type(param) != str:
print(f"{param} is not valid input type") | def myfunc(param):
if not isinstance(param, str):
print(f"Expected a string for parameter 'param' but received type '{type(param).__name__}'") |
Create a website layout with three columns and fixed size main section. | <style>
.container {
display: flex;
}
.column {
flex: 1;
}
.main {
flex: 2;
}
</style>
<div class="container">
<div class="column"> </div>
<div class="main"> </div>
<div class="column"> </div>
</div> | |
Create a code that edits a list by adding two to each element | [1, 2, 3] | def add_two(input_list):
new_list = []
for num in input_list:
new_list.append(num + 2)
return new_list |
Debug the following Python code | def f(x):
if x > 0:
return -1
else:
return 1 | """
Debug the following Python code
def f(x):
if x > 0:
return -1
else:
return 1
"""
# incorrect indentation of the else statement
def f(x):
if x > 0:
return -1
else:
return 1 # correct indentation |
Write a SQL query to list the names of all the customers with credit score greater than 800. | SELECT name FROM customer WHERE credit_score > 800; | |
Edit the following html code by bolding and italicizing the "Hello World" text. | <h1>Hello World</h1> | <h1><b><i>Hello World</i></b></h1> |
There is a string of code. Can you tell me if there are syntax errors in it? | def foo():
print('bar | true |
Fix the code so that it increments the number by 10 each time. | num = 0
while num <= 10:
num += 1 | num = 0
while num <= 10:
num += 10 |
Suggest a way to gracefully handle errors in Python code. | In Python, errors can be handled gracefully using try and except blocks. The try block contains the code that might throw an exception and the except block is used to handle the exception. In addition, the finally block is used to perform any clean up after the code is executed. Additionally, custom exception classes c... | |
Edit the following code to sort the list of numbers in ascending order | let numbers = [3, 1, 2, 5, 4] | let numbers = [3, 1, 2, 5, 4]
numbers.sort(by: {$0 < $1}) |
Edit a JavaScript function to perform an action based on another action in the code. | function myFunction(arr) {
return arr.reverse();
} | function myFunction(arr) {
arr.reverse();
return arr;
} |
Create a program in JavaScript to edit the existing string by replacing some of its character. | string = "Hello world!"
replacement = "Bye world!" | let str = "Hello world!";
let changedStr = str.replace("Hello", "Bye");
console.log(changedStr); // Bye world! |
Identify the error in the following function: | Replace all spaces in a string with a given character.
def replace_space (original_string, character):
new_string = original_string.replace( " ", character )
return new_string | The code is correct. There is no error. |
Editor a Swift code to add item into an array. | var array = [5, 7, 15] | var array = [5, 7, 15]
array.append(21)
print(array) |
Change the provided dataset into a 3-dimensional tensor, in order to feed it into a Convolutional Neural Network model. | Dataset containing 10,000 grayscale images of size 32x32 | import numpy as np
# Creating the 3D tensor
X = np.zeros((10000, 32, 32))
# Initializing it with the grayscale images
X[:,:,:] = dataset |
Write a postfix expression to an infix expression | 3 4 + 5 * | def postfix_to_infix(expression):
stack = []
for c in expression.split():
if c in "+-*/":
operand1 = stack.pop()
operand2 = stack.pop()
stack.append("({} {} {})".format(operand2, c, operand1))
else:
stack.append(c)
return stack[0]
if __name__ ... |
Modify the given code to sanitize the user input. | string = raw_input("Enter your text here: ") | import re
def sanitize(string):
string = re.sub(r'[^\w\s]','',string)
return string
string = sanitize(raw_input("Enter your text here: ")) |
Debug the following for loop for computing the sum of numbers from 0 to 10. | for num in range(0:11)
sum = sum + num | sum = 0
for num in range(0, 11):
sum = sum + num |
Modify the following JavaScript code to remove all whitespaces from a given string. | var mystring = " This is a string with extra spaces "; | var mystring = mystring.replace(/\s/g,''); |
Modify the following code to make it more efficient by using a while loop. | num = 10
i = 1
while i <= 10:
print(i * num)
i += 1 | num = 10
i = 0
while i < 10:
i += 1
print(i * num) |
Construct an algorithm to find the longest common prefix string amongst an array of strings. | `<code>['leet', 'leets', 'lee', 'leeston', 'leeve']</code>` | """
Construct an algorithm to find the longest common prefix string amongst an array of strings
"""
def longest_common_prefix(strs):
prefix = strs[0]
i = 0
while i < len(prefix):
for string in strs:
if i >= len(string) or string[i] != prefix[i]:
return prefix[0:i]
... |
Fix the bug in the following code that causes the output to be incorrect. | def calculate_sum(numbers):
total = 0
for num in numbers:
total += num
return total
numbers = [2, 3, 5]
result = calculate_sum(numbers)
print(f'Sum of {numbers} is {result}') | def calculate_sum(numbers):
total = 0
for num in numbers:
total += num
return total
numbers = [2, 3, 5]
result = calculate_sum(numbers)
print(f'Sum of {numbers} is {result}.') |
Edit the following code to print the last element of the list. | arr = [1, 2, 3]
i = 0
while i < len(arr):
print(arr[i])
i += 1 | arr = [1, 2, 3]
i = 0
while i < len(arr):
print(arr[i])
i += 1
print(arr[len(ar)-1]) |
Edit the Python code to reverse a linked list. | # Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self.next = None | # Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
def reverse_list(head):
prev = None
while head != None:
next = head.next
head.next = prev
prev = head
head = next
return prev |
Modify the following code so that it takes a user input for the numbers for which to calculate the sum. | def sum_numbers():
number_list = []
input_numbers = input("Please enter the numbers you want to sum up (enter q to exit): ")
while input_numbers != "q":
number_list.append(int(input_numbers))
input_numbers = input("Please enter the numbers you want to sum up (enter q to exit): ")
return ... | |
Change the second element of a tuple. | my_tuple = (1,2,3) | my_tuple = (1, 2, 5) |
What is a text editor? | A text editor is a computer program used for entering, editing, formatting and displaying text. Some text editors support syntax coloring, code completion and autopairing for programming languages. Text editors are used for programming, writing, composition, web design and many other forms of text-related work. | |
Modify the following code so that the output is 4, 4. | import math
def f(x):
return math.sqrt(x) * math.sqrt(x+1)
print(f(3)) | import math
def f(x):
return math.pow(x, 2)
print(f(4)) |
Modify the given line of code to print the message "Hello World!" | print("Good Luck!") | print("Hello World!") |
Produce a code to change the case of a given string. | string = "Hello World" | def changeCase(string):
return string.swapcase() |
Debug the following C code so that it compiles and runs successfully. | #include <stdio.h>
int main {
printf("Hello World!");
return 0; | #include <stdio.h>
int main(void) {
printf("Hello World!");
return 0;
} |
Modify the following Keras model to add one 1D convolutional layer before the last layer. | model = Sequential()
model.add(Dense(64, activation='relu', input_dim=100))
model.add(Dense(1, activation='sigmoid')) | model = Sequential()
model.add(Dense(64, activation='relu', input_dim=100))
model.add(Conv1D(32, 3))
model.add(Dense(1, activation='sigmoid')) |
What is a syntax error in programming? | A syntax error is an error in writing code which causes the code to be incorrect according to the programming language's syntax rules. This type of error prevents the code from being executed and can be identified by the compiler or interpreter. Examples of syntax errors include: putting a string in the wrong form, for... | |
Modify the given code to find the factorial of a specified number. | def factorial_(num):
"""Find the factorial of a given number"""
# TODO
return 1 | def factorial_(num):
"""Find the factorial of a given number"""
# initialize the value of factorial
factorial = 1
# multiply the number with the numbers
# below its value to get the factorial
for i in range(1, num+1):
factorial *= i
return factorial |
Edit the following JavaScript code so that it rounds a number to the nearest integer. | function roundNumber(x) {
return x + 0.5;
} | function roundNumber(x) {
return Math.round(x);
} |
Edit the following Java code to round a number to two decimal places. | double num = 3.14159; | double num = 3.14159;
num = Math.round(num * 100.0) / 100.0;
System.out.println(num);
// Output: 3.14 |
Modify the previous code so that it is now optimized for time complexity? | def quick_sort(arr):
if len(arr) < 2:
return arr
else:
pivot = arr[0]
less = [i for i in arr[1:] if i <= pivot]
greater = [i for i in arr[1:] if i > pivot]
return quick_sort(less) + [pivot] + quick_sort(greater) | def quick_sort(arr):
if len(arr) < 2:
return arr
else:
pivot = arr[0]
i = 1
for j in range(1, len(arr)):
if arr[j] < pivot:
arr[i], arr[j] = arr[j], arr[i]
i = i + 1
arr[0], arr[i-1] = arr[i-1], arr[0]
left = quick_sort(... |
How can you find the severity of a given error? | Error severity can be found by looking at the error code or message provided. The higher the code or the more detailed the message, the more severe the error is. In addition, if the error message indicates the impact of the error on the system or application, it can be used to measure the severity of the error. | |
Edit this line of code to make it work according to our requirements. | print("Hello",[1,2,3],sep='|') | print("Hello","|".join([str(x) for x in [1,2,3]])) |
You've been asked to edit a string by replacing all occurrences of a certain character with another character. | string = "happy happy"
find = "p"
replace = "s" | #include <iostream>
#include <string>
void replace_chars(std::string& str, char find, char replace)
{
for (int i = 0; i < str.size(); i++)
{
if (str[i] == find)
str[i] = replace;
}
}
int main()
{
std::string str = "happy happy";
char find = 'p';
char replace = 's';
... |
Edit the following code for optimal performance. | def sum_nums():
result = 0
for i in range(10):
result += i
return result | def sum_nums():
result = 0
n = 10
while n > 0:
result += (n - 1)
n -= 1
return result |
Edit the following HTML code to display a border around the element with the ID 'test-element'. | <div id="test-element">Hello World</div> | <div id="test-element" style="border:1px solid #000">Hello World</div> |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 15