Appearance
question:def max_tasks(n: int, k: int, a: List[int]) -> int: Determines the maximum number of tasks that can be completed within a total time of k. Parameters: n (int): Number of tasks. k (int): Total time available. a (list of int): List of times each task takes. Returns: int: The maximum number of tasks that can be completed within the total time k. >>> max_tasks(5, 10, [1, 2, 3, 4, 5]) 4 >>> max_tasks(5, 1, [2, 3, 4, 5, 6]) 0 >>> max_tasks(3, 10, [1, 2, 3]) 3 >>> max_tasks(1, 1, [1]) 1 >>> max_tasks(1, 0, [1]) 0 >>> max_tasks(1, 1, [2]) 0 >>> max_tasks(4, 1000000000, [100000000, 200000000, 300000000, 400000000]) 4 >>> max_tasks(6, 7, [2, 3, 3, 2, 1, 1]) 4
answer:def max_tasks(n, k, a): Determines the maximum number of tasks that can be completed within a total time of k. Parameters: n (int): Number of tasks. k (int): Total time available. a (list of int): List of times each task takes. Returns: int: The maximum number of tasks that can be completed within the total time k. # Sort the tasks by their time requirements (ascending order) a.sort() time_spent = 0 tasks_completed = 0 # Iterate through the sorted times for time in a: if time_spent + time <= k: time_spent += time tasks_completed += 1 else: break return tasks_completed
question:def longest_same_parity_subarray(t: int, test_cases: List[Tuple[int, List[int]]]) -> List[int]: Determine the length of the largest contiguous subarray where all elements have the same parity. Args: t (int): The number of test cases. test_cases (List[Tuple[int, List[int]]]): A list of tuples where each tuple contains an integer n and a list of integers. Returns: List[int]: A list of integers, each integer representing the length of the largest contiguous subarray of the same parity for each test case. Example: >>> longest_same_parity_subarray(2, [(7, [1, 2, 2, 2, 3, 4, 4]), (6, [5, 5, 5, 5, 5, 5])]) [3, 6] >>> longest_same_parity_subarray(1, [(5, [2, 2, 2, 2, 2])]) [5] >>> longest_same_parity_subarray(1, [(5, [1, 2, 3, 4, 5])]) [1] from solution import longest_same_parity_subarray def test_single_test_case(): t = 1 test_cases = [(7, [1, 2, 2, 2, 3, 4, 4])] assert longest_same_parity_subarray(t, test_cases) == [3] def test_multiple_test_cases(): t = 2 test_cases = [ (7, [1, 2, 2, 2, 3, 4, 4]), (6, [5, 5, 5, 5, 5, 5]) ] assert longest_same_parity_subarray(t, test_cases) == [3, 6] def test_all_same_parity(): t = 1 test_cases = [(5, [2, 2, 2, 2, 2])] assert longest_same_parity_subarray(t, test_cases) == [5] def test_no_repeats(): t = 1 test_cases = [(5, [1, 2, 3, 4, 5])] assert longest_same_parity_subarray(t, test_cases) == [1] def test_alternating_parity(): t = 1 test_cases = [(8, [1, 2, 1, 2, 1, 2, 1, 2])] assert longest_same_parity_subarray(t, test_cases) == [1] def test_single_element(): t = 1 test_cases = [(1, [7])] assert longest_same_parity_subarray(t, test_cases) == [1]
answer:def longest_same_parity_subarray(t, test_cases): results = [] for i in range(t): n, arr = test_cases[i] max_length = 1 current_length = 1 for j in range(1, n): if arr[j] % 2 == arr[j - 1] % 2: current_length += 1 else: max_length = max(max_length, current_length) current_length = 1 max_length = max(max_length, current_length) results.append(max_length) return results
question:def min_total_cost(n: int, m: int, roads: List[Tuple[int, int, int, int]]) -> int: Find the minimum total installation cost to ensure all intersections are illuminated. Args: n: int - number of intersections m: int - number of roads roads: list of tuples - each tuple contains (u, v, l, c) Returns: int - minimum total cost to ensure all intersections are illuminated >>> min_total_cost(4, 5, [(0, 1, 10, 5), (0, 2, 6, 2), (0, 3, 5, 1), (1, 3, 15, 10), (2, 3, 4, 3)]) 8 >>> min_total_cost(2, 1, [(0, 1, 10, 1)]) 1 >>> min_total_cost(2, 2, [(0, 1, 10, 5), (0, 1, 15, 3)]) 3 >>> min_total_cost(1, 0, []) 0 >>> min_total_cost(3, 1, [(0, 1, 10, 4)]) 4 >>> min_total_cost(4, 5, [(0, 1, 1, 3), (1, 2, 2, 2), (2, 3, 3, 1), (0, 3, 4, 4), (1, 3, 10, 2)]) 6
answer:def min_total_cost(n, m, roads): Find the minimum total installation cost to ensure all intersections are illuminated. Args: n: int - number of intersections m: int - number of roads roads: list of tuples - each tuple contains (u, v, l, c) Returns: int - minimum total cost to ensure all intersections are illuminated import heapq # Create adjacency list for the graph adj = [[] for _ in range(n)] for u, v, l, c in roads: adj[u].append((c, v)) adj[v].append((c, u)) # Use a min-heap to build our MST using Prim's algorithm min_heap = [(0, 0)] # (cost, node) visited = [False] * n total_cost = 0 while min_heap: cost, node = heapq.heappop(min_heap) if visited[node]: continue visited[node] = True total_cost += cost for edge_cost, neighbor in adj[node]: if not visited[neighbor]: heapq.heappush(min_heap, (edge_cost, neighbor)) return total_cost
question:def generate_sequence(n: int) -> list: Generate a sequence of length n such that for every integer k from 1 to n, there are exactly k numbers in the sequence that are divisible by k. Parameters: n (int): The length of the sequence. Returns: list: A sequence of integers of length n that satisfies the condition, or returns -1 if no such sequence exists. >>> generate_sequence(1) [1] >>> generate_sequence(2) [1, 2] >>> generate_sequence(3) [1, 2, 3] >>> generate_sequence(4) [1, 2, 3, 4] # Your code here
answer:def generate_sequence(n): Generate a sequence of length n such that for every integer k from 1 to n, there are exactly k numbers in the sequence that are divisible by k. Parameters: n (int): The length of the sequence. Returns: list: A sequence of integers of length n that satisfies the condition, or returns -1 if no such sequence exists. if n == 1: return [1] sequence = [i for i in range(1, n + 1)] return sequence