Merge branch 'master' of https://github.com/athikha/Python

Author: athikha

.github/workflows/build.yml

@@ -9,13 +9,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - run:
-          sudo apt-get update && sudo apt-get install -y libtiff5-dev libjpeg8-dev libopenjp2-7-dev
-          zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.6-dev tk8.6-dev python3-tk
-          libharfbuzz-dev libfribidi-dev libxcb1-dev
-          libxml2-dev libxslt-dev
-          libhdf5-dev
-          libopenblas-dev
+      - run: sudo apt-get update && sudo apt-get install -y libhdf5-dev
       - uses: actions/checkout@v5
       - uses: astral-sh/setup-uv@v7
         with:
@@ -32,6 +26,7 @@ jobs:
           --ignore=computer_vision/cnn_classification.py
           --ignore=docs/conf.py
           --ignore=dynamic_programming/k_means_clustering_tensorflow.py
+          --ignore=machine_learning/local_weighted_learning/local_weighted_learning.py
           --ignore=machine_learning/lstm/lstm_prediction.py
           --ignore=neural_network/input_data.py
           --ignore=project_euler/

CONTRIBUTING.md

@@ -99,7 +99,7 @@ We want your work to be readable by others; therefore, we encourage you to note
   ruff check
   ```
 
-- Original code submission require docstrings or comments to describe your work.
+- Original code submissions require docstrings or comments to describe your work.
 
 - More on docstrings and comments:
 

DIRECTORY.md

@@ -624,6 +624,7 @@
   * [Sequential Minimum Optimization](machine_learning/sequential_minimum_optimization.py)
   * [Similarity Search](machine_learning/similarity_search.py)
   * [Support Vector Machines](machine_learning/support_vector_machines.py)
+  * [T Stochastic Neighbour Embedding](machine_learning/t_stochastic_neighbour_embedding.py)
   * [Word Frequency Functions](machine_learning/word_frequency_functions.py)
   * [Xgboost Classifier](machine_learning/xgboost_classifier.py)
   * [Xgboost Regressor](machine_learning/xgboost_regressor.py)

data_structures/__init__.py

@@ -0,0 +1,9 @@
+"""Top-level data_structures package.
+
+This file exposes a small `simple` collection of educational data structures
+under `data_structures.simple` and provides a few convenience imports.
+"""
+
+from . import simple
+
+__all__ = ["simple"]

data_structures/simple/__init__.py

@@ -0,0 +1,26 @@
+"""Simple implementations of common data structures.
+
+This subpackage contains small, educational implementations copied from the
+`ds_extra` package so they can be accessed via `data_structures.simple`.
+"""
+
+from .linked_list import LinkedList
+from .stack import ListStack, LinkedStack
+from .queue import Queue
+from .bst import BinarySearchTree
+from .graph import Graph
+from .trie import Trie
+from .union_find import UnionFind
+from .min_heap import MinHeap
+
+__all__ = [
+    "LinkedList",
+    "ListStack",
+    "LinkedStack",
+    "Queue",
+    "BinarySearchTree",
+    "Graph",
+    "Trie",
+    "UnionFind",
+    "MinHeap",
+]

data_structures/simple/bst.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional, List
+
+
+class BSTNode:
+    def __init__(self, key: Any):
+        self.key = key
+        self.left: Optional[BSTNode] = None
+        self.right: Optional[BSTNode] = None
+
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root: Optional[BSTNode] = None
+
+    def insert(self, key: Any) -> None:
+        def _insert(node: Optional[BSTNode], key: Any) -> BSTNode:
+            if not node:
+                return BSTNode(key)
+            if key < node.key:
+                node.left = _insert(node.left, key)
+            else:
+                node.right = _insert(node.right, key)
+            return node
+
+        self.root = _insert(self.root, key)
+
+    def search(self, key: Any) -> bool:
+        node = self.root
+        while node:
+            if key == node.key:
+                return True
+            node = node.left if key < node.key else node.right
+        return False
+
+    def inorder(self) -> List[Any]:
+        res: List[Any] = []
+
+        def _in(node: Optional[BSTNode]) -> None:
+            if not node:
+                return
+            _in(node.left)
+            res.append(node.key)
+            _in(node.right)
+
+        _in(self.root)
+        return res

data_structures/simple/graph.py

@@ -0,0 +1,41 @@
+from collections import defaultdict, deque
+from typing import Any, Dict, List
+
+
+class Graph:
+    def __init__(self, directed: bool = False):
+        self.adj: Dict[Any, List[Any]] = defaultdict(list)
+        self.directed = directed
+
+    def add_edge(self, u: Any, v: Any) -> None:
+        self.adj[u].append(v)
+        if not self.directed:
+            self.adj[v].append(u)
+
+    def bfs(self, start: Any) -> List[Any]:
+        visited = set()
+        order = []
+        q = deque([start])
+        visited.add(start)
+        while q:
+            u = q.popleft()
+            order.append(u)
+            for v in self.adj[u]:
+                if v not in visited:
+                    visited.add(v)
+                    q.append(v)
+        return order
+
+    def dfs(self, start: Any) -> List[Any]:
+        visited = set()
+        order = []
+
+        def _dfs(u: Any) -> None:
+            visited.add(u)
+            order.append(u)
+            for v in self.adj[u]:
+                if v not in visited:
+                    _dfs(v)
+
+        _dfs(start)
+        return order

data_structures/simple/linked_list.py

@@ -0,0 +1,56 @@
+from typing import Any, Optional
+
+
+class Node:
+    def __init__(self, value: Any):
+        self.value = value
+        self.next: Optional[Node] = None
+
+
+class LinkedList:
+    def __init__(self):
+        self.head: Optional[Node] = None
+
+    def append(self, value: Any) -> None:
+        node = Node(value)
+        if not self.head:
+            self.head = node
+            return
+        cur = self.head
+        while cur.next:
+            cur = cur.next
+        cur.next = node
+
+    def prepend(self, value: Any) -> None:
+        node = Node(value)
+        node.next = self.head
+        self.head = node
+
+    def find(self, value: Any) -> Optional[Node]:
+        cur = self.head
+        while cur:
+            if cur.value == value:
+                return cur
+            cur = cur.next
+        return None
+
+    def delete(self, value: Any) -> bool:
+        cur = self.head
+        prev = None
+        while cur:
+            if cur.value == value:
+                if prev:
+                    prev.next = cur.next
+                else:
+                    self.head = cur.next
+                return True
+            prev, cur = cur, cur.next
+        return False
+
+    def to_list(self) -> list:
+        out = []
+        cur = self.head
+        while cur:
+            out.append(cur.value)
+            cur = cur.next
+        return out

data_structures/simple/min_heap.py

@@ -0,0 +1,16 @@
+import heapq
+from typing import Any, List, Optional
+
+
+class MinHeap:
+    def __init__(self):
+        self._data: List[Any] = []
+
+    def push(self, v: Any) -> None:
+        heapq.heappush(self._data, v)
+
+    def pop(self) -> Any:
+        return heapq.heappop(self._data)
+
+    def peek(self) -> Optional[Any]:
+        return self._data[0] if self._data else None

data_structures/simple/queue.py

@@ -0,0 +1,16 @@
+from collections import deque
+from typing import Any, Optional
+
+
+class Queue:
+    def __init__(self):
+        self._dq = deque()
+
+    def enqueue(self, v: Any) -> None:
+        self._dq.append(v)
+
+    def dequeue(self) -> Any:
+        return self._dq.popleft()
+
+    def peek(self) -> Optional[Any]:
+        return self._dq[0] if self._dq else None