heapplot 1.0.0__tar.gz

heapplot-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 heapplot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

heapplot-1.0.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: heapplot
+Version: 1.0.0
+Summary: AI Lab Code Reference Package — Automation toolkit for AI game engine logic in VR headset development. Instantly print complete source code for classic AI algorithms: BFS, DFS, DLS, Best First Search, A*, 8-Puzzle, N-Queens, Hill Climbing, Alpha-Beta Pruning, Missionaries & Cannibals, Goal Stack Planning, Forward Chaining, and Bayesian Networks.
+Author: heapplot
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/heapplot/
+Keywords: ai,artificial-intelligence,algorithms,search,bfs,dfs,astar,a-star,alpha-beta,alphabeta,minimax,hill-climbing,bayesian,forward-chaining,n-queens,csp,8-puzzle,goal-stack,missionaries-cannibals,vr,game-engine,education
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# heapplot
+
+> **AI Lab Code Reference Package** — Automation toolkit for AI game engine logic in VR headset development.
+
+`heapplot` was born out of the need to rapidly prototype and reference classic AI decision-making algorithms for an automation layer powering game engine AI in VR headsets. Each function in this package prints the complete, ready-to-run source code of a specific AI algorithm directly to your terminal — making it a lightning-fast reference for AI developers and students alike.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install heapplot
+```
+
+---
+
+## 🚀 Usage
+
+```python
+import heapplot
+
+# See all available functions
+heapplot.help()
+
+# Print the code for any algorithm
+heapplot.bfs()
+heapplot.alphabeta()
+heapplot.bayesian()
+```
+
+---
+
+## 📚 Available Functions
+
+| Function | Assignment | Concept |
+|---|---|---|
+| `heapplot.bfs()` | 1 | Breadth First Search |
+| `heapplot.dfs()` | 1 | Depth First Search |
+| `heapplot.dls()` | 1 | Depth Limited Search |
+| `heapplot.bestfirst()` | 2 | Best First Search |
+| `heapplot.astar()` | 2 | A* Algorithm |
+| `heapplot.puzzle8()` | 3 | 8-Puzzle Problem (A* with misplaced tiles heuristic) |
+| `heapplot.nqueens()` | 4 | N-Queens (Constraint Satisfaction / Backtracking) |
+| `heapplot.hillclimbing()` | 5 | Hill Climbing Algorithm |
+| `heapplot.alphabeta()` | 6 | Alpha-Beta Pruning (Minimax Game Trees) |
+| `heapplot.missionarycannibals()` | 7 | Missionaries & Cannibals (A*) |
+| `heapplot.goalstack()` | 8 | Goal Stack Planning (Blocks World / STRIPS) |
+| `heapplot.forwardchaining()` | 9 | Forward Chaining Inference Engine |
+| `heapplot.bayesian()` | 10 | Bayesian Network (Student Exam Performance) |
+
+---
+
+## 🧠 Algorithm Details
+
+### Assignment 1 — Search Algorithms
+
+#### `heapplot.bfs()` — Breadth First Search
+Level-by-level graph traversal using a deque queue. Guarantees shortest path in unweighted graphs.
+
+#### `heapplot.dfs()` — Depth First Search
+Recursive depth-first traversal. Explores as far as possible before backtracking.
+
+#### `heapplot.dls()` — Depth Limited Search
+DFS with a depth limit to prevent infinite loops in deep/cyclic graphs.
+
+---
+
+### Assignment 2 — Heuristic Search
+
+#### `heapplot.bestfirst()` — Best First Search
+Greedy search that expands the node with the lowest heuristic value using a priority queue.
+
+#### `heapplot.astar()` — A* Algorithm
+Optimal search combining path cost `g` and heuristic `h` → `f = g + h`.
+
+---
+
+### Assignment 3 — Puzzle Solving
+
+#### `heapplot.puzzle8()` — 8-Puzzle Problem
+A* solution for the 8-tile sliding puzzle using misplaced tiles as the heuristic.
+
+---
+
+### Assignment 4 — Constraint Satisfaction
+
+#### `heapplot.nqueens()` — N-Queens Problem
+Backtracking CSP solver that places N non-attacking queens on an N×N chessboard.
+
+---
+
+### Assignment 5 — Local Search
+
+#### `heapplot.hillclimbing()` — Hill Climbing
+Greedy local search that always moves to the neighbour with the best heuristic.
+
+---
+
+### Assignment 6 — Game Tree Search
+
+#### `heapplot.alphabeta()` — Alpha-Beta Pruning
+Minimax algorithm with alpha-beta pruning to eliminate branches that cannot affect the result. Core to adversarial AI in game engines.
+
+---
+
+### Assignment 7 — Planning with Search
+
+#### `heapplot.missionarycannibals()` — Missionaries & Cannibals
+A* solution to the classic river-crossing puzzle with safety constraints.
+
+---
+
+### Assignment 8 — AI Planning
+
+#### `heapplot.goalstack()` — Goal Stack Planning
+STRIPS-style planning using a goal stack and operators (STACK, UNSTACK, PICKUP, PUTDOWN) in a blocks world domain.
+
+---
+
+### Assignment 9 — Knowledge Representation
+
+#### `heapplot.forwardchaining()` — Forward Chaining
+Data-driven inference engine that repeatedly applies rules to derive new facts until a query is satisfied.
+
+---
+
+### Assignment 10 — Probabilistic AI
+
+#### `heapplot.bayesian()` — Bayesian Network
+Joint probability computation over a student exam performance Bayesian Network using Conditional Probability Tables (CPTs).
+
+---
+
+## 🎮 Why heapplot?
+
+`heapplot` was originally developed as an automation reference layer for an AI game engine powering VR headsets. The core algorithms — from minimax and alpha-beta pruning for adversarial NPC behaviour, to A* and BFS for pathfinding, to Bayesian networks for probabilistic decision-making — form the backbone of intelligent behaviour in VR environments.
+
+---
+
+## 📄 License
+
+MIT License

heapplot-1.0.0/README.md

@@ -0,0 +1,142 @@
+# heapplot
+
+> **AI Lab Code Reference Package** — Automation toolkit for AI game engine logic in VR headset development.
+
+`heapplot` was born out of the need to rapidly prototype and reference classic AI decision-making algorithms for an automation layer powering game engine AI in VR headsets. Each function in this package prints the complete, ready-to-run source code of a specific AI algorithm directly to your terminal — making it a lightning-fast reference for AI developers and students alike.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install heapplot
+```
+
+---
+
+## 🚀 Usage
+
+```python
+import heapplot
+
+# See all available functions
+heapplot.help()
+
+# Print the code for any algorithm
+heapplot.bfs()
+heapplot.alphabeta()
+heapplot.bayesian()
+```
+
+---
+
+## 📚 Available Functions
+
+| Function | Assignment | Concept |
+|---|---|---|
+| `heapplot.bfs()` | 1 | Breadth First Search |
+| `heapplot.dfs()` | 1 | Depth First Search |
+| `heapplot.dls()` | 1 | Depth Limited Search |
+| `heapplot.bestfirst()` | 2 | Best First Search |
+| `heapplot.astar()` | 2 | A* Algorithm |
+| `heapplot.puzzle8()` | 3 | 8-Puzzle Problem (A* with misplaced tiles heuristic) |
+| `heapplot.nqueens()` | 4 | N-Queens (Constraint Satisfaction / Backtracking) |
+| `heapplot.hillclimbing()` | 5 | Hill Climbing Algorithm |
+| `heapplot.alphabeta()` | 6 | Alpha-Beta Pruning (Minimax Game Trees) |
+| `heapplot.missionarycannibals()` | 7 | Missionaries & Cannibals (A*) |
+| `heapplot.goalstack()` | 8 | Goal Stack Planning (Blocks World / STRIPS) |
+| `heapplot.forwardchaining()` | 9 | Forward Chaining Inference Engine |
+| `heapplot.bayesian()` | 10 | Bayesian Network (Student Exam Performance) |
+
+---
+
+## 🧠 Algorithm Details
+
+### Assignment 1 — Search Algorithms
+
+#### `heapplot.bfs()` — Breadth First Search
+Level-by-level graph traversal using a deque queue. Guarantees shortest path in unweighted graphs.
+
+#### `heapplot.dfs()` — Depth First Search
+Recursive depth-first traversal. Explores as far as possible before backtracking.
+
+#### `heapplot.dls()` — Depth Limited Search
+DFS with a depth limit to prevent infinite loops in deep/cyclic graphs.
+
+---
+
+### Assignment 2 — Heuristic Search
+
+#### `heapplot.bestfirst()` — Best First Search
+Greedy search that expands the node with the lowest heuristic value using a priority queue.
+
+#### `heapplot.astar()` — A* Algorithm
+Optimal search combining path cost `g` and heuristic `h` → `f = g + h`.
+
+---
+
+### Assignment 3 — Puzzle Solving
+
+#### `heapplot.puzzle8()` — 8-Puzzle Problem
+A* solution for the 8-tile sliding puzzle using misplaced tiles as the heuristic.
+
+---
+
+### Assignment 4 — Constraint Satisfaction
+
+#### `heapplot.nqueens()` — N-Queens Problem
+Backtracking CSP solver that places N non-attacking queens on an N×N chessboard.
+
+---
+
+### Assignment 5 — Local Search
+
+#### `heapplot.hillclimbing()` — Hill Climbing
+Greedy local search that always moves to the neighbour with the best heuristic.
+
+---
+
+### Assignment 6 — Game Tree Search
+
+#### `heapplot.alphabeta()` — Alpha-Beta Pruning
+Minimax algorithm with alpha-beta pruning to eliminate branches that cannot affect the result. Core to adversarial AI in game engines.
+
+---
+
+### Assignment 7 — Planning with Search
+
+#### `heapplot.missionarycannibals()` — Missionaries & Cannibals
+A* solution to the classic river-crossing puzzle with safety constraints.
+
+---
+
+### Assignment 8 — AI Planning
+
+#### `heapplot.goalstack()` — Goal Stack Planning
+STRIPS-style planning using a goal stack and operators (STACK, UNSTACK, PICKUP, PUTDOWN) in a blocks world domain.
+
+---
+
+### Assignment 9 — Knowledge Representation
+
+#### `heapplot.forwardchaining()` — Forward Chaining
+Data-driven inference engine that repeatedly applies rules to derive new facts until a query is satisfied.
+
+---
+
+### Assignment 10 — Probabilistic AI
+
+#### `heapplot.bayesian()` — Bayesian Network
+Joint probability computation over a student exam performance Bayesian Network using Conditional Probability Tables (CPTs).
+
+---
+
+## 🎮 Why heapplot?
+
+`heapplot` was originally developed as an automation reference layer for an AI game engine powering VR headsets. The core algorithms — from minimax and alpha-beta pruning for adversarial NPC behaviour, to A* and BFS for pathfinding, to Bayesian networks for probabilistic decision-making — form the backbone of intelligent behaviour in VR environments.
+
+---
+
+## 📄 License
+
+MIT License

heapplot-1.0.0/heapplot/__init__.py

@@ -0,0 +1,143 @@
+"""
+heapplot - AI Lab Assignment Code Reference Package
+====================================================
+
+A Python package that prints the complete source code of classic AI algorithms
+from university lab assignments directly to your terminal.
+
+Built to automate AI game engine logic references for VR headset development.
+
+Available Functions
+-------------------
+Assignment 1 - Search Algorithms:
+    heapplot.bfs()             - Breadth First Search
+    heapplot.dfs()             - Depth First Search
+    heapplot.dls()             - Depth Limited Search
+
+Assignment 2 - Heuristic Search:
+    heapplot.bestfirst()       - Best First Search
+    heapplot.astar()           - A* Algorithm (graph)
+
+Assignment 3 - Puzzle Solving:
+    heapplot.puzzle8()         - 8-Puzzle Problem (A* with misplaced tiles)
+
+Assignment 4 - Constraint Satisfaction:
+    heapplot.nqueens()         - N-Queens Problem (CSP with Backtracking)
+
+Assignment 5 - Local Search:
+    heapplot.hillclimbing()    - Hill Climbing Algorithm
+
+Assignment 6 - Game Tree Search:
+    heapplot.alphabeta()       - Alpha-Beta Pruning (Minimax)
+
+Assignment 7 - Planning with Search:
+    heapplot.missionarycannibals() - Missionaries & Cannibals (A*)
+
+Assignment 8 - AI Planning:
+    heapplot.goalstack()       - Goal Stack Planning (Blocks World)
+
+Assignment 9 - Knowledge Representation:
+    heapplot.forwardchaining() - Forward Chaining Inference
+
+Assignment 10 - Probabilistic AI:
+    heapplot.bayesian()        - Bayesian Network (Student Exam Performance)
+
+Usage
+-----
+    import heapplot
+
+    heapplot.bfs()
+    heapplot.alphabeta()
+    heapplot.bayesian()
+    # ... etc
+
+Or use heapplot.help() to list all available functions.
+"""
+
+from .bfs import bfs
+from .dfs import dfs
+from .dls import dls
+from .bestfirst import bestfirst
+from .astar import astar
+from .puzzle8 import puzzle8
+from .nqueens import nqueens
+from .hillclimbing import hillclimbing
+from .alphabeta import alphabeta
+from .missionarycannibals import missionarycannibals
+from .goalstack import goalstack
+from .forwardchaining import forwardchaining
+from .bayesian import bayesian
+
+__version__ = "1.0.0"
+__author__ = "heapplot"
+__description__ = (
+    "AI Lab Assignment Code Reference Package - "
+    "Automation toolkit for AI game engine logic in VR headset development"
+)
+
+__all__ = [
+    "bfs",
+    "dfs",
+    "dls",
+    "bestfirst",
+    "astar",
+    "puzzle8",
+    "nqueens",
+    "hillclimbing",
+    "alphabeta",
+    "missionarycannibals",
+    "goalstack",
+    "forwardchaining",
+    "bayesian",
+    "help",
+]
+
+
+def help():
+    """
+    Print all available heapplot functions with their descriptions.
+    Usage: heapplot.help()
+    """
+    print("""
+╔══════════════════════════════════════════════════════════════════════════╗
+║                    heapplot - AI Lab Code Reference                     ║
+║          Automation Toolkit for VR Headset AI Game Engine Logic         ║
+╚══════════════════════════════════════════════════════════════════════════╝
+
+ Assignment 1 - Search Algorithms:
+   heapplot.bfs()                  Breadth First Search
+   heapplot.dfs()                  Depth First Search
+   heapplot.dls()                  Depth Limited Search
+
+ Assignment 2 - Heuristic Search:
+   heapplot.bestfirst()            Best First Search
+   heapplot.astar()                A* Algorithm
+
+ Assignment 3 - Puzzle Solving:
+   heapplot.puzzle8()              8-Puzzle Problem (A* search)
+
+ Assignment 4 - Constraint Satisfaction:
+   heapplot.nqueens()              N-Queens Problem (CSP / Backtracking)
+
+ Assignment 5 - Local Search:
+   heapplot.hillclimbing()         Hill Climbing Algorithm
+
+ Assignment 6 - Game Tree Search:
+   heapplot.alphabeta()            Alpha-Beta Pruning (Minimax)
+
+ Assignment 7 - Planning with Search:
+   heapplot.missionarycannibals()  Missionaries & Cannibals (A*)
+
+ Assignment 8 - AI Planning:
+   heapplot.goalstack()            Goal Stack Planning (Blocks World)
+
+ Assignment 9 - Knowledge Representation:
+   heapplot.forwardchaining()      Forward Chaining Inference Engine
+
+ Assignment 10 - Probabilistic AI:
+   heapplot.bayesian()             Bayesian Network
+
+──────────────────────────────────────────────────────────────────────────
+  Call any function to print its full source code to the terminal.
+  Example: heapplot.alphabeta()
+""")

