Software Engineer

An array of linked lists can be used to implement a hashmap.
To transform the key into an index, we look to a hashing function. We can use a hashing function to convert the key into an integer within the bounds of our hash map array's index range. In an ideal situation, that would allow us to reduce the size of the hash map array to the maximum number of entries. 
For the get() method , we just hash() our key, access the corresponding bucket in our hashmap array (data), and navigate through the linked list (if necessary) and return the correct value, or -1 if the key is not found.
For the put() method, we should first remove() any earlier instance of that key to avoid chaining multiple versions of a key definition in our linked list. Then we simply form a new node at the head of the proper hash map bucket, pushing any others back.
The remove() method will be similar to the get() method, except that we need to find and stitch together the nodes on either side of the node that matches the key, removing it from the linked list entirely.

A lookup table can be used to map the digit with its corresponding Roman numeral. Next, traverse the lookup table in descending order of the keys and keep inserting the appropriate numeral as many times till the target number is greater than the corresponding key. Keep reducing the target number by the same amount.

The idea behind the approach would be that If the rectangles do not overlap, then rectangle 1 must either be higher, lower, to the left, or to the right of rectangle 2.
Consider a 1D overlap : 
[(x1,y1)(x2,y1)] and [(x3,y2),(x4,y2)]
For an overlap to occur necessary condition is: x1 < x3 < x2 && x3 < x2 < x4 
Now, for a 2D case we use 1D conditions for both X and Y axes
Case-1: Rec2 intersects with Rec1 on top right corner
Case-2: Rec2 intersects with Rec1 on top left corner.
Case-3: Rec2 intersects with Rec1 on bottom left corner
Case-4: Rec2 intersects with Rec1 on bottom right corner
bool case1 = (x1 < x4 && x3 < x2 && y1 < y4 && y3 < y2); //top right intersection
bool case2 = (x3 < x2 && x1 < x4 && y1 < y4 && y3 < y2); //top left intersection
bool case3 = (x3 < x2 && x1 < x4 && y3 < y2 && y4 < y1); //bottom left intersection
bool case4 = (x1 < x4 && x3 < x2 && y3 < y2 && y4 < y1); //bottom right intersection

The naive approach is to find all substrings in O(n2) and checking it with the substrings of the remaining string in O(n). The time complexity of this solution would be O(N^3). 
The solution can be optimized to O(N^2) using the concept of dynamic programming. 
The idea is to look for every same character and save its index. Check whether difference between index is less than longest repeating and non-overlapping substring size.
Here, dp[i][j] stores length of the matching and non-overlapping substrings ending with i'th and j'th characters.
If the characters at (i-1)th and (j-1)th position matches dp[i-1][j-1] is less than the length of the considered substring (j-1) then maximum value of dp[i][j] and the maximum index i till this point is updated. The length of the longest repeating and non-overlapping substring can be found by the maximum value of dp[i][j] and the substring itself can be found using the length and the ending index which is the finishing index of the suffix.

Recursive Relation :
LCSRe(i, j) stores length of the matching and non-overlapping substrings ending with i'th and j'th characters.
If str[i-1] == str[j-1] && (j-i) > LCSRe(i-1, j-1)
LCSRe(i, j) = LCSRe(i-1, j-1) + 1, 
Else
LCSRe(i, j) = 0
Where i varies from 1 to n and j varies from i+1 to n

A rate limiter is a tool that monitors the number of requests per a window time a service agrees to allow. If the request count exceeds the number agreed by the service owner and the user (in a decided window time), the rate limiter blocks all the excess calls(say by throwing exceptions). Rate limiters can be implemented using different designs :
Fixed window counters
Sliding window counters 
Sliding window logs

Tip 1: Firstly, remember that the system design round is extremely open-ended and there’s no such thing as a standard answer. Even for the same question, you’ll have a totally different discussion with different interviewers.
Tip 2:Before you jump into the solution always clarify all the assumptions you’re making at the beginning of the interview. Ask questions to identify the scope of the system. This will clear the initial doubt, and you will get to know what are the specific detail interviewer wants to consider in this service.
Tip 3 : Design your structure and functions according to the requirements and try to convey your thoughts properly to the interviewer so that you do not mess up while implementing the idea .