ExamGrader

https://github.com/ythuang0522/examgrader
Admin
ExamGrader is a Python application that uses generative AI to automatically extract handwritten...
Tokens:14,782
Snippets:42
Trust Score:7.8
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install ExamGrader Dependencies

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This snippet shows how to clone the ExamGrader repository and install its Python dependencies using pip.

```Bash
git clone <repository-url>
cd ExamGrader
pip install -r requirements.txt
```

--------------------------------

### Weighted Interval Scheduling DP Table Calculation (Overlap Allowed)

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

This example demonstrates the calculation of the DP table for the Weighted Interval Scheduling problem where start times can overlap with finish times. It shows the step-by-step computation of A(i) values based on the recurrence relation and the provided activity data (start, finish, weight).

```table
| activity | 1 | 2 | 3 | 4 | 5 | 6 |
|----------|---|---|---|---|---|---|
| start    | 1 | 1 | 2 | 3 | 3 | 5 |
| finish   | 3 | 4 | 4 | 4 | 5 | 5 |
| weight   | 1 | 5 | 3 | 2 | 4 | 5 |
| HL(i)    | 0 | 0 | 0 | 1 | 1 | 5 |
| A(i)     | 1 | 3 | 3 | 3 | 5 | 10 |
```

--------------------------------

### Start Web Interface

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This command launches the web-based interface for the exam grader. You can optionally specify the host and port for the web server. The interface typically runs on http://127.0.0.1:5000 by default.

```bash
python run.py --web [--host HOST] [--port PORT]
```

--------------------------------

### Grade Directory of Student PDFs with ExamGrader

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

Example command to process multiple student answer PDFs located in a directory using ExamGrader for batch grading.

```Bash
python run.py -q questions.pdf -c answers.pdf -s student_answers/
```

--------------------------------

### Weighted Interval Scheduling DP Calculation (No Overlap)

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

This example illustrates the DP table calculation for the Weighted Interval Scheduling problem when start times cannot overlap with finish times. It follows a similar dynamic programming approach but uses a slightly different definition for the predecessor index p(j) and the recurrence relation dp[j] = max(dp[j-1], v_j + dp[p(j)]).

```table
| j | activity | start | end | value | p(j) | 狀態計算        | dp[j] |
|---|----------|-------|-----|-------|------|-----------------|-------|
| 1 | 5        | 1     | 3   | 1     | 0    | max(0, 1+0)     | 1     |
| 2 | 4        | 1     | 4   | 3     | 0    | max(1, 3+0)     | 3     |
| 3 | 1        | 2     | 4   | 3     | 0    | max(3, 3+0)     | 3     |
| 4 | 3        | 3     | 4   | 2     | 1    | max(3, 2+1)     | 3     |
| 5 | 6        | 3     | 5   | 4     | 1    | max(3, 4+1)     | 5     |
| 6 | 2        | 5     | 5   | 5     | 3    | max(5, 5+3)     | 8     |
```

--------------------------------

### Grade Single Student PDF with ExamGrader

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

Example command to grade a single student's PDF answers using ExamGrader, providing the questions file, correct answers file, and the specific student's answer file.

```Bash
python run.py -q questions.pdf -c answers.pdf -s student1.pdf
```

--------------------------------

### Weighted Interval Scheduling DP Recurrence

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

This snippet outlines the dynamic programming approach for the Weighted Interval Scheduling problem. It defines the recurrence relation A(i) = max(A(i-1), wi + A(HL(i))) and explains the terms involved, such as wi (weight of activity i) and HL(i) (the latest activity finishing before activity i starts). This is applied when start times can overlap with finish times.

```pseudocode
A(i) = {
  0 , i=0
  max{A(i-1), wi + A(HL(i))} o.w.
}

where:
HL(i) = max{ l = {1, 2, ..., i-1} | fl <= si}
wi = weight/value of activity i
si = start time of activity i
fi = finish time of activity i
```

--------------------------------

### Grade Multi-Student PDF with ExamGrader

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

Example command to grade a single PDF file containing answers from multiple students using ExamGrader. The `-m` flag enables automatic splitting and processing of individual student answers.

```Bash
python run.py -q questions.pdf -c answers.pdf -s all_students.pdf -m
```

--------------------------------

### Weighted Interval Scheduling DP Recurrence (No Overlap)

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

This snippet presents the dynamic programming recurrence relation used when start times cannot overlap with finish times in the Weighted Interval Scheduling problem. The relation is dp[j] = max(dp[j-1], v_j + dp[p(j)]), where dp[j] is the maximum value considering activity j, v_j is its value, and p(j) is the index of the latest activity that finishes before activity j starts.

```pseudocode
dp[j] = max(dp[j-1], v_j + dp[p(j)])
where:
  dp[j] = Max value considering activity j
  v_j = value of activity j
  p(j) = index of the latest activity finishing before activity j starts
  dp[0] = 0
```

--------------------------------

### AI Prompt Templates

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This utility module contains pre-defined prompt templates used for interacting with AI models. These prompts are crucial for guiding the AI in generating accurate rubrics and grading student answers effectively.

```python
from utils.prompts import generate_rubric_prompt

question_text = "Explain the water cycle."
rubric = generate_rubric_prompt(question_text, total_points=10)

```

--------------------------------

### Configure API Keys for ExamGrader

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This snippet demonstrates how to set up the necessary API keys for Gemini and OpenAI by creating a `.env` file in the project's root directory.

```Bash
GEMINI_API_KEY=your_gemini_api_key
OPENAI_API_KEY=your_openai_api_key
```

--------------------------------

### Bottom-Up DP Computation for Stick Cutting

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Illustrates the step-by-step computation of the dynamic programming table for the stick cutting problem. It shows how the minimum costs for smaller stick segments are calculated first and then used to compute costs for larger segments, eventually leading to the solution for the entire stick.

```Table
| dp[i][j] | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
|   | 0 | 3 | 6 | 12 | 17 | 22 | 28 | 30 |
| 0 | 0 | 0 | 6 | 18 | 34 | 50 | 72 | 84 |
| 1 | 3 |   | 0 | 9 | 23 | 35 | 59 | 70 |
| 2 | 6 |   |   | 0 | 11 | 26 | 44 | 56 |
| 3 | 12 |   |   |   | 0 | 10 | 26 | 36 |
| 4 | 17 |   |   |   |   | 0 | 11 | 21 |
| 5 | 22 |   |   |   |   |   | 0 | 8 |
| 6 | 28 |   |   |   |   |   |   | 0 |
| 7 | 30 |   |   |   |   |   |   |   | 0 |
```

--------------------------------

### Knapsack Problem DP (Weight-based)

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Demonstrates the dynamic programming approach to the knapsack problem where the state is defined by the number of items and the capacity. It shows the recurrence relation and table filling for calculating the maximum value.

```markdown
學生答案:
令 Vi 為 ith 物品的 value, Wi 為 ith 物品的 weight, W 為 max capacity, B[k,w] 表示前 k 個物品在容量 W 下的 Max value
令 B[k,w] = { B[k-1, w] if w < Wk 以 weight 為主方法
{ Max([B[k-1, w], B[k-1, w-Wk] + bk]) o.w. 
bk = 第 k 個物品的 value
初使時若 k=0 or w=0 => 0; B[0, v] 都設為 0

| item | Wi  | Vi |
|------|-----|----|
| 1    | 100 | 1  |
| 2    | 150 | 2  |
| 3    | 200 | 3  |
| 4    | 300 | 4  |

| item \ w | 0 | 100 | 150 | 200 | 250 | 300 | 350 |
|----------|---|-----|-----|-----|-----|-----|-----|
| 0        | 0 | 0   | 0   | 0   | 0   | 0   | 0   |
| X 1      | 0 | 1   | 1   | 1   | 1   | 1   | 1   |
| V 2      | 0 | 1   | 2   | 2   | 3   | 3   | 3   | 2-2=0
| V 3      | 0 | 1   | 2   | 3   | 3   | 4   | 5   | 5-3=2
| X 4      | 0 | 1   | 2   | 3   | 3   | 4   | 5   |
A = value = 5 #

因此題 weight 較 value 大, 以 value 為主
```

--------------------------------

### Backtracking for Optimal Stick Cutting Sequence

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Demonstrates how to reconstruct the optimal sequence of cuts from the computed DP table. By referencing the `bestcut` table, which stores the optimal cut point for each subproblem, the algorithm traces back the decisions made to achieve the minimum cost, identifying the cuts in the correct order.

```Table
| dp[i][j] | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|----------|---|---|---|---|---|---|---|---|
|   |   | 0 | 3 | 6 | 12 | 17 | 22 | 28 | 30 |
| 0 | 0 | 0 | 0 | 6 | 18 | 34 | 50 | 72 | 84 |
| 1 | 3 |   | 0 | 0 | 9 | 23 | 35 | 59 | 70 |
| 2 | 6 |   |   | 0 | 0 | 11 | 26 | 44 | 56 |
| 3 | 12 |  |   |   | 0 | 0 | 10 | 26 | 36 |
| 4 | 17 |  |   |   |   | 0 | 0 | 11 | 21 |
| 5 | 22 |  |   |   |   |   | 0 | 0 | 8 |
| 6 | 28 |  |   |   |   |   |   | 0 | 0 |
| 7 | 30 |  |   |   |   |   |   |   | 0 |
```

```Table
| best cut | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|----------|---|---|---|---|---|---|---|---|
|   |   | 0 | 3 | 6 | 12 | 17 | 22 | 28 | 30 |
| 0 | 0 | 0 | 0 | 3 | 6 | 6 | 12 | 12 | 12 |
| 1 | 3 |   | 0 | 0 | 6 | 6 | 17 | 17 | 22 |
| 2 | 6 |   |   | 0 | 0 | 12 | 12 | 22 | 22 |
| 3 | 12 |  |   |   | 0 | 0 | 17 | 17 | 22 |
| 4 | 17 |  |   |   |   | 0 | 0 | 22 | 28 |
| 5 | 22 |  |   |   |   |   | 0 | 0 | 28 |
| 6 | 28 |  |   |   |   |   |   | 0 | 0 |
| 7 | 30 |  |   |   |   |   |   |   | 0 |
```

--------------------------------

### Activity Selection Problem DP

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Illustrates a dynamic programming algorithm for the activity selection problem, focusing on finding a mutually-exclusive subset of activities with maximum total value. It includes sorting activities, identifying predecessors, defining the DP recurrence, and filling the DP table.

```markdown
step 1: 先照結束時間排序 (ascending)
| activity | start | end | value | p(j) | 狀態計算             | dp[j] |
|----------|-------|-----|-------|------|----------------------|-------|
| 5        | 1     | 3   | 1     | 0    | max(0, 1+0)          | 1     |
| 4        | 1     | 4   | 3     | 0    | max(1, 3+0)          | 3     |
| 1        | 2     | 4   | 3     | 0    | max(3, 3+0)          | 3     |
| 3        | 3     | 4   | 2     | 1    | max(3, 2+1)          | 3     |
| 6        | 3     | 5   | 4     | 1    | max(3, 4+1)          | 5     |
| 2        | 5     | 5   | 5     | 3    | max(5, 5+3)          | 8     |

令 dp[j] 為選擇 activity j 的 Max value, p(j) 表活動 j 前結束的 最後一個 index ⇒ dp[j] = Max(dp[j-1], vj+dp[p(j)])
最佳解 dp[6]=8
option one ⇒ 選 activity (2,4,1,3) + activity (5,5,5)
```

--------------------------------

### Weighted Interval Scheduling Student Answer Analysis (Chinese)

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

This section provides a detailed breakdown and scoring of a student's solution to the Weighted Interval Scheduling problem. It covers the correctness of activity sorting, predecessor identification, recurrence relation definition, DP table filling, and the final solution construction. The scoring is based on these criteria.

```text
得分: 10.0/10.0

評分理由: - 活動排序與前驅活動的識別 (3 分)：學生答案正確地將活動按照結束時間排序，並明確給出各活動的 p(j) 值，與參考答案一致，故給予滿分。
- 定義遞迴關係與動態規劃表格填充 (4 分)：學生答案正確定義了遞迴公式 dp[j] = max(dp[j-1], v_j + dp[p(j)]) 並展示了完整的 dp 表格填充過程，計算步驟清晰，故給予滿分。
- 舉例說明與構造最終解 (3 分)：學生答案利用示例詳盡說明了如何回溯和構造最終的最優活動組合，並給出最優總價值及選擇的活動，與參考答案完全吻合，故給予滿分。
```

--------------------------------

### Knapsack Problem DP (Value-based)

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Presents an alternative dynamic programming approach to the knapsack problem where the state is defined by the value and the number of items. It illustrates the recurrence relation and table filling for finding the minimum weight for a given value.

