We have several unauthorized applications that are listening on the ports between 8,000 and 9,000. Our task is to identify those processes and terminate them. We'll need to scan this port range and find processes that are binding to TCP and UDP ports and then get their process ID and kill that. We'll use SS command, which is more suitable for this, and SS stands for socket statistics. We'll do SS T that stands for TCP, U for UDP, and then L, the ones that are listening, P to get process IDs. And then we'll have to add N as well to get numerical ports. Sometimes we need to use force kill, and for that we need to use sudo hyphen nine and then process ID.

We have a service that is failing. It runs periodically and exits with some error code. Our task here is to create a systemly service that will run regularly. It should try to restart the service once it fails. Trigger should be on failure and it should attempt three restarts within 60 seconds. And delay between attempts should be five seconds. We need to create system D service and I'll create it under ETC system, D system, and then the name of the service. Start limit burst equals to three. Three attempts and start limit interval in seconds is 60. Trigger on failure and then attempt window. How many seconds we should wait between next attempt, restart sec equals to five. We've been asked to configure the service to start on boot. For this we need to have install section with wanted by key equals to multi-user target. Enable our new system D service, pseudo system CTL enable, and then name of the service.

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 →

We will filter popular videos on a streaming platform. Snowflake is a cloud-based data warehouse platform. Here, your query will look just like an SQL. We are given videos table, which contains video ID, title, genre, release year, duration, and view count columns. Our job is to retrieve those videos that have more than one million views and that were released in year 2019 or later. FROM clause, this is one of the things that differ regular SQL from Snowflake. It uses a dynamic reference with the ref function. Instead of naming the table, we are asking the system to find correct version of the table for us. Inside of the double curly braces, we put the ref function with the name of our table. We select all columns using select with a star. Our main goal was to filter the videos, and to do so, we should build sort of a condition inside of the WHERE clause. The first statement is that a number inside of view count column should be higher than one million. The second is that release year should be higher or equal to 2019. Since both of the statements are mandatory, we will use a logical operator.

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.

We'll match string patterns using like. We have two tables, departments and employees. Our job is to filter employees based on three conditions. First one is that their name must start with letter A. Second is that the email must contain the substring @tech, and third is the position level must contain the word senior. A join in SQL connects two tables together based on a common column. We are more interested in inner join because it returns only the rows where there is a match in both tables. Like is an operator in SQL used to search for a specific pattern inside of a string. Like works together with wild cards, and the most significant one is percent sign. We write name column from employees table, like A percent sign, which means A is the first letter, and then any symbol can follow this letter. Second condition is that email from employees table must contain @tech keyword, and since this value is in the middle of the string, we put percent signs from both sides. And finally we sort everything in ascending order by name.

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 →