Diagnose and fix ENTRYPOINT/CMD misconfiguration that prevents command-line arguments from passing through containers. Master the difference between shell form and exec form syntax, use exec "$@" in entrypoint scripts for proper argument forwarding, and ensure docker run commands execute as expected. Resolve containers that exit immediately without output by implementing proper ENTRYPOINT/CMD patterns. Essential for container orchestration, CLI tools, Docker init scripts, and flexible container execution.

Correct feature branches created from wrong bases by rebasing onto the correct parent branch. Use git rebase develop to replay commits on the correct foundation, preserve all work, maintain clean linear history, and enable proper pull requests. Essential for team workflows, branching strategies, keeping features synchronized with development branches, and preventing merge conflicts from divergent bases.

def product_except_self(nums: list[int]) -> list[int]:
res = [1] * len(nums)

# Calculate prefix products
prefix = 1
for i in range(len(nums)):
    res[i] = prefix
    prefix *= nums[i]

# Calculate suffix products and combine
postfix = 1
for i in range(len(nums) - 1, -1, -1):
    res[i] *= postfix
    postfix *= nums[i]

return res

Definition for singly-linked list.

class ListNode:

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

self.val = val

self.next = next

def reorder_list(head: Optional[ListNode]) -> Optional[ListNode]:
if not head: return None

# 1. Find middle
slow, fast = head, head.next
while fast and fast.next:
    slow = slow.next
    fast = fast.next.next
    
# 2. Reverse second half
second = slow.next
prev = slow.next = None
while second:
    tmp = second.next
    second.next = prev
    prev = second
    second = tmp
    
# 3. Merge
first, second = head, prev
while second:
    tmp1, tmp2 = first.next, second.next
    first.next = second
    second.next = tmp1
    first, second = tmp1, tmp2
