Question

Determine the Big-O value for the following functions.

The valid Big-O options are:

• 'O(1)'
• 'O(N)'
• 'O(LOG2(N))'
• 'O(N * LOG2(N))'
• 'O(N^2)'
• 'O(inf)' # This is Big-O of infinity

def function_one(list_):
    for pass_ in range(len(list_) - 1, 0, -1):
        for i in range(pass_):
            if list_[i] > list_[i+1]:
                temp = list_[i]
                list_[i] = list_[i+1]
                list_[i+1] = temp


def function_two(list_):
    if len(list_) > 1:
        midpoint_index = len(list_) // 2
        left_half = list_[:midpoint_index]
        right_half = list_[midpoint_index:]

        function_two(left_half)
        function_two(right_half)

        left_half_pos = 0
        right_half_pos = 0
        new_position = 0
        while left_half_pos < len(left_half) and right_half_pos < len(right_half):
            if left_half[left_half_pos] < right_half[right_half_pos]:
                list_[new_position] = left_half[left_half_pos]
                left_half_pos += 1
            else:
                list_[new_position] = right_half[right_half_pos]
                right_half_pos += 1

            new_position += 1

        # empty remaning items in left list
        while left_half_pos < len(left_half):
            list_[new_position] = left_half[left_half_pos]
            left_half_pos += 1
            new_position += 1

        # empty remaning items in right list
        while right_half_pos < len(right_half):
            list_[new_position]=right_half[right_half_pos]
            right_half_pos += 1
            new_position += 1


def function_three(x, max_):
    assert 0 < x < max_
    while x < max_:
        x *= 2


def function_four(x):
    for i in range(x):
        for j in range(x - i):
            for k in range(x - j):
                if i + j + k == 0:
                    break
            if i + j == 0:
                break
        if i == 0:
            break
    return x + 1

Answer 1

Big-O value for function:

1)_one(list_):
O(N^2) you can see that an outer loop that iterates through all the items in the input list and then a nested inner loop, which again iterates through all the items in the input list. The total number of steps performed is n * n, where n is the number of items in the input array.

2)_two(list_):

it's O(2^n), or exponential, since each function call calls itself twice unless it has been recursed n times

3)_three(x, max_):

It will be O(N) because it iterates through one loop.

4)_four(x)

O(inf) because it will never stop looping goes into infinity,

Happy Coding !!!

Comment down if you have queries over a answer!!!