Algorithm Prep provides an easy way to practise algorithms for programmers and students. It includes the ready-to-use test cases for user to test the algorithm, and the reference implementations to benchmark the performance of the user's algorithms.
$ pip install algorithm-prep
Let's take sorting algorithm as an example. You can create your own algorithm in a function, then add a main block to test your function.
from algorithm_prep import test
from algorithm_prep.classic.sort import test_cases
def my_sort_function(arr):
# my implementation
return arr
test(my_sort_function, test_cases)
from algorithm_prep import benchmark
from algorithm_prep.classic.sort import algorithms, test_cases
def my_sort_function(arr):
# my implementation
return arr
benchmark(my_sort_function, algorithms, test_cases)
There are a few algorithms implemented in algorithm-prep.
First include following import statements in your code
from algorithm_prep import test, benchmark
from algorithm_prep.classic.sort import test_cases, algorithms
Then write your sorting function
def your_sort_algorithm(arr):
"""
:type arr: List[int]
:rtype: List[int]
"""
To test the function
test(your_sort_algorithm, test_cases)
Or to benchmark your algorithm
benchmark(your_sort_algorithm, algorithms, test_cases)
Following reference algorithms are implemented for benchmark
- Bubble Sort
- Insertion Sort
- Merge Sort
- Quick Sort
- Heap Sort
- Radix Sort
First make following import statement
from algorithm_prep import test, benchmark
from algorithm_prep.classic.string_search import algorithms, test_cases
Then write your own string search algorithm
def your_string_search(string, target):
"""Search target in string, and return the index of first occurance, or return -1 if not found.
:type string: str
:type target: str
:rtype: int
"""
Now you can test your algorithm
test(your_string_search, test_cases)
Or benchmark its performance
benchmark(your_string_search, algorithms, test_cases)
The reference implementations of string search algorithms include
- Brute force search algorithm
- str.find() in Python
- KMP algorithm
- Rabin-Karp algorithm
First import following codes
from algorithm_prep import test, benchmark
from algorithm_prep.classic.binary_search import algorithms, test_cases
Then add your search algorithm
def your_search_algorithm(arr, target):
"""Search target in arr and return the index, or return -1 if target not found.
:type arr: list[int]
:type target: int
:rtype: int
"""
At last your can test your algorithm
test(your_search_algorithm, test_cases)
Or run benchmark
benchmark(your_search_algorithm, algorithms, test_cases)
First make import statement
from algorithm_prep import test, benchmark
from algorithm_prep.classic.union_find import algorithms, test_cases
Then add your algorithm
def your_union_find(vertices, edges):
"""Find the number of the components in a graph. The graph is represented in the number of vertices (the vertices will be [0,1,...,n-1]) and list of edges [(i, j), (k, l),..]
:type vertices: int
:type edges: list[tuple(int)]
:rtype: int
"""
At last you can test your algorithm
test(your_union_find, test_cases)
Or you run benchmark
benchmark(your_union_find, algorithms, test_cases)