Initial Course

modules/04_arrays_and_strings/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_course_exercise(NAME c_arrays MODULE 04_arrays_and_strings STANDARD 17
+    SOURCES src/c_arrays.cpp test/c_arrays_test.cpp)
+add_course_exercise(NAME std_string MODULE 04_arrays_and_strings STANDARD 17
+    SOURCES src/std_string.cpp test/std_string_test.cpp)
+add_course_exercise(NAME std_vector MODULE 04_arrays_and_strings STANDARD 17
+    SOURCES src/std_vector.cpp test/std_vector_test.cpp)
+add_course_exercise(NAME multidimensional MODULE 04_arrays_and_strings STANDARD 17
+    SOURCES src/multidimensional.cpp test/multidimensional_test.cpp)

modules/04_arrays_and_strings/README.md

@@ -0,0 +1,17 @@
+# Module 04: Arrays and Strings
+
+## Learning Goals
+
+- Use C-style arrays and understand their limitations
+- Work with `std::string` manipulation
+- Master `std::vector` as a dynamic array
+- Handle multi-dimensional data structures
+
+## Exercises
+
+| Exercise | Topic |
+|----------|-------|
+| `c_arrays` | Fixed-size arrays, bounds |
+| `std_string` | String operations |
+| `std_vector` | Dynamic arrays |
+| `multidimensional` | 2D vectors and matrices |

modules/04_arrays_and_strings/include/c_arrays.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <cstddef>
+
+namespace arrays {
+
+[[nodiscard]] auto array_sum(const int* data, std::size_t size) -> int;
+[[nodiscard]] auto array_max(const int* data, std::size_t size) -> int;
+void reverse_array(int* data, std::size_t size);
+
+}  // namespace arrays

modules/04_arrays_and_strings/include/multidimensional.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <vector>
+
+namespace arrays {
+
+using Matrix = std::vector<std::vector<int>>;
+
+[[nodiscard]] auto create_matrix(int rows, int cols, int fill) -> Matrix;
+[[nodiscard]] auto transpose(const Matrix& matrix) -> Matrix;
+[[nodiscard]] auto row_sums(const Matrix& matrix) -> std::vector<int>;
+
+}  // namespace arrays

modules/04_arrays_and_strings/include/std_string.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+
+namespace arrays {
+
+[[nodiscard]] auto to_uppercase(std::string text) -> std::string;
+[[nodiscard]] auto trim(const std::string& text) -> std::string;
+[[nodiscard]] auto replace_all(std::string text, char from, char to) -> std::string;
+[[nodiscard]] auto starts_with(const std::string& text, const std::string& prefix) -> bool;
+
+}  // namespace arrays

modules/04_arrays_and_strings/include/std_vector.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <vector>
+
+namespace arrays {
+
+[[nodiscard]] auto vector_sum(const std::vector<int>& data) -> int;
+void remove_value(std::vector<int>& data, int value);
+[[nodiscard]] auto unique_sorted(std::vector<int> data) -> std::vector<int>;
+[[nodiscard]] auto chunk(const std::vector<int>& data, std::size_t size) -> std::vector<std::vector<int>>;
+
+}  // namespace arrays

modules/04_arrays_and_strings/src/c_arrays.cpp

@@ -0,0 +1,9 @@
+#include "c_arrays.hpp"
+
+namespace arrays {
+
+auto array_sum(const int* data, std::size_t size) -> int { (void)data; (void)size; return 0; }
+auto array_max(const int* data, std::size_t size) -> int { (void)data; (void)size; return 0; }
+void reverse_array(int* data, std::size_t size) { (void)data; (void)size; }
+
+}  // namespace arrays

modules/04_arrays_and_strings/src/multidimensional.cpp

@@ -0,0 +1,9 @@
+#include "multidimensional.hpp"
+
+namespace arrays {
+
+auto create_matrix(int rows, int cols, int fill) -> Matrix { (void)rows; (void)cols; (void)fill; return {}; }
+auto transpose(const Matrix& matrix) -> Matrix { (void)matrix; return {}; }
+auto row_sums(const Matrix& matrix) -> std::vector<int> { (void)matrix; return {}; }
+
+}  // namespace arrays

modules/04_arrays_and_strings/src/std_string.cpp

@@ -0,0 +1,10 @@
+#include "std_string.hpp"
+
+namespace arrays {
+
+auto to_uppercase(std::string text) -> std::string { (void)text; return {}; }
+auto trim(const std::string& text) -> std::string { (void)text; return {}; }
+auto replace_all(std::string text, char from, char to) -> std::string { (void)text; (void)from; (void)to; return {}; }
+auto starts_with(const std::string& text, const std::string& prefix) -> bool { (void)text; (void)prefix; return false; }
+
+}  // namespace arrays

