Merge branch 'master' into add_sha1_algorithm

.github/workflows/stale.yml

@@ -0,0 +1,18 @@
+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

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)
@@ -320,6 +321,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)

backtracking/magic_sequence.cpp

@@ -132,4 +132,5 @@ int main() {
  backtracking::magic_sequence::print(item);
  }
  }
+ return 0;
 }

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:https://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 <algorithm> /// for std::min
+#include <cassert> /// for assert
+#include <iostream> /// for IO operations
+#include <limits> /// for limits of integral types
+#include <vector> /// 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<std::vector<uint32_t>> *cities,
+ int32_t src, uint32_t V) {
+ //// vtx stores the vertexs of the graph
+ std::vector<uint32_t> 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<std::vector<uint32_t>> 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<std::vector<uint32_t>> 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;
+}

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 <algorithm> /// for std::is_sorted
+#include <cassert> /// for assert
+#include <iostream> /// for std::swap and io operations
+#include <vector> /// 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 <typename T>
+uint64_t findMinIndex(const std::vector<T> &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 <typename T>
+void selectionSortRecursive(std::vector<T> &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<uint64_t> 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<uint64_t> 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<uint64_t> 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<uint64_t> 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;
+}