Connection fails because certificate doesn't contain Subject alternative name. Because modern TLS clients ignore common name and they require SAN to have DNS or IP address for verification. We'll need to generate new certificate that contains a valid IP address or DNS to which we will connect. We can run openssl as client to capture information about the certificate that is being served from this web server. We can just run openssl s_client and then grep subject field and we'll see that subject is wrong. Generate new certificate. OpenSSL x509 new key and then algorithm, nodes, the key and output is server certificate. Subject is going to be localhost and subject alternative name is going to be an IP address and this is our validity time of the certificate. We can use sed command. Sed command is useful for finding and replacing certain lines in the file.

We have a container image, my app Fs, built from this Docker file that performs intensive file system right operations. Docker currently is using overlay FS storage driver and right performance is a bottleneck. We need to configure Docker Demon to use appropriate configuration for the right heavy setup, then restart Docker Demon and then rebuild this image. Overlay FS works in a way that the kernel automatically decides when to copy files from the image layer to the writeable layer. There's a process in Docker called copy up. Files in docker are read only. So if we need to change the file in the docker, we need to copy it from the image layer into the writeable layer. It works really fast, but it's prone to errors in certain conditions, especially when we have very right heavy system. For those things we use something called fuse overlay Fs, and in the fuse, the driver itself explicitly decides and performs this copy before writing. So it's slower, but it's more stable. We need to check if we have Fuse installed on our system. We need to change the docker demon to use different storage driver.

We have a Git repository. Under this folder we have a feature payment branch and it's behind our main branch by 32 commits. We need to rebase a feature branch onto the latest main. We need to bring all the latest changes from main to this feature branch. Switch to feature payment branch. We need to rebase from main. Type git rebase main. We have conflicts. Some of the commits cannot be rebased. We have two changes for the same line. Remove the obsolete one and keep what we need. And now we can git add and git rebase continue. We've successfully rebased and updated feature payment.

def exist(board: list[list[str]], word: str) -> bool:
ROWS, COLS = len(board), len(board[0])

def dfs(r, c, i):
    if i == len(word):
        return True
        
    if (r < 0 or c < 0 or r >= ROWS or c >= COLS or 
        board[r][c] != word[i]):
        return False
        
    temp = board[r][c]
    board[r][c] = "#"
    
    found = (dfs(r + 1, c, i + 1) or
             dfs(r - 1, c, i + 1) or
             dfs(r, c + 1, i + 1) or
             dfs(r, c - 1, i + 1))
             
    board[r][c] = temp
    
    return found
    
for r in range(ROWS):
    for c in range(COLS):
        if dfs(r, c, 0):
            return True
            
return False

class GraphNode:

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

self.val = val

self.neighbors = neighbors if neighbors is not None else []

def clone_graph(node: 'GraphNode') -> 'GraphNode':
old_to_new = {}

def dfs(node):
    if not node:
        return None
    if node in old_to_new:
        return old_to_new[node]
        
    copy = GraphNode(node.val)
    old_to_new[node] = copy
    
    for nei in node.neighbors:
        copy.neighbors.append(dfs(nei))
        
    return copy
    
return dfs(node)

Diagnose and fix a broken TLS certificate chain by identifying the missing intermediate CA and rebuilding the chain bundle so the server certificate validates successfully.

We'll need to sort Avro employee records by salary. Avro stores data in a compressed binary format, which makes it much more efficient for large data sets. The schema travels with the data within the same file and never gets separated. An Avro file is made up of a header that is followed by multiple blocks. We are given one file that is called employees.avro. Our goal here is to read the given file, sort the records by salary in descending order, and save the result as JSON file. We import two things, Reader function from FastAvro library that will help us to read the file, and then JSON. To read the file, we will use open function that takes two arguments. First is file path, and second is mode. In our case, it is rb, that stands for read binary mode. We create the Avro reader from the open file using the Reader function. We need to sort that list by salary using sorted function. As a second argument, we implement a small lambda function that for each X employee returns X salary. In third argument, we set reverse to True, which will sort everything out in descending order.

WITH combined AS (
SELECT
b.department,
b.amount_budgeted,
s.amount_spent
FROM {{ ref("budgets") }} b
INNER JOIN {{ ref("spending") }} s
ON b.department = s.department
AND b.fiscal_year = s.fiscal_year
),
aggregated AS (
SELECT
department,
CAST(VARIANCE(amount_budgeted) AS INTEGER) AS budget_variance,
CAST(VARIANCE(amount_spent) AS INTEGER) AS spending_variance
FROM combined
GROUP BY department
)
SELECT * FROM aggregated
ORDER BY department

We are given two tables, rides and visitors. Our job here is to find rides whose average rating is unusually high or unusually low compared to all other rides. We measure this using standard deviation. Standard deviation is a statistical measure that checks how spread out a set of values is from their average. Our query will consist of three parts. First, we will calculate the average rating per ride. Second, we will calculate global mean and standard deviation across all ride averages. And third, we will use those stats to flag anomalies. A CTE, or common table expression, is a temporary result set that we define at the top of our query. For our task, we are more interested in inner join because it returns only the rows where there is a match in both tables. A window function, unlike group by that collapses all rows into one, performs a calculation across multiple rows and keeps every single row in the result. Stddev is a built-in SQL and Snowflake function that calculates standard deviation. We wrap it inside of ABS, which stands for absolute value. Then we compare if that distance is greater than global standard deviation. If the distance is greater than one standard deviation, the ride is considered too far from the norm and gets true.

WITH daily_values AS (
SELECT
p.PE_firm,
pr.date,
CAST(SUM(p.shares * pr.closing_price) AS INTEGER) AS portfolio_value
FROM {{ ref("portfolio") }} AS p
INNER JOIN {{ ref("prices") }} AS pr
ON p.company = pr.company
GROUP BY p.PE_firm, pr.date
)
SELECT * FROM daily_values

def length_of_longest_substring(s: str) -> int:
char_set = set()
l = 0
res = 0

for r in range(len(s)):
    while s[r] in char_set:
        char_set.remove(s[l])
        l += 1
        
    char_set.add(s[r])
    res = max(res, r - l + 1)
    
return res

Fetch paginated JSON data from a REST API, flatten nested product information, create a SQLite database table, and insert all records using Python.

Master mouse hover actions with Selenium ActionChains. Learn to reveal hidden elements, validate visibility changes, and test interactive UI components....

🔒 Premium Content

Detailed explanation and solution available for premium members.

Upgrade to Premium →