Discover data structures and algorithms using Python. Gain insights into solving real-world problems and typical interview questions with detailed reviews, explanations, and hands-on coding exercises.

Data structures and algorithms are among the most fundamental concepts of Computer Science. Whether it’s real-world problems you’re trying to solve or the typical coding question asked in an interview, almost every problem requires you to demonstrate a deep understanding of data structures and algorithms. 

This course is a detailed review of some of the most common data structures and algorithms that you’ll see in interviews and your everyday work. With implementation details, thorough explanations, and hands-on coding exercises, you’ll quickly gain the confidence you need to solve any problem, no matter the situation.

Data Structures and Algorithms in Python

In this lesson, we focus on the following problem:

**Given a string, calculate the number of consonants present.**

The vowels are the following letters:
```
a e i o u
```
Any other letter that is not a vowel is a consonant.  

Let's have a look at an example:
```
Welcome to Educative!
```
has `9` consonants. 

Before you dive into the implementation, consider the edge cases such as spaces and exclamation marks. This implies that if a character is not a vowel, it has to be a letter to be considered a consonant. 

# Iterative Approach
Check out the iterative approach in the snippet below:

vowels = "aeiou"

def iterative_count_consonants(input_str):
    consonant_count = 0
    for i in range(len(input_str)):
        if input_str[i].lower() not in vowels and input_str[i].isalpha():
            consonant_count += 1
    return consonant_count

On **line 1**, we define `vowels` globally to be `"aeiou"`. `input_str` is the given string passed to `iterative_count_consonants` function which we have to process to calculate the number of consonants. `consonant_count` is initialized to `0` on **line 4** and then the `input_str` is traversed character by character using a `for` loop on **line 5**. Note that `input_str[i]` is changed to lowercase using `lower()` because `vowels` contains all the vowels in lowercase so that we can compare them correctly on **line 6**. As discussed before, we check if `input_str[i].lower()` is present in `vowels` or not. Additionally, `input_str[i].isalpha()` should also be `True` for the condition on **line 6**  to be `True`. Thus, if `input_str[i]` is not a vowel and an alphabet, then `consonant_count` is incremented by `1` on **line 7**. After the condition on **line 6** is evaluated for every character in `input_str`, the final count of `consonant_count` is returned from the function on **line 8**. 

The running time complexity for the iterative approach is $O(n)$ because, for each character in the input string of length $n$, we spend a constant amount of effort. 

# Recursive Approach

The implementation of the recursive approach will be very similar to the recursive implementations we have covered in the previous lessons. Check it out below:

In this lesson, you will learn how to count consonants of a string using both an iterative and recursive approach in Python.

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Count Consonants in String

Iterative Approach