heapplot-1.0.0/heapplot/alphabeta.py

@@ -0,0 +1,57 @@
+"""Assignment 6: Alpha-Beta Pruning"""
+
+CODE = '''# Tree from the example: A (MAX) -> B, C (MIN) -> D, E, F, G (MAX) -> leaves
+tree = {
+    'A': ['B', 'C'],
+    'B': ['D', 'E'],
+    'C': ['F', 'G'],
+    'D': [3, 5],
+    'E': [6, 9],
+    'F': [1, 2],
+    'G': [0, -1],
+}
+INF = float('inf')
+
+def alphabeta(node, is_max, alpha, beta):
+    best = -INF if is_max else INF
+    for child in tree[node]:
+        # a child is either another node (string) or a leaf value (number)
+        value = alphabeta(child, not is_max, alpha, beta) if isinstance(child, str) else child
+        if is_max:
+            best = max(best, value)
+            alpha = max(alpha, best)
+        else:
+            best = min(best, value)
+            beta = min(beta, best)
+        if beta <= alpha:  # pruning condition
+            print(f"  Pruned remaining children of {node} (alpha={alpha}, beta={beta})")
+            break
+    print(f"Node {node} (\'MAX\' if is_max else \'MIN\') value = {best}")
+    return best
+
+print("Alpha-Beta Pruning")
+result = alphabeta('A', True, -INF, INF)
+print("Value of root A =", result)
+
+# Output
+# Alpha-Beta Pruning
+# Node D (MAX) value = 5
+#   Pruned remaining children of E (alpha=6, beta=5)
+# Node E (MAX) value = 6
+# Node B (MIN) value = 5
+# Node F (MAX) value = 2
+#   Pruned remaining children of C (alpha=5, beta=2)
+# Node C (MIN) value = 2
+# Node A (MAX) value = 5
+# Value of root A = 5
+'''
+
+def alphabeta():
+    """
+    Assignment 6 - Alpha-Beta Pruning
+    
+    Prints the Alpha-Beta Pruning algorithm code for minimax game trees.
+    Optimizes the minimax algorithm by pruning branches that cannot affect the result.
+    Usage: heapplot.alphabeta()
+    """
+    print(CODE)