modules/04_arrays_and_strings/src/std_vector.cpp

@@ -0,0 +1,10 @@
+#include "std_vector.hpp"
+
+namespace arrays {
+
+auto vector_sum(const std::vector<int>& data) -> int { (void)data; return 0; }
+void remove_value(std::vector<int>& data, int value) { (void)data; (void)value; }
+auto unique_sorted(std::vector<int> data) -> std::vector<int> { (void)data; return {}; }
+auto chunk(const std::vector<int>& data, std::size_t size) -> std::vector<std::vector<int>> { (void)data; (void)size; return {}; }
+
+}  // namespace arrays

modules/04_arrays_and_strings/test/c_arrays_test.cpp

@@ -0,0 +1,19 @@
+#include "c_arrays.hpp"
+#include <gtest/gtest.h>
+
+TEST(CArrays, Sum) {
+    const int data[] = {1, 2, 3, 4};
+    EXPECT_EQ(arrays::array_sum(data, 4), 10);
+}
+
+TEST(CArrays, Max) {
+    const int data[] = {1, 9, 3};
+    EXPECT_EQ(arrays::array_max(data, 3), 9);
+}
+
+TEST(CArrays, Reverse) {
+    int data[] = {1, 2, 3, 4};
+    arrays::reverse_array(data, 4);
+    EXPECT_EQ(data[0], 4);
+    EXPECT_EQ(data[3], 1);
+}

modules/04_arrays_and_strings/test/multidimensional_test.cpp

@@ -0,0 +1,20 @@
+#include "multidimensional.hpp"
+#include <gtest/gtest.h>
+
+TEST(Multidimensional, CreateMatrix) {
+    const auto m = arrays::create_matrix(2, 3, 7);
+    ASSERT_EQ(m.size(), 2U);
+    ASSERT_EQ(m[0].size(), 3U);
+    EXPECT_EQ(m[1][2], 7);
+}
+
+TEST(Multidimensional, Transpose) {
+    const arrays::Matrix m{{1, 2}, {3, 4}};
+    const auto t = arrays::transpose(m);
+    EXPECT_EQ(t, (arrays::Matrix{{1, 3}, {2, 4}}));
+}
+
+TEST(Multidimensional, RowSums) {
+    const arrays::Matrix m{{1, 2, 3}, {4, 5, 6}};
+    EXPECT_EQ(arrays::row_sums(m), (std::vector<int>{6, 15}));
+}

modules/04_arrays_and_strings/test/std_string_test.cpp

@@ -0,0 +1,19 @@
+#include "std_string.hpp"
+#include <gtest/gtest.h>
+
+TEST(StdString, ToUppercase) {
+    EXPECT_EQ(arrays::to_uppercase("Hello"), "HELLO");
+}
+
+TEST(StdString, Trim) {
+    EXPECT_EQ(arrays::trim("  hi  "), "hi");
+}
+
+TEST(StdString, ReplaceAll) {
+    EXPECT_EQ(arrays::replace_all("a-b-c", '-', '_'), "a_b_c");
+}
+
+TEST(StdString, StartsWith) {
+    EXPECT_TRUE(arrays::starts_with("C++26", "C++"));
+    EXPECT_FALSE(arrays::starts_with("C++26", "Java"));
+}

modules/04_arrays_and_strings/test/std_vector_test.cpp

@@ -0,0 +1,21 @@
+#include "std_vector.hpp"
+#include <gtest/gtest.h>
+
+TEST(StdVector, Sum) {
+    EXPECT_EQ(arrays::vector_sum({1, 2, 3}), 6);
+}
+
+TEST(StdVector, RemoveValue) {
+    std::vector<int> data = {1, 2, 2, 3};
+    arrays::remove_value(data, 2);
+    EXPECT_EQ(data, (std::vector<int>{1, 3}));
+}
+
+TEST(StdVector, UniqueSorted) {
+    EXPECT_EQ(arrays::unique_sorted({3, 1, 2, 2, 3}), (std::vector<int>{1, 2, 3}));
+}
+
+TEST(StdVector, Chunk) {
+    EXPECT_EQ(arrays::chunk({1, 2, 3, 4, 5}, 2),
+              (std::vector<std::vector<int>>{{1, 2}, {3, 4}, {5}}));
+}