## Introduction

In this article, we are going to develop a simple Project of **Python Time Complexity Calculator**. You can learn what is complexity and what is time complexity here. So, **what is Time complexity?** Time Complexity of an algorithm is calculated by counting the number of basic operations executed by the algorithm, assuming that each elementary operation takes a constant amount of time to execute.

## Python Time Complexity Calculator

We will be using the **big-o-calculator** library for estimating the temporal or time complexity of sorting methods in Python. If the big-o-calculator is not installed in your python library, first of all, install it.

**Installation**

`pip install big-o-calculator`

You may evaluate time complexity, compute runtime, and compare two sorting algorithms with this big-o-calculator but sometimes results may vary.

### Methods

There are a lot of methods available in the bio-o-calculator library, basically, it is a calculator to estimate the time complexity of a sorting function. Some of the important methods of bio-o-calculator library are **test()**, **test_all()**, **runtime()**, **compare()**,etc. All these methods contain many parameters. Now, let’s see Python Time Complexity Calculator code now.

### Code

```
from bigO import BigO
from bigO import algorithm
from random import randint
fname=input("Enter algorithm name:")
def fname(array): # in-place, unstable
'''
Best : O(n^2) Time | O(1) Space
Average : O(n^2) Time | O(1) Space
Worst : O(n^2) Time | O(1) Space
'''
currentIndex = 0
while currentIndex < len(array) - 1:
smallestIndex = currentIndex
for i in range(currentIndex + 1, len(array)):
if array[smallestIndex] > array[i]:
smallestIdx = i
array[currentIndex], array[smallestIndex] = array[smallestIndex], array[currentIndex]
currentIndex += 1
return array
def TimeComplexity(functionname):
lib = BigO()
cmplx = lib.test(functionname, "random")
cmplx = lib.test(functionname, "sorted")
cmplx = lib.test(functionname, "reversed")
cmplx = lib.test(functionname, "partial")
cmplx = lib.test(functionname, "Ksorted")
TimeComplexity(fname)
```

We are using the Selection Sort algorithm to understand the working of the big-o-calculator library of python.

**Explanation:**

For calculating the time complexity, you just need to enter the algorithm name and then define the function for this particular algorithm as we did with selectionSort in the example above. After that, we just test the algorithm with the help of the test() function of BigO and it will show all the results. You can test it with other algorithms as well.

### Comparison of two algorithms

You can also compare two algorithms. For comparison, we need two algorithms. So, one we are taking bubble sort and second quick sort. Now, let’s see the Python Time Complexity Calculator code for a comparison of two algorithms.

#### Code

```
from bigO import BigO
from bigO import algorithm
from random import randint
fname=input("Enter algorithm name:")
fname1=input("Enter algorithm name")
def fname(array): #bubbleSort algorithm
"""
Best:O(n) time| O(1) space
Average: O(n^2) time | O(1) space
Worst: O(n^2) time | O(1) space
"""
n = len(array)
# Traverse through all array elements
for i in range(n):
# Last i elements are already in place
for j in range(0, n-i-1):
# traverse the array from 0 to n-i-1
# Swap if the element found is greater
# than check the next element
if array[j] > array[j+1]:
array[j], array[j+1] = array[j+1], array[j]
def fname1(array): # in-place | not-stable quicksort algorithm
"""
Best : O(nlogn) Time | O(logn) Space
Average : O(nlogn) Time | O(logn) Space
Worst : O(n^2) Time | O(logn) Space
"""
if len(array) <= 1:
return array
smaller, equal, larger = [], [], [] #taking 3 arrays small, equal and large
pivot = array[randint(0, len(array) - 1)] #finding the pivot element
for x in array: #traverse each element of array
if x < pivot:
smaller.append(x) #if x element is smaller than pivot element then move it in small array
elif x == pivot:
equal.append(x) #if x element is equal to pivot element then move it in equal array
else:
larger.append(x) # if x element is equal to pivot element then move it in large array
return fname1(smaller) + equal + fname1(larger) #now again
def TimeComplexity(functionname,functionname1):
lib = BigO()
cmplx = lib.test(functionname, "random")
cmplx = lib.test(functionname, "sorted")
cmplx = lib.test(functionname, "reversed")
cmplx = lib.test(functionname1, "random")
cmplx = lib.test(functionname1, "sorted")
cmplx = lib.test(functionname1, "reversed")
cmplx=lib.compare(fname,fname1,"random",5000)
cmplx=lib.compare(fname,fname1,"all",5000)
TimeComplexity(fname,fname1)
```

**Explanation:**

For comparing two algorithms we are using compare method of BigO.

- fname is for bubbleSort algorithm and fname1 is for quickSort.
- Select a random array with size 5000.
- The second time we compare all types of arrays and the size is 5000 in all cases.

**Summary**

Using the Python big-o-calculator library and some code, we have constructed a simple python time complexity calculator that allows us to simply compute the time complexity for different algorithms.

Thank you for reading this article, click here to start learning Python in 2022.

**Also Read:**

- Print Colored Text Output in Python
- Gender Recognition by Voice using Python
- Make money with Python in 2022
- File Explorer in Python using Tkinter
- Drawing Application in Python Tkinter
- Top 32 Python Interview Questions For Experienced
- Top 10 Final Year Projects for Computer Science Students
- Diabetes prediction using Machine Learning
- Tkinter GUI Calendar in Python
- Library Management System Project in Java
- Microsoft Giving Free Python Course: Enroll Now
- Top 5 Free Python Courses on YouTube in 2022
- Bank Management System Project in Java
- CS Class 12th Python Projects
- Google Giving Free Python Course: Enroll Now
- How to extract YouTube comments using Python?
- 15 Deep Learning Projects for Final year
- Python Alarm Clock | Tkinter GUI App
- Complete Python Roadmap for Beginners in 2022
- Games in Python | Assignment Expert
- Top 10 Python Projects for Final year Students
- 10 Tkinter Projects for Beginners
- Vending Machine with Python Code
- Python OOP Projects | Source code and example
- Generate QR Code in Python
- Make Minecraft in Python
- Battleship Game Code in Python
- Simple Atm Program in Python
- Top 8 Apps To Learn Python Free In 2022
- Data Science Projects for Final Year