answer:def shortest_subarray_with_sum(N, X, prices): Finds the length of the shortest contiguous subarray whose sum equals X. If there are multiple such subarrays, the one with the smallest starting index is chosen. If no such subarray is found, return -1. from collections import deque min_length = float('inf') current_sum = 0 start = 0 subarray_indices = (-1, -1) for end in range(N): current_sum += prices[end] while current_sum >= X: if current_sum == X: if (end - start + 1) < min_length: min_length = end - start + 1 subarray_indices = (start, end) current_sum -= prices[start] start += 1 return min_length if min_length != float('inf') else -1

answer:def convert_to_title_case(s): Converts a given string into Title Case. Parameters: s (str): Input string containing only alphabetic characters and spaces. Returns: str: The string converted to Title Case. return s.title()

answer:import heapq def find(parent, i): A function to find the set of an element i (uses path compression technique) if parent[i] == i: return i else: parent[i] = find(parent, parent[i]) return parent[i] def union(parent, rank, x, y): A function that does union of two sets of x and y (uses union by rank) xroot = find(parent, x) yroot = find(parent, y) if rank[xroot] < rank[yroot]: parent[xroot] = yroot elif rank[xroot] > rank[yroot]: parent[yroot] = xroot else: parent[yroot] = xroot rank[xroot] += 1 def kruskal_mst(towns, roads): Function to construct MST using Kruskal's algorithm result = [] # Step 1: Sort all the edges in non-decreasing order of their weight. roads = sorted(roads, key=lambda item: item[2]) parent = [] rank = [] # Create V subsets with single elements for node in range(towns): parent.append(node) rank.append(0) # Number of edges to be taken is equal to V-1 e = 0 i = 0 # Step 2: Pick the smallest edge. Check if it forms a cycle with the spanning tree # formed so far. If cycle is not formed, include this edge. Else, discard it. while e < towns - 1: # Step 2.1: Pick the smallest edge and increment the index for next iteration u, v, w = roads[i] i = i + 1 x = find(parent, u - 1) y = find(parent, v - 1) # If including this edge does't cause cycle, include it in result and increment # the index of result for next edge if x != y: e = e + 1 result.append([u, v, w]) union(parent, rank, x, y) # Else discard the edge # Print the contents of result[] to display the built MST minimum_cost = sum([w for u, v, w in result]) return minimum_cost def minimum_spanning_tree(towns, road_data): return kruskal_mst(towns, road_data)

answer:import math from functools import reduce def gcd(a, b): return math.gcd(a, b) def gcd_of_list(lst): return reduce(gcd, lst) def gcd_of_subarray(arr, l, r): subarray = arr[l-1:r] return gcd_of_list(subarray)