Our server has multiple network interfaces and traffic. The 10.1.0.0/16 subnet is being routed incorrectly. That means packets might be living through the wrong interface, which can break connectivity or slow down communication. Our goal is to verify current routing table and make sure that subnet is using correct gateway and correct network interface. Start with running route -n to display the route table. This lets us see which interfaces different networks are using and we can search through this table by typing the destination IP address by using grep command. The subnet is using wrong network interface and it's using incorrect gateway. First, we'll need to delete this route table entry, and then we'll have to recreate a correct one. We'll use route delete command, and add netmask. Recreate route with a proper gateway and proper network interface.

Usage on slash bar partition is 92% and increasing rapidly. We need to identify the largest file consuming this space, process IDs that are using those files, and log rotation status, because log rotation lets us avoid files growing indefinitely. First we need to use command find to search slash bar directory. We'll type F which will show us files only. We need size and then the file name. Find lets us add exec so we can execute a command and we'll do in human readable format and we will add dev null because we don't want to see permission errors. We use sort, we'll use reverse order because we need largest files first and we'll use also H because our values here for the size are in human readable format. We need to get top 10 results, head 10. Next task is we need to find process IDs. We can use X args LSOF, which will show us the process ID and files. Finally we need to find log rotate status. For log rotate status we need to search for this directory ETC log rotate D. We need first to isolate only log files. We'll use grep, those are our log files, and now we need to search for that name in log rotate.

One of the long running node services has been slowing down. The CPU usage and IO is normal. When we have something that is leaking memory, we take a snapshot of the memory usage, and then after some time, we can take another snapshot and compare relatively to other services how much the memory consumption is increasing. First list all the node JS processes. They run under name node usually in the system. We will use pgrep since we know the process name. Use ps and then the process number, and we will output RSS, which is resident set size. It's how much ram this process is using in kbs. Process number 1585 that's the one that is leaking. We need to kill that process.

Diagnose and fix TLS/HTTPS protocol mismatches in microservices receiving encrypted traffic instead of plain HTTP. Learn how to identify protocol mismatches by analyzing network traffic with packet capture, recognize TLS handshake data in service logs, and implement TLS termination using openssl s_server or similar tools. This guide covers understanding client-server protocol expectations, using tcpdump to inspect incoming traffic, fixing load balancer configuration issues, and ensuring proper TLS decryption before forwarding to HTTP backends. Essential for microservices debugging, load balancer troubleshooting, and resolving mysterious connection failures in containerized environments.

Debug Kubernetes pod scheduling issues: fix NodeSelector misconfigurations, implement PriorityClass, and resolve Pending pods. Master K8s scheduling troubleshooting.

Investigate a failed systemd service by extracting and saving its complete journal logs from the current boot session using journalctl with appropriate filtering options.

def eval_rpn(tokens: list[str]) -> int:
stack = []

for c in tokens:
    if c == "+":
        stack.append(stack.pop() + stack.pop())
    elif c == "-":
        b, a = stack.pop(), stack.pop()
        stack.append(a - b)
    elif c == "*":
        stack.append(stack.pop() * stack.pop())
    elif c == "/":
        b, a = stack.pop(), stack.pop()
        stack.append(int(a / b))
    else:
        stack.append(int(c))
        
return stack[0]

Definition for singly-linked list.

class ListNode:

def init(self, val=0, next=None):

self.val = val

self.next = next

def reverse_list(head: Optional[ListNode]) -> Optional[ListNode]:
prev = None
curr = head

while curr:
    nxt = curr.next
    curr.next = prev
    prev = curr
    curr = nxt
    
return prev

Definition for singly-linked list.

class ListNode:

def init(self, x):

self.val = x

self.next = None

def has_cycle(head: Optional[ListNode]) -> bool:
slow, fast = head, head

while fast and fast.next:
    slow = slow.next
    fast = fast.next.next
    if slow == fast:
        return True
        
return False

Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

def max_depth(root: Optional[TreeNode]) -> int:
if not root:
return 0

return 1 + max(max_depth(root.left), max_depth(root.right))

Deploy a decoupled job processing architecture on AWS using SQS for message queuing, ECS Fargate for running API and worker containers, and an Application Load Balancer for public access, with proper VPC networking, security groups, and least privilege IAM roles.

Test your AWS architecture skills by designing a secure, globally distributed web application using CloudFront, an internal Application Load Balancer, and Route 53 with strict origin isolation.

We need to write a query to filter orders by date range. We are given one table that is called Orders. It has four columns: customer's name, ID of an order that has been made, date of transaction, and total amount spent. We are required to return only the orders that were placed between January 1st, 2023, and June 30th, 2023. Both dates are inclusive, which means that orders on exactly those dates should be included, too. In SQL, we always start with FROM clause because this tells which table we want to work with. Using SELECT clause, we can choose the columns for the output. WHERE clause, which is the filter step. It goes through every single row and checks if the condition is true. For order date column, we use BETWEEN and operators. This combination checks if a value falls within a range, including both the start and end values. Finally, we sort everything by order date in ascending order so that the rows with the earliest date come first.

How to Transform Sales Data for Specific Dates with SQL

Objective: In this task, you are required to utilize your SQL skills to transform sales data from a table named Sales. The table includes three significant attributes: product_name, sale_date, and sales_amount. Your goal is to ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Detailed Explanation of SQL Query to Retrieve Order Information

If you're preparing for a technical interview and face a question related to extracting data from an SQL table, it's crucial to demonstrate both your understanding of SQL functions and your ability to solve problems efficiently. Be...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

We need to calculate descriptive statistics for numeric columns in Pandas. We are given one CSV file that is called Sales Data. It contains e-commerce transaction information with both numeric and non-numeric columns. Descriptive statistics are numbers that summarize a data set. Mean is an average value of all numbers, median is the middle value when sorted from low to high, STD is mathematical standard deviation, min for smallest value, max for largest value, and then the percentages. Our main goal is to calculate these eight descriptive statistics for all numeric columns and save the result as a CSV report with all values rounded to two decimal places. In order to work with the CSV file, it should be read into a data frame. Select_dtype is a Pandas method that filters columns by their data type. Include number means that we only want to keep columns that contains integers and floats. We save the report as a CSV file using to_csv function, and we set index to false to prevent Pandas from adding an extra row number column.

Master global sorting and sequential numbering in PySpark. Learn how to join DataFrames and use the row_number() window function across an entire unpartitioned dataset.

Master mathematical operations in PySpark. Learn how to perform column-wise division, handle division-by-zero errors gracefully using F.when(), and round your results to a specific decimal place.

Detailed Explanation for SQL Query to Retrieve Sales Department Employee Details

Optimizing for search engines while still creating informative content is essential for ranking highly in search results, especially for competitive keywords such as "SQL query join tables." Here's an SEO-friendly ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Identifying Gaps Between Consecutive Dates

Interview questions that test your ability to identify gaps between consecutive dates involve both problem-solving and SQL query skills. You will be provided with a table named dates that contains a column date, listing specific, sorted, and unique...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

We are given one table, Enrollments. This table has three columns that contain information like course ID, student ID, and term ID. Our job here is to calculate what percentage of students are enrolled in two or more consecutive terms. Consecutive means that in term ID column, the sequence goes like 101, 102, 103 without any gaps. A CTE is a temporary result set in SQL that you can reference within a single query. We will call our CTE as consecutive terms, and from enrollments table, we select student and term ID columns. We implement a window function with row number. Partition by clause divides a result set into smaller groups and allows a function to perform calculations on each subset separately. Row number assigns a sequential number to each row starting from one. In order to prevent all the duplicates, count with distinct will only return unique student IDs and completely ignore any null values. Cast in SQL is used to convert a value of one data type into another. We are required to round the results to two decimal places, and the only way to do so is by using a round function.

class Deduplicator:
def init(self, ttl):
self.ttl = ttl
self.seen = {}

def process(self, timestamp, eventId):
    expired = [k for k, t in self.seen.items() if timestamp - t > self.ttl]
    for k in expired:
        del self.seen[k]

    if eventId in self.seen:
        self.seen[eventId] = timestamp
        return False
    self.seen[eventId] = timestamp
    return True

class MinStack:
def init(self):
self.stack = []
self.min_stack = []

def push(self, val: int) -> None:
    self.stack.append(val)
    if self.min_stack:
        self.min_stack.append(min(val, self.min_stack[-1]))
    else:
        self.min_stack.append(val)

def pop(self) -> None:
    self.stack.pop()
    self.min_stack.pop()

def top(self) -> int:
    return self.stack[-1]

def getMin(self) -> int:
    return self.min_stack[-1]

class Twitter:
def init(self):
self.count = 0
self.tweetMap = {}
self.followMap = {}

def postTweet(self, userId: int, tweetId: int) -> None:
    if userId not in self.tweetMap:
        self.tweetMap[userId] = []
    self.tweetMap[userId].append([self.count, tweetId])
    self.count -= 1

def getNewsFeed(self, userId: int) -> list[int]:
    res = []
    minHeap = []
    
    if userId not in self.followMap:
        self.followMap[userId] = set()
        
    self.followMap[userId].add(userId)
    
    for followeeId in self.followMap[userId]:
        if followeeId in self.tweetMap and len(self.tweetMap[followeeId]) > 0:
            index = len(self.tweetMap[followeeId]) - 1
            count, tweetId = self.tweetMap[followeeId][index]
            heapq.heappush(minHeap, [count, tweetId, followeeId, index - 1])
            
    while minHeap and len(res) < 10:
        count, tweetId, followeeId, index = heapq.heappop(minHeap)
        res.append(tweetId)
        
        if index >= 0:
            next_count, next_tweetId = self.tweetMap[followeeId][index]
            heapq.heappush(minHeap, [next_count, next_tweetId, followeeId, index - 1])
            
    self.followMap[userId].remove(userId)
    return res

def follow(self, followerId: int, followeeId: int) -> None:
    if followerId not in self.followMap:
        self.followMap[followerId] = set()
    self.followMap[followerId].add(followeeId)

def unfollow(self, followerId: int, followeeId: int) -> None:
    if followerId in self.followMap and followeeId in self.followMap[followerId]:
        self.followMap[followerId].remove(followeeId)

class TrieNode:
def init(self):
self.children = {}
self.is_end = False

class WordDictionary:
def init(self):
self.root = TrieNode()

def addWord(self, word: str) -> None:
    curr = self.root
    for char in word:
        if char not in curr.children:
            curr.children[char] = TrieNode()
        curr = curr.children[char]
    curr.is_end = True

def search(self, word: str) -> bool:
    def dfs(j, root):
        curr = root
        for i in range(j, len(word)):
            char = word[i]
            if char == '.':
                for child in curr.children.values():
                    if dfs(i + 1, child):
                        return True
                return False
            else:
                if char not in curr.children:
                    return False
                curr = curr.children[char]
        return curr.is_end
        
    return dfs(0, self.root)

class TrieNode:
def init(self):
self.children = {}
self.is_end_of_word = False

class Trie:
def init(self):
self.root = TrieNode()

def insert(self, word: str) -> None:
    curr = self.root
    for char in word:
        if char not in curr.children:
            curr.children[char] = TrieNode()
        curr = curr.children[char]
    curr.is_end_of_word = True

def search(self, word: str) -> bool:
    curr = self.root
    for char in word:
        if char not in curr.children:
            return False
        curr = curr.children[char]
    return curr.is_end_of_word

def startsWith(self, prefix: str) -> bool:
    curr = self.root
    for char in prefix:
        if char not in curr.children:
            return False
        curr = curr.children[char]
    return True

class Node:
def init(self, key=0, val=0):
self.key = key
self.val = val
self.prev = None
self.next = None

class LRUCache:
def init(self, capacity: int):
self.cap = capacity
self.cache = {}

    self.left = Node()
    self.right = Node()
    self.left.next = self.right
    self.right.prev = self.left

def remove(self, node):
    prev_node = node.prev
    next_node = node.next
    prev_node.next = next_node
    next_node.prev = prev_node

def insert(self, node):
    prev_mru = self.right.prev
    prev_mru.next = node
    self.right.prev = node
    node.prev = prev_mru
    node.next = self.right

def get(self, key: int) -> int:
    if key in self.cache:
        self.remove(self.cache[key])
        self.insert(self.cache[key])
        return self.cache[key].val
    return -1

def put(self, key: int, value: int) -> None:
    if key in self.cache:
        self.remove(self.cache[key])
        
    self.cache[key] = Node(key, value)
    self.insert(self.cache[key])
    
    if len(self.cache) > self.cap:
        lru = self.left.next
        self.remove(lru)
        del self.cache[lru.key]

def check_subarray_sum(nums: list[int], k: int) -> bool:
remainder_map = {0: -1}
prefix_sum = 0

for i in range(len(nums)):
    prefix_sum += nums[i]
    remainder = prefix_sum % k
    
    if remainder in remainder_map:
        if i - remainder_map[remainder] >= 2:
            return True
    else:
        remainder_map[remainder] = i
        
return False

class UnionFind:
def init(self):
self.parent = {}

def find(self, x):
    if x not in self.parent:
        self.parent[x] = x
    if self.parent[x] != x:
        self.parent[x] = self.find(self.parent[x])
    return self.parent[x]
    
def union(self, x, y):
    rootX = self.find(x)
    rootY = self.find(y)
    if rootX != rootY:
        self.parent[rootY] = rootX

def accounts_merge(accounts: list[list[str]]) -> list[list[str]]:
uf = UnionFind()
email_to_name = {}

for acc in accounts:
    name = acc[0]
    first_email = acc[1]
    for i in range(1, len(acc)):
        email = acc[i]
        email_to_name[email] = name
        uf.union(first_email, email)
        
