Merge branch 'develop' into main

Author: codejsha

coding-test-cpp-practice/src/CMakeLists.txt

@@ -6,3 +6,5 @@ add_subdirectory(problem43163)
 add_subdirectory(problem43164)
 add_subdirectory(problem64063)
 add_subdirectory(problem72411)
+add_subdirectory(problem132265)
+add_subdirectory(problem154538)

coding-test-cpp-practice/src/problem132265/CMakeLists.txt

@@ -0,0 +1,28 @@
+enable_testing()
+find_package(GTest REQUIRED)
+
+if(WIN32)
+    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+endif(WIN32)
+
+macro(add_library_target target)
+    add_library(${target} STATIC "${target}.cpp")
+    target_link_libraries(${target} PRIVATE ${ARGN})
+    set_property(TARGET ${target} PROPERTY CXX_STANDARD 17)
+endmacro()
+
+macro(add_target_test target)
+    string(REPLACE "_test" "" target_name ${target})
+    add_executable(${target} "${target}.cpp" "${target_name}.cpp")
+    target_link_libraries(${target} PRIVATE GTest::gtest GTest::gtest_main ${ARGN})
+    if(MSVC)
+        ### Edit and Continue for CMake projects
+        target_compile_options(${target} PUBLIC "/Zi")
+        target_link_options(${target} PUBLIC "/INCREMENTAL")
+    endif()
+    gtest_discover_tests(${target})
+endmacro()
+
+add_library_target(cutting_roll_cake)
+
+add_target_test(cutting_roll_cake_test)

coding-test-cpp-practice/src/problem132265/cutting_roll_cake.cpp

@@ -0,0 +1,32 @@
+#include "cutting_roll_cake.h"
+
+#include <unordered_map>
+
+int CuttingRollCake::CuttingRollCake(std::vector<int>& topping)
+{
+    auto total_map = std::unordered_map<int, int>{};
+    for (const auto& item : topping)
+    {
+        ++total_map[item];
+    }
+
+    auto left_map = std::unordered_map<int, int>{};
+    auto same_topping_case = 0;
+    for (auto current : topping)
+    {
+        ++left_map[current];
+        --total_map[current];
+
+        if (total_map[current] == 0)
+        {
+            total_map.erase(current);
+        }
+
+        if (left_map.size() == total_map.size())
+        {
+            ++same_topping_case;
+        }
+    }
+
+    return same_topping_case;
+}

coding-test-cpp-practice/src/problem132265/cutting_roll_cake.h

@@ -0,0 +1,16 @@
+#ifndef CODING_TEST_CPP_PRACTICE_CUTTING_ROLL_CAKE_H
+#define CODING_TEST_CPP_PRACTICE_CUTTING_ROLL_CAKE_H
+
+#include <vector>
+
+namespace CuttingRollCake
+{
+    /**
+     * @brief Find the number of cases that the left and right pieces of cake have the same topping
+     * @param topping topping array of cake
+     * @return the number of cases that the left and right pieces of cake have the same topping
+     */
+    int CuttingRollCake(std::vector<int>& topping);
+}
+
+#endif

coding-test-cpp-practice/src/problem132265/cutting_roll_cake_test.cpp

@@ -0,0 +1,19 @@
+#include "cutting_roll_cake.h"
+
+#include <gtest/gtest.h>
+
+GTEST_TEST(CuttingRollCake, Successful1)
+{
+    auto topping = std::vector<int>{1, 2, 1, 3, 1, 4, 1, 2};
+    const auto expected = 2;
+    const auto actual = CuttingRollCake::CuttingRollCake(topping);
+    EXPECT_EQ(expected, actual);
+}
+
+GTEST_TEST(CuttingRollCake, Successful2)
+{
+    auto topping = std::vector<int>{1, 2, 3, 1, 4};
+    const auto expected = 0;
+    const auto actual = CuttingRollCake::CuttingRollCake(topping);
+    EXPECT_EQ(expected, actual);
+}

coding-test-cpp-practice/src/problem154538/CMakeLists.txt

@@ -0,0 +1,28 @@
+enable_testing()
+find_package(GTest REQUIRED)
+
+if(WIN32)
+    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+endif(WIN32)
+
+macro(add_library_target target)
+    add_library(${target} STATIC "${target}.cpp")
+    target_link_libraries(${target} PRIVATE ${ARGN})
+    set_property(TARGET ${target} PROPERTY CXX_STANDARD 17)
+endmacro()
+
+macro(add_target_test target)
+    string(REPLACE "_test" "" target_name ${target})
+    add_executable(${target} "${target}.cpp" "${target_name}.cpp")
+    target_link_libraries(${target} PRIVATE GTest::gtest GTest::gtest_main ${ARGN})
+    if(MSVC)
+        ### Edit and Continue for CMake projects
+        target_compile_options(${target} PUBLIC "/Zi")
+        target_link_options(${target} PUBLIC "/INCREMENTAL")
+    endif()
+    gtest_discover_tests(${target})
+endmacro()
+
+add_library_target(converting_number)
+
+add_target_test(converting_number_test)

coding-test-cpp-practice/src/problem154538/converting_number.cpp

@@ -0,0 +1,63 @@
+#include "converting_number.h"
+
+#include <queue>
+#include <unordered_set>
+#include <vector>
+
+int bfs(int input, int target, const std::vector<std::function<int(int)>>& operations)
+{
+    struct State
+    {
+        int value;
+        int steps;
+    };
+
+    std::queue<State> q;
+    std::unordered_set<int> visited;
+
+    q.push({input, 0});
+    visited.insert(input);
+
+    while (!q.empty())
+    {
+        auto current = q.front();
+        q.pop();
+
+        if (current.value == target)
+        {
+            return current.steps;
+        }
+
+        for (const auto& op : operations)
+        {
+            int next_value = op(current.value);
+            if (next_value <= target && visited.find(next_value) == visited.end())
+            {
+                visited.insert(next_value);
+                q.push({next_value, current.steps + 1});
+            }
+        }
+    }
+
+    return -1;
+}
+
+int ConvertingNumber::ConvertingNumberMinStep(int x, int y, const int n)
+{
+    std::function<int(int, int)> multiply = [](int x, int k) { return x * k; };
+    std::function<int(int, int)> add = [](int x, int k) { return x + k; };
+
+    auto multiply_three = [multiply](auto&& number) {
+        return multiply(std::forward<decltype(number)>(number), 3);
+    };
+    auto multiply_two = [multiply](auto&& number) {
+        return multiply(std::forward<decltype(number)>(number), 2);
+    };
+    auto add_n = [add, n](auto&& number) {
+        return add(std::forward<decltype(number)>(number), n);
+    };
+
+    std::vector<std::function<int(int)>> functions = {multiply_three, multiply_two, add_n};
+    auto result = bfs(x, y, functions);
+    return (result == 0) ? -1 : result;
+}

coding-test-cpp-practice/src/problem154538/converting_number.h

@@ -0,0 +1,19 @@
+#ifndef CODING_TEST_CPP_PRACTICE_CONVERTING_NUMBER_H
+#define CODING_TEST_CPP_PRACTICE_CONVERTING_NUMBER_H
+
+/**
+ * not submitted to site yet
+ */
+namespace ConvertingNumber
+{
+    /**
+     * @brief Find the minimum number of steps to convert x to y
+     * @param x input value
+     * @param y target value
+     * @param n operand value for addition
+     * @return the minimum number of steps to convert x to y
+     */
+    int ConvertingNumberMinStep(int x, int y, int n);
+}
+
+#endif

coding-test-cpp-practice/src/problem154538/converting_number_test.cpp

@@ -0,0 +1,36 @@
+#include "converting_number.h"
+
+#include <gtest/gtest.h>
+
+GTEST_TEST(ConvertingNumberMinStep, Successful1)
+{
+    const auto x = 10;
+    const auto y = 40;
+    const auto n = 5;
+    const auto expected = 2;
+
+    const auto actual = ConvertingNumber::ConvertingNumberMinStep(x, y, n);
+    EXPECT_EQ(expected, actual);
+}
+
+GTEST_TEST(ConvertingNumberMinStep, Successful2)
+{
+    const auto x = 10;
+    const auto y = 40;
+    const auto n = 30;
+    const auto expected = 1;
+
+    const auto actual = ConvertingNumber::ConvertingNumberMinStep(x, y, n);
+    EXPECT_EQ(expected, actual);
+}
+
+GTEST_TEST(ConvertingNumberMinStep, Failed1)
+{
+    const auto x = 2;
+    const auto y = 5;
+    const auto n = 4;
+    const auto expected = -1;
+
+    const auto actual = ConvertingNumber::ConvertingNumberMinStep(x, y, n);
+    EXPECT_EQ(expected, actual);
+}