diff --git a/.clang-format b/.clang-format new file mode 100644 index 000000000..2711cbb0b --- /dev/null +++ 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: '^' + 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 +... + diff --git a/.github/workflows/awesome_workflow.yml b/.github/workflows/awesome_workflow.yml index 9cff1c48d..78ea62c7b 100644 --- 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: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 35d875d43..07d620dea 100644 --- 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. diff --git a/DIRECTORY.md b/DIRECTORY.md index 605c4a1fe..178e88499 100644 --- 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) diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp index 493523b61..4e3c15de8 100644 --- 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; diff --git a/others/fast_interger_input.cpp b/others/fast_integer_input.cpp similarity index 100% rename from others/fast_interger_input.cpp rename to others/fast_integer_input.cpp diff --git a/search/median_search.cpp b/search/median_search.cpp index 7379cad26..479de8107 100644 --- 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 + #include +#include #include +#include /** - * @todo add documentation + * @namespace search + * @brief Search algorithms */ -template -void comp(X x, std::vector *s1, std::vector *s2, - std::vector *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& A, const int& idx) { + int pivot = 0; // initialized with zero + std::vector a(A.begin(), A.end()); + std::vector 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 low; + std::vector 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 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 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 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 v{25, 21, 98, 100, 76, 22, 43, 60, 89, 87}; - std::vector s1; - std::vector s2; - std::vector 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 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; } -/// } + diff --git a/sorting/pigeonhole_sort.cpp b/sorting/pigeonhole_sort.cpp new file mode 100644 index 000000000..764365b86 --- /dev/null +++ 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 //for std::is_sorted +#include //for std::array +#include //for assert +#include //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::array pigeonSort(std::array 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 test_array = {8, 3, 2, 7, 4, 6, 8}; + + test_array = sorting::pigeonSort(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 test_array = {802, 630, 20, 745, 52, + 300, 612, 932, 78, 187}; + + test_array = sorting::pigeonSort(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 test_array = {11, 13, 12, 14}; + + test_array = sorting::pigeonSort(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; +}