Appearance
question:def knight_moves(position: str) -> int: Returns the number of valid moves a knight can make from the given position on an 8x8 chessboard. Position is given in standard chess notation (e.g., 'd4'). >>> knight_moves('d4') 8 >>> knight_moves('e5') 8 >>> knight_moves('a1') 2 >>> knight_moves('h8') 2 >>> knight_moves('a4') 4 >>> knight_moves('h4') 4 >>> knight_moves('d1') 4 >>> knight_moves('d8') 4 >>> knight_moves('b1') 3 >>> knight_moves('g8') 3 >>> knight_moves('a2') 3 >>> knight_moves('h7') 3
answer:def knight_moves(position): Returns the number of valid moves a knight can make from the given position on an 8x8 chessboard. Position is given in standard chess notation (e.g., 'd4'). # Convert the position to board indices column, row = position[0], int(position[1]) col_idx = ord(column) - ord('a') # Convert 'a' to 0, 'b' to 1, ..., 'h' to 7 row_idx = row - 1 # Convert '1' to 0, '2' to 1, ..., '8' to 7 # Define all possible moves a knight can make possible_moves = [ (2, 1), (2, -1), (-2, 1), (-2, -1), (1, 2), (1, -2), (-1, 2), (-1, -2) ] valid_moves = 0 # Check each possible move to see if it's valid for move in possible_moves: new_col = col_idx + move[0] new_row = row_idx + move[1] if 0 <= new_col < 8 and 0 <= new_row < 8: valid_moves += 1 return valid_moves
question:from typing import List def findClosestElements(arr: List[int], k: int, x: int) -> List[int]: Given a sorted array of integers arr and an integer k, find the k closest elements to a given value x. Parameters: arr (List[int]): A sorted array of integers. k (int): The number of closest integers to return. x (int): The target integer to find the closest values to. Returns: List[int]: A list of k closest integers to x, sorted in ascending order. Examples: >>> findClosestElements([1, 2, 3, 4, 5], 4, 3) [1, 2, 3, 4] >>> findClosestElements([1, 2, 3, 4, 5], 4, -1) [1, 2, 3, 4]
answer:def findClosestElements(arr, k, x): Given a sorted array of integers arr and an integer k, find the k closest elements to a given value x. Parameters: arr (List[int]): A sorted array of integers. k (int): The number of closest integers to return. x (int): The target integer to find the closest values to. Returns: List[int]: A list of k closest integers to x, sorted in ascending order. left, right = 0, len(arr) - k while left < right: mid = (left + right) // 2 if x - arr[mid] > arr[mid + k] - x: left = mid + 1 else: right = mid return arr[left:left + k]
question:def has_path(test_cases): In a grid-based game, you are given a 2D grid with N rows and M columns. Each cell in the grid either contains an obstacle marked by '#', or is empty marked by '.'. You need to determine if there is a path from the top-left corner (0,0) to the bottom-right corner (N-1,M-1), such that you can only move right or down. For each test case, print "YES" if there exists a path from (0,0) to (N-1,M-1), otherwise print "NO". Args: test_cases (List[Tuple[int, int, List[str]]]): List of tuples where each tuple contains the number of rows, number of columns, and the grid itself. Returns: List[str]: List containing "YES" or "NO" for each test case. >>> test_cases = [ ... (3, 3, ['..#', '.#.', '...']), ... (3, 3, ['..#', '.', '...']) ... ] >>> has_path(test_cases) ['YES', 'NO']
answer:def is_path_exists(grid, n, m): Returns 'YES' if there is a path from (0, 0) to (n-1, m-1) through the grid, only moving right or down. Returns 'NO' otherwise. if grid[0][0] == '#' or grid[n-1][m-1] == '#': return "NO" visited = [[False for _ in range(m)] for _ in range(n)] def dfs(x, y): if x == n-1 and y == m-1: return True if x < 0 or x >= n or y < 0 or y >= m or grid[x][y] == '#' or visited[x][y]: return False visited[x][y] = True # Move right if dfs(x, y + 1): return True # Move down if dfs(x + 1, y): return True return False return "YES" if dfs(0, 0) else "NO" def has_path(test_cases): results = [] for n, m, grid in test_cases: results.append(is_path_exists(grid, n, m)) return results
question:def LongestSubstring(s: str) -> int: Returns the length of the longest substring without repeating characters. >>> LongestSubstring("abcabcbb") 3 >>> LongestSubstring("bbbbb") 1 >>> LongestSubstring("pwwkew") 3
answer:def LongestSubstring(s): Returns the length of the longest substring without repeating characters. :param s: str :return: int char_index_map = {} longest = 0 start = 0 for end in range(len(s)): if s[end] in char_index_map: start = max(start, char_index_map[s[end]] + 1) char_index_map[s[end]] = end longest = max(longest, end - start + 1) return longest