From b845985cfab30d7bdedcd64cfeac9b755ba186d9 Mon Sep 17 00:00:00 2001
From: KsenkaKich <ks325kich@gmail.com>
Date: Thu, 20 Nov 2025 13:29:27 +0000
Subject: [PATCH 1/3] Working code and report

---
 .../common/include/common.hpp                 |  15 ++++
 .../data/pic.jpg                              | Bin 0 -> 23 bytes
 .../info.json                                 |   9 ++
 .../mpi/include/ops_mpi.hpp                   |  22 +++++
 .../mpi/src/ops_mpi.cpp                       |  72 +++++++++++++++
 .../report.md                                 |   0
 .../seq/include/ops_seq.hpp                   |  22 +++++
 .../seq/src/ops_seq.cpp                       |  42 +++++++++
 .../settings.json                             |   7 ++
 .../tests/.clang-tidy                         |  13 +++
 .../tests/functional/main.cpp                 |  85 ++++++++++++++++++
 .../tests/performance/main.cpp                |  48 ++++++++++
 12 files changed, 335 insertions(+)
 create mode 100644 tasks/kichanova_k_count_letters_in_str/common/include/common.hpp
 create mode 100644 tasks/kichanova_k_count_letters_in_str/data/pic.jpg
 create mode 100644 tasks/kichanova_k_count_letters_in_str/info.json
 create mode 100644 tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp
 create mode 100644 tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
 create mode 100644 tasks/kichanova_k_count_letters_in_str/report.md
 create mode 100644 tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp
 create mode 100644 tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp
 create mode 100644 tasks/kichanova_k_count_letters_in_str/settings.json
 create mode 100644 tasks/kichanova_k_count_letters_in_str/tests/.clang-tidy
 create mode 100644 tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
 create mode 100644 tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp

diff --git a/tasks/kichanova_k_count_letters_in_str/common/include/common.hpp b/tasks/kichanova_k_count_letters_in_str/common/include/common.hpp
new file mode 100644
index 0000000000..defbe8f7ce
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/common/include/common.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+
+#include "task/include/task.hpp"
+
+namespace kichanova_k_count_letters_in_str {
+
+using InType = std::string;
+using OutType = int;
+using TestType = std::tuple<int, std::string>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/data/pic.jpg b/tasks/kichanova_k_count_letters_in_str/data/pic.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..637624238c89d914613ed301968bffbf462bc110
GIT binary patch
literal 23
bcmWGA<1$h(;xaNd<@(RSzyQYo|NjR7KDY<J

literal 0
HcmV?d00001

diff --git a/tasks/kichanova_k_count_letters_in_str/info.json b/tasks/kichanova_k_count_letters_in_str/info.json
new file mode 100644
index 0000000000..09e4730b92
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/info.json
@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Ксения",
+    "last_name": "Кичанова",
+    "middle_name": "Константиновна",
+    "group_number": "3823Б1ФИ3",
+    "task_number": "1"
+  }
+}
diff --git a/tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp b/tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp
new file mode 100644
index 0000000000..9dac011418
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "kichanova_k_count_letters_in_str/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace kichanova_k_count_letters_in_str {
+
+class KichanovaKCountLettersInStrMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit KichanovaKCountLettersInStrMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp b/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
new file mode 100644
index 0000000000..f19a868037
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
@@ -0,0 +1,72 @@
+#include "kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <cctype>
+#include <string>
+
+#include "kichanova_k_count_letters_in_str/common/include/common.hpp"
+#include "util/include/util.hpp"
+
+namespace kichanova_k_count_letters_in_str {
+
+KichanovaKCountLettersInStrMPI::KichanovaKCountLettersInStrMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0;
+}
+
+bool KichanovaKCountLettersInStrMPI::ValidationImpl() {
+  return !GetInput().empty() && (GetOutput() == 0);
+}
+
+bool KichanovaKCountLettersInStrMPI::PreProcessingImpl() {
+  GetOutput() = 0;
+  return true;
+}
+
+bool KichanovaKCountLettersInStrMPI::RunImpl() {
+  auto input_str = GetInput();
+  if (input_str.empty()) {
+    return false;
+  }
+
+  int rank, size;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  int total_length = input_str.length();
+  int chunk_size = total_length / size;
+  int remainder = total_length % size;
+
+  int start_index = rank * chunk_size + std::min(rank, remainder);
+  int end_index = start_index + chunk_size + (rank < remainder ? 1 : 0);
+
+  int local_count = 0;
+  for (int i = start_index; i < end_index && i < total_length; i++) {
+    if (std::isalpha(static_cast<unsigned char>(input_str[i]))) {
+      local_count++;
+    }
+  }
+
+  int global_count = 0;
+  MPI_Reduce(&local_count, &global_count, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+
+  if (rank == 0) {
+    GetOutput() = global_count;
+  }
+
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  if (rank == 0) {
+    return GetOutput() > 0;
+  }
+  return true;
+
+}
+
+bool KichanovaKCountLettersInStrMPI::PostProcessingImpl() {
+  return GetOutput() >= 0;
+}
+
+}  // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/report.md b/tasks/kichanova_k_count_letters_in_str/report.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp b/tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp
new file mode 100644
index 0000000000..71162b81a5
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "kichanova_k_count_letters_in_str/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace kichanova_k_count_letters_in_str {
+
+class KichanovaKCountLettersInStrSEQ : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kSEQ;
+  }
+  explicit KichanovaKCountLettersInStrSEQ(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp b/tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp
new file mode 100644
index 0000000000..dfbb59ff2e
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp
@@ -0,0 +1,42 @@
+#include "kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp"
+
+#include <cctype>
+#include <string>
+
+#include "kichanova_k_count_letters_in_str/common/include/common.hpp"
+#include "util/include/util.hpp"
+
+namespace kichanova_k_count_letters_in_str {
+
+KichanovaKCountLettersInStrSEQ::KichanovaKCountLettersInStrSEQ(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0;
+}
+
+bool KichanovaKCountLettersInStrSEQ::ValidationImpl() {
+  return !GetInput().empty() && (GetOutput() == 0);
+}
+
+bool KichanovaKCountLettersInStrSEQ::PreProcessingImpl() {
+  GetOutput() = 0;
+  return true;
+}
+
+bool KichanovaKCountLettersInStrSEQ::RunImpl() {
+const std::string& input_str = GetInput();
+  
+  for (char c : input_str) {
+    if (std::isalpha(static_cast<unsigned char>(c))) {
+      GetOutput()++;
+    }
+  }
+  
+  return GetOutput() >= 0;
+}
+
+bool KichanovaKCountLettersInStrSEQ::PostProcessingImpl() {
+  return GetOutput() >= 0;
+}
+
+}  // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/settings.json b/tasks/kichanova_k_count_letters_in_str/settings.json
new file mode 100644
index 0000000000..7d2c35b298
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/settings.json
@@ -0,0 +1,7 @@
+{
+  "tasks_type": "processes",
+  "tasks": {
+    "mpi": "enabled",
+    "seq": "enabled"
+  }
+}
diff --git a/tasks/kichanova_k_count_letters_in_str/tests/.clang-tidy b/tasks/kichanova_k_count_letters_in_str/tests/.clang-tidy
new file mode 100644
index 0000000000..d68523c24e
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/tests/.clang-tidy
@@ -0,0 +1,13 @@
+InheritParentConfig: true
+
+Checks: >
+  -modernize-loop-convert,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -misc-use-anonymous-namespace,
+  -modernize-use-std-print,
+  -modernize-type-traits
+
+CheckOptions:
+  - key: readability-function-cognitive-complexity.Threshold
+    value: 50  # Relaxed for tests
diff --git a/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp b/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
new file mode 100644
index 0000000000..37c17f9e04
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
@@ -0,0 +1,85 @@
+#include <gtest/gtest.h>
+#include <stb/stb_image.h>
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "kichanova_k_count_letters_in_str/common/include/common.hpp"
+#include "kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp"
+#include "kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp"
+#include "util/include/func_test_util.hpp"
+#include "util/include/util.hpp"
+
+namespace kichanova_k_count_letters_in_str {
+
+class KichanovaKCountLettersInStrFuncTests : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
+ public:
+  static std::string PrintTestParam(const TestType &test_param) {
+    return std::to_string(std::get<0>(test_param)) + "_" + std::get<1>(test_param);
+  }
+
+ protected:
+  void SetUp() override {
+    TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    input_string_ = std::get<1>(params);
+    expected_output_ = CalculateExpectedCount(input_string_);
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    return (expected_output_ == output_data);
+  }
+
+  InType GetTestInputData() final {
+    return input_string_;
+  }
+
+ private:
+  int CalculateExpectedCount(const std::string& str) {
+    int count = 0;
+    for (char c : str) {
+      if (std::isalpha(static_cast<unsigned char>(c))) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  std::string input_string_;
+  int expected_output_;
+};
+
+namespace {
+
+TEST_P(KichanovaKCountLettersInStrFuncTests, CountLettersInString) {
+  ExecuteTest(GetParam());
+}
+
+
+const std::array<TestType, 4> kTestParam = {
+    std::make_tuple(5, "Hello"),           
+    std::make_tuple(10, "Hello World"),    
+    std::make_tuple(8, "Test123!"),        
+    std::make_tuple(0, "123!@#")           
+};
+
+const auto kTestTasksList =
+    std::tuple_cat(ppc::util::AddFuncTask<KichanovaKCountLettersInStrMPI, InType>(kTestParam, PPC_SETTINGS_example_processes),
+                   ppc::util::AddFuncTask<KichanovaKCountLettersInStrSEQ, InType>(kTestParam, PPC_SETTINGS_example_processes));
+
+const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
+
+const auto kPerfTestName = KichanovaKCountLettersInStrFuncTests::PrintFuncTestName<KichanovaKCountLettersInStrFuncTests>;
+
+INSTANTIATE_TEST_SUITE_P(StringTests, KichanovaKCountLettersInStrFuncTests, kGtestValues, kPerfTestName);
+
+}  // namespace
+
+}  // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp b/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
new file mode 100644
index 0000000000..50b226ae83
--- /dev/null
+++ b/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
@@ -0,0 +1,48 @@
+#include <gtest/gtest.h>
+
+#include "kichanova_k_count_letters_in_str/common/include/common.hpp"
+#include "kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp"
+#include "kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp"
+#include "util/include/perf_test_util.hpp"
+
+namespace kichanova_k_count_letters_in_str {
+
+class KichanovaKCountLettersInStrPerfTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
+  const std::string kTestString_ = "test string with letters and numbers 12345 and symbols !@#$%";
+  InType input_data_{};
+  int expected_output_{};
+
+  void SetUp() override {
+    input_data_ = kTestString_;
+    expected_output_ = 0;
+    for (char c : kTestString_) {
+      if (std::isalpha(static_cast<unsigned char>(c))) {
+        expected_output_++;
+      }
+    }
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    return expected_output_ == output_data;
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+};
+
+TEST_P(KichanovaKCountLettersInStrPerfTest, RunPerfModes) {
+  ExecuteTest(GetParam());
+}
+
+const auto kAllPerfTasks =
+    ppc::util::MakeAllPerfTasks<InType, KichanovaKCountLettersInStrMPI, KichanovaKCountLettersInStrSEQ>(PPC_SETTINGS_example_processes);
+
+const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
+
+const auto kPerfTestName = KichanovaKCountLettersInStrPerfTest::CustomPerfTestName;
+
+INSTANTIATE_TEST_SUITE_P(RunModeTests, KichanovaKCountLettersInStrPerfTest, kGtestValues, kPerfTestName);
+
+
+}  // namespace kichanova_k_count_letters_in_str

From bdfee543d693d4d13315e5a530af0cab28f99e4a Mon Sep 17 00:00:00 2001
From: KsenkaKich <ks325kich@gmail.com>
Date: Thu, 20 Nov 2025 13:34:09 +0000
Subject: [PATCH 2/3] Working code and have report

---
 .../mpi/src/ops_mpi.cpp                       |  57 ++++-----
 .../report.md                                 | 115 ++++++++++++++++++
 .../tests/functional/main.cpp                 |  27 +++-
 .../tests/performance/main.cpp                |  23 ++--
 4 files changed, 176 insertions(+), 46 deletions(-)

diff --git a/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp b/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
index f19a868037..7540c3cd81 100644
--- a/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
+++ b/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
@@ -17,7 +17,7 @@ KichanovaKCountLettersInStrMPI::KichanovaKCountLettersInStrMPI(const InType &in)
 }
 
 bool KichanovaKCountLettersInStrMPI::ValidationImpl() {
-  return !GetInput().empty() && (GetOutput() == 0);
+  return !GetInput().empty();
 }
 
 bool KichanovaKCountLettersInStrMPI::PreProcessingImpl() {
@@ -26,43 +26,36 @@ bool KichanovaKCountLettersInStrMPI::PreProcessingImpl() {
 }
 
 bool KichanovaKCountLettersInStrMPI::RunImpl() {
-  auto input_str = GetInput();
-  if (input_str.empty()) {
-    return false;
-  }
-
-  int rank, size;
-  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-  MPI_Comm_size(MPI_COMM_WORLD, &size);
-
-  int total_length = input_str.length();
-  int chunk_size = total_length / size;
-  int remainder = total_length % size;
-
-  int start_index = rank * chunk_size + std::min(rank, remainder);
-  int end_index = start_index + chunk_size + (rank < remainder ? 1 : 0);
-
-  int local_count = 0;
-  for (int i = start_index; i < end_index && i < total_length; i++) {
-    if (std::isalpha(static_cast<unsigned char>(input_str[i]))) {
-      local_count++;
+    auto input_str = GetInput();
+    if (input_str.empty()) {
+        return false;
     }
-  }
 
-  int global_count = 0;
-  MPI_Reduce(&local_count, &global_count, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+    int rank, size;
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    int total_length = input_str.length();
+    int chunk_size = total_length / size;
+    
+    int start_index = rank * chunk_size;
+    int end_index = (rank == size - 1) ? total_length : start_index + chunk_size;
+
+    int local_count = 0;
+    for (int i = start_index; i < end_index; i++) {
+        if (std::isalpha(static_cast<unsigned char>(input_str[i]))) {
+            local_count++;
+        }
+    }
 
-  if (rank == 0) {
-    GetOutput() = global_count;
-  }
+    int global_count = 0;
+    MPI_Reduce(&local_count, &global_count, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
 
-  MPI_Barrier(MPI_COMM_WORLD);
+    MPI_Bcast(&global_count, 1, MPI_INT, 0, MPI_COMM_WORLD);
 
-  if (rank == 0) {
-    return GetOutput() > 0;
-  }
-  return true;
+    GetOutput() = global_count;
 
+    return true;
 }
 
 bool KichanovaKCountLettersInStrMPI::PostProcessingImpl() {
diff --git a/tasks/kichanova_k_count_letters_in_str/report.md b/tasks/kichanova_k_count_letters_in_str/report.md
index e69de29bb2..b1c84098fb 100644
--- a/tasks/kichanova_k_count_letters_in_str/report.md
+++ b/tasks/kichanova_k_count_letters_in_str/report.md
@@ -0,0 +1,115 @@
+# Отчёт по лабораторной работе
+# Подсчёт числа буквенных символов в строке
+
+- Student: Кичанова Ксения Константиновна, group 3823Б1ФИ3
+- Technology: SEQ | MPI
+- Variant: 22
+
+## 1. Introduction
+Подсчет буквенных символов в строке — классическая задача обработки текстовых данных. В контексте параллельного программирования данная задача представляет интерес благодаря возможности распараллеливания операции подсчета символов в больших текстовых данных. Ожидается, что при использовании технолоогии mpi произойдёт ускорение по сравнению с последовательной версией.
+
+## 2. Problem Statement
+Нужно найти количество буквенных символов в строке input_str.
+Input: Строка (std::string)
+Output: Целое число (int) - количество буквенных символов в строке
+
+## 3. Baseline Algorithm (Sequential)
+Базовый последовательный алгоритм реализует однопроходное сканирование входной строки. Алгоритм последовательно обрабатывает каждый символ строки, проверяя его принадлежность к множеству буквенных символов с помощью функции std::isalpha. Для каждого символа, удовлетворяющего условию, увеличивается счетчик.
+Вычислительная сложность: O(N)
+
+## 4. Parallelization Scheme
+Каждый процесс MPI получает для обработки сегмент исходной строки. Размер сегмента вычисляется как целочисленное деление общей длины строки на количество процессов. Процесс с наибольшим рангом получает оставшуюся часть строки. Каждый процесс независимо выполняет подсчет буквенных символов в своем сегменте, проверяя каждый символ с помощью функции std::isalpha. После завершения локальных вычислений процессы синхронизируются: операция MPI_Reduce с операцией суммирования MPI_SUM собирает все локальные счетчики на процессе с рангом 0. Затем итоговый результат рассылается всем процессам с помощью MPI_Bcast для обеспечения идентичности выходных данных во всех процессах.
+
+## 5. Implementation Details
+- common.hpp - общие типы данных и константы
+- ops_seq - последовательная реализация алгоритма
+- ops_mpi - параллельная MPI-реализация алгоритма
+- tests - functional для проверки корректности и performance для замера скорости.
+
+## 6. Experimental Setup
+- Аппаратное обеспечение: AMD Ryzen 5 5500U (6 ядер, 12 логических процессоров, базовая скорость 2,10 ГГц)
+- ОЗУ — 8 ГБ 
+- Операционная система: Windows 11
+- Компилятор: g++
+- Использовался Docker-контейнер.
+- Тип сборки: Release
+
+## 7. Results and Discussion
+
+### 7.1 Correctness
+Корректность реализации проверялась тестами, включающие пустые строки, цифры, знаки и длинные строки.
+
+### 7.2 Performance
+
+pipeline:
+
+| Mode        | Count | Time, s   | Speedup | Efficiency |
+|-------------|-------|-----------|---------|------------|
+| seq         | 1     | 0.01322   | 1.00    | N/A        |
+| omp         | 2     | 0.01044   | 1.27    | 63.5%      |
+| omp         | 4     | 0.00748   | 1.77    | 44.3%      |
+
+task_run:
+
+| Mode        | Count | Time, s   | Speedup | Efficiency |
+|-------------|-------|-----------|---------|------------|
+| seq         | 1     | 0.01419   | 1.00    | N/A        |
+| omp         | 2     | 0.00865   | 1.64    | 82.0%      |
+| omp         | 4     | 0.00569   | 2.49    | 62.3%      |
+
+
+## 8. Conclusions
+MPI реализация демонстрирует положительное ускорение на всех конфигурациях. Максимальное ускорение 2.49 достигнуто в режиме task_run на 4 процессах. Эффективность параллелизации снижается с ростом числа процессов из-за накладных расходов MPI.
+
+## 9. References
+1. Лекции и практики курса "Параллельное программирование для кластерных систем"
+
+
+## Appendix
+ops_seq.cpp:
+bool KichanovaKCountLettersInStrSEQ::RunImpl() {
+const std::string& input_str = GetInput();
+  
+  for (char c : input_str) {
+    if (std::isalpha(static_cast<unsigned char>(c))) {
+      GetOutput()++;
+    }
+  }
+  
+  return GetOutput() >= 0;
+}
+
+ops_mpi.cpp:
+bool KichanovaKCountLettersInStrMPI::RunImpl() {
+    auto input_str = GetInput();
+    if (input_str.empty()) {
+        return false;
+    }
+
+    int rank, size;
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    int total_length = input_str.length();
+    int chunk_size = total_length / size;
+    
+    int start_index = rank * chunk_size;
+    int end_index = (rank == size - 1) ? total_length : start_index + chunk_size;
+
+    int local_count = 0;
+    for (int i = start_index; i < end_index; i++) {
+        if (std::isalpha(static_cast<unsigned char>(input_str[i]))) {
+            local_count++;
+        }
+    }
+
+    int global_count = 0;
+    MPI_Reduce(&local_count, &global_count, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+
+    MPI_Bcast(&global_count, 1, MPI_INT, 0, MPI_COMM_WORLD);
+
+    GetOutput() = global_count;
+
+    return true;
+}
+``` 
\ No newline at end of file
diff --git a/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp b/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
index 37c17f9e04..c44f35cca2 100644
--- a/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
+++ b/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
@@ -23,7 +23,18 @@ namespace kichanova_k_count_letters_in_str {
 class KichanovaKCountLettersInStrFuncTests : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
  public:
   static std::string PrintTestParam(const TestType &test_param) {
-    return std::to_string(std::get<0>(test_param)) + "_" + std::get<1>(test_param);
+    std::string input_str = std::get<1>(test_param);
+    std::string safe_name;
+    
+    for (char c : input_str) {
+      if (std::isalnum(static_cast<unsigned char>(c))) {
+        safe_name += c;
+      } else {
+        safe_name += '_';
+      }
+    }
+    
+    return std::to_string(std::get<0>(test_param)) + "_" + safe_name;
   }
 
  protected:
@@ -63,11 +74,15 @@ TEST_P(KichanovaKCountLettersInStrFuncTests, CountLettersInString) {
 }
 
 
-const std::array<TestType, 4> kTestParam = {
-    std::make_tuple(5, "Hello"),           
-    std::make_tuple(10, "Hello World"),    
-    std::make_tuple(8, "Test123!"),        
-    std::make_tuple(0, "123!@#")           
+const std::array<TestType, 8> kTestParam = {
+    std::make_tuple(5, "Hello"),
+    std::make_tuple(10, "Hello World"), 
+    std::make_tuple(8, "Test123!"),
+    std::make_tuple(0, "123!@#"),
+    std::make_tuple(0, " "),
+    std::make_tuple(4, "a.b,c!d"),
+    std::make_tuple(50, std::string(100, 'a') + std::string(100, '1')),    
+    std::make_tuple(1000, std::string(1000, 'x')),    
 };
 
 const auto kTestTasksList =
diff --git a/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp b/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
index 50b226ae83..a6e62c3a99 100644
--- a/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
+++ b/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
@@ -8,18 +8,25 @@
 namespace kichanova_k_count_letters_in_str {
 
 class KichanovaKCountLettersInStrPerfTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
-  const std::string kTestString_ = "test string with letters and numbers 12345 and symbols !@#$%";
   InType input_data_{};
   int expected_output_{};
 
-  void SetUp() override {
-    input_data_ = kTestString_;
-    expected_output_ = 0;
-    for (char c : kTestString_) {
-      if (std::isalpha(static_cast<unsigned char>(c))) {
-        expected_output_++;
-      }
+   void SetUp() override {
+    const size_t str_size = 5000000; 
+    
+    std::string generated_string;
+    generated_string.reserve(str_size);
+    
+    for (size_t i = 0; i < str_size; ++i) {
+        if (i % 3 == 0) {
+            generated_string += (i % 2 == 0) ? 'a' + (i % 26) : 'A' + (i % 26);
+            expected_output_++;
+        } else {
+            generated_string += (i % 2 == 0) ? '0' + (i % 10) : '!' + (i % 15);
+        }
     }
+    
+    input_data_ = generated_string;
   }
 
   bool CheckTestOutputData(OutType &output_data) final {

From a2deba4ee627608fd863b04c0838ef51f1a6fe67 Mon Sep 17 00:00:00 2001
From: KsenkaKich <ks325kich@gmail.com>
Date: Fri, 21 Nov 2025 09:50:50 +0000
Subject: [PATCH 3/3] Fix clang-format

---
 .../common/include/common.hpp                 |  2 +-
 .../mpi/include/ops_mpi.hpp                   |  6 +--
 .../mpi/src/ops_mpi.cpp                       | 54 ++++++++++---------
 .../seq/include/ops_seq.hpp                   |  6 +--
 .../seq/src/ops_seq.cpp                       | 11 ++--
 .../tests/functional/main.cpp                 | 48 +++++++++--------
 .../tests/performance/main.cpp                | 42 ++++++++-------
 7 files changed, 89 insertions(+), 80 deletions(-)

diff --git a/tasks/kichanova_k_count_letters_in_str/common/include/common.hpp b/tasks/kichanova_k_count_letters_in_str/common/include/common.hpp
index defbe8f7ce..c9a49c4f2f 100644
--- a/tasks/kichanova_k_count_letters_in_str/common/include/common.hpp
+++ b/tasks/kichanova_k_count_letters_in_str/common/include/common.hpp
@@ -12,4 +12,4 @@ using OutType = int;
 using TestType = std::tuple<int, std::string>;
 using BaseTask = ppc::task::Task<InType, OutType>;
 
-}  // namespace kichanova_k_count_letters_in_str
+} // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp b/tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp
index 9dac011418..21a495c737 100644
--- a/tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp
+++ b/tasks/kichanova_k_count_letters_in_str/mpi/include/ops_mpi.hpp
@@ -6,17 +6,17 @@
 namespace kichanova_k_count_letters_in_str {
 
 class KichanovaKCountLettersInStrMPI : public BaseTask {
- public:
+public:
   static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
     return ppc::task::TypeOfTask::kMPI;
   }
   explicit KichanovaKCountLettersInStrMPI(const InType &in);
 
- private:
+private:
   bool ValidationImpl() override;
   bool PreProcessingImpl() override;
   bool RunImpl() override;
   bool PostProcessingImpl() override;
 };
 
-}  // namespace kichanova_k_count_letters_in_str
+} // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp b/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
index 7540c3cd81..ed656097b2 100644
--- a/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
+++ b/tasks/kichanova_k_count_letters_in_str/mpi/src/ops_mpi.cpp
@@ -10,7 +10,8 @@
 
 namespace kichanova_k_count_letters_in_str {
 
-KichanovaKCountLettersInStrMPI::KichanovaKCountLettersInStrMPI(const InType &in) {
+KichanovaKCountLettersInStrMPI::KichanovaKCountLettersInStrMPI(
+    const InType &in) {
   SetTypeOfTask(GetStaticTypeOfTask());
   GetInput() = in;
   GetOutput() = 0;
@@ -26,40 +27,41 @@ bool KichanovaKCountLettersInStrMPI::PreProcessingImpl() {
 }
 
 bool KichanovaKCountLettersInStrMPI::RunImpl() {
-    auto input_str = GetInput();
-    if (input_str.empty()) {
-        return false;
-    }
+  auto input_str = GetInput();
+  if (input_str.empty()) {
+    return false;
+  }
+
+  int rank, size;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  int total_length = input_str.length();
+  int chunk_size = total_length / size;
 
-    int rank, size;
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-    MPI_Comm_size(MPI_COMM_WORLD, &size);
-
-    int total_length = input_str.length();
-    int chunk_size = total_length / size;
-    
-    int start_index = rank * chunk_size;
-    int end_index = (rank == size - 1) ? total_length : start_index + chunk_size;
-
-    int local_count = 0;
-    for (int i = start_index; i < end_index; i++) {
-        if (std::isalpha(static_cast<unsigned char>(input_str[i]))) {
-            local_count++;
-        }
+  int start_index = rank * chunk_size;
+  int end_index = (rank == size - 1) ? total_length : start_index + chunk_size;
+
+  int local_count = 0;
+  for (int i = start_index; i < end_index; i++) {
+    if (std::isalpha(static_cast<unsigned char>(input_str[i]))) {
+      local_count++;
     }
+  }
 
-    int global_count = 0;
-    MPI_Reduce(&local_count, &global_count, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+  int global_count = 0;
+  MPI_Reduce(&local_count, &global_count, 1, MPI_INT, MPI_SUM, 0,
+             MPI_COMM_WORLD);
 
-    MPI_Bcast(&global_count, 1, MPI_INT, 0, MPI_COMM_WORLD);
+  MPI_Bcast(&global_count, 1, MPI_INT, 0, MPI_COMM_WORLD);
 
-    GetOutput() = global_count;
+  GetOutput() = global_count;
 
-    return true;
+  return true;
 }
 
 bool KichanovaKCountLettersInStrMPI::PostProcessingImpl() {
   return GetOutput() >= 0;
 }
 
-}  // namespace kichanova_k_count_letters_in_str
+} // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp b/tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp
index 71162b81a5..8a321ea862 100644
--- a/tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp
+++ b/tasks/kichanova_k_count_letters_in_str/seq/include/ops_seq.hpp
@@ -6,17 +6,17 @@
 namespace kichanova_k_count_letters_in_str {
 
 class KichanovaKCountLettersInStrSEQ : public BaseTask {
- public:
+public:
   static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
     return ppc::task::TypeOfTask::kSEQ;
   }
   explicit KichanovaKCountLettersInStrSEQ(const InType &in);
 
- private:
+private:
   bool ValidationImpl() override;
   bool PreProcessingImpl() override;
   bool RunImpl() override;
   bool PostProcessingImpl() override;
 };
 
-}  // namespace kichanova_k_count_letters_in_str
+} // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp b/tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp
index dfbb59ff2e..b8d621c475 100644
--- a/tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp
+++ b/tasks/kichanova_k_count_letters_in_str/seq/src/ops_seq.cpp
@@ -8,7 +8,8 @@
 
 namespace kichanova_k_count_letters_in_str {
 
-KichanovaKCountLettersInStrSEQ::KichanovaKCountLettersInStrSEQ(const InType &in) {
+KichanovaKCountLettersInStrSEQ::KichanovaKCountLettersInStrSEQ(
+    const InType &in) {
   SetTypeOfTask(GetStaticTypeOfTask());
   GetInput() = in;
   GetOutput() = 0;
@@ -24,14 +25,14 @@ bool KichanovaKCountLettersInStrSEQ::PreProcessingImpl() {
 }
 
 bool KichanovaKCountLettersInStrSEQ::RunImpl() {
-const std::string& input_str = GetInput();
-  
+  const std::string &input_str = GetInput();
+
   for (char c : input_str) {
     if (std::isalpha(static_cast<unsigned char>(c))) {
       GetOutput()++;
     }
   }
-  
+
   return GetOutput() >= 0;
 }
 
@@ -39,4 +40,4 @@ bool KichanovaKCountLettersInStrSEQ::PostProcessingImpl() {
   return GetOutput() >= 0;
 }
 
-}  // namespace kichanova_k_count_letters_in_str
+} // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp b/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
index c44f35cca2..111b4e87b8 100644
--- a/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
+++ b/tasks/kichanova_k_count_letters_in_str/tests/functional/main.cpp
@@ -20,12 +20,13 @@
 
 namespace kichanova_k_count_letters_in_str {
 
-class KichanovaKCountLettersInStrFuncTests : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
- public:
+class KichanovaKCountLettersInStrFuncTests
+    : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
+public:
   static std::string PrintTestParam(const TestType &test_param) {
     std::string input_str = std::get<1>(test_param);
     std::string safe_name;
-    
+
     for (char c : input_str) {
       if (std::isalnum(static_cast<unsigned char>(c))) {
         safe_name += c;
@@ -33,13 +34,14 @@ class KichanovaKCountLettersInStrFuncTests : public ppc::util::BaseRunFuncTests<
         safe_name += '_';
       }
     }
-    
+
     return std::to_string(std::get<0>(test_param)) + "_" + safe_name;
   }
 
- protected:
+protected:
   void SetUp() override {
-    TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    TestType params = std::get<static_cast<std::size_t>(
+        ppc::util::GTestParamIndex::kTestParams)>(GetParam());
     input_string_ = std::get<1>(params);
     expected_output_ = CalculateExpectedCount(input_string_);
   }
@@ -48,12 +50,10 @@ class KichanovaKCountLettersInStrFuncTests : public ppc::util::BaseRunFuncTests<
     return (expected_output_ == output_data);
   }
 
-  InType GetTestInputData() final {
-    return input_string_;
-  }
+  InType GetTestInputData() final { return input_string_; }
 
- private:
-  int CalculateExpectedCount(const std::string& str) {
+private:
+  int CalculateExpectedCount(const std::string &str) {
     int count = 0;
     for (char c : str) {
       if (std::isalpha(static_cast<unsigned char>(c))) {
@@ -73,28 +73,32 @@ TEST_P(KichanovaKCountLettersInStrFuncTests, CountLettersInString) {
   ExecuteTest(GetParam());
 }
 
-
 const std::array<TestType, 8> kTestParam = {
     std::make_tuple(5, "Hello"),
-    std::make_tuple(10, "Hello World"), 
+    std::make_tuple(10, "Hello World"),
     std::make_tuple(8, "Test123!"),
     std::make_tuple(0, "123!@#"),
     std::make_tuple(0, " "),
     std::make_tuple(4, "a.b,c!d"),
-    std::make_tuple(50, std::string(100, 'a') + std::string(100, '1')),    
-    std::make_tuple(1000, std::string(1000, 'x')),    
+    std::make_tuple(50, std::string(100, 'a') + std::string(100, '1')),
+    std::make_tuple(1000, std::string(1000, 'x')),
 };
 
-const auto kTestTasksList =
-    std::tuple_cat(ppc::util::AddFuncTask<KichanovaKCountLettersInStrMPI, InType>(kTestParam, PPC_SETTINGS_example_processes),
-                   ppc::util::AddFuncTask<KichanovaKCountLettersInStrSEQ, InType>(kTestParam, PPC_SETTINGS_example_processes));
+const auto kTestTasksList = std::tuple_cat(
+    ppc::util::AddFuncTask<KichanovaKCountLettersInStrMPI, InType>(
+        kTestParam, PPC_SETTINGS_example_processes),
+    ppc::util::AddFuncTask<KichanovaKCountLettersInStrSEQ, InType>(
+        kTestParam, PPC_SETTINGS_example_processes));
 
 const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
 
-const auto kPerfTestName = KichanovaKCountLettersInStrFuncTests::PrintFuncTestName<KichanovaKCountLettersInStrFuncTests>;
+const auto kPerfTestName =
+    KichanovaKCountLettersInStrFuncTests::PrintFuncTestName<
+        KichanovaKCountLettersInStrFuncTests>;
 
-INSTANTIATE_TEST_SUITE_P(StringTests, KichanovaKCountLettersInStrFuncTests, kGtestValues, kPerfTestName);
+INSTANTIATE_TEST_SUITE_P(StringTests, KichanovaKCountLettersInStrFuncTests,
+                         kGtestValues, kPerfTestName);
 
-}  // namespace
+} // namespace
 
-}  // namespace kichanova_k_count_letters_in_str
+} // namespace kichanova_k_count_letters_in_str
diff --git a/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp b/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
index a6e62c3a99..b3849553a6 100644
--- a/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
+++ b/tasks/kichanova_k_count_letters_in_str/tests/performance/main.cpp
@@ -7,25 +7,26 @@
 
 namespace kichanova_k_count_letters_in_str {
 
-class KichanovaKCountLettersInStrPerfTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
+class KichanovaKCountLettersInStrPerfTest
+    : public ppc::util::BaseRunPerfTests<InType, OutType> {
   InType input_data_{};
   int expected_output_{};
 
-   void SetUp() override {
-    const size_t str_size = 5000000; 
-    
+  void SetUp() override {
+    const size_t str_size = 5000000;
+
     std::string generated_string;
     generated_string.reserve(str_size);
-    
+
     for (size_t i = 0; i < str_size; ++i) {
-        if (i % 3 == 0) {
-            generated_string += (i % 2 == 0) ? 'a' + (i % 26) : 'A' + (i % 26);
-            expected_output_++;
-        } else {
-            generated_string += (i % 2 == 0) ? '0' + (i % 10) : '!' + (i % 15);
-        }
+      if (i % 3 == 0) {
+        generated_string += (i % 2 == 0) ? 'a' + (i % 26) : 'A' + (i % 26);
+        expected_output_++;
+      } else {
+        generated_string += (i % 2 == 0) ? '0' + (i % 10) : '!' + (i % 15);
+      }
     }
-    
+
     input_data_ = generated_string;
   }
 
@@ -33,9 +34,7 @@ class KichanovaKCountLettersInStrPerfTest : public ppc::util::BaseRunPerfTests<I
     return expected_output_ == output_data;
   }
 
-  InType GetTestInputData() final {
-    return input_data_;
-  }
+  InType GetTestInputData() final { return input_data_; }
 };
 
 TEST_P(KichanovaKCountLettersInStrPerfTest, RunPerfModes) {
@@ -43,13 +42,16 @@ TEST_P(KichanovaKCountLettersInStrPerfTest, RunPerfModes) {
 }
 
 const auto kAllPerfTasks =
-    ppc::util::MakeAllPerfTasks<InType, KichanovaKCountLettersInStrMPI, KichanovaKCountLettersInStrSEQ>(PPC_SETTINGS_example_processes);
+    ppc::util::MakeAllPerfTasks<InType, KichanovaKCountLettersInStrMPI,
+                                KichanovaKCountLettersInStrSEQ>(
+        PPC_SETTINGS_example_processes);
 
 const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
 
-const auto kPerfTestName = KichanovaKCountLettersInStrPerfTest::CustomPerfTestName;
-
-INSTANTIATE_TEST_SUITE_P(RunModeTests, KichanovaKCountLettersInStrPerfTest, kGtestValues, kPerfTestName);
+const auto kPerfTestName =
+    KichanovaKCountLettersInStrPerfTest::CustomPerfTestName;
 
+INSTANTIATE_TEST_SUITE_P(RunModeTests, KichanovaKCountLettersInStrPerfTest,
+                         kGtestValues, kPerfTestName);
 
-}  // namespace kichanova_k_count_letters_in_str
+} // namespace kichanova_k_count_letters_in_str