Join our community to practice, learn, solve your problems with AI. Recruiters: create tests and evaluate candidates instantly.
Categories:
Code Problem
Databases
Python
Programming Languages
Mathematics
Machine Learning
NodeJS
Puzzles
Math
Algorithms
Strings
Theorems
Data structures
Games
JavaScript
More...
Recent solutions:
Check these solutions from our community:
This problem asks you to reverse a string using a stack. An example input and output are provided.
About this solution: The candidate's solution is correct and uses a stack to reverse the string as required. The candidate's code is clean and easy to read. Well done.
Given an object with nested objects, this function flattens the object by creating key paths for nested values.
About this solution: This solution is correct and demonstrates a level of completeness. It solves the problem and takes a general approach of flattening the object.
Given a table of data representing customer orders, this SQL query finds the order with the highest total value.
About this solution: The solution above is optimal because it uses the GROUP BY clause to group the data by customer_id and order_id, and then uses the SUM function to calculate the total value of each order.
The solution then uses the ORDER BY clause to sort the data by total_value in descending order, and then uses the LIMIT clause to return only the first row.
This function takes in a graph represented as an adjacency list, and returns whether or not the graph contains a cycle.
About this solution: The candidate's solution is correct and demonstrates a good understanding of depth first search. However, the code could be more concise. For example, the has_cycle function could be written as follows:
def has_cycle(g):
visited = set()
for node in g:
if node not in visited:
if dfs(node, visited, None):
return 1
return 0
def dfs(node, visited, parent):
visited.add(node)
for neighbor in node:
if neighbor not in visited:
if dfs(neighbor, visited, node):
return True
elif neighbor != parent:
return True
return False
Given a table of data, write a SQL query to partition the data by year. The table should have three columns: id, value, and year. The query should return the id, value, and year for each row in the table.
About this solution: The solution above is correct and demonstrates a level of completeness. It solves the problem by partitioning the data by year. The approach is efficient and straightforward.
This problem is about printing all numbers from 1 to n in ascending order. The function takes in a number n and prints out all numbers from 1 to n.
About this solution: The candidate's solution correctly prints out all the numbers from 1 to n in ascending order. The candidate's approach is to use a for loop to iterate through the numbers from 1 to n and print each number. This is a valid approach.
Update the email field for all users in a MongoDB document whose id is greater than 100.
About this solution: The candidate's solution is complete and solves the problem. The candidate has used the $gt operator to find all documents where the id is greater than 100 and the $set operator to update the email field for all documents that match the query.
This problem asks the reader to write a cursor to update the prices of all products in a table by 10%. The table is provided as input, and the expected output is also shown.
About this solution: The candidate's solution is correct and demonstrates a level of completeness. The candidate has correctly used a cursor to iterate over the table and update the prices of all products by 10%. The candidate's approach is sound and the solution is efficient.