merged_emails = {}
for email in email_to_name:
    root = uf.find(email)
    if root not in merged_emails:
        merged_emails[root] = []
    merged_emails[root].append(email)
    
res = []
for root, emails in merged_emails.items():
    res.append([email_to_name[root]] + sorted(emails))
    
return res

def subarray_sum(nums: list[int], k: int) -> int:
count = 0
prefix_sum = 0
prefix_map = {0: 1}

for num in nums:
    prefix_sum += num
    diff = prefix_sum - k
    
    if diff in prefix_map:
        count += prefix_map[diff]
        
    prefix_map[prefix_sum] = prefix_map.get(prefix_sum, 0) + 1
    
return count

def median_sliding_window(nums: list[int], k: int) -> list[float]:
small = []
large = []
lazy = {}

for i in range(k):
    heapq.heappush(small, -nums[i])
    
for i in range(k // 2):
    heapq.heappush(large, -heapq.heappop(small))
    
def get_median():
    if k % 2 == 1:
        return float(-small[0])
    return (-small[0] + large[0]) / 2.0
    
res = [get_median()]

for i in range(k, len(nums)):
    out_num = nums[i - k]
    in_num = nums[i]
    
    lazy[out_num] = lazy.get(out_num, 0) + 1
    
    balance = 0
    
    if out_num <= -small[0]:
        balance -= 1
    else:
        balance += 1
        
    if small and in_num <= -small[0]:
        balance += 1
        heapq.heappush(small, -in_num)
    else:
        balance -= 1
        heapq.heappush(large, in_num)
        
    if balance < 0:
        heapq.heappush(small, -heapq.heappop(large))
    elif balance > 0:
        heapq.heappush(large, -heapq.heappop(small))
        
    while small and lazy.get(-small[0], 0) > 0:
        lazy[-small[0]] -= 1
        heapq.heappop(small)
        
    while large and lazy.get(large[0], 0) > 0:
        lazy[large[0]] -= 1
        heapq.heappop(large)
        
    res.append(get_median())
    
return res

WITH
expanded AS (
SELECT
searches
FROM
search_frequency
CROSS JOIN GENERATE_SERIES(1, num_users)
)
SELECT
ROUND(
PERCENTILE_CONT(0.5) WITHIN GROUP (
ORDER BY
searches
)::DECIMAL,
1
) AS median_searches
FROM
expanded;

Definition for singly-linked list.

class ListNode:

def init(self, val=0, next=None):

self.val = val

self.next = next

def add_two_numbers(l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode(0)
curr = dummy
carry = 0

while l1 or l2 or carry:
    val1 = l1.val if l1 else 0
    val2 = l2.val if l2 else 0
    
    total = val1 + val2 + carry
    carry = total // 10
    curr.next = ListNode(total % 10)
    
    curr = curr.next
    if l1: l1 = l1.next
    if l2: l2 = l2.next
    
return dummy.next

Objective

Write an SQL query to determine the average delivery time for each supplier. The delivery time is defined as the number of days between the order date and the delivery date. The result should list each supplier's name and the average delivery time in ascending order of average delivery...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

How to Calculate Records at Each Stage of a Sales Funnel and Determine Conversion Rates with SQL

Objective

In this article, we will walk you through creating an SQL query to calculate the number of records at each stage of a sales funnel and determine the conversion rate from one stage to ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Are you preparing for an SQL interview and looking for ways to demonstrate your expertise in data analysis for subscription services? A common interview question revolves around calculating the monthly churn rate using SQL. This detailed explanation will take you through the process step-by-step...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Objective

Write an SQL query to determine the best-selling product in each region based on the total quantity sold. The output should list the region name, product name, and total sales of each top-selling product, sorted in descending order by the total sales.

Additional information

• Assu...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

How to Answer the SQL Query Interview Question on Calculating Total Compensation for Employees

Objective

In an SQL-based interview, you may be asked to write a query that calculates the total compensation for employees involved in at least two distinct projects. The compensation comprises ...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Stripe processes billions of dollars in payments annually for millions of businesses. QA testing of payment APIs requires comprehensive validation of charge processing, refunds, webhook security, and transaction history to ensure reliable financial operations....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Zoom hosts over 300 million daily meeting participants across 220+ countries. QA testing of video conferencing APIs requires comprehensive validation of meeting creation, participant management, recording controls, and quality analytics to ensure seamless remote collaboration....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Microsoft Azure Active Directory handles millions of authentication requests daily. QA testing of authentication APIs requires comprehensive validation of login flows, password resets, user registration, and profile management to ensure secure user access control....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Master table data extraction with Selenium. Learn row navigation, cell parsing, and comprehensive data validation techniques....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Master multi-window testing with Selenium. Learn window handle management, context switching, and data extraction across browser windows....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →