Meta Interview Questions (25+ Questions)

Learn how to create symbolic links to centralize file references across application directories using Linux Bash commands. This guide covers linking configuration files, verifying symlink resolution, and enabling transparent access to centralized resources, essential for configuration management, reducing duplication, and maintaining consistency in multi-service deployments.

We have a scenario where we need to forward everything from the port 8080 to Port 8081. We have an app that runs under Port 8080, and we cannot change anything in the app configuration, and without doing that, we have to redirect traffic from one port to another. This is not IP route because ips are on the L three level where ports does not exist yet. For that, we'll need to use nat tables. Make sure we have application running under port 8080. Check this with SS TLNP, or we can use LSOF hyphen I. To add entries into nat, we'll use IP tables. First, we'll use pre routing, and the protocol will be the TCP destination. Port is 8081, and it's going to be redirected to the Port 8080. Pre routing will be for external traffic coming via our network interface and output will be the traffic that we invoke internally. We can run pseudo IP table safe command. Our configuration changes will persist after the reboot of the system.

Accelerate container startup from 30+ seconds to under 3 seconds by identifying and fixing initialization bottlenecks. Diagnose DNS resolution timeouts, /dev/random entropy blocking, missing device access, and network connection hangs using docker logs and docker exec. Optimize Dockerfile initialization, replace blocking operations with non-blocking alternatives, and verify exit times with the time command. Essential for fast deployments, improved user experience, CI/CD pipeline efficiency, and production reliability.

def solve(board: list[list[str]]) -> list[list[str]]:
if not board or not board[0]:
return board

rows, cols = len(board), len(board[0])

def dfs(r, c):
    if r < 0 or c < 0 or r >= rows or c >= cols or board[r][c] != "O":
        return
        
    board[r][c] = "T"
    
    dfs(r + 1, c)
    dfs(r - 1, c)
    dfs(r, c + 1)
    dfs(r, c - 1)
    
for r in range(rows):
    dfs(r, 0)
    dfs(r, cols - 1)
    
for c in range(cols):
    dfs(0, c)
    dfs(rows - 1, c)
    
for r in range(rows):
    for c in range(cols):
        if board[r][c] == "O":
            board[r][c] = "X"
        elif board[r][c] == "T":
            board[r][c] = "O"
            
return board

Parse application access logs to calculate the error rate and determine whether the service stayed within its defined SLO error budget.

How to Create a Terraform Configuration for Filtering a Developer List on Team Collaboration Projects

When managing a team collaboration platform, it's essential to assign developers to projects efficiently. One common scenario involves generating a filtered list of developers based on certain ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

We have only one table that is called Employees and three columns that indicate employee ID, the name of that employee, and supervisor ID. One employee can be a supervisor for his or her colleagues. Our job is simply to find employees whose supervisor does not exist in the table. Employees with a null value in supervisor ID column are excluded. The final list should be sorted out in ascending order by employee ID. In order to reference the same table twice, we give it two different names, or aliases. e1 will represent each employee, and e2 will search for supervisor. We will use left join, which will keep all rows from the left table, regardless of whether a match was found in the right table or not. Using ON condition, we simply ask the query to take the supervisor ID from e1 table and look for it in employee ID column of e2 table. The first statement is employee ID from e2 table is null, which will simply catch all employees whose supervisor was not found in the table after the left join. We also check if supervisor ID is not a null value.

We'll need to aggregate SQL query results and export them to Excel using Pandas. Pandas is a library that was specifically designed for data analysis and manipulation. We are given one SQLite database that is called Orders. It contains two tables, the first one with customers' information and second one with all the transactions. SQLite is a lightweight database that stores everything in a single file. Our job here is to join both of the given tables, then calculate the total order value per customer, and save the results to an Excel file. We import two libraries, SQLite 3 and Pandas. Then we open the database using the connect function. We are more interested in inner join because it returns only the rows where there is a match in both tables. Then we execute what we have written above using the read_sql_query function and load the results directly into a Pandas data frame. We use group by so that all rows belonging to the same customer are put together. Finally, we save the resulting data frame to Excel file.

PII stands for Personally Identifiable Information, data like emails and phone numbers that can identify a real person. We are given only one file that is called users.csv, and this data frame contains three columns: email, phone number of the user, along with referenced_by ID. We are required to do two things. First, we extract the domain from the email address, which means that we keep everything after the @ symbol. Then we need to hide the first digits of the phone number, and only the last four should be visible. Regex stands for regular expression. It is a pattern that is used to search, extract, or replace specific text inside of a string. Regexp_extract is a Spark function that takes a specific part of a string using a regex pattern. We will use the regexp_replace function that simply replaces part of the string. WithColumn will take the results and create a new column.

SELECT
user_id,
page_id,
visit_time AS interaction_time,
'visit' AS interaction_type
FROM {{ ref("page_visits") }}

UNION ALL

SELECT
user_id,
page_id,
like_time AS interaction_time,
'like' AS interaction_type
FROM {{ ref("page_likes") }}

UNION ALL

SELECT
user_id,
page_id,
comment_time AS interaction_time,
'comment' AS interaction_type
FROM {{ ref("page_comments") }}

SELECT
p.page_id
FROM
pages p
LEFT JOIN page_likes pl ON p.page_id = pl.page_id
WHERE
pl.page_id IS NULL
ORDER BY
p.page_id ASC;

SELECT
user_id,
MAX(post_date::DATE) - MIN(post_date::DATE) AS days_between
FROM
posts
WHERE
EXTRACT(
YEAR
FROM
post_date
) = 2021
GROUP BY
user_id
HAVING
COUNT(post_id) >= 2
ORDER BY
user_id;

SELECT
e.employee_id,
e.employee_name
FROM
employees e
JOIN employees m ON e.manager_id = m.employee_id
WHERE
e.salary > m.salary
ORDER BY
e.employee_id ASC;

SELECT
app_id,
ROUND(
100.0 * SUM(
CASE
WHEN event_type = 'click' THEN 1
ELSE 0
END
) / SUM(
CASE
WHEN event_type = 'impression' THEN 1
ELSE 0
END
),
2
) AS ctr
FROM
events
WHERE
EXTRACT(
YEAR
FROM
event_date
) = 2022
GROUP BY
app_id
ORDER BY
app_id ASC;

SELECT
drug_name,
SUM(total_sales - cogs) AS total_profit
FROM
pharmacy_sales
GROUP BY
drug_name
ORDER BY
total_profit DESC
LIMIT
3;

SELECT
post_bucket,
COUNT(user_id) AS users_num
FROM
(
SELECT
user_id,
COUNT(post_id) AS post_bucket
FROM
user_posts
WHERE
EXTRACT(
YEAR
FROM
post_date
) = 2024
GROUP BY
user_id
) AS user_post_counts
GROUP BY
post_bucket
ORDER BY
post_bucket ASC;

SELECT
manufacturer,
CONCAT(
'$',
ROUND(SUM(total_sales) / 1000000),
' million'
) AS sale
FROM
pharmacy_sales
GROUP BY
manufacturer
ORDER BY
SUM(total_sales) DESC,
manufacturer ASC;

SELECT
age_bucket,
ROUND(
100.0 * SUM(
CASE
WHEN activity_type = 'send' THEN time_spent
ELSE 0
END
) / SUM(time_spent),
2
) AS send_perc,
ROUND(
100.0 * SUM(
CASE
WHEN activity_type = 'open' THEN time_spent
ELSE 0
END
) / SUM(time_spent),
2
) AS open_perc
FROM
activities a
INNER JOIN age_breakdown ab ON a.user_id = ab.user_id
GROUP BY
age_bucket
ORDER BY
age_bucket;

WITH
jan_users AS (
SELECT DISTINCT
user_id
FROM
user_actions
WHERE
EXTRACT(
MONTH
FROM
event_date
) = 1
AND EXTRACT(
YEAR
FROM
event_date
) = 2026
),
feb_users AS (
SELECT DISTINCT
user_id
FROM
user_actions
WHERE
EXTRACT(
MONTH
FROM
event_date
) = 2
AND EXTRACT(
YEAR
FROM
event_date
) = 2026
)
SELECT
2 AS MONTH,
COUNT(*) AS monthly_active_users
FROM
feb_users f
JOIN jan_users j ON f.user_id = j.user_id;

SELECT
COALESCE(a.user_id, p.user_id) AS user_id,
CASE
WHEN p.user_id IS NULL THEN 'CHURN'
WHEN a.status IS NULL THEN 'NEW'
WHEN a.status = 'CHURN' THEN 'RESURRECT'
ELSE 'EXISTING'
END AS new_status
FROM
advertiser a
FULL OUTER JOIN daily_pay p ON a.user_id = p.user_id
ORDER BY
user_id;

def longest_consecutive(nums: list[int]) -> int:
num_set = set(nums)
longest = 0

for n in num_set:
    # Only check for the start of a sequence
    if (n - 1) not in num_set:
        length = 1
        
        while (n + length) in num_set:
            length += 1
            
        longest = max(length, longest)
        
return longest

def min_eating_speed(piles: list[int], h: int) -> int:
l, r = 1, max(piles)
res = r

while l <= r:
    k = (l + r) // 2
    hours = 0
    for p in piles:
        hours += (p + k - 1) // k
        
    if hours <= h:
        res = k
        r = k - 1
    else:
        l = k + 1
        
return res

How to Retrieve Customers with At Least 3 Orders and Minimum Spending of 1000 Using SQL

When preparing for SQL or database-related interviews, you might encounter a question that asks you to retrieve the names of customers who have placed at least 3 orders and spent at least 1000 units in ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Netflix processes billions of streaming requests daily serving content to millions of users worldwide. QA testing of streaming platform APIs requires comprehensive validation of content upload, recommendation algorithms, user preference management, and analytics to ensure optimal viewing experiences...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Master checkbox state management testing with Selenium. Learn state verification, dynamic selection, and comprehensive interaction validation....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →