An iterator is an object that enables us to traverse a container or data structure such as a list, tuple, dictionary, or set. It allows us to access elements of the container one at a time, without exposing its underlying implementation. Iterators are used to iterate over a sequence of values and perform operations on them.

In Python, an iterator is an object that implements the iterator protocol, which consists of the __iter__() and __next__() methods. The __iter__() method returns the iterator object itself, and the __next__() method returns the next value from the iterator.

Here is an example program to demonstrate the tower of Hanoi using a recursive function:

def tower_of_hanoi(n, from_rod, to_rod, aux_rod):

    if n == 1:

        print(f”Move disk 1 from {from_rod} to {to_rod}”)

        return

    tower_of_hanoi(n – 1, from_rod, aux_rod, to_rod)

    print(f”Move disk {n} from {from_rod} to {to_rod}”)

    tower_of_hanoi(n – 1, aux_rod, to_rod, from_rod)

# Sample usage

tower_of_hanoi(3, ‘A’, ‘C’, ‘B’)

In the above code, we define a function tower_of_hanoi() that takes four parameters: the number of disks n, the source rod from_rod, the destination rod to_rod, and the auxiliary rod aux_rod.

The function first checks if there is only one disk. If so, it simply moves it from the source rod to the destination rod. If there are more than one disk, it calls the tower_of_hanoi() function recursively on the subproblem of moving n-1 disks from the source rod to the auxiliary rod, then it moves the n-th disk from the source rod to the destination rod, and finally calls the tower_of_hanoi() function recursively on the subproblem of moving n-1 disks from the auxiliary rod to the destination rod.

When we call the function tower_of_hanoi(3, ‘A’, ‘C’, ‘B’), it prints the steps required to move three disks from rod A to rod C using rod B as an auxiliary rod:

Move disk 1 from A to C

Move disk 2 from A to B

Move disk 1 from C to B

Move disk 3 from A to C

Move disk 1 from B to A

Move disk 2 from B to C

Move disk 1 from A to C

Sorting is the process of arranging data in a particular order, typically in ascending or descending order. Merging is the process of combining two or more sorted arrays or lists into a single sorted list.

There are many different algorithms for sorting data, and each has its own advantages and disadvantages in terms of time complexity, space complexity, and stability. Some of the most common sorting algorithms are:

Bubble Sort: Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The algorithm ends when no more swaps are needed. Here’s an example implementation in Python:

def bubble_sort(arr):

    n = len(arr)

    for i in range(n):

        for j in range(n-i-1):

            if arr[j] > arr[j+1]:

                arr[j], arr[j+1] = arr[j+1], arr[j]

    return arr

Selection Sort: Selection sort is a simple sorting algorithm that repeatedly selects the smallest element from the unsorted portion of the list and swaps it with the leftmost unsorted element. Here’s an example implementation in Python:

def selection_sort(arr):

    n = len(arr)

    for i in range(n):

        min_idx = i

        for j in range(i+1, n):

            if arr[j] < arr[min_idx]:

                min_idx = j

        arr[i], arr[min_idx] = arr[min_idx], arr[i]

    return arr

Insertion Sort: Insertion sort is a simple sorting algorithm that builds the final sorted array one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. Here’s an example implementation in Python:

def insertion_sort(arr):

    n = len(arr)

    for i in range(1, n):

        key = arr[i]

        j = i-1

        while j >= 0 and key < arr[j]:

            arr[j+1] = arr[j]

            j -= 1

        arr[j+1] = key

    return arr

Merge Sort: Merge sort is a divide-and-conquer algorithm that works by recursively dividing the input array into smaller subarrays, sorting them, and then merging them back together. Here’s an example implementation in Python:

def merge_sort(arr):

    if len(arr) > 1:

        mid = len(arr)//2

        left_arr = arr[:mid]

        right_arr = arr[mid:]

        merge_sort(left_arr)

        merge_sort(right_arr)

        i = j = k = 0

        while i < len(left_arr) and j < len(right_arr):

            if left_arr[i] < right_arr[j]:

                arr[k] = left_arr[i]

                i += 1

            else:

                arr[k] = right_arr[j]

                j += 1

            k += 1

        while i < len(left_arr):

            arr[k] = left_arr[i]

            i += 1

            k += 1

        while j < len(right_arr):

            arr[k] = right_arr[j]

            j += 1

            k += 1

    return arr

Quick Sort: Quick sort is a divide-and-conquer algorithm that works by selecting a pivot element from the array and partitioning the other elements into two sub-arrays, according to whether they are less than or greater than the pivot. Here’s an example implementation in Python:

def quick_sort(arr):

    if len(arr) <= 1:

        return arr

The Sieve of Eratosthenes is an algorithm for finding all the prime numbers in a range of numbers up to a given limit. The algorithm works by iteratively marking as composite (i.e., not prime) the multiples of each prime, starting with the multiples of 2. Here’s an example implementation in Python:

def sieve_of_eratosthenes(n):

    # Create a boolean array “prime[0..n]” and initialize

    # all entries it as true. A value in prime[i] will

    # finally be false if i is Not a prime, else true.

    prime = [True for i in range(n+1)]

    p = 2

    while p*p <= n:

        # If prime[p] is not changed, then it is a prime

        if prime[p] == True:

            # Update all multiples of p

            for i in range(p*p, n+1, p):

                prime[i] = False

        p += 1

    # Print all prime numbers

    for p in range(2, n+1):

        if prime[p]:

            print(p, end=” “)

This function takes a single argument n, which is the upper limit of the range of numbers to search for primes. The function creates a boolean array prime of length n+1, initializes all entries to True, and then iterates through the array starting at p=2. For each prime number p, the function marks all multiples of p as composite by setting their corresponding entries in prime to False. Finally, the function prints all prime numbers by iterating through the array and printing the indices of all True entries (excluding 0 and 1).