Learn how to scan for listening services on specific port ranges and identify their associated processes using Linux Bash commands. This guide covers discovering unauthorized applications on non-standard ports, extracting process IDs, and safely terminating services-essential for security audits and removing unauthorized network listeners.

Learn how to create robust systemd services with intelligent restart policies using Linux system administration. This guide covers configuring automatic recovery from failures, preventing restart storms with rate limiting, enabling boot persistence, and testing failure scenarios, essential for building resilient services and preventing resource exhaustion in production environments.

def contains_duplicate(nums: list[int]) -> bool:
seen = set()
for n in nums:
if n in seen:
return True
seen.add(n)
return False

"""

Definition for a Node.

class Node:
def init(self, x: int, next: 'Node' = None, random: 'Node' = None):
self.val = int(x)
self.next = next
self.random = random
"""

def copy_random_list(head: 'Optional[Node]') -> 'Optional[Node]':
if not head:
return None

# 1. Interweave
curr = head
while curr:
    new_node = Node(curr.val, curr.next)
    curr.next = new_node
    curr = new_node.next
    
# 2. Assign random pointers
curr = head
while curr:
    if curr.random:
        curr.next.random = curr.random.next
    curr = curr.next.next
    
# 3. Separate
curr = head
new_head = head.next
while curr:
    copy = curr.next
    curr.next = copy.next
    if copy.next:
        copy.next = copy.next.next
    curr = curr.next
    
return new_head

def pacific_atlantic(heights: list[list[int]]) -> list[list[int]]:
if not heights or not heights[0]:
return []

rows, cols = len(heights), len(heights[0])
pacific = set()
atlantic = set()

def dfs(r, c, visited, prev_height):
    if (r < 0 or c < 0 or r >= rows or c >= cols or 
        (r, c) in visited or heights[r][c] < prev_height):
        return
        
    visited.add((r, c))
    
    dfs(r + 1, c, visited, heights[r][c])
    dfs(r - 1, c, visited, heights[r][c])
    dfs(r, c + 1, visited, heights[r][c])
    dfs(r, c - 1, visited, heights[r][c])
        
for c in range(cols):
    dfs(0, c, pacific, heights[0][c])
    dfs(rows - 1, c, atlantic, heights[rows - 1][c])
    
for r in range(rows):
    dfs(r, 0, pacific, heights[r][0])
    dfs(r, cols - 1, atlantic, heights[r][cols - 1])
    
res = []
for r in range(rows):
    for c in range(cols):
        if (r, c) in pacific and (r, c) in atlantic:
            res.append([r, c])
            
return res

def oranges_rotting(grid: list[list[int]]) -> int:
rows, cols = len(grid), len(grid[0])
q = deque()
fresh_count = 0

for r in range(rows):
    for c in range(cols):
        if grid[r][c] == 2:
            q.append((r, c))
        elif grid[r][c] == 1:
            fresh_count += 1
            
minutes = 0
directions = [[1, 0], [-1, 0], [0, 1], [0, -1]]

while q and fresh_count > 0:
    level_size = len(q)
    
    for _ in range(level_size):
        r, c = q.popleft()
        
        for dr, dc in directions:
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 1:
                grid[nr][nc] = 2
                fresh_count -= 1
                q.append((nr, nc))
                
    minutes += 1
    
return minutes if fresh_count == 0 else -1

Objective

Retrieve the name and price of the product(s) with the lowest price from the products table.

Additional Information

• The products table contains the following columns:
  • id (integer): Unique identifier for each product.
  • name (string): Name of the product.
  • `p...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

SELECT *
FROM {{ ref("videos") }}
WHERE view_count > 1000000
AND release_year >= 2019

Practice advanced joining techniques in PySpark. Learn how to perform a cross join (Cartesian product) to pair every transaction with every customer, and effectively handle overlapping column names.

Objective

In order to extract specific employee information from a database using SQL, a meticulous approach is necessary to filter the data based on certain criteria. The task is to fetch the names, department names, email addresses, and position levels of employees with the following specifications:

• Only include employees whose names start with the letter 'A'.
• Only include employees whose email addresses contain the substring '@tech'.
• Only include employees whose position levels contain the word 'Senior'.
• The results must be sorted by employee names in ascending order.

SQL Query Instructions

Given the structure of your database, there are two tables you need to use: employees and departments. The employees table consists of columns id, name, department_id, email, and position_level. The departments table consists of columns id, name, and location. The tables are joined based on the department identifiers department_id from the employees table and id from the departments table.

SQL Query

To achieve the desired output, you should write an SQL query that performs the following actions:

1. Joins the tables employees and departments on the department_id and id columns respectively.
2. Filters the employees based on the specified criteria:
   • Employee names start with 'A'.
   • Employee email addresses contain the substring '@tech'.
   • Employee position levels contain the word 'Senior'.
3. Selects the required columns: name, department, email, and position_level.
4. Orders the results by employee names in ascending order.

SQL Code

SELECT e.name, d.name AS department, e.email, e.position_level
FROM employees e
JOIN departments d ON e.department_id = d.id
WHERE e.name LIKE 'A%'
  AND e.email LIKE '%@tech%'
  AND e.position_level LIKE '%Senior%'
ORDER BY e.name ASC;

This query ensures that the data returned meets all the given criteria and is neatly organized according to the required order. Implement these steps accurately to retrieve the correct set of employee information from your database, ensuring clarity and precision in your data analysis.

from collections import defaultdict

class HashJoin:
def init(self):
self.table = defaultdict(list)

def build(self, rows, keyIndex):
    self.table.clear()
    for row in rows:
        self.table[row[keyIndex]].append(row)

def probe(self, rows, keyIndex):
    result = []
    for row in rows:
        for build_row in self.table.get(row[keyIndex], []):
            result.append(build_row + row)
    result.sort()
    return result

Objective

Write an SQL query to calculate the cumulative sales total for each day from a table named daily_sales. The table contains two columns: date and sales_amount. The result should include each date, the sales amount for that date, and the running total of sales up to and including t...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Objective

Create an SQL query designed to retrieve the number of orders made by each customer during the first quarter of the year, specifically in January, February, and March. The required output should group these counts by customer_id and detail the number of orders for each of these thre...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

def min_window(s: str, t: str) -> str:
if t == "": return ""

count_t, window = {}, {}
for c in t:
    count_t[c] = 1 + count_t.get(c, 0)
    
have, need = 0, len(count_t)
res, res_len = [-1, -1], float("infinity")
l = 0

for r in range(len(s)):
    c = s[r]
    window[c] = 1 + window.get(c, 0)
    
    if c in count_t and window[c] == count_t[c]:
        have += 1
        
    while have == need:
        if (r - l + 1) < res_len:
            res = [l, r]
            res_len = (r - l + 1)
        
        window[s[l]] -= 1
        if s[l] in count_t and window[s[l]] < count_t[s[l]]:
            have -= 1
        l += 1
        
l, r = res
return s[l : r + 1] if res_len != float("infinity") else ""

Comprehensive Guide to SQL Query for Analyzing Order Data

Objective

In this task, you are required to create an SQL query to analyze order data from the orders table. Specifically, you need to extract various metrics for each year from the data. Here is a detailed breakdown of the requir...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Answering the Interview Question: Calculate the Number of Days Between Consecutive Orders for Each Customer Using SQL

Objective

To create an SQL query that calculates the number of days between consecutive orders for each customer. The results will provide essential details such as the cus...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

Master dynamic form validation testing with Selenium. Learn input field validation and real-time form behavior automation....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →