Add advanced and expert assessments

Author: lucasbellesi

languages/cpp/03-advanced/PROGRESS.md

@@ -13,7 +13,7 @@ Use this file as your personal progress log for this level.
 ## Level Milestones
 
 - [ ] Completed capstone: `languages/cpp/projects/03-advanced`
-- [ ] (Optional for now) add and complete `languages/cpp/assessments/03-advanced`
+- [ ] Completed assessment: `languages/cpp/assessments/03-advanced`
 - [ ] Updated global checklist: `languages/cpp/CHECKLIST.md`
 
 ## My Struggles And Fixes

languages/cpp/04-expert/PROGRESS.md

@@ -13,7 +13,7 @@ Use this file as your personal progress log for this level.
 ## Level Milestones
 
 - [ ] Completed capstone: `languages/cpp/projects/04-expert`
-- [ ] (Optional for now) add and complete `languages/cpp/assessments/04-expert`
+- [ ] Completed assessment: `languages/cpp/assessments/04-expert`
 - [ ] Updated global checklist: `languages/cpp/CHECKLIST.md`
 
 ## My Struggles And Fixes

languages/cpp/CHECKLIST.md

@@ -40,7 +40,7 @@
 - [ ] Complete `03-advanced/inheritance-and-polymorphism`.
 - [ ] Complete `03-advanced/templates-basics`.
 - [ ] Complete capstone `projects/03-advanced`.
-- [ ] Complete assessment `assessments/03-advanced` (when available).
+- [ ] Complete assessment `assessments/03-advanced`.
 - [ ] Update `03-advanced/PROGRESS.md` with session notes.
 
 ## 04-expert
@@ -51,5 +51,5 @@
 - [ ] Complete `04-expert/performance-and-profiling-basics`.
 - [ ] Complete `04-expert/modularization-and-build-structure`.
 - [ ] Complete capstone `projects/04-expert`.
-- [ ] Complete assessment `assessments/04-expert` (when available).
+- [ ] Complete assessment `assessments/04-expert`.
 - [ ] Update `04-expert/PROGRESS.md` with session notes.

languages/cpp/assessments/03-advanced/README.md

@@ -0,0 +1,39 @@
+# Assessment 03: Advanced
+
+## Goal
+
+Combine class design, polymorphism, and templates in one practical program.
+
+## Task
+
+Write a program that:
+
+1. Defines a polymorphic `Shape` hierarchy (`Circle`, `Rectangle`).
+2. Stores shapes in `vector<unique_ptr<Shape>>`.
+3. Calculates each shape area and total area.
+4. Uses a template helper to print any numeric vector.
+5. Prints min and max area values.
+
+## Quick Run
+
+```bash
+g++ -std=c++17 -Wall -Wextra -pedantic main.cpp -o assessment_03_advanced
+./assessment_03_advanced
+```
+
+## Expected Output (shape)
+
+```text
+Shape areas:
+- Circle: ...
+- Rectangle: ...
+Total area: ...
+Minimum area: ...
+Maximum area: ...
+```
+
+## What To Check
+
+- Polymorphic calls happen through base pointers.
+- No raw owning pointers are used.
+- Template helper works for both `vector<int>` and `vector<double>`.

languages/cpp/assessments/03-advanced/main.cpp

@@ -0,0 +1,93 @@
+#include <algorithm>
+#include <numeric>
+#include <cmath>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+class Shape {
+public:
+    virtual ~Shape() = default;
+    virtual double area() const = 0;
+    virtual string name() const = 0;
+};
+
+class Circle : public Shape {
+public:
+    explicit Circle(double radiusValue) : radius(radiusValue) {}
+
+    double area() const override {
+        return 3.141592653589793 * radius * radius;
+    }
+
+    string name() const override {
+        return "Circle";
+    }
+
+private:
+    double radius;
+};
+
+class Rectangle : public Shape {
+public:
+    Rectangle(double widthValue, double heightValue)
+        : width(widthValue), height(heightValue) {}
+
+    double area() const override {
+        return width * height;
+    }
+
+    string name() const override {
+        return "Rectangle";
+    }
+
+private:
+    double width;
+    double height;
+};
+
+template <typename T>
+void printVector(const vector<T>& values, const string& label) {
+    cout << label << ": [";
+    for (size_t i = 0; i < values.size(); ++i) {
+        cout << values[i];
+        if (i + 1 < values.size()) {
+            cout << ", ";
+        }
+    }
+    cout << "]\n";
+}
+
+int main() {
+    vector<unique_ptr<Shape>> shapes;
+    shapes.push_back(make_unique<Circle>(2.0));
+    shapes.push_back(make_unique<Rectangle>(3.0, 4.0));
+    shapes.push_back(make_unique<Circle>(1.5));
+
+    vector<double> areas;
+    areas.reserve(shapes.size());
+
+    cout << "Shape areas:\n";
+    for (const unique_ptr<Shape>& shape : shapes) {
+        const double value = shape->area();
+        areas.push_back(value);
+        cout << "- " << shape->name() << ": " << value << '\n';
+    }
+
+    const double totalArea = accumulate(areas.begin(), areas.end(), 0.0);
+    const double minArea = *min_element(areas.begin(), areas.end());
+    const double maxArea = *max_element(areas.begin(), areas.end());
+
+    cout << "Total area: " << totalArea << '\n';
+    cout << "Minimum area: " << minArea << '\n';
+    cout << "Maximum area: " << maxArea << '\n';
+
+    vector<int> sampleCounts = {1, 2, 3, 4};
+    printVector(sampleCounts, "Sample counts");
+    printVector(areas, "Computed areas");
+
+    return 0;
+}

languages/cpp/assessments/04-expert/README.md

@@ -0,0 +1,45 @@
+# Assessment 04: Expert
+
+## Goal
+
+Practice ownership, thread-safe work distribution, and result aggregation.
+
+## Task
+
+Write a program that:
+
+1. Uses `unique_ptr` to manage a shared data container.
+2. Splits work across multiple threads.
+3. Uses `mutex` to protect shared aggregation state.
+4. Computes:
+- total sum
+- minimum value
+- maximum value
+5. Prints per-thread partial sums and final summary.
+
+## Quick Run
+
+```bash
+g++ -std=c++17 -Wall -Wextra -pedantic -pthread main.cpp -o assessment_04_expert
+./assessment_04_expert
+```
+
+On Linux, `-pthread` is required for thread support.
+
+## Expected Output (shape)
+
+```text
+Worker 0 partial sum: ...
+Worker 1 partial sum: ...
+...
+Final summary:
+Total: ...
+Minimum: ...
+Maximum: ...
+```
+
+## What To Check
+
+- No data races (shared updates protected by `mutex`).
+- Ownership is explicit (`unique_ptr`).
+- Threads are always joined before program exit.

languages/cpp/assessments/04-expert/main.cpp

@@ -0,0 +1,79 @@
+#include <algorithm>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+using namespace std;
+
+struct Summary {
+    long long total = 0;
+    int minimum = numeric_limits<int>::max();
+    int maximum = numeric_limits<int>::min();
+};
+
+int main() {
+    auto data = make_unique<vector<int>>(vector<int>{
+        12, 7, 25, 4, 31, 19, 2, 45, 18, 9, 27, 6
+    });
+
+    const size_t threadCount = 3;
+    vector<thread> workers;
+    workers.reserve(threadCount);
+
+    Summary globalSummary;
+    mutex summaryMutex;
+
+    const size_t chunkSize = (data->size() + threadCount - 1) / threadCount;
+
+    for (size_t workerId = 0; workerId < threadCount; ++workerId) {
+        const size_t begin = workerId * chunkSize;
+        const size_t end = min(begin + chunkSize, data->size());
+
+        workers.emplace_back([workerId, begin, end, &data, &globalSummary, &summaryMutex]() {
+            if (begin >= end) {
+                return;
+            }
+
+            long long localTotal = 0;
+            int localMin = (*data)[begin];
+            int localMax = (*data)[begin];
+
+            for (size_t i = begin; i < end; ++i) {
+                const int value = (*data)[i];
+                localTotal += value;
+                if (value < localMin) {
+                    localMin = value;
+                }
+                if (value > localMax) {
+                    localMax = value;
+                }
+            }
+
+            {
+                lock_guard<mutex> lock(summaryMutex);
+                cout << "Worker " << workerId << " partial sum: " << localTotal << '\n';
+                globalSummary.total += localTotal;
+                if (localMin < globalSummary.minimum) {
+                    globalSummary.minimum = localMin;
+                }
+                if (localMax > globalSummary.maximum) {
+                    globalSummary.maximum = localMax;
+                }
+            }
+        });
+    }
+
+    for (thread& worker : workers) {
+        worker.join();
+    }
+
+    cout << "\nFinal summary:\n";
+    cout << "Total: " << globalSummary.total << '\n';
+    cout << "Minimum: " << globalSummary.minimum << '\n';
+    cout << "Maximum: " << globalSummary.maximum << '\n';
+
+    return 0;
+}

languages/cpp/assessments/README.md

@@ -6,6 +6,8 @@ Use these assessments after finishing each level to check practical readiness.
 
 1. [01-foundations](./01-foundations/README.md)
 2. [02-core](./02-core/README.md)
+3. [03-advanced](./03-advanced/README.md)
+4. [04-expert](./04-expert/README.md)
 
 Each assessment contains: