We have a scenario with JS web server, a list of IP addresses in the access log. We need to use this file to calculate average load on our server and make a rate limit on our JS configuration. First thing we need to do is to calculate top IP addresses under this file. IP is stored under first column as a first element in this file, so we can use awk to extract this. By typing awk print dollar sign one, we'll print the first element. Use this command to add additional features, meaning sort this take only unique values and count them, then sort them again and take top three values. Next, we'll use rate limit equals to echo, sum divided by three, multiplied by 0.8. And I'll use this formula, the sum divided by three and multiplied by 0.8. And the answer is 300. We need to add 300 into our configuration file.

We have random timeouts that users report and we need to investigate why this occurs. We've been tasked to check the gateway ip, the DNS server and google.com. We'd like to check the local network ability to connect to the external IP and the DNS resolution. We need to identify the gateway ip and for that we'll use IP route and we'll search for something where we see default. This means that any traffic that will not match other rules will go to this default gateway's IP address. Next, ping our gateway IP address and we've been asked to ping it five times. So it's flag C. And then number five. Repeat the same thing for Google DNS. An average round trip is indicated. Most likely the issue is coming from the DNS resolution because we've got 60% packet loss.

We need to test our runs multiple versions using a matrix strategy. The challenge here is that by default, if one particular version fails, GitHub Actions cancels all the other running versions immediately. What we want to change is that every version runs to completion, even if one of them fails. M...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

def two_sum(nums: list[int], target: int) -> list[int]:
prev_map = {} # value -> index

for i, n in enumerate(nums):
    diff = target - n
    if diff in prev_map:
        return [prev_map[diff], i]
    prev_map[n] = i
    
return []

Objective

In this article, we'll tackle a commonly asked SQL interview question that involves analyzing sales data to produce a summarized monthly revenue report for different regions. Given a table named sales with columns id, region, amount, and sale_date, the goal is to write a SQL...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

SQL Interview Question: Extracting Distinct Payment Methods

Objective

Construct an SQL query to extract all distinct payment methods from the payments table. The resulting list should be ordered alphabetically by the payment method names.

Additional Information

• The `payments...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

We'll remove seasonal effects from time series sales data using Pandas and Statsmodels. We are given one CSV file, sales data, that contains transactions over multiple years. The sales indicate the current seasonal pattern. We are required to remove those seasonal effects so that we can see if the company is actually growing or it is just a result of seasonal factors. Deseasonalization simply removes that repeating pattern so that we can see the real trend. We import two things, Pandas library, and seasonal decompose function from Statsmodels. Seasonal decompose is the function that splits our time and date into trend, seasonal, and residual components. We specify the decomposition model by setting it to additive, which simply means that the components will add up together. Since our data is monthly and seasons repeat every year, the period will be set to 12 months. In order to calculate the deseasonalized value, we need to sum the trend values with residual values.

We will assign row numbers to authors for each paper. This is a Snowflake question, which is a cloud-based data warehouse that uses all main concepts from SQL. We have two tables, research_papers and authors. Our job here is to join these two tables together and assign a sequential row number to each author per paper. The numbering must reset for every new paper so that the first author of each paper always gets row number one. In Snowflake, we put the table inside of ref function, and this whole thing is wrapped up in double curly braces. We are more interested in inner join because it returns only the rows where there is a match in both tables. Between these two tables, we implement inner join operator, and using on keyword, we indicate which columns are used to combine the tables. Row number assigns a sequential number to each row, starting from one. Over keyword simply activates the window function. Partition by divides all the rows into separate groups based on a column. In our case, it's paper_id. Row number will reset back to one at the start of each new group. And then we sort everything out in ascending order by author_id.

Spark is a framework that processes large amounts of data across multiple machines. At the same time, instead of tables, it uses data frames. We are given two files, companies and investments. Our job here is to find the total investment amount for each industry sector and sort from highest to lowest. We will first combine both of the data frames, then we will sum investments per industries, and in the end, we will sort everything in descending order. Inner join returns only rows where a match exists in both tables or data frames. We will use inner join because for every investment row, we want the company's name and industry to be right next to it. We group by industry column so that all rows that share the same field are put together. Sum function simply adds up all amount values and finds the total investment per industry. The third step is that we order everything by total investment column in descending order.

SELECT
s.name AS star_name,
s.color AS star_color,
s.type AS star_type,
p.name AS planet_name,
p.type AS planet_type,
s.distance AS distance_star_earth,
p.distance AS distance_planet_star
FROM {{ ref("planets") }} p
INNER JOIN {{ ref("stars") }} s
ON p.star_id = s.id

Master relational joins and mathematical operations in PySpark. Learn how to perform an inner join to filter unmatched records and multiply columns together to calculate the Ideal Gas Law result.

Objective

To effectively handle inventory within a warehouse, it's pivotal to have a clear summary of inventory details. This SQL query strives to generate a concise summary that includes the warehouse name, product type, count of different items, the total quantity of items, and their cumulati...

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →

def top_k_frequent(nums: list[int], k: int) -> list[int]:
count = {}
freq = [[] for i in range(len(nums) + 1)]

for n in nums:
    count[n] = 1 + count.get(n, 0)
    
for n, c in count.items():
    freq[c].append(n)
    
res = []
for i in range(len(freq) - 1, 0, -1):
    for n in freq[i]:
        res.append(n)
        if len(res) == k:
            return res
            
return res

Definition for singly-linked list.

class ListNode:

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

self.val = val

self.next = next

def remove_nth_from_end(head: Optional[ListNode], n: int) -> Optional[ListNode]:
dummy = ListNode(0, head)
left = dummy
right = head

while n > 0 and right:
    right = right.next
    n -= 1
    
while right:
    left = left.next
    right = right.next
    
left.next = left.next.next

return dummy.next