return head

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 is_subtree(root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
if not subRoot:
return True
if not root:
return False

if is_same_tree(root, subRoot):
    return True
    
return is_subtree(root.left, subRoot) or is_subtree(root.right, subRoot)

def is_same_tree(p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
if not p and not q:
return True
if not p or not q or p.val != q.val:
return False
return is_same_tree(p.left, q.left) and is_same_tree(p.right, q.right)

def least_interval(tasks: list[str], n: int) -> int:
counts = Counter(tasks)

max_freq = max(counts.values())

max_freq_count = 0
for count in counts.values():
    if count == max_freq:
        max_freq_count += 1
        
required_time = (max_freq - 1) * (n + 1) + max_freq_count

return max(len(tasks), required_time)

How to Replace NULL with 0 in SQL and Retrieve All Orders from the orders Table

Writing clean and efficient SQL queries is an essential skill for database management and data analysis. If you're asked to retrieve all orders from an orders table, ensuring that any NULL values in the discount column are replaced with 0, you need to follow specific steps to structure your query correctly. Below is a comprehensive guide on achieving this task.

Steps to Write the SQL Query

1. Identify the Columns: The orders table contains the columns order_id, customer_name, discount, and total_amount.
2. Handle NULL Values: Ensure that the discount column does not contain any NULL values by using the COALESCE function, which allows you to replace NULL values with 0.
3. Select All Required Columns: Ensure that the query retrieves all the columns in the specified order - order_id, customer_name, discount, and total_amount.
4. Order the Results: Use the ORDER BY clause to sort the results by order_id in ascending order.

Sample SQL Query

SELECT 
    order_id,
    customer_name,
    COALESCE(discount, 0) AS discount,
    total_amount
FROM 
    orders
ORDER BY 
    order_id ASC;

Breaking Down the Query

• SELECT statement: This part retrieves the columns you need.

  SELECT 
      order_id,
      customer_name,
  

• COALESCE Function: Use COALESCE(discount, 0) to replace NULL values in the discount column with 0.

      COALESCE(discount, 0) AS discount,
  

• FROM clause: Specifies the table from which to fetch the data.

  FROM 
      orders
  

• ORDER BY clause: Ensures the result set is ordered by order_id in ascending sequence, making it easier to read and analyze.

  ORDER BY 
      order_id ASC;
  

Best Practices

• Readability: Write clear and readable queries. Using aliases (like COALESCE(discount, 0) AS discount) makes it easier to interpret results.
• Performance: Ensure your database has indexes on columns commonly used in ORDER BY clauses, like order_id, to optimize query performance.

Leveraging these structured steps will help you efficiently write the required SQL query to retrieve and process the orders data from the orders table, replacing NULL discounts with 0, and ordering by order_id. This method ensures clean data handling and a structured output, which is a critical aspect of database queries and analysis.

Read employee data from a CSV file, sort records by salary column in descending order, and save the sorted dataset using pandas.

Practice data integration and cleaning in PySpark. Learn how to deduplicate event logs, perform full outer joins across multiple tables, and sort data using multiple columns.

SELECT
e.experiment_date,
e.experiment_id,
e.experiment_results,
COALESCE(e.material_id, m.material_id) AS material_id,
m.material_name,
m.material_type
FROM {{ ref("experiments") }} AS e
FULL OUTER JOIN {{ ref("materials") }} AS m
ON e.material_id = m.material_id

Master data aggregation and filtering in PySpark. Learn how to join tables, group by categories to calculate averages, and filter rows based on dynamic column comparisons.

SQL Query to Find the Top 3 Product Categories with the Highest Average Price

Objective

Write an SQL query to identify the top 3 product categories that exhibit the highest average price for their active products. Specifically, for each of these categories, the query should return:

• The number of active products within the category.
• The average price of these active products, rounded to two decimal places.
• The count of active products with stock levels falling below 10 units.

Additional Information:

• Only consider products marked as active (is_active = true).
• If multiple categories share the same average price, prioritize them based on the number of active products, in descending order.
• The final output should be ordered by the average price in descending order and then by the number of active products in descending order.
• Limit the results to the top 3 categories.
• The products table contains attributes related to the products.
• The inventory table maintains information pertaining to the stock levels of these products.

Clarifications:

• avg_price: The average price of the active products in each category.
• product_count: The total number of active products in each category.
• low_stock_items: The number of active products in each category that have stock levels below 10 units.

SQL Query Example

SELECT
    p.category AS category,
    COUNT(p.id) AS product_count,
    ROUND(AVG(p.price), 2) AS avg_price,
    SUM(CASE WHEN i.stock < 10 THEN 1 ELSE 0 END) AS low_stock_items
FROM
    products p
JOIN
    inventory i ON p.id = i.product_id
WHERE
    p.is_active = true
GROUP BY
    p.category
ORDER BY
    avg_price DESC,
    product_count DESC
LIMIT 3;

This query joins the products and inventory tables, filters for active products, calculates the required metrics, and ensures the results are prioritized and limited according to the given conditions.

Interview Question: SQL Query to Calculate Average Number of Orders and Monthly Order Frequency by Customer Loyalty Status

Objective
Create an SQL query to calculate the average number of orders and average monthly order frequency for customers, grouped by their loyalty membership status....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Objective

Write a SQL query to retrieve the names, department names, and salaries of employees whose salary is greater than 65,000. The result should be sorted in descending order of salary.

Additional Information

• The database contains two tables: employees and departments.
• Each emp...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

def merge(intervals: list[list[int]]) -> list[list[int]]:
intervals.sort(key=lambda x: x[0])

merged = [intervals[0]]

for start, end in intervals[1:]:
    last_end = merged[-1][1]
    
    if start <= last_end:
        merged[-1][1] = max(last_end, end)
    else:
        merged.append([start, end])
        
return merged

SQL Query to Fetch Employee Names, Department Names, and Salaries with Specific Criteria

Interviewers often assess your expertise in SQL by presenting a scenario that requires writing a complex query to retrieve data from multiple tables. In this scenario, the task is to fetch the names of empl...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →