Appearance
question:# Problem Statement As part of a data processing system, you need to implement a function that consolidates sales data from two different sources. The sales data from each source consists of product names and their respective sales figures. Your task is to merge these sales data, summing up the sales figures for products that appear in both sources. # Task Design a function `merge_sales_data(sales1: dict, sales2: dict) -> dict` that takes two dictionaries representing sales data from two different sources and returns a single dictionary with consolidated sales figures. # Input - Two dictionaries `sales1` and `sales2`. Each dictionary has keys as product names (strings) and values as sales figures (integers). # Output - A single dictionary with product names as keys and consolidated sales figures as values. If a product appears in both input dictionaries, its sales figures should be summed up. # Constraints - The keys (product names) in `sales1` and `sales2` are non-empty strings. - The values (sales figures) are non-negative integers. - The dictionaries have at most 1000 key-value pairs each. # Example ```python >>> merge_sales_data({"apple": 100, "banana": 150}, {"banana": 200, "cherry": 250}) {'apple': 100, 'banana': 350, 'cherry': 250} >>> merge_sales_data({"pen": 50}, {"pen": 30, "pencil": 20}) {'pen': 80, 'pencil': 20} >>> merge_sales_data({}, {"eraser": 5}) {'eraser': 5} >>> merge_sales_data({"notebook": 70, "marker": 90}, {}) {'notebook': 70, 'marker': 90} ``` # Detailed Requirements 1. The function should correctly sum the sales figures for products that are present in both dictionaries. 2. If a product appears in only one dictionary, it should appear in the resulting dictionary with its original sales figure. 3. The function should handle empty dictionaries correctly, including cases where one or both input dictionaries are empty. 4. Ensure your solution is efficient, considering both time complexity and memory usage.
answer:def merge_sales_data(sales1, sales2): Merges two sales data dictionaries and sums the values for matching keys. Args: sales1 (dict): Sales data from source 1. sales2 (dict): Sales data from source 2. Returns: dict: Consolidated sales data. merged_sales = sales1.copy() for product, sales in sales2.items(): if product in merged_sales: merged_sales[product] += sales else: merged_sales[product] = sales return merged_sales
question:# Coding Assessment Question Scenario You are a software engineer working on a data aggregation service for e-commerce websites. One of the features of your service is to analyze sales data to identify trends. Specifically, your task is to determine the maximum sales difference between any two days within a given range. Task Implement a function `max_sales_difference` that calculates the maximum difference in sales between any two days within a specified range for a given list of daily sales amounts. Function Signature ```python def max_sales_difference(sales: Sequence[int], start_day: int, end_day: int) -> int: pass ``` Input * `sales`: A sequence of integers representing the daily sales amounts. * `start_day`: An integer representing the starting index (inclusive) of the range. * `end_day`: An integer representing the ending index (inclusive) of the range. Output * Returns an integer representing the maximum difference between the sales on any two days within the specified range. Constraints * `start_day` and `end_day` will always be valid indexes within the bounds of the `sales` list. * The list of sales amounts will have at least two elements. * `start_day` will always be less than or equal to `end_day`. Performance Requirement * Aim for (O(n)) time complexity within the specified range. Example ```python >>> max_sales_difference([120, 180, 90, 200, 150, 80, 250], 1, 5) 110 # Maximum difference is between 200 (index 3) and 90 (index 2). >>> max_sales_difference([100, 220, 150, 180, 90], 0, 2) 120 # Maximum difference is between 220 (index 1) and 100 (index 0). >>> max_sales_difference([50, 60, 70, 80, 90], 2, 4) 20 # Maximum difference is between 90 (index 4) and 70 (index 2). ``` Edge Cases * Verify behavior when `start_day` and `end_day` are the same (should return 0). * Verify handling of the smallest possible sales list with two elements.
answer:from typing import Sequence def max_sales_difference(sales: Sequence[int], start_day: int, end_day: int) -> int: Calculates the maximum difference in sales between any two days within the given range. Args: sales (Sequence[int]): A sequence of integers representing daily sales amounts. start_day (int): The starting index (inclusive) of the range. end_day (int): The ending index (inclusive) of the range. Returns: int: The maximum difference between sales on any two days within the specified range. min_sales = sales[start_day] max_sales = sales[start_day] for i in range(start_day, end_day + 1): if sales[i] < min_sales: min_sales = sales[i] if sales[i] > max_sales: max_sales = sales[i] return max_sales - min_sales
question:# Directed Graph Pathfinding Problem Context You have been tasked with developing a pathfinding algorithm in a directed graph for a route planning application. Users should be able to find the shortest path between two locations if one exists. Task Implement a class `DirectedGraph` in Python that supports the following operations: 1. Initialization of an empty graph. 2. Adding nodes and directed edges with associated positive costs. 3. Finding the shortest path between two nodes using Dijkstra's algorithm. 4. String representation of the graph. Requirements 1. **Initialization**: - The constructor should start with an empty graph. ```python def __init__(self) -> None: ``` 2. **Adding a Node**: ```python def add_node(self, node: Any) -> None: ``` 3. **Adding a Directed Edge**: ```python def add_edge(self, from_node: Any, to_node: Any, cost: float) -> None: ``` 4. **Shortest Path (Dijkstra's Algorithm)**: ```python def shortest_path(self, start_node: Any, end_node: Any) -> Tuple[List[Any], float]: ``` 5. **String Representation**: ```python def __str__(self) -> str: ``` Input and Output Formats: - **Adding a Node**: `graph.add_node('A')` should add node 'A' to the graph. - **Adding a Directed Edge**: `graph.add_edge('A', 'B', 3.5)` should add a directed edge from 'A' to 'B' with a cost of 3.5. - **Shortest Path**: `graph.shortest_path('A', 'C')` should return (['A', 'B', 'C'], 5.0) if the shortest path from 'A' to 'C' is A -> B -> C with a total cost of 5.0. Constraints: - Costs of the edges should always be positive real numbers. - Ensure that your algorithm can handle graphs with up to 10,000 nodes and 50,000 edges efficiently. - If there is no path between the start and end node, return ([], float('inf')). - Use appropriate data structures to guarantee efficient performance. Example: ```python graph = DirectedGraph() graph.add_node('A') graph.add_node('B') graph.add_node('C') graph.add_edge('A', 'B', 1) graph.add_edge('B', 'C', 2) graph.add_edge('A', 'C', 4) print(graph.shortest_path('A', 'C')) # Should return (['A', 'B', 'C'], 3.0) print(graph) # Should display the graph with nodes and edges ```
answer:import heapq from typing import Any, List, Dict, Tuple class DirectedGraph: def __init__(self) -> None: self.graph: Dict[Any, Dict[Any, float]] = {} def add_node(self, node: Any) -> None: if node not in self.graph: self.graph[node] = {} def add_edge(self, from_node: Any, to_node: Any, cost: float) -> None: if from_node in self.graph and to_node in self.graph: self.graph[from_node][to_node] = cost def shortest_path(self, start_node: Any, end_node: Any) -> Tuple[List[Any], float]: if start_node not in self.graph or end_node not in self.graph: return ([], float('inf')) distances = {node: float('inf') for node in self.graph} previous_nodes = {node: None for node in self.graph} distances[start_node] = 0 priority_queue = [(0, start_node)] while priority_queue: current_distance, current_node = heapq.heappop(priority_queue) if current_distance > distances[current_node]: continue for neighbor, weight in self.graph[current_node].items(): distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance previous_nodes[neighbor] = current_node heapq.heappush(priority_queue, (distance, neighbor)) path = [] current_node = end_node while previous_nodes[current_node] is not None: path.insert(0, current_node) current_node = previous_nodes[current_node] if path: path.insert(0, start_node) if distances[end_node] == float('inf'): return ([], float('inf')) return (path, distances[end_node]) def __str__(self) -> str: result = '' for node in self.graph: for neighbor, cost in self.graph[node].items(): result += f'{node} -> {neighbor} [cost={cost}]n' return result
question:# Integer Sequence Analyzer You are provided with a list of integers representing a sequence. Your task is to analyze the sequence and determine specific properties such as its length, the maximum value, the minimum value, and whether the sequence is strictly increasing, strictly decreasing, or neither. Requirements: 1. **Analyze Sequence Properties**: Implement a function `analyze_sequence(sequence: List[int]) -> Dict[str, Union[int, bool]]` that returns a dictionary with the following information: - The length of the sequence. - The maximum value in the sequence. - The minimum value in the sequence. - A boolean indicating if the sequence is strictly increasing. - A boolean indicating if the sequence is strictly decreasing. # Input Specifications: 1. The function `analyze_sequence(sequence: List[int]) -> Dict[str, Union[int, bool]]` accepts a list of integers as input. # Output Specifications: 1. The function should return a dictionary with keys: `length`, `max_value`, `min_value`, `is_increasing`, and `is_decreasing`. # Constraints: 1. The input list will contain at least one integer. 2. Assume all list values are integers. # Scenarios and Examples: 1. **Simple Case**: - `analyze_sequence([1, 2, 3, 4, 5])` should return `{'length': 5, 'max_value': 5, 'min_value': 1, 'is_increasing': True, 'is_decreasing': False}`. 2. **Constant Sequence**: - `analyze_sequence([5, 5, 5, 5, 5])` should return `{'length': 5, 'max_value': 5, 'min_value': 5, 'is_increasing': False, 'is_decreasing': False}`. 3. **Decreasing Sequence**: - `analyze_sequence([5, 4, 3, 2, 1])` should return `{'length': 5, 'max_value': 5, 'min_value': 1, 'is_increasing': False, 'is_decreasing': True}`. 4. **Mixed Sequence**: - `analyze_sequence([3, 1, 4, 1, 5, 9, 2, 6, 5])` should return `{'length': 9, 'max_value': 9, 'min_value': 1, 'is_increasing': False, 'is_decreasing': False}`. # Boilerplate Code ```python from typing import List, Dict, Union def analyze_sequence(sequence: List[int]) -> Dict[str, Union[int, bool]]: length = len(sequence) max_value = max(sequence) min_value = min(sequence) is_increasing = all(x < y for x, y in zip(sequence, sequence[1:])) is_decreasing = all(x > y for x, y in zip(sequence, sequence[1:])) return { 'length': length, 'max_value': max_value, 'min_value': min_value, 'is_increasing': is_increasing, 'is_decreasing': is_decreasing } if __name__ == "__main__": import doctest # Write doctests for analyze_sequence doctest.testmod() ```
answer:from typing import List, Dict, Union def analyze_sequence(sequence: List[int]) -> Dict[str, Union[int, bool]]: length = len(sequence) max_value = max(sequence) min_value = min(sequence) is_increasing = all(x < y for x, y in zip(sequence, sequence[1:])) is_decreasing = all(x > y for x, y in zip(sequence, sequence[1:])) return { 'length': length, 'max_value': max_value, 'min_value': min_value, 'is_increasing': is_increasing, 'is_decreasing': is_decreasing }