Add 02-core modules: input validation and algorithms basics

Author: lucasbellesi

README.md

@@ -32,10 +32,12 @@ Current C++ foundations modules:
 - `control-flow`
 - `functions`
 - `arrays-and-vectors`
+- `strings`
 
-Next C++ module:
+Current C++ core modules:
 
-- `01-foundations/strings`
+- `02-core/input-validation`
+- `02-core/algorithms-basics`
 
 ## Guided Learning Path
 
@@ -45,7 +47,7 @@ Next C++ module:
    - read `README.md`
    - run `example/main.cpp`
    - solve `exercises/01.cpp` and `exercises/02.cpp`
-   - for strings, continue with `languages/cpp/01-foundations/strings`
+   - after foundations, continue with `languages/cpp/02-core`
 4. Mark progress in `languages/cpp/CHECKLIST.md`
 5. Repeat until all modules are complete
 

languages/cpp/02-core/README.md

@@ -1,13 +1,17 @@
 # 02 Core
 
-This level is reserved for intermediate C++ topics that build on foundations.
+This level introduces intermediate patterns that build directly on foundations.
 
-## Intended Topics
+## Module Order
 
-- Strings in depth and parsing patterns
-- Standard library containers and algorithms
-- Error handling basics
+1. [input-validation](./input-validation/README.md)
+2. [algorithms-basics](./algorithms-basics/README.md)
 
-## Status
+## How To Study This Level
 
-This level folder is ready for future modules.
+For each module:
+
+1. Read `README.md`.
+2. Run `example/main.cpp`.
+3. Complete `exercises/01.cpp` and `exercises/02.cpp`.
+4. Mark progress in `../CHECKLIST.md`.

languages/cpp/02-core/algorithms-basics/README.md

@@ -0,0 +1,52 @@
+# Algorithms Basics
+
+This module introduces essential algorithmic patterns using loops and vectors.
+
+## Why It Matters
+
+Many programming problems reduce to a few patterns: search, count, and min/max scanning.
+
+## Quick Run
+
+```bash
+g++ -std=c++17 -Wall -Wextra -pedantic example/main.cpp -o algorithms_basics_example
+./algorithms_basics_example
+```
+
+On Windows (MSYS2 shell), run:
+
+```bash
+./algorithms_basics_example.exe
+```
+
+## Topics Covered
+
+### Linear Search
+
+Find the first position of a target by scanning from left to right.
+
+### Counting Pattern
+
+Count how many values match a condition (for example, equal to a target).
+
+### Min/Max Scan
+
+Track smallest and largest values while iterating once through data.
+
+## Common Pitfalls
+
+- Forgetting to handle empty input.
+- Using uninitialized `min`/`max` values.
+- Doing extra loops when one pass is enough.
+
+## Exercise Focus
+
+- `exercises/01.cpp`: implement linear search over user-provided values.
+- `exercises/02.cpp`: compute min, max, and count of even numbers in one pass.
+
+## Checkpoint
+
+- [ ] I can implement linear search.
+- [ ] I can count values matching a condition.
+- [ ] I can compute min and max safely.
+- [ ] I completed both exercises.

languages/cpp/02-core/algorithms-basics/example/main.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+#include <vector>
+
+int linearSearch(const std::vector<int>& values, int target) {
+    for (std::size_t i = 0; i < values.size(); ++i) {
+        if (values[i] == target) {
+            return static_cast<int>(i);
+        }
+    }
+    return -1;
+}
+
+int countOccurrences(const std::vector<int>& values, int target) {
+    int count = 0;
+    for (int value : values) {
+        if (value == target) {
+            ++count;
+        }
+    }
+    return count;
+}
+
+void printMinMax(const std::vector<int>& values) {
+    if (values.empty()) {
+        std::cout << "No values to process.\n";
+        return;
+    }
+
+    int minValue = values[0];
+    int maxValue = values[0];
+    for (int value : values) {
+        if (value < minValue) {
+            minValue = value;
+        }
+        if (value > maxValue) {
+            maxValue = value;
+        }
+    }
+
+    std::cout << "Minimum: " << minValue << '\n';
+    std::cout << "Maximum: " << maxValue << '\n';
+}
+
+int main() {
+    const std::vector<int> values{4, 7, 4, 1, 9, 4, 2};
+    const int target = 4;
+
+    const int firstIndex = linearSearch(values, target);
+    std::cout << "First index of " << target << ": " << firstIndex << '\n';
+    std::cout << "Occurrences of " << target << ": " << countOccurrences(values, target) << '\n';
+
+    printMinMax(values);
+    return 0;
+}

languages/cpp/02-core/algorithms-basics/exercises/01.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <vector>
+
+int main() {
+    int n = 0;
+    std::cout << "How many integers? ";
+    std::cin >> n;
+
+    if (n <= 0) {
+        std::cout << "Please enter a positive count.\n";
+        return 0;
+    }
+
+    std::vector<int> values;
+    values.reserve(static_cast<std::size_t>(n));
+
+    for (int i = 0; i < n; ++i) {
+        int value = 0;
+        std::cout << "Value " << (i + 1) << ": ";
+        std::cin >> value;
+        values.push_back(value);
+    }
+
+    int target = 0;
+    std::cout << "Target to find: ";
+    std::cin >> target;
+
+    int index = -1;
+    for (int i = 0; i < n; ++i) {
+        if (values[static_cast<std::size_t>(i)] == target) {
+            index = i;
+            break;
+        }
+    }
+
+    std::cout << "First index: " << index << '\n';
+    return 0;
+}

languages/cpp/02-core/algorithms-basics/exercises/02.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <vector>
+
+int main() {
+    int n = 0;
+    std::cout << "How many integers? ";
+    std::cin >> n;
+
+    if (n <= 0) {
+        std::cout << "Please enter a positive count.\n";
+        return 0;
+    }
+
+    std::vector<int> values;
+    values.reserve(static_cast<std::size_t>(n));
+
+    for (int i = 0; i < n; ++i) {
+        int value = 0;
+        std::cout << "Value " << (i + 1) << ": ";
+        std::cin >> value;
+        values.push_back(value);
+    }
+
+    int minValue = values[0];
+    int maxValue = values[0];
+    int evenCount = 0;
+
+    for (int value : values) {
+        if (value < minValue) {
+            minValue = value;
+        }
+        if (value > maxValue) {
+            maxValue = value;
+        }
+        if (value % 2 == 0) {
+            ++evenCount;
+        }
+    }
+
+    std::cout << "Minimum: " << minValue << '\n';
+    std::cout << "Maximum: " << maxValue << '\n';
+    std::cout << "Even numbers: " << evenCount << '\n';
+    return 0;
+}

languages/cpp/02-core/input-validation/README.md

@@ -0,0 +1,55 @@
+# Input Validation
+
+This module teaches how to read user input safely and repeatedly until it is valid.
+
+## Why It Matters
+
+Real programs must handle invalid input without crashing or producing wrong results.
+
+## Quick Run
+
+```bash
+g++ -std=c++17 -Wall -Wextra -pedantic example/main.cpp -o input_validation_example
+./input_validation_example
+```
+
+On Windows (MSYS2 shell), run:
+
+```bash
+./input_validation_example.exe
+```
+
+## Topics Covered
+
+### Stream Validation
+
+- `std::cin >> value` can fail when input type is wrong.
+- On failure, clear error state with `std::cin.clear()`.
+- Remove bad input with `std::cin.ignore(...)`.
+
+### Range Validation
+
+- Validate business rules after extraction (for example, age must be between 1 and 120).
+- Keep asking until the value is acceptable.
+
+### Reusable Validation Functions
+
+Use small helper functions to avoid repeating validation logic.
+
+## Common Pitfalls
+
+- Not clearing `std::cin` after invalid input.
+- Accepting values outside expected ranges.
+- Writing duplicate validation loops everywhere instead of reusable helpers.
+
+## Exercise Focus
+
+- `exercises/01.cpp`: read a valid integer in a range and print its square.
+- `exercises/02.cpp`: read multiple valid scores and compute class average.
+
+## Checkpoint
+
+- [ ] I can detect extraction failure and recover safely.
+- [ ] I can enforce numeric ranges.
+- [ ] I can loop until valid data is entered.
+- [ ] I completed both exercises.

languages/cpp/02-core/input-validation/example/main.cpp

@@ -0,0 +1,60 @@
+#include <iostream>
+#include <limits>
+#include <string>
+
+int readIntInRange(const std::string& label, int minValue, int maxValue) {
+    int value = 0;
+
+    while (true) {
+        std::cout << label;
+        if (!(std::cin >> value)) {
+            std::cout << "Invalid input type. Please enter an integer.\n";
+            std::cin.clear();
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            continue;
+        }
+
+        if (value < minValue || value > maxValue) {
+            std::cout << "Value must be between " << minValue << " and " << maxValue << ".\n";
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            continue;
+        }
+
+        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        return value;
+    }
+}
+
+double readDoubleInRange(const std::string& label, double minValue, double maxValue) {
+    double value = 0.0;
+
+    while (true) {
+        std::cout << label;
+        if (!(std::cin >> value)) {
+            std::cout << "Invalid input type. Please enter a decimal number.\n";
+            std::cin.clear();
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            continue;
+        }
+
+        if (value < minValue || value > maxValue) {
+            std::cout << "Value must be between " << minValue << " and " << maxValue << ".\n";
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            continue;
+        }
+
+        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        return value;
+    }
+}
+
+int main() {
+    const int age = readIntInRange("Enter your age (1-120): ", 1, 120);
+    const double gpa = readDoubleInRange("Enter your GPA (0.0-4.0): ", 0.0, 4.0);
+
+    std::cout << "\nValidated input summary:\n";
+    std::cout << "Age: " << age << '\n';
+    std::cout << "GPA: " << gpa << '\n';
+
+    return 0;
+}

languages/cpp/02-core/input-validation/exercises/01.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <limits>
+
+int main() {
+    int value = 0;
+
+    while (true) {
+        std::cout << "Enter an integer from 1 to 100: ";
+        if (!(std::cin >> value)) {
+            std::cout << "Invalid input. Please enter an integer.\n";
+            std::cin.clear();
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            continue;
+        }
+
+        if (value < 1 || value > 100) {
+            std::cout << "Out of range. Try again.\n";
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            continue;
+        }
+
+        break;
+    }
+
+    std::cout << "Square: " << (value * value) << '\n';
+    return 0;
+}