scratch/debug.txt

��t1_001 
ORIG:
 def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1 
BUGGY:
 def binary_search(arr, target):
    left, right = 0, len(arr)
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid
    return -1 
TESTS:
 [{'input': [[1, 3, 5, 7, 9], 5], 'expected_output': 2}, {'input': [[1, 3, 5, 7, 9], 1], 'expected_output': 0}, {'input': [[1, 3, 5, 7, 9], 9], 'expected_output': 4}, {'input': [[1, 3, 5, 7, 9], 4], 'expected_output': -1}] 

t1_003 
ORIG:
 def find_max(nums):
    max_val = nums[0]
    for i in range(1, len(nums)):
        if nums[i] > max_val:
            max_val = nums[i]
    return max_val 
BUGGY:
 def find_max(nums):
    max_val = nums[0]
    for i in range(1, len(nums) + 1):
        if nums[i] > max_val:
            max_val = nums[i]
    return max_val 
TESTS:
 [{'input': [3, 1, 4, 1, 5, 9], 'expected_output': 9}, {'input': [1], 'expected_output': 1}, {'input': [-5, -1, -3], 'expected_output': -1}, {'input': [7, 7, 7], 'expected_output': 7}] 

t1_005 
ORIG:
 def sum_list(nums):
    total = 0
    for i in range(len(nums)):
        total += nums[i]
    return total 
BUGGY:
 def sum_list(nums):
    total = 0
    for i in range(len(nums) - 1):
        total += nums[i]
    return total 
TESTS:
 [{'input': [1, 2, 3], 'expected_output': 6}, {'input': [0], 'expected_output': 0}, {'input': [10, 20, 30, 40], 'expected_output': 100}, {'input': [], 'expected_output': 0}] 

t1_006 
ORIG:
 def is_sorted(lst):
    for i in range(len(lst) - 1):
        if lst[i] > lst[i + 1]:
            return False
    return True 
BUGGY:
 def is_sorted(lst):
    for i in range(len(lst) - 1):
        if lst[i] > lst[i + 1]:
            return True
    return False 
TESTS:
 [{'input': [1, 2, 3], 'expected_output': True}, {'input': [3, 1, 2], 'expected_output': False}, {'input': [1], 'expected_output': True}, {'input': [2, 2, 2], 'expected_output': True}] 

t1_026 
ORIG:
 def longest_common_prefix(strs):
    if not strs:
        return ""
    prefix = strs[0]
    for s in strs[1:]:
        while not s.startswith(prefix):
            prefix = prefix[:-1]
            if not prefix:
                return ""
    return prefix 
BUGGY:
 def longest_common_prefix(strs):
    if not strs:
        return ""
    prefix = strs[0]
    for s in strs:
        while not s.startswith(prefix):
            prefix = prefix[:-1]
            if not prefix:
                return ""
    return prefix 
TESTS:
 [{'input': [['flower', 'flow', 'flight']], 'expected_output': 'fl'}, {'input': [['dog', 'racecar', 'car']], 'expected_output': ''}, {'input': [[]], 'expected_output': ''}, {'input': [['a']], 'expected_output': 'a'}] 

