task_01 returned

Author: H0p1ty

task_01/CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 3.10)
+
+get_filename_component(PROJECT_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+string(REPLACE " " "_" PROJECT_NAME ${PROJECT_NAME})
+project(${PROJECT_NAME} C CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+file(GLOB_RECURSE source_list "src/*.cpp" "src/*.hpp")
+file(GLOB_RECURSE lib_source_list "../lib/src/*.cpp" "../lib/src/*.hpp")
+file(GLOB_RECURSE main_source_list "src/main.cpp")
+file(GLOB_RECURSE test_source_list "src/*.cpp")
+file(GLOB_RECURSE test_list "src/*test.cpp")
+
+list(REMOVE_ITEM test_source_list ${main_source_list})
+list(REMOVE_ITEM source_list ${test_list})
+
+include_directories(${PROJECT_NAME} PUBLIC src)
+include_directories(${PROJECT_NAME} PUBLIC ../lib/src)
+
+add_executable(${PROJECT_NAME} ${source_list})
+target_link_libraries(${PROJECT_NAME} PUBLIC Utils)
+
+# Locate GTest
+enable_testing()
+find_package(GTest REQUIRED)
+include_directories(${GTEST_INCLUDE_DIRS})
+
+# Link runTests with what we want to test and the GTest and pthread library
+add_executable(${PROJECT_NAME}_tests ${test_source_list})
+target_link_libraries(
+  ${PROJECT_NAME}_tests
+  GTest::gtest_main
+  Utils
+)
+
+include(GoogleTest)
+gtest_discover_tests(${PROJECT_NAME}_tests)

task_01/README.md

@@ -0,0 +1,3 @@
+# Задача 1
+
+Дано целое число и массив целых чисел, нужно найти 2 числа из массива которые в сумме дадут заданное число

task_01/src/main.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+
+#include "solution.h"
+
+int main() {
+  int sum, arr_size, t;
+  std::vector<int> input_vector;
+  std::unordered_map<int, int> indices_map;  // keeps array numbers as keys and
+                                             // indices as values behind keys
+
+  std::cin >> sum >> arr_size;
+
+  for (int i = 0; i < arr_size; i++) {
+    std::cin >> t;
+    input_vector.push_back(t);
+  }
+
+  std::pair<int, int> sol = solution(sum, input_vector);
+  std::cout << sol.first << ' ' << sol.second;
+
+  return 0;
+}

task_01/src/solution.h

@@ -0,0 +1,41 @@
+#include <unordered_map>
+#include <vector>
+
+/*
+
+Output - indices of two numbers, which sum is equal to needed number, if there's
+no such numbers, the output is "-1 -1"
+
+Input:
+
+10
+10
+-2 2 3 3 5 8 11 13 14 15
+
+Output:
+
+1 5
+
+*/
+
+// Solution below has a time complexity of O(n) and memory complexity of O(n)
+
+std::pair<int, int> solution(int sum, std::vector<int> v) {
+  std::unordered_map<int, int> indices_map;  // keeps array numbers as keys and
+                                             // indices as values behind keys
+
+  for (int i = 0; i < v.size(); i++) {
+    if (indices_map.find(sum - v[i]) !=
+        indices_map
+            .end()) {  // if key "number - t" exists, we have found the solution
+      return {indices_map[sum - v[i]], i};
+    }
+
+    if (indices_map.find(v[i]) == indices_map.end())
+      indices_map[v[i]] =
+          i;  // We only add keys that weren't in the map before (that
+              // way we get the least possible sum of i and j)
+  }
+
+  return {-1, -1};  // in case there are no such numbers
+}

task_01/src/test.cpp

@@ -0,0 +1,39 @@
+
+#include <gtest/gtest.h>
+
+#include "solution.h"
+
+TEST(solution, simple) {
+  std::vector<int> v1 = {-2, 2, 3, 3, 5, 9, 11, 13, 14, 15};
+  std::pair<int, int> p1 = {-1, -1};
+  ASSERT_EQ(p1, solution(10, v1));
+
+  std::vector<int> v2 = {-2, 2, 3, 3, 5, 8, 11, 13, 14, 15};
+  std::pair<int, int> p2 = {1, 5};
+  ASSERT_EQ(p2, solution(10, v2));
+
+  std::vector<int> v3 = {};
+  std::pair<int, int> p3 = {-1, -1};
+  ASSERT_EQ(p3, solution(0, v3));
+
+  std::vector<int> v4 = {1};
+  std::pair<int, int> p4 = {-1, -1};
+  ASSERT_EQ(p4, solution(1, v4));
+
+  std::vector<int> v5 = {1, 2};
+  std::pair<int, int> p5 = {0, 1};
+  ASSERT_EQ(p5, solution(3, v5));
+
+  // if there are multiple solutions, the algorithm
+  // will pick the one, in which sum of i and j is the least,
+  // where i and j are indices of numbers, which sum is equal to needed number
+  std::vector<int> v6 = {1, 1, 1, 1, 1, 1, 1, 1, 1};
+  std::pair<int, int> p6 = {0, 1};
+  ASSERT_EQ(p6, solution(2, v6));
+
+  // in case there are multiple solutions in which i+j is the least,
+  // the algorithm will pick the one, in which i is greater
+  std::vector<int> v7 = {1, 2, 1, 1, 4, 5, 1, 1, 1};
+  std::pair<int, int> p7 = {1, 4};
+  ASSERT_EQ(p7, solution(6, v7));
+}