Vercel Interview Questions (9+ Questions)

Restore accidentally deleted branches by leveraging Git's reflog history to find lost commits. Identify the branch's last commit hash, recreate the branch at that point, and verify all work is restored. Essential for preventing permanent data loss, recovering from mistakes, maintaining team productivity, and understanding Git's safety mechanisms for protecting committed work.

Read a mixed-format text file where each row has a different delimiter based on its type indicator, parse and separate the data into multiple CSV files using Python.

Optimized Solution for Interview Question: Counting Tag Occurrences from product_tags Table

Objective

To solve the problem of counting occurrences of each tag across all products within the product_tags table, follow these SQL query guidelines. The table product_tags consists of two columns: id (a unique identifier for each product) and tags (a string containing comma-separated tags associated with the product). The goal is to list each distinct tag along with its count, sorted by the count in descending order and then alphabetically by the tag.

SQL Query to Achieve the Objective:

1. Split the Tags: First, we need to split the comma-separated tags column into individual tag entries. This requires using a string splitting function that varies depending on the SQL database being used (e.g., STRING_SPLIT in SQL Server, regexp_split_to_table in PostgreSQL).
2. Count the Tags: Once individual tags are extracted, the next step is to group these tags and count their occurrences.
3. Sort the Results: Finally, the results should be sorted based on the count in descending order and then alphabetically by the tag.

Here’s a concise and efficient SQL query example that achieves these steps (example uses PostgreSQL syntax):

WITH SplitTags AS (
    SELECT
        id,
        UNNEST(string_to_array(tags, ',')) AS tag
    FROM
        product_tags
)
SELECT
    tag,
    COUNT(*) AS tag_count
FROM
    SplitTags
GROUP BY
    tag
ORDER BY
    tag_count DESC,
    tag ASC;

Additional Considerations:

• Handling Case Sensitivity: Ensure to maintain the case sensitivity to differentiate between tags like 'Tag' and 'tag'.
• Database Compatibility: Adapt the string splitting function according to the SQL database being used.
• Performance Optimization: If handling a large dataset, consider indexing on the tags field or using more advanced processing techniques like parallel processing or temporary tables.

This query efficiently counts and displays the tag occurrences as required, ensuring a comprehensive, optimized solution for the interview scenario.

Fetch data from a REST API, read from a CSV file, query from a SQLite database, merge all three sources using pandas, and generate a unified CSV report with calculated fields.

WITH deduped_activities AS (
SELECT
user_id,
activity_date,
activity_type
FROM {{ ref("activities") }}
QUALIFY ROW_NUMBER() OVER (
PARTITION BY user_id, activity_date, activity_type
ORDER BY activity_date
) = 1
),
combined AS (
SELECT
a.user_id,
a.account_created_date,
a.location,
act.activity_date,
act.activity_type,
e.exit_date,
e.exit_reason
FROM {{ ref("accounts") }} a
LEFT JOIN deduped_activities act
ON a.user_id = act.user_id
LEFT JOIN {{ ref("exit_surveys") }} e
ON a.user_id = e.user_id
)
SELECT *
FROM combined
ORDER BY user_id ASC, activity_date DESC

WITH clean_clients AS (
SELECT client_id, client_name, industry
FROM {{ ref("clients") }}
WHERE client_id > 0
QUALIFY ROW_NUMBER() OVER (PARTITION BY client_id ORDER BY client_id) = 1
),
clean_transactions AS (
SELECT transaction_id, client_id, date, amount
FROM {{ ref("transactions") }}
WHERE transaction_id > 0
QUALIFY COUNT(*) OVER (PARTITION BY transaction_id) = 1
),
joined AS (
SELECT
t.transaction_id,
t.client_id,
t.date,
CAST(t.amount AS INTEGER) AS amount,
c.client_name,
c.industry
FROM clean_transactions t
INNER JOIN clean_clients c
ON t.client_id = c.client_id
)
SELECT * FROM joined

Determining the Completion Percentage of Required Training Courses for Employees

Creating an SQL query to determine the completion percentage of required training courses for employees is a common interview question that tests your ability to handle aggregate functions and conditional logic in ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

def largest_rectangle_area(heights: list[int]) -> int:
max_area = 0
stack = []

for i, h in enumerate(heights):
    start = i
    while stack and stack[-1][1] > h:
        index, height = stack.pop()
        max_area = max(max_area, height * (i - index))
        start = index
    stack.append((start, h))
    
for i, h in stack:
    max_area = max(max_area, h * (len(heights) - i))
    
return max_area

def numIslands(grid: list[list[str]]) -> int:
if not grid:
return 0

ROWS, COLS = len(grid), len(grid[0])
islands = 0

def bfs(r, c):
    q = deque()
    q.append((r, c))
    grid[r][c] = "0"
    
    while q:
        row, col = q.popleft()
        directions = [[1, 0], [-1, 0], [0, 1], [0, -1]]
        
        for dr, dc in directions:
            nr, nc = row + dr, col + dc
            if (0 <= nr < ROWS and 0 <= nc < COLS and grid[nr][nc] == "1"):
                q.append((nr, nc))
                grid[nr][nc] = "0"
                
for r in range(ROWS):
    for c in range(COLS):
        if grid[r][c] == "1":
            islands += 1
            bfs(r, c)
            
return islands