Merge branch 'master' of https://github.com/TheAlgorithms/C-Plus-Plus into nnfix

2026-05-09 07:32:54 +08:00 · 2020-08-26 22:55:15 +05:30
parent d453702ff5 c4f586b6ab
commit d7b21906de
8 changed files with 466 additions and 86 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -0,0 +1,167 @@
+---
+Language:        Cpp
+AccessModifierOffset: -3
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: true
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: true
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+    SortPriority:    0
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+    SortPriority:    0
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: true
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+Standard:        Auto
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        4
+UseCRLF:         false
+UseTab:          Never
+...
+
--- a/.github/workflows/awesome_workflow.yml
+++ b/.github/workflows/awesome_workflow.yml
@@ -16,7 +16,7 @@ jobs:
      - name: requirements
        run: | 
          sudo apt -qq -y update
-          sudo apt -qq install clang-tidy-10
+          sudo apt -qq install clang-tidy-10 clang-format-10
        # checks are passing with less errors when used with this version. 
        # The default installs v6.0 which did not work out well in my tests
      - name: Setup Git Specs
@@ -44,7 +44,7 @@ jobs:
              git "mv" "${fname}" ${new_fname}
            fi
          done
-          git commit -am "formatting filenames $GITHUB_SHA" ||  true
+          git commit -am "formatting filenames ${GITHUB_SHA::8}" ||  true

      - name: Update DIRECTORY.md
        shell: python
@@ -124,15 +124,9 @@ jobs:

          subprocess.run(["clang-tidy-10", "--fix", "-p=build", "--extra-arg=-std=c++11", *cpp_files, "--"], 
              check=True, text=True, stderr=subprocess.STDOUT)
-          # for cpp_file in cpp_files:
-          #   subprocess.run(["clang-tidy-10", "--fix", "-p=build", cpp_file, "--"], 
-          #     check=True, text=True, stderr=subprocess.STDOUT)

-          # print("g++:")
-          # compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split())
-          # compile_files = [file for file in cpp_files if file.lower().endswith(compile_exts)]
-          # for cpp_file in cpp_files:
-          #   subprocess.run(["g++", cpp_file], check=True, text=True)
+          subprocess.run(["clang-format-10", "-i", "-style=file", *cpp_files], 
+              check=True, text=True, stderr=subprocess.STDOUT)

          upper_files = [file for file in cpp_files if file != file.lower()]
          if upper_files:
@@ -155,7 +149,7 @@ jobs:
      - name: Commit and push changes
        run: |
          git diff DIRECTORY.md
-          git commit -am "clang-tidy fixes for $GITHUB_SHA" ||  true
+          git commit -am "clang-format and clang-tidy fixes for ${GITHUB_SHA::8}" ||  true
          git push --force origin HEAD:$GITHUB_REF || true

  build:
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -23,7 +23,8 @@ We are very happy that you consider implementing algorithms and data structures
 - Please use the directory structure of the repository.
 - File extension for code should be *.h *.cpp.
 - Don't use **bits/stdc++.h** because this is quite Linux specific and slows down the compilation process.
