answer:def get_primes_up_to(n): primes = [] sieve = [True] * (n + 1) sieve[0] = sieve[1] = False for start in range(2, n + 1): if sieve[start]: primes.append(start) for multiple in range(start * start, n + 1, start): sieve[multiple] = False return primes def get_prime_map(): primes = get_primes_up_to(101) prime_map = {chr(97 + i): primes[i] for i in range(26)} # Mapping 'a'..'z' to prime numbers return prime_map def get_string_product(s, prime_map): product = 1 for char in s: product *= prime_map[char] return product def can_form_query_string(T, test_cases): prime_map = get_prime_map() results = [] for i in range(T): N, string_list, query_string = test_cases[i] string_products = [get_string_product(s, prime_map) for s in string_list] query_product = get_string_product(query_string, prime_map) from itertools import combinations, chain possible_products = set() possible_products.add(1) # Add product of empty sequence for length in range(1, N+1): for comb in combinations(string_products, length): combined_product = 1 for prod in comb: combined_product *= prod possible_products.add(combined_product) if query_product in possible_products: results.append("YES") else: results.append("NO") return results

answer:def max_subarray_sum(arr): Finds the maximum sum subarray from the given array of integers. Parameters: arr (list): A list of integers n (1 ≤ n ≤ 10^5), where elements are in range -10^4 ≤ a[i] ≤ 10^4. Returns: tuple: A tuple containing the maximum sum and a list representing one subarray with the maximum sum. max_sum = float('-inf') current_sum = 0 start = 0 end = 0 s = 0 for i in range(len(arr)): current_sum += arr[i] if current_sum > max_sum: max_sum = current_sum start = s end = i if current_sum < 0: current_sum = 0 s = i + 1 return (max_sum, arr[start:end+1]) # Example input and invocation # Example output should be (6, [4, -1, 2, 1]) # print(max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4]))

answer:class Node: def __init__(self, key=None, value=None): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self, capacity: int): self.capacity = capacity self.cache = dict() # maps key to node self.head = Node() # dummy head of the doubly linked list self.tail = Node() # dummy tail of the doubly linked list self.head.next = self.tail self.tail.prev = self.head def _remove(self, node): prev_node = node.prev next_node = node.next prev_node.next = next_node next_node.prev = prev_node def _add(self, node): prev_tail = self.tail.prev prev_tail.next = node self.tail.prev = node node.prev = prev_tail node.next = self.tail def get(self, key: int) -> int: if key in self.cache: node = self.cache[key] self._remove(node) self._add(node) return node.value return -1 def put(self, key: int, value: int) -> None: if key in self.cache: self._remove(self.cache[key]) elif len(self.cache) >= self.capacity: lru_node = self.head.next self._remove(lru_node) del self.cache[lru_node.key] new_node = Node(key, value) self._add(new_node) self.cache[key] = new_node

answer:def find_unique_triplets(nums): Returns a list of unique triplets [a, b, c] in nums such that a + b + c = 0. Triplets are ordered such that a <= b <= c. nums.sort() triplets = [] for i in range(len(nums)): if i > 0 and nums[i] == nums[i-1]: continue left, right = i+1, len(nums)-1 while left < right: total = nums[i] + nums[left] + nums[right] if total == 0: triplets.append([nums[i], nums[left], nums[right]]) # Move `left` and `right` to the next different numbers while left < right and nums[left] == nums[left + 1]: left += 1 while left < right and nums[right] == nums[right - 1]: right -= 1 left += 1 right -= 1 elif total < 0: left += 1 else: right -= 1 return triplets