```markdown
dp[v, i] = { 0 if v=0
{ ∞ if i=0, v>0
{ min(dp[v, i-1], dp[v-v_i, i-1] + w_i) o.w.  -> ith 物品的 weight
-> ith 物品的 value

| v \ i | 0 | 1   | 2   | 3   | 4   |
|-------|---|-----|-----|-----|-----|
| 0     | 0 | 0   | 0   | 0   | 0   |
| 1     | ∞ | 100 | 100 | 100 | 100 |
| 2     | ∞ | ∞   | 150 | 150 | 150 |
| 3     | ∞ | ∞   | 250 | 200 | 200 |
| 4     | ∞ | ∞   | ∞   | 300 | 300 |
| 5     | ∞ | ∞   | ∞   | 350 | 350 |
| 6     | ∞ | ∞   | ∞   | 450 | 450 |
| 7     | ∞ | ∞   | ∞   | ∞   | 500 |
| 8     | ∞ | ∞   | ∞   | ∞   | 600 |
| :     | : | :   | :   | :   | :   |

| item | Wi  | Vi |
|------|-----|----|
| 1    | 100 | 1  |
| 2    | 150 | 2  |
| 3    | 200 | 3  |
| 4    | 300 | 4  |

因 W 背包容量 共有 350, 由 dp[5][4] 往回找
350 - 200 = 150 150 - 150 = 0
=> item 3 + item 2
=> value = 2 + 3 = 5 #
```

--------------------------------

### Exam Grader CLI Entry Point

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

The main entry point for the Exam Grader command-line interface. This script orchestrates the grading process, handling file inputs, AI interactions, and output generation. It supports various arguments for customization.

```python
import main

if __name__ == "__main__":
    main.main()

```

--------------------------------

### Run ExamGrader Application

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This command shows the basic usage of the ExamGrader Python script, specifying input files for questions, correct answers, and student answers, with optional parameters for output file, grading rounds, workers, and debug mode.

```Bash
python run.py -q <questions_file> -c <correct_answers_file> -s <student_answers_file> [-o <output_file>] [-r <rounds>] [--workers N] [--debug]
```

--------------------------------

### Fibonacci with Memoization and Tail Recursion

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Demonstrates two methods to compute the nth Fibonacci number using recursion while avoiding stack overflow. Memoization stores previously computed values to prevent redundant calculations, and tail recursion allows for compiler optimizations to reduce stack depth.

```C++
int memo[1000000] = {0};
int fib(int n){
  if(n<=1) return n;
  if(memo[n]!=0) return memo[n]; 
  return memo[n] = fib(n-1)+fib(n-2);
}
```

```C++
int fib_tail(int n, int a=0, int b=1){
  if(n==0) return a;
  if(n==1) return b;
  return fib_tail(n-1, b, a+b);
}
```

--------------------------------

### Prove Heap Node Count at Height h

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

This section details the proof that an n-element heap has at most ⌈n/2^(h+1)⌉ nodes at height h. It utilizes the properties of complete binary trees and mathematical induction.

```English
Heap is a complete binary tree, each level is full, only the bottom level may not be full, filled from left to right. H = floor(log_2 n), root: H=0; bottom level: H=H nodes.
Hth level Max node count = 2^H
Known Full Binary Tree at height H has Max node count = 2^(H+1) - 1
By Mathematical Theorem,
① When h=0, at most n/2 nodes at 0th level => "n / 2^(h+1)" = "n / 2^(0+1)" = "n/2" holds (∵ half are leaves, h=0 is the bottom level here)
Divided by 2 because each child has at most 2 nodes, and nodes at level h come from level (h+1)
② When h=k, assume at kth level there are at most "n / 2^(k+1)" nodes holds
③ When h=k+1, at most (kth level nodes) / 2 nodes (∵ complete and binary)
Which is "n / 2^(k+1)" / 2 = "n / 2^((k+1)+1)" at (k+1)th level, consistent with assumption ②
Thus n-element heap has at most "n / 2^(h+1)" nodes at height h #
```

```English
Heap is a complete binary tree, each level is full, only the bottom level may not be full, filled from left to right. H = floor(log_2 n), root: H=0; bottom level: H=H (node count).
Hth level Max node count = 2^H
Known Full Binary Tree at height H has Max node count = 2^(H+1) - 1
By Mathematical Theorem (Induction is likely meant),
① When h=0, at most ceil(n/2) nodes at 0th level => ceil(n / 2^(h+1)) = ceil(n / 2^(0+1)) = ceil(n/2) holds (∵ half are leaves, h=0 is the bottom level here)
Divided by 2 because each child has at most 2 nodes, and nodes at level h come from level (h+1) (Note: This reasoning seems reversed; nodes at h+1 are parents of nodes at h)
② When h=k, assume at kth level there are at most ceil(n / 2^(k+1)) nodes holds
③ When h=k+1, at most (kth level nodes) / 2 nodes (∵ complete and binary)
Which is ceil(n / 2^(k+1)) / 2 = ceil(n / 2^((k+1)+1)) at (k+1)th level, consistent with assumption ② (Note: The equality shown uses properties of ceiling division, specifically ceil(ceil(x)/2) = ceil(x/2))
Thus n-element heap has at most ceil(n / 2^(h+1)) nodes at height h #
```

--------------------------------

### Knapsack Problem DP (Value-centric) (English)

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Solves the knapsack problem where item sizes are large and values are small. It uses a dynamic programming approach with value as the state parameter to minimize weight. Includes recurrence relation and tabular computation.

```English
Let Vi be the value of the ith item, Wi be the weight of the ith item, W be the max capacity, B[k,w] represents the Max value for capacity W considering the first k items.
Let B[k,w] = { B[k-1, w] if w < Wk using weight as primary; Max((B[k-1, w], B[k-1, w-Wk]+bk)) otherwise } bk = value of the kth item
Initially, if k=0 or w=0 => 0; B[0, w] are all 0
| item | Wi  | Vi | 
|------|-----|----|
| 1    | 100 | 1  |
| 2    | 150 | 2  |
| 3    | 200 | 3  |
| 4    | 300 | 4  |
| item \ w | 0 | 100 | 150 | 200 | 250 | 300 | 350 |
|----------|---|-----|-----|-----|-----|-----|-----|
| 0        | 0 | 0   | 0   | 0   | 0   | 0   | 0   |
| X 1      | 0 | 1   | 1   | 1   | 1   | 1   | 1   |
| ✓ 2      | 0 | 1   | 2   | 2   | 3   | 3   | 3   |
| ✓ 3      | 0 | 1   | 2   | 3   | 3   | 4   | 5   |
| X 4      | 0 | 1   | 2   | 3   | 3   | 4   | 5   |
Calculation on the side: 2-2=0, 5-3=2
A= value=5 #
Therefore, for this problem where weight is larger than value, use value as the primary state.
dp[v, i] = { 0 if v=0; ∞ if i=0, v>0; min(dp[v, i-1], dp[v-vi, i-1]+wi) otherwise }
(Notes beside the formula: `vi -> value of ith item`, `wi -> weight of ith item`)
| v \ i | 0 | 1   | 2   | 3   | 4   |
|-------|---|-----|-----|-----|-----|
| 0     | 0 | 0   | 0   | 0   | 0   |
| 1     | ∞ | 100 | 100 | 100 | 100 |
```

--------------------------------

### Radix Sort vs. Comparison-Based Sorting

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Explains why comparison-based sorting algorithms are preferred as built-in functions despite Radix Sort's potentially better theoretical time complexity. It highlights the trade-offs in terms of data type applicability, generality, and resource usage.

```English
① Radix Sort can only sort integers, fixed-length strings.
Comparison-based Sorting can handle arbitrary data types, e.g., float, double.
② Comparison sort is practical and stable in general, with slightly lower constant time overhead.
Moreover, its generality and ease of use provide high consistency across environments.
③ Radix Sort is only applicable to data with fixed and small key values, requiring extra space.
And when the key is too large, O(d(n+k)) will be greater than Comparison-based Sorting's O(nlogn).
```

```English
① Radix Sort can only sort integers, fixed-length strings.
Comparison-based Sorting can handle arbitrary data types, e.g., float, double.
② Comparison sort is practical and stable in general, with varying constant time overhead.
Moreover, its generality and ease of use provide high consistency across environments.
③ Radix Sort is only applicable to data with fixed and small key values, requiring extra space.
```

--------------------------------

### Styling for Jailbreak Results (CSS)

Source: https://github.com/ythuang0522/examgrader/blob/main/examgrader/web/templates/jailbreak_results.html

This CSS code provides styling for the jailbreak results section, including a container for the results, status indicators, a spinner animation, alert messages for success or danger, and a detailed view with criteria lists and conclusions. It enhances the visual presentation of the jailbreak detection output.