- Avoid using **struct** and instead use the **class** keyword.
+- Organize your code using **`struct`**, **`class`** and/or **`namespace`** keywords
+- If an implementation of the algorithm already exists, please refer to the [file-name section below](#new-file-name-guidelines).
 - You can suggest reasonable changes to existing algorithms.
 - Strictly use snake_case (underscore_separated) in filenames.
 - If you have added or modified code, please make sure the code compiles before submitting.
@@ -116,6 +117,7 @@ my_new_cpp_class.cpp    is correct format
 ```
 - It will be used to dynamically create a directory of files and implementation.
 - File name validation will run on docker to ensure the validity.
+- If an implementation of the algorithm already exists and your version is different from that implemented, please use incremental numeric digit as a suffix. For example, if `median_search.cpp` already exists in the `search` folder and you are contributing a new implementation, the filename should be `median_search2.cpp` and for a third implementation, `median_search3.cpp`.

 #### New Directory guidelines 
 - We recommend adding files to existing directories as much as possible.
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -113,7 +113,9 @@
  * [Adaline Learning](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/machine_learning/adaline_learning.cpp)
  * [Kohonen Som Topology](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/machine_learning/kohonen_som_topology.cpp)
  * [Kohonen Som Trace](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/machine_learning/kohonen_som_trace.cpp)
+  * [Neural Network](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/machine_learning/neural_network.cpp)
  * [Ordinary Least Squares Regressor](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/machine_learning/ordinary_least_squares_regressor.cpp)
+  * [Vector Ops](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/machine_learning/vector_ops.hpp)

 ## Math
  * [Armstrong Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/armstrong_number.cpp)
@@ -182,7 +184,7 @@
  * [Decimal To Binary](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_binary.cpp)
  * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_hexadecimal.cpp)
  * [Decimal To Roman Numeral](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_roman_numeral.cpp)
-  * [Fast Interger Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_interger_input.cpp)
+  * [Fast Integer Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_integer_input.cpp)
  * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
  * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
  * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/palindrome_of_number.cpp)
@@ -239,6 +241,7 @@
  * [Non Recursive Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/non_recursive_merge_sort.cpp)
  * [Numeric String Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/numeric_string_sort.cpp)
  * [Odd Even Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/odd_even_sort.cpp)
+  * [Pigeonhole Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/pigeonhole_sort.cpp)
  * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort.cpp)
  * [Quick Sort 3](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort_3.cpp)
  * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort.cpp)
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -13,12 +13,15 @@

 /**
 * Recursively compute sequences
+ * @param n input
+ * @returns n-th element of the Fbinacci's sequence
 */
-unsigned int fibonacci(unsigned int n) {
+uint64_t fibonacci(uint64_t n) {
    /* If the input is 0 or 1 just return the same
       This will set the first 2 values of the sequence */
-    if (n <= 1)
+    if (n <= 1) {
        return n;
+    }

    /* Add the last 2 values of the sequence to get next */
    return fibonacci(n - 1) + fibonacci(n - 2);
@@ -30,27 +33,27 @@ unsigned int fibonacci(unsigned int n) {
 * @returns `void`
 */
 static void test() {
-    unsigned int test_case_1 = fibonacci(0);
+    uint64_t test_case_1 = fibonacci(0);
    assert(test_case_1 == 0);
    std::cout << "Passed Test 1!" << std::endl;

-    unsigned int test_case_2 = fibonacci(1);
+    uint64_t test_case_2 = fibonacci(1);
    assert(test_case_2 == 1);
    std::cout << "Passed Test 2!" << std::endl;

-    unsigned int test_case_3 = fibonacci(2);
+    uint64_t test_case_3 = fibonacci(2);
    assert(test_case_3 == 1);
    std::cout << "Passed Test 3!" << std::endl;

-    unsigned int test_case_4 = fibonacci(3);
+    uint64_t test_case_4 = fibonacci(3);
    assert(test_case_4 == 2);
    std::cout << "Passed Test 4!" << std::endl;

-    unsigned int test_case_5 = fibonacci(4);
+    uint64_t test_case_5 = fibonacci(4);
    assert(test_case_5 == 3);
    std::cout << "Passed Test 5!" << std::endl;

-    unsigned int test_case_6 = fibonacci(15);
+    uint64_t test_case_6 = fibonacci(15);
    assert(test_case_6 == 610);
    std::cout << "Passed Test 6!" << std::endl << std::endl;
 }
@@ -58,7 +61,7 @@ static void test() {
 /// Main function
 int main() {
    test();
-    int n;
+    int n = 0;
    std::cin >> n;
    assert(n >= 0);
    std::cout << "F(" << n << ")= " << fibonacci(n) << std::endl;
--- a/others/fast_interger_input.cpp
+++ b/others/fast_interger_input.cpp
--- a/search/median_search.cpp
+++ b/search/median_search.cpp
@@ -1,78 +1,156 @@
 /**
- * \file
- * \brief [Median search](https://en.wikipedia.org/wiki/Median_search) algorithm
- * \warning This core is erroneous and gives invorrect answers. Tested using
- * cases from [here](https://brilliant.org/wiki/median-finding-algorithm/)
- * \ingroup median search
- * \{
+ * @file median_search.cpp
+ * @brief Implementation of [Median search](https://en.wikipedia.org/wiki/Median_of_medians) algorithm.
+ * @cases from [here](https://brilliant.org/wiki/median-finding-algorithm/)
+ *
+ * @details
+ * Given an array A[1,...,n] of n numbers and an index i, where 1 ≤ i ≤ n, find the i-th smallest element of A.
+ * median_of_medians(A, i):
+ *  #divide A into sublists of len 5
+ *  sublists = [A[j:j+5] for j in range(0, len(A), 5)]
+ *  medians = [sorted(sublist)[len(sublist)/2] for sublist in sublists]
+ *  if len(medians) <= 5:
+ *	pivot = sorted(medians)[len(medians)/2]
+ *  else:
+ *      #the pivot is the median of the medians
+ *      pivot = median_of_medians(medians, len(medians)/2)
+ *  #partitioning step
+ *  low = [j for j in A if j < pivot]
+ *  high = [j for j in A if j > pivot]
+ *  k = len(low)
+ *   if i < k:
+ *      return median_of_medians(low,i)
+ *   elif i > k:
+ *      return median_of_medians(high,i-k-1)
+ *  else: #pivot = k
+ *       return pivot
+ *
+ * \note this algorithm implements median search for only arrays which have distinct elements
+ *
+ * Here are some example lists you can use to see how the algorithm works
+ * A = [1,2,3,4,5,1000,8,9,99] (Contain Unique Elements)
+ * B = [1,2,3,4,5,6] (Contains Unique Elements)
+ * print median_of_medians(A, 0) #should be 1
+ * print median_of_medians(A,7) #should be 99
+ * print median_of_medians(B,4) #should be 5
+ *
+ * @author Unknown author
+ * @author [Sushil Kumar](https://github.com/Rp-sushil)
 */
-#include <algorithm>
+
 #include <iostream>
+#include <algorithm>
 #include <vector>
+#include <cassert>

 /**
- * @todo add documentation
+ * @namespace search
+ * @brief Search algorithms
 */
-template <class X>
-void comp(X x, std::vector<int> *s1, std::vector<int> *s2,
-          std::vector<int> *s3) {
-    if (s1->size() >= x && s1->size() + s2->size() < x) {
-        std::cout << (*s2)[0] << " is the " << x + 1 << "th element from front";
-    } else if (s1->size() > x) {
-        std::sort(s1->begin(), s1->end());
-        std::cout << (*s1)[x] << " is the " << x + 1 << "th element from front";
-    } else if (s1->size() + s2->size() <= x && s3->size() > x) {
-        std::sort(s3->begin(), s3->end());
-        std::cout << (*s3)[x - s1->size() - s2->size()] << " is the " << x + 1
-                  << "th element from front";
-    } else {
-        std::cout << x + 1 << " is invalid location";
-    }
+namespace search {
+/**
+ * @namespace median_search
+ * @brief Functions for [Median search](https://en.wikipedia.org/wiki/Median_search) algorithm
+ */
+namespace median_search {
+/**
+* This function search the element in an array for the given index.
+* @param A array where numbers are saved
+* @param idx current index in array
+* @returns corresponding element which we want to search.
+*/  
+int median_of_medians(const std::vector<int>& A,  const int& idx) {
+	int pivot = 0;					// initialized with zero
+	std::vector<int> a(A.begin(), A.end());
+	std::vector<int> m;
+	int r = a.size();
+	for(int i = 0; i < r; i += 5){
+		std::sort(a.begin() + i, a.begin() + std::min(r, i + 5));
+		int mid = (i + std::min(r, i + 5)) / 2;
+		m.push_back(a[mid]);
+	}
+	int sz = int(m.size());
+	if(sz <= 5){
+		std::sort(m.begin(), m.end());
+		pivot = m[(sz- 1) / 2];
+	}
+	else{
+		pivot = median_of_medians(m, idx);
+	}
+	std::vector<int> low;
+	std::vector<int> high;
+	for(int i = 0; i < r; i++){
+		if(a[i] < pivot){
+			low.push_back(a[i]);
+		}
+		else if(a[i] > pivot){
+			high.push_back(a[i]);
+		}
+	}
+	int k = int(low.size());
+	if(idx < k){
+		return median_of_medians(low, idx);
+	}
+	else if(idx > k){
+		return median_of_medians(high, idx-k-1);
+	}
+	else{
+		return pivot;
+	}
 }
+}  // namespace median_search
+}  // namespace search

-#define MAX_NUM 20  ///< maximum number of values to sort from
+/**
+ * Function to test above algorithm
+ */
+void test(){
+	std::vector<int> A{25,21,98,100,76,22,43,60,89,87};
+	int i = 3;
+	assert(A[6] == search::median_search::median_of_medians(A, i));		// A[6]  = 43, is the fourth smallest element.
+	std::cout << "test case:1 passed\n";
+	
+	std::vector<int> B{1,2,3,4,5,6};
+	int j = 4;
+	assert(B[4] == search::median_search::median_of_medians(B, j));		// B[4] = 5, is the fifth smallest element.
+	std::cout << "test case:2 passed\n";
+	
+	std::vector<int> C{1,2,3,4,5,1000,8,9,99};
+	int k = 3;
+	assert(C[3] == search::median_search::median_of_medians(C, k)); 	// C[3] = 4, is the fourth smallest element.
+	std::cout << "test case:3 passed\n";
+	std::cout << "--All tests passed--\n";
+}

 /**
 * Main function
 */
-int main() {
-    std::vector<int> v{25, 21, 98, 100, 76, 22, 43, 60, 89, 87};
-    std::vector<int> s1;
-    std::vector<int> s2;
-    std::vector<int> s3;
-
-    // creates an array of random numbers
-    // for (int i = 0; i < MAX_NUM; i++) {
-    //     int r = std::rand() % 1000;
-    //     v.push_back(r);
-    //     std::cout << r << " ";
-    // }
-    for (int r : v) std::cout << r << " ";
-
-    int median = std::rand() % 1000;  // initialize to a random numnber
-
-    std::cout << "\nmedian=" << median << std::endl;
-    int avg1, avg2, avg3, sum1 = 0, sum2 = 0, sum3 = 0;
-
-    for (int i = 0; i < v.size(); i++) {  // iterate through all numbers
-        if (v.back() == v[median]) {
-            avg1 = sum1 + v.back();
-            s2.push_back(v.back());
-        } else if (v.back() < v[median]) {
-            avg2 = sum2 + v.back();
-            s1.push_back(v.back());
-        } else {
-            avg3 = sum3 + v.back();
-            s3.push_back(v.back());
-        }
-        v.pop_back();
-    }
-
-    int x;
-    std::cout << "enter the no. to be searched form begining:- ";
-    std::cin >> x;
-    comp(x - 1, &s1, &s2, &s3);
-
-    return 0;
+int main()
+{
+	test();
+	int n = 0;
+	std::cout << "Enter Size of Array: ";
+	std::cin >> n;
+	std::vector<int> a(n);
+	std::cout << "Enter Array: ";
+	for(int i = 0; i < n; i++){
+		std::cin >> a[i];
+	}
+	std::cout << "Median: ";			// Median defination: https://en.wikipedia.org/wiki/Median
+	int x = search::median_search::median_of_medians(a,  (n - 1) / 2);
+	if(n % 2 == 0){
+		int y = search::median_search::median_of_medians(a, n / 2);
+		std::cout << (float(x) + float(y))/2.0;
+	}
+	else{
+		std::cout << x;
+	}
+	std::cout << "\nTo find i-th smallest element ";
+       	std::cout << "\nEnter i: ";
+	int idx = 0;
+	std::cin >> idx;
+	idx--;
+	std::cout << idx + 1<< "-th smallest element: " << search::median_search::median_of_medians(a, idx) << '\n';
+	return 0;
 }
-/// }
+
--- a/sorting/pigeonhole_sort.cpp
+++ b/sorting/pigeonhole_sort.cpp
@@ -0,0 +1,133 @@
+/**
+ * @file
+ * @brief Implementation of [Pigeonhole Sort algorithm]
+ * (https://en.wikipedia.org/wiki/Pigeonhole_sort)
+ * @author [Lownish](https://github.com/Lownish)
+ * @details
+ * Pigeonhole sorting is a sorting algorithm that is suitable for sorting lists
+ * of elements where the number of elements and the number of possible key
+ * values are approximately the same. It requires O(n + Range) time where n is
+ * number of elements in input array and ‘Range’ is number of possible values in
+ * array.
+ *
+ * The time Complexity of the algorithm is \f$O(n+N)\f$.
+ */
+
+#include <algorithm>  //for std::is_sorted
+#include <array>      //for std::array
+#include <cassert>    //for assert
+#include <iostream>   //for io operations
+
+/**
+ * @namespace sorting
+ * @brief Sorting algorithms
+ */
+namespace sorting {
+
+/**
+ * Pigeonhole sorting of array of size n
+ * The function will sort the array through Pigeonhole algorithm and print
+ * @param arr unsorted array of elements
+ * @returns sorted array of elements
+ */
+template <std::size_t N>
+std::array<int, N> pigeonSort(std::array<int, N> arr) {
+    // Finding min and max*
+    auto min = std::min_element(std::begin(arr), std::end(arr));
+    auto max = std::max_element(std::begin(arr), std::end(arr));
+
+    // Range refers to the number of holes required
+    int range = *max - *min + 1;
+    int *hole = new int[range]();
+
+    // Copying all array values to pigeonhole
+    for (int i = 0; i < N; i++) {
+        hole[arr[i] - *min] = arr[i];
+    }
+
+    // Deleting elements from list and storing to original array
+    int count = 0;
+    for (int i = 0; i < range; i++) {
+        while (hole[i] != '\0') {
+            arr[count] = hole[i];
+            hole[i] = {};
+            count++;
+        }
+    }
+    delete[] hole;
+
+    return arr;
+}
+}  // namespace sorting
+
+/**
+ * Test function 1 with unsorted array
+ * {8, 3, 2, 7, 4, 6, 8}
+ * @returns none
+ */
+static void test_1() {
+    const int n = 7;
+    std::array<int, n> test_array = {8, 3, 2, 7, 4, 6, 8};
+
+    test_array = sorting::pigeonSort<n>(test_array);
+
+    assert(std::is_sorted(std::begin(test_array), std::end(test_array)));
+
+    // Printing sorted array
+    for (int i = 0; i < n; i++) {
+        std::cout << test_array.at(i) << " ";
+    }
+    std::cout << "\nPassed\n";
+}
+
+/**
+ * Test function 2 with unsorted array
+ * {802, 630, 20, 745, 52, 300, 612, 932, 78, 187}
+ * @returns none
+ */
+static void test_2() {
+    const int n = 10;
+    std::array<int, n> test_array = {802, 630, 20,  745, 52,
+                                     300, 612, 932, 78,  187};
+
+    test_array = sorting::pigeonSort<n>(test_array);
+
+    assert(std::is_sorted(std::begin(test_array), std::end(test_array)));
+
+    // Printing sorted array
+    for (int i = 0; i < n; i++) {
+        std::cout << test_array.at(i) << " ";
+    }
+    std::cout << "\nPassed\n";
+}
+
+/**
+ * Test function 1 with unsorted array
+ * {11,13,12,14}
+ * @returns none
+ */
+static void test_3() {
+    const int n = 4;
+    std::array<int, n> test_array = {11, 13, 12, 14};
+
+    test_array = sorting::pigeonSort<n>(test_array);
+
+    assert(std::is_sorted(std::begin(test_array), std::end(test_array)));
+
+    // Printing sorted array
+    for (int i = 0; i < n; i++) {
+        std::cout << test_array.at(i) << " ";
+    }
+    std::cout << "\nPassed\n";
+}
+
+/**
+ * Main function
+ */
+int main() {
+    test_1();
+    test_2();
+    test_3();
+
+    return 0;
+}