Questions

# Python code
def calculate_sum(input_list):
    return sum(input_list)

my_list = [1, 2, 3, 4, 5]
result = calculate_sum(my_list)

print("Sum of the elements in the list:", result)

# Python code
def find_max_min(lst):
    if not lst:
        return None, None  # Handle an empty list

    max_value = lst[0]
    min_value = lst[0]

    for item in lst:
        if item > max_value:
            max_value = item
        elif item < min_value:
            min_value = item

    return max_value, min_value

# Example usage:
my_list = [5, 2, 9, 1, 7, 3]
max_val, min_val = find_max_min(my_list)
print("Maximum value:", max_val)
print("Minimum value:", min_val)

# Python code
def reverse_list(lst):
    reversed_lst = []
    for item in lst:
        reversed_lst.insert(0, item)
    return reversed_lst

# Example usage:
my_list = [1, 2, 3, 4, 5]
reversed_list = reverse_list(my_list)
print(reversed_list)

# Python code
original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_numbers = [x for x in original_list if x % 2 == 0]

print(even_numbers)

# Python code
def filter_divisible_elements(lst, divisor):
    filtered_list = [x for x in lst if x % divisor != 0]
    return filtered_list

# Example usage:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
divisor = 2
filtered_result = filter_divisible_elements(my_list, divisor)
print(filtered_result)

# Python code
def flatten_list(list_of_lists):
    flattened_list = [item for sublist in list_of_lists for item in sublist]
    return flattened_list

# Example usage:
list_of_lists = [[1, 2], [3, 4], [5, 6]]
flattened_result = flatten_list(list_of_lists)
print(flattened_result)

# Python code
original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
sub_list = original_list[2:6]
print(sub_list)  # Output: [3, 4, 5, 6]

original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
reversed_sub_list = original_list[2:6][::-1]
print(reversed_sub_list)  # Output: [6, 5, 4, 3]

original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
elements_in_range = original_list[2:6]
print(elements_in_range)  # Output: [3, 4, 5, 6

# Python code
def sort_list(input_list, ascending=True):
    # Sort the list in ascending order by default
    sorted_list = sorted(input_list) if ascending else sorted(input_list, reverse=True)
    return sorted_list

# Example usage:
my_list = [5, 2, 9, 1, 7, 3]

ascending_result = sort_list(my_list, ascending=True)
descending_result = sort_list(my_list, ascending=False)

print("Ascending order:", ascending_result)
print("Descending order:", descending_result)

# Python code
def remove_duplicates(lst):
    unique_list = []
    for item in lst:
        if item not in unique_list:
            unique_list.append(item)
    return unique_list

# Example usage:
my_list = [1, 2, 2, 3, 4, 4, 5, 6, 6]
result = remove_duplicates(my_list)
print(result)

# Python code
def find_common_elements(list1, list2):
    set1 = set(list1)
    set2 = set(list2)
    common_elements = list(set1.intersection(set2))
    return common_elements

# Example usage:
list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]
result = find_common_elements(list1, list2)
print(result)

# Python code
def count_occurrences(lst, target):
    count = 0
    for item in lst:
        if item == target:
            count += 1
    return count
my_list = [1, 2, 2, 3, 4, 2, 5, 2]
element_to_count = 2
result = count_occurrences(my_list, element_to_count)
print(f"The element {element_to_count} appears {result} times in the list."

# Python code
def split_list(input_list, sublist_size):
    if sublist_size <= 0:
        return "Sublist size must be greater than 0."
    
    sublists = []
    for i in range(0, len(input_list), sublist_size):
        sublist = input_list[i:i + sublist_size]
        sublists.append(sublist)
    return sublists
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
sublist_size = 3

result = split_list(my_list, sublist_size)
print(result)

# Python code
def is_palindrome(input_list):
    reversed_list = input_list[::-1]
    return input_list == reversed_list
my_list = [1, 2, 3, 2, 1]
result = is_palindrome(my_list)
print(result)  # True

my_list = [1, 2, 3, 4, 5]
result = is_palindrome(my_list)
print(result)  # False

# Python code
def merge_sorted_lists(list1, list2):
    merged_list = []
    i = j = 0

    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            merged_list.append(list1[i])
            i += 1
        else:
            merged_list.append(list2[j])
            j += 1

    # If there are remaining elements in list1 or list2, add them to the merged list
    merged_list.extend(list1[i:])
    merged_list.extend(list2[j:])

    return merged_list
list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]

result = merge_sorted_lists(list1, list2)
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8]

# Python code
def find_median(input_list):
    sorted_list = sorted(input_list)
    n = len(sorted_list)
    
    if n % 2 == 1:  # Odd number of elements
        median = sorted_list[n // 2]
    else:  # Even number of elements
        middle1 = sorted_list[n // 2 - 1]
        middle2 = sorted_list[n // 2]
        median = (middle1 + middle2) / 2.0
    
    return median
my_list = [5, 2, 9, 1, 5, 6]
result = find_median(my_list)
print(result)  # 5.0

# Python code
import random

def shuffle_list(input_list):
    shuffled_list = input_list.copy()  # Create a copy to avoid modifying the original list
    random.shuffle(shuffled_list)
    return shuffled_list
my_list = [1, 2, 3, 4, 5]
shuffled = shuffle_list(my_list)
print(shuffled)

# Python code
def partition_list(input_list, condition):
    true_list = [x for x in input_list if condition(x)]
    false_list = [x for x in input_list if not condition(x)]
    return true_list, false_list
def is_even(x):
    return x % 2 == 0

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

even_numbers, odd_numbers = partition_list(my_list, is_even)

print("Even numbers:", even_numbers)
print("Odd numbers:", odd_numbers)

# Python code
def main():
    my_list = []  # Initialize an empty list

    while True:
        print("Current list:", my_list)
        print("Menu:")
        print("1. Add an element")
        print("2. Remove an element")
        print("3. Update an element")
        print("4. Exit")
        
        choice = input("Enter your choice (1/2/3/4): ")

        if choice == '1':
            element = input("Enter the element to add: ")
            my_list.append(element)
            print(f"'{element}' has been added to the list.")

        elif choice == '2':
            element = input("Enter the element to remove: ")
            if element in my_list:
                my_list.remove(element)
                print(f"'{element}' has been removed from the list.")
            else:
                print(f"'{element}' not found in the list.")

        elif choice == '3':
            element = input("Enter the element to update: ")
            if element in my_list:
                index = my_list.index(element)
                new_element = input("Enter the new value: ")
                my_list[index] = new_element
                print(f"'{element}' has been updated to '{new_element}'.")
            else:
                print(f"'{element}' not found in the list.")

        elif choice == '4':
            print("Exiting the program.")
            break

        else:
            print("Invalid choice. Please enter a valid option (1/2/3/4).")

if __name__ == "__main__":
    main()