```CSS
.jailbreak-results { margin: 20px 0; padding: 15px; border-radius: 8px; background-color: #fff; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
.status-indicator { display: flex; align-items: center; gap: 10px; }
.spinner { width: 20px; height: 20px; border: 3px solid #f3f3f3; border-top: 3px solid #3498db; border-radius: 50%; animation: spin 1s linear infinite; }
@keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
.alert { padding: 16px; margin-bottom: 15px; border-radius: 8px; display: flex; flex-direction: column; gap: 8px; }
.alert h4 { font-size: 1.1rem; font-weight: 600; margin: 0; }
.alert p { margin: 0; font-size: 0.95rem; }
.alert-danger { background-color: #fff2f2; border-left: 4px solid #dc3545; color: #721c24; }
.alert-success { background-color: #f1f9f5; border-left: 4px solid #28a745; color: #155724; }
.details-section { margin-top: 15px; border: 1px solid #e9ecef; border-radius: 8px; overflow: hidden; }
.details-summary { padding: 12px 16px; background-color: #f8f9fa; cursor: pointer; font-weight: 500; user-select: none; }
.details-summary:hover { background-color: #e9ecef; }
.criteria-list { padding: 16px; }
.criteria-header { font-size: 0.9rem; color: #6c757d; margin-bottom: 12px; font-weight: 500; }
.criteria-item { padding: 8px 0; border-bottom: 1px solid #f0f0f0; display: flex; align-items: baseline; gap: 8px; font-size: 0.9rem; }
.criteria-item:last-child { border-bottom: none; }
.criteria-label { color: #495057; font-weight: 500; min-width: 200px; }
.criteria-result { color: #6c757d; }
.criteria-conclusion { margin-top: 16px; padding: 12px; background-color: #f8f9fa; border-radius: 6px; font-size: 0.9rem; color: #495057; }
```

--------------------------------

### Solve Recurrence Relation T(n) = 2T(√n) + lg n

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Demonstrates the process of solving a recurrence relation using variable substitution and the Master Theorem. The problem involves transforming T(n) = 2T(√n) + lg n into a solvable form, S(k) = 2S(k/2) + k, and deriving the time complexity.

```English
T(n) = 2T(√n) + lg n
Let k = lg n => n = 2^k => T(2^k) = 2T(2^(k/2)) + k
Let S(k) = T(2^k) => S(k) = 2S(k/2) + k
By Master Theorem, log_2 2 = 1 => O(k^1)
But f(n) is also O(k) => S(k) = O(k log k)
Substitute back => T(2^k) = O(k log k) => T(n) = O(lg n log lg n)
Which is T(n) = O(log n log log n) * (∵ log is usually base 2)
```

```English
T(n) = 2T(sqrt(n)) + lgn
Let k = lgn => n = 2^k => T(2^k) = 2T(2^(k/2)) + k
Let S(k) = T(2^k) => S(k) = 2S(k/2) + k
By Master Theorem, log_2 2 = 1 => O(k^1)
But f(k) = k is also Θ(k^log_2 2) = Θ(k) => S(k) = O(klogk)
Substitute back => T(2^k) = O(klogk) => T(n) = O(lgn loglgn)
Which is T(n) = O(lgn loglgn) # (∵ log is usually base 2)
```

--------------------------------

### Run Grading with Multiple Rounds

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This command initiates the exam grading process with a specified number of grading rounds. It takes question, correct answers, and student answers files as input. Increasing the number of rounds can help mitigate the randomness of LLM responses by selecting the best score across multiple attempts.

```bash
python run.py -q questions.pdf -c answers.pdf -s student.pdf -r 3
```

--------------------------------

### Web Application Implementation

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This file contains the implementation of the web application for the Exam Grader. It likely uses a framework like Flask to handle user requests, file uploads, and display grading results.

```python
from web import app

if __name__ == "__main__":
    app.run(debug=True)

```

--------------------------------

### Display Jailbreak Detection Results (Jinja)

Source: https://github.com/ythuang0522/examgrader/blob/main/examgrader/web/templates/jailbreak_results.html

This Jinja macro processes and displays the results of a jailbreak detection system. It checks the status of the submission and conditionally renders messages indicating whether jailbreak attempts were detected, along with detailed analysis if available. It relies on a 'results' object containing status and detection details.

```Jinja
{% macro jailbreak_results(results) %}

{% if results.status == 'running' %}

Checking for jailbreak attempts...

{% elif results.status == 'complete' %} {% if results.has_jailbreak %}

#### ⚠️ Jailbreak Attempts Detected!

The system has detected potential jailbreak attempts in the student's answers.

{% else %}

#### ✓ No Jailbreak Attempts Detected

The student's answers have passed the security check.

{% endif %} {% if results.results %} View Detection Details

{% for line in results.results.details.split('\n') %} {% if line.strip().startswith('Analysis based on') %}

##### {{ line.strip() }}

{% elif line.strip().startswith('The submission appears') %}

{{ line.strip() }}

{% elif line.strip() and not line.strip().isspace() %}

{% set parts = line.split('**') %} {% if parts|length >= 3 %} {{ parts[1] }}: {{ parts[2] }} {% else %} {{ line }} {% endif %}

{% endif %} {% endfor %}

{% endif %} {% endif %}

{% endmacro %}
```

--------------------------------

### OpenAI API Client

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This module provides a client for interacting with the OpenAI API. It includes logic for making requests, handling responses, and implementing retry mechanisms to ensure robustness.

```python
from api.openai import OpenAIClient

client = OpenAIClient(api_key='YOUR_API_KEY')
response = client.generate_text('Prompt here')

```

--------------------------------

### Multi-Student PDF Partitioning

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This utility module handles the partitioning of PDF files that contain answers from multiple students into individual files. This is useful for processing large batches of student submissions efficiently.

```python
from utils.pdf_partitioner import partition_pdf

partition_pdf('multi_student_answers.pdf', output_dir='student_files/')
```

--------------------------------

### Gemini API Client

Source: https://github.com/ythuang0522/examgrader/blob/main/README.md

This module provides a client for interacting with the Google Gemini API. It allows the application to leverage Gemini's capabilities for tasks such as rubric generation and answer grading.

```python
import google.generativeai as genai

genai.configure(api_key='YOUR_GEMINI_API_KEY')
model = genai.GenerativeModel('gemini-2.5-pro-exp-03-25')
response = model.generate_content('Prompt here')

```

--------------------------------

### Recurrence Relation for Minimum Stick Cutting Cost

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

Defines the recursive formula to calculate the minimum cost of cutting a stick segment. `dp[i][j]` represents the minimum cost to cut a stick segment from point `i` to point `j`. The cost is minimized by considering all possible cut points `k` between `i` and `j`, adding the cost of the current cut (`S[j]-S[i]`) to the minimum costs of the subproblems (`dp[i][k]` and `dp[k][j]`).

```Pseudocode
dp[i][j] = min (dp[i][k] + dp[k][j] + (S[j]-S[i])) for i < k < j
dp[i][j] = minimum cost for segment from i to j
i = left boundary, j = right boundary
S[j]-S[i] = cost of cutting the segment from i to j
```

--------------------------------

### Optimal Polygon Triangulation DP Recurrence and Calculation

Source: https://github.com/ythuang0522/examgrader/blob/main/Data/411000001_範例_results.txt

This snippet details the dynamic programming recurrence relation for optimal polygon triangulation: dp[i][j] = min_{i<k<j} (dp[i][k] + dp[k][j] + cost(i, j)). It also shows the bottom-up DP calculation and the backtracing process to find the optimal cuts.

```Chinese
dp[i][j] = min_{i<k<j} (dp[i][k] + dp[k][j] + (S[j]-S[i])) ⤴︎k=欲切割點
i=左界 j=右界 S[j]-S[i] = 長度j到i的成本
dp[i][j] = 長度i到j的最小成本
S = {0, 3, 6, 12, 17, 22, 28, 30}

長度2:
S[0]=0 ~ S[2]=6
(1) dp[0][2] = dp[0][1] + dp[1][2] + (6-0) = 0+0+6 = 6
(2) dp[1][3] = dp[1][2] + dp[2][3] + (12-3) = 0+0+9 = 9
(3) 同理, dp[2][4] = 17-6=11 ; dp[3][5] = 22-12=10
dp[4][6] = 28-17=11 ; dp[5][7] = 30-22=8

長度3: dp[0][3] = min_{0<k<3} (dp[0][k] + dp[k][3] + 12)
= dp[0][2] + dp[2][3] + 12 = 18

最終得到 dp[0][7] = 84
```
Tokens:
Raw