From a6bbe050f7b56f4351bddf05fc3f8cf7c1d63711 Mon Sep 17 00:00:00 2001 From: Jxtopher <39927513+Jxtopher@users.noreply.github.com> Date: Sun, 5 Sep 2021 19:37:31 +0200 Subject: [PATCH 1/5] fix: Add `return 0` in `bactracking/magic_sequence.cpp` (#1589) * Update magic_sequence.cpp * clang-format and clang-tidy fixes for ff127de6 * Update backtracking/magic_sequence.cpp Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: Abhinn Mishra <49574460+mishraabhinn@users.noreply.github.com> Co-authored-by: David Leal --- backtracking/magic_sequence.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/backtracking/magic_sequence.cpp b/backtracking/magic_sequence.cpp index 13a260dc9..478dd28dc 100644 --- a/backtracking/magic_sequence.cpp +++ b/backtracking/magic_sequence.cpp @@ -132,4 +132,5 @@ int main() { backtracking::magic_sequence::print(item); } } + return 0; } From ea9ae3a91ba42d78867293f24914fd42ed8950b4 Mon Sep 17 00:00:00 2001 From: Tushar Khanduri <62638544+Tushar-K24@users.noreply.github.com> Date: Sun, 5 Sep 2021 23:20:51 +0530 Subject: [PATCH 2/5] feat: Add the Selection Sort Recursive algorithm (#1578) * Create selection_sort_recursive.cpp * updating DIRECTORY.md * Add: Description of Algorithm * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * clang-format and clang-tidy fixes for 8f466c86 * Apply suggestions from code review * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update selection_sort_recursive.cpp * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * clang-format and clang-tidy fixes for bfda3660 * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: Ayaan Khan Co-authored-by: David Leal Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: Ayaan Khan --- DIRECTORY.md | 1 + sorting/selection_sort_recursive.cpp | 131 +++++++++++++++++++++++++++ 2 files changed, 132 insertions(+) create mode 100644 sorting/selection_sort_recursive.cpp diff --git a/DIRECTORY.md b/DIRECTORY.md index 97a648755..b34e8afe6 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -319,6 +319,7 @@ * [Random Pivot Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/random_pivot_quick_sort.cpp) * [Recursive Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/recursive_bubble_sort.cpp) * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort.cpp) + * [Selection Sort Recursive](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort_recursive.cpp) * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort.cpp) * [Shell Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort2.cpp) * [Slow Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/slow_sort.cpp) diff --git a/sorting/selection_sort_recursive.cpp b/sorting/selection_sort_recursive.cpp new file mode 100644 index 000000000..83f1a21b7 --- /dev/null +++ b/sorting/selection_sort_recursive.cpp @@ -0,0 +1,131 @@ +/** + * @file + * @brief Implementation of the [Selection + * sort](https://en.wikipedia.org/wiki/Selection_sort) + * implementation using recursion + * @details + * The selection sort algorithm divides the input list into two parts: a sorted + * sublist of items which is built up from left to right at the front (left) of + * the list, and a sublist of the remaining unsorted items that occupy the rest + * of the list. Initially, the sorted sublist is empty, and the unsorted sublist + * is the entire input list. The algorithm proceeds by finding the smallest (or + * largest, depending on the sorting order) element in the unsorted sublist, + * exchanging (swapping) it with the leftmost unsorted element (putting it in + * sorted order), and moving the sublist boundaries one element to the right. + * + * ### Implementation + * FindMinIndex + * This function finds the minimum element of the array(list) recursively by + * simply comparing the minimum element of array reduced size by 1 and compares + * it to the last element of the array to find the minimum of the whole array. + * + * SelectionSortRecursive + * Just like selection sort, it divides the list into two parts (i.e.: sorted + * and unsorted) and finds the minimum of the unsorted array. By calling the + * `FindMinIndex` function, it swaps the minimum element with the first element + * of the list, and then solves recursively for the remaining unsorted list. + * @author [Tushar Khanduri](https://github.com/Tushar-K24) + */ + +#include /// for std::is_sorted +#include /// for assert +#include /// for std::swap and io operations +#include /// for std::vector + +/** + * @namespace sorting + * @brief Sorting algorithms + */ +namespace sorting { +/** + * @namespace selection_sort_recursive + * @brief Functions for the [Selection + * sort](https://en.wikipedia.org/wiki/Selection_sort) + * implementation using recursion + */ +namespace selection_sort_recursive { +/** + * @brief The main function finds the index of the minimum element + * @tparam T type of array + * @param in_arr array whose minimum element is to be returned + * @param current_position position/index from where the in_arr starts + * @returns index of the minimum element + */ +template +uint64_t findMinIndex(const std::vector &in_arr, uint64_t current_position = 0) { + if (current_position + 1 == in_arr.size()) { + return current_position; + } + uint64_t answer = findMinIndex(in_arr, current_position + 1); + if (in_arr[current_position] < in_arr[answer]) { + answer = current_position; + } + return answer; +} + +/** + * @brief The main function implements Selection sort + * @tparam T type of array + * @param in_arr array to be sorted, + * @param current_position position/index from where the in_arr starts + * @returns void + */ +template +void selectionSortRecursive(std::vector &in_arr, + uint64_t current_position = 0) { + if (current_position == in_arr.size()) { + return; + } + uint64_t min_element_idx = + selection_sort_recursive::findMinIndex(in_arr, current_position); + if (min_element_idx != current_position) { + std::swap(in_arr[min_element_idx], in_arr[current_position]); + } + selectionSortRecursive(in_arr, current_position + 1); +} +} // namespace selection_sort_recursive +} // namespace sorting + +/** + * @brief Self-test implementations + * @returns void + */ +static void test() { + // 1st test + // [1, 0, 2, 1] return [0, 1, 1, 2] + std::vector array1 = {0, 1, 1, 2}; + std::cout << "1st test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array1); + assert(std::is_sorted(std::begin(array1), std::end(array1))); + std::cout << "passed" << std::endl; + // 2nd test + // [1, 0, 0, 1, 1, 0, 2, 1] return [0, 0, 0, 1, 1, 1, 1, 2] + std::vector array2 = {1, 0, 0, 1, 1, 0, 2, 1}; + std::cout << "2nd test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array2); + assert(std::is_sorted(std::begin(array2), std::end(array2))); + std::cout << "passed" << std::endl; + // 3rd test + // [1, 1, 0, 0, 1, 2, 2, 0, 2, 1] return [0, 0, 0, 1, 1, 1, 1, 2, 2, 2] + std::vector array3 = {1, 1, 0, 0, 1, 2, 2, 0, 2, 1}; + std::cout << "3rd test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array3); + assert(std::is_sorted(std::begin(array3), std::end(array3))); + std::cout << "passed" << std::endl; + // 4th test + // [2, 2, 2, 0, 0, 1, 1] return [0, 0, 1, 1, 2, 2, 2] + std::vector array4 = {2, 2, 2, 0, 0, 1, 1}; + std::cout << "4th test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array4); + assert(std::is_sorted(std::begin(array4), std::end(array4))); + std::cout << "passed" << std::endl; +} + +/** + * @brief Main function + * @returns 0 on exit + */ +int main() { + test(); // run self-test implementations + return 0; +} From 040237d41a7a27da5165cc2cea0cba2a3eaaa3c4 Mon Sep 17 00:00:00 2001 From: Mayank Mamgain <56592363+Mayank17M@users.noreply.github.com> Date: Sun, 12 Sep 2021 22:49:06 +0530 Subject: [PATCH 3/5] feat: Add Travelling Salesman Problem(Naive Approach) (#1590) * Add Travelling Salesman Problem(Naive Approach) * Change header and add reference in Travelling Salesman problem * feat: Add travelling salesman problem(Naive Approach) * feat: Add travelling salesman problem. * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * updating DIRECTORY.md * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * feat: Add Travelling Salesman Problem * feat: Add Travelling Salesman Problem * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * feat: Add travelling salesman problem * fix: Hopefully fix Ci errors * Update graph/travelling_salesman_problem.cpp Co-authored-by: David Leal * clang-format and clang-tidy fixes for 56dc1e90 * feat: Add travelling salesman problem. * feat: Add travelling salesman problem Co-authored-by: David Leal Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> --- DIRECTORY.md | 1 + graph/travelling_salesman_problem.cpp | 111 ++++++++++++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100644 graph/travelling_salesman_problem.cpp diff --git a/DIRECTORY.md b/DIRECTORY.md index b34e8afe6..f19f1c8ac 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -122,6 +122,7 @@ * [Prim](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/prim.cpp) * [Topological Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/topological_sort.cpp) * [Topological Sort By Kahns Algo](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/topological_sort_by_kahns_algo.cpp) + * [Travelling Salesman Problem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/travelling_salesman_problem.cpp) ## Graphics * [Spirograph](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graphics/spirograph.cpp) diff --git a/graph/travelling_salesman_problem.cpp b/graph/travelling_salesman_problem.cpp new file mode 100644 index 000000000..28df3e931 --- /dev/null +++ b/graph/travelling_salesman_problem.cpp @@ -0,0 +1,111 @@ +/** + * @file + * @brief [Travelling Salesman Problem] + * (https://en.wikipedia.org/wiki/Travelling_salesman_problem) implementation + * + * @author [Mayank Mamgain](http://github.com/Mayank17M) + * + * @details + * Travelling salesman problem asks: + * Given a list of cities and the distances between each pair of cities, what is + * the shortest possible route that visits each city exactly once and returns to + * the origin city? + * TSP can be modeled as an undirected weighted graph, such that cities are the + * graph's vertices, paths are the graph's edges, and a path's distance is the + * edge's weight. It is a minimization problem starting and finishing at a + * specified vertex after having visited each other vertex exactly once. + * This is the naive implementation of the problem. + */ + +#include /// for std::min +#include /// for assert +#include /// for IO operations +#include /// for limits of integral types +#include /// for std::vector + +/** + * @namespace graph + * @brief Graph Algorithms + */ +namespace graph { +/** + * @brief Function calculates the minimum path distance that will cover all the + * cities starting from the source. + * + * @param cities matrix representation of cities + * @param src Point from where salesman is starting + * @param V number of vertices in the graph + * + */ +int TravellingSalesmanProblem(std::vector> *cities, + int32_t src, uint32_t V) { + //// vtx stores the vertexs of the graph + std::vector vtx; + for (uint32_t i = 0; i < V; i++) { + if (i != src) { + vtx.push_back(i); + } + } + + //// store minimum weight Hamiltonian Cycle. + int32_t min_path = 2147483647; + do { + //// store current Path weight(cost) + int32_t curr_weight = 0; + + //// compute current path weight + int k = src; + for (int i : vtx) { + curr_weight += (*cities)[k][i]; + k = i; + } + curr_weight += (*cities)[k][src]; + + //// update minimum + min_path = std::min(min_path, curr_weight); + + } while (next_permutation(vtx.begin(), vtx.end())); + + return min_path; +} +} // namespace graph + +/** + * @brief Self-test implementations + * @returns void + */ +static void tests() { + std::cout << "Initiatinig Predefined Tests..." << std::endl; + std::cout << "Initiating Test 1..." << std::endl; + std::vector> cities = { + {0, 20, 42, 35}, {20, 0, 30, 34}, {42, 30, 0, 12}, {35, 34, 12, 0}}; + uint32_t V = cities.size(); + assert(graph::TravellingSalesmanProblem(&cities, 0, V) == 97); + std::cout << "1st test passed..." << std::endl; + + std::cout << "Initiating Test 2..." << std::endl; + cities = {{0, 5, 10, 15}, {5, 0, 20, 30}, {10, 20, 0, 35}, {15, 30, 35, 0}}; + V = cities.size(); + assert(graph::TravellingSalesmanProblem(&cities, 0, V) == 75); + std::cout << "2nd test passed..." << std::endl; + + std::cout << "Initiating Test 3..." << std::endl; + cities = { + {0, 10, 15, 20}, {10, 0, 35, 25}, {15, 35, 0, 30}, {20, 25, 30, 0}}; + V = cities.size(); + assert(graph::TravellingSalesmanProblem(&cities, 0, V) == 80); + std::cout << "3rd test passed..." << std::endl; +} + +/** + * @brief Main function + * @returns 0 on exit + */ +int main() { + tests(); // run self-test implementations + std::vector> cities = { + {0, 5, 10, 15}, {5, 0, 20, 30}, {10, 20, 0, 35}, {15, 30, 35, 0}}; + uint32_t V = cities.size(); + std::cout << graph::TravellingSalesmanProblem(&cities, 0, V) << std::endl; + return 0; +} From 66331a77b46c330f1684af19b133ad519ea0976a Mon Sep 17 00:00:00 2001 From: Andrii Siriak Date: Mon, 13 Sep 2021 22:23:24 +0300 Subject: [PATCH 4/5] [feat/fix]: Add working workflow for stale items (#1605) * Create stale.yml * Delete stale.yml * Update stale.yml --- .github/stale.yml | 63 ------------------------------------- .github/workflows/stale.yml | 19 +++++++++++ 2 files changed, 19 insertions(+), 63 deletions(-) delete mode 100644 .github/stale.yml create mode 100644 .github/workflows/stale.yml diff --git a/.github/stale.yml b/.github/stale.yml deleted file mode 100644 index 6506453ea..000000000 --- a/.github/stale.yml +++ /dev/null @@ -1,63 +0,0 @@ -# Configuration for probot-stale - https://github.com/probot/stale - -# Number of days of inactivity before an Issue or Pull Request becomes stale -daysUntilStale: 30 - -# Number of days of inactivity before an Issue or Pull Request with the stale label is closed. -# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale. -daysUntilClose: 7 - -# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled) -onlyLabels: [] - -# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable -exemptLabels: - - "approved" - - "dont-close" - -# Set to true to ignore issues in a project (defaults to false) -exemptProjects: false - -# Set to true to ignore issues in a milestone (defaults to false) -exemptMilestones: false - -# Set to true to ignore issues with an assignee (defaults to false) -exemptAssignees: false - -# Label to use when marking as stale -staleLabel: abandoned - -# Limit the number of actions per hour, from 1-30. Default is 30 -limitPerRun: 5 - -# Comment to post when removing the stale label. -# unmarkComment: > -# Your comment here. - -# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls': -pulls: - # Comment to post when marking as stale. Set to `false` to disable - markComment: > - This pull request has been automatically marked as abandoned because it has not had - recent activity. It will be closed if no further activity occurs. Thank you - for your contributions. - - # Comment to post when closing a stale Pull Request. - closeComment: > - Please ping one of the maintainers once you commit the changes requested - or make improvements on the code. If this is not the case and you need - some help, feel free to ask for help in our [Gitter](https://gitter.im/TheAlgorithms) - channel. Thank you for your contributions! - -issues: - # Comment to post when marking as stale. Set to `false` to disable - markComment: > - This issue has been automatically marked as abandoned because it has not had - recent activity. It will be closed if no further activity occurs. Thank you - for your contributions. - - # Comment to post when closing a stale Issue. - closeComment: > - Please ping one of the maintainers once you add more information and updates here. - If this is not the case and you need some help, feel free to ask for help - in our [Gitter](https://gitter.im/TheAlgorithms) channel. Thank you for your contributions! diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml new file mode 100644 index 000000000..199a8b1fc --- /dev/null +++ b/.github/workflows/stale.yml @@ -0,0 +1,19 @@ +name: 'Close stale issues and PRs' +on: + schedule: + - cron: '0 0 * * *' +jobs: + stale: + runs-on: ubuntu-latest + steps: + - uses: actions/stale@v4 + with: + stale-issue-message: 'This issue has been automatically marked as abandoned because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.' + close-issue-message: 'Please ping one of the maintainers once you add more information and updates here. If this is not the case and you need some help, feel free to ask for help in our [Gitter](https://gitter.im/TheAlgorithms) channel. Thank you for your contributions!' + stale-pr-message: 'This pull request has been automatically marked as abandoned because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.' + close-pr-message: 'Please ping one of the maintainers once you commit the changes requested or make improvements on the code. If this is not the case and you need some help, feel free to ask for help in our [Gitter](https://gitter.im/TheAlgorithms) channel. Thank you for your contributions!' + exempt-issue-labels: 'dont-close,approved' + exempt-pr-labels: 'dont-close,approved' + days-before-stale: 30 + days-before-close: 7 + operations-per-run: 5 From 9f5bfc723028176f86746bbab0adea2ba9282683 Mon Sep 17 00:00:00 2001 From: Andrii Siriak Date: Tue, 14 Sep 2021 21:16:13 +0300 Subject: [PATCH 5/5] feat: Unleash full power of the stale workflow (#1607) Set stale bot action limit to default because it's actually GitHub API action limit and not the number of issues/PRs it marks per run as I thought Co-authored-by: David Leal --- .github/workflows/stale.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml index 199a8b1fc..93befa6cb 100644 --- a/.github/workflows/stale.yml +++ b/.github/workflows/stale.yml @@ -16,4 +16,3 @@ jobs: exempt-pr-labels: 'dont-close,approved' days-before-stale: 30 days-before-close: 7 - operations-per-run: 5