SHORTEST PATH
+========+
Time: 30 minutes - 1 hour
Difficulty: Hard
Languages: Any
+========+
Given a graph represented by an adjacency matrix and a starting vertex, implement a function that finds the shortest path to every other vertex in the graph using Dijkstra's algorithm.
+========+
Please answer to this message with your solution 🙂

MAXIMUM PRODUCT SUBSET
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a list of integers, implement a function that finds the maximum product that can be formed by selecting any subset of the integers.
+========+
Please answer to this message with your solution 🙂

MAXIMUM SUM SUBSEQUENCE
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a list of integers, implement a function that finds the maximum sum that can be formed by selecting any contiguous subsequence of the integers.
+========+
Please answer to this message with your solution 🙂

PRIMES
+========+
Time: 30 minutes - 1 hour
Difficulty: Hard
Languages: Any
+========+
Implement a function that returns a list of all prime numbers less than a given number n
+========+
Please answer to this message with your solution 🙂

FIBONACCI
+========+
Time: 15 minutes - 30 minutes
Difficulty: Easy
Languages: Any
+========+
Implement a function that returns the nth Fibonacci number in a sequence.
+========+
Please answer to this message with your solution 🙂

MAXIMUM WATER TRAPPED
+========+
Time: 30 minutes - 1 hour
Difficulty: Hard
Languages: Any
+========+
Given an array of non-negative integers representing a landscape, where the width of each bar is 1, implement a function that finds the amount of water that can be trapped in the landscape.
+========+
Please answer to this message with your solution 🙂

BUBBLE SORT
+========+
Time: 15 minutes - 30 minutes
Difficulty: Easy
Languages: Any
+========+
Implement the bubble sort algorithm for sorting a list of integers.
+========+
Please answer to this message with your solution 🙂

BINARY TREE ZIGZAG LEVEL ORDER TRAVERSAL
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given the root of a binary tree, implement a function that performs a zigzag level-order traversal of the tree and return a list of lists of the nodes at each level.
+========+
Please answer to this message with your solution 🙂

STRING COMPRESSION
+========+
Time: 30 minutes - 1 hour
Difficulty: Easy
Languages: Any
+========+
Given a string, implement a function that performs basic string compression using the counts of repeated characters.
+========+
Please answer to this message with your solution 🙂

QUICKSORT
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Implement the quicksort algorithm for sorting a list of integers.
+========+
Please answer to this message with your solution 🙂

ALL PAIRS SHORTEST PATH
+========+
Time: 1 hour - 2 hours
Difficulty: Hard
Languages: Any
+========+
Given a graph represented by an adjacency matrix, implement a function that finds the shortest path between every pair of vertices using the Floyd-Warshall algorithm.
+========+
Please answer to this message with your solution 🙂

MAXIMUM SUBARRAY
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given an array of integers, implement a function that finds the contiguous subarray with the largest sum of its elements.
+========+
Please answer to this message with your solution 🙂

WORD LADDER
+========+
Time: 1 hour - 2 hours
Difficulty: Hard
Languages: Any
+========+
Given two words and a list of words, implement a function that finds the shortest sequence of transformations from the start word to the end word, where each transformation is a change of a single letter to any other letter.
+========+
Please answer to this message with your solution 🙂

GRAPH COLORING
+========+
Time: 1 hour - 2 hours
Difficulty: Hard
Languages: Any
+========+
Given a graph represented by an adjacency matrix, implement a function that colors the graph with the minimum number of colors such that no two adjacent vertices have the same color, using the Welsh-Powell algorithm.
+========+
Please answer to this message with your solution 🙂

MINIMUM SPANNING TREE
+========+
Time: 1 hour - 2 hours
Difficulty: Hard
Languages: Any
+========+
Given a graph represented by an adjacency matrix, implement a function that finds the minimum spanning tree of the graph using Prim's algorithm.
+========+
Please answer to this message with your solution 🙂

TEMPLATE MATCHING
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given two images represented by two matrices, implement a function that finds the location of the template image within the larger image using the normalized cross-correlation method.
+========+
Please answer to this message with your solution 🙂

WORD BREAK
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a string and a list of words, implement a function that checks whether the string can be segmented into a space-separated sequence of one or more dictionary words, using dynamic programming approach.
+========+
Please answer to this message with your solution 🙂

TSP
+========+
Time: 2 hours - 3 hours
Difficulty: Hard
Languages: Any
+========+
Given a set of cities and the distance between each pair of cities, implement a function that finds the shortest possible route that visits each city exactly once and returns to the starting point, using the brute force approach.
+========+
Please answer to this message with your solution 🙂

IMAGE BLURRING
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given an image represented by a matrix, implement a function that applies a blurring effect to the image using a convolution matrix.
+========+
Please answer to this message with your solution 🙂

DFS
+========+
Time: 30 minutes - 1 hour
Difficulty: Easy
Languages: Any
+========+
Given a graph represented by an adjacency list, implement a function that performs a depth-first search of the graph, and returns a list of the visited nodes.
+========+
Please answer to this message with your solution 🙂