MAXIMUM FLOW
+========+
Time: 2 hours - 3 hours
Difficulty: Hard
Languages: Any
+========+
Given a network represented by a directed graph with capacities on the edges, implement a function that finds the maximum flow through the network using the Ford-Fulkerson algorithm
+========+
Please answer to this message with your solution 🙂

DYNAMIC PROGRAMMING COIN CHANGE
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a target value and a list of coin values, implement a function that finds the number of ways to make the target value using the given coin denominations with dynamic programming.
+========+
Please answer to this message with your solution 🙂

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

AVL TREE
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a list of integers, implement a function that constructs an AVL tree from the list and a function that performs an in-order traversal of the tree
+========+
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 them, implement a function that finds the shortest possible route that visits each city exactly once and returns to the origin city using the branch and bound algorithm
+========+
Please answer to this message with your solution 🙂

MINIMUM SPANNING TREE
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given an undirected graph represented by an adjacency matrix, implement a function that finds the minimum spanning tree using the Kruskal's algorithm
+========+
Please answer to this message with your solution 🙂

IMAGE SEGMENTATION
+========+
Time: 1 hour - 2 hours
Difficulty: Hard
Languages: Any
+========+
Given an image represented by a matrix, implement a function that segments the image into multiple regions using the region growing algorithm
+========+
Please answer to this message with your solution 🙂

SINGLE-LINKAGE CLUSTERING
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a set of points in two-dimensional space, implement a function that performs single-linkage clustering on the set, using the nearest-neighbor algorithm
+========+
Please answer to this message with your solution 🙂

Summer break 😎

Prograchallenges is on summer vacation the first 2 weeks in July. Hope you have had an amazing 2023 so far, and remember to take some time off and be outside.

See you soon again!

BELLMAN-FORD
+========+
Time: 2 hours - 3 hours
Difficulty: Hard
Languages: Any
+========+
Given a directed graph represented by an adjacency matrix and a source vertex, implement a function that finds the shortest path from the source vertex to all other vertices using the Bellman-Ford algorithm.
+========+
Please answer to this message with your solution 🙂

GREEDY ALGORITHM
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a set of items, each with a value and a weight, and a knapsack with a maximum weight capacity, implement a function that finds the maximum value that can be placed in the knapsack using a greedy algorithm.
+========+
Please answer to this message with your solution 🙂

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

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

DEPTH-FIRST SEARCH
+========+
Time: 2 hours - 3 hours
Difficulty: Hard
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 🙂

GRADIENT DESCENT
+========+
Time: 1 hour - 2 hours
Difficulty: Hard
Languages: Any
+========+
Given a set of data points and a cost function, implement a function that finds the minimum of the cost function using gradient descent algorithm.
+========+
Please answer to this message with your solution 🙂

HUFFMAN CODING
+========+
Time: 30 minutes - 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a string of characters, implement a function that performs Huffman coding on the string to compress it.
+========+
Please answer to this message with your solution 🙂

BUBBLE SORT
+========+
Time: 30 minutes
Difficulty: Easy
Languages: Any
+========+
Given a list of integers, implement a function that performs a bubble sort on the list
+========+
Please answer to this message with your solution 🙂

QUICKSORT
+========+
Time: 1 hour
Difficulty: Medium
Languages: Any
+========+
Given a list of integers, implement a function that performs a quicksort on the list
+========+
Please answer to this message with your solution 🙂

Dijkstra's Shortest Path
+========+
Time: 2 hours - 3 hours
Difficulty: Hard
Languages: Any
+========+
Given a directed graph represented by an adjacency matrix and a source vertex, implement a function that finds the shortest path from the source vertex to all other vertices using Dijkstra's shortest path algorithm
+========+
Please answer to this message with your solution 🙂

TOWER OF HANOI
+========+
Time: 30 minutes
Difficulty: Easy
Languages: Any
+========+
Given a tower of n discs stacked in decreasing order of size and 3 pegs, implement a function that solves the tower of Hanoi puzzle by moving the discs from the first peg to the last peg with the help of the middle peg.
+========+
Please answer to this message with your solution 🙂

FIBONACCI SEQUENCE
+========+
Time: 30 minutes
Difficulty: Easy
Languages: Any
+========+
Given a number n, implement a function that returns the nth number in the Fibonacci sequence using recursion
+========+
Please answer to this message with your solution 🙂