t1_033 
ORIG:
 def house_robber(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    dp = [0] * len(nums)
    dp[0] = nums[0]
    dp[1] = max(nums[0], nums[1])
    for i in range(2, len(nums)):
        dp[i] = max(dp[i-1], dp[i-2] + nums[i])
    return dp[-1] 
BUGGY:
 def house_robber(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    dp = [0] * len(nums)
    dp[0] = nums[0]
    dp[1] = min(nums[0], nums[1])
    for i in range(2, len(nums)):
        dp[i] = max(dp[i-1], dp[i-2] + nums[i])
    return dp[-1] 
TESTS:
 [{'input': [[1, 2, 3, 1]], 'expected_output': 4}, {'input': [[2, 7, 9, 3, 1]], 'expected_output': 12}, {'input': [[]], 'expected_output': 0}, {'input': [[5]], 'expected_output': 5}] 

t1_034 
ORIG:
 def house_robber(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    dp = [0] * len(nums)
    dp[0] = nums[0]
    dp[1] = max(nums[0], nums[1])
    for i in range(2, len(nums)):
        dp[i] = max(dp[i-1], dp[i-2] + nums[i])
    return dp[-1] 
BUGGY:
 def house_robber(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    dp = [0] * len(nums)
    dp[0] = nums[0]
    dp[1] = max(nums[0], nums[1])
    for i in range(1, len(nums)):
        dp[i] = max(dp[i-1], dp[i-2] + nums[i])
    return dp[-1] 
TESTS:
 [{'input': [[1, 2, 3, 1]], 'expected_output': 4}, {'input': [[2, 7, 9, 3, 1]], 'expected_output': 12}, {'input': [[]], 'expected_output': 0}, {'input': [[5]], 'expected_output': 5}] 

t2_003 
ORIG:
 def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result 
BUGGY:
 def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.append(flatten(item))
        else:
            result.append(item)
    return result 
TESTS:
 [{'input': [[1, [2]], 3], 'expected_output': [1, 2, 3]}, {'input': [1, 2, 3], 'expected_output': [1, 2, 3]}, {'input': [[1, 2], [3, [4, 5]]], 'expected_output': [1, 2, 3, 4, 5]}] 

t2_026 
ORIG:
 def find_min_max(nums):
    if not nums:
        return None
    mn = min(nums)
    mx = max(nums)
    return (mn, mx) 
BUGGY:
 def find_min_max(nums):
    if not nums:
        return None
    mn = min(nums)
    mx = max(nums)
    return (mn, mn) 
TESTS:
 [{'input': [[1, 2, 5]], 'expected_output': (1, 5)}, {'input': [[3, 3]], 'expected_output': (3, 3)}, {'input': [[-1, 0, 1]], 'expected_output': (-1, 1)}, {'input': [[]], 'expected_output': None}] 

t2_029 
ORIG:
 def swap_halves(lst):
    mid = len(lst) // 2
    left = lst[:mid]
    right = lst[mid:]
    return right + left 
BUGGY:
 def swap_halves(lst):
    mid = len(lst) // 2
    left = lst[:mid]
    right = lst[mid:]
    return left + left 
TESTS:
 [{'input': [[1, 2, 3, 4]], 'expected_output': [3, 4, 1, 2]}, {'input': [[1, 2, 3]], 'expected_output': [3, 1, 2]}, {'input': [[1]], 'expected_output': [1]}, {'input': [[]], 'expected_output': []}] 

t3_002 
ORIG:
 def rotate_matrix(matrix):
    n = len(matrix)
    for i in range(n):
        for j in range(i, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
    for row in matrix:
        row.reverse()
    return matrix 
BUGGY:
 def rotate_matrix(matrix):
    n = len(matrix)
    for i in range(n):
        for j in range(i, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
    return matrix 
TESTS:
 [{'input': [[1, 2], [3, 4]], 'expected_output': [[3, 1], [4, 2]]}, {'input': [[1, 2, 3], [4, 5, 6], [7, 8, 9]], 'expected_output': [[7, 4, 1], [8, 5, 2], [9, 6, 3]]}] 

t3_007 
ORIG:
 def calc_area(w, h):
    return w * h

def create_rectangle(width, height):
    return {'w': width, 'h': height, 'area': calc_area(width, height)} 
BUGGY:
 def calc_area(w, h):
    return w * h

def create_rectangle(width, height):
    return {'w': width, 'h': height, 'area': calc_area(height, width)} 
TESTS:
 [{'input': [5, 10], 'expected_output': {'w': 5, 'h': 10, 'area': 50}}, {'input': [2, 3], 'expected_output': {'w': 2, 'h': 3, 'area': 6}}, {'input': [1, 1], 'expected_output': {'w': 1, 'h': 1, 'area': 1}}, {'input': [0, 5], 'expected_output': {'w': 0, 'h': 5, 'area': 0}}] 

t3_009 
ORIG:
 def filter_unique(items, seen):
    res = []
    for item in items:
        if item not in seen:
            seen.add(item)
            res.append(item)
    return res

def get_unique_items(items):
    return filter_unique(items, set()) 
BUGGY:
 seen = set()
def filter_unique(items):
    res = []
    for item in items:
        if item not in seen:
            seen.add(item)
            res.append(item)
    return res

def get_unique_items(items):
    return filter_unique(items) 
TESTS:
 [{'input': [[1, 2, 2, 3]], 'expected_output': [1, 2, 3]}, {'input': [[1, 2, 2, 3]], 'expected_output': [1, 2, 3]}, {'input': [[4, 4, 5]], 'expected_output': [4, 5]}, {'input': [[4, 4, 5]], 'expected_output': [4, 5]}] 

t3_010 
ORIG:
 def accumulate_values(vals):
    total = 0
    res = []
    for v in vals:
        total += v
        res.append(total)
    return res 
BUGGY:
 total = 0
def add_to_total(val):
    global total
    total += val
    return total

def accumulate_values(vals):
    return [add_to_total(v) for v in vals] 
TESTS:
 [{'input': [[1, 2]], 'expected_output': [1, 3]}, {'input': [[1, 2]], 'expected_output': [1, 3]}, {'input': [[5, 5]], 'expected_output': [5, 10]}, {'input': [[5, 5]], 'expected_output': [5, 10]}] 

t3_011 
ORIG:
 def helper(val, lst=None):
    if lst is None:
        lst = []
    lst.append(val)
    return lst

def append_to_default(val):
    return helper(val) 
BUGGY:
 def helper(val, lst=[]):
    lst.append(val)
    return lst

def append_to_default(val):
    return helper(val) 
TESTS:
 [{'input': 1, 'expected_output': [1]}, {'input': 2, 'expected_output': [2]}, {'input': 3, 'expected_output': [3]}, {'input': 4, 'expected_output': [4]}] 

t3_012 
ORIG:
 def count_calls(n):
    calls = 0
    res = []
    for _ in range(n):
        calls += 1
        res.append(calls)
    return res 
BUGGY:
 calls = 0
def tracker():
    global calls
    calls += 1
    return calls

def count_calls(n):
    res = []
    for _ in range(n):
        res.append(tracker())
    return res 
TESTS:
 [{'input': 2, 'expected_output': [1, 2]}, {'input': 2, 'expected_output': [1, 2]}, {'input': 3, 'expected_output': [1, 2, 3]}, {'input': 3, 'expected_output': [1, 2, 3]}] 

t3_013 
ORIG:
 def build_sentence(words):
    words_cache = []
    def add_word(w):
        words_cache.append(w)
        return ' '.join(words_cache)
    res = ''
    for w in words:
        res = add_word(w)
    return res 
BUGGY:
 words_cache = []
def add_word(w):
    words_cache.append(w)
    return ' '.join(words_cache)

def build_sentence(words):
    res = ''
    for w in words:
        res = add_word(w)
    return res 
TESTS:
 [{'input': [['hello', 'world']], 'expected_output': 'hello world'}, {'input': [['foo', 'bar']], 'expected_output': 'foo bar'}, {'input': [['a', 'b', 'c']], 'expected_output': 'a b c'}, {'input': [['x']], 'expected_output': 'x'}] 

t3_014 
ORIG:
 def collect_errors(err_list):
    errors = []
    def log_error(err):
        errors.append(err)
        return errors
    res = []
    for e in err_list:
        res = log_error(e)
    return res 
BUGGY:
 errors = []
def log_error(err):
    errors.append(err)
    return errors

def collect_errors(err_list):
    for e in err_list:
        res = log_error(e)
    return res if err_list else [] 
TESTS:
 [{'input': [['e1']], 'expected_output': ['e1']}, {'input': [['e2']], 'expected_output': ['e2']}, {'input': [['e3', 'e4']], 'expected_output': ['e3', 'e4']}, {'input': [['e5']], 'expected_output': ['e5']}]