heapplot-1.0.0/heapplot/astar.py

@@ -0,0 +1,47 @@
+"""Assignment 2: A* Algorithm"""
+
+CODE = '''import heapq
+
+graph = {
+    'A': [('B', 1), ('C', 4)],
+    'B': [('D', 2), ('E', 5)],
+    'C': [('F', 1)],
+    'D': [], 'E': [], 'F': []
+}
+heuristic = {'A': 6, 'B': 4, 'C': 5, 'D': 2, 'E': 0, 'F': 3}
+
+def a_star(start, goal):
+    pq = [(heuristic[start], 0, start)]
+    visited = set()
+    while pq:
+        f, g, node = heapq.heappop(pq)
+        if node in visited:
+            continue
+        print(node, "|| g =", g, "|| f =", f)
+        visited.add(node)
+        if node == goal:
+            print("Goal reached with total cost", g)
+            return
+        for neighbour, cost in graph[node]:
+            if neighbour not in visited:
+                new_g = g + cost
+                heapq.heappush(pq, (new_g + heuristic[neighbour], new_g, neighbour))
+
+a_star('A', 'E')
+
+# Output
+# A || g = 0 || f = 6
+# B || g = 1 || f = 5
+# D || g = 3 || f = 5
+# E || g = 6 || f = 6
+# Goal reached with total cost 6
+'''
+
+def astar():
+    """
+    Assignment 2 - A* Algorithm
+    
+    Prints the A* search algorithm code that finds the optimal path using f = g + h.
+    Usage: heapplot.astar()
+    """
+    print(CODE)

