Puzzles
Categories:
Code Problem / Data Structures and Algorithms / Recursion (32)
Code Problem / Data Structures and Algorithms / Binary Search (30)
Code Problem / Data Structures and Algorithms / Linked Lists (26)
Code Problem / Data Structures and Algorithms / Backtracking (26)
Code Problem / Data Structures and Algorithms / Stacks and Queues (25)
Code Problem / Data Structures and Algorithms / Hashing (24)
Databases / SQL / Backup and Recovery (19)
Code Problem / Data Structures and Algorithms / Arrays and Strings (19)
Databases / SQL / Database Normalization (18)
Code Problem / Data Structures and Algorithms / Time Complexity (17)
Databases / SQL / Locking (16)
Databases / SQL / Replication (15)
Databases / SQL / SQL Queries (13)
Code Problem / Data Structures and Algorithms / Graphs (13)
Databases / SQL / Database Security (13)
More...
Recent solutions:
Check these solutions from our community:
The Tower of Hanoi is a classic puzzle in which disks are moved from one peg to another, without ever placing a larger disk on top of a smaller one.
About this solution: The candidate's solution is correct and solves the problem. The candidate has taken a recursive approach to solving the problem, which is a good approach. The candidate could improve their solution by adding comments to explain the code.
The Tower of Hanoi is a puzzle in which the objective is to move a stack of disks from one rod to another, obeying certain rules. This problem asks for the sequence of moves required to solve the puzzle for a given number of disks.
About this solution: The candidate's solution correctly solves the problem. The candidate uses a recursive approach, which is the most efficient way to solve the Tower of Hanoi problem.
The goal of the Tower of Hanoi problem is to move all disks from the first tower to the third tower, such that each disk is on top of a larger disk. You can only move one disk at a time, and you can only move a disk to the top of another tower if that tower has no disks on it, or if the top disk on that tower is larger than the disk you are trying to move.
About this solution: The candidate's solution is incomplete and does not solve the problem. The candidate's approach is to describe an optimal solution, but does not provide any code or pseudocode to implement the solution.
The Tower of Hanoi problem is a classic algorithmic puzzle that can be solved using a simple recursive algorithm. Given a stack of n disks, the algorithm moves the disks from the first stack to the last stack, using only three stacks and moving only one disk at a time. The disks must be moved so that the smallest disk is on top of the largest disk.
About this solution: The candidate's solution is correct and demonstrates a level of completeness. The approach is clear and easy to follow.
This puzzle asks you to write a function that takes in a list of integers and outputs the largest number in the list.
About this solution: The candidate's solution correctly finds the largest number in the list. The candidate uses a for loop to iterate through the list and compare each number to the current largest number. If the number is larger, it becomes the new largest number. This is a good approach as it iterates through the entire list only once.
Given a list of numbers, find the two numbers with the greatest product and return that product.
About this solution: The candidate's solution is correct and demonstrates a level of completeness. The candidate has correctly identified that the last two numbers in the list will be the largest two numbers and has sorted the list in ascending order. This is the optimal solution.
You are given a list of numbers and a target number. Find a way to split the list into two parts such that the sum of the first part is equal to the target number.
About this solution: The candidate's solution is a greedy algorithm, which is a good approach for this problem. The algorithm is optimal because it always chooses the best option at the moment, which in this case is the largest number that is less than or equal to the target. If the largest number is greater than the target, then the next largest number will be chosen, and this process will continue until the target is reached.