PPL.py

"""Python Programming Lab (PPL) - an interactive menu of ten classic programming exercises.

Each exercise is presented the way a lab record is written up: Aim, Algorithm,
Program, Output and Result.
"""

from __future__ import annotations

import inspect
import os
import platform
import tempfile
import textwrap
from collections import Counter
from dataclasses import dataclass
from typing import Callable

import numpy as np


# --------------------------------------------------------------------------- #
# Shared input helpers (kept small and reused so every exercise validates the
# same way instead of repeating its own retry loop).
# --------------------------------------------------------------------------- #

def read_int(prompt: str) -> int:
    while True:
        try:
            return int(input(prompt))
        except ValueError:
            print('\n  Invalid input (e.g. 1 or 2 or 3)\n')


def read_int_list(prompt: str) -> list[int]:
    while True:
        try:
            return [int(value) for value in input(prompt).split()]
        except ValueError:
            print('\n  Invalid input (e.g. 1 2 3)\n')


def read_text(prompt: str) -> str:
    while True:
        text = input(prompt)
        if text.strip():
            return text
        print('\n  Invalid input (text cannot be empty)\n')


# --------------------------------------------------------------------------- #
# 1. Count the number of even/odd numbers in a given list.
# --------------------------------------------------------------------------- #

def count_odd_even() -> None:
    numbers = read_int_list('\nInput:\n\n  Enter the list (separated by spaces): ')
    odd = sum(1 for n in numbers if n % 2 != 0)
    even = len(numbers) - odd
    print(f'\nOutput:\n\n  Number of odd numbers: {odd}\n  Number of even numbers: {even}')


# --------------------------------------------------------------------------- #
# 2. Count the number of digits and letters in a given text.
# --------------------------------------------------------------------------- #

def count_digits_letters() -> None:
    text = read_text('\nInput:\n\n  Enter the text: ')
    digits = sum(1 for ch in text if ch.isdigit())
    letters = sum(1 for ch in text if ch.isalpha())
    print(f'\nOutput:\n\n  Number of digits: {digits}\n  Number of letters: {letters}')


# --------------------------------------------------------------------------- #
# 3. Validate a password.
# --------------------------------------------------------------------------- #

def check_password() -> None:
    rules: list[tuple[Callable[[str], bool], str]] = [
        (lambda s: any(ch.islower() for ch in s), 'At least 1 letter between [a-z]'),
        (lambda s: any(ch.isupper() for ch in s), 'At least 1 letter between [A-Z]'),
        (lambda s: any(ch.isdigit() for ch in s), 'At least 1 number between [0-9]'),
        (lambda s: any(ch in '$#@' for ch in s), 'At least 1 character from [$#@]'),
        (lambda s: len(s) >= 6, 'Minimum length 6 characters'),
        (lambda s: len(s) <= 16, 'Maximum length 16 characters'),
    ]
    while True:
        password = input('\nInput:\n\n  Enter the password: ')
        failed_rule = next((message for is_met, message in rules if not is_met(password)), None)
        if failed_rule is None:
            print('\nOutput:\n\n  Valid Password')
            return
        print(f'\nOutput:\n\n  Invalid Password ({failed_rule})')


# --------------------------------------------------------------------------- #
# 4. Sum and average of n integers, 0 to finish.
# --------------------------------------------------------------------------- #

def sum_and_average() -> None:
    total, count = 0, 0
    number = read_int('\nInput:\n\n  Enter the number (0 to finish): ')
    while number != 0:
        total += number
        count += 1
        number = read_int('  Enter the number (0 to finish): ')
    if count == 0:
        print('\nOutput:\n\n  Sum of the above numbers: 0\n  Average of the above numbers: 0')
    else:
        print(f'\nOutput:\n\n  Sum of the above numbers: {total}\n  Average of the above numbers: {total / count}')


# --------------------------------------------------------------------------- #
# 5. Count upper case and lower case letters in a string.
# --------------------------------------------------------------------------- #

def count_case() -> None:
    text = read_text('\nInput:\n\n  Enter the text: ')
    upper = sum(1 for ch in text if ch.isupper())
    lower = sum(1 for ch in text if ch.islower())
    print(f'\nOutput:\n\n  Number of upper case letters: {upper}\n  Number of lower case letters: {lower}')


# --------------------------------------------------------------------------- #
# 6. Fibonacci series using a while loop.
# --------------------------------------------------------------------------- #

def fibonacci_series() -> None:
    limit = read_int('\nInput:\n\n  Enter the number: ')
    series = []
    a, b = 0, 1
    while b <= limit:
        series.append(b)
        a, b = b, a + b
    print(f"\nOutput:\n\n  Fibonacci series: {', '.join(map(str, series))}")


# --------------------------------------------------------------------------- #
# 7. Factorial using recursion.
# --------------------------------------------------------------------------- #

def factorial() -> None:
    def factorial_of(n: int) -> int:
        return 1 if n <= 1 else n * factorial_of(n - 1)

    while True:
        number = read_int('\nInput:\n\n  Enter the number: ')
        if number < 0:
            print('\n  Invalid input (must be 0 or a positive number)\n')
            continue
        break
    print(f'\nOutput:\n\n  Factorial of {number} is: {factorial_of(number)}')


# --------------------------------------------------------------------------- #
# 8. Binary search.
# --------------------------------------------------------------------------- #

def binary_search() -> None:
    while True:
        numbers = read_int_list('\nInput:\n\n  Enter the list, sorted ascending (separated by spaces): ')
        if numbers == sorted(numbers):
            break
        print('\n  Invalid input (the list must be sorted in ascending order)\n')
    target = read_int('  Search: ')

    low, high, index = 0, len(numbers) - 1, -1
    while low <= high:
        mid = (low + high) // 2
        if numbers[mid] == target:
            index = mid
            break
        if target < numbers[mid]:
            high = mid - 1
        else:
            low = mid + 1

    if index != -1:
        print(f'\nOutput:\n\n  Number {target} is present at index {index} in the list')
    else:
        print(f'\nOutput:\n\n  Number {target} is not present in the list')


# --------------------------------------------------------------------------- #
# 9. Most frequent word in a text read from a file.
# --------------------------------------------------------------------------- #

def most_frequent_word() -> None:
    text = read_text('\nInput:\n\n  Write (to file): ')

    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as file:
        file.write(text)
        path = file.name
    try:
        with open(path, encoding='utf-8') as file:
            content = file.read()
    finally:
        os.remove(path)

    for punctuation in ',.!?;:':
        content = content.replace(punctuation, ' ')
    words = content.split()

    if not words:
        print('\nOutput:\n\n  No words found in the given text')
        return
    word, freq = Counter(words).most_common(1)[0]
    print(f"\nOutput:\n\n  Frequent word: '{word}' at {freq} times")


# --------------------------------------------------------------------------- #
# 10. Matrix addition, subtraction and (element-wise) multiplication.
# --------------------------------------------------------------------------- #

def matrix_operations() -> None:
    def read_matrix(rows: int, columns: int, label: str) -> np.ndarray:
        matrix = []
        for row_number in range(1, rows + 1):
            while True:
                row = read_int_list(f'  Enter row {row_number} of the {label} matrix (separated by spaces): ')
                if len(row) == columns:
                    matrix.append(row)
                    break
                print(f'\n  Invalid input (expected {columns} numbers)\n')
        return np.array(matrix)

    print('\nInput:\n')
    rows = read_int('  Enter the number of rows: ')
    columns = read_int('  Enter the number of columns: ')
    first = read_matrix(rows, columns, 'first')
    second = read_matrix(rows, columns, 'second')

    operations = {
        '1': ('addition', first + second),
        '2': ('subtraction', first - second),
        '3': ('multiplication (element-wise)', first * second),
    }
    while True:
        print('\n[1 - addition | 2 - subtraction | 3 - multiplication | e - exit]\n')
        choice = input('Select operation: ').strip().lower()
        if choice == 'e':
            break
        if choice in operations:
            name, result = operations[choice]
            print(f'\nOutput ({name}):\n')
            for row in result:
                print('  ' + ' '.join(map(str, row)))
        else:
            print('\nInvalid Input')


# --------------------------------------------------------------------------- #
# Exercise registry and menu.
# --------------------------------------------------------------------------- #

@dataclass(frozen=True)
class Exercise:
    aim: str
    algorithm: list[str]
    run: Callable[[], None]


