Merge pull request #29 from Certseeds/dev for v0.8.4

prepare for v0.8.4

algorithm/2020S/20200415/20200415.cpp

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/* CS203_DSAA_template
+ Copyright (C) 2020-2022 nanoseeds
+*/
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <unordered_map>
+
+using namespace std;
+
+bool check_value(unordered_map<int32_t, int32_t> umap, vector<int32_t> vec1, double value);
+
+int main() {
+ int32_t n;
+ cin >> n;
+ unordered_map<int32_t, int32_t> value_max;
+ int32_t max_v = INT32_MIN / 2;
+ for (int32_t i = 0; i < n; ++i) {
+ int32_t a;
+ int32_t b;
+ cin >> a >> b;
+ max_v = std::max(max_v, std::max(a, b));
+ value_max[a] = std::max(value_max[a], b);
+ }
+ vector<int32_t> value1;
+ value1.reserve(value_max.size());
+ for (const auto &i: value_max) {
+ value1.push_back(i.first);
+ }
+ std::sort(value1.begin(), value1.end(), std::less<int32_t>());
+ int32_t begin = 0;
+ int32_t end = max_v * 2;
+ int32_t middle = 0;
+ while (begin < end) {
+ middle = (end - begin) / 2 + begin;
+ bool temp = check_value(value_max, value1, middle);
+ cout << middle << " " << temp << endl;
+ if (temp) {
+ begin = middle + 1;
+ } else {
+ end = middle;
+ }
+ }
+ cout << middle / 2;
+ return 0;
+}
+
+bool check_value(unordered_map<int32_t, int32_t> umap, vector<int32_t> vec1, double value) {
+ for (int32_t i = vec1.size() - 1; i >= 0; i--) {
+ auto order = std::lower_bound(vec1.begin(), vec1.end(), value - vec1[i]);
+ if (order == vec1.end()) {
+ continue;
+ }
+ if (i != order - vec1.begin() && umap[vec1[i]] + umap[vec1[order - vec1.begin()]] >= value) {
+ return true;
+ }
+ }
+ return false;
+}

algorithm/2020S/20200415/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.16.6)
+set(PROJECT_DAY 20200415)
+project(${PROJECT_NAME}_${PROJECT_DAY})
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+add_executable(${PROJECT_NAME}_${PROJECT_DAY} ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_DAY}.cpp)

algorithm/2020S/20200415/README.md

@@ -0,0 +1,4 @@
+20200415 code test
+
+company: [encryet company name](./company.gpg)
+

algorithm/2020S/20200426/20200426_1st.cpp

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/* CS203_DSAA_template
+ Copyright (C) 2020-2022 nanoseeds
+*/
+#include <cstdint>
+#include <iostream>
+#include <queue>
+#include <algorithm>
+#include <array>
+
+static constexpr const std::array<const char *const, 5> command2{"PUSH", "TOP", "POP", "SIZE", "CLEAR"};
+
+int32_t main() {
+ size_t t{0};
+ std::cin >> t;
+ for (size_t i{0}; i < t; ++i) {
+ std::queue<int32_t> que;
+ size_t q{0};
+ std::cin >> q;
+ for (size_t j{0}; j < q; ++j) {
+ std::string com;
+ int number;
+ std::cin >> com;
+ switch (std::distance(command2.begin(),
+ std::find(command2.begin(), command2.end(), com)
+ )) {
+ case 1: {
+ std::cin >> number;
+ que.push(number);
+ break;
+ }
+ case 2: {
+ if (que.empty()) {
+ std::cout << -1 << std::endl;
+ } else {
+ std::cout << que.front() << std::endl;
+ }
+ break;
+ }
+ case 3: {
+ if (que.empty()) {
+ std::cout << -1 << std::endl;
+ } else {
+ que.pop();
+ }
+ break;
+ }
+ case 4: {
+ std::cout << que.size() << std::endl;
+ break;
+ }
+ case 5: {
+ que = std::queue<int32_t>();
+ break;
+ }
+ }
+ }
+ }
+ return 0;
+}

algorithm/2020S/20200426/20200426_3rd.cpp

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/* CS203_DSAA_template
+ Copyright (C) 2020-2022 nanoseeds
+*/
+#include <cstdint>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <cmath>
+
+int32_t main() {
+ int32_t n{0};
+ std::cin >> n;
+ std::vector<std::pair<int32_t, int32_t>> a;
+ std::vector<std::pair<int32_t, int32_t>> b;
+ for (int i{0}; i < n; ++i) {
+ int x1{0}, x2{0};
+ std::cin >> x1 >> x2;
+ a.emplace_back(x1, x2);
+ }
+ for (int i{0}; i < n; ++i) {
+ int x1{0}, x2{0};
+ std::cin >> x1 >> x2;
+ b.emplace_back(x1, x2);
+ }
+ std::sort(a.begin(), a.end());
+ std::sort(b.begin(), b.end());
+ double min_value = INT32_MAX / 2;
+ struct compare {
+ bool operator()(const std::pair<int, int> &value,
+ const int &key) {
+ return (value.first < key);
+ }
+
+ bool operator()(const int &key,
+ const std::pair<int, int> &value) {
+ return (key < value.first);
+ }
+ };
+ for (const auto &i: a) {
+ const auto it = std::upper_bound(b.begin(), b.end(),
+ i.first, compare()) - b.begin();
+ // int order = std::find(b.begin(), b.end(), a.at(j).first) - b.begin();
+ for (int l = 0; l < 16; ++l) {
+ min_value = std::min(
+ min_value,
+ std::pow((i.first - b.at(std::min(it + l, static_cast<long>(b.size() - 1))).first), 2) +
+ std::pow((i.second - b.at(std::min(it + l, static_cast<long>(b.size() - 1))).second), 2));
+ min_value = std::min(
+ min_value,
+ std::pow((i.first - b.at(std::max(it - l, static_cast<long>(0))).first), 2) +
+ std::pow((i.second - b.at(std::max(it - l, static_cast<long>(0))).second), 2));
+ }
+ }
+ printf("%.3f", std::sqrt(min_value));
+ return 0;
+}

algorithm/2020S/20200426/20200426_4th.cpp

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/* CS203_DSAA_template
+ Copyright (C) 2020-2022 nanoseeds
+*/
+#include <cstdint>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <stack>
+
+inline void s1_to_s2(std::stack<int32_t> &s1, std::stack<int32_t> &s2) {
+ while (!s1.empty()) {
+ s2.push(s1.top());
+ s1.pop();
+ }
+}
+
+int32_t main() {
+ int32_t n{0};
+ std::cin >> n;
+ std::stack<int32_t> stack1, stack2;
+ for (int i = 0; i < n; ++i) {
+ std::string str;
+ std::cin >> str;
+ if ("add" == str) {
+ int number;
+ std::cin >> number;
+ stack1.push(number);
+ s1_to_s2(stack2, stack1);
+ s1_to_s2(stack1, stack2);
+ } else if ("poll" == str) {
+ s1_to_s2(stack2, stack1);
+ stack1.pop();
+ s1_to_s2(stack1, stack2);
+ } else if ("peek" == str) {
+ s1_to_s2(stack2, stack1);
+ std::cout << stack1.top() << std::endl;
+ s1_to_s2(stack1, stack2);
+ }
+ }
+ return 0;
+}

algorithm/2020S/20200426/20200426_5th.cpp

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/* CS203_DSAA_template
+ Copyright (C) 2020-2022 nanoseeds
+*/
+#include <cstdint>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <stack>
+
+int main() {
+ uint32_t q{0};
+ std::cin >> q;
+ for (uint32_t i{0}; i < q; ++i) {
+ int64_t x{0};
+ int32_t k{0};
+ std::cin >> x >> k;
+ int32_t times{0};
+ std::stack<int32_t> sta;
+ while (x > 0) {
+ sta.push(x & 1);
+ x /= 2;
+ times++;
+ }
+ if (k >= times) {
+ std::cout << -1 << std::endl;
+ continue;
+ }
+ uint64_t will_cout = 0;
+ for (int32_t j{0}; j + 1 < k; ++j) {
+ will_cout += sta.top();
+ sta.pop();
+ will_cout *= 2;
+ }
+ will_cout += sta.top();
+ //cout << times << endl;
+ std::cout << will_cout << std::endl;
+ }
+}

algorithm/2020S/20200426/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.16.6)
+set(PROJECT_DAY 20200426)
+project(${PROJECT_NAME}_${PROJECT_DAY})
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+
+set(dependencies "1st" "3rd" "4th" "5th")
+foreach (elementName IN LISTS dependencies)
+ add_executable(${PROJECT_NAME}_${PROJECT_DAY}_${elementName}
+ ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_DAY}_${elementName}.cpp)
+endforeach ()

algorithm/2020S/20200426/README.md

@@ -0,0 +1,4 @@
+20200426 code test
+
+company: [encryet company name](./company.gpg)
+

algorithm/2020S/20200511/20200511_4th.cpp

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/* CS203_DSAA_template
+ Copyright (C) 2020-2022 nanoseeds
+*/
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <unordered_set>
+
+#ifdef CS203_DSAA_TEST_MACRO
+namespace fourth_20200511{
+#endif
+
+using std::cin;
+using std::cout;
+using std::string;
+using std::vector;
+using std::unordered_set;
+static constexpr const char end{'\n'};
+
+using num_t = int32_t;
+
+int main() {
+ string init;
+ int32_t number;
+ cin >> init;
+ cin >> number;
+ int32_t command{0};
+ unordered_set<char> uset;
+ int32_t first{0};
+ for (int32_t i{0}; i < number; ++i) {
+ cin >> command;
+ cin >> first;
+ switch (command) {
+ case 1: {
+ char second;
+ cin >> second;
+ init[first - 1] = second;
+ break;
+ }
+ case 2: {
+ int32_t second;
+ cin >> second;
+ for (int j = first - 1; j < second; ++j) {
+ uset.insert(init[j]);
+ }
+ cout << uset.size() << "\n";
+ uset.clear();
+ break;
+ }
+ default: {
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+static const auto faster_streams = [] {
+ srand(time(nullptr));
+ // use time to init the random seed
+ std::ios::sync_with_stdio(false);
+ std::istream::sync_with_stdio(false);
+ std::ostream::sync_with_stdio(false);
+ std::cin.tie(nullptr);
+ std::cout.tie(nullptr);
+ // 关闭c++风格输入输出 , 与C风格输入输出的同步,提高性能.
+ return 0;
+}();
+#ifdef CS203_DSAA_TEST_MACRO
+}
+#endif

algorithm/2020S/20200511/20200511_4th_data/1.data.in

@@ -0,0 +1,7 @@
+abacaba
+5
+2 1 4
+1 4 b
+1 5 b
+2 4 6
+2 1 7

algorithm/2020S/20200511/20200511_4th_data/1.data.out

@@ -0,0 +1,3 @@
+3
+1
+2