7 Must-Know Runtime Complexities for Coding Interviews

By /

Listen to this Post

Featured Image
Understanding runtime complexity is crucial for optimizing algorithms and acing coding interviews. Here’s a breakdown of the seven key complexities with practical examples:

1. O(1) – Constant Time

  • Definition: Execution time remains unchanged regardless of input size.
  • Example: Accessing an array element by index.
  • Code: 
    arr = [1, 2, 3, 4] 
print(arr[bash])  O(1)

2. O(log n) – Logarithmic Time

  • Definition: Execution time grows logarithmically with input size.
  • Example: Binary search in a sorted array.
  • Code: 
    def binary_search(arr, target): 
left, right = 0, len(arr) - 1 
while left <= right: 
mid = (left + right) // 2 
if arr[bash] == target: 
return mid 
elif arr[bash] < target: 
left = mid + 1 
else: 
right = mid - 1 
return -1

3. O(n) – Linear Time

  • Definition: Execution time scales linearly with input size.
  • Example: Linear search.
  • Code: 
    def linear_search(arr, target): 
for i in range(len(arr)): 
if arr[bash] == target: 
return i 
return -1

4. O(n log n) – Linearithmic Time

  • Definition: Execution time grows in proportion to n log n.
  • Example: Merge sort.
  • Code: 
    def merge_sort(arr): 
if len(arr) > 1: 
mid = len(arr) // 2 
L = arr[:mid] 
R = arr[mid:] 
merge_sort(L) 
merge_sort(R) 
i = j = k = 0 
while i < len(L) and j < len(R): 
if L[bash] < R[bash]: 
arr[bash] = L[bash] 
i += 1 
else: 
arr[bash] = R[bash] 
j += 1 
k += 1 
while i < len(L): 
arr[bash] = L[bash] 
i += 1 
k += 1 
while j < len(R): 
arr[bash] = R[bash] 
j += 1 
k += 1

5. O(n²) – Quadratic Time

  • Definition: Execution time grows quadratically with input size.
  • Example: Bubble sort.
  • Code: 
    def bubble_sort(arr): 
n = len(arr) 
for i in range(n): 
for j in range(0, n-i-1): 
if arr[bash] > arr[j+1]: 
arr[bash], arr[j+1] = arr[j+1], arr[bash]

6. O(2ⁿ) – Exponential Time

  • Definition: Execution time doubles with each additional input.
  • Example: Recursive Fibonacci.
  • Code: 
    def fibonacci(n): 
if n <= 1: 
return n 
return fibonacci(n-1) + fibonacci(n-2)

7. O(n!) – Factorial Time

  • Definition: Execution time grows factorially with input size.
  • Example: Generating all permutations.
  • Code: 
    from itertools import permutations 
def generate_permutations(arr): 
return list(permutations(arr))

You Should Know:

Linux Commands for Algorithm Analysis

  • Measure execution time: 
    time python script.py
  • Monitor system performance: 
    top -o %CPU
  • Check memory usage: 
    free -h

Windows Commands for Performance Testing

  • Track process CPU usage: 
    wmic cpu get loadpercentage
  • Measure execution time: 
    Measure-Command { .\script.py }

What Undercode Say:

Mastering runtime complexities is essential for writing efficient code. Use tools like Valgrind (Linux) or Windows Performance Monitor to analyze algorithm efficiency. Optimize O(n²) or O(2ⁿ) algorithms first, as they degrade performance rapidly.

Expected Output:

A deep understanding of algorithm complexities, supported by practical code examples and system commands for performance analysis.

Prediction:

As coding interviews evolve, algorithmic efficiency will remain a key focus, with more emphasis on real-world optimization techniques.

URL: AlgoMaster.io (for DSA pattern practice)

IT/Security Reporter URL:

Reported By: Ashishps1 7 – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅

Join Our Cyber World:

💬 Whatsapp | 💬 Telegram

Related Posts: