fix bugs

Author: lighting9999

Timetable_Operations.py

@@ -1,52 +1,180 @@
-##Clock in pt2thon##
-
-t1 = input("Init schedule : ")  # first schedule
-HH1 = int(t1[0] + t1[1])
-MM1 = int(t1[3] + t1[4])
-SS1 = int(t1[6] + t1[7])
-
-t2 = input("Final schedule : ")  # second schedule
-HH2 = int(t2[0] + t2[1])
-MM2 = int(t2[3] + t2[4])
-SS2 = int(t2[6] + t2[7])
-
-tt1 = (HH1 * 3600) + (MM1 * 60) + SS1  # total schedule 1
-tt2 = (HH2 * 3600) + (MM2 * 60) + SS2  # total schedule 2
-tt3 = tt2 - tt1  # difference between tt2 e tt1
-
-# Part Math
-if tt3 < 0:
-    # If the difference between tt2 e tt1 for negative :
-
-    a = 86400 - tt1  # 86400 is seconds in 1 day;
-    a2 = a + tt2  # a2 is the difference between 1 day e the <hours var>;
-    Ht = a2 // 3600  # Ht is hours calculated;
-
-    a = a2 % 3600  # Convert 'a' in seconds;
-    Mt = a // 60  # Mt is minutes calculated;
-    St = a % 60  # St is seconds calculated;
-
-else:
-    # If the difference between tt2 e tt1 for positive :
-
-    Ht = tt3 // 3600  # Ht is hours calculated;
-    z = tt3 % 3600  # 'z' is tt3 converting in hours by seconds
-
-    Mt = z // 60  # Mt is minutes calculated;
-    St = tt3 % 60  # St is seconds calculated;
-
-# special condition below :
-if Ht < 10:
-    h = "0" + str(Ht)
-    Ht = h
-if Mt < 10:
-    m = "0" + str(Mt)
-    Mt = m
-if St < 10:
-    s = "0" + str(St)
-    St = s
-# add '0' to the empty spaces (caused by previous operations) in the final result!
-
-print(
-    "final result is :", str(Ht) + ":" + str(Mt) + ":" + str(St)
-)  # final result (formatted in clock)
+"""Clock Time Difference Calculator
+
+Calculates the time difference between two 24-hour formatted times (HH:MM:SS)
+and returns the result in the same HH:MM:SS format. Handles cases where the
+second time is earlier than the first (crosses midnight).
+"""
+
+import sys
+
+
+def parse_time(time_str: str) -> tuple[int, int, int]:
+    """Parse a time string in HH:MM:SS format into hours, minutes, seconds.
+
+    Args:
+        time_str: Time string in "HH:MM:SS" format.
+
+    Returns:
+        Tuple containing (hours, minutes, seconds).
+
+    Raises:
+        ValueError: If input format is invalid or values are out of range.
+    """
+    # Validate string structure
+    if not isinstance(time_str, str):
+        raise ValueError("Time must be a string")
+
+    if len(time_str) != 8:
+        raise ValueError(f"Invalid time length: '{time_str}' (expected 8 characters)")
+
+    if time_str[2] != ":" or time_str[5] != ":":
+        raise ValueError(f"Invalid format: '{time_str}' (use HH:MM:SS)")
+
+    # Extract and validate components
+    try:
+        hours = int(time_str[0:2])
+        minutes = int(time_str[3:5])
+        seconds = int(time_str[6:8])
+    except ValueError as e:
+        raise ValueError(f"Non-numeric components in '{time_str}': {e}") from e
+
+    # Validate value ranges
+    if not (0 <= hours < 24):
+        raise ValueError(f"Hours out of range (0-23): {hours}")
+    if not (0 <= minutes < 60):
+        raise ValueError(f"Minutes out of range (0-59): {minutes}")
+    if not (0 <= seconds < 60):
+        raise ValueError(f"Seconds out of range (0-59): {seconds}")
+
+    return hours, minutes, seconds
+
+
+def time_to_seconds(hours: int, minutes: int, seconds: int) -> int:
+    """Convert hours, minutes, seconds to total seconds since midnight.
+
+    Args:
+        hours: Hours (0-23)
+        minutes: Minutes (0-59)
+        seconds: Seconds (0-59)
+
+    Returns:
+        Total seconds (0-86399).
+    """
+    # Double-check input ranges (defensive programming)
+    if not (0 <= hours < 24):
+        raise ValueError(f"Invalid hours: {hours} (must be 0-23)")
+    if not (0 <= minutes < 60):
+        raise ValueError(f"Invalid minutes: {minutes} (must be 0-59)")
+    if not (0 <= seconds < 60):
+        raise ValueError(f"Invalid seconds: {seconds} (must be 0-59)")
+
+    return hours * 3600 + minutes * 60 + seconds
+
+
+def seconds_to_time(total_seconds: int) -> tuple[int, int, int]:
+    """Convert total seconds to hours, minutes, seconds.
+
+    Args:
+        total_seconds: Total seconds (handles negative values and large numbers).
+
+    Returns:
+        Tuple containing (hours, minutes, seconds) normalized to 0-23:59:59.
+    """
+    # Handle negative values by adding full days until positive
+    if total_seconds < 0:
+        days_to_add = (-total_seconds // 86400) + 1
+        total_seconds += days_to_add * 86400
+
+    # Normalize to within a single day (0-86399 seconds)
+    total_seconds %= 86400
+
+    hours = total_seconds // 3600
+    remaining = total_seconds % 3600
+    minutes = remaining // 60
+    seconds = remaining % 60
+
+    return hours, minutes, seconds
+
+
+def format_time(hours: int, minutes: int, seconds: int) -> str:
+    """Format hours, minutes, seconds into HH:MM:SS string.
+
+    Args:
+        hours: Hours (0-23)
+        minutes: Minutes (0-59)
+        seconds: Seconds (0-59)
+
+    Returns:
+        Formatted time string with leading zeros where necessary.
+    """
+    # Final validation before formatting
+    if not (0 <= hours < 24):
+        raise ValueError(f"Invalid hours for formatting: {hours}")
+    if not (0 <= minutes < 60):
+        raise ValueError(f"Invalid minutes for formatting: {minutes}")
+    if not (0 <= seconds < 60):
+        raise ValueError(f"Invalid seconds for formatting: {seconds}")
+
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+
+def calculate_time_difference(t1: str, t2: str) -> str:
+    """Calculate the time difference between two times (t2 - t1).
+
+    Args:
+        t1: Start time in HH:MM:SS format.
+        t2: End time in HH:MM:SS format.
+
+    Returns:
+        Time difference in HH:MM:SS format.
+    """
+    # Validate input isn't empty
+    if not t1.strip():
+        raise ValueError("Initial time cannot be empty")
+    if not t2.strip():
+        raise ValueError("Final time cannot be empty")
+
+    # Parse input times with detailed error context
+    try:
+        h1, m1, s1 = parse_time(t1)
+    except ValueError as e:
+        raise ValueError(f"Invalid initial time: {e}") from e
+
+    try:
+        h2, m2, s2 = parse_time(t2)
+    except ValueError as e:
+        raise ValueError(f"Invalid final time: {e}") from e
+
+    # Convert to total seconds with range checks
+    sec1 = time_to_seconds(h1, m1, s1)
+    sec2 = time_to_seconds(h2, m2, s2)
+
+    # Calculate difference (handle midnight crossing)
+    diff_seconds = sec2 - sec1
+
+    # Convert back to hours, minutes, seconds with normalization
+    h_diff, m_diff, s_diff = seconds_to_time(diff_seconds)
+
+    # Format and return result
+    return format_time(h_diff, m_diff, s_diff)
+
+
+def main() -> None:
+    """Main function to handle user input and display results."""
+    try:
+        t1 = input("Initial schedule (HH:MM:SS): ").strip()
+        t2 = input("Final schedule (HH:MM:SS): ").strip()
+
+        result = calculate_time_difference(t1, t2)
+        print(f"Final result is: {result}")
+
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

To find the largest number between 3 numbers.py

@@ -1,6 +1,81 @@
-# Python program to find the largest number among the three input numbers
+"""Find the Largest Number Among Three Inputs
 
-a = []
-for i in range(3):
-    a.append(int(input()))
-print("The largest among three numbers is:", max(a))
+This program takes three numeric inputs from the user and determines
+the largest number using a straightforward comparison approach.
+"""
+
+
+def get_valid_number(input_prompt: str) -> float:
+    """Prompt the user for a number and validate the input.
+
+    Args:
+        input_prompt: String to display when requesting input
+
+    Returns:
+        Validated numeric value (integer or float)
+
+    Raises:
+        ValueError: If input cannot be converted to a number
+    """
+    while True:
+        user_input = input(input_prompt).strip()
+        try:
+            return float(user_input)
+        except ValueError:
+            print(f"Error: '{user_input}' is not a valid number. Please try again.")
+
+
+def get_three_numbers() -> list[float]:
+    """Collect three valid numbers from the user.
+
+    Returns:
+        List containing three numeric values
+    """
+    numbers: list[float] = []
+    for i in range(3):
+        num = get_valid_number(f"Enter number {i + 1}: ")
+        numbers.append(num)
+    return numbers
+
+
+def find_largest(numbers: list[int | float]) -> int | float:
+    """Determine the largest number in a list of three numbers.
+
+    Args:
+        numbers: List containing exactly three numeric values
+
+    Returns:
+        The largest value in the list
+
+    Raises:
+        ValueError: If the input list does not contain exactly three numbers
+        TypeError: If any element in the list is not numeric
+    """
+    # Validate input list
+    if len(numbers) != 3:
+        raise ValueError(f"Expected 3 numbers, got {len(numbers)}")
+
+    for i, num in enumerate(numbers):
+        if not isinstance(num, (int, float)):
+            raise TypeError(f"Element {i + 1} is not a number: {type(num).__name__}")
+
+    return max(numbers)
+
+
+def main() -> None:
+    """Main function to coordinate input collection and result display."""
+    print("Find the largest number among three inputs\n")
+
+    try:
+        numbers = get_three_numbers()
+        largest = find_largest(numbers)
+        print(f"\nThe largest among the three numbers is: {largest}")
+    except (ValueError, TypeError) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    import sys  # Import here to avoid unused import in module mode
+
+    main()

tic_tak_toe.py

@@ -7,7 +7,7 @@
 
 import random
 import time
-from typing import List, Tuple
+
 import numpy as np
 
 
@@ -20,7 +20,7 @@ def create_board() -> np.ndarray:
     return np.array([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
 
 
-def possibilities(board: np.ndarray) -> List[Tuple[int, int]]:
+def possibilities(board: np.ndarray) -> list[tuple[int, int]]:
     """Find all empty positions on the board.
 
     Args:
@@ -29,7 +29,7 @@ def possibilities(board: np.ndarray) -> List[Tuple[int, int]]:
     Returns:
         List of (row, column) tuples where the board has a zero (empty).
     """
-    empty_positions: List[Tuple[int, int]] = []
+    empty_positions: list[tuple[int, int]] = []
     for row in range(len(board)):
         for col in range(len(board[row])):
             if board[row, col] == 0: