Add LLM vs RAG vs Fine-Tuning comparison project

.gitattributes

@@ -0,0 +1,5 @@
+checkpoint-25/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,24 @@
+# Environment variables
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Model artifacts
+finetuned_model/
+
+# Results
+results/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,207 @@
+---
+base_model: TinyLlama/TinyLlama-1.1B-Chat-v1.0
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:TinyLlama/TinyLlama-1.1B-Chat-v1.0
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.18.1

data/docs/backtracking.txt

@@ -0,0 +1,204 @@
+BACKTRACKING
+============
+Backtracking explores all possible solutions by building candidates incrementally.
+If a candidate fails, it backtracks and tries the next option.
+
+Template:
+def backtrack(state, choices):
+    if is_solution(state):
+        record(state)
+        return
+    for choice in choices:
+        if is_valid(state, choice):
+            make_choice(state, choice)
+            backtrack(state, remaining_choices)
+            undo_choice(state, choice)   # BACKTRACK
+
+--- Generate All Subsets ---
+def subsets(nums):
+    result = []
+    def backtrack(start, current):
+        result.append(current[:])   # record every state
+        for i in range(start, len(nums)):
+            current.append(nums[i])
+            backtrack(i + 1, current)
+            current.pop()           # backtrack
+    backtrack(0, [])
+    return result
+
+print(subsets([1, 2, 3]))
+# [[], [1], [1,2], [1,2,3], [1,3], [2], [2,3], [3]]
+
+--- Generate All Permutations ---
+def permute(nums):
+    result = []
+    def backtrack(current):
+        if len(current) == len(nums):
+            result.append(current[:])
+            return
+        for num in nums:
+            if num not in current:
+                current.append(num)
+                backtrack(current)
+                current.pop()   # backtrack
+    backtrack([])
+    return result
+
+print(permute([1, 2, 3]))
+# [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]
+
+--- Combination Sum ---
+Find all combinations that sum to target. Numbers can be reused.
+
+def combination_sum(candidates, target):
+    result = []
+    candidates.sort()
+    def backtrack(start, current, remaining):
+        if remaining == 0:
+            result.append(current[:])
+            return
+        for i in range(start, len(candidates)):
+            if candidates[i] > remaining:
+                break
+            current.append(candidates[i])
+            backtrack(i, current, remaining - candidates[i])  # i (not i+1) allows reuse
+            current.pop()
+    backtrack(0, [], target)
+    return result
+
+print(combination_sum([2, 3, 6, 7], 7))
+# [[2, 2, 3], [7]]
+
+--- N-Queens Problem ---
+Place N queens on NxN board so no two queens attack each other.
+
+def solve_n_queens(n):
+    result = []
+    cols = set()
+    diag1 = set()  # row - col
+    diag2 = set()  # row + col
+
+    board = [['.' for _ in range(n)] for _ in range(n)]
+
+    def backtrack(row):
+        if row == n:
+            result.append([''.join(r) for r in board])
+            return
+        for col in range(n):
+            if col in cols or (row - col) in diag1 or (row + col) in diag2:
+                continue
+            cols.add(col)
+            diag1.add(row - col)
+            diag2.add(row + col)
+            board[row][col] = 'Q'
+            backtrack(row + 1)
+            cols.remove(col)         # backtrack
+            diag1.remove(row - col)
+            diag2.remove(row + col)
+            board[row][col] = '.'
+
+    backtrack(0)
+    return result
+
+solutions = solve_n_queens(4)
+print(f"Number of solutions for 4-Queens: {len(solutions)}")  # 2
+for sol in solutions:
+    for row in sol:
+        print(row)
+    print()
+
+--- Sudoku Solver ---
+Fill 9x9 grid so each row, column, and 3x3 box has digits 1-9.
+
+def solve_sudoku(board):
+    def is_valid(board, row, col, num):
+        num = str(num)
+        if num in board[row]:
+            return False
+        if num in [board[r][col] for r in range(9)]:
+            return False
+        box_r, box_c = 3 * (row // 3), 3 * (col // 3)
+        for r in range(box_r, box_r + 3):
+            for c in range(box_c, box_c + 3):
+                if board[r][c] == num:
+                    return False
+        return True
+
+    def backtrack():
+        for r in range(9):
+            for c in range(9):
+                if board[r][c] == '.':
+                    for num in range(1, 10):
+                        if is_valid(board, r, c, num):
+                            board[r][c] = str(num)
+                            if backtrack():
+                                return True
+                            board[r][c] = '.'  # backtrack
+                    return False
+        return True
+
+    backtrack()
+
+--- Word Search in Grid ---
+Find if word exists in 2D grid by moving up/down/left/right.
+
+def word_search(board, word):
+    rows, cols = len(board), len(board[0])
+
+    def backtrack(r, c, index):
+        if index == len(word):
+            return True
+        if r < 0 or r >= rows or c < 0 or c >= cols:
+            return False
+        if board[r][c] != word[index]:
+            return False
+        temp = board[r][c]
+        board[r][c] = '#'  # mark visited
+        found = (backtrack(r+1, c, index+1) or
+                 backtrack(r-1, c, index+1) or
+                 backtrack(r, c+1, index+1) or
+                 backtrack(r, c-1, index+1))
+        board[r][c] = temp  # backtrack (restore)
+        return found
+
+    for r in range(rows):
+        for c in range(cols):
+            if backtrack(r, c, 0):
+                return True
+    return False
+
+board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]]
+print(word_search(board, "ABCCED"))  # True
+print(word_search(board, "SEE"))     # True
+print(word_search(board, "ABCB"))    # False
+
+--- Rat in a Maze ---
+Find path from (0,0) to (n-1,n-1) in a grid (1=open, 0=blocked).
+
+def rat_in_maze(maze):
+    n = len(maze)
+    solution = [[0]*n for _ in range(n)]
+
+    def is_safe(r, c):
+        return 0 <= r < n and 0 <= c < n and maze[r][c] == 1
+
+    def solve(r, c):
+        if r == n-1 and c == n-1:
+            solution[r][c] = 1
+            return True
+        if is_safe(r, c):
+            solution[r][c] = 1
+            if solve(r+1, c): return True
+            if solve(r, c+1): return True
+            solution[r][c] = 0  # backtrack
+            return False
+        return False
+
+    if solve(0, 0):
+        return solution
+    return []
+
+maze = [[1,0,0,0],[1,1,0,1],[0,1,0,0],[1,1,1,1]]
+path = rat_in_maze(maze)
+for row in path:
+    print(row)

data/docs/binary_search.txt

@@ -0,0 +1,130 @@
+SEARCHING ALGORITHMS
+====================
+
+--- Linear Search ---
+Check every element one by one until the target is found.
+Time: O(n). Space: O(1). Works on unsorted arrays.
+
+def linear_search(arr, target):
+    for i, val in enumerate(arr):
+        if val == target:
+            return i
+    return -1
+
+print(linear_search([5, 3, 8, 1, 9], 8))  # Output: 2
+print(linear_search([5, 3, 8, 1, 9], 7))  # Output: -1
+
+--- Binary Search ---
+Works on SORTED arrays. Compare target with middle element.
+If smaller, search left half. If larger, search right half.
+Time: O(log n). Space: O(1) iterative, O(log n) recursive.
+
+# Iterative
+def binary_search(arr, target):
+    low, high = 0, len(arr) - 1
+    while low <= high:
+        mid = (low + high) // 2
+        if arr[mid] == target:
+            return mid
+        elif arr[mid] < target:
+            low = mid + 1
+        else:
+            high = mid - 1
+    return -1
+
+arr = [1, 3, 5, 7, 9, 11, 13]
+print(binary_search(arr, 7))   # Output: 3
+print(binary_search(arr, 10))  # Output: -1
+
+# Recursive
+def binary_search_recursive(arr, target, low, high):
+    if low > high:
+        return -1
+    mid = (low + high) // 2
+    if arr[mid] == target:
+        return mid
+    elif arr[mid] < target:
+        return binary_search_recursive(arr, target, mid + 1, high)
+    else:
+        return binary_search_recursive(arr, target, low, mid - 1)
+
+arr = [2, 4, 6, 8, 10, 12]
+print(binary_search_recursive(arr, 10, 0, len(arr) - 1))  # Output: 4
+
+--- Find First and Last Position ---
+Find first and last occurrence of target in sorted array.
+
+def find_first(arr, target):
+    low, high, result = 0, len(arr) - 1, -1
+    while low <= high:
+        mid = (low + high) // 2
+        if arr[mid] == target:
+            result = mid
+            high = mid - 1  # keep searching left
+        elif arr[mid] < target:
+            low = mid + 1
+        else:
+            high = mid - 1
+    return result
+
+def find_last(arr, target):
+    low, high, result = 0, len(arr) - 1, -1
+    while low <= high:
+        mid = (low + high) // 2
+        if arr[mid] == target:
+            result = mid
+            low = mid + 1  # keep searching right
+        elif arr[mid] < target:
+            low = mid + 1
+        else:
+            high = mid - 1
+    return result
+
+arr = [1, 2, 2, 2, 3, 4]
+print(find_first(arr, 2))  # Output: 1
+print(find_last(arr, 2))   # Output: 3
+
+--- Search in Rotated Sorted Array ---
+Array was sorted then rotated (e.g., [4,5,6,7,0,1,2]).
+
+def search_rotated(arr, target):
+    low, high = 0, len(arr) - 1
+    while low <= high:
+        mid = (low + high) // 2
+        if arr[mid] == target:
+            return mid
+        if arr[low] <= arr[mid]:  # left half sorted
+            if arr[low] <= target < arr[mid]:
+                high = mid - 1
+            else:
+                low = mid + 1
+        else:  # right half sorted
+            if arr[mid] < target <= arr[high]:
+                low = mid + 1
+            else:
+                high = mid - 1
+    return -1
+
+print(search_rotated([4, 5, 6, 7, 0, 1, 2], 0))  # Output: 4
+print(search_rotated([4, 5, 6, 7, 0, 1, 2], 3))  # Output: -1
+
+--- Square Root using Binary Search ---
+Find integer square root of a number without using sqrt().
+
+def sqrt_binary(n):
+    if n < 2:
+        return n
+    low, high, result = 1, n // 2, 0
+    while low <= high:
+        mid = (low + high) // 2
+        if mid * mid == n:
+            return mid
+        elif mid * mid < n:
+            result = mid
+            low = mid + 1
+        else:
+            high = mid - 1
+    return result
+
+print(sqrt_binary(16))  # Output: 4
+print(sqrt_binary(20))  # Output: 4 (floor)

data/docs/css_flexbox.txt

@@ -0,0 +1,17 @@
+CSS Flexbox (Flexible Box Layout) is a layout model for arranging items in a container.
+Activated by setting display: flex on a container element.
+
+Container properties:
+- flex-direction: row (default, horizontal) or column (vertical).
+- justify-content: aligns items on main axis. Values: flex-start, flex-end, center, space-between, space-around.
+- align-items: aligns items on cross axis. Values: stretch (default), flex-start, flex-end, center.
+- flex-wrap: nowrap (default) or wrap to allow items to move to next line.
+- gap: space between flex items.
+
+Item properties:
+- flex-grow: how much item grows relative to siblings. 0 means no grow.
+- flex-shrink: how much item shrinks when space is limited.
+- flex-basis: initial size of item before flex calculations.
+- align-self: overrides align-items for a single item.
+
+Shorthand: flex: grow shrink basis (e.g., flex: 1 1 auto)

data/docs/dynamic_programming.txt

@@ -0,0 +1,173 @@
+DYNAMIC PROGRAMMING (DP)
+========================
+DP solves problems by breaking them into overlapping subproblems and storing results to avoid recomputation.
+
+Two approaches:
+- Top-Down (Memoization): recursion + cache
+- Bottom-Up (Tabulation): fill a table iteratively
+
+Key properties needed:
+1. Optimal substructure: optimal solution built from optimal subproblems.
+2. Overlapping subproblems: same subproblem solved multiple times.
+
+--- Fibonacci Number ---
+Classic DP example. fib(n) = fib(n-1) + fib(n-2)
+
+# Naive recursion - O(2^n)
+def fib_naive(n):
+    if n <= 1:
+        return n
+    return fib_naive(n-1) + fib_naive(n-2)
+
+# Memoization - O(n)
+def fib_memo(n, memo={}):
+    if n in memo:
+        return memo[n]
+    if n <= 1:
+        return n
+    memo[n] = fib_memo(n-1, memo) + fib_memo(n-2, memo)
+    return memo[n]
+
+# Tabulation - O(n)
+def fib_dp(n):
+    if n <= 1:
+        return n
+    dp = [0] * (n + 1)
+    dp[1] = 1
+    for i in range(2, n + 1):
+        dp[i] = dp[i-1] + dp[i-2]
+    return dp[n]
+
+print(fib_dp(10))   # Output: 55
+print(fib_dp(20))   # Output: 6765
+
+--- 0/1 Knapsack Problem ---
+Given items with weights and values, maximize value in a bag of capacity W.
+Each item can be taken once (0/1). Time: O(n*W). Space: O(n*W).
+
+def knapsack(weights, values, capacity):
+    n = len(weights)
+    dp = [[0] * (capacity + 1) for _ in range(n + 1)]
+    for i in range(1, n + 1):
+        for w in range(capacity + 1):
+            # Don't take item i
+            dp[i][w] = dp[i-1][w]
+            # Take item i if it fits
+            if weights[i-1] <= w:
+                dp[i][w] = max(dp[i][w], dp[i-1][w - weights[i-1]] + values[i-1])
+    return dp[n][capacity]
+
+weights = [1, 2, 3, 5]
+values  = [1, 6, 10, 16]
+capacity = 7
+print(knapsack(weights, values, capacity))  # Output: 22
+
+--- Longest Common Subsequence (LCS) ---
+Find length of longest subsequence present in both strings.
+Time: O(m*n). Space: O(m*n).
+
+def lcs(s1, s2):
+    m, n = len(s1), len(s2)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if s1[i-1] == s2[j-1]:
+                dp[i][j] = dp[i-1][j-1] + 1
+            else:
+                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+    return dp[m][n]
+
+print(lcs("ABCBDAB", "BDCABA"))  # Output: 4 (BCBA)
+
+--- Longest Increasing Subsequence (LIS) ---
+Find length of longest strictly increasing subsequence.
+Time: O(n^2). Space: O(n).
+
+def lis(arr):
+    n = len(arr)
+    dp = [1] * n
+    for i in range(1, n):
+        for j in range(i):
+            if arr[j] < arr[i]:
+                dp[i] = max(dp[i], dp[j] + 1)
+    return max(dp)
+
+print(lis([10, 9, 2, 5, 3, 7, 101, 18]))  # Output: 4 (2,3,7,101)
+
+--- Coin Change Problem ---
+Find minimum number of coins to make amount. Coins can be reused.
+Time: O(amount * len(coins)). Space: O(amount).
+
+def coin_change(coins, amount):
+    dp = [float('inf')] * (amount + 1)
+    dp[0] = 0
+    for i in range(1, amount + 1):
+        for coin in coins:
+            if coin <= i:
+                dp[i] = min(dp[i], dp[i - coin] + 1)
+    return dp[amount] if dp[amount] != float('inf') else -1
+
+print(coin_change([1, 5, 6, 9], 11))  # Output: 2 (coins 5+6)
+print(coin_change([2], 3))            # Output: -1 (impossible)
+
+--- Subset Sum Problem ---
+Check if any subset of array sums to target.
+Time: O(n * target). Space: O(n * target).
+
+def subset_sum(arr, target):
+    n = len(arr)
+    dp = [[False] * (target + 1) for _ in range(n + 1)]
+    for i in range(n + 1):
+        dp[i][0] = True  # sum 0 always possible
+    for i in range(1, n + 1):
+        for j in range(1, target + 1):
+            dp[i][j] = dp[i-1][j]
+            if arr[i-1] <= j:
+                dp[i][j] = dp[i][j] or dp[i-1][j - arr[i-1]]
+    return dp[n][target]
+
+print(subset_sum([3, 34, 4, 12, 5, 2], 9))  # Output: True (4+5)
+print(subset_sum([3, 34, 4, 12, 5, 2], 30)) # Output: False
+
+--- Matrix Chain Multiplication ---
+Find minimum operations to multiply a chain of matrices.
+Time: O(n^3). Space: O(n^2).
+
+def matrix_chain(dims):
+    n = len(dims) - 1
+    dp = [[0] * n for _ in range(n)]
+    for length in range(2, n + 1):
+        for i in range(n - length + 1):
+            j = i + length - 1
+            dp[i][j] = float('inf')
+            for k in range(i, j):
+                cost = dp[i][k] + dp[k+1][j] + dims[i]*dims[k+1]*dims[j+1]
+                dp[i][j] = min(dp[i][j], cost)
+    return dp[0][n-1]
+
+dims = [40, 20, 30, 10, 30]
+print(matrix_chain(dims))  # Output: 26000
+
+--- Edit Distance (Levenshtein) ---
+Minimum operations (insert, delete, replace) to convert one string to another.
+Time: O(m*n). Space: O(m*n).
+
+def edit_distance(s1, s2):
+    m, n = len(s1), len(s2)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    for i in range(m + 1):
+        dp[i][0] = i
+    for j in range(n + 1):
+        dp[0][j] = j
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if s1[i-1] == s2[j-1]:
+                dp[i][j] = dp[i-1][j-1]
+            else:
+                dp[i][j] = 1 + min(dp[i-1][j],    # delete
+                                   dp[i][j-1],    # insert
+                                   dp[i-1][j-1])  # replace
+    return dp[m][n]
+
+print(edit_distance("horse", "ros"))   # Output: 3
+print(edit_distance("intention", "execution"))  # Output: 5

data/docs/graph_algorithms.txt

@@ -0,0 +1,217 @@
+GRAPH ALGORITHMS
+================
+A graph has vertices (nodes) connected by edges. Used to model networks, maps, dependencies.
+
+Types:
+- Directed / Undirected
+- Weighted / Unweighted
+- Cyclic / Acyclic (DAG = Directed Acyclic Graph)
+
+Representations:
+- Adjacency Matrix: 2D array. O(1) edge lookup, O(V^2) space.
+- Adjacency List: dict/list of lists. O(V+E) space. Most common.
+
+# Adjacency List representation
+graph = {
+    0: [1, 2],
+    1: [0, 3, 4],
+    2: [0],
+    3: [1],
+    4: [1]
+}
+
+--- BFS (Breadth-First Search) ---
+Explore level by level using a queue. Finds shortest path in unweighted graphs.
+Time: O(V+E). Space: O(V).
+
+from collections import deque
+
+def bfs(graph, start):
+    visited = set([start])
+    queue = deque([start])
+    order = []
+    while queue:
+        node = queue.popleft()
+        order.append(node)
+        for neighbor in graph[node]:
+            if neighbor not in visited:
+                visited.add(neighbor)
+                queue.append(neighbor)
+    return order
+
+graph = {0:[1,2], 1:[0,3,4], 2:[0], 3:[1], 4:[1]}
+print(bfs(graph, 0))  # Output: [0, 1, 2, 3, 4]
+
+--- DFS (Depth-First Search) ---
+Explore as deep as possible before backtracking. Uses stack (or recursion).
+Time: O(V+E). Space: O(V).
+
+# Iterative DFS
+def dfs_iterative(graph, start):
+    visited = set()
+    stack = [start]
+    order = []
+    while stack:
+        node = stack.pop()
+        if node not in visited:
+            visited.add(node)
+            order.append(node)
+            for neighbor in graph[node]:
+                if neighbor not in visited:
+                    stack.append(neighbor)
+    return order
+
+# Recursive DFS
+def dfs_recursive(graph, node, visited=None):
+    if visited is None:
+        visited = set()
+    visited.add(node)
+    result = [node]
+    for neighbor in graph[node]:
+        if neighbor not in visited:
+            result += dfs_recursive(graph, neighbor, visited)
+    return result
+
+print(dfs_iterative(graph, 0))   # Output: [0, 2, 1, 4, 3]
+print(dfs_recursive(graph, 0))   # Output: [0, 1, 3, 4, 2]
+
+--- Shortest Path: Dijkstra's Algorithm ---
+Find shortest path from source to all nodes in a weighted graph (non-negative weights).
+Time: O((V+E) log V) with min-heap. Space: O(V).
+
+import heapq
+
+def dijkstra(graph, start):
+    # graph: {node: [(neighbor, weight), ...]}
+    dist = {node: float('inf') for node in graph}
+    dist[start] = 0
+    heap = [(0, start)]  # (distance, node)
+    while heap:
+        d, u = heapq.heappop(heap)
+        if d > dist[u]:
+            continue
+        for v, w in graph[u]:
+            if dist[u] + w < dist[v]:
+                dist[v] = dist[u] + w
+                heapq.heappush(heap, (dist[v], v))
+    return dist
+
+wgraph = {
+    'A': [('B', 1), ('C', 4)],
+    'B': [('C', 2), ('D', 5)],
+    'C': [('D', 1)],
+    'D': []
+}
+print(dijkstra(wgraph, 'A'))
+# Output: {'A': 0, 'B': 1, 'C': 3, 'D': 4}
+
+--- Cycle Detection in Directed Graph ---
+Use DFS with a recursion stack to detect back edges.
+
+def has_cycle_directed(graph):
+    visited = set()
+    rec_stack = set()
+
+    def dfs(node):
+        visited.add(node)
+        rec_stack.add(node)
+        for neighbor in graph.get(node, []):
+            if neighbor not in visited:
+                if dfs(neighbor):
+                    return True
+            elif neighbor in rec_stack:
+                return True
+        rec_stack.remove(node)
+        return False
+
+    for node in graph:
+        if node not in visited:
+            if dfs(node):
+                return True
+    return False
+
+g1 = {0: [1], 1: [2], 2: [0]}  # cycle
+g2 = {0: [1], 1: [2], 2: []}   # no cycle
+print(has_cycle_directed(g1))   # True
+print(has_cycle_directed(g2))   # False
+
+--- Topological Sort (Kahn's Algorithm) ---
+Linear ordering of vertices in a DAG such that for every edge u->v, u comes before v.
+Time: O(V+E). Space: O(V).
+
+from collections import deque
+
+def topological_sort(graph, num_nodes):
+    in_degree = [0] * num_nodes
+    for u in graph:
+        for v in graph[u]:
+            in_degree[v] += 1
+    queue = deque([i for i in range(num_nodes) if in_degree[i] == 0])
+    order = []
+    while queue:
+        node = queue.popleft()
+        order.append(node)
+        for neighbor in graph.get(node, []):
+            in_degree[neighbor] -= 1
+            if in_degree[neighbor] == 0:
+                queue.append(neighbor)
+    return order if len(order) == num_nodes else []  # empty = cycle
+
+dag = {0: [1, 2], 1: [3], 2: [3], 3: []}
+print(topological_sort(dag, 4))  # Output: [0, 1, 2, 3] or [0, 2, 1, 3]
+
+--- Minimum Spanning Tree: Kruskal's Algorithm ---
+Connect all nodes with minimum total edge weight. Uses Union-Find.
+Time: O(E log E). Space: O(V).
+
+def kruskal(num_nodes, edges):
+    # edges: [(weight, u, v), ...]
+    edges.sort()
+    parent = list(range(num_nodes))
+
+    def find(x):
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    def union(x, y):
+        px, py = find(x), find(y)
+        if px == py:
+            return False
+        parent[px] = py
+        return True
+
+    mst_cost = 0
+    mst_edges = []
+    for w, u, v in edges:
+        if union(u, v):
+            mst_cost += w
+            mst_edges.append((u, v, w))
+    return mst_cost, mst_edges
+
+edges = [(4,0,1),(2,0,2),(3,1,2),(1,1,3),(5,2,3)]
+print(kruskal(4, edges))
+# Output: (6, [(1, 3, 1), (0, 2, 2), (1, 2, 3)])
+
+--- Bellman-Ford Algorithm ---
+Shortest path with negative weights. Detects negative cycles.
+Time: O(V*E). Space: O(V).
+
+def bellman_ford(graph, num_nodes, start):
+    # graph: [(u, v, weight), ...]
+    dist = [float('inf')] * num_nodes
+    dist[start] = 0
+    for _ in range(num_nodes - 1):
+        for u, v, w in graph:
+            if dist[u] + w < dist[v]:
+                dist[v] = dist[u] + w
+    # Check for negative cycles
+    for u, v, w in graph:
+        if dist[u] + w < dist[v]:
+            return None  # negative cycle
+    return dist
+
+edges = [(0,1,4),(0,2,5),(1,2,-3),(2,3,4)]
+print(bellman_ford(edges, 4, 0))
+# Output: [0, 4, 1, 5]

data/docs/greedy_algorithms.txt

@@ -0,0 +1,169 @@
+GREEDY ALGORITHMS
+=================
+Greedy algorithms make the locally optimal choice at each step hoping to find a global optimum.
+They do NOT reconsider past choices (unlike DP).
+
+When to use greedy: when local optimum leads to global optimum (greedy choice property + optimal substructure).
+
+--- Activity Selection Problem ---
+Select maximum number of non-overlapping activities.
+Sort by end time, always pick activity that ends earliest.
+Time: O(n log n).
+
+def activity_selection(activities):
+    # activities: [(start, end), ...]
+    activities.sort(key=lambda x: x[1])  # sort by end time
+    selected = [activities[0]]
+    last_end = activities[0][1]
+    for start, end in activities[1:]:
+        if start >= last_end:
+            selected.append((start, end))
+            last_end = end
+    return selected
+
+acts = [(1,4),(3,5),(0,6),(5,7),(3,9),(5,9),(6,10),(8,11),(8,12),(2,14),(12,16)]
+print(activity_selection(acts))
+# [(1,4),(5,7),(8,11),(12,16)] — 4 activities
+
+--- Fractional Knapsack ---
+Take fractions of items to maximize value. Unlike 0/1 knapsack, items can be split.
+Sort by value/weight ratio. Greedy works here (not for 0/1).
+Time: O(n log n).
+
+def fractional_knapsack(weights, values, capacity):
+    items = sorted(zip(values, weights), key=lambda x: x[0]/x[1], reverse=True)
+    total_value = 0
+    for value, weight in items:
+        if capacity >= weight:
+            total_value += value
+            capacity -= weight
+        else:
+            total_value += value * (capacity / weight)
+            break
+    return round(total_value, 2)
+
+weights = [10, 20, 30]
+values  = [60, 100, 120]
+print(fractional_knapsack(weights, values, 50))  # Output: 240.0
+
+--- Coin Change (Greedy — only works for canonical coin systems) ---
+For standard denominations (1,5,10,25 cents), greedy gives minimum coins.
+Note: greedy FAILS for arbitrary denominations — use DP instead.
+
+def coin_change_greedy(coins, amount):
+    coins.sort(reverse=True)
+    count = 0
+    result = []
+    for coin in coins:
+        while amount >= coin:
+            amount -= coin
+            count += 1
+            result.append(coin)
+    return count, result
+
+print(coin_change_greedy([1, 5, 10, 25], 41))
+# Output: (4, [25, 10, 5, 1])
+
+--- Job Scheduling to Maximize Profit ---
+Schedule jobs with deadlines to maximize total profit. Each job takes 1 unit of time.
+Time: O(n^2).
+
+def job_scheduling(jobs):
+    # jobs: [(id, deadline, profit), ...]
+    jobs.sort(key=lambda x: x[2], reverse=True)  # sort by profit
+    max_deadline = max(j[1] for j in jobs)
+    slots = [None] * (max_deadline + 1)
+    total_profit = 0
+    for job_id, deadline, profit in jobs:
+        for t in range(min(deadline, max_deadline), 0, -1):
+            if slots[t] is None:
+                slots[t] = job_id
+                total_profit += profit
+                break
+    scheduled = [s for s in slots if s]
+    return scheduled, total_profit
+
+jobs = [('a',2,100),('b',1,19),('c',2,27),('d',1,25),('e',3,15)]
+print(job_scheduling(jobs))  # (['c', 'a', 'e'], 142)
+
+--- Huffman Encoding ---
+Build optimal prefix-free codes for data compression.
+Characters with higher frequency get shorter codes.
+Time: O(n log n).
+
+import heapq
+
+def huffman_encoding(freq):
+    heap = [[f, [ch, ""]] for ch, f in freq.items()]
+    heapq.heapify(heap)
+    while len(heap) > 1:
+        lo = heapq.heappop(heap)
+        hi = heapq.heappop(heap)
+        for pair in lo[1:]:
+            pair[1] = '0' + pair[1]
+        for pair in hi[1:]:
+            pair[1] = '1' + pair[1]
+        heapq.heappush(heap, [lo[0] + hi[0]] + lo[1:] + hi[1:])
+    return sorted(heap[0][1:], key=lambda x: len(x[1]))
+
+freq = {'a': 5, 'b': 9, 'c': 12, 'd': 13, 'e': 16, 'f': 45}
+codes = huffman_encoding(freq)
+for char, code in codes:
+    print(f"{char}: {code}")
+# f: 0
+# c: 100
+# d: 101
+# a: 1100
+# b: 1101
+# e: 111
+
+--- Minimum Platforms (Greedy) ---
+Find minimum number of platforms needed at a railway station.
+Time: O(n log n).
+
+def min_platforms(arrivals, departures):
+    arrivals.sort()
+    departures.sort()
+    platforms = 1
+    max_platforms = 1
+    i = 1
+    j = 0
+    while i < len(arrivals) and j < len(departures):
+        if arrivals[i] <= departures[j]:
+            platforms += 1
+            i += 1
+        else:
+            platforms -= 1
+            j += 1
+        max_platforms = max(max_platforms, platforms)
+    return max_platforms
+
+arr = [900, 940, 950, 1100, 1500, 1800]
+dep = [910, 1200, 1120, 1130, 1900, 2000]
+print(min_platforms(arr, dep))  # Output: 3
+
+--- Gas Station (Circular Route) ---
+Find starting gas station to complete a circular route. Greedy: if total gas >= total cost, solution exists.
+Time: O(n). Space: O(1).
+
+def can_complete_circuit(gas, cost):
+    total_tank = 0
+    curr_tank = 0
+    start = 0
+    for i in range(len(gas)):
+        diff = gas[i] - cost[i]
+        total_tank += diff
+        curr_tank += diff
+        if curr_tank < 0:
+            start = i + 1
+            curr_tank = 0
+    return start if total_tank >= 0 else -1
+
+gas  = [1, 2, 3, 4, 5]
+cost = [3, 4, 5, 1, 2]
+print(can_complete_circuit(gas, cost))  # Output: 3
+
+--- Greedy vs Dynamic Programming ---
+Greedy: fast O(n log n), works when greedy choice is provably optimal.
+DP: slower O(n^2) or O(n*W), works for all optimization problems.
+Example: Fractional Knapsack → Greedy. 0/1 Knapsack → DP.

data/docs/hashing.txt

@@ -0,0 +1,171 @@
+HASHING AND HASH TABLES
+=======================
+A hash table stores key-value pairs. Uses a hash function to map keys to indices.
+Average time: O(1) for insert, delete, search. Worst case: O(n) with collisions.
+
+Python's dict and set are hash tables.
+
+--- Hash Table Basics ---
+# Python dict = hash map
+phone_book = {}
+phone_book["Alice"] = "555-1234"
+phone_book["Bob"]   = "555-5678"
+
+print(phone_book["Alice"])          # "555-1234"
+print("Alice" in phone_book)        # True
+del phone_book["Bob"]
+print(phone_book.get("Bob", "N/A")) # "N/A"
+
+# Iterate
+for name, number in phone_book.items():
+    print(name, number)
+
+--- Build a Hash Map from Scratch ---
+class HashMap:
+    def __init__(self, size=1000):
+        self.size = size
+        self.buckets = [[] for _ in range(size)]
+
+    def _hash(self, key):
+        return hash(key) % self.size
+
+    def put(self, key, value):
+        idx = self._hash(key)
+        for i, (k, v) in enumerate(self.buckets[idx]):
+            if k == key:
+                self.buckets[idx][i] = (key, value)
+                return
+        self.buckets[idx].append((key, value))
+
+    def get(self, key):
+        idx = self._hash(key)
+        for k, v in self.buckets[idx]:
+            if k == key:
+                return v
+        return None
+
+    def remove(self, key):
+        idx = self._hash(key)
+        self.buckets[idx] = [(k, v) for k, v in self.buckets[idx] if k != key]
+
+hm = HashMap()
+hm.put("name", "Alice")
+hm.put("age", 25)
+print(hm.get("name"))   # Alice
+hm.remove("age")
+print(hm.get("age"))    # None
+
+--- Two Sum Problem ---
+Find two numbers that add up to target. Classic hash map problem.
+Time: O(n). Space: O(n).
+
+def two_sum(nums, target):
+    seen = {}  # value → index
+    for i, num in enumerate(nums):
+        complement = target - num
+        if complement in seen:
+            return [seen[complement], i]
+        seen[num] = i
+    return []
+
+print(two_sum([2, 7, 11, 15], 9))   # [0, 1]
+print(two_sum([3, 2, 4], 6))        # [1, 2]
+
+--- Group Anagrams ---
+Group words that are anagrams of each other.
+Time: O(n * k log k) where k = max word length.
+
+from collections import defaultdict
+
+def group_anagrams(words):
+    groups = defaultdict(list)
+    for word in words:
+        key = ''.join(sorted(word))  # sorted chars as key
+        groups[key].append(word)
+    return list(groups.values())
+
+print(group_anagrams(["eat","tea","tan","ate","nat","bat"]))
+# [["eat","tea","ate"], ["tan","nat"], ["bat"]]
+
+--- Frequency Counter ---
+Count frequency of each element.
+
+from collections import Counter
+
+def top_k_frequent(nums, k):
+    count = Counter(nums)
+    return [x for x, _ in count.most_common(k)]
+
+print(top_k_frequent([1,1,1,2,2,3], 2))  # [1, 2]
+
+--- Longest Consecutive Sequence ---
+Find length of longest consecutive elements sequence.
+Time: O(n). Space: O(n).
+
+def longest_consecutive(nums):
+    num_set = set(nums)
+    best = 0
+    for num in num_set:
+        if num - 1 not in num_set:  # start of sequence
+            length = 1
+            while num + length in num_set:
+                length += 1
+            best = max(best, length)
+    return best
+
+print(longest_consecutive([100,4,200,1,3,2]))  # 4 (1,2,3,4)
+
+--- Subarray Sum Equals K ---
+Count subarrays with sum equal to k. Uses prefix sum + hash map.
+Time: O(n). Space: O(n).
+
+def subarray_sum(nums, k):
+    count = 0
+    prefix = 0
+    freq = {0: 1}  # prefix_sum → frequency
+    for num in nums:
+        prefix += num
+        if prefix - k in freq:
+            count += freq[prefix - k]
+        freq[prefix] = freq.get(prefix, 0) + 1
+    return count
+
+print(subarray_sum([1, 1, 1], 2))   # 2
+print(subarray_sum([1, 2, 3], 3))   # 2
+
+--- Check if Two Strings are Anagram ---
+def is_anagram(s, t):
+    return Counter(s) == Counter(t)
+
+print(is_anagram("anagram", "nagaram"))  # True
+print(is_anagram("rat", "car"))          # False
+
+--- First Non-Repeating Character ---
+def first_unique(s):
+    count = Counter(s)
+    for i, ch in enumerate(s):
+        if count[ch] == 1:
+            return i
+    return -1
+
+print(first_unique("leetcode"))   # 0 (l)
+print(first_unique("aabb"))       # -1
+
+--- Hash Set Uses ---
+# O(1) membership test
+visited = set()
+visited.add(5)
+print(5 in visited)   # True
+print(10 in visited)  # False
+
+# Remove duplicates
+arr = [1, 2, 2, 3, 3, 4]
+unique = list(set(arr))
+print(unique)  # [1, 2, 3, 4]
+
+# Intersection, Union
+a = {1, 2, 3, 4}
+b = {3, 4, 5, 6}
+print(a & b)  # {3, 4}  intersection
+print(a | b)  # {1,2,3,4,5,6} union
+print(a - b)  # {1, 2}  difference

data/docs/javascript_promises.txt

@@ -0,0 +1,34 @@
+JavaScript Promises handle asynchronous operations in a cleaner way than callbacks.
+
+Promise States:
+- Pending: initial state, operation not complete.
+- Fulfilled: operation completed successfully.
+- Rejected: operation failed.
+
+Creating a Promise:
+const myPromise = new Promise((resolve, reject) => {
+  if (success) resolve(result);
+  else reject(error);
+});
+
+Consuming a Promise:
+myPromise
+  .then(result => console.log(result))
+  .catch(error => console.error(error))
+  .finally(() => console.log('always runs'));
+
+async/await syntax (ES2017) is syntactic sugar over promises:
+async function fetchData() {
+  try {
+    const data = await fetch(url);
+    const json = await data.json();
+    return json;
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+Promise utility methods:
+- Promise.all([p1, p2]): runs in parallel, resolves when all resolve.
+- Promise.race([p1, p2]): resolves/rejects with first settled promise.
+- Promise.allSettled(): waits for all, returns all results regardless of success/failure.

data/docs/linked_list.txt

@@ -0,0 +1,206 @@
+LINKED LISTS
+============
+A linked list stores elements in nodes. Each node holds data and a pointer to the next node.
+Unlike arrays, nodes are not stored in contiguous memory.
+
+Advantages: O(1) insert/delete at head, dynamic size.
+Disadvantages: O(n) access by index, extra memory for pointers.
+
+--- Node Definition ---
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+--- Singly Linked List ---
+Each node points to the next. Last node points to None.
+
+class LinkedList:
+    def __init__(self):
+        self.head = None
+
+    def insert_at_head(self, data):
+        node = Node(data)
+        node.next = self.head
+        self.head = node
+
+    def insert_at_tail(self, data):
+        node = Node(data)
+        if not self.head:
+            self.head = node
+            return
+        curr = self.head
+        while curr.next:
+            curr = curr.next
+        curr.next = node
+
+    def delete(self, data):
+        if not self.head:
+            return
+        if self.head.data == data:
+            self.head = self.head.next
+            return
+        curr = self.head
+        while curr.next and curr.next.data != data:
+            curr = curr.next
+        if curr.next:
+            curr.next = curr.next.next
+
+    def search(self, data):
+        curr = self.head
+        while curr:
+            if curr.data == data:
+                return True
+            curr = curr.next
+        return False
+
+    def print_list(self):
+        curr = self.head
+        result = []
+        while curr:
+            result.append(curr.data)
+            curr = curr.next
+        print(result)
+
+ll = LinkedList()
+ll.insert_at_tail(1)
+ll.insert_at_tail(2)
+ll.insert_at_tail(3)
+ll.insert_at_head(0)
+ll.print_list()   # [0, 1, 2, 3]
+ll.delete(2)
+ll.print_list()   # [0, 1, 3]
+
+--- Reverse a Linked List ---
+Time: O(n). Space: O(1).
+
+def reverse(head):
+    prev = None
+    curr = head
+    while curr:
+        next_node = curr.next
+        curr.next = prev
+        prev = curr
+        curr = next_node
+    return prev  # new head
+
+--- Detect Cycle (Floyd's Algorithm) ---
+Use slow and fast pointers. If they meet, there is a cycle.
+Time: O(n). Space: O(1).
+
+def has_cycle(head):
+    slow = fast = head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+        if slow == fast:
+            return True
+    return False
+
+--- Find Middle of Linked List ---
+Time: O(n). Space: O(1).
+
+def find_middle(head):
+    slow = fast = head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+    return slow  # slow is at middle
+
+--- Merge Two Sorted Linked Lists ---
+Time: O(n + m). Space: O(1).
+
+def merge_sorted(l1, l2):
+    dummy = Node(0)
+    curr = dummy
+    while l1 and l2:
+        if l1.data <= l2.data:
+            curr.next = l1
+            l1 = l1.next
+        else:
+            curr.next = l2
+            l2 = l2.next
+        curr = curr.next
+    curr.next = l1 or l2
+    return dummy.next
+
+--- Remove Nth Node From End ---
+Use two pointers separated by n steps.
+Time: O(n). Space: O(1).
+
+def remove_nth_from_end(head, n):
+    dummy = Node(0)
+    dummy.next = head
+    fast = slow = dummy
+    for _ in range(n + 1):
+        fast = fast.next
+    while fast:
+        slow = slow.next
+        fast = fast.next
+    slow.next = slow.next.next
+    return dummy.next
+
+--- Check if Palindrome ---
+Time: O(n). Space: O(1).
+
+def is_palindrome(head):
+    # Find middle
+    slow = fast = head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+    # Reverse second half
+    prev = None
+    curr = slow
+    while curr:
+        nxt = curr.next
+        curr.next = prev
+        prev = curr
+        curr = nxt
+    # Compare halves
+    left, right = head, prev
+    while right:
+        if left.data != right.data:
+            return False
+        left = left.next
+        right = right.next
+    return True
+
+--- Doubly Linked List ---
+Each node has a pointer to both next and previous nodes.
+
+class DNode:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+        self.prev = None
+
+class DoublyLinkedList:
+    def __init__(self):
+        self.head = None
+
+    def insert_at_head(self, data):
+        node = DNode(data)
+        if self.head:
+            self.head.prev = node
+        node.next = self.head
+        self.head = node
+
+    def delete(self, node):
+        if node.prev:
+            node.prev.next = node.next
+        else:
+            self.head = node.next
+        if node.next:
+            node.next.prev = node.prev
+
+--- Circular Linked List ---
+Last node points back to head forming a circle.
+
+def is_circular(head):
+    if not head:
+        return False
+    curr = head.next
+    while curr and curr != head:
+        curr = curr.next
+    return curr == head

data/docs/react_hooks.txt

@@ -0,0 +1,20 @@
+React Hooks are functions that let you use state and lifecycle features in functional components.
+Introduced in React 16.8 to replace class components.
+
+useState: manages local component state.
+Syntax: const [state, setState] = useState(initialValue)
+Example: const [count, setCount] = useState(0)
+
+useEffect: handles side effects like API calls, subscriptions, DOM updates.
+Runs after every render by default.
+Syntax: useEffect(() => { /* effect */ }, [dependencies])
+Empty dependency array [] means run only once on mount.
+
+useContext: consume React context without wrapping in Consumer component.
+Syntax: const value = useContext(MyContext)
+
+useRef: holds mutable value that does not trigger re-render. Also used to access DOM elements.
+
+Rules of Hooks:
+1. Only call hooks at the top level (not inside loops or conditions).
+2. Only call hooks from React function components or custom hooks.

data/docs/recursion.txt

@@ -0,0 +1,148 @@
+RECURSION
+=========
+Recursion is when a function calls itself to solve a smaller version of the same problem.
+Every recursive function needs:
+1. Base case — condition to stop recursion.
+2. Recursive case — function calls itself with smaller input.
+
+--- Factorial ---
+n! = n * (n-1) * ... * 1
+
+def factorial(n):
+    if n == 0 or n == 1:   # base case
+        return 1
+    return n * factorial(n - 1)  # recursive case
+
+print(factorial(5))   # 120
+print(factorial(0))   # 1
+
+# Iterative equivalent
+def factorial_iter(n):
+    result = 1
+    for i in range(2, n + 1):
+        result *= i
+    return result
+
+--- Fibonacci ---
+fib(n) = fib(n-1) + fib(n-2), fib(0)=0, fib(1)=1
+
+def fib(n):
+    if n <= 1:
+        return n
+    return fib(n-1) + fib(n-2)
+
+print([fib(i) for i in range(8)])  # [0, 1, 1, 2, 3, 5, 8, 13]
+
+--- Sum of Array ---
+def array_sum(arr):
+    if not arr:
+        return 0
+    return arr[0] + array_sum(arr[1:])
+
+print(array_sum([1, 2, 3, 4, 5]))  # 15
+
+--- Power Function ---
+def power(base, exp):
+    if exp == 0:
+        return 1
+    if exp % 2 == 0:
+        half = power(base, exp // 2)
+        return half * half  # O(log n) — fast power
+    return base * power(base, exp - 1)
+
+print(power(2, 10))   # 1024
+print(power(3, 5))    # 243
+
+--- Reverse a String ---
+def reverse_string(s):
+    if len(s) <= 1:
+        return s
+    return reverse_string(s[1:]) + s[0]
+
+print(reverse_string("hello"))  # "olleh"
+
+--- Check Palindrome ---
+def is_palindrome(s):
+    if len(s) <= 1:
+        return True
+    if s[0] != s[-1]:
+        return False
+    return is_palindrome(s[1:-1])
+
+print(is_palindrome("racecar"))  # True
+print(is_palindrome("hello"))    # False
+
+--- Tower of Hanoi ---
+Move n disks from source to destination using auxiliary peg.
+Minimum moves = 2^n - 1.
+
+def hanoi(n, source, destination, auxiliary):
+    if n == 1:
+        print(f"Move disk 1 from {source} to {destination}")
+        return
+    hanoi(n-1, source, auxiliary, destination)
+    print(f"Move disk {n} from {source} to {destination}")
+    hanoi(n-1, auxiliary, destination, source)
+
+hanoi(3, 'A', 'C', 'B')
+# Moves disk 1 from A to C
+# Moves disk 2 from A to B
+# Moves disk 1 from C to B
+# ... (7 total moves)
+
+--- Binary Search (Recursive) ---
+def binary_search(arr, target, low, high):
+    if low > high:
+        return -1
+    mid = (low + high) // 2
+    if arr[mid] == target:
+        return mid
+    elif arr[mid] < target:
+        return binary_search(arr, target, mid + 1, high)
+    else:
+        return binary_search(arr, target, low, mid - 1)
+
+arr = [1, 3, 5, 7, 9]
+print(binary_search(arr, 7, 0, len(arr)-1))  # 3
+
+--- Flatten Nested List ---
+def flatten(lst):
+    result = []
+    for item in lst:
+        if isinstance(item, list):
+            result.extend(flatten(item))
+        else:
+            result.append(item)
+    return result
+
+print(flatten([1, [2, [3, 4], 5], 6]))  # [1, 2, 3, 4, 5, 6]
+
+--- Generate All Subsets (Power Set) ---
+def subsets(nums):
+    if not nums:
+        return [[]]
+    rest = subsets(nums[1:])
+    return rest + [[nums[0]] + s for s in rest]
+
+print(subsets([1, 2, 3]))
+# [[], [3], [2], [2,3], [1], [1,3], [1,2], [1,2,3]]
+
+--- Generate Permutations ---
+def permutations(nums):
+    if len(nums) <= 1:
+        return [nums]
+    result = []
+    for i, num in enumerate(nums):
+        rest = nums[:i] + nums[i+1:]
+        for perm in permutations(rest):
+            result.append([num] + perm)
+    return result
+
+print(permutations([1, 2, 3]))
+# [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]
+
+--- Recursion vs Iteration ---
+Recursion: cleaner code, natural for tree/graph problems, risk of stack overflow.
+Iteration: better performance, no stack overflow, sometimes harder to read.
+Use recursion when the problem is naturally recursive (trees, divide-and-conquer).
+Convert to iteration for very deep recursion using an explicit stack.

data/docs/rest_api.txt

@@ -0,0 +1,21 @@
+REST API (Representational State Transfer) is an architectural style for web services.
+REST uses standard HTTP methods to perform operations on resources.
+
+HTTP Methods:
+- GET: retrieve/read resource. No request body.
+- POST: create new resource. Data sent in request body.
+- PUT: update existing resource completely.
+- PATCH: partially update a resource.
+- DELETE: remove a resource.
+
+HTTP Status Codes:
+- 200 OK: request succeeded.
+- 201 Created: new resource created successfully.
+- 400 Bad Request: invalid request from client.
+- 401 Unauthorized: authentication required.
+- 403 Forbidden: authenticated but not authorized.
+- 404 Not Found: resource does not exist.
+- 500 Internal Server Error: server-side error.
+
+REST principles: Stateless, Client-Server, Cacheable, Uniform Interface.
+JSON is the most common data format for REST API responses.

data/docs/sorting_algorithms.txt

@@ -0,0 +1,165 @@
+SORTING ALGORITHMS
+==================
+
+--- Bubble Sort ---
+Repeatedly compare adjacent elements and swap if out of order. Largest element bubbles to end each pass.
+Time: O(n^2) average/worst, O(n) best (already sorted). Space: O(1). Stable.
+
+def bubble_sort(arr):
+    n = len(arr)
+    for i in range(n):
+        swapped = False
+        for j in range(0, n - i - 1):
+            if arr[j] > arr[j + 1]:
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+                swapped = True
+        if not swapped:
+            break  # already sorted
+    return arr
+
+print(bubble_sort([64, 34, 25, 12, 22, 11, 90]))
+# Output: [11, 12, 22, 25, 34, 64, 90]
+
+--- Selection Sort ---
+Find the minimum element and place it at the beginning. Repeat for remaining array.
+Time: O(n^2) all cases. Space: O(1). Not stable.
+
+def selection_sort(arr):
+    n = len(arr)
+    for i in range(n):
+        min_idx = i
+        for j in range(i + 1, n):
+            if arr[j] < arr[min_idx]:
+                min_idx = j
+        arr[i], arr[min_idx] = arr[min_idx], arr[i]
+    return arr
+
+print(selection_sort([64, 25, 12, 22, 11]))
+# Output: [11, 12, 22, 25, 64]
+
+--- Insertion Sort ---
+Build sorted array one element at a time. Take each element and insert it into the correct position.
+Time: O(n^2) worst, O(n) best. Space: O(1). Stable. Best for small or nearly sorted data.
+
+def insertion_sort(arr):
+    for i in range(1, len(arr)):
+        key = arr[i]
+        j = i - 1
+        while j >= 0 and arr[j] > key:
+            arr[j + 1] = arr[j]
+            j -= 1
+        arr[j + 1] = key
+    return arr
+
+print(insertion_sort([12, 11, 13, 5, 6]))
+# Output: [5, 6, 11, 12, 13]
+
+--- Merge Sort ---
+Divide array in half, recursively sort both halves, then merge the sorted halves.
+Time: O(n log n) all cases. Space: O(n). Stable. Best for linked lists and large datasets.
+
+def merge_sort(arr):
+    if len(arr) <= 1:
+        return arr
+    mid = len(arr) // 2
+    left = merge_sort(arr[:mid])
+    right = merge_sort(arr[mid:])
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    i = j = 0
+    while i < len(left) and j < len(right):
+        if left[i] <= right[j]:
+            result.append(left[i]); i += 1
+        else:
+            result.append(right[j]); j += 1
+    result.extend(left[i:])
+    result.extend(right[j:])
+    return result
+
+print(merge_sort([38, 27, 43, 3, 9, 82, 10]))
+# Output: [3, 9, 10, 27, 38, 43, 82]
+
+--- Quick Sort ---
+Pick a pivot, partition array so all elements less than pivot are on left, greater on right. Recurse.
+Time: O(n log n) average, O(n^2) worst. Space: O(log n). Not stable. Fastest in practice.
+
+def quick_sort(arr, low=0, high=None):
+    if high is None:
+        high = len(arr) - 1
+    if low < high:
+        pi = partition(arr, low, high)
+        quick_sort(arr, low, pi - 1)
+        quick_sort(arr, pi + 1, high)
+    return arr
+
+def partition(arr, low, high):
+    pivot = arr[high]
+    i = low - 1
+    for j in range(low, high):
+        if arr[j] <= pivot:
+            i += 1
+            arr[i], arr[j] = arr[j], arr[i]
+    arr[i + 1], arr[high] = arr[high], arr[i + 1]
+    return i + 1
+
+print(quick_sort([10, 7, 8, 9, 1, 5]))
+# Output: [1, 5, 7, 8, 9, 10]
+
+--- Heap Sort ---
+Build a max-heap from the array. Repeatedly extract the maximum and place at end.
+Time: O(n log n) all cases. Space: O(1). Not stable.
+
+def heap_sort(arr):
+    n = len(arr)
+    for i in range(n // 2 - 1, -1, -1):
+        heapify(arr, n, i)
+    for i in range(n - 1, 0, -1):
+        arr[0], arr[i] = arr[i], arr[0]
+        heapify(arr, i, 0)
+    return arr
+
+def heapify(arr, n, i):
+    largest = i
+    left = 2 * i + 1
+    right = 2 * i + 2
+    if left < n and arr[left] > arr[largest]:
+        largest = left
+    if right < n and arr[right] > arr[largest]:
+        largest = right
+    if largest != i:
+        arr[i], arr[largest] = arr[largest], arr[i]
+        heapify(arr, n, largest)
+
+print(heap_sort([12, 11, 13, 5, 6, 7]))
+# Output: [5, 6, 7, 11, 12, 13]
+
+--- Counting Sort ---
+Count occurrences of each element. Works only on non-negative integers within a known range.
+Time: O(n + k) where k is the range. Space: O(k). Stable.
+
+def counting_sort(arr):
+    if not arr:
+        return arr
+    max_val = max(arr)
+    count = [0] * (max_val + 1)
+    for num in arr:
+        count[num] += 1
+    result = []
+    for i, c in enumerate(count):
+        result.extend([i] * c)
+    return result
+
+print(counting_sort([4, 2, 2, 8, 3, 3, 1]))
+# Output: [1, 2, 2, 3, 3, 4, 8]
+
+--- Comparison Summary ---
+Algorithm     | Best      | Average   | Worst     | Space  | Stable
+Bubble Sort   | O(n)      | O(n^2)    | O(n^2)    | O(1)   | Yes
+Selection Sort| O(n^2)    | O(n^2)    | O(n^2)    | O(1)   | No
+Insertion Sort| O(n)      | O(n^2)    | O(n^2)    | O(1)   | Yes
+Merge Sort    | O(n log n)| O(n log n)| O(n log n)| O(n)   | Yes
+Quick Sort    | O(n log n)| O(n log n)| O(n^2)    | O(log n)| No
+Heap Sort     | O(n log n)| O(n log n)| O(n log n)| O(1)   | No
+Counting Sort | O(n+k)    | O(n+k)    | O(n+k)    | O(k)   | Yes

data/docs/stack_queue.txt

@@ -0,0 +1,218 @@
+STACK AND QUEUE
+===============
+
+--- STACK ---
+LIFO — Last In First Out. Think of a stack of plates.
+Operations: push (add), pop (remove top), peek (view top). All O(1).
+
+Uses: undo/redo, function call stack, expression evaluation, DFS, balanced brackets.
+
+# Stack using Python list
+class Stack:
+    def __init__(self):
+        self.items = []
+
+    def push(self, item):
+        self.items.append(item)
+
+    def pop(self):
+        if self.is_empty():
+            raise IndexError("Stack is empty")
+        return self.items.pop()
+
+    def peek(self):
+        if self.is_empty():
+            raise IndexError("Stack is empty")
+        return self.items[-1]
+
+    def is_empty(self):
+        return len(self.items) == 0
+
+    def size(self):
+        return len(self.items)
+
+s = Stack()
+s.push(10)
+s.push(20)
+s.push(30)
+print(s.peek())  # 30
+print(s.pop())   # 30
+print(s.size())  # 2
+
+--- Balanced Brackets using Stack ---
+Check if brackets (, ), {, }, [, ] are balanced.
+
+def is_balanced(expr):
+    stack = []
+    pairs = {')': '(', '}': '{', ']': '['}
+    for ch in expr:
+        if ch in '({[':
+            stack.append(ch)
+        elif ch in ')}]':
+            if not stack or stack[-1] != pairs[ch]:
+                return False
+            stack.pop()
+    return len(stack) == 0
+
+print(is_balanced("({[]})"))   # True
+print(is_balanced("({[})"))    # False
+print(is_balanced("((()))"))   # True
+
+--- Next Greater Element using Stack ---
+For each element, find the next element greater than it.
+Time: O(n). Space: O(n).
+
+def next_greater(arr):
+    n = len(arr)
+    result = [-1] * n
+    stack = []  # stores indices
+    for i in range(n):
+        while stack and arr[stack[-1]] < arr[i]:
+            result[stack.pop()] = arr[i]
+        stack.append(i)
+    return result
+
+print(next_greater([4, 5, 2, 25]))  # [5, 25, 25, -1]
+
+--- Evaluate Postfix Expression ---
+Postfix: operands come before operator (e.g. "2 3 +" = 5).
+
+def evaluate_postfix(expression):
+    stack = []
+    for token in expression.split():
+        if token.lstrip('-').isdigit():
+            stack.append(int(token))
+        else:
+            b = stack.pop()
+            a = stack.pop()
+            if token == '+': stack.append(a + b)
+            elif token == '-': stack.append(a - b)
+            elif token == '*': stack.append(a * b)
+            elif token == '/': stack.append(int(a / b))
+    return stack[0]
+
+print(evaluate_postfix("2 3 1 * + 9 -"))  # Output: -4
+
+--- Min Stack ---
+Stack that supports getMin() in O(1).
+
+class MinStack:
+    def __init__(self):
+        self.stack = []
+        self.min_stack = []
+
+    def push(self, val):
+        self.stack.append(val)
+        if not self.min_stack or val <= self.min_stack[-1]:
+            self.min_stack.append(val)
+
+    def pop(self):
+        val = self.stack.pop()
+        if val == self.min_stack[-1]:
+            self.min_stack.pop()
+
+    def get_min(self):
+        return self.min_stack[-1]
+
+ms = MinStack()
+ms.push(5); ms.push(3); ms.push(7); ms.push(2)
+print(ms.get_min())  # 2
+ms.pop()
+print(ms.get_min())  # 3
+
+--- QUEUE ---
+FIFO — First In First Out. Think of a line at a ticket counter.
+Operations: enqueue (add rear), dequeue (remove front), peek. All O(1).
+
+Uses: BFS, scheduling, print queues, sliding window.
+
+from collections import deque
+
+class Queue:
+    def __init__(self):
+        self.items = deque()
+
+    def enqueue(self, item):
+        self.items.append(item)
+
+    def dequeue(self):
+        if self.is_empty():
+            raise IndexError("Queue is empty")
+        return self.items.popleft()
+
+    def peek(self):
+        return self.items[0]
+
+    def is_empty(self):
+        return len(self.items) == 0
+
+    def size(self):
+        return len(self.items)
+
+q = Queue()
+q.enqueue(10)
+q.enqueue(20)
+q.enqueue(30)
+print(q.dequeue())  # 10
+print(q.peek())     # 20
+
+--- Circular Queue ---
+Fixed-size queue where rear wraps around to front.
+
+class CircularQueue:
+    def __init__(self, capacity):
+        self.queue = [None] * capacity
+        self.front = self.rear = -1
+        self.capacity = capacity
+        self.size = 0
+
+    def enqueue(self, item):
+        if self.size == self.capacity:
+            raise OverflowError("Queue is full")
+        self.rear = (self.rear + 1) % self.capacity
+        self.queue[self.rear] = item
+        if self.front == -1:
+            self.front = 0
+        self.size += 1
+
+    def dequeue(self):
+        if self.size == 0:
+            raise IndexError("Queue is empty")
+        item = self.queue[self.front]
+        self.front = (self.front + 1) % self.capacity
+        self.size -= 1
+        return item
+
+--- Deque (Double-Ended Queue) ---
+Insert and delete from both ends in O(1).
+
+from collections import deque
+d = deque()
+d.appendleft(1)   # add to front
+d.append(2)       # add to rear
+d.appendleft(0)
+print(d)          # deque([0, 1, 2])
+d.popleft()       # remove from front → 0
+d.pop()           # remove from rear  → 2
+print(d)          # deque([1])
+
+--- Priority Queue ---
+Elements are dequeued based on priority, not insertion order.
+Python's heapq is a min-heap by default.
+
+import heapq
+
+pq = []
+heapq.heappush(pq, (3, 'low'))
+heapq.heappush(pq, (1, 'high'))
+heapq.heappush(pq, (2, 'medium'))
+print(heapq.heappop(pq))  # (1, 'high')
+print(heapq.heappop(pq))  # (2, 'medium')
+
+# Max-heap: negate priorities
+heapq.heappush(pq, (-5, 'top priority'))
+print(heapq.heappop(pq))  # (-5, 'top priority')
+
+--- Difference: Stack vs Queue ---
+Stack: LIFO — last added is first removed. Uses: DFS, backtracking, undo.
+Queue: FIFO — first added is first removed. Uses: BFS, scheduling, buffering.

data/docs/string_algorithms.txt

@@ -0,0 +1,194 @@
+STRING ALGORITHMS
+=================
+Strings are sequences of characters. Most string operations in Python run in O(n).
+
+--- Basic String Operations ---
+s = "hello world"
+print(len(s))           # 11
+print(s.upper())        # HELLO WORLD
+print(s.lower())        # hello world
+print(s.split())        # ['hello', 'world']
+print(s.replace("world", "Python"))  # hello Python
+print(s.startswith("hello"))  # True
+print(s.endswith("world"))    # True
+print(s.find("world"))        # 6 (index)
+print(s.count("l"))           # 3
+print(s[::-1])                # dlrow olleh (reverse)
+print("".join(reversed(s)))   # same as above
+
+--- Reverse Words in a Sentence ---
+def reverse_words(sentence):
+    return ' '.join(sentence.split()[::-1])
+
+print(reverse_words("Hello World Python"))  # Python World Hello
+
+--- Check Palindrome ---
+def is_palindrome(s):
+    s = ''.join(c.lower() for c in s if c.isalnum())
+    return s == s[::-1]
+
+print(is_palindrome("A man a plan a canal Panama"))  # True
+print(is_palindrome("race a car"))                   # False
+
+--- Anagram Check ---
+Two strings are anagrams if they have same characters with same frequency.
+
+from collections import Counter
+
+def is_anagram(s, t):
+    return Counter(s) == Counter(t)
+
+print(is_anagram("listen", "silent"))  # True
+print(is_anagram("hello", "world"))    # False
+
+--- Count Character Frequency ---
+def char_frequency(s):
+    freq = {}
+    for ch in s:
+        freq[ch] = freq.get(ch, 0) + 1
+    return freq
+
+print(char_frequency("abracadabra"))
+# {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}
+
+--- KMP String Matching ---
+Find all occurrences of pattern in text.
+Time: O(n + m). Space: O(m). Efficient, no unnecessary comparisons.
+
+def kmp_search(text, pattern):
+    n, m = len(text), len(pattern)
+    if m == 0:
+        return [0]
+
+    # Build failure function
+    fail = [0] * m
+    j = 0
+    for i in range(1, m):
+        while j > 0 and pattern[i] != pattern[j]:
+            j = fail[j - 1]
+        if pattern[i] == pattern[j]:
+            j += 1
+        fail[i] = j
+
+    # Search
+    matches = []
+    j = 0
+    for i in range(n):
+        while j > 0 and text[i] != pattern[j]:
+            j = fail[j - 1]
+        if text[i] == pattern[j]:
+            j += 1
+        if j == m:
+            matches.append(i - m + 1)
+            j = fail[j - 1]
+    return matches
+
+print(kmp_search("aabaacaadaabaaba", "aaba"))  # [0, 9, 12]
+
+--- Rabin-Karp Rolling Hash ---
+Find pattern in text using hashing. Avg O(n+m), worst O(nm).
+
+def rabin_karp(text, pattern):
+    n, m = len(text), len(pattern)
+    BASE, MOD = 256, 101
+    pat_hash = text_hash = 0
+    h = pow(BASE, m - 1, MOD)
+    matches = []
+
+    for i in range(m):
+        pat_hash  = (BASE * pat_hash  + ord(pattern[i])) % MOD
+        text_hash = (BASE * text_hash + ord(text[i]))    % MOD
+
+    for i in range(n - m + 1):
+        if pat_hash == text_hash:
+            if text[i:i+m] == pattern:  # verify
+                matches.append(i)
+        if i < n - m:
+            text_hash = (BASE*(text_hash - ord(text[i])*h) + ord(text[i+m])) % MOD
+            if text_hash < 0:
+                text_hash += MOD
+    return matches
+
+print(rabin_karp("GEEKS FOR GEEKS", "GEEKS"))  # [0, 10]
+
+--- Longest Common Prefix ---
+def longest_common_prefix(strs):
+    if not strs:
+        return ""
+    prefix = strs[0]
+    for s in strs[1:]:
+        while not s.startswith(prefix):
+            prefix = prefix[:-1]
+        if not prefix:
+            return ""
+    return prefix
+
+print(longest_common_prefix(["flower","flow","flight"]))  # "fl"
+print(longest_common_prefix(["dog","racecar","car"]))     # ""
+
+--- Valid Parentheses ---
+def is_valid_parentheses(s):
+    stack = []
+    pairs = {')':'(', '}':'{', ']':'['}
+    for ch in s:
+        if ch in '({[':
+            stack.append(ch)
+        elif ch in ')}]':
+            if not stack or stack[-1] != pairs[ch]:
+                return False
+            stack.pop()
+    return not stack
+
+print(is_valid_parentheses("()[]{}"))    # True
+print(is_valid_parentheses("([)]"))      # False
+
+--- Roman to Integer ---
+def roman_to_int(s):
+    values = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
+    result = 0
+    for i in range(len(s)):
+        if i + 1 < len(s) and values[s[i]] < values[s[i+1]]:
+            result -= values[s[i]]
+        else:
+            result += values[s[i]]
+    return result
+
+print(roman_to_int("III"))    # 3
+print(roman_to_int("LVIII"))  # 58
+print(roman_to_int("MCMXCIV"))# 1994
+
+--- String Compression ---
+Compress "aabcccdddd" to "a2b1c3d4".
+
+def compress(s):
+    result = []
+    i = 0
+    while i < len(s):
+        ch = s[i]
+        count = 0
+        while i < len(s) and s[i] == ch:
+            count += 1
+            i += 1
+        result.append(ch + str(count))
+    compressed = ''.join(result)
+    return compressed if len(compressed) < len(s) else s
+
+print(compress("aabcccdddd"))  # a2b1c3d4
+print(compress("abcd"))        # abcd (no gain)
+
+--- Zigzag String Conversion ---
+Convert string to zigzag pattern across rows.
+
+def convert_zigzag(s, numRows):
+    if numRows == 1 or numRows >= len(s):
+        return s
+    rows = [''] * numRows
+    row, step = 0, 1
+    for ch in s:
+        rows[row] += ch
+        if row == 0: step = 1
+        if row == numRows - 1: step = -1
+        row += step
+    return ''.join(rows)
+
+print(convert_zigzag("PAYPALISHIRING", 3))  # PAHNAPLSIIGYIR

data/docs/trees.txt

@@ -0,0 +1,224 @@
+TREES AND BINARY TREES
+======================
+A tree is a hierarchical data structure. Root is the topmost node.
+Each node has at most one parent and zero or more children.
+Leaf nodes have no children.
+
+--- Binary Tree Node ---
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+# Build a sample tree:
+#        1
+#       / \
+#      2   3
+#     / \   \
+#    4   5   6
+root = TreeNode(1)
+root.left = TreeNode(2)
+root.right = TreeNode(3)
+root.left.left = TreeNode(4)
+root.left.right = TreeNode(5)
+root.right.right = TreeNode(6)
+
+--- Tree Traversals ---
+# Inorder (Left, Root, Right) — gives sorted output for BST
+def inorder(root):
+    if not root:
+        return []
+    return inorder(root.left) + [root.val] + inorder(root.right)
+
+# Preorder (Root, Left, Right) — used to copy the tree
+def preorder(root):
+    if not root:
+        return []
+    return [root.val] + preorder(root.left) + preorder(root.right)
+
+# Postorder (Left, Right, Root) — used to delete the tree
+def postorder(root):
+    if not root:
+        return []
+    return postorder(root.left) + postorder(root.right) + [root.val]
+
+# Level Order (BFS)
+from collections import deque
+def level_order(root):
+    if not root:
+        return []
+    result, queue = [], deque([root])
+    while queue:
+        node = queue.popleft()
+        result.append(node.val)
+        if node.left:  queue.append(node.left)
+        if node.right: queue.append(node.right)
+    return result
+
+print(inorder(root))     # [4, 2, 5, 1, 3, 6]
+print(preorder(root))    # [1, 2, 4, 5, 3, 6]
+print(postorder(root))   # [4, 5, 2, 6, 3, 1]
+print(level_order(root)) # [1, 2, 3, 4, 5, 6]
+
+--- Tree Height ---
+def height(root):
+    if not root:
+        return 0
+    return 1 + max(height(root.left), height(root.right))
+
+print(height(root))  # Output: 3
+
+--- Count Nodes ---
+def count_nodes(root):
+    if not root:
+        return 0
+    return 1 + count_nodes(root.left) + count_nodes(root.right)
+
+--- Binary Search Tree (BST) ---
+Left child < Parent < Right child.
+Insert, Search, Delete: O(log n) average, O(n) worst (skewed).
+
+# Insert into BST
+def bst_insert(root, val):
+    if not root:
+        return TreeNode(val)
+    if val < root.val:
+        root.left = bst_insert(root.left, val)
+    else:
+        root.right = bst_insert(root.right, val)
+    return root
+
+# Search in BST
+def bst_search(root, val):
+    if not root or root.val == val:
+        return root
+    if val < root.val:
+        return bst_search(root.left, val)
+    return bst_search(root.right, val)
+
+# Delete from BST
+def bst_delete(root, val):
+    if not root:
+        return None
+    if val < root.val:
+        root.left = bst_delete(root.left, val)
+    elif val > root.val:
+        root.right = bst_delete(root.right, val)
+    else:
+        if not root.left:
+            return root.right
+        if not root.right:
+            return root.left
+        # Find inorder successor (smallest in right subtree)
+        curr = root.right
+        while curr.left:
+            curr = curr.left
+        root.val = curr.val
+        root.right = bst_delete(root.right, curr.val)
+    return root
+
+bst = None
+for v in [5, 3, 7, 1, 4, 6, 8]:
+    bst = bst_insert(bst, v)
+print(inorder(bst))  # [1, 3, 4, 5, 6, 7, 8]
+
+--- Check if Balanced ---
+A tree is balanced if height difference of left and right subtrees is at most 1 for every node.
+
+def is_balanced(root):
+    def check(node):
+        if not node:
+            return 0
+        left  = check(node.left)
+        right = check(node.right)
+        if left == -1 or right == -1 or abs(left - right) > 1:
+            return -1
+        return 1 + max(left, right)
+    return check(root) != -1
+
+--- Lowest Common Ancestor (LCA) ---
+Find the lowest node that has both p and q as descendants.
+
+def lca(root, p, q):
+    if not root or root == p or root == q:
+        return root
+    left  = lca(root.left, p, q)
+    right = lca(root.right, p, q)
+    if left and right:
+        return root  # p and q on different sides
+    return left or right
+
+--- Level Order by Levels ---
+Return nodes grouped by level.
+
+def level_order_levels(root):
+    if not root:
+        return []
+    result, queue = [], deque([root])
+    while queue:
+        level = []
+        for _ in range(len(queue)):
+            node = queue.popleft()
+            level.append(node.val)
+            if node.left:  queue.append(node.left)
+            if node.right: queue.append(node.right)
+        result.append(level)
+    return result
+
+print(level_order_levels(root))
+# Output: [[1], [2, 3], [4, 5, 6]]
+
+--- Diameter of Binary Tree ---
+Longest path between any two nodes (path may not pass through root).
+
+def diameter(root):
+    max_d = [0]
+    def depth(node):
+        if not node:
+            return 0
+        left  = depth(node.left)
+        right = depth(node.right)
+        max_d[0] = max(max_d[0], left + right)
+        return 1 + max(left, right)
+    depth(root)
+    return max_d[0]
+
+--- Invert Binary Tree ---
+Mirror the tree — swap left and right children of every node.
+
+def invert_tree(root):
+    if not root:
+        return None
+    root.left, root.right = invert_tree(root.right), invert_tree(root.left)
+    return root
+
+--- AVL Tree (Self-Balancing BST) ---
+Keeps height O(log n) by rotating after every insert/delete.
+Balance factor = height(left) - height(right). Must be -1, 0, or 1.
+
+def get_height(node):
+    return node.height if node else 0
+
+def get_balance(node):
+    return get_height(node.left) - get_height(node.right) if node else 0
+
+# Right rotation
+def rotate_right(y):
+    x = y.left
+    T2 = x.right
+    x.right = y
+    y.left = T2
+    y.height = 1 + max(get_height(y.left), get_height(y.right))
+    x.height = 1 + max(get_height(x.left), get_height(x.right))
+    return x
+
+# Left rotation
+def rotate_left(x):
+    y = x.right
+    T2 = y.left
+    y.left = x
+    x.right = T2
+    x.height = 1 + max(get_height(x.left), get_height(x.right))
+    y.height = 1 + max(get_height(y.left), get_height(y.right))
+    return y

data/docs/two_pointers.txt

@@ -0,0 +1,204 @@
+TWO POINTERS AND SLIDING WINDOW
+================================
+
+--- TWO POINTERS TECHNIQUE ---
+Use two pointers (left and right) to scan an array from both ends or at different speeds.
+Reduces O(n^2) brute force to O(n).
+
+--- Two Sum (Sorted Array) ---
+Find two numbers that add up to target in a sorted array.
+Time: O(n). Space: O(1).
+
+def two_sum_sorted(arr, target):
+    left, right = 0, len(arr) - 1
+    while left < right:
+        total = arr[left] + arr[right]
+        if total == target:
+            return [left, right]
+        elif total < target:
+            left += 1
+        else:
+            right -= 1
+    return []
+
+print(two_sum_sorted([1, 2, 3, 4, 6], 6))  # [1, 3] (2+4)
+
+--- Reverse an Array In-Place ---
+def reverse_array(arr):
+    left, right = 0, len(arr) - 1
+    while left < right:
+        arr[left], arr[right] = arr[right], arr[left]
+        left += 1
+        right -= 1
+    return arr
+
+print(reverse_array([1, 2, 3, 4, 5]))  # [5, 4, 3, 2, 1]
+
+--- Remove Duplicates from Sorted Array ---
+Time: O(n). Space: O(1).
+
+def remove_duplicates(arr):
+    if not arr:
+        return 0
+    slow = 0
+    for fast in range(1, len(arr)):
+        if arr[fast] != arr[slow]:
+            slow += 1
+            arr[slow] = arr[fast]
+    return slow + 1  # length of unique part
+
+arr = [1, 1, 2, 2, 3, 4, 4]
+k = remove_duplicates(arr)
+print(arr[:k])  # [1, 2, 3, 4]
+
+--- Container With Most Water ---
+Find two lines that form container holding most water.
+Time: O(n). Space: O(1).
+
+def max_water(heights):
+    left, right = 0, len(heights) - 1
+    max_area = 0
+    while left < right:
+        area = min(heights[left], heights[right]) * (right - left)
+        max_area = max(max_area, area)
+        if heights[left] < heights[right]:
+            left += 1
+        else:
+            right -= 1
+    return max_area
+
+print(max_water([1,8,6,2,5,4,8,3,7]))  # Output: 49
+
+--- Three Sum ---
+Find all triplets that sum to zero.
+Time: O(n^2). Space: O(n).
+
+def three_sum(nums):
+    nums.sort()
+    result = []
+    for i in range(len(nums) - 2):
+        if i > 0 and nums[i] == nums[i-1]:
+            continue  # skip duplicates
+        left, right = i + 1, len(nums) - 1
+        while left < right:
+            total = nums[i] + nums[left] + nums[right]
+            if total == 0:
+                result.append([nums[i], nums[left], nums[right]])
+                while left < right and nums[left] == nums[left+1]: left += 1
+                while left < right and nums[right] == nums[right-1]: right -= 1
+                left += 1
+                right -= 1
+            elif total < 0:
+                left += 1
+            else:
+                right -= 1
+    return result
+
+print(three_sum([-1, 0, 1, 2, -1, -4]))
+# [[-1, -1, 2], [-1, 0, 1]]
+
+--- Trapping Rain Water ---
+Calculate water trapped between bars.
+Time: O(n). Space: O(1).
+
+def trap_water(height):
+    left, right = 0, len(height) - 1
+    left_max = right_max = 0
+    water = 0
+    while left < right:
+        if height[left] < height[right]:
+            if height[left] >= left_max:
+                left_max = height[left]
+            else:
+                water += left_max - height[left]
+            left += 1
+        else:
+            if height[right] >= right_max:
+                right_max = height[right]
+            else:
+                water += right_max - height[right]
+            right -= 1
+    return water
+
+print(trap_water([0,1,0,2,1,0,1,3,2,1,2,1]))  # Output: 6
+
+--- Slow/Fast Pointer: Detect Cycle ---
+def has_cycle(head):
+    slow = fast = head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+        if slow == fast:
+            return True
+    return False
+
+--- SLIDING WINDOW TECHNIQUE ---
+Maintain a window of fixed or variable size. Slide it across array.
+Avoids recomputing the entire window each step.
+
+--- Maximum Sum Subarray of Size K (Fixed Window) ---
+Time: O(n). Space: O(1).
+
+def max_sum_subarray(arr, k):
+    window_sum = sum(arr[:k])
+    max_sum = window_sum
+    for i in range(k, len(arr)):
+        window_sum += arr[i] - arr[i - k]
+        max_sum = max(max_sum, window_sum)
+    return max_sum
+
+print(max_sum_subarray([2,1,5,1,3,2], 3))  # Output: 9 (5+1+3)
+
+--- Longest Substring Without Repeating Characters (Variable Window) ---
+Time: O(n). Space: O(k) where k = charset size.
+
+def length_of_longest_substring(s):
+    char_index = {}
+    left = 0
+    max_len = 0
+    for right, ch in enumerate(s):
+        if ch in char_index and char_index[ch] >= left:
+            left = char_index[ch] + 1
+        char_index[ch] = right
+        max_len = max(max_len, right - left + 1)
+    return max_len
+
+print(length_of_longest_substring("abcabcbb"))  # 3 (abc)
+print(length_of_longest_substring("pwwkew"))    # 3 (wke)
+
+--- Minimum Size Subarray Sum ---
+Find smallest subarray with sum >= target.
+Time: O(n). Space: O(1).
+
+def min_subarray_len(target, nums):
+    left = 0
+    curr_sum = 0
+    min_len = float('inf')
+    for right in range(len(nums)):
+        curr_sum += nums[right]
+        while curr_sum >= target:
+            min_len = min(min_len, right - left + 1)
+            curr_sum -= nums[left]
+            left += 1
+    return min_len if min_len != float('inf') else 0
+
+print(min_subarray_len(7, [2,3,1,2,4,3]))  # Output: 2 (4+3)
+
+--- Longest Substring with K Distinct Characters ---
+Time: O(n). Space: O(k).
+
+def longest_k_distinct(s, k):
+    from collections import defaultdict
+    char_count = defaultdict(int)
+    left = max_len = 0
+    for right, ch in enumerate(s):
+        char_count[ch] += 1
+        while len(char_count) > k:
+            char_count[s[left]] -= 1
+            if char_count[s[left]] == 0:
+                del char_count[s[left]]
+            left += 1
+        max_len = max(max_len, right - left + 1)
+    return max_len
+
+print(longest_k_distinct("araaci", 2))  # Output: 4 (araa)

data/finetune_data.jsonl

@@ -0,0 +1,20 @@
+{"instruction": "What is binary search?", "input": "", "output": "Binary search is an efficient searching algorithm for sorted arrays. It works by repeatedly dividing the search interval in half. Time complexity: O(log n), Space complexity: O(1). Requires the array to be sorted beforehand."}
+{"instruction": "What is the time complexity of binary search?", "input": "", "output": "Binary search has a time complexity of O(log n) because it halves the search space with each step. Best case is O(1) when the middle element is the target. Space complexity is O(1) for iterative implementation."}
+{"instruction": "What is the difference between stack and queue?", "input": "", "output": "Stack uses LIFO (Last In First Out) - the last element added is the first to be removed. Operations: push and pop. Queue uses FIFO (First In First Out) - the first element added is the first to be removed. Operations: enqueue and dequeue. Both have O(1) operations."}
+{"instruction": "Explain merge sort.", "input": "", "output": "Merge sort is a divide-and-conquer sorting algorithm. It splits the array in half, recursively sorts each half, then merges the two sorted halves. Time complexity: O(n log n) in all cases. Space complexity: O(n). It is a stable sorting algorithm, making it good for sorting linked lists."}
+{"instruction": "What is quicksort?", "input": "", "output": "Quicksort is a divide-and-conquer algorithm that picks a pivot element and partitions the array into elements less than and greater than the pivot, then recursively sorts each partition. Average time: O(n log n), Worst case: O(n^2) when pivot is always smallest or largest element. Space: O(log n)."}
+{"instruction": "What is a linked list?", "input": "", "output": "A linked list is a linear data structure where elements are stored in nodes. Each node contains data and a pointer to the next node. Types: Singly (one direction), Doubly (both directions), Circular (last points to first). Advantage: dynamic size, O(1) insertion at head. Disadvantage: no random access, O(n) search."}
+{"instruction": "What is a Binary Search Tree?", "input": "", "output": "A Binary Search Tree (BST) is a binary tree where for every node, all values in the left subtree are less than the node's value, and all values in the right subtree are greater. This property enables O(log n) average search, insert, and delete operations. Worst case is O(n) for unbalanced trees."}
+{"instruction": "What is dynamic programming?", "input": "", "output": "Dynamic programming solves complex problems by breaking them into overlapping subproblems and storing results to avoid recomputation. Two approaches: Memoization (top-down, recursion with cache) and Tabulation (bottom-up, iterative). Requires optimal substructure and overlapping subproblems. Examples: Fibonacci, Knapsack, LCS, Coin Change."}
+{"instruction": "What are React hooks?", "input": "", "output": "React hooks are functions that let you use state and lifecycle features in functional components, introduced in React 16.8. Key hooks: useState for state management, useEffect for side effects like API calls, useContext for consuming context, useRef for DOM references. Rules: only call hooks at top level, only in React functions."}
+{"instruction": "What is useState in React?", "input": "", "output": "useState is a React hook for managing local component state. Syntax: const [state, setState] = useState(initialValue). It returns the current state value and a setter function. Calling setState triggers a re-render with the new value. Example: const [count, setCount] = useState(0) then setCount(count + 1) to increment."}
+{"instruction": "What is useEffect in React?", "input": "", "output": "useEffect is a React hook for handling side effects like API calls, subscriptions, and DOM updates. It runs after every render by default. The dependency array controls when it runs: empty array [] runs only on mount, [value] runs when value changes. Return a cleanup function to run on unmount. Syntax: useEffect(() => { effect }, [deps])."}
+{"instruction": "What is a REST API?", "input": "", "output": "REST API (Representational State Transfer) is an architectural style for web services using standard HTTP methods. GET retrieves resources, POST creates new resources, PUT updates resources completely, PATCH partially updates, DELETE removes resources. REST is stateless meaning each request contains all needed information. JSON is the most common response format."}
+{"instruction": "What HTTP methods does REST use?", "input": "", "output": "REST uses five main HTTP methods: GET for reading/retrieving data, POST for creating new resources, PUT for completely updating an existing resource, PATCH for partially updating a resource, and DELETE for removing a resource. These map to CRUD operations: Create (POST), Read (GET), Update (PUT/PATCH), Delete (DELETE)."}
+{"instruction": "What does HTTP status code 404 mean?", "input": "", "output": "HTTP status code 404 means Not Found. It indicates the server cannot find the requested resource. The URL may be wrong, the resource may have been deleted, or it may never have existed. Other important codes: 200 (OK), 201 (Created), 400 (Bad Request), 401 (Unauthorized), 403 (Forbidden), 500 (Internal Server Error)."}
+{"instruction": "What is CSS Flexbox?", "input": "", "output": "CSS Flexbox is a layout model that makes it easy to arrange items in a container. Activated by display: flex on the container. Key properties: flex-direction (row or column), justify-content (main axis alignment: flex-start, center, space-between), align-items (cross axis: stretch, center, flex-start), flex-wrap (allow wrapping). Items can have flex-grow to fill available space."}
+{"instruction": "What is a JavaScript Promise?", "input": "", "output": "A JavaScript Promise represents an asynchronous operation with three states: pending (initial), fulfilled (success), rejected (failure). Created with new Promise((resolve, reject) => {}). Consumed with .then() for success and .catch() for errors. async/await is syntactic sugar that makes promises look synchronous. Promise.all() runs multiple promises in parallel."}
+{"instruction": "What is inorder traversal?", "input": "", "output": "Inorder traversal visits tree nodes in Left, Root, Right order. For a Binary Search Tree, inorder traversal produces nodes in ascending sorted order. Algorithm: recursively visit left subtree, then process current node, then recursively visit right subtree. Time complexity: O(n) where n is number of nodes."}
+{"instruction": "What is the difference between BFS and DFS?", "input": "", "output": "BFS (Breadth-First Search) explores level by level using a queue data structure. It finds shortest path in unweighted graphs. DFS (Depth-First Search) explores as deep as possible using a stack or recursion. BFS is better for shortest path problems; DFS is better for cycle detection, topological sort, and finding connected components. Both have O(V+E) time complexity."}
+{"instruction": "What is memoization?", "input": "", "output": "Memoization is a top-down dynamic programming technique that caches results of expensive function calls and returns the cached result when the same inputs occur again. It uses recursion combined with a hash map or array to store computed values. For example, Fibonacci with memoization runs in O(n) instead of O(2^n). It trades space for time."}
+{"instruction": "What is flex-grow in CSS?", "input": "", "output": "flex-grow is a CSS Flexbox property that defines how much a flex item grows relative to other items when extra space is available in the container. A value of 0 means the item will not grow. A value of 1 means the item takes equal share of available space. If one item has flex-grow: 2 and another has flex-grow: 1, the first gets twice as much extra space."}

data/prepare_docs.py

@@ -0,0 +1,222 @@
+import os
+
+docs = {
+    "binary_search.txt": """Binary Search is an efficient algorithm for finding an item in a sorted list.
+It works by repeatedly dividing the search interval in half.
+Time Complexity: O(log n). Space Complexity: O(1).
+Steps:
+1) Find the middle element.
+2) If target equals middle, return index.
+3) If target < middle, search left half.
+4) Else search right half.
+Requires the array to be sorted before searching.
+Best case: O(1) when middle element is the target.
+""",
+
+    "stack_queue.txt": """Stack is a linear data structure following LIFO (Last In First Out) principle.
+Operations: push() adds element, pop() removes top element, peek() views top.
+All stack operations run in O(1) time.
+Use stack for: undo operations, expression evaluation, function call stack, DFS traversal.
+
+Queue follows FIFO (First In First Out) principle.
+Operations: enqueue() adds to rear, dequeue() removes from front.
+All queue operations run in O(1) time.
+Use queue for: BFS traversal, scheduling, print spooler, task queues.
+
+Key difference: Stack removes most recently added item; Queue removes oldest item.
+""",
+
+    "sorting_algorithms.txt": """Bubble Sort: repeatedly swaps adjacent elements if out of order.
+Time: O(n^2) average and worst. Space: O(1). Stable sort.
+
+Merge Sort: divide array in half, sort each half recursively, merge results.
+Time: O(n log n) all cases. Space: O(n). Stable sort. Best for linked lists.
+
+Quick Sort: picks a pivot element, partitions array around it, recursively sorts partitions.
+Time: O(n log n) average, O(n^2) worst case. Space: O(log n). Not stable.
+
+Insertion Sort: builds sorted array one element at a time by inserting each into correct position.
+Time: O(n^2) worst, O(n) best. Space: O(1). Good for small or nearly sorted arrays.
+
+Heap Sort: builds a max-heap, repeatedly extracts maximum element.
+Time: O(n log n). Space: O(1). Not stable.
+""",
+
+    "linked_list.txt": """Linked List is a linear data structure where elements are stored in nodes.
+Each node contains: data field + pointer to next node.
+
+Types:
+- Singly Linked List: each node points to next node only.
+- Doubly Linked List: each node has pointers to both next and previous nodes.
+- Circular Linked List: last node points back to first node.
+
+Advantages over arrays: dynamic size, O(1) insertion/deletion at head.
+Disadvantages: no random access (must traverse), extra memory for pointers.
+
+Operations: Insert at head O(1), Search O(n), Delete O(n), Access by index O(n).
+""",
+
+    "trees.txt": """Binary Tree: each node has at most 2 children called left and right child.
+Root is the topmost node. Leaf nodes have no children.
+
+Binary Search Tree (BST): left child < parent node < right child.
+Search, Insert, Delete all take O(log n) average, O(n) worst case.
+
+Tree Traversals:
+- Inorder (Left, Root, Right): gives sorted order for BST.
+- Preorder (Root, Left, Right): used to copy tree.
+- Postorder (Left, Right, Root): used to delete tree.
+- Level Order: BFS traversal level by level.
+
+Height of tree: number of edges on longest path from root to leaf.
+Balanced BST examples: AVL Tree, Red-Black Tree — guarantee O(log n) operations.
+""",
+
+    "dynamic_programming.txt": """Dynamic Programming (DP) solves problems by breaking into overlapping subproblems.
+Stores results of subproblems to avoid recomputation (memoization).
+
+Key properties required:
+1. Optimal substructure: optimal solution built from optimal subproblem solutions.
+2. Overlapping subproblems: same subproblems solved multiple times.
+
+Approaches:
+- Top-down (Memoization): recursion + cache results in a table.
+- Bottom-up (Tabulation): fill table iteratively from smallest subproblems.
+
+Classic DP problems:
+- Fibonacci: O(2^n) naive → O(n) with DP.
+- 0/1 Knapsack: maximize value within weight limit.
+- Longest Common Subsequence (LCS).
+- Coin Change: minimum coins to make a sum.
+- Longest Increasing Subsequence.
+""",
+
+    "react_hooks.txt": """React Hooks are functions that let you use state and lifecycle features in functional components.
+Introduced in React 16.8 to replace class components.
+
+useState: manages local component state.
+Syntax: const [state, setState] = useState(initialValue)
+Example: const [count, setCount] = useState(0)
+
+useEffect: handles side effects like API calls, subscriptions, DOM updates.
+Runs after every render by default.
+Syntax: useEffect(() => { /* effect */ }, [dependencies])
+Empty dependency array [] means run only once on mount.
+
+useContext: consume React context without wrapping in Consumer component.
+Syntax: const value = useContext(MyContext)
+
+useRef: holds mutable value that does not trigger re-render. Also used to access DOM elements.
+
+Rules of Hooks:
+1. Only call hooks at the top level (not inside loops or conditions).
+2. Only call hooks from React function components or custom hooks.
+""",
+
+    "rest_api.txt": """REST API (Representational State Transfer) is an architectural style for web services.
+REST uses standard HTTP methods to perform operations on resources.
+
+HTTP Methods:
+- GET: retrieve/read resource. No request body.
+- POST: create new resource. Data sent in request body.
+- PUT: update existing resource completely.
+- PATCH: partially update a resource.
+- DELETE: remove a resource.
+
+HTTP Status Codes:
+- 200 OK: request succeeded.
+- 201 Created: new resource created successfully.
+- 400 Bad Request: invalid request from client.
+- 401 Unauthorized: authentication required.
+- 403 Forbidden: authenticated but not authorized.
+- 404 Not Found: resource does not exist.
+- 500 Internal Server Error: server-side error.
+
+REST principles: Stateless, Client-Server, Cacheable, Uniform Interface.
+JSON is the most common data format for REST API responses.
+""",
+
+    "css_flexbox.txt": """CSS Flexbox (Flexible Box Layout) is a layout model for arranging items in a container.
+Activated by setting display: flex on a container element.
+
+Container properties:
+- flex-direction: row (default, horizontal) or column (vertical).
+- justify-content: aligns items on main axis. Values: flex-start, flex-end, center, space-between, space-around.
+- align-items: aligns items on cross axis. Values: stretch (default), flex-start, flex-end, center.
+- flex-wrap: nowrap (default) or wrap to allow items to move to next line.
+- gap: space between flex items.
+
+Item properties:
+- flex-grow: how much item grows relative to siblings. 0 means no grow.
+- flex-shrink: how much item shrinks when space is limited.
+- flex-basis: initial size of item before flex calculations.
+- align-self: overrides align-items for a single item.
+
+Shorthand: flex: grow shrink basis (e.g., flex: 1 1 auto)
+""",
+
+    "javascript_promises.txt": """JavaScript Promises handle asynchronous operations in a cleaner way than callbacks.
+
+Promise States:
+- Pending: initial state, operation not complete.
+- Fulfilled: operation completed successfully.
+- Rejected: operation failed.
+
+Creating a Promise:
+const myPromise = new Promise((resolve, reject) => {
+  if (success) resolve(result);
+  else reject(error);
+});
+
+Consuming a Promise:
+myPromise
+  .then(result => console.log(result))
+  .catch(error => console.error(error))
+  .finally(() => console.log('always runs'));
+
+async/await syntax (ES2017) is syntactic sugar over promises:
+async function fetchData() {
+  try {
+    const data = await fetch(url);
+    const json = await data.json();
+    return json;
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+Promise utility methods:
+- Promise.all([p1, p2]): runs in parallel, resolves when all resolve.
+- Promise.race([p1, p2]): resolves/rejects with first settled promise.
+- Promise.allSettled(): waits for all, returns all results regardless of success/failure.
+""",
+
+    "graph_algorithms.txt": """Graph is a data structure with nodes (vertices) connected by edges.
+Types: Directed/Undirected, Weighted/Unweighted, Cyclic/Acyclic.
+
+Representations:
+- Adjacency Matrix: 2D array. O(1) edge lookup, O(V^2) space.
+- Adjacency List: array of lists. O(V+E) space. Better for sparse graphs.
+
+BFS (Breadth-First Search):
+Explores level by level using a queue. Time: O(V+E).
+Used for: shortest path in unweighted graph, level-order traversal.
+
+DFS (Depth-First Search):
+Explores as far as possible using stack/recursion. Time: O(V+E).
+Used for: cycle detection, topological sort, connected components.
+
+Dijkstra's Algorithm: shortest path in weighted graph with non-negative edges.
+Time: O((V+E) log V) with priority queue.
+
+Topological Sort: linear ordering of vertices where each directed edge u→v means u comes before v.
+Only valid for Directed Acyclic Graphs (DAGs).
+"""
+}
+
+os.makedirs("docs", exist_ok=True)
+for filename, content in docs.items():
+    with open(f"docs/{filename}", "w", encoding="utf-8") as f:
+        f.write(content.strip())
+
+print(f"Created {len(docs)} documents in docs/")

data/prepare_finetune.py

@@ -0,0 +1,91 @@
+import json
+import os
+
+qa_pairs = [
+    {"instruction": "What is binary search?",
+     "input": "",
+     "output": "Binary search is an efficient searching algorithm for sorted arrays. It works by repeatedly dividing the search interval in half. Time complexity: O(log n), Space complexity: O(1). Requires the array to be sorted beforehand."},
+
+    {"instruction": "What is the time complexity of binary search?",
+     "input": "",
+     "output": "Binary search has a time complexity of O(log n) because it halves the search space with each step. Best case is O(1) when the middle element is the target. Space complexity is O(1) for iterative implementation."},
+
+    {"instruction": "What is the difference between stack and queue?",
+     "input": "",
+     "output": "Stack uses LIFO (Last In First Out) - the last element added is the first to be removed. Operations: push and pop. Queue uses FIFO (First In First Out) - the first element added is the first to be removed. Operations: enqueue and dequeue. Both have O(1) operations."},
+
+    {"instruction": "Explain merge sort.",
+     "input": "",
+     "output": "Merge sort is a divide-and-conquer sorting algorithm. It splits the array in half, recursively sorts each half, then merges the two sorted halves. Time complexity: O(n log n) in all cases. Space complexity: O(n). It is a stable sorting algorithm, making it good for sorting linked lists."},
+
+    {"instruction": "What is quicksort?",
+     "input": "",
+     "output": "Quicksort is a divide-and-conquer algorithm that picks a pivot element and partitions the array into elements less than and greater than the pivot, then recursively sorts each partition. Average time: O(n log n), Worst case: O(n^2) when pivot is always smallest or largest element. Space: O(log n)."},
+
+    {"instruction": "What is a linked list?",
+     "input": "",
+     "output": "A linked list is a linear data structure where elements are stored in nodes. Each node contains data and a pointer to the next node. Types: Singly (one direction), Doubly (both directions), Circular (last points to first). Advantage: dynamic size, O(1) insertion at head. Disadvantage: no random access, O(n) search."},
+
+    {"instruction": "What is a Binary Search Tree?",
+     "input": "",
+     "output": "A Binary Search Tree (BST) is a binary tree where for every node, all values in the left subtree are less than the node's value, and all values in the right subtree are greater. This property enables O(log n) average search, insert, and delete operations. Worst case is O(n) for unbalanced trees."},
+
+    {"instruction": "What is dynamic programming?",
+     "input": "",
+     "output": "Dynamic programming solves complex problems by breaking them into overlapping subproblems and storing results to avoid recomputation. Two approaches: Memoization (top-down, recursion with cache) and Tabulation (bottom-up, iterative). Requires optimal substructure and overlapping subproblems. Examples: Fibonacci, Knapsack, LCS, Coin Change."},
+
+    {"instruction": "What are React hooks?",
+     "input": "",
+     "output": "React hooks are functions that let you use state and lifecycle features in functional components, introduced in React 16.8. Key hooks: useState for state management, useEffect for side effects like API calls, useContext for consuming context, useRef for DOM references. Rules: only call hooks at top level, only in React functions."},
+
+    {"instruction": "What is useState in React?",
+     "input": "",
+     "output": "useState is a React hook for managing local component state. Syntax: const [state, setState] = useState(initialValue). It returns the current state value and a setter function. Calling setState triggers a re-render with the new value. Example: const [count, setCount] = useState(0) then setCount(count + 1) to increment."},
+
+    {"instruction": "What is useEffect in React?",
+     "input": "",
+     "output": "useEffect is a React hook for handling side effects like API calls, subscriptions, and DOM updates. It runs after every render by default. The dependency array controls when it runs: empty array [] runs only on mount, [value] runs when value changes. Return a cleanup function to run on unmount. Syntax: useEffect(() => { effect }, [deps])."},
+
+    {"instruction": "What is a REST API?",
+     "input": "",
+     "output": "REST API (Representational State Transfer) is an architectural style for web services using standard HTTP methods. GET retrieves resources, POST creates new resources, PUT updates resources completely, PATCH partially updates, DELETE removes resources. REST is stateless meaning each request contains all needed information. JSON is the most common response format."},
+
+    {"instruction": "What HTTP methods does REST use?",
+     "input": "",
+     "output": "REST uses five main HTTP methods: GET for reading/retrieving data, POST for creating new resources, PUT for completely updating an existing resource, PATCH for partially updating a resource, and DELETE for removing a resource. These map to CRUD operations: Create (POST), Read (GET), Update (PUT/PATCH), Delete (DELETE)."},
+
+    {"instruction": "What does HTTP status code 404 mean?",
+     "input": "",
+     "output": "HTTP status code 404 means Not Found. It indicates the server cannot find the requested resource. The URL may be wrong, the resource may have been deleted, or it may never have existed. Other important codes: 200 (OK), 201 (Created), 400 (Bad Request), 401 (Unauthorized), 403 (Forbidden), 500 (Internal Server Error)."},
+
+    {"instruction": "What is CSS Flexbox?",
+     "input": "",
+     "output": "CSS Flexbox is a layout model that makes it easy to arrange items in a container. Activated by display: flex on the container. Key properties: flex-direction (row or column), justify-content (main axis alignment: flex-start, center, space-between), align-items (cross axis: stretch, center, flex-start), flex-wrap (allow wrapping). Items can have flex-grow to fill available space."},
+
+    {"instruction": "What is a JavaScript Promise?",
+     "input": "",
+     "output": "A JavaScript Promise represents an asynchronous operation with three states: pending (initial), fulfilled (success), rejected (failure). Created with new Promise((resolve, reject) => {}). Consumed with .then() for success and .catch() for errors. async/await is syntactic sugar that makes promises look synchronous. Promise.all() runs multiple promises in parallel."},
+
+    {"instruction": "What is inorder traversal?",
+     "input": "",
+     "output": "Inorder traversal visits tree nodes in Left, Root, Right order. For a Binary Search Tree, inorder traversal produces nodes in ascending sorted order. Algorithm: recursively visit left subtree, then process current node, then recursively visit right subtree. Time complexity: O(n) where n is number of nodes."},
+
+    {"instruction": "What is the difference between BFS and DFS?",
+     "input": "",
+     "output": "BFS (Breadth-First Search) explores level by level using a queue data structure. It finds shortest path in unweighted graphs. DFS (Depth-First Search) explores as deep as possible using a stack or recursion. BFS is better for shortest path problems; DFS is better for cycle detection, topological sort, and finding connected components. Both have O(V+E) time complexity."},
+
+    {"instruction": "What is memoization?",
+     "input": "",
+     "output": "Memoization is a top-down dynamic programming technique that caches results of expensive function calls and returns the cached result when the same inputs occur again. It uses recursion combined with a hash map or array to store computed values. For example, Fibonacci with memoization runs in O(n) instead of O(2^n). It trades space for time."},
+
+    {"instruction": "What is flex-grow in CSS?",
+     "input": "",
+     "output": "flex-grow is a CSS Flexbox property that defines how much a flex item grows relative to other items when extra space is available in the container. A value of 0 means the item will not grow. A value of 1 means the item takes equal share of available space. If one item has flex-grow: 2 and another has flex-grow: 1, the first gets twice as much extra space."},
+]
+
+output_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "finetune_data.jsonl")
+with open(output_path, "w", encoding="utf-8") as f:
+    for pair in qa_pairs:
+        f.write(json.dumps(pair) + "\n")
+
+print(f"Saved {len(qa_pairs)} training examples to data/finetune_data.jsonl")

data/prepare_questions.py

@@ -0,0 +1,66 @@
+import csv
+import os
+
+questions = [
+    "What is binary search?",
+    "What is the time complexity of binary search?",
+    "When can you use binary search?",
+    "Explain bubble sort.",
+    "What is the difference between stack and queue?",
+    "What is LIFO?",
+    "What is FIFO?",
+    "Explain merge sort.",
+    "What is quicksort?",
+    "What is the worst case time complexity of quicksort?",
+    "What is a linked list?",
+    "What is the difference between array and linked list?",
+    "What is a doubly linked list?",
+    "What is a binary tree?",
+    "What is a Binary Search Tree?",
+    "What is inorder traversal?",
+    "What is the difference between BFS and DFS?",
+    "What is dynamic programming?",
+    "What is memoization?",
+    "What is the difference between memoization and tabulation?",
+    "Explain the coin change problem.",
+    "What is React?",
+    "What are React hooks?",
+    "What is useState in React?",
+    "What is useEffect in React?",
+    "What is a REST API?",
+    "What HTTP methods does REST use?",
+    "What does HTTP status code 404 mean?",
+    "What does HTTP status code 200 mean?",
+    "What is CSS Flexbox?",
+    "What does justify-content do in Flexbox?",
+    "What is a JavaScript Promise?",
+    "What are the three states of a Promise?",
+    "What is async/await in JavaScript?",
+    "What is Promise.all()?",
+    "What is insertion sort?",
+    "What is heap sort?",
+    "What is a graph in data structures?",
+    "What is Dijkstra algorithm?",
+    "What is topological sort?",
+    "What is the difference between stack and heap memory?",
+    "What is a circular linked list?",
+    "What is an AVL tree?",
+    "What is the difference between preorder and postorder traversal?",
+    "What is the knapsack problem?",
+    "What is the longest common subsequence?",
+    "What is flex-grow in CSS?",
+    "What is useContext in React?",
+    "What is useRef in React?",
+    "What is the difference between PUT and PATCH in REST?",
+]
+
+os.makedirs(os.path.dirname(os.path.abspath(__file__)), exist_ok=True)
+
+output_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "questions.csv")
+with open(output_path, "w", newline="", encoding="utf-8") as f:
+    writer = csv.writer(f)
+    writer.writerow(["id", "question"])
+    for i, q in enumerate(questions, 1):
+        writer.writerow([i, q])
+
+print(f"Created {len(questions)} questions in data/questions.csv")

data/questions.csv

@@ -0,0 +1,51 @@
+id,question
+1,What is binary search?
+2,What is the time complexity of binary search?
+3,When can you use binary search?
+4,Explain bubble sort.
+5,What is the difference between stack and queue?
+6,What is LIFO?
+7,What is FIFO?
+8,Explain merge sort.
+9,What is quicksort?
+10,What is the worst case time complexity of quicksort?
+11,What is a linked list?
+12,What is the difference between array and linked list?
+13,What is a doubly linked list?
+14,What is a binary tree?
+15,What is a Binary Search Tree?
+16,What is inorder traversal?
+17,What is the difference between BFS and DFS?
+18,What is dynamic programming?
+19,What is memoization?
+20,What is the difference between memoization and tabulation?
+21,Explain the coin change problem.
+22,What is React?
+23,What are React hooks?
+24,What is useState in React?
+25,What is useEffect in React?
+26,What is a REST API?
+27,What HTTP methods does REST use?
+28,What does HTTP status code 404 mean?
+29,What does HTTP status code 200 mean?
+30,What is CSS Flexbox?
+31,What does justify-content do in Flexbox?
+32,What is a JavaScript Promise?
+33,What are the three states of a Promise?
+34,What is async/await in JavaScript?
+35,What is Promise.all()?
+36,What is insertion sort?
+37,What is heap sort?
+38,What is a graph in data structures?
+39,What is Dijkstra algorithm?
+40,What is topological sort?
+41,What is the difference between stack and heap memory?
+42,What is a circular linked list?
+43,What is an AVL tree?
+44,What is the difference between preorder and postorder traversal?
+45,What is the knapsack problem?
+46,What is the longest common subsequence?
+47,What is flex-grow in CSS?
+48,What is useContext in React?
+49,What is useRef in React?
+50,What is the difference between PUT and PATCH in REST?

demo.py

@@ -0,0 +1,409 @@
+import os
+import streamlit as st
+from system1_baseline import ask_baseline
+from system2_rag import ask_rag, load_vectorstore, build_vectorstore
+
+st.set_page_config(
+    page_title="CodeSage",
+    page_icon="🧙",
+    layout="wide"
+)
+
+# ── Session state init ────────────────────────────────────────────────────────
+if "ratings" not in st.session_state:
+    st.session_state.ratings = []          # list of rating dicts
+if "last_results" not in st.session_state:
+    st.session_state.last_results = None   # most recent answers
+if "rating_submitted" not in st.session_state:
+    st.session_state.rating_submitted = False
+
+# ── Custom CSS ────────────────────────────────────────────────────────────────
+st.markdown("""
+<style>
+/* System 1 — Blue */
+.card-blue {
+    background: linear-gradient(135deg, #0d1f3c, #102a4c);
+    border: 1px solid #2563eb;
+    border-top: 4px solid #3b82f6;
+    border-radius: 12px;
+    padding: 20px;
+    margin-top: 10px;
+    min-height: 180px;
+}
+.card-blue .answer { color: #93c5fd; font-size: 15px; line-height: 1.7; }
+.card-blue .time   { color: #60a5fa; font-size: 13px; margin-top: 12px; }
+
+/* System 2 — Teal/Green */
+.card-teal {
+    background: linear-gradient(135deg, #052e1c, #063d24);
+    border: 1px solid #059669;
+    border-top: 4px solid #10b981;
+    border-radius: 12px;
+    padding: 20px;
+    margin-top: 10px;
+    min-height: 180px;
+}
+.card-teal .answer  { color: #6ee7b7; font-size: 15px; line-height: 1.7; }
+.card-teal .time    { color: #34d399; font-size: 13px; margin-top: 12px; }
+.card-teal .context { background: #063d24; border: 1px solid #065f46; border-radius: 8px;
+                      padding: 12px; margin-top: 14px; color: #a7f3d0;
+                      font-size: 13px; line-height: 1.6; }
+.card-teal .ctx-label { color: #6ee7b7; font-size: 12px; font-weight: 600;
+                         margin-bottom: 6px; text-transform: uppercase; letter-spacing: 0.5px; }
+
+/* System 3 — Purple */
+.card-purple {
+    background: linear-gradient(135deg, #1a0a2e, #220d3b);
+    border: 1px solid #7c3aed;
+    border-top: 4px solid #8b5cf6;
+    border-radius: 12px;
+    padding: 20px;
+    margin-top: 10px;
+    min-height: 180px;
+}
+.card-purple .answer { color: #c4b5fd; font-size: 15px; line-height: 1.7; }
+.card-purple .time   { color: #a78bfa; font-size: 13px; margin-top: 12px; }
+
+/* Section headers */
+.sys-header { font-size: 18px; font-weight: 700; margin-bottom: 2px; }
+.sys-blue   { color: #3b82f6; }
+.sys-teal   { color: #10b981; }
+.sys-purple { color: #8b5cf6; }
+
+/* Rating box */
+.rating-box {
+    background: #111827;
+    border: 1px solid #374151;
+    border-radius: 12px;
+    padding: 18px 20px;
+    margin-top: 8px;
+}
+
+/* Eval table */
+.eval-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 14px;
+    margin-top: 10px;
+}
+.eval-table th {
+    padding: 12px 16px;
+    text-align: center;
+    font-weight: 700;
+    font-size: 15px;
+    border-bottom: 2px solid #374151;
+}
+.eval-table th:first-child { text-align: left; color: #9ca3af; }
+.eval-table th.col-blue   { color: #3b82f6; }
+.eval-table th.col-teal   { color: #10b981; }
+.eval-table th.col-purple { color: #8b5cf6; }
+.eval-table td {
+    padding: 11px 16px;
+    text-align: center;
+    border-bottom: 1px solid #1f2937;
+    color: #d1d5db;
+}
+.eval-table td:first-child { text-align: left; color: #9ca3af; font-weight: 600; }
+.eval-table tr:hover td { background: #111827; }
+.badge {
+    display: inline-block;
+    padding: 3px 10px;
+    border-radius: 12px;
+    font-weight: 700;
+    font-size: 13px;
+}
+.badge-green  { background: #052e1c; color: #10b981; border: 1px solid #059669; }
+.badge-yellow { background: #1c1a05; color: #f59e0b; border: 1px solid #d97706; }
+.badge-red    { background: #2e0505; color: #ef4444; border: 1px solid #dc2626; }
+.badge-grey   { background: #1f2937; color: #6b7280; border: 1px solid #374151; }
+.metric-note  { color: #6b7280; font-size: 12px; font-weight: 400; }
+</style>
+""", unsafe_allow_html=True)
+
+# ── Title ─────────────────────────────────────────────────────────────────────
+st.title("🧙 CODESAGE")
+st.markdown(
+    "**Comparative Study — RAG vs Fine-Tuning for Domain-Specific QA**  \n"
+    "Ask the same question to all 3 systems and compare their answers."
+)
+
+# ── Load vector store once ────────────────────────────────────────────────────
+@st.cache_resource(show_spinner="Building knowledge base...")
+def get_vectorstore():
+    if not os.path.exists("data/faiss_index"):
+        return build_vectorstore()
+    return load_vectorstore()
+
+vs = get_vectorstore()
+
+# ── Input ─────────────────────────────────────────────────────────────────────
+st.divider()
+question = st.text_input(
+    "Enter your question:",
+    placeholder="e.g. What is binary search? / What are React hooks? / Explain merge sort."
+)
+
+sample_questions = [
+    "What is binary search?",
+    "What is the difference between stack and queue?",
+    "Explain merge sort.",
+    "What are React hooks?",
+    "What is a REST API?",
+    "What is dynamic programming?",
+]
+
+st.markdown("**Quick questions:**")
+cols = st.columns(len(sample_questions))
+for i, sq in enumerate(sample_questions):
+    if cols[i].button(sq, key=f"sq_{i}"):
+        question = sq
+
+# ── Run systems ───────────────────────────────────────────────────────────────
+if st.button("Ask All 3 Systems", type="primary") and question:
+    st.session_state.rating_submitted = False  # reset for new question
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown('<p class="sys-header sys-blue">System 1 — Baseline LLM</p>', unsafe_allow_html=True)
+        st.caption("Prompt only. No extra knowledge.")
+        with st.spinner("Generating..."):
+            r1 = ask_baseline(question)
+
+    with col2:
+        st.markdown('<p class="sys-header sys-teal">System 2 — RAG Chatbot</p>', unsafe_allow_html=True)
+        st.caption("Retrieves from knowledge base, then generates.")
+        with st.spinner("Retrieving + generating..."):
+            r2 = ask_rag(question, vs)
+
+    with col3:
+        st.markdown('<p class="sys-header sys-purple">System 3 — Fine-Tuned Model</p>', unsafe_allow_html=True)
+        st.caption("TinyLlama fine-tuned on programming Q&A via LoRA.")
+        if os.path.exists("./finetuned_model"):
+            with st.spinner("Generating..."):
+                from system3_inference import ask_finetuned
+                r3 = ask_finetuned(question)
+        else:
+            r3 = {"answer": "Model not available.", "response_time": 0}
+
+    # persist results so they survive reruns
+    st.session_state.last_results = {
+        "question": question,
+        "r1": r1, "r2": r2, "r3": r3,
+    }
+
+# ── Always render answers if they exist ───────────────────────────────────────
+if st.session_state.last_results:
+    res = st.session_state.last_results
+    r1, r2, r3 = res["r1"], res["r2"], res["r3"]
+
+    st.divider()
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown('<p class="sys-header sys-blue">System 1 — Baseline LLM</p>', unsafe_allow_html=True)
+        st.caption("Prompt only. No extra knowledge.")
+        st.markdown(f"""
+        <div class="card-blue">
+            <div class="answer">{r1['answer']}</div>
+            <div class="time">⏱️ Response Time: {r1['response_time']}s</div>
+        </div>
+        """, unsafe_allow_html=True)
+
+    with col2:
+        st.markdown('<p class="sys-header sys-teal">System 2 — RAG Chatbot</p>', unsafe_allow_html=True)
+        st.caption("Retrieves from knowledge base, then generates.")
+        st.markdown(f"""
+        <div class="card-teal">
+            <div class="answer">{r2['answer']}</div>
+            <div class="time">⏱️ Response Time: {r2['response_time']}s</div>
+            <div class="context">
+                <div class="ctx-label">📄 Context retrieved from knowledge base</div>
+                {r2['context_used']}
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+    with col3:
+        st.markdown('<p class="sys-header sys-purple">System 3 — Fine-Tuned Model</p>', unsafe_allow_html=True)
+        st.caption("TinyLlama fine-tuned on programming Q&A via LoRA.")
+        if r3["answer"] == "Model not available.":
+            st.warning(
+                "Fine-tuned model not ready yet.  \n"
+                "Run `system3_finetune_colab.ipynb` on Google Colab, "
+                "download `finetuned_model.zip`, and unzip it here."
+            )
+        else:
+            st.markdown(f"""
+            <div class="card-purple">
+                <div class="answer">{r3['answer']}</div>
+                <div class="time">⏱️ Response Time: {r3['response_time']}s</div>
+            </div>
+            """, unsafe_allow_html=True)
+
+# ── Rating section ─────────────────────────────────────────────────────────────
+if st.session_state.last_results and not st.session_state.rating_submitted:
+    st.divider()
+    st.subheader("Rate the Answers")
+    st.caption("Your ratings are used to build the live evaluation table below.")
+
+    rc1, rc2, rc3 = st.columns(3)
+
+    with rc1:
+        st.markdown("**System 1 — Baseline LLM**")
+        c1_correct = st.slider("Correctness (1–5)", 1, 5, 3, key="c1_correct")
+        c1_halluc  = st.checkbox("Hallucination detected?", key="c1_halluc")
+        c1_complete= st.slider("Completeness (1–5)", 1, 5, 3, key="c1_complete")
+
+    with rc2:
+        st.markdown("**System 2 — RAG Chatbot**")
+        c2_correct = st.slider("Correctness (1–5)", 1, 5, 3, key="c2_correct")
+        c2_halluc  = st.checkbox("Hallucination detected?", key="c2_halluc")
+        c2_complete= st.slider("Completeness (1–5)", 1, 5, 3, key="c2_complete")
+
+    with rc3:
+        st.markdown("**System 3 — Fine-Tuned**")
+        c3_correct = st.slider("Correctness (1–5)", 1, 5, 3, key="c3_correct")
+        c3_halluc  = st.checkbox("Hallucination detected?", key="c3_halluc")
+        c3_complete= st.slider("Completeness (1–5)", 1, 5, 3, key="c3_complete")
+
+    if st.button("Submit Ratings", type="primary"):
+        res = st.session_state.last_results
+        st.session_state.ratings.append({
+            "question":    res["question"],
+            # correctness
+            "c1_correct":  c1_correct,
+            "c2_correct":  c2_correct,
+            "c3_correct":  c3_correct,
+            # hallucination (1 = yes, 0 = no)
+            "c1_halluc":   1 if c1_halluc  else 0,
+            "c2_halluc":   1 if c2_halluc  else 0,
+            "c3_halluc":   1 if c3_halluc  else 0,
+            # completeness
+            "c1_complete": c1_complete,
+            "c2_complete": c2_complete,
+            "c3_complete": c3_complete,
+            # response times (auto)
+            "c1_time":     res["r1"]["response_time"],
+            "c2_time":     res["r2"]["response_time"],
+            "c3_time":     res["r3"]["response_time"],
+        })
+        st.session_state.rating_submitted = True
+        st.success(f"Rating saved! Total questions rated: {len(st.session_state.ratings)}")
+        st.rerun()
+
+# ── Metrics table (live) ───────────────────────────────────────────────────────
+st.divider()
+st.subheader("Evaluation Metrics Comparison")
+
+ratings = st.session_state.ratings
+n = len(ratings)
+
+if n == 0:
+    st.caption("No ratings yet. Ask a question and rate the answers to populate this table.")
+
+    # show placeholder dashes
+    def badge(val, _n):
+        return f'<span class="badge badge-grey">—</span>'
+else:
+    st.caption(f"Based on **{n} question(s)** rated by you. Response time is measured automatically.")
+
+    def avg(key):
+        return round(sum(r[key] for r in ratings) / n, 2)
+
+    def pct(key):
+        return round(sum(r[key] for r in ratings) / n * 100)
+
+    def color_correct(v):
+        if v >= 4.0: return "badge-green"
+        if v >= 3.0: return "badge-yellow"
+        return "badge-red"
+
+    def color_halluc(v):   # lower = better
+        if v <= 15:  return "badge-green"
+        if v <= 30:  return "badge-yellow"
+        return "badge-red"
+
+    def color_complete(v):
+        if v >= 4.0: return "badge-green"
+        if v >= 3.0: return "badge-yellow"
+        return "badge-red"
+
+    def color_time(v):     # lower = better
+        if v <= 1.0: return "badge-green"
+        if v <= 2.0: return "badge-yellow"
+        return "badge-red"
+
+    v_c1 = avg("c1_correct");  v_c2 = avg("c2_correct");  v_c3 = avg("c3_correct")
+    v_h1 = pct("c1_halluc");   v_h2 = pct("c2_halluc");   v_h3 = pct("c3_halluc")
+    v_p1 = avg("c1_complete"); v_p2 = avg("c2_complete"); v_p3 = avg("c3_complete")
+    v_t1 = avg("c1_time");     v_t2 = avg("c2_time");     v_t3 = avg("c3_time")
+
+    def badge(val, cls):
+        return f'<span class="badge {cls}">{val}</span>'
+
+    row_correct  = (badge(f"{v_c1}/5", color_correct(v_c1)),
+                    badge(f"{v_c2}/5", color_correct(v_c2)),
+                    badge(f"{v_c3}/5", color_correct(v_c3)))
+    row_halluc   = (badge(f"{v_h1}%",  color_halluc(v_h1)),
+                    badge(f"{v_h2}%",  color_halluc(v_h2)),
+                    badge(f"{v_h3}%",  color_halluc(v_h3)))
+    row_complete = (badge(f"{v_p1}/5", color_complete(v_p1)),
+                    badge(f"{v_p2}/5", color_complete(v_p2)),
+                    badge(f"{v_p3}/5", color_complete(v_p3)))
+    row_time     = (badge(f"{v_t1}s",  color_time(v_t1)),
+                    badge(f"{v_t2}s",  color_time(v_t2)),
+                    badge(f"{v_t3}s",  color_time(v_t3)))
+
+if n == 0:
+    dash = '<span class="badge badge-grey">—</span>'
+    row_correct = row_halluc = row_complete = row_time = (dash, dash, dash)
+
+st.markdown(f"""
+<table class="eval-table">
+  <thead>
+    <tr>
+      <th>Metric</th>
+      <th class="col-blue">System 1<br><span style="font-weight:400;font-size:12px">Baseline LLM</span></th>
+      <th class="col-teal">System 2<br><span style="font-weight:400;font-size:12px">RAG Chatbot</span></th>
+      <th class="col-purple">System 3<br><span style="font-weight:400;font-size:12px">Fine-Tuned</span></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Correctness Score <span class="metric-note">(1–5, user rated)</span></td>
+      <td>{row_correct[0]}</td><td>{row_correct[1]}</td><td>{row_correct[2]}</td>
+    </tr>
+    <tr>
+      <td>Hallucination Rate <span class="metric-note">(%, user rated)</span></td>
+      <td>{row_halluc[0]}</td><td>{row_halluc[1]}</td><td>{row_halluc[2]}</td>
+    </tr>
+    <tr>
+      <td>Answer Completeness <span class="metric-note">(1–5, user rated)</span></td>
+      <td>{row_complete[0]}</td><td>{row_complete[1]}</td><td>{row_complete[2]}</td>
+    </tr>
+    <tr>
+      <td>Avg Response Time <span class="metric-note">(seconds, auto)</span></td>
+      <td>{row_time[0]}</td><td>{row_time[1]}</td><td>{row_time[2]}</td>
+    </tr>
+  </tbody>
+</table>
+""", unsafe_allow_html=True)
+
+if n > 0:
+    if st.button("Clear All Ratings"):
+        st.session_state.ratings = []
+        st.rerun()
+
+# ── About ──────────────────────────────────────────────────────────────────────
+st.divider()
+with st.expander("About CodeSage"):
+    st.markdown("""
+**Project:** CodeSage — Comparative Study of RAG and Fine-Tuning for Domain-Specific Question Answering
+**Domain:** Programming Tutor (DSA + Web Development)
+
+| System | Description |
+|--------|-------------|
+| Baseline | Llama 3.1 8B (via Groq) with only a system prompt |
+| RAG | FAISS vector store + HuggingFace embeddings + Llama 3.1 8B (via Groq) |
+| Fine-tuned | TinyLlama 1.1B fine-tuned via LoRA on 20 programming Q&A pairs |
+""")

evaluate.py

@@ -0,0 +1,135 @@
+"""
+Runs all 3 systems on the test questions and saves results to results/evaluation_results.csv.
+After running, open the CSV and manually fill in:
+  - correctness_score (1-5): 1=wrong, 3=partial, 5=perfect
+  - hallucination (Yes/No): Yes if the answer contains false information
+"""
+import csv
+import os
+import time
+
+from system1_baseline import ask_baseline
+from system2_rag import ask_rag, load_vectorstore, build_vectorstore
+
+QUESTIONS_PATH = "data/questions.csv"
+RESULTS_PATH = "results/evaluation_results.csv"
+NUM_QUESTIONS = 30  # increase to 50 when ready
+
+
+def load_questions():
+    questions = []
+    with open(QUESTIONS_PATH, encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            questions.append(row["question"])
+    return questions[:NUM_QUESTIONS]
+
+
+def run_evaluation():
+    os.makedirs("results", exist_ok=True)
+
+    # Load RAG vectorstore
+    if not os.path.exists("data/faiss_index"):
+        print("Building FAISS index first...")
+        vs = build_vectorstore()
+    else:
+        print("Loading existing FAISS index...")
+        vs = load_vectorstore()
+
+    questions = load_questions()
+    print(f"\nEvaluating {len(questions)} questions across 3 systems...\n")
+
+    results = []
+
+    for i, q in enumerate(questions, 1):
+        print(f"[{i}/{len(questions)}] {q}")
+
+        r1 = ask_baseline(q)
+        time.sleep(0.5)  # avoid rate limiting
+        r2 = ask_rag(q, vs)
+        time.sleep(0.5)
+
+        # System 3 — placeholder until fine-tuned model is ready
+        try:
+            from system3_inference import ask_finetuned
+            r3 = ask_finetuned(q)
+        except Exception:
+            r3 = {"answer": "Model not available yet.", "response_time": 0}
+
+        results.append({
+            "id": i,
+            "question": q,
+            # Baseline
+            "baseline_answer": r1["answer"],
+            "baseline_time": r1["response_time"],
+            "baseline_correctness": "",   # Fill manually: 1-5
+            "baseline_hallucination": "", # Fill manually: Yes/No
+            # RAG
+            "rag_answer": r2["answer"],
+            "rag_time": r2["response_time"],
+            "rag_correctness": "",
+            "rag_hallucination": "",
+            # Fine-tuned
+            "finetuned_answer": r3["answer"],
+            "finetuned_time": r3["response_time"],
+            "finetuned_correctness": "",
+            "finetuned_hallucination": "",
+        })
+
+        print(f"  Baseline ({r1['response_time']}s): {r1['answer'][:70]}...")
+        print(f"  RAG      ({r2['response_time']}s): {r2['answer'][:70]}...")
+        print()
+
+    # Save CSV
+    with open(RESULTS_PATH, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=results[0].keys())
+        writer.writeheader()
+        writer.writerows(results)
+
+    print(f"Saved {len(results)} results to {RESULTS_PATH}")
+    print("\nNext step: open the CSV and fill in 'correctness' (1-5) and 'hallucination' (Yes/No) columns manually.")
+
+
+def print_summary():
+    """Print average scores after you have manually filled in the CSV."""
+    if not os.path.exists(RESULTS_PATH):
+        print("No results file found. Run evaluate.py first.")
+        return
+
+    baseline_scores, rag_scores, ft_scores = [], [], []
+    baseline_hall, rag_hall, ft_hall = [], [], []
+    baseline_times, rag_times, ft_times = [], [], []
+
+    with open(RESULTS_PATH, encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            if row["baseline_correctness"]:
+                baseline_scores.append(float(row["baseline_correctness"]))
+                baseline_hall.append(1 if row["baseline_hallucination"].strip().lower() == "yes" else 0)
+                baseline_times.append(float(row["baseline_time"]) if row["baseline_time"] else 0)
+            if row["rag_correctness"]:
+                rag_scores.append(float(row["rag_correctness"]))
+                rag_hall.append(1 if row["rag_hallucination"].strip().lower() == "yes" else 0)
+                rag_times.append(float(row["rag_time"]) if row["rag_time"] else 0)
+            if row["finetuned_correctness"]:
+                ft_scores.append(float(row["finetuned_correctness"]))
+                ft_hall.append(1 if row["finetuned_hallucination"].strip().lower() == "yes" else 0)
+                ft_times.append(float(row["finetuned_time"]) if row["finetuned_time"] else 0)
+
+    def avg(lst): return round(sum(lst) / len(lst), 2) if lst else "N/A"
+    def pct(lst): return f"{round(sum(lst)/len(lst)*100)}%" if lst else "N/A"
+
+    print("\n===== EVALUATION SUMMARY =====")
+    print(f"{'Metric':<30} {'Baseline':>12} {'RAG':>12} {'Fine-tuned':>12}")
+    print("-" * 66)
+    print(f"{'Avg Correctness (1-5)':<30} {avg(baseline_scores):>12} {avg(rag_scores):>12} {avg(ft_scores):>12}")
+    print(f"{'Hallucination Rate':<30} {pct(baseline_hall):>12} {pct(rag_hall):>12} {pct(ft_hall):>12}")
+    print(f"{'Avg Response Time (s)':<30} {avg(baseline_times):>12} {avg(rag_times):>12} {avg(ft_times):>12}")
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1 and sys.argv[1] == "summary":
+        print_summary()
+    else:
+        run_evaluation()

requirements.txt

@@ -0,0 +1,13 @@
+openai>=1.0.0
+langchain>=0.2.0
+langchain-community>=0.2.0
+faiss-cpu>=1.7.4
+sentence-transformers>=2.7.0
+transformers>=4.40.0
+datasets>=2.19.0
+peft>=0.10.0
+accelerate>=0.29.0
+streamlit>=1.35.0
+pandas>=2.0.0
+python-dotenv>=1.0.0
+tqdm>=4.66.0

system1_baseline.py

@@ -0,0 +1,50 @@
+import os
+import time
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = OpenAI(
+    api_key=os.getenv("GROQ_API_KEY"),
+    base_url="https://api.groq.com/openai/v1",
+)
+
+MODEL = "llama-3.1-8b-instant"
+
+SYSTEM_PROMPT = (
+    "You are a programming tutor specializing in Data Structures, Algorithms, "
+    "and Web Development. Answer questions clearly and concisely."
+)
+
+
+def ask_baseline(question: str) -> dict:
+    start = time.time()
+
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": question},
+        ],
+        max_tokens=300,
+        temperature=0.3,
+    )
+
+    elapsed = round(time.time() - start, 2)
+    answer = response.choices[0].message.content.strip()
+
+    return {
+        "system": "Baseline",
+        "question": question,
+        "answer": answer,
+        "response_time": elapsed,
+    }
+
+
+if __name__ == "__main__":
+    test_q = "What is binary search?"
+    print(f"Question: {test_q}\n")
+    result = ask_baseline(test_q)
+    print(f"Answer:\n{result['answer']}")
+    print(f"\nResponse time: {result['response_time']}s")

system2_rag.py

@@ -0,0 +1,101 @@
+import os
+import time
+from dotenv import load_dotenv
+from langchain_community.document_loaders import DirectoryLoader, TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_huggingface import HuggingFaceEmbeddings
+from openai import OpenAI
+
+load_dotenv()
+
+client = OpenAI(
+    api_key=os.getenv("GROQ_API_KEY"),
+    base_url="https://api.groq.com/openai/v1",
+)
+
+MODEL = "llama-3.1-8b-instant"
+
+DOCS_PATH = "data/docs"
+INDEX_PATH = "data/faiss_index"
+EMBED_MODEL = "all-MiniLM-L6-v2"
+
+SYSTEM_PROMPT = (
+    "You are a programming tutor. Use only the provided context to answer. "
+    "If the answer is not in the context, say 'I don't have that in my knowledge base.'"
+)
+
+
+def build_vectorstore() -> FAISS:
+    print("Loading documents...")
+    loader = DirectoryLoader(DOCS_PATH, glob="**/*.txt", loader_cls=TextLoader,
+                             loader_kwargs={"encoding": "utf-8"})
+    documents = loader.load()
+    print(f"Loaded {len(documents)} documents.")
+
+    splitter = RecursiveCharacterTextSplitter(chunk_size=400, chunk_overlap=60)
+    chunks = splitter.split_documents(documents)
+    print(f"Split into {len(chunks)} chunks.")
+
+    embeddings = HuggingFaceEmbeddings(model_name=EMBED_MODEL)
+    vectorstore = FAISS.from_documents(chunks, embeddings)
+    vectorstore.save_local(INDEX_PATH)
+    print(f"Vector store saved to {INDEX_PATH}/")
+    return vectorstore
+
+
+def load_vectorstore() -> FAISS:
+    embeddings = HuggingFaceEmbeddings(model_name=EMBED_MODEL)
+    return FAISS.load_local(INDEX_PATH, embeddings, allow_dangerous_deserialization=True)
+
+
+def ask_rag(question: str, vectorstore: FAISS) -> dict:
+    start = time.time()
+
+    # Retrieve top-3 relevant chunks
+    docs = vectorstore.similarity_search(question, k=3)
+    context = "\n\n".join([doc.page_content for doc in docs])
+
+    prompt = f"""Use the following context to answer the question accurately.
+
+Context:
+{context}
+
+Question: {question}
+Answer:"""
+
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": prompt},
+        ],
+        max_tokens=300,
+        temperature=0.3,
+    )
+
+    elapsed = round(time.time() - start, 2)
+    answer = response.choices[0].message.content.strip()
+
+    return {
+        "system": "RAG",
+        "question": question,
+        "answer": answer,
+        "context_used": context,
+        "response_time": elapsed,
+    }
+
+
+if __name__ == "__main__":
+    if not os.path.exists(INDEX_PATH):
+        vs = build_vectorstore()
+    else:
+        print("Loading existing vector store...")
+        vs = load_vectorstore()
+
+    test_q = "What is binary search?"
+    print(f"\nQuestion: {test_q}\n")
+    result = ask_rag(test_q, vs)
+    print(f"Answer:\n{result['answer']}")
+    print(f"\nContext used:\n{result['context_used'][:300]}...")
+    print(f"\nResponse time: {result['response_time']}s")

system3_finetune_colab.ipynb

@@ -0,0 +1,176 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# System 3 — Fine-Tuning with LoRA\n",
+    "**Run this notebook on Google Colab with a T4 GPU.**\n",
+    "Runtime → Change runtime type → T4 GPU"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install transformers datasets peft accelerate bitsandbytes -q"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Upload finetune_data.jsonl from your data/ folder before running this cell\n",
+    "from google.colab import files\n",
+    "uploaded = files.upload()  # select data/finetune_data.jsonl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import torch\n",
+    "from datasets import Dataset\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer, DataCollatorForLanguageModeling\n",
+    "from peft import LoraConfig, get_peft_model, TaskType\n",
+    "\n",
+    "# Load dataset\n",
+    "data = []\n",
+    "with open('finetune_data.jsonl') as f:\n",
+    "    for line in f:\n",
+    "        data.append(json.loads(line))\n",
+    "\n",
+    "print(f'Loaded {len(data)} training examples')\n",
+    "\n",
+    "def format_prompt(example):\n",
+    "    return f\"### Instruction:\\n{example['instruction']}\\n\\n### Response:\\n{example['output']}\"\n",
+    "\n",
+    "dataset = Dataset.from_list([{'text': format_prompt(d)} for d in data])\n",
+    "print(dataset[0]['text'][:200])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MODEL_NAME = 'TinyLlama/TinyLlama-1.1B-Chat-v1.0'\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    MODEL_NAME,\n",
+    "    torch_dtype=torch.float16,\n",
+    "    device_map='auto'\n",
+    ")\n",
+    "print('Model loaded.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lora_config = LoraConfig(\n",
+    "    task_type=TaskType.CAUSAL_LM,\n",
+    "    r=8,\n",
+    "    lora_alpha=32,\n",
+    "    target_modules=['q_proj', 'v_proj'],\n",
+    "    lora_dropout=0.05,\n",
+    ")\n",
+    "model = get_peft_model(model, lora_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize(examples):\n",
+    "    return tokenizer(examples['text'], truncation=True, max_length=512, padding='max_length')\n",
+    "\n",
+    "tokenized = dataset.map(tokenize, batched=True)\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir='./finetuned_model',\n",
+    "    num_train_epochs=5,\n",
+    "    per_device_train_batch_size=4,\n",
+    "    save_steps=50,\n",
+    "    logging_steps=10,\n",
+    "    learning_rate=2e-4,\n",
+    "    fp16=True,\n",
+    "    report_to='none'\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=tokenized,\n",
+    "    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False)\n",
+    ")\n",
+    "\n",
+    "trainer.train()\n",
+    "model.save_pretrained('./finetuned_model')\n",
+    "tokenizer.save_pretrained('./finetuned_model')\n",
+    "print('Fine-tuning complete!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test the fine-tuned model\n",
+    "def ask_finetuned(question):\n",
+    "    prompt = f'### Instruction:\\n{question}\\n\\n### Response:\\n'\n",
+    "    inputs = tokenizer(prompt, return_tensors='pt').to(model.device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = model.generate(**inputs, max_new_tokens=200, temperature=0.7,\n",
+    "                                  do_sample=True, pad_token_id=tokenizer.eos_token_id)\n",
+    "    full = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "    return full.split('### Response:\\n')[-1].strip()\n",
+    "\n",
+    "print(ask_finetuned('What is binary search?'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Download the fine-tuned model\n",
+    "import shutil\n",
+    "shutil.make_archive('finetuned_model', 'zip', './finetuned_model')\n",
+    "from google.colab import files\n",
+    "files.download('finetuned_model.zip')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

system3_inference.py

@@ -0,0 +1,75 @@
+"""
+Run inference with the fine-tuned model.
+After running system3_finetune_colab.ipynb on Google Colab:
+  1. Download finetuned_model.zip from Colab
+  2. Unzip into this project root as finetuned_model/
+  3. Then run this file
+"""
+import os
+import time
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+
+BASE_MODEL = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+FINETUNED_PATH = "./finetuned_model"
+
+_model = None
+_tokenizer = None
+
+
+def load_model():
+    global _model, _tokenizer
+    if _model is not None:
+        return _model, _tokenizer
+
+    print("Loading fine-tuned model (this takes ~30s first time)...")
+    _tokenizer = AutoTokenizer.from_pretrained(FINETUNED_PATH)
+    base = AutoModelForCausalLM.from_pretrained(BASE_MODEL, torch_dtype=torch.float32)
+    _model = PeftModel.from_pretrained(base, FINETUNED_PATH)
+    _model.eval()
+    print("Fine-tuned model ready.")
+    return _model, _tokenizer
+
+
+def ask_finetuned(question: str) -> dict:
+    if not os.path.exists(FINETUNED_PATH):
+        return {
+            "system": "Fine-tuned",
+            "question": question,
+            "answer": "Fine-tuned model not found. Run system3_finetune_colab.ipynb on Google Colab first, then unzip finetuned_model.zip here.",
+            "response_time": 0,
+        }
+
+    model, tokenizer = load_model()
+    start = time.time()
+
+    prompt = f"### Instruction:\n{question}\n\n### Response:\n"
+    inputs = tokenizer(prompt, return_tensors="pt")
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=100,
+            do_sample=False,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+
+    full_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    answer = full_output.split("### Response:\n")[-1].strip()
+    elapsed = round(time.time() - start, 2)
+
+    return {
+        "system": "Fine-tuned",
+        "question": question,
+        "answer": answer,
+        "response_time": elapsed,
+    }
+
+
+if __name__ == "__main__":
+    test_q = "What is binary search?"
+    print(f"Question: {test_q}\n")
+    result = ask_finetuned(test_q)
+    print(f"Answer:\n{result['answer']}")
+    print(f"\nResponse time: {result['response_time']}s")