question:# Given Problem: You are provided with n x m matrices and you need to perform various transformations on these matrices. Write implementations of the following functions with the given requirements: # Required Function Descriptions: 1. **rotate_clockwise(matrix: List[List[int]]) -> List[List[int]]**: Rotate the given matrix 90 degrees clockwise. 2. **rotate_counterclockwise(matrix: List[List[int]]) -> List[List[int]]**: Rotate the given matrix 90 degrees counterclockwise. 3. **bottom_left_invert(matrix: List[List[int]]) -> List[List[int]]**: Invert the given matrix from bottom-left to top-right. # Inputs: - matrix: List of lists representing the matrix consisting of integers. (1 <= len(matrix) <= 100; 1 <= len(matrix[0]) <= 100) # Outputs: - Each function should return a new matrix that represents the transformed version of the input matrix. # Constraints: - Matrices are rectangular, i.e., non-square. - Matrix values are integers and could be negative. # Definition of the functions: ```python def rotate_clockwise(matrix: List[List[int]]) -> List[List[int]]: pass def rotate_counterclockwise(matrix: List[List[int]]) -> List[List[int]]: pass def bottom_left_invert(matrix: List[List[int]]) -> List[List[int]]: pass ``` # Example: Given the following matrix: ```python matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9], ] ``` - **rotate_clockwise(matrix)** would output: ```python [ [7, 4, 1], [8, 5, 2], [9, 6, 3], ] ``` - **rotate_counterclockwise(matrix)** would output: ```python [ [3, 6, 9], [2, 5, 8], [1, 4, 7], ] ``` - **bottom_left_invert(matrix)** would output: ```python [ [9, 8, 7], [6, 5, 4], [3, 2, 1], ] ``` Ensure your implementations pass these cases and handle all edge cases effectively.

question:**Assessing Anagram Equality of Strings** # Problem Statement: You are given two strings that contain only lowercase alphabetic characters. Write a function to determine if they are anagrams of each other. Strive to implement the solution with optimal performance in mind. # Function Signature: ```python def are_anagrams(s1: str, s2: str) -> bool: ``` # Input: - `s1`: A string of lowercase alphabetic characters (1 ≤ |s1| ≤ 10^5) - `s2`: A string of lowercase alphabetic characters (1 ≤ |s2| ≤ 10^5) # Output: - Return `True` if `s1` and `s2` are anagrams. - Return `False` otherwise. # Constraints: - String lengths are no greater than (10^5). - Only lowercase English alphabet characters are included. # Examples: Example 1: ```python s1 = "listen" s2 = "silent" # Output: True (Both strings contain the same characters with the same frequency) ``` Example 2: ```python s1 = "triangle" s2 = "integral" # Output: True (Both strings contain the same characters with the same frequency) ``` Example 3: ```python s1 = "apple" s2 = "pale" # Output: False (Different frequency of characters) ``` # Performance Requirements: - Ensure the solution operates efficiently within the given constraints.

question:# Question: Reconstruct Queue with Constraints **Scenario**: You are tasked with organizing a queue of people based on their heights and a specific position constraint. Each person is described by a pair of integers ((h, k)), where: - ( h ) is the height of the person. - ( k ) is the number of people in front of this person who have a height greater than or equal to ( h ). Your goal is to reconstruct the queue such that the given constraints are satisfied for each person. **Input**: - A list of pairs of integers. Each pair represents a person in the form ([h, k]). **Output**: - Reconstructed queue as a list of pairs of integers. **Constraints**: 1. The number of people is less than 1,100. 2. Heights and counts are non-negative integers. **Example**: ```python Input: [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]] Output: [[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]] ``` **Explanation**: 1. Person [7,0] has height 7 and no one taller in front. 2. Person [4,4] has height 4 and four taller people in front. 3. Person [7,1] has height 7 and one person taller or same height in front. 4. Person [5,0] has height 5 and no one taller in front. 5. Person [6,1] has height 6 and one person taller or same height in front. 6. Person [5,2] has height 5 and two people taller in front. **Task**: Implement the function `reconstruct_queue(people)` to generate the correct reconstructed queue. ```python def reconstruct_queue(people): :type people: List[List[int]] :rtype: List[List[int]] queue = [] people.sort(key=lambda x: (-x[0], x[1])) for h, k in people: queue.insert(k, [h, k]) return queue ``` **Evaluation Criteria**: - Correct implementation of the sorting and insertion steps. - Handling of edge cases accurately. - Time and space complexity analysis.

question:# Question: You are given two strings `s` and `t`. Write a function `is_anagram(s: str, t: str) -> bool` to determine if `t` is an anagram of `s`. An anagram is defined as a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once. Example 1: ```plaintext Input: s = "anagram", t = "nagaram" Output: True ``` Example 2: ```plaintext Input: s = "rat", t = "car" Output: False ``` # Constraints: * The strings `s` and `t` will only contain lowercase alphabets. * The solution should be optimized for time and space complexity as described in the provided algorithm analysis. # Input Format: Two strings `s` and `t`. # Output Format: A boolean value `True` if `t` is an anagram of `s`, and `False` otherwise. # Requirements: 1. Implement and use hash maps (dictionaries) to count character occurrences. 2. Ensure the comparison of these counts to determine the anagram status. 3. Add edge case checks for empty strings. # Performance: * Time Complexity should be O(n) where n is the length of the given strings. * Space Complexity should remain constant, considering the fixed size of the alphabet. ```python def is_anagram(s: str, t: str) -> bool: # Your code here # Ensure to implement hash map, count comparison, and edge-case handling pass ```