You are given a Python 3 online assessment with seven independent coding tasks. For each task, implement a function named `solution` with the specified signature. Unless otherwise stated, return a new value and do not rely on unavailable external state. ## 1. Center Crop Implement: ```python def solution(image: list[list[int]], crop_height: int, crop_width: int) -> list[list[int]]: pass ``` Given a grayscale image represented as a 2D list of integers with shape `H x W`, return the centered crop with shape `crop_height x crop_width`. Requirements: - `crop_height <= H` and `crop_width <= W`. - The crop is centered in the original image. - It is guaranteed that `H - crop_height` and `W - crop_width` are even, so the crop removes the same number of rows or columns from both sides. - Do not use NumPy. ## 2. Rotate Image 90 Degrees Clockwise Implement: ```python def solution(image: list[list[int]]) -> list[list[int]]: pass ``` Given a grayscale image represented as a 2D list of integers with shape `H x W`, return a new 2D list with shape `W x H` representing the image rotated 90 degrees clockwise. Requirements: - You may use Python built-ins. - You may use NumPy for basic array manipulation, but you may not use a direct rotation helper such as `rot90`. ## 3. Softmax Implement: ```python import math def solution(z: list[float]) -> list[float]: pass ``` Given a list of logits `z`, return the softmax probabilities. For each index `i`, the output is: ```text exp(z[i]) / sum(exp(z[j]) for all j) ``` Requirements: - Return a list of floats of the same length as `z`. - Do not use NumPy, PyTorch, or similar libraries. - You may use `math.exp`. - The implementation should avoid numerical overflow or instability for large logits. ## 4. Gaussian Blur Kernel Implement: ```python def solution(k: int, sigma: float) -> list[list[float]]: pass ``` Return a 2D Gaussian blur kernel of size `k x k`. For each cell, compute the unnormalized Gaussian weight using: ```text G(x, y) = (1 / (2 * pi * sigma^2)) * exp(-(x^2 + y^2) / (2 * sigma^2)) ``` where `x` and `y` are distances from the center of the kernel. Requirements: - `k` is the kernel size and should be odd for symmetry, for example `3`, `5`, or `7`. - `sigma` is the standard deviation controlling the spread of the Gaussian. - The center cell has coordinate offset `(0, 0)`. - Normalize the kernel so that the sum of all values is `1.0`. - Return the kernel as a 2D list of floats. ## 5. Triangle From Adjacent Elements Implement: ```python def solution(arr: list[int]) -> list[int]: pass ``` You are given an array of positive integers `arr`. For every adjacent triple `(arr[i], arr[i + 1], arr[i + 2])`, determine whether those three values can be side lengths of a triangle. Return an array of length `len(arr) - 2`, where the `i`th element is: - `1` if a triangle can be formed from `arr[i]`, `arr[i + 1]`, and `arr[i + 2]`. - `0` otherwise. A triangle can be formed from side lengths `a`, `b`, and `c` if: ```text a + b > c a + c > b b + c > a ``` Examples: ```text arr = [1, 2, 2, 4] output = [1, 0] ``` ```text arr = [2, 10, 2, 10, 2] output = [0, 1, 0] ``` ```text arr = [1000000000, 1000000000, 1000000000, 1000000000] output = [1, 1] ``` Constraints: - `3 <= len(arr) <= 1000` - `1 <= arr[i] <= 10^9` ## 6. Minimum Euclidean Distance Implement: ```python def solution(p: list[list[int]]) -> float: pass ``` You are given an array `p` of points on a Cartesian plane. Each point is represented as `[x, y]`. Return the minimum Euclidean distance between two points with different indices. The Euclidean distance between points `(x1, y1)` and `(x2, y2)` is: ```text sqrt((x1 - x2)^2 + (y1 - y2)^2) ``` Example: ```text p = [[0, 11], [-7, 1], [-5, -3]] output = 4.472135955 ``` Constraints: - `2 <= len(p) <= 20000` - Each `p[i]` contains exactly two integers. - `abs(p[i][j]) <= 10^7` - Your answer is accepted if its absolute error is at most `10^-5`. ## 7. Impute Missing Values and Normalize Implement: ```python def solution(dataset: list[list[float]]) -> list[list[float]]: pass ``` You are given a matrix `dataset` of positive floating-point values. Missing values are represented by `0`. Perform the following two steps: 1. For each column, replace every `0` with the mean of the non-zero values originally present in that column. 2. After imputation, normalize each column so that its mean is `0` and its population standard deviation is `1`. For every value `e` in column `c`, transform it to: ```text (e - column_mean) / column_std ``` where `column_mean` and `column_std` are computed after missing values have been imputed. Use population standard deviation: ```text sqrt(sum((value - column_mean)^2 for value in column) / number_of_rows) ``` Example: ```text dataset = [ [1, 2, 0], [0, 1, 1], [5, 6, 5] ] ``` After replacing missing values: ```text [ [1, 2, 3.0], [3.0, 1, 1], [5, 6, 5] ] ``` A valid normalized output is approximately: ```text [ [-1.224744871391589, -0.4629100498862757, 0.0], [0.0, -0.9258200997725514, -1.224744871391589], [1.224744871391589, 1.3887301496588271, 1.224744871391589] ] ``` Constraints: - `2 <= number of rows <= 50` - `1 <= number of columns <= 50` - All rows have the same number of columns. - Each column has at least two distinct non-zero values. - Each output value is accepted if its absolute error is at most `10^-5`.