first working version

exam_system/data/input/cpp/2025-10/cpp-intermediate-v1.json

@@ -0,0 +1,118 @@
+{
+  "examId": "cpp-intermediate-v1",
+  "title": "C++ Intermediate - OOP & Practical Coding",
+  "subject": "C++",
+  "difficulty": "intermediate",
+  "durationMinutes": 90,
+  "passingScore": 70,
+  "sections": [
+    {
+      "id": "theory",
+      "title": "OOP Theory & Concepts",
+      "questions": [
+        {
+          "id": "q1",
+          "type": "single_choice",
+          "prompt": "In C++, what is the correct way to prevent a derived class from overriding a virtual function?",
+          "choices": [
+            { "key": "A", "text": "Use the 'final' keyword" },
+            { "key": "B", "text": "Make it private" },
+            { "key": "C", "text": "Use the 'sealed' keyword" },
+            { "key": "D", "text": "Remove the virtual keyword" }
+          ],
+          "answer": "A",
+          "allowIDK": true,
+          "points": 10
+        },
+        {
+          "id": "q2",
+          "type": "multiple_choices",
+          "prompt": "Which are true about the Rule of Five in modern C++? (Select all that apply)",
+          "choices": [
+            { "key": "A", "text": "Includes copy constructor" },
+            { "key": "B", "text": "Includes move constructor" },
+            { "key": "C", "text": "Includes move assignment operator" },
+            { "key": "D", "text": "Includes default constructor" }
+          ],
+          "answer": ["A", "B", "C"],
+          "partialCredit": true,
+          "allowIDK": true,
+          "points": 15
+        },
+        {
+          "id": "q3",
+          "type": "true_false",
+          "prompt": "In C++, a pure virtual function must be implemented in the base class.",
+          "answer": false,
+          "allowIDK": true,
+          "points": 10
+        }
+      ]
+    },
+    {
+      "id": "coding",
+      "title": "Practical Coding Tasks",
+      "questions": [
+        {
+          "id": "q4",
+          "type": "code_simple",
+          "prompt": "Write a function 'factorial' that computes the factorial of a non-negative integer n recursively. Return the result as an unsigned long long.",
+          "language": "cpp",
+          "tests": [
+            { "input": "0", "expected": "1", "visibility": "public" },
+            { "input": "1", "expected": "1", "visibility": "public" },
+            { "input": "5", "expected": "120", "visibility": "public" },
+            { "input": "10", "expected": "3628800", "visibility": "hidden" }
+          ],
+          "points": 20
+        },
+        {
+          "id": "q5",
+          "type": "code_simple",
+          "prompt": "Implement a function 'isPalindrome' that takes a std::string and returns true if it's a palindrome (reads the same forwards and backwards), false otherwise. Ignore case and spaces.",
+          "language": "cpp",
+          "tests": [
+            { "input": "\"racecar\"", "expected": "true", "visibility": "public" },
+            { "input": "\"hello\"", "expected": "false", "visibility": "public" },
+            { "input": "\"A man a plan a canal Panama\"", "expected": "true", "visibility": "public" },
+            { "input": "\"Race Car\"", "expected": "true", "visibility": "hidden" }
+          ],
+          "points": 25
+        },
+        {
+          "id": "q6",
+          "type": "code_exercise",
+          "prompt": "Create a class 'Vector2D' that represents a 2D vector with x and y components. Implement:\n- Constructor taking x and y\n- operator+ for vector addition\n- operator* for dot product (returns double)\n- magnitude() method returning the length\n- normalize() method returning a unit vector\n\nExample:\nVector2D v1(3, 4);\nVector2D v2(1, 2);\nVector2D v3 = v1 + v2;  // Should be (4, 6)\ndouble dot = v1 * v2;    // Should be 11\ndouble mag = v1.magnitude();  // Should be 5",
+          "language": "cpp",
+          "tests": [
+            { "input": "Vector2D(3, 4); Vector2D(1, 2); v1 + v2", "expected": "Vector2D(4, 6)", "visibility": "public" },
+            { "input": "Vector2D(3, 4); Vector2D(1, 2); v1 * v2", "expected": "11", "visibility": "public" },
+            { "input": "Vector2D(3, 4); v.magnitude()", "expected": "5", "visibility": "public" },
+            { "input": "Vector2D(6, 8); v.normalize().magnitude()", "expected": "1", "visibility": "hidden", "weight": 2 }
+          ],
+          "rubric": {
+            "criteria": [
+              { "name": "Constructor implementation", "weight": 0.2 },
+              { "name": "operator+ overloading", "weight": 0.2 },
+              { "name": "operator* overloading (dot product)", "weight": 0.2 },
+              { "name": "magnitude() method", "weight": 0.2 },
+              { "name": "normalize() method", "weight": 0.2 }
+            ],
+            "maxPoints": 30
+          },
+          "starterCode": "class Vector2D {\nprivate:\n    double x, y;\npublic:\n    // Your implementation here\n};",
+          "points": 30
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "version": "1.0.0",
+    "createdAt": "2025-10-21T17:00:00Z",
+    "createdBy": "system",
+    "tags": ["cpp", "c++", "intermediate", "oop", "coding", "manual-grading"],
+    "description": "Intermediate C++ exam covering OOP concepts with three practical coding tasks: recursion, string manipulation, and class design with operator overloading.",
+    "gradingNotes": "Theory questions (q1-q3) are auto-graded. Coding tasks (q4-q6) require manual review and grading based on rubrics and test cases."
+  }
+}
+