Pinterest Interview Questions

Background: In Pinterest, handling user-generated content is critical to ensuring smooth performance. When grouping content into arrays based on collective engagement, it is important to optimize resource consumption during this process.
Problem statement: Given an array nums of non-negative integers, partition it into m non-empty contiguous subarrays. The task is to minimize the largest sum among these subarrays. For example, if nums = [7, 2, 5, 10, 8] and m = 2, the partitioning could be [7,2] and [5,10,8], resulting in a largest sum of 18.
Function/class signature:

• def split_array(nums: List[int], m: int) -> int:

Example 1:
Input: nums = [7, 2, 5, 10, 8], m = 2
Output: 18
Explanation: One optimal solution is to split the array into [7,2] and [5,10,8]. The largest sum is 18.Example 2:
Input: nums = [1, 4, 4], m = 3
Output: 4
Explanation: Split into [1], [4], [4], hence the largest sum is 4.Constraints:

• 1 <= nums.length <= 1000


• 0 <= nums[i] <= 10^6


• 1 <= m <= nums.length

Background: In Pinterest, users can save various travel ideas including destinations and routes. Efficiently organizing and reconstructing these routes from a set of unordered flight tickets is crucial for building features like travel boards.
Problem statement: You are given an array of tickets where each ticket is represented as a pair of strings ['Origin', 'Destination']. You need to reconstruct the itinerary in order of visits starting from 'JFK' and visiting each destination exactly once. The answer should be in lexicographically smallest order if there are multiple valid itineraries. Return the reconstructed itinerary as a list of strings.
Function/class signature:

• def find_itinerary(tickets: List[List[str]]) -> List[str]:

Example 1: Input: [['MUC', 'LHR'], ['JFK', 'MUC'], ['SFO', 'SJC'], ['LHR', 'SFO']]
Output: ['JFK', 'MUC', 'LHR', 'SFO', 'SJC']
Explanation: Starting from 'JFK', the only path using all tickets is 'JFK' → 'MUC' → 'LHR' → 'SFO' → 'SJC'.
Example 2: Input: [['JFK', 'SFO'], ['JFK', 'ATL'], ['ATL', 'JFK'], ['SFO', 'ATL']]
Output: ['JFK', 'ATL', 'JFK', 'SFO']
Constraints:

• 1 <= tickets.length <= 1000


• Each ticket is a non-empty pair of strings with length <= 3


• All Origin and Destination strings consist of uppercase English letters only.

Background: Pinterest enables users to share travel inspirations and itineraries through boards. When users share travel tickets, reconstructing the ordered trip route enhances usability and improves user experience.
Problem statement: You are given a list of tickets, where each ticket is a pair of departure and arrival airports represented as strings. The tickets may not be in any specific order. Your task is to reconstruct the itinerary in the order of travel. The itinerary must start from 'JFK'. Return a list of strings representing the route. If no such itinerary exists, return an empty list. Note that there may be multiple valid itineraries, but you should return the one that uses the smallest lexical order.
Function/class signature:

• def findItinerary(tickets: List[List[str]]) -> List[str]:

Example 1:

• Input: [['MUC', 'LHR'], ['JFK', 'MUC'], ['SFO', 'SJC'], ['LHR', 'SFO']]


• Output: ['JFK', 'MUC', 'LHR', 'SFO', 'SJC']


• Explanation: The route starts from JFK, and tickets are used in the order of their lexical order while ensuring all connected travel.

Example 2:

• Input: [['JFK', 'SFO'], ['JFK', 'ATL'], ['ATL', 'JFK'], ['SFO', 'ATL']]


• Output: ['JFK', 'ATL', 'JFK', 'SFO']

Constraints:

• 1 <= len(tickets) <= 1000


• Airports are represented by capital letters and can have up to 10 characters each.

Background: Pinterest connects users through shared interests, and travel ideas often come from various sources. Reconstructing users' travel routes from unordered tickets can help provide enhanced recommendations and visualizations.
Problem statement: You are given a list of unordered travel tickets represented as pairs of departure and arrival airports. Your task is to reconstruct the itinerary based on the tickets and return it in order. You may assume that the provided tickets are such that there is exactly one valid itinerary without cycles. Use depth-first search to find the route. The resulting route must start from JFK.
Function/class signature:

• def reconstruct_itinerary(tickets: List[List[str]]) -> List[str]:

Example 1:

• Input: [['MUC', 'LHR'], ['JFK', 'MUC'], ['SFO', 'SJC'], ['LHR', 'SFO']]


• Output: ['JFK', 'MUC', 'LHR', 'SFO', 'SJC']


• Explanation: The valid order of tickets represents the reconstructed route starting from JFK and ensuring all tickets are used.

Example 2:

• Input: [['JFK', 'SFO'], ['JFK', 'ATL'], ['ATL', 'JFK'], ['SFO', 'ATL']]


• Output: ['JFK', 'ATL', 'JFK', 'SFO']


• Explanation: The route allows to return to JFK from ATL using available tickets.

Constraints:

• 1 <= len(tickets) <= 1000


• Each ticket is represented by a pair of strings: from and to airport codes.


• Each airport code consists of 3 uppercase letters.

Background: Pinterest often encourages travel and exploration of interests through its platform. Efficient route mapping can enhance user experiences related to travel pins and recommendations.
Problem statement: Given a list of unordered travel tickets represented as pairs of strings, where each pair (from, to) indicates a direct ticket from from to to, reconstruct the route in the correct order starting from the initial city. You must return a list of cities in the correct order.Function/class signature:

• def reconstruct_ticket(tickets: List[Tuple[str, str]]) -> List[str]:

Example 1:
Input: tickets = [("MUC", "LHR"), ("JFK", "MUC"), ("SFO", "SJC"), ("LHR", "SFO")]
Output: ['JFK', 'MUC', 'LHR', 'SFO', 'SJC']
Explanation: The correct route starts from JFK and goes through MUC, LHR, SFO, and ends with SJC.Example 2:
Input: tickets = [("JFK", "ATL"), ("ATL", "JFK"), ("JFK", "SFO")]
Output: ['JFK', 'ATL', 'JFK', 'SFO']
Explanation: The route starts at JFK, goes to ATL, returns to JFK, and finally goes to SFO.Constraints:

• 1 ≤ tickets.length ≤ 1000


• The from and to strings are guaranteed to be non-empty and contain only English letters.


• Each ticket appears at most once in the tickets list.

Background: In Pinterest's visual discovery platform, users can curate and search through a vast number of images, each representing various interests. A feature to suggest the most relevant trends or categories could greatly enhance user engagement. Finding the longest increasing subsequence of interests can help in generating recommended content.
Problem statement: Given an array of integers representing user interests, where each integer corresponds to a unique identifier for an interest, your task is to find the length of the longest increasing subsequence of these interests. The interests can be thought of as items in a feed whose engagement counts are being tracked.
Function/class signature:

• def longest_increasing_subsequence(interests: List[int]) -> int:

Example 1:
Input: [10, 5, 20, 30, 15]
Output: 3
Explanation: The longest increasing subsequence is [10, 20, 30].
Example 2:
Input: [3, 10, 2, 1, 20]
Output: 3
Explanation: The longest increasing subsequence is [3, 10, 20].
Constraints:

• 1 <= len(interests) <= 1000


• -10^6 <= interests[i] <= 10^6