Merge branch 'main' into theme-selector

Author: steam-bell-92

math/Heap-Sort/Heap-Sort.py

@@ -0,0 +1,113 @@
+import sys
+import os
+
+# Add project root to sys.path
+if "__file__" in globals():
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+else:
+    sys.path.append(os.path.abspath(os.getcwd()))
+
+from utils.validation import get_choice, get_int_list
+
+
+def _sift_down(arr: list[int], start: int, end: int, reverse: bool) -> None:
+    """Restores the heap property for the subtree rooted at `start`.
+
+    Args:
+        arr: The list being heapified (mutated in place).
+        start: Index of the subtree root to sift down from.
+        end: Last valid index of the active heap region.
+        reverse: If True, maintains a min-heap (for descending sort).
+                 Otherwise, maintains a max-heap (for ascending sort).
+    """
+    root = start
+
+    while True:
+        child = 2 * root + 1
+        if child > end:
+            break
+
+        # Pick the child that should be closer to the root
+        if child + 1 <= end:
+            if not reverse and arr[child] < arr[child + 1]:
+                child += 1
+            elif reverse and arr[child] > arr[child + 1]:
+                child += 1
+
+        should_swap = (not reverse and arr[root] < arr[child]) or (reverse and arr[root] > arr[child])
+
+        if should_swap:
+            arr[root], arr[child] = arr[child], arr[root]
+            root = child
+        else:
+            break
+
+
+def heap_sort(arr: list[int], reverse: bool = False) -> list[int]:
+    """Sorts a list of integers using the Heap Sort algorithm.
+
+    Args:
+        arr: The list of integers to sort.
+        reverse: If True, sorts in descending order. Otherwise, ascending.
+
+    Returns:
+        A new sorted list.
+    """
+    result = arr.copy()
+    n = len(result)
+
+    # Phase 1: Build a max-heap (ascending) or min-heap (descending)
+    for start in range(n // 2 - 1, -1, -1):
+        _sift_down(result, start, n - 1, reverse)
+
+    # Phase 2: Repeatedly extract the root and shrink the heap
+    for end in range(n - 1, 0, -1):
+        result[0], result[end] = result[end], result[0]
+        _sift_down(result, 0, end - 1, reverse)
+
+    return result
+
+
+def main() -> None:
+    print("=" * 50)
+    print("🏔️  HEAP SORT INTERACTIVE TOOL 🏔️")
+    print("=" * 50)
+    print("Sort a list of numbers in Ascending or Descending order.\n")
+
+    while True:
+        print("=" * 50)
+
+        arr = get_int_list(
+            prompt="➡️  Enter numbers to sort separated by spaces (e.g., 64 34 25): ",
+            error_empty="❌ Error: Input cannot be empty!",
+            error_invalid="❌ Error: Please enter valid integers only."
+        )
+
+        print("\nChoose sorting order:")
+        print("1️⃣  Ascending")
+        print("2️⃣  Descending")
+
+        order_choice = get_choice(
+            prompt="🎯 Enter your choice (1 or 2): ",
+            choices=["1", "2"],
+            error_invalid="❌ Invalid sorting choice! Please select 1 or 2."
+        )
+
+        reverse = (order_choice == "2")
+
+        sorted_arr = heap_sort(arr, reverse)
+
+        print(f"\n📊 Original list: {arr}")
+        if reverse:
+            print(f"✅ Sorted list (Descending): {sorted_arr}")
+        else:
+            print(f"✅ Sorted list (Ascending): {sorted_arr}")
+
+        again = input("\n🔄 Do you want to sort another list? (y/n): ").strip().lower()
+        if again != 'y':
+            print("\n👋 Thanks for using Heap Sort Tool! Goodbye!\n")
+            break
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -9,11 +9,11 @@ python = ">=3.10,<3.13"
 pygame = "2.6.1"
 numpy = "1.26.4"
 matplotlib = "3.8.3"
-pillow = "12.2.0"
+pillow = "12.3.0"
 requests = "2.34.2"
 markdown2 = "2.5.5"
 reportlab = "4.5.1"
-nltk = "3.9.1"
+nltk = "3.10.0"
 
 
 [tool.poetry.group.dev.dependencies]

requirements.txt

@@ -16,7 +16,7 @@ markdown2==2.5.5
 reportlab==4.5.1
 
 # NLP dependencies
-nltk==3.9.1
+nltk==3.10.0
 pyenchant==3.3.0
 
 # TUI dependencies

tests/test_heap_sort.py

@@ -0,0 +1,77 @@
+import unittest
+from unittest.mock import patch
+import io
+import os
+import importlib.util
+
+# Absolute path to Heap-Sort.py
+file_path = os.path.join(
+    os.path.dirname(__file__), "..",
+    "math", "Heap-Sort", "Heap-Sort.py"
+)
+file_path = os.path.abspath(file_path)
+
+# Load module dynamically
+spec = importlib.util.spec_from_file_location("heap_sort_module", file_path)
+heap_sort_module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(heap_sort_module)
+
+heap_sort = heap_sort_module.heap_sort
+main = heap_sort_module.main
+
+
+class TestHeapSort(unittest.TestCase):
+
+    def test_heap_sort_ascending(self):
+        self.assertEqual(heap_sort([64, 34, 25, 12, 22, 11, 90]), [11, 12, 22, 25, 34, 64, 90])
+        self.assertEqual(heap_sort([5, 1, 4, 2, 8]), [1, 2, 4, 5, 8])
+
+    def test_heap_sort_descending(self):
+        self.assertEqual(heap_sort([64, 34, 25, 12, 22, 11, 90], reverse=True), [90, 64, 34, 25, 22, 12, 11])
+        self.assertEqual(heap_sort([5, 1, 4, 2, 8], reverse=True), [8, 5, 4, 2, 1])
+
+    def test_heap_sort_empty_and_single_item(self):
+        self.assertEqual(heap_sort([]), [])
+        self.assertEqual(heap_sort([42]), [42])
+
+    def test_heap_sort_negative_integers(self):
+        self.assertEqual(heap_sort([-5, -1, -10, 0, 5]), [-10, -5, -1, 0, 5])
+        self.assertEqual(heap_sort([-5, -1, -10, 0, 5], reverse=True), [5, 0, -1, -5, -10])
+
+    def test_heap_sort_already_sorted(self):
+        self.assertEqual(heap_sort([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5])
+        self.assertEqual(heap_sort([5, 4, 3, 2, 1], reverse=True), [5, 4, 3, 2, 1])
+
+    def test_heap_sort_with_duplicates(self):
+        self.assertEqual(heap_sort([5, 3, 8, 3, 9, 1, 5]), [1, 3, 3, 5, 5, 8, 9])
+
+    def test_heap_sort_does_not_mutate_original(self):
+        original = [5, 3, 1, 4, 2]
+        original_copy = original.copy()
+        heap_sort(original)
+        self.assertEqual(original, original_copy)
+
+    @patch('builtins.input')
+    @patch('sys.stdout', new_callable=io.StringIO)
+    def test_main_flow_ascending(self, mock_stdout, mock_input):
+        mock_input.side_effect = ["64 34 25", "1", "n"]
+        main()
+        output = mock_stdout.getvalue()
+        self.assertIn("Original list: [64, 34, 25]", output)
+        self.assertIn("Sorted list (Ascending): [25, 34, 64]", output)
+
+    @patch('builtins.input')
+    @patch('sys.stdout', new_callable=io.StringIO)
+    def test_main_flow_invalid_inputs(self, mock_stdout, mock_input):
+        mock_input.side_effect = ["", "64 abc 25", "64 34 25", "3", "64 34 25", "1", "y", "12 11", "2", "n"]
+        main()
+        output = mock_stdout.getvalue()
+        self.assertIn("Error: Input cannot be empty!", output)
+        self.assertIn("Error: Please enter valid integers only.", output)
+        self.assertIn("Invalid sorting choice! Please select 1 or 2.", output)
+        self.assertIn("Sorted list (Ascending): [25, 34, 64]", output)
+        self.assertIn("Sorted list (Descending): [12, 11]", output)
+
+
+if __name__ == '__main__':
+    unittest.main()

web-app/css/styles.css

@@ -1051,6 +1051,129 @@ main>.hero-section:has(.hero-code-snippets) {
   padding: 0 1rem;
 }
 
+/* ==========================================================
+   FIX ISSUE #1703
+   Homepage Category Navigation
+========================================================== */
+
+.hero-category-nav{
+
+    display:flex;
+
+    justify-content:center;
+
+    align-items:center;
+
+    gap:18px;
+
+    width:fit-content;
+
+    margin:0 auto 42px;
+
+    padding:12px 24px;
+
+    background:rgba(255,255,255,.72);
+
+    backdrop-filter:blur(18px);
+
+    border:1px solid rgba(255,255,255,.35);
+
+    border-radius:18px;
+
+    box-shadow:0 8px 30px rgba(0,0,0,.08);
+
+}
+
+.hero-nav-btn{
+
+    display:flex;
+
+    align-items:center;
+
+    gap:8px;
+
+    background:none;
+
+    border:none;
+
+    cursor:pointer;
+
+    padding:10px 4px;
+
+    position:relative;
+
+    color:var(--text-secondary);
+
+    font-size:15px;
+
+    font-weight:600;
+
+    transition:.25s;
+
+}
+
+.hero-nav-btn i{
+
+    font-size:14px;
+
+}
+
+.hero-nav-btn:hover{
+
+    color:var(--accent);
+
+}
+
+.hero-nav-btn.active{
+
+    color:var(--accent);
+
+}
+
+.hero-nav-btn::after{
+
+    content:"";
+
+    position:absolute;
+
+    left:0;
+
+    bottom:-8px;
+
+    width:100%;
+
+    height:3px;
+
+    background:var(--accent);
+
+    border-radius:999px;
+
+    transform:scaleX(0);
+
+    transition:.25s;
+
+}
+
+.hero-nav-btn.active::after{
+
+    transform:scaleX(1);
+
+}
+
+html[data-theme="dark"] .hero-category-nav{
+
+    background:rgba(28,28,28,.65);
+
+    border:1px solid rgba(255,255,255,.08);
+
+    box-shadow:0 10px 35px rgba(0,0,0,.45);
+
+}
+
+
+
+
+
 /* ── Hero Big Logo & Brand Title ────────────────────────────── */
 .hero-logo-header {
   display: flex;
@@ -1834,12 +1957,24 @@ main>.hero-section:has(.hero-code-snippets) {
   align-items: center;
   gap: 8px;
 }
-
-.editor-actions {
+.editor-actions,
+.console-actions {
   display: flex;
   gap: 6px;
 }
 
+.btn-panel-action.copy-success {
+  background: rgba(16, 185, 129, 0.12) !important;
+  border-color: rgba(16, 185, 129, 0.4) !important;
+  color: #10b981 !important;
+}
+
+.btn-panel-action.copy-error {
+  background: rgba(239, 68, 68, 0.12) !important;
+  border-color: rgba(239, 68, 68, 0.4) !important;
+  color: #ef4444 !important;
+}
+
 .draft-selector {
   background: var(--bg-glass);
   border: 1px solid var(--border);