Initial Course

modules/02_control_flow/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_course_exercise(NAME conditionals MODULE 02_control_flow STANDARD 17
+    SOURCES src/conditionals.cpp test/conditionals_test.cpp)
+add_course_exercise(NAME switch_statements MODULE 02_control_flow STANDARD 17
+    SOURCES src/switch_statements.cpp test/switch_statements_test.cpp)
+add_course_exercise(NAME loops MODULE 02_control_flow STANDARD 17
+    SOURCES src/loops.cpp test/loops_test.cpp)
+add_course_exercise(NAME break_continue MODULE 02_control_flow STANDARD 17
+    SOURCES src/break_continue.cpp test/break_continue_test.cpp)

modules/02_control_flow/README.md

@@ -0,0 +1,17 @@
+# Module 02: Control Flow
+
+## Learning Goals
+
+- Write conditional logic with `if`, `else if`, and `else`
+- Use `switch` statements and understand fall-through
+- Implement loops: `for`, `while`, and range-based patterns
+- Control loop execution with `break` and `continue`
+
+## Exercises
+
+| Exercise | Topic |
+|----------|-------|
+| `conditionals` | Classification, min/max, sign |
+| `switch_statements` | Menu dispatch, enum handling |
+| `loops` | Summation, factorial, search |
+| `break_continue` | Filtering, early exit |

modules/02_control_flow/include/break_continue.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <vector>
+
+namespace control_flow {
+
+[[nodiscard]] auto sum_positive(const std::vector<int>& data) -> int;
+[[nodiscard]] auto first_multiple_of(const std::vector<int>& data, int divisor) -> int;
+[[nodiscard]] auto collect_until_negative(const std::vector<int>& data) -> std::vector<int>;
+
+}  // namespace control_flow

modules/02_control_flow/include/conditionals.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace control_flow {
+
+enum class Grade { A, B, C, D, F };
+
+[[nodiscard]] auto classify_score(int score) -> Grade;
+[[nodiscard]] auto max_of_three(int a, int b, int c) -> int;
+[[nodiscard]] auto sign_of(int value) -> int;
+
+}  // namespace control_flow

modules/02_control_flow/include/loops.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <vector>
+
+namespace control_flow {
+
+[[nodiscard]] auto sum_range(int from, int to) -> int;
+[[nodiscard]] auto factorial(int n) -> long long;
+[[nodiscard]] auto count_occurrences(const std::vector<int>& data, int target) -> int;
+[[nodiscard]] auto first_index_of(const std::vector<int>& data, int target) -> int;
+
+}  // namespace control_flow

modules/02_control_flow/include/switch_statements.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+
+namespace control_flow {
+
+enum class Operation { Add, Subtract, Multiply, Divide, Unknown };
+
+[[nodiscard]] auto parse_operation(char op) -> Operation;
+[[nodiscard]] auto apply_operation(Operation op, int lhs, int rhs) -> int;
+[[nodiscard]] auto day_name(int day) -> std::string;
+
+}  // namespace control_flow

modules/02_control_flow/src/break_continue.cpp

@@ -0,0 +1,20 @@
+#include "break_continue.hpp"
+
+namespace control_flow {
+
+auto sum_positive(const std::vector<int>& data) -> int {
+    (void)data;
+    return 0;
+}
+
+auto first_multiple_of(const std::vector<int>& data, int divisor) -> int {
+    (void)data; (void)divisor;
+    return -1;
+}
+
+auto collect_until_negative(const std::vector<int>& data) -> std::vector<int> {
+    (void)data;
+    return {};
+}
+
+}  // namespace control_flow

modules/02_control_flow/src/conditionals.cpp

@@ -0,0 +1,22 @@
+#include "conditionals.hpp"
+
+namespace control_flow {
+
+auto classify_score(int score) -> Grade {
+    // TODO: A>=90, B>=80, C>=70, D>=60, else F
+    (void)score;
+    return Grade::F;
+}
+
+auto max_of_three(int a, int b, int c) -> int {
+    (void)a; (void)b; (void)c;
+    return 0;
+}
+
+auto sign_of(int value) -> int {
+    // TODO: Return -1, 0, or 1
+    (void)value;
+    return 0;
+}
+
+}  // namespace control_flow

modules/02_control_flow/src/loops.cpp

@@ -0,0 +1,26 @@
+#include "loops.hpp"
+
+namespace control_flow {
+
+auto sum_range(int from, int to) -> int {
+    (void)from; (void)to;
+    return 0;
+}
+
+auto factorial(int n) -> long long {
+    (void)n;
+    return 1;
+}
+
+auto count_occurrences(const std::vector<int>& data, int target) -> int {
+    (void)data; (void)target;
+    return 0;
+}
+
+auto first_index_of(const std::vector<int>& data, int target) -> int {
+    // TODO: Return index or -1 if not found
+    (void)data; (void)target;
+    return -1;
+}
+
+}  // namespace control_flow

modules/02_control_flow/src/switch_statements.cpp

@@ -0,0 +1,21 @@
+#include "switch_statements.hpp"
+
+namespace control_flow {
+
+auto parse_operation(char op) -> Operation {
+    (void)op;
+    return Operation::Unknown;
+}
+
+auto apply_operation(Operation op, int lhs, int rhs) -> int {
+    (void)op; (void)lhs; (void)rhs;
+    return 0;
+}
+
+auto day_name(int day) -> std::string {
+    // TODO: 1=Monday ... 7=Sunday, else "Invalid"
+    (void)day;
+    return "Invalid";
+}
+
+}  // namespace control_flow

modules/02_control_flow/test/break_continue_test.cpp

@@ -0,0 +1,15 @@
+#include "break_continue.hpp"
+#include <gtest/gtest.h>
+
+TEST(BreakContinue, SumPositive) {
+    EXPECT_EQ(control_flow::sum_positive({1, -2, 3, -4, 5}), 9);
+}
+
+TEST(BreakContinue, FirstMultipleOf) {
+    EXPECT_EQ(control_flow::first_multiple_of({1, 3, 4, 8}, 4), 8);
+    EXPECT_EQ(control_flow::first_multiple_of({1, 3, 5}, 4), -1);
+}
+
+TEST(BreakContinue, CollectUntilNegative) {
+    EXPECT_EQ(control_flow::collect_until_negative({1, 2, 3, -1, 4}), (std::vector<int>{1, 2, 3}));
+}

modules/02_control_flow/test/conditionals_test.cpp

@@ -0,0 +1,19 @@
+#include "conditionals.hpp"
+#include <gtest/gtest.h>
+
+TEST(Conditionals, ClassifyScore) {
+    EXPECT_EQ(control_flow::classify_score(95), control_flow::Grade::A);
+    EXPECT_EQ(control_flow::classify_score(82), control_flow::Grade::B);
+    EXPECT_EQ(control_flow::classify_score(55), control_flow::Grade::F);
+}
+
+TEST(Conditionals, MaxOfThree) {
+    EXPECT_EQ(control_flow::max_of_three(1, 9, 3), 9);
+    EXPECT_EQ(control_flow::max_of_three(-1, -5, -2), -1);
+}
+
+TEST(Conditionals, SignOf) {
+    EXPECT_EQ(control_flow::sign_of(10), 1);
+    EXPECT_EQ(control_flow::sign_of(0), 0);
+    EXPECT_EQ(control_flow::sign_of(-3), -1);
+}

modules/02_control_flow/test/loops_test.cpp

@@ -0,0 +1,21 @@
+#include "loops.hpp"
+#include <gtest/gtest.h>
+
+TEST(Loops, SumRange) {
+    EXPECT_EQ(control_flow::sum_range(1, 5), 15);
+    EXPECT_EQ(control_flow::sum_range(5, 5), 5);
+}
+
+TEST(Loops, Factorial) {
+    EXPECT_EQ(control_flow::factorial(0), 1);
+    EXPECT_EQ(control_flow::factorial(5), 120);
+}
+
+TEST(Loops, CountOccurrences) {
+    EXPECT_EQ(control_flow::count_occurrences({1, 2, 2, 3}, 2), 2);
+}
+
+TEST(Loops, FirstIndexOf) {
+    EXPECT_EQ(control_flow::first_index_of({4, 5, 6}, 5), 1);
+    EXPECT_EQ(control_flow::first_index_of({4, 5, 6}, 9), -1);
+}

modules/02_control_flow/test/switch_statements_test.cpp

@@ -0,0 +1,18 @@
+#include "switch_statements.hpp"
+#include <gtest/gtest.h>
+
+TEST(SwitchStatements, ParseOperation) {
+    EXPECT_EQ(control_flow::parse_operation('+'), control_flow::Operation::Add);
+    EXPECT_EQ(control_flow::parse_operation('?'), control_flow::Operation::Unknown);
+}
+
+TEST(SwitchStatements, ApplyOperation) {
+    EXPECT_EQ(control_flow::apply_operation(control_flow::Operation::Add, 2, 3), 5);
+    EXPECT_EQ(control_flow::apply_operation(control_flow::Operation::Multiply, 4, 5), 20);
+}
+
+TEST(SwitchStatements, DayName) {
+    EXPECT_EQ(control_flow::day_name(1), "Monday");
+    EXPECT_EQ(control_flow::day_name(7), "Sunday");
+    EXPECT_EQ(control_flow::day_name(0), "Invalid");
+}