pre-for-release v0.8.3

</subject> Branch: master <type>: - [ ] Bug fix - [ ] Bug fix (Test) - [x] New feature - [ ] Breaking change - [ ] Documentation update - [ ] This change requires a documentation update <body> <footer> Signed-off-by: Certseeds <[email protected]>
Certseeds · Jun 19, 2022 · 7553c71 · 7553c71
2 parents 7994547 + 1a2d42d
commit 7553c71
Show file tree

Hide file tree

Showing 17 changed files with 501 additions and 241 deletions.
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -119,13 +119,12 @@ jobs:
           tree
 
       - name: release
-        uses: "marvinpinto/action-automatic-releases@latest"
+        uses: softprops/action-gh-release@v1
+        if: startsWith(github.ref, 'refs/tags/')
         with:
-          repo_token: "${{ secrets.GITHUB_TOKEN }}"
-          automatic_release_tag: "${{steps.branch_name.outputs.SOURCE_TAG}}"
-          prerelease: false
-          title: "${{steps.branch_name.outputs.SOURCE_TAG}}"
           files: ./../script_no_need.zip
+          prerelease: false
+          generate_release_notes: true
 
       - name: tree
         run: tree

diff --git a/algorithm/array/CMakeLists.txt b/algorithm/array/CMakeLists.txt
@@ -19,7 +19,8 @@ list(APPEND leetcode_order 747 766 1606 48 59)
 list(APPEND leetcode_order 334 238 560 804 806)
 list(APPEND leetcode_order 807 811 830 832 840)
 list(APPEND leetcode_order 849 852 867 868 896)
-list(APPEND leetcode_order 905 908 922)
+list(APPEND leetcode_order 905 908 922 941 942)
+list(APPEND leetcode_order 944 977)
 LIST(TRANSFORM leetcode_order PREPEND leetcode_)
 
 set(dependencies ${dependencies} ${leetcode_order})

diff --git a/algorithm/array/leetcode_941.cpp b/algorithm/array/leetcode_941.cpp
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+#include "leetcode_941_test.hpp"
+
+namespace leetcode_941 {
+
+bool leetcode_941::validMountainArray(const vector<int32_t> &arr) {
+    const auto arr_size{arr.size()};
+    if (arr_size < 3) {
+        return false;
+    } else if (arr_size == 3) {
+        return arr[0] < arr[1] && arr[1] > arr[2];
+    }
+    size_t count{0};
+    for (size_t i{1}; i + 1 < arr_size; ++i) {
+        if (arr[i - 1] == arr[i] || arr[i] == arr[i + 1]) {
+            return false;
+        }
+        count += (arr[i - 1] < arr[i]) == (arr[i] < arr[i + 1]);
+    }
+    if (count + 3 == arr_size) {
+        return true;
+    }
+    return false;
+}
+}
diff --git a/algorithm/array/leetcode_941_test.hpp b/algorithm/array/leetcode_941_test.hpp
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+//@Tag array
+//@Tag 
+#ifndef CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_941_TEST_HPP
+#define CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_941_TEST_HPP
+
+#include <catch_main.hpp>
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+
+namespace leetcode_941 {
+using std::vector;
+
+struct leetcode_941 {
+    static bool validMountainArray(const vector<int32_t> &arr);
+};
+
+
+TEST_CASE("test case 1 {test_941}", "{test_941}") {
+    const vector<int32_t> input{4, 5, 10, 7};
+    CHECK(leetcode_941::validMountainArray(input));
+}
+
+TEST_CASE("test case 2 {test_941}", "{test_941}") {
+    const vector<int32_t> input{0, 3, 2, 1};
+    CHECK(leetcode_941::validMountainArray(input));
+}
+
+TEST_CASE("test case 3 {test_941}", "{test_941}") {
+    const vector<int32_t> input{114, 514, 191};
+    CHECK(leetcode_941::validMountainArray(input));
+}
+
+TEST_CASE("test case 4 {test_941}", "{test_941}") {
+    const vector<int32_t> input{1, 8, 0};
+    CHECK(leetcode_941::validMountainArray(input));
+}
+
+TEST_CASE("test case 5 {test_941}", "{test_941}") {
+    const vector<int32_t> input{9, 1, 9};
+    CHECK_FALSE(leetcode_941::validMountainArray(input));
+}
+}
+#endif //CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_941_TEST_HPP
diff --git a/algorithm/array/leetcode_942.cpp b/algorithm/array/leetcode_942.cpp
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+#include "leetcode_942_test.hpp"
+
+namespace leetcode_942 {
+
+vector<int32_t> leetcode_942::diStringMatch(const string &str) {
+    const auto str_size{str.size()};
+    int32_t min{0}, max{static_cast<int32_t>(str_size)};
+    vector<int32_t> willreturn(max + 1);
+    for (size_t i{0}; i < str_size; i++) {
+        if (str[i] == 'I') {
+            willreturn[i] = min;
+            min++;
+        } else {
+            willreturn[i] = max;
+            max--;
+        }
+    }
+    willreturn.back() = min;
+    return willreturn;
+}
+
+}
diff --git a/algorithm/array/leetcode_942_test.hpp b/algorithm/array/leetcode_942_test.hpp
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+//@Tag array
+//@Tag 
+#ifndef CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_942_TEST_HPP
+#define CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_942_TEST_HPP
+
+#include <catch_main.hpp>
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+#include <string>
+
+namespace leetcode_942 {
+using std::vector;
+using std::string;
+
+struct leetcode_942 {
+    static vector<int> diStringMatch(const string &str);
+};
+
+static void check(const string &str, const vector<int32_t> &vec) {
+    const auto str_size{str.size()}, vec_size{vec.size()};
+    CHECK(str_size + 1 == vec_size);
+    for (size_t i{0}; i < str_size; ++i) {
+        CHECK((str[i] == 'I' || str[i] == 'D'));
+        if (str[i] == 'I') {
+            CHECK(vec[i] < vec[i + 1]);
+        } else {
+            CHECK(vec[i] > vec[i + 1]);
+        }
+    }
+}
+
+TEST_CASE("test case 1 {test_942}", "{test_942}") {
+    static constexpr const char *const str{"IDID"};
+    check(str, leetcode_942::diStringMatch(str));
+}
+
+TEST_CASE("test case 2 {test_942}", "{test_942}") {
+    static constexpr const char *const str{"III"};
+    check(str, leetcode_942::diStringMatch(str));
+}
+
+TEST_CASE("test case 3 {test_942}", "{test_942}") {
+    static constexpr const char *const str{"DDI"};
+    check(str, leetcode_942::diStringMatch(str));
+}
+}
+#endif //CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_942_TEST_HPP
diff --git a/algorithm/array/leetcode_944.cpp b/algorithm/array/leetcode_944.cpp
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+#include "leetcode_944_test.hpp"
+
+namespace leetcode_944 {
+
+int leetcode_944::minDeletionSize(const vector<string> &strs) {
+    int count{0};
+    const auto lines{strs.size()};
+    const auto str_size{strs[0].size()};
+    for (size_t i{0},notdeletex{true}; i < str_size; ++i,notdeletex = true) {
+        for (size_t j{1}; j < lines; ++j) {
+            notdeletex = notdeletex & (strs[j][i] >= strs[j - 1][i]);
+        }
+        count += !notdeletex;
+    }
+    return count;
+}
+
+}
diff --git a/algorithm/array/leetcode_944_test.hpp b/algorithm/array/leetcode_944_test.hpp
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+//@Tag array
+//@Tag 
+#ifndef CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_944_TEST_HPP
+#define CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_944_TEST_HPP
+
+#include <catch_main.hpp>
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+#include <string>
+
+namespace leetcode_944 {
+using std::vector;
+using std::string;
+
+struct leetcode_944 {
+    static int minDeletionSize(const vector<string> &A);
+};
+
+TEST_CASE("test case 1 {test_944}", "{test_944}") {
+    static constexpr const std::array<const char *const, 3> input{
+            "abc", "bce", "cae"
+    };
+    static constexpr const auto result{1};
+    CHECK(result == leetcode_944::minDeletionSize({input.begin(), input.end()}));
+}
+
+TEST_CASE("test case 2 {test_944}", "{test_944}") {
+    static constexpr const std::array<const char *const, 2> input{
+            "a", "b"
+    };
+    static constexpr const auto result{0};
+    CHECK(result  == leetcode_944::minDeletionSize({input.begin(), input.end()}));
+}
+TEST_CASE("test case 3 {test_944}", "{test_944}") {
+    static constexpr const std::array<const char *const, 3> input{
+            "zyx", "wvu", "tsr"
+    };
+    static constexpr const auto result{3};
+    CHECK(result == leetcode_944::minDeletionSize({input.begin(), input.end()}));
+}
+}
+#endif //CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_944_TEST_HPP
diff --git a/algorithm/array/leetcode_977.cpp b/algorithm/array/leetcode_977.cpp
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+#include "leetcode_977_test.hpp"
+
+namespace leetcode_977 {
+
+// best O(n)
+vector<int32_t> leetcode_977::sortedSquares(const vector<int32_t> &nums) {
+    const auto nums_size{nums.size()};
+    static constexpr const auto cmp = [](int32_t x, int32_t y) {
+        return x * x <= y * y;
+    };
+    vector<int32_t> will_return{};
+    const size_t posi = std::min_element(nums.cbegin(), nums.cend(), cmp) - nums.cbegin();
+    size_t left{posi + 1}, right{posi + 1};
+    while (0 < left && right < nums_size) {
+        const auto cmpValue = cmp(nums[left - 1], nums[right]);
+        if (cmpValue) {
+            will_return.push_back(nums[left - 1] * nums[left - 1]);
+            --left;
+        } else {
+            will_return.push_back(nums[right] * nums[right]);
+            ++right;
+        }
+    }
+    for (; 0 < left; --left) { will_return.push_back(nums[left - 1] * nums[left - 1]); }
+    for (; right < nums_size; ++right) { will_return.push_back(nums[right] * nums[right]); }
+    return will_return;
+}
+
+}
diff --git a/algorithm/array/leetcode_977_test.hpp b/algorithm/array/leetcode_977_test.hpp
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+//@Tag array
+//@Tag 
+#ifndef CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_977_TEST_HPP
+#define CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_977_TEST_HPP
+
+#include <catch_main.hpp>
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+#include <string>
+
+namespace leetcode_977 {
+using std::vector;
+using std::string;
+
+struct leetcode_977 {
+    static vector<int32_t> sortedSquares(const vector<int32_t> &nums);
+};
+
+using Catch::Matchers::Equals;
+
+TEST_CASE("test case 1 {test_977}", "{test_977}") {
+    const vector<int32_t> input{-4, -1, 0, 3, 10};
+    const vector<int32_t> result{0, 1, 9, 16, 100};
+    CHECK_THAT(result, Equals(leetcode_977::sortedSquares(input)));
+}
+
+TEST_CASE("test case 2 {test_977}", "{test_977}") {
+    const vector<int32_t> input{-7, -3, 2, 3, 11};
+    const vector<int32_t> result{4, 9,9, 49, 121};
+    CHECK_THAT(result, Equals(leetcode_977::sortedSquares(input)));
+}
+}
+#endif //CS203_DSAA_TEMPLATE_ALGORITHM_ARRAY_LEETCODE_977_TEST_HPP
diff --git a/algorithm/associative_container/CMakeLists.txt b/algorithm/associative_container/CMakeLists.txt
@@ -8,7 +8,7 @@ enable_testing()
 set(dependencies)
 
 set(leetcode_order 888 890 893 1409 914)
-list(APPEND leetcode_order 929)
+list(APPEND leetcode_order 929 961)
 LIST(TRANSFORM leetcode_order PREPEND leetcode_)
 
 set(dependencies ${dependencies} ${leetcode_order})

diff --git a/algorithm/associative_container/leetcode_961.cpp b/algorithm/associative_container/leetcode_961.cpp
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+/*
+CS203_DSAA_template
+
+Copyright (C) 2022  nanoseeds
+
+*/
+#include "leetcode_961_test.hpp"
+#include <unordered_set>
+
+namespace leetcode_961 {
+using std::unordered_set;
+
+int32_t leetcode_961::repeatedNTimes(const vector<int32_t> &nums) {
+    unordered_set<int32_t> uset{};
+    for (const auto num: nums) {
+        if (uset.count(num) != 0) {
+            return num;
+        } else {
+            uset.insert(num);
+        }
+    }
+    return -1;
+}
+
+}