Python Programming

num = int(input("Enter a number: "))
if (num % 2) == 0:
    print(f"{num} is an Even number")
else:
    print(f"{num} is an Odd number")

num = int(input("Enter a number: "))
if num > 1:
    for i in range(2, int(num**0.5) + 1):
        if (num % i) == 0:
            print(f"{num} is not a prime number")
            break
    else:
        print(f"{num} is a prime number")
else:
    print(f"{num} is not a prime number")

n = int(input("Enter any number: "))
fact = 1
if n < 0:
    print("Factorial does not exist for negative numbers")
elif n == 0:
    print("The factorial of 0 is 1")
else:
    for i in range(1, n + 1):
        fact = fact * i
    print(f"The factorial of {n} is {fact}")

text = input("Enter any string: ")
# Remove spaces and convert to lowercase for accurate check
clean_text = text.replace(" ", "").lower()
if clean_text == clean_text[::-1]:
    print(f'"{text}" is a palindrome')
else:
    print(f'"{text}" is not a palindrome')

n = int(input("Enter any number: "))
if n < 1:
    print("Please enter a positive number")
else:
    sum_val = (n * (n + 1)) // 2
    print(f"Sum of first {n} natural numbers is {sum_val}")

n = int(input("Enter the number of terms: "))
first, second = 0, 1
if n <= 0:
    print("Please enter a positive integer")
elif n == 1:
    print("Fibonacci sequence:", first)
else:
    print("Fibonacci sequence:")
    for _ in range(n):
        print(first, end=" ")
        next_term = first + second
        first = second
        second = next_term

n = int(input("Enter any value: "))
reverse = 0
while n != 0:
    digit = n % 10
    reverse = reverse * 10 + digit
    n //= 10
print(f"The reverse of the number is {reverse}")

import math
x = int(input("Enter the first number: "))
y = int(input("Enter the second number: "))
print(f"GCD of the two numbers is: {math.gcd(x, y)}")

num_str = input("Enter any number: ")
order = len(num_str)
n = int(num_str)
temp = n
sum_val = 0
while temp > 0:
    digit = temp % 10
    sum_val += digit ** order
    temp //= 10
if n == sum_val:
    print(f"{n} is an Armstrong number")
else:
    print(f"{n} is not an Armstrong number")

def linear_search(items, key):
    for i, item in enumerate(items):
        if item == key:
            return i
    return -1

my_list = [1, 3, 5, 4, 7, 9]
search_key = 7
result = linear_search(my_list, search_key)
if result == -1:
    print("Element not found")
else:
    print(f"Element found at index: {result}")

def binary_search(sorted_list, key):
    low = 0
    high = len(sorted_list) - 1
    while low <= high:
        mid = (high + low) // 2
        if sorted_list[mid] < key:
            low = mid + 1
        elif sorted_list[mid] > key:
            high = mid - 1
        else:
            return mid
    return -1

my_list = [12, 24, 32, 39, 45, 50, 54]
search_key = 45
result = binary_search(my_list, search_key)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in the list")

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

my_array = [2, 1, 10, 23, 5]
bubble_sort(my_array)
print("Sorted array is:", my_array)

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]
        merge_sort(left_half)
        merge_sort(right_half)
        i = j = k = 0
        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1
        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1
        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

my_array = [12, 11, 13, 5, 6, 7]
merge_sort(my_array)
print("Sorted array is:", my_array)

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

my_array = [7, 2, 1, 6]
insertion_sort(my_array)
print("Sorted array is:", my_array)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

def quick_sort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quick_sort(arr, low, pi - 1)
        quick_sort(arr, pi + 1, high)

data = [1, 7, 4, 1, 10, 9, -2]
quick_sort(data, 0, len(data) - 1)
print("Sorted array is:", data)

def selection_sort(arr):
    size = len(arr)
    for i in range(size):
        min_idx = i
        for j in range(i + 1, size):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

data = [7, 2, 1, 6]
selection_sort(data)
print("Sorted array is:", data)

def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2
    if l < n and arr[i] < arr[l]:
        largest = l
    if r < n and arr[largest] < arr[r]:
        largest = r
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)

arr = [12, 11, 13, 5, 6, 7]
heap_sort(arr)
print("Sorted array is:", arr)

stack = []
# Push items onto the stack
stack.append('A')
stack.append('B')
stack.append('C')
print("Initial stack:", stack)
# Pop items from the stack
print("Popped item:", stack.pop())
print("Popped item:", stack.pop())
print("Stack after popping:", stack)

from collections import deque
queue = deque()
# Enqueue items
queue.append('A')
queue.append('B')
queue.append('C')
print("Initial queue:", queue)
# Dequeue items
print("Dequeued item:", queue.popleft())
print("Dequeued item:", queue.popleft())
print("Queue after dequeuing:", queue)