Microsoft Interview Questions

This problem is common in manipulating linked lists, which are used in many Microsoft applications, including data structures in Azure services.
Problem statement: Given the head of a singly linked list, return the head of the list after reversing it. You need to reverse the list in-place, which means you should not use extra space for another list.
Function/class signature:

• def reverse_linked_list(head: Optional[ListNode]) -> Optional[ListNode]:

Example 1:

• Input: head = [1, 2, 3, 4, 5]


• Output: [5, 4, 3, 2, 1]


• Explanation: After reversing, the last element becomes the head.

Example 2:

• Input: head = [1]


• Output: [1]


• Explanation: A single node remains unchanged when reversed.

Constraints:

• The number of nodes in the list is in the range [0, 5000].


• -5000 <= Node.val <= 5000.


• The input list is guaranteed to have at least one node.

Background: Reversing a linked list is a common operation in various data structures and can be essential in memory management of linked data. For Microsoft products that utilize linked lists for managing dynamic data, efficient reversing can significantly improve performance in data traversal tasks.
Problem statement: You are given a singly linked list with the head node head. Your task is to reverse the linked list and return the new head node. Ensure that the function can handle edge cases such as an empty list or a single node list.
Function/class signature:

• def reverse_linked_list(head: Optional[Node]) -> Optional[Node]:

Example 1:
Input: head = 1 -> 2 -> 3 -> None
Output: 3 -> 2 -> 1 -> None
Explanation: The linked list is reversed from 1 -> 2 -> 3 to 3 -> 2 -> 1.
Example 2:
Input: head = None
Output: None
Explanation: The input is an empty list, so the output is also None.
Constraints:

• The number of nodes in the list is in the range [0, 5000].


• The values of the nodes are integers between -1000 and 1000.


• The nodes of the linked list are unique.

Background: Microsoft often works with complex data structures in its software, and understanding linked lists is crucial for optimizing performance in these systems. This exercise simulates data manipulation relevant in environments like Azure or Microsoft 365.
Problem statement: Given a singly linked list, reverse the list and return the new head of the reversed linked list. You need to ensure your solution runs in O(n) time and O(1) space complexity.
Function/class signature:

• def reverse_linked_list(head: Optional[ListNode]) -> Optional[ListNode]:

Example 1:
Input: 1 -> 2 -> 3 -> 4 -> 5 -> None
Output: 5 -> 4 -> 3 -> 2 -> 1 -> None
Explanation: The linked list is reversed from its original order.
Example 2:
Input: 1 -> None
Output: 1 -> None
Constraints:

• The list may be empty (head will be None).


• The number of nodes in the list is within the range [0, 5000].

Background: Reversing a linked list is a common operation used in various algorithms and data processing tasks. Microsoft may require this for its applications dealing with data structures, especially in scenarios involving programming languages like C# where linked lists are prevalent in data representation.
Problem statement: Given a singly linked list, you need to reverse the linked list so that the head points to the last node and each node points to the previous node instead of the next node. The reversal should be done in-place without using extra space for another data structure.
Function/class signature:

• def reverse_linked_list(head: ListNode) -> ListNode:

Example 1:

• Input: head = [1, 2, 3, 4, 5]


• Output: [5, 4, 3, 2, 1]


• Explanation: The linked list gets reversed so 1 becomes 5, 2 becomes 4, and so on.

Example 2:

• Input: head = [1]


• Output: [1]


• Explanation: A single element list remains unchanged.

Constraints:

• The head of the list will have at least one node.


• Node values can be any integer.


• The maximum number of nodes does not exceed 10^4.

Background: Microsoft often handles large volumes of data where quick access to previously used data is critical for performance. An efficient caching mechanism like an LRU (Least Recently Used) Cache is necessary to optimize memory usage and speed up data retrieval in applications such as Azure services.
Problem statement: Design and implement an LRU Cache that supports the following operations: get(key) and put(key, value). The get method retrieves the value of the key if it exists in the cache. Otherwise, it returns -1. The put method will insert or update the value for a key. If the cache exceeds its capacity, it should invalidate the least recently used item before inserting a new item into the cache.

• Function/class signature:

- def __init__(self, capacity: int): # Initializes the LRU cache with positive size capacity.
- def get(self, key: int) -> int: # Returns the value of the key if it exists in the cache, otherwise returns -1.
- def put(self, key: int, value: int) -> None: # Updates or inserts the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item.
Example 1:

• Input: cache = LRUCache(2); cache.put(1, 1); cache.put(2, 2); cache.get(1)


• Output: 1


• Explanation: 1 was accessed and is now the most recently used.

Example 2:

• Input: cache.put(3, 3)


• Output: -1


• Explanation: cache exceeds capacity. 2 is evicted.

Constraints:

• The cache will have a capacity of at least 1 and at most 3000.


• The keys and values will be integers ranging from 0 to 10^4.

Background: Microsoft products often require efficient data retrieval and caching systems, particularly for performance optimization in applications like Azure and Windows services. Implementing an LRU cache allows for fast access to frequently used data while managing memory efficiently.
Problem statement: Design and implement a data structure that supports the following operations: get(key) and put(key, value). The get method retrieves the value of the key if it exists in the cache, otherwise returns -1. The put method updates or adds the value of the key in the cache. When the cache reaches its capacity, it should invalidate the least recently used entry before inserting a new item.
Function/class signature:

• def __init__(self, capacity: int): # initialize LRUCache with positive size capacity


• def get(self, key: int) -> int: # return the value of the key, or -1 if the key does not exist


• def put(self, key: int, value: int) -> None: # update the value of the key or insert the key if it is not already present

Example 1:
Input: lru_cache = LRUCache(2)lru_cache.put(1, 1)lru_cache.put(2, 2)print(lru_cache.get(1))
Output: 1
Explanation: Key 1 was found, returned 1.
Example 2:
Input: lru_cache.put(3, 3)
Output: None (cache evicts key 2)
Constraints:

• 1 <= capacity <= 3000


• 0 <= key <= 10^4


• 0 <= value <= 10^8

Background: In applications like Microsoft Word or Microsoft Teams, analyzing text for formatting or categorizing can often benefit from identifying palindromic substrings to enhance features like spell-checkers or text analyzers.
Problem statement: Given a string s, you need to return the number of palindromic substrings in s. A palindrome is a string that reads the same backward as forward.
Function/class signature:

• def count_palindromic_substrings(s: str) -> int:



Example 1: Input: "aaa", Output: 6, Explanation: Substrings are "a", "a", "a", "aa", "aa", "aaa".
Example 2: Input: "abc", Output: 3, Explanation: Substrings are "a", "b", "c".
Constraints:

• 1 <= len(s) <= 1000


• s consists of lowercase English letters.

In services like Azure Data Lake, it is important to find the maximum throughput of data streams over given segments. This requires identifying the largest sum of neighboring data packets for optimization.
Problem statement: Given an integer array nums, implement a function maxSubArray(nums: List[int]) -> int that returns the largest sum of contiguous elements in the array.

• Method Signature: def maxSubArray(nums: List[int]) -> int: Returns the maximum sum of a contiguous subarray.

Example 1:
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The contiguous subarray [4,-1,2,1] has the largest sum 6.Example 2:
Input: nums = [1]
Output: 1Constraints:

• 1 <= nums.length <= 10^5


• -10^4 <= nums[i] <= 10^4

Microsoft Azure needs to optimize routing between data centers. The goal is to find the shortest path between nodes in the network to enhance performance and reduce latency.
Problem statement: Given a directed graph represented as an adjacency list, implement a function dijkstra(graph: Dict[int, List[Tuple[int, int]]], start: int) -> Dict[int, int] that calculates the shortest path from a starting node to all other nodes.

• Method Signature: def dijkstra(graph: Dict[int, List[Tuple[int, int]]], start: int) -> Dict[int, int]: Returns a dictionary where keys are node indices and values are the shortest distances from the start.

Example 1:
Input: graph = {0: [(1, 4), (2, 1)], 1: [(3, 1)], 2: [(1, 2), (3, 5)], 3: []}, start = 0
Output: {0: 0, 1: 3, 2: 1, 3: 4}
Explanation: The shortest path from node 0 to node 3 is through 2 and then to 1.Example 2:
Input: graph = {0: [(1, 2)], 1: [(2, 3)], 2: [(3, 1)], 3: []}, start = 0
Output: {0: 0, 1: 2, 2: 5, 3: 6}Constraints:

• 1 <= len(graph) <= 10^4


• 0 <= graph[i][j][0] < len(graph)


• 0 < graph[i][j][1] <= 10^3

Considering the real-time capabilities of Azure, create a basic Twitter API that can fetch user feeds. This design must include necessary features for users to follow others and retrieve their latest tweets in real-time.
Problem statement: Design a Twitter class that supports the following methods:

• postTweet(userId: int, tweetId: int) -> None: Record a new tweet.


• getNewsFeed(userId: int) -> List[int]: Retrieve the 10 most recent tweet IDs in the user's news feed.


• follow(followerId: int, followeeId: int) -> None: Allow a follower to follow a followee.


• unfollow(followerId: int, followeeId: int) -> None: Allow a follower to unfollow a followee.

Method Signatures:
- def postTweet(self, userId: int, tweetId: int) -> None
- def getNewsFeed(self, userId: int) -> List[int]
- def follow(self, followerId: int, followeeId: int) -> None
- def unfollow(self, followerId: int, followeeId: int) -> NoneExample 1:
Input: twitter = Twitter()
twitter.postTweet(1, 5)
twitter.getNewsFeed(1)
Output: [5]Example 2:
Input: twitter.follow(1, 2)
twitter.postTweet(2, 6)
twitter.getNewsFeed(1)
Output: [6, 5]Constraints:

• 0 <= userId, followerId, followeeId, tweetId <= 10^4


• The number of tweets will not exceed 10^4. At most 3 * 10^4 follow operations will occur.

Microsoft Azure commonly uses caching to speed up responses to repeated API requests. Implement an LRU (Least Recently Used) Cache to maintain efficient access and updates.
Problem statement: Design and implement an LRUCache class that supports get(key: int) -> int and put(key: int, value: int) -> None methods. The cache will have a limited capacity.

• Method Signatures:

- def get(self, key: int) -> int: Returns the value of the key if present, otherwise -1.
- def put(self, key: int, value: int) -> None: Updates the value of the key or adds it if it's not already present. When the cache reaches its capacity, it invalidates the least recently used item before inserting a new item.Example 1:
Input: cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
cache.get(1)
Output: 1Example 2:
Input: cache.put(2, 1)
cache.put(2, 2)
cache.get(2)
Output: 2Constraints:

• capacity will be between 1 and 3000.


• key and value are integers within the range of a 32-bit signed integer.