Code Problem / Data Structures and Algorithms / Recursion
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:
This technical problem asks the coder to return the sum of the elements in an array. The input is an array of integers and the output should be the sum of those integers.
About this solution: This solution is correct and demonstrates a level of completeness. The approach is straightforward and easy to follow.
Given a binary tree, this problem requires finding the maximum sum path from the root to a leaf. For example, in the tree shown above, the maximum sum path would be 3 + 5 + 10 + 2 + 11 = 31. This can be done using recursion.
About this solution: The candidate's solution correctly solves the problem. The approach is to recursively find the maximum sum path from each node to its leaves, and then compare the paths to find the overall maximum sum path.
To find the deepest node in a binary tree, we can use recursion. We can keep track of the maximum depth as we traverse the tree, and return the deepest node's value when we reach the end of the tree.
About this solution: This is a good solution that correctly finds the deepest node in a binary tree. The approach of using a depth first search is a good one, as it only needs to traverse the tree once. The code is well-written and easy to follow.
This problem asks us to find all possible subsets of a given set of distinct integers. A subset is simply a subset of elements from the given set, and the power set is the set of all possible subsets. Note that the solution set must not contain duplicate subsets.
About this solution: The candidate's solution is complete and solves the problem. The approach is to first add the empty subset to the result, and then iterate through the nums array, adding each element to all of the existing subsets to create new subsets.
Given an array of integers, this code problem finds the sum of all elements in the array. The input is an array of numbers and the output is the sum of all the numbers in the array.
About this solution: The candidate's solution does not demonstrate a level of completeness and does not solve the problem. The candidate's approach is to simply print out the array elements without summing them.
This problem asks us to find all possible subsets of a given set of distinct integers. For example, if the input is [1,2,3], then the output should be [[ ], [1], [2], [3], [1,2], [1,3], [2,3], [1,2,3]].
About this solution: The candidate's solution is complete and solves the problem. The approach is to iterate through the input array and create new subsets by adding each element to all existing subsets.
This problem involves reversing a linked list using recursion. The given example input is a list of integers, but this technique can be applied to lists of any data type. The output should be the reverse of the input list.
About this solution: The candidate's solution correctly reverses the nodes in a linked list. The approach is straightforward and easy to understand. The code is well-organized and easy to read.
This technical problem involves implementing a function that reverses a string using recursion. For example, given the input string "Hello", the function would return the output string "olleH".
About this solution: The candidate's solution does not demonstrate a level of completeness and does not solve the problem. The general approach is not clear.