1. Generate the first 10 numbers in the Fibonacci sequence
  2. Print numbers from 1 to 100, replacing multiples of 3 with "Fizz," multiples of 5 with "Buzz," and both with "FizzBuzz" (FizzBuzz)
  3. Implement a function to traverse a graph by exploring as far as possible before backtracking (Depth-first search)
  4. Explore nodes layer by layer in a graph (Breadth-first search)
  5. Divide and conquer by repeatedly narrowing the search range (Binary Search)
  6. Check each element in a list to find a target value (Linear Search)
  7. Find pairs in array using two pointers technique
  8. Reverse the order of characters in a string
  9. Check if two strings are made of the same characters (Anagram Check)
  10. Check if a string can be split into dictionary words (Word Break)
  11. Expand and contract a range to find subarrays that meet criteria (Sliding Window)
  12. Check if a string has balanced opening and closing brackets (Valid Parentheses)
  13. Find all possible solutions by trying different paths and backtracking when needed (Backtracking)
  14. Split and merge sorted halves to sort an array (Merge Sort)
  15. Order graph nodes in a sequence respecting dependencies (Topological Sort)
  16. Repeatedly swap adjacent elements to sort an array (Bubble Sort)
  17. Sort by placing elements into different 'buckets' before sorting each bucket (Bucket Sort)
  18. Find the smallest unsorted element and move it to the front (Selection Sort)
  19. Insert each unsorted element into its correct position (Insertion Sort)
  20. Sort using a binary heap structure (Heap Sort)
  21. Use a pivot to partition elements into two groups for sorting (Quick Sort)
  22. Store strings in a prefix tree structure for fast retrieval (Trie)
  23. Compute cumulative sums for subarray calculations (Prefix Sum)
  24. Find the k-th smallest element in an unsorted array (Quickselect)
  25. Find the shortest path from a source node to all other nodes (Dijkstra's Algorithm)
  26. Group nodes by connectivity for union-find operations (Union Find)
  27. Find the minimum number of coins needed to make change for a given amount using available denominations (Coin Change Problem)
  28. Find the shortest path in a weighted graph, using heuristics (A* Algorithm)
  29. Find the minimum spanning tree of a graph (Prim's Algorithm)
  30. Detect cycles in a linked list (Floyd's Cycle Detection)
  31. Encode characters based on frequency for data compression (Huffman Encoding)
  32. Maximize value in a knapsack by allowing fractional items (Fractional Knapsack Problem)
  33. Count the number of vowels in a string
  34. Generate a pattern where characters are repeated in steps (Steps String Pattern)
  35. Create a centered pyramid pattern with strings (Pyramid String Pattern)
  36. Traverse a matrix in a spiral order (Spiral Matrix)
  37. Find the minimum spanning tree of a graph using edge weights (Kruskal's Algorithm)
  38. Find the maximum sum of any subarray (Kadane's Algorithm)
  39. Identify the most frequently occurring character in a string (Maximum Frequency Character)
  40. Transform the casing of strings to title case, where the first letter of each word is capitalized
  41. Use a hash map to find two numbers that add up to a target (Two Sum Problem)
  42. Implement a debounce function in JavaScript
  43. Implement a function to find all permutations of a string in JavaScript
  44. Implement a closure in JavaScript that maintains private state
  45. Check if a string is a palindrome
  46. Implement a function to deep clone an object
  47. Flatten a nested array
  48. Remove duplicates from an array in JavaScript
  49. Implement a memoize function in JavaScript
  50. Implement a function to get unique elements from an array
  51. Implement a function to deep compare two objects
  52. Implement a function to find the intersection of two arrays
  53. Implement a function to find all anagrams of a word within a list of words
  54. Implement prototype-based inheritance in JavaScript without using classes
  55. Implement a function to rotate an array to the right by `k` steps
  56. Implement a function to count the number of islands in a 2D grid
  57. Implement a function to find the longest consecutive sequence in an array
  58. Implement a function to find the first unique character in a string
  59. Implement a function to fetch data using Promises and async/await in JavaScript
  60. Implement a function to find the maximum depth of a binary tree
  61. Implement a function to serialize and deserialize a binary tree
  62. Implement a function to find the maximum product of three numbers in an array
  63. Implement a function to find the longest common prefix among an array of strings
  64. Implement a regular expression to validate email addresses in JavaScript
  65. Merge two sorted arrays in JavaScript
  66. Implement a function to find the longest substring with at most two distinct characters
  67. Find the most common integer in a list, returning the smallest in case of a tie in JavaScript
  68. Implement a function to flatten a deeply nested object in JavaScript
  69. Implement a function to check if a number is prime
  70. Reverse a singly linked list in JavaScript
  71. Calculate the factorial of a number using recursion in JavaScript
Estimated time: 40 hours

Settings

THEME

NAVIGATION

Show arrows

JAVASCRIPT CONSOLE

Enable console
Keep it on all tabs

TIMER

Show in top bar
Infinite loop
Enable sound

QUESTIONS

Show answer background

APPLICATION DATA

This application is currently in maintenance mode.
Both questions and answers need to be refactored and restructured. There will be also new functionalities soon