CodeSignal OAs Medium Interview Questions

Background: CodeSignal OAs is focused on optimizing coding challenges. Understanding how to maximize subarray sums is crucial for building efficient algorithms that assess code performance and data handling in real-time.
Problem statement: You are given an array of integers nums. Find the contiguous subarray (contiguous elements of the array) with the largest sum and return its sum.
Function/class signature:

• def max_subarray_sum(nums: List[int]) -> int:

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: 1


• Explanation: The largest subarray is [1].

Constraints:

• The input array has at least 1 element.


• Each element in the array is an integer within the range [-10^4, 10^4].

Background: CodeSignal OAs often deals with algorithm-intensive problems for candidates assessing their programming skills. One common problem type relates to identifying patterns in data sequences, particularly in arrays and lists.
Problem statement: Given an array of integers nums, find the length of the longest strictly increasing subsequence. A subsequence is defined as a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
Function/class signature:

• def lengthOfLIS(nums: List[int]) -> int:

Example 1:

• Input: nums = [10, 9, 2, 5, 3, 7, 101, 18]


• Output: 4


• Explanation: The longest increasing subsequence is [2, 3, 7, 101], which has length 4.

Example 2:

• Input: nums = [0, 1, 0, 3, 2, 3]


• Output: 4


• Explanation: The longest increasing subsequence is [0, 1, 2, 3], which also has length 4.

Constraints:

• 1 <= nums.length <= 2500


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

Background: CodeSignal OAs requires efficient algorithms to handle a variety of competitive programming challenges and assessments that involve sequences. The longest increasing subsequence problem is a classic algorithmic challenge that can arise in numerous coding tests.
Problem statement: Given an array of integers nums, you need to return the length of the longest increasing subsequence. An increasing subsequence is a subset of numbers such that all elements are in increasing order. Your solution should be efficient enough to handle large input sizes.
Function/class signature:

• def lengthOfLIS(nums: List[int]) -> int:

Example 1:

• Input: nums = [10, 9, 2, 5, 3, 7, 101, 18]


• Output: 4


• Explanation: The longest increasing subsequence is [2, 3, 7, 101], thus the length is 4.

Example 2:

• Input: nums = [0, 1, 0, 3, 2, 3]


• Output: 4


• Explanation: The longest increasing subsequence is [0, 1, 2, 3], thus the length is 4.

Constraints:

• 1 <= nums.length <= 2500


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

Background: In text processing and analytics, accurate counting of word occurrences is critical for generating insights. CodeSignal needs a reliable function to count the frequency of words in a given text, which can help in developing features related to data analysis on their platform.
Problem statement: Write a function that takes a string text and returns a dictionary where each key is a word from text and the value is the number of times that word appears. The words are case-insensitive and should be stripped of punctuation.
Function/class signature:

• def word_frequency(text: str) -> Dict[str, int]:

Example 1:

• Input: "Hello world! Hello everyone."


• Output: {'hello': 2, 'world': 1, 'everyone': 1}


• Explanation: The word hello appears twice (case-insensitive) while world and everyone appear once each.

Example 2:

• Input: "CodeSignal is amazing! CodeSignal is the future..."


• Output: {'codesignal': 2, 'is': 2, 'amazing': 1, 'the': 1, 'future': 1}

Constraints:

• Length of text (1 ≤ len(text) ≤ 10^4)


• The text contains alphanumeric characters and typical punctuation marks.


• Return the frequency of each unique word in a case-insensitive manner.

Background: CodeSignal OAs provides a platform for connecting educators and learners, making social interaction essential in its design. Efficient networking algorithms are crucial for ensuring smooth connectivity between users.
Problem statement: Given a graph representing a social network where each node is a user and edges represent relationships, implement a function that finds the shortest path between two users. The graph can be traversed in both directions. Use the user_id as the node identifier.
Function/class signature:

• def shortest_path(graph: Dict[int, List[int]], start_id: int, end_id: int) -> List[int]:

Example 1:
Input: graph = {1: [2, 3], 2: [1, 4], 3: [1, 4], 4: [2, 3]}, start_id = 1, end_id = 4
Output: [1, 2, 4]
Explanation: The shortest path from user 1 to user 4 is through user 2.Example 2:
Input: graph = {1: [2, 3, 5], 2: [1], 3: [1, 4], 4: [3], 5: [1, 6], 6: [5]}, start_id = 3, end_id = 6
Output: []
Explanation: There is no path from user 3 to user 6.Constraints:

• Number of nodes in the graph: 1 <= |V| <= 10^5


• Number of edges in the graph: 0 <= |E| <= 10^5


• user_id is a positive integer up to 10^6.

Background: CodeSignal's platform includes various challenges that require understanding of graph structures and algorithms. Efficient pathfinding is crucial for problem-solving scenarios in coding assessments.
Problem statement: Given a directed graph represented as an adjacency list, your task is to write a function that finds the shortest path from a source node to a target node. The graph can have multiple nodes and edges, and you need to return the path as a list of nodes from source to target. If no path exists, return an empty list. Use BFS for traversal as it is optimal for unweighted graphs.
Function/class signature:

• def shortest_path(graph: Dict[int, List[int]], source: int, target: int) -> List[int]:

Example 1:
Input: graph = {0: [1, 2], 1: [2], 2: [0, 3], 3: []}, source = 0, target = 3
Output: [0, 2, 3]
Explanation: The shortest path from node 0 to node 3 is achieved through node 2.
Example 2:
Input: graph = {0: [1], 1: [2], 2: [3], 3: []}, source = 0, target = 4
Output: []
Explanation: There is no path from node 0 to node 4.
Constraints:

• The graph will contain unique nodes indexed from 0 to n-1


• The number of nodes, n, will be at most 1000


• The number of edges, m, can be up to 5000


• Nodes will be represented as integers.