Appearance
question:** Design a function `evaluate_and_optimize` that simulates a simple gradient descent optimization process for a linear regression model. The function will accept the following parameters: - `X`: Numpy array of shape (m, n) containing the features of the dataset. - `y`: Numpy array of shape (m,) containing the target values. - `learning_rate`: Scalar value representing the step size for each iteration of the gradient descent. - `iterations`: Integer value specifying the number of iterations to run the optimization. - `plot_performance`: Boolean value indicating whether to plot the cost function over iterations. Your task is to: 1. Initialize the weights and bias to zero. 2. Implement the gradient descent algorithm to update the weights and bias. 3. Compute the cost function (Mean Squared Error) at each iteration. 4. Store the cost at each iteration in a list called `cost_history`. 5. If `plot_performance` is set to True, plot the cost function over the iterations using `matplotlib.pyplot.plot` and `matplotlib.pyplot.show`. Your function signature should be: ```python def evaluate_and_optimize(X, y, learning_rate, iterations, plot_performance): ``` Here is a helper code snippet and the required libraries: ```python import numpy as np import matplotlib.pyplot as plt def compute_cost(X, y, weights, bias): m = len(y) predictions = X.dot(weights) + bias cost = (1 / (2 * m)) * np.sum((predictions - y) ** 2) return cost def gradient_descent_step(X, y, weights, bias, learning_rate): m = len(y) predictions = X.dot(weights) + bias dW = (1 / m) * X.T.dot(predictions - y) db = (1 / m) * np.sum(predictions - y) weights -= learning_rate * dW bias -= learning_rate * db return weights, bias def evaluate_and_optimize(X, y, learning_rate, iterations, plot_performance): m, n = X.shape weights = np.zeros(n) bias = 0 cost_history = [] for i in range(iterations): weights, bias = gradient_descent_step(X, y, weights, bias, learning_rate) cost = compute_cost(X, y, weights, bias) cost_history.append(cost) if plot_performance: plt.plot(range(iterations), cost_history) plt.xlabel('Iterations') plt.ylabel('Cost') plt.title('Cost Function over Iterations') plt.show() return weights, bias, cost_history # Example usage X = np.random.randn(100, 2) y = X[:, 0] * 3 + X[:, 1] * 5 + np.random.randn(100) evaluate_and_optimize(X, y, 0.01, 1000, True) ```
answer:import numpy as np import matplotlib.pyplot as plt def compute_cost(X, y, weights, bias): Computes the Mean Squared Error cost function. m = len(y) predictions = X.dot(weights) + bias cost = (1 / (2 * m)) * np.sum((predictions - y) ** 2) return cost def gradient_descent_step(X, y, weights, bias, learning_rate): Performs one step of gradient descent on the weights and bias. m = len(y) predictions = X.dot(weights) + bias dW = (1 / m) * X.T.dot(predictions - y) db = (1 / m) * np.sum(predictions - y) weights -= learning_rate * dW bias -= learning_rate * db return weights, bias def evaluate_and_optimize(X, y, learning_rate, iterations, plot_performance): Simulates the gradient descent optimization process for a linear regression model. m, n = X.shape weights = np.zeros(n) bias = 0 cost_history = [] for i in range(iterations): weights, bias = gradient_descent_step(X, y, weights, bias, learning_rate) cost = compute_cost(X, y, weights, bias) cost_history.append(cost) if plot_performance: plt.plot(range(iterations), cost_history) plt.xlabel('Iterations') plt.ylabel('Cost') plt.title('Cost Function over Iterations') plt.show() return weights, bias, cost_history # Example usage X = np.random.randn(100, 2) y = X[:, 0] * 3 + X[:, 1] * 5 + np.random.randn(100) evaluate_and_optimize(X, y, 0.01, 1000, True)
question:You are required to develop a function named `calculate_meeting_days` that determines the number of days two colleagues will meet at the office based on their individual work schedules. Both colleagues have schedules that repeat weekly. # Function Specification 1. **Input**: The function should accept two arguments: - A list representing the days the first colleague is in the office, e.g., `[1, 2, 3]` where 1 corresponds to Monday, 2 to Tuesday, etc. - A list representing the days the second colleague is in the office, e.g., `[3, 4, 5]`. 2. **Output**: The function should return an integer representing the number of days both colleagues are in the office simultaneously. # Example ```python def calculate_meeting_days(schedule1: List[int], schedule2: List[int]) -> int: ``` Example 1: ```plaintext Input: schedule1 = [1, 3, 5], schedule2 = [2, 3, 5] Output: 2 Explanation: Colleagues meet on Tuesdays (3) and Thursdays (5). ``` Example 2: ```plaintext Input: schedule1 = [1, 2, 3, 4, 5, 6, 7], schedule2 = [1, 2, 3, 4, 5, 6, 7] Output: 7 Explanation: Both colleagues are at the office every day of the week. ``` # Constraints - You can assume both input lists have unique values within the range [1, 7]. Write the function `calculate_meeting_days` to determine how many days both colleagues will be in the office together.
answer:def calculate_meeting_days(schedule1, schedule2): Returns the number of days both colleagues are in the office simultaneously. :param schedule1: List of integers representing the days first colleague is in the office. :param schedule2: List of integers representing the days second colleague is in the office. :return: Integer count of days both colleagues are in the office. # Convert the lists to sets set1 = set(schedule1) set2 = set(schedule2) # Find the intersection of both sets common_days = set1.intersection(set2) # Return the number of common days return len(common_days)
question:** You are tasked with creating a function named `find_common_elements` that identifies common elements from two lists and returns them as a sorted list without duplicates. Here's the detailed requirement: 1. Define a function `find_common_elements(list1, list2)` which will perform the following tasks: - Accept two lists as inputs: `list1` and `list2`. - Identify the common elements between the two lists. - Remove any duplicate values that might arise, ensuring that each element in the returned list is unique. - Return the common elements sorted in ascending order. **Function Signature**: ```python def find_common_elements(list1, list2): pass ``` **Examples**: ```python find_common_elements([1, 2, 3, 4], [3, 4, 5, 6]) # Returns: [3, 4] find_common_elements(['apple', 'banana', 'cherry'], ['banana', 'cherry', 'date', 'apple']) # Returns: ['apple', 'banana', 'cherry'] find_common_elements([1.1, 2.2, 3.3], [3.3, 4.4, 5.5, 1.1]) # Returns: [1.1, 3.3] ``` In this task, you will gain experience with set operations, list manipulations, and sorting in Python.
answer:def find_common_elements(list1, list2): Returns a sorted list of unique common elements from two lists. # Convert input lists to sets to find intersection set1 = set(list1) set2 = set(list2) # Find common elements common_elements = set1.intersection(set2) # Sort the common elements and convert to list before returning return sorted(common_elements)
question:You are asked to implement a function that generates a rotated version of a given 2D matrix. The function should be able to rotate the matrix 90, 180, or 270 degrees clockwise. You can accomplish this by first writing helper functions that generate the necessary transformations. The function should be named `rotate_matrix`. # Function Signature ```python def rotate_matrix(matrix: list[list[int]], angle: int) -> list[list[int]]: ``` # Parameters - `matrix` (list of list of int): A 2D list representing the matrix to be rotated. You can assume the input matrix will be non-empty and square (NxN). - `angle` (int): The degree of rotation. It can be `90`, `180`, or `270`. # Returns - `list of list of int`: A new matrix which is the rotated version of the input matrix. # Behavior 1. If the angle is `90`, the function should rotate the matrix 90 degrees clockwise. 2. If the angle is `180`, the function should rotate the matrix 180 degrees. 3. If the angle is `270`, the function should rotate the matrix 270 degrees clockwise. # Example ```python matrix_1 = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] angle_1 = 90 print(rotate_matrix(matrix_1, angle_1)) # Output should be: # [ # [7, 4, 1], # [8, 5, 2], # [9, 6, 3] # ] matrix_2 = [ [1, 2], [3, 4] ] angle_2 = 180 print(rotate_matrix(matrix_2, angle_2)) # Output should be: # [ # [4, 3], # [2, 1] # ] matrix_3 = [ [1, 2], [3, 4] ] angle_3 = 270 print(rotate_matrix(matrix_3, angle_3)) # Output should be: # [ # [2, 4], # [1, 3] # ] ``` # Constraints - The input matrix will always be a square matrix with side length between 1 and 100, inclusive. - The `angle` parameter will always be one of `90`, `180`, or `270`. - You are not allowed to use any in-built rotation functions or libraries for this task; implement the rotation logic manually.
answer:def rotate_matrix(matrix: list[list[int]], angle: int) -> list[list[int]]: Rotates the given NxN matrix to the specified angle. Args: matrix (list of list of int): A 2D list representing the matrix. angle (int): The angle of rotation. Can be 90, 180, or 270 degrees. Returns: list of list of int: A new matrix which is the rotated version of the input matrix. def rotate_90(matrix): n = len(matrix) rotated = [[0] * n for _ in range(n)] for i in range(n): for j in range(n): rotated[j][n-1-i] = matrix[i][j] return rotated def rotate_180(matrix): n = len(matrix) rotated = [[0] * n for _ in range(n)] for i in range(n): for j in range(n): rotated[n-1-i][n-1-j] = matrix[i][j] return rotated def rotate_270(matrix): n = len(matrix) rotated = [[0] * n for _ in range(n)] for i in range(n): for j in range(n): rotated[n-1-j][i] = matrix[i][j] return rotated if angle == 90: return rotate_90(matrix) elif angle == 180: return rotate_180(matrix) elif angle == 270: return rotate_270(matrix) else: raise ValueError("Invalid rotation angle. Choose between 90, 180, 270.")