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']}]