heapplot-1.0.0/heapplot/bayesian.py

@@ -0,0 +1,49 @@
+"""Assignment 10: Bayesian Network"""
+
+CODE = '''# Practical 10: Bayesian Network - student exam performance
+# Variables: e = exam level, i = IQ level, s = aptitude score, m = marks, a = admission
+# Each value is 0 or 1. CPTs list [P(x=0), P(x=1)].
+
+P_e = [0.7, 0.3]
+P_i = [0.8, 0.2]
+P_s_given_i = {0: [0.75, 0.25], 1: [0.4, 0.6]}
+P_m_given_ie = {(0, 0): [0.6, 0.4], (0, 1): [0.9, 0.1],
+                (1, 0): [0.5, 0.5], (1, 1): [0.8, 0.2]}
+P_a_given_m = {0: [0.6, 0.4], 1: [0.9, 0.1]}
+
+def joint(a, m, i, e, s):
+    """P(a,m,i,e,s) = P(a|m) * P(m|i,e) * P(i) * P(e) * P(s|i)"""
+    return (P_a_given_m[m][a] * P_m_given_ie[(i, e)][m] *
+            P_i[i] * P_e[e] * P_s_given_i[i][s])
+
+print("Case 1: difficult exam, low IQ, low aptitude, passes and gets admission")
+print("P(a=1, m=1, i=0, e=1, s=0) =", round(joint(1, 1, 0, 1, 0), 4))
+print("\\nCase 2: easy exam, high IQ, high aptitude, fails and no admission")
+print("P(a=0, m=0, i=1, e=0, s=1) =", round(joint(0, 0, 1, 0, 1), 4))
+
+# Extra: add up the joint over all 32 combinations
+combos = [(a, m, i, e, s) for a in (0, 1) for m in (0, 1)
+          for i in (0, 1) for e in (0, 1) for s in (0, 1)]
+print("\\nSum of the joint over all 32 combinations =", round(sum(joint(*c) for c in combos), 4))
+print("P(Admission = 1) =", round(sum(joint(*c) for c in combos if c[0] == 1), 4))
+
+# Output
+# Case 1: difficult exam, low IQ, low aptitude, passes and gets admission
+# P(a=1, m=1, i=0, e=1, s=0) = 0.0018
+#
+# Case 2: easy exam, high IQ, high aptitude, fails and no admission
+# P(a=0, m=0, i=1, e=0, s=1) = 0.0252
+#
+# Sum of the joint over all 32 combinations = 1.0
+# P(Admission = 1) = 0.301
+'''
+
+def bayesian():
+    """
+    Assignment 10 - Bayesian Network
+    
+    Prints the Bayesian Network code modelling student exam performance
+    using Conditional Probability Tables (CPTs).
+    Usage: heapplot.bayesian()
+    """
+    print(CODE)

heapplot-1.0.0/heapplot/bestfirst.py

@@ -0,0 +1,43 @@
+"""Assignment 2: Best First Search"""
+
+CODE = '''import heapq
+
+graph = {
+    'A': [('B', 1), ('C', 1)],
+    'B': [('D', 1), ('E', 1)],
+    'C': [('F', 1)],
+    'D': [], 'E': [], 'F': []
+}
+heuristic = {'A': 6, 'B': 4, 'C': 5, 'D': 7, 'E': 3, 'F': 0}
+
+def best_first_search(start, goal):
+    visited = set()
+    pq = [(heuristic[start], start)]
+    while pq:
+        h, node = heapq.heappop(pq)
+        if node in visited:
+            continue
+        print(node, end=" ")
+        visited.add(node)
+        if node == goal:
+            print("\\nGoal reached!")
+            return
+        for neighbour, cost in graph[node]:
+            if neighbour not in visited:
+                heapq.heappush(pq, (heuristic[neighbour], neighbour))
+
+best_first_search('A', 'F')
+
+# Output
+# A B E C F
+# Goal reached!
+'''
+
+def bestfirst():
+    """
+    Assignment 2 - Best First Search
+    
+    Prints the Best First Search algorithm code using a priority queue with heuristics.
+    Usage: heapplot.bestfirst()
+    """
+    print(CODE)