EXERCISES: dict[int, Exercise] = {
    1: Exercise(
        aim='Write a Python program to count the number of even/odd numbers in a given list.',
        algorithm=[
            'Read a list of integers from the user.',
            'Initialise odd and even counters to 0.',
            'For each number, increment even if it is divisible by 2, else increment odd.',
            'Display the odd and even counts.',
        ],
        run=count_odd_even,
    ),
    2: Exercise(
        aim='Write a Python program to calculate the number of digits and letters in a given text.',
        algorithm=[
            'Read a text string from the user.',
            'Initialise digit and letter counters to 0.',
            'For each character, increment digits if it is a digit, or letters if it is alphabetic.',
            'Display the digit and letter counts.',
        ],
        run=count_digits_letters,
    ),
    3: Exercise(
        aim=(
            'Write a Python program to check the validity of a password validation:\n\n'
            '    a. At least 1 letter between [a-z] and 1 letter between [A-Z].\n\n'
            '    b. At least 1 number between [0-9].\n\n'
            '    c. At least 1 character from [$#@].\n\n'
            '    d. Minimum length 6 characters.\n\n'
            '    e. Maximum length 16 characters.'
        ),
        algorithm=[
            'Read a password string from the user.',
            'Check it contains a lower case letter, an upper case letter, a digit and one of [$#@].',
            'Check its length is between 6 and 16 characters.',
            'If every check passes, display "Valid Password".',
            'Otherwise, display which rule failed and ask for the password again.',
        ],
        run=check_password,
    ),
    4: Exercise(
        aim=(
            'Write a Python program to calculate the sum and average of n integer numbers '
            '(input from the user). Input 0 to finish.'
        ),
        algorithm=[
            'Initialise sum and count to 0.',
            'Repeatedly read an integer until the user enters 0.',
            'Add each non-zero number to the sum and increment the count.',
            'If count is 0, the sum and average are both 0; otherwise average = sum / count.',
            'Display the sum and the average.',
        ],
        run=sum_and_average,
    ),
    5: Exercise(
        aim=(
            'Write a Python function that accepts a string and calculate the number of upper '
            'case letters and lower case letters.'
        ),
        algorithm=[
            'Read a text string from the user.',
            'Initialise upper and lower counters to 0.',
            'For each character, increment upper if it is upper case, or lower if it is lower case.',
            'Display the upper case and lower case counts.',
        ],
        run=count_case,
    ),
    6: Exercise(
        aim='Write a Python program to calculate the Fibonacci series using while loop.',
        algorithm=[
            'Read a limiting number n from the user.',
            'Initialise the series with a = 0 and b = 1.',
            'While b is less than or equal to n, append b to the series and update a, b = b, a + b.',
            'Display the series.',
        ],
        run=fibonacci_series,
    ),
    7: Exercise(
        aim='Write a python program to find the factorial of a given number using recursion function.',
        algorithm=[
            'Read a non-negative integer n from the user.',
            'Define a recursive function that returns 1 when n is 0 or 1.',
            'Otherwise, the function returns n multiplied by the factorial of n - 1.',
            'Display the factorial of n.',
        ],
        run=factorial,
    ),
    8: Exercise(
        aim='Write a python program to implement the binary search algorithm.',
        algorithm=[
            'Read a list sorted in ascending order and a target value from the user.',
            'Set low to 0 and high to the last index of the list.',
            'While low <= high, compute mid = (low + high) // 2.',
            'If the middle element equals the target, the search succeeds at index mid.',
            'If the target is smaller, search the left half (high = mid - 1); otherwise search the right half (low = mid + 1).',
            'If the loop ends with no match, the value is not present in the list.',
        ],
        run=binary_search,
    ),
    9: Exercise(
        aim='Write a python program to find the most frequent words in a text read from a file.',
        algorithm=[
            'Read a line of text from the user and write it to a temporary file.',
            'Read the text back from that file.',
            'Replace punctuation with spaces and split the text into words.',
            'Count how many times each word occurs.',
            'Display the word with the highest count.',
        ],
        run=most_frequent_word,
    ),
    10: Exercise(
        aim='Write a python program to perform the matrix addition, subtraction and multiplication.',
        algorithm=[
            'Read the number of rows and columns, then read both matrices of that size.',
            'Repeatedly ask the user to choose addition, subtraction, element-wise multiplication, or exit.',
            'Compute and display the result of the chosen operation.',
        ],
        run=matrix_operations,
    ),
}


def render_program(func: Callable[[], None]) -> str:
    return textwrap.indent(inspect.getsource(func), '  ')


def list_of_programs() -> str:
    return '\n\n'.join(f'{number}. {exercise.aim}' for number, exercise in sorted(EXERCISES.items()))


def run_exercise(number: int) -> None:
    exercise = EXERCISES[number]
    print(f'\nAim:\n\n  {exercise.aim}')
    print('\nAlgorithm:\n')
    for step, description in enumerate(exercise.algorithm, start=1):
        print(f'  {step}. {description}')
    print(f'\nProgram:\n\n{render_program(exercise.run)}')
    exercise.run()
    print('\nResult:\n\n  Thus the above code was executed successfully.')


def clear_screen() -> None:
    os.system('cls' if platform.system() == 'Windows' else 'clear')
    if platform.system() == 'Windows':
        os.system('title Python Programming Lab')


def main() -> None:
    clear_screen()
    print('\nWelcome to Python Programming Lab!')
    while True:
        print('\n[lop - list of programs | 1 to 10 - number of programs | cls - clear screen | e - exit]')
        command = input('\nEnter your command: ').strip().lower()
        if command == 'lop':
            print(f'\n{list_of_programs()}')
        elif command == 'e':
            break
        elif command == 'cls':
            clear_screen()
            print('\nWelcome to Python Programming Lab!')
        elif command.isdigit() and int(command) in EXERCISES:
            run_exercise(int(command))
        else:
            print('\nInvalid command (expected: lop, 1-10, cls, or e)')


if __name__ == '__main__':
    main()