OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2 from kvedala/document/others

Browse Source 
Documentation for files in the folder `others`
This commit is contained in:
Krishna Vedala 2020-05-28 16:10:23 -04:00 committed by GitHub
commit 645768f140
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
35 changed files with 1035 additions and 790 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.github/workflows/cpplint_modified_files.yml vendored
View File

@ -37,7 +37,8 @@ jobs:
sys.exit(0) sys.exit(0)
print("cpplint:") print("cpplint:")
subprocess.run(["cpplint", "--filter=-legal/copyright"] + cpp_files, check=True, text=True) for cpp_file in cpp_files:
subprocess.run(["cpplint", "--filter=-legal/copyright", cpp_file], check=True, text=True)
print("g++:") print("g++:")
# compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split()) # compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split())

15
DIRECTORY.md
View File

@ -109,8 +109,13 @@
* [Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/factorial.cpp) * [Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/factorial.cpp)
* [Fast Power](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fast_power.cpp) * [Fast Power](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fast_power.cpp)
* [Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci.cpp) * [Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci.cpp)
* [Fibonacci Fast](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci_fast.cpp)
* [Fibonacci Large](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci_large.cpp)
* [Gcd Iterative Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_iterative_euclidean.cpp) * [Gcd Iterative Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_iterative_euclidean.cpp)
* [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_of_n_numbers.cpp)
* [Gcd Recursive Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_recursive_euclidean.cpp) * [Gcd Recursive Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_recursive_euclidean.cpp)
* [Large Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/large_factorial.cpp)
* [Large Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/large_number.h)
* [Modular Inverse Fermat Little Theorem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/modular_inverse_fermat_little_theorem.cpp) * [Modular Inverse Fermat Little Theorem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/modular_inverse_fermat_little_theorem.cpp)
* [Number Of Positive Divisors](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/number_of_positive_divisors.cpp) * [Number Of Positive Divisors](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/number_of_positive_divisors.cpp)
* [Power For Huge Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/power_for_huge_numbers.cpp) * [Power For Huge Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/power_for_huge_numbers.cpp)
@ -119,6 +124,7 @@
* [Primes Up To Billion](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/primes_up_to_billion.cpp) * [Primes Up To Billion](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/primes_up_to_billion.cpp)
* [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sieve_of_eratosthenes.cpp) * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sieve_of_eratosthenes.cpp)
* [Sqrt Double](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sqrt_double.cpp) * [Sqrt Double](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sqrt_double.cpp)
* [String Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/string_fibonacci.cpp)
## Operations On Datastructures ## Operations On Datastructures
* [Array Left Rotation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Array%20Left%20Rotation.cpp) * [Array Left Rotation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Array%20Left%20Rotation.cpp)
@ -137,23 +143,16 @@
* [Decimal To Hexadecimal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_hexadecimal.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) * [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 Interger Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_interger_input.cpp)
* [Fibonacci Fast](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_fast.cpp)
* [Fibonacci Large](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_large.cpp)
* [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/gcd_of_n_numbers.cpp)
* [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp) * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
* [Large Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/large_factorial.cpp)
* [Large Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/large_number.h)
* [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.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) * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/palindrome_of_number.cpp)
* [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp) * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)
* [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp) * [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp)
* [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/primality_test.cpp) * [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/primality_test.cpp)
* [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sieve_of_Eratosthenes.cpp) * [Smallest Circle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/smallest_circle.cpp)
* [Smallest-Circle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/smallest-circle.cpp)
* [Sparse Matrix](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sparse_matrix.cpp) * [Sparse Matrix](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sparse_matrix.cpp)
* [Spiral Print](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/spiral_print.cpp) * [Spiral Print](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/spiral_print.cpp)
* [Stairs Pattern](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/stairs_pattern.cpp) * [Stairs Pattern](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/stairs_pattern.cpp)
* [String Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/string_fibonacci.cpp)
* [Tower Of Hanoi](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/tower_of_hanoi.cpp) * [Tower Of Hanoi](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/tower_of_hanoi.cpp)
* [Vector Important Functions](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/vector_important_functions.cpp) * [Vector Important Functions](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/vector_important_functions.cpp)

1
data_structure/doubly_linked_list.cpp
View File

@ -61,6 +61,7 @@ void double_linked_list::remove(int x) {
t->prev->next = t->next; t->prev->next = t->next;
t->next->prev = t->prev; t->next->prev = t->prev;
} }
delete t;
} }
void double_linked_list::search(int x) { void double_linked_list::search(int x) {

5
math/fibonacci.cpp
View File

@ -5,6 +5,8 @@
* Calculate the the value on Fibonacci's sequence given an * Calculate the the value on Fibonacci's sequence given an
* integer as input. * integer as input.
* \f[\text{fib}(n) = \text{fib}(n-1) + \text{fib}(n-2)\f] * \f[\text{fib}(n) = \text{fib}(n-1) + \text{fib}(n-2)\f]
*
* @see fibonacci_large.cpp, fibonacci_fast.cpp, string_fibonacci.cpp
*/ */
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
@ -15,7 +17,8 @@
int fibonacci(unsigned int n) { int fibonacci(unsigned int n) {
/* If the input is 0 or 1 just return the same /* If the input is 0 or 1 just return the same
This will set the first 2 values of the sequence */ This will set the first 2 values of the sequence */
if (n <= 1) return n; if (n <= 1)
return n;
/* Add the last 2 values of the sequence to get next */ /* Add the last 2 values of the sequence to get next */
return fibonacci(n - 1) + fibonacci(n - 2); return fibonacci(n - 1) + fibonacci(n - 2);

52
math/fibonacci_fast.cpp Normal file
View File

@ -0,0 +1,52 @@
/**
* @file
* @brief Faster computation of Fibonacci series
*
* An efficient way to calculate nth fibonacci number faster and simpler than
* \f$O(n\log n)\f$ method of matrix exponentiation This works by using both
* recursion and dynamic programming. as 93rd fibonacci exceeds 19 digits, which
* cannot be stored in a single long long variable, we can only use it till 92nd
* fibonacci we can use it for 10000th fibonacci etc, if we implement
* bigintegers. This algorithm works with the fact that nth fibonacci can easily
* found if we have already found n/2th or (n+1)/2th fibonacci It is a property
* of fibonacci similar to matrix exponentiation.
*
* @see fibonacci_large.cpp, fibonacci.cpp
*/
#include <cinttypes>
#include <cstdio>
#include <iostream>
/** maximum number that can be computed - The result after 93 cannot be stored
* in a `uint64_t` data type. */
const uint64_t MAX = 93;
/** Array of computed fibonacci numbers */
uint64_t f[MAX] = {0};
/** Algorithm */
uint64_t fib(uint64_t n) {
if (n == 0)
return 0;
if (n == 1 || n == 2)
return (f[n] = 1);
if (f[n])
return f[n];
uint64_t k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
f[n] = (n % 2 != 0) ? (fib(k) * fib(k) + fib(k - 1) * fib(k - 1))
: (2 * fib(k - 1) + fib(k)) * fib(k);
return f[n];
}
/** Main function */
int main() {
// Main Function
for (uint64_t i = 1; i < 93; i++) {
std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
}
return 0;
}

11
others/fibonacci_large.cpp → math/fibonacci_large.cpp
View File

@ -1,11 +1,14 @@
/** /**
* Computes N^th Fibonacci number given as * @file
* @brief Computes N^th Fibonacci number given as
* input argument. Uses custom build arbitrary integers library * input argument. Uses custom build arbitrary integers library
* to perform additions and other operations. * to perform additions and other operations.
* *
* Took 0.608246 seconds to compute 50,000^th Fibonacci * Took 0.608246 seconds to compute 50,000^th Fibonacci
* number that contains 10450 digits! * number that contains 10450 digits!
**/ *
* @see fibonacci.cpp, fibonacci_fast.cpp, string_fibonacci.cpp
*/
#include <cinttypes> #include <cinttypes>
#include <ctime> #include <ctime>
@ -13,6 +16,10 @@
#include "./large_number.h" #include "./large_number.h"
/** Compute fibonacci numbers using the relation
* \f[f(n)=f(n-1)+f(n-2)\f]
* and returns the result as a large_number type.
*/
large_number fib(uint64_t n) { large_number fib(uint64_t n) {
large_number f0(1); large_number f0(1);
large_number f1(1); large_number f1(1);

2
math/gcd_iterative_euclidean.cpp
View File

@ -4,7 +4,7 @@
* *iterative form* of * *iterative form* of
* [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm) * [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm)
* *
* @see gcd_recursive_euclidean.cpp * @see gcd_recursive_euclidean.cpp, gcd_of_n_numbers.cpp
*/ */
#include <iostream> #include <iostream>
#include <stdexcept> #include <stdexcept>

41
math/gcd_of_n_numbers.cpp Normal file
View File

@ -0,0 +1,41 @@
/**
* @file
* @brief This program aims at calculating the GCD of n numbers by division
* method
*
* @see gcd_iterative_euclidean.cpp, gcd_recursive_euclidean.cpp
*/
#include <iostream>
/** Compute GCD using division algorithm
*
* @param[in] a array of integers to compute GCD for
* @param[in] n number of integers in array `a`
*/
int gcd(int *a, int n) {
int j = 1; // to access all elements of the array starting from 1
int gcd = a[0];
while (j < n) {
if (a[j] % gcd == 0) // value of gcd is as needed so far
j++; // so we check for next element
else
gcd = a[j] % gcd; // calculating GCD by division method
}
return gcd;
}
/** Main function */
int main() {
int n;
std::cout << "Enter value of n:" << std::endl;
std::cin >> n;
int *a = new int[n];
int i;
std::cout << "Enter the n numbers:" << std::endl;
for (i = 0; i < n; i++) std::cin >> a[i];
std::cout << "GCD of entered n numbers:" << gcd(a, n) << std::endl;
delete[] a;
return 0;
}

14
math/gcd_recursive_euclidean.cpp
View File

@ -4,7 +4,7 @@
* *recursive form* of * *recursive form* of
* [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm) * [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm)
* *
* @see gcd_iterative_euclidean.cpp * @see gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp
*/ */
#include <iostream> #include <iostream>
@ -21,14 +21,18 @@ int gcd(int num1, int num2) {
} }
// Everything divides 0 // Everything divides 0
if (num1 == 0) return num2; if (num1 == 0)
if (num2 == 0) return num1; return num2;
if (num2 == 0)
return num1;
// base case // base case
if (num1 == num2) return num1; if (num1 == num2)
return num1;
// a is greater // a is greater
if (num1 > num2) return gcd(num1 - num2, num2); if (num1 > num2)
return gcd(num1 - num2, num2);
return gcd(num1, num2 - num1); return gcd(num1, num2 - num1);
} }

0
others/large_factorial.cpp → math/large_factorial.cpp
View File

0
others/large_number.h → math/large_number.h
View File

89
math/string_fibonacci.cpp Normal file
View File

@ -0,0 +1,89 @@
/**
* @file
* @brief This Programme returns the Nth fibonacci as a string.
*
* The method used is manual addition with carry and placing it in a string
* which is called string addition This makes it have no bounds or limits
*
* @see fibonacci_large.cpp, fibonacci_fast.cpp, fibonacci.cpp
*/
#include <iostream>
#ifdef _MSC_VER
#include <string> // use this for MS Visual C
#else
#include <cstring> // otherwise
#endif
/**
* function to add two string numbers
* \param [in] a first number in string to add
* \param [in] b second number in string to add
* \returns sum as a std::string
*/
std::string add(std::string a, std::string b) {
std::string temp = "";
// carry flag
int carry = 0;
// fills up with zeros
while (a.length() < b.length()) {
a = "0" + a;
}
// fills up with zeros
while (b.length() < a.length()) {
b = "0" + b;
}
// adds the numbers a and b
for (int i = a.length() - 1; i >= 0; i--) {
char val = static_cast<char>(((a[i] - 48) + (b[i] - 48)) + 48 + carry);
if (val > 57) {
carry = 1;
val -= 10;
} else {
carry = 0;
}
temp = val + temp;
}
// processes the carry flag
if (carry == 1) {
temp = "1" + temp;
}
// removes leading zeros.
while (temp[0] == '0' && temp.length() > 1) {
temp = temp.substr(1);
}
return temp;
}
/** Fibonacci iterator
* \param [in] n n^th Fibonacci number
*/
void fib_Accurate(uint64_t n) {
std::string tmp = "";
std::string fibMinus1 = "1";
std::string fibMinus2 = "0";
for (uint64_t i = 0; i < n; i++) {
tmp = add(fibMinus1, fibMinus2);
fibMinus2 = fibMinus1;
fibMinus1 = tmp;
}
std::cout << fibMinus2;
}
/** main function */
int main() {
int n;
std::cout << "Enter whatever number N you want to find the fibonacci of\n";
std::cin >> n;
std::cout << n << " th Fibonacci is \n";
fib_Accurate(n);
return 0;
}

33
others/buzz_number.cpp
View File

@ -1,17 +1,20 @@
//A buzz number is a number that is either divisble by 7 or has last digit as 7. /**
* @file
* @brief A buzz number is a number that is either divisible by 7 or has last
* digit as 7.
*/
#include <iostream> #include <iostream>
using namespace std;
int main() /** main function */
{ int main() {
int n, t; int n, t;
cin >> t; std::cin >> t;
while (t--) while (t--) {
{ std::cin >> n;
cin >> n; if ((n % 7 == 0) || (n % 10 == 7))
if ((n % 7 == 0) || (n % 10 == 7)) std::cout << n << " is a buzz number" << std::endl;
cout << n << " is a buzz number" << endl; else
else std::cout << n << " is not a buzz number" << std::endl;
cout << n << " is not a buzz number" << endl; }
} return 0;
return 0;
} }

72
others/decimal_to_binary.cpp
View File

@ -1,25 +1,55 @@
// This function convert decimal to binary number /**
// * @file
* @brief Function to convert decimal number to binary representation
*/
#include <iostream> #include <iostream>
using namespace std;
int main() /**
{ * This method converts the bit representation and stores it as a decimal
int number; * number.
cout << "Enter a number:"; */
cin >> number; void method1(int number) {
int remainder, binary = 0, var = 1; int remainder, binary = 0, var = 1;
do do {
{ remainder = number % 2;
remainder = number % 2; number = number / 2;
number = number / 2; binary = binary + (remainder * var);
binary = binary + (remainder * var); var = var * 10;
var = var * 10; } while (number > 0);
std::cout << "Method 1 : " << binary << std::endl;
} while (number > 0); }
cout << "the binary is :";
cout << binary; /**
cout << endl; * This method stores each bit value from LSB to MSB and then prints them back
return 0; * from MSB to LSB
*/
void method2(int number) {
int num_bits = 0;
char bit_string[50];
do {
bool bit = number & 0x01; // get last bit
if (bit)
bit_string[num_bits++] = '1';
else
bit_string[num_bits++] = '0';
number >>= 1; // right shift bit 1 bit
} while (number > 0);
std::cout << "Method 2 : ";
while (num_bits >= 0)
std::cout << bit_string[num_bits--]; // print from MSB to LSB
std::cout << std::endl;
}
int main() {
int number;
std::cout << "Enter a number:";
std::cin >> number;
method1(number);
method2(number);
return 0;
} }

48
others/decimal_to_hexadecimal.cpp
View File

@ -1,28 +1,34 @@
/**
* @file
* @brief Convert decimal number to hexadecimal representation
*/
#include <iostream> #include <iostream>
using namespace std; /**
* Main program
*/
int main(void) {
int valueToConvert = 0; // Holds user input
int hexArray[8]; // Contains hex values backwards
int i = 0; // counter
char HexValues[] = "0123456789ABCDEF";
int main(void) std::cout << "Enter a Decimal Value"
{ << std::endl; // Displays request to stdout
int valueToConvert = 0; //Holds user input std::cin >>
int hexArray[8]; //Contains hex values backwards valueToConvert; // Stores value into valueToConvert via user input
int i = 0; //counter
char HexValues[] = "0123456789ABCDEF";
cout << "Enter a Decimal Value" << endl; //Displays request to stdout while (valueToConvert > 15) { // Dec to Hex Algorithm
cin >> valueToConvert; //Stores value into valueToConvert via user input hexArray[i++] = valueToConvert % 16; // Gets remainder
valueToConvert /= 16;
// valueToConvert >>= 4; // This will divide by 2^4=16 and is faster
}
hexArray[i] = valueToConvert; // Gets last value
while (valueToConvert > 15) std::cout << "Hex Value: ";
{ //Dec to Hex Algorithm while (i >= 0) std::cout << HexValues[hexArray[i--]];
hexArray[i++] = valueToConvert % 16; //Gets remainder
valueToConvert /= 16;
}
hexArray[i] = valueToConvert; //Gets last value
cout << "Hex Value: "; std::cout << std::endl;
while (i >= 0) return 0;
cout << HexValues[hexArray[i--]];
cout << endl;
return 0;
} }

131
others/decimal_to_roman_numeral.cpp
View File

@ -1,97 +1,76 @@
//This Programme Converts a given decimal number in the range [0,4000) /**
//to both Lower case and Upper case Roman Numeral * @file
* @brief This Programme Converts a given decimal number in the range [0,4000)
* to both Lower case and Upper case Roman Numeral
*/
#include <cmath> #include <cmath>
#include <cstdio> #include <cstdio>
#include <string> #include <cstring>
#include <iostream> #include <iostream>
using namespace std;
//This functions fills a string with character c, n times and returns it /** This functions fills a string with character c, n times and returns it
string fill(char c, int n) * @note This can probably be replace by `memcpy` function.
{ */
string s = ""; std::string fill(char c, int n) {
while (n--) std::string s = "";
s += c; while (n--) s += c;
return s; return s;
} }
//to convert to lowercase Roman Numeral /** to convert to lowercase Roman Numeral
// the function works recursively * the function works recursively
string tolowerRoman(int n) */
{ std::string tolowerRoman(int n) {
if (n < 4) if (n < 4) return fill('i', n);
return fill('i', n); if (n < 6) return fill('i', 5 - n) + "v";
if (n < 6) if (n < 9) return std::string("v") + fill('i', n - 5);
return fill('i', 5 - n) + "v"; if (n < 11) return fill('i', 10 - n) + "x";
if (n < 9) if (n < 40) return fill('x', n / 10) + tolowerRoman(n % 10);
return string("v") + fill('i', n - 5); if (n < 60) return fill('x', 5 - n / 10) + 'l' + tolowerRoman(n % 10);
if (n < 11)
return fill('i', 10 - n) + "x";
if (n < 40)
return fill('x', n / 10) + tolowerRoman(n % 10);
if (n < 60)
return fill('x', 5 - n / 10) + 'l' + tolowerRoman(n % 10);
if (n < 90) if (n < 90)
return string("l") + fill('x', n / 10 - 5) + tolowerRoman(n % 10); return std::string("l") + fill('x', n / 10 - 5) + tolowerRoman(n % 10);
if (n < 110) if (n < 110) return fill('x', 10 - n / 10) + "c" + tolowerRoman(n % 10);
return fill('x', 10 - n / 10) + "c" + tolowerRoman(n % 10); if (n < 400) return fill('c', n / 100) + tolowerRoman(n % 100);
if (n < 400) if (n < 600) return fill('c', 5 - n / 100) + 'd' + tolowerRoman(n % 100);
return fill('c', n / 100) + tolowerRoman(n % 100);
if (n < 600)
return fill('c', 5 - n / 100) + 'd' + tolowerRoman(n % 100);
if (n < 900) if (n < 900)
return string("d") + fill('c', n / 100 - 5) + tolowerRoman(n % 100); return std::string("d") + fill('c', n / 100 - 5) +
if (n < 1100) tolowerRoman(n % 100);
return fill('c', 10 - n / 100) + "m" + tolowerRoman(n % 100); if (n < 1100) return fill('c', 10 - n / 100) + "m" + tolowerRoman(n % 100);
if (n < 4000) if (n < 4000) return fill('m', n / 1000) + tolowerRoman(n % 1000);
return fill('m', n / 1000) + tolowerRoman(n % 1000);
return "?"; return "?";
} }
//to convert to uppercase Roman Numeral /** to convert to uppercase Roman Numeral
// the function works recursively * the function works recursively
string toupperRoman(int n) */
{ std::string toupperRoman(int n) {
if (n < 4) if (n < 4) return fill('I', n);
return fill('I', n); if (n < 6) return fill('I', 5 - n) + "V";
if (n < 6) if (n < 9) return std::string("V") + fill('I', n - 5);
return fill('I', 5 - n) + "V"; if (n < 11) return fill('I', 10 - n) + "X";
if (n < 9) if (n < 40) return fill('X', n / 10) + toupperRoman(n % 10);
return string("V") + fill('I', n - 5); if (n < 60) return fill('X', 5 - n / 10) + 'L' + toupperRoman(n % 10);
if (n < 11)
return fill('I', 10 - n) + "X";
if (n < 40)
return fill('X', n / 10) + toupperRoman(n % 10);
if (n < 60)
return fill('X', 5 - n / 10) + 'L' + toupperRoman(n % 10);
if (n < 90) if (n < 90)
return string("L") + fill('X', n / 10 - 5) + toupperRoman(n % 10); return std::string("L") + fill('X', n / 10 - 5) + toupperRoman(n % 10);
if (n < 110) if (n < 110) return fill('X', 10 - n / 10) + "C" + toupperRoman(n % 10);
return fill('X', 10 - n / 10) + "C" + toupperRoman(n % 10); if (n < 400) return fill('C', n / 100) + toupperRoman(n % 100);
if (n < 400) if (n < 600) return fill('C', 5 - n / 100) + 'D' + toupperRoman(n % 100);
return fill('C', n / 100) + toupperRoman(n % 100);
if (n < 600)
return fill('C', 5 - n / 100) + 'D' + toupperRoman(n % 100);
if (n < 900) if (n < 900)
return string("D") + fill('C', n / 100 - 5) + toupperRoman(n % 100); return std::string("D") + fill('C', n / 100 - 5) +
if (n < 1100) toupperRoman(n % 100);
return fill('C', 10 - n / 100) + "M" + toupperRoman(n % 100); if (n < 1100) return fill('C', 10 - n / 100) + "M" + toupperRoman(n % 100);
if (n < 4000) if (n < 4000) return fill('M', n / 1000) + toupperRoman(n % 1000);
return fill('M', n / 1000) + toupperRoman(n % 1000);
return "?"; return "?";
} }
//main function /** main function */
int main() {
int main()
{
int n; int n;
cout << "\t\tRoman numbers converter\n\n"; std::cout << "\t\tRoman numbers converter\n\n";
cout << "Type in decimal number between 0 up to 4000 (exclusive): "; std::cout << "Type in decimal number between 0 up to 4000 (exclusive): ";
cin >> n; std::cin >> n;
cout << n << " in Upper Roman Numerals is " << toupperRoman(n) << "\n"; std::cout << n << " in Upper Roman Numerals is " << toupperRoman(n) << "\n";
cout << n << " in Lower Roman Numerals is " << tolowerRoman(n) << "\n"; std::cout << n << " in Lower Roman Numerals is " << tolowerRoman(n) << "\n";
return 0; return 0;
} }

23
others/fast_interger_input.cpp
View File

@ -1,7 +1,15 @@
// Read integers in the fastest way in c plus plus /**
#include<iostream> * @file
* @brief Read integers from stdin continuously as they are entered without
* waiting for the `\n` character
*/
#include <iostream>
/** Function to read the number from stdin. The function reads input until a non
* numeric character is entered.
*/
void fastinput(int *number) { void fastinput(int *number) {
// variable to indicate sign of input integer // variable to indicate sign of input integer
bool negative = false; bool negative = false;
register int c; register int c;
*number = 0; *number = 0;
@ -19,18 +27,17 @@ void fastinput(int *number) {
// Keep on extracting characters if they are integers // Keep on extracting characters if they are integers
// i.e ASCII Value lies from '0'(48) to '9' (57) // i.e ASCII Value lies from '0'(48) to '9' (57)
for (; (c > 47 && c < 58); c = std::getchar()) for (; (c > 47 && c < 58); c = std::getchar())
*number = *number *10 + c - 48; *number = *number * 10 + c - 48;
// if scanned input has a negative sign, negate the // if scanned input has a negative sign, negate the
// value of the input number // value of the input number
if (negative) if (negative) *(number) *= -1;
*(number) *= -1;
} }
// Function Call /** Main function */
int main() { int main() {
int number; int number;
fastinput(&number); fastinput(&number);
std::cout << number << "\n"; std::cout << number << std::endl;
return 0; return 0;
} }

37
others/fibonacci_fast.cpp
View File

@ -1,37 +0,0 @@
// An efficient way to calculate nth fibonacci number faster and simpler than
// O(nlogn) method of matrix exponentiation This works by using both recursion
// and dynamic programming. as 93rd fibonacci exceeds 19 digits, which cannot be
// stored in a single long long variable, we can only use it till 92nd fibonacci
// we can use it for 10000th fibonacci etc, if we implement bigintegers.
// This algorithm works with the fact that nth fibonacci can easily found if we
// have already found n/2th or (n+1)/2th fibonacci It is a property of fibonacci
// similar to matrix exponentiation.
#include <cinttypes>
#include <cstdio>
#include <iostream>
const uint64_t MAX = 93;
uint64_t f[MAX] = {0};
uint64_t fib(uint64_t n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return (f[n] = 1);
if (f[n]) return f[n];
uint64_t k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
f[n] = (n % 2 != 0) ? (fib(k) * fib(k) + fib(k - 1) * fib(k - 1))
: (2 * fib(k - 1) + fib(k)) * fib(k);
return f[n];
}
int main() {
// Main Function
for (uint64_t i = 1; i < 93; i++) {
std::cout << i << " th fibonacci number is " << fib(i) << "\n";
}
return 0;
}

23
others/gcd_of_n_numbers.cpp
View File

@ -1,23 +0,0 @@
// This program aims at calculating the GCD of n numbers by division method
#include <iostream>
int main() {
int n;
std::cout << "Enter value of n:" << std::endl;
std::cin >> n;
int *a = new int[n];
int i, j, gcd;
std::cout << "Enter the n numbers:" << std::endl;
for (i = 0; i < n; i++) std::cin >> a[i];
j = 1; // to access all elements of the array starting from 1
gcd = a[0];
while (j < n) {
if (a[j] % gcd == 0) // value of gcd is as needed so far
j++; // so we check for next element
else
gcd = a[j] % gcd; // calculating GCD by division method
}
std::cout << "GCD of entered n numbers:" << gcd;
delete[] a;
return 0;
}

57
others/happy_number.cpp
View File

@ -1,28 +1,39 @@
/* A happy number is a number whose sum of digits is calculated until the sum is a single digit, /**
and this sum turns out to be 1 */ * A [happy number](https://en.wikipedia.org/wiki/Happy_number) is a decimal
* number whose sum of digits is calculated until the sum is a single digit, and
// Copyright 2019 TheAlgorithms contributors * this sum turns out to be 1.
*/
#include <iostream> #include <iostream>
int main() { /**
int n, k, s = 0, d; * Checks if a decimal number is a happy number
std::cout << "Enter a number:"; * \returns true if happy else false
std::cin >> n; */
s = 0; template <typename T>
k = n; bool is_happy(T n) {
while (k > 9) { T s = 0; // stores sum of digits
while (k != 0) { while (n > 9) { // while number is > 9, there are more than 1 digit
d = k % 10; while (n != 0) { // get digit
s += d; T d = n % 10;
k /= 10; s += d;
n /= 10;
}
n = s;
s = 0;
} }
k = s; return (n == 1) ? true : false; // true if k == 1
s = 0; }
}
if (k == 1) /** Main function */
std::cout << n << " is a happy number" << std::endl; int main() {
else int n;
std::cout << n << " is not a happy number" << std::endl; std::cout << "Enter a number:";
return 0; std::cin >> n;
if (is_happy(n))
std::cout << n << " is a happy number" << std::endl;
else
std::cout << n << " is not a happy number" << std::endl;
return 0;
} }

80
others/matrix_exponentiation.cpp
View File

@ -1,20 +1,24 @@
/* /**
Matrix Exponentiation. @file
@brief Matrix Exponentiation.
The problem can be solved with DP but constraints are high. The problem can be solved with DP but constraints are high.
ai = bi (for i <= k) <br/>\f$a_i = b_i\f$ (for \f$i <= k\f$)
ai = c1*ai-1 + c2*ai-2 + ... + ck*ai-k (for i > k) <br/>\f$a_i = c_1 a_{i-1} + c_2 a_{i-2} + ... + c_k a_{i-k}\f$ (for \f$i > k\f$)
Taking the example of Fibonacci series, K=2 <br/>Taking the example of Fibonacci series, \f$k=2\f$
b1 = 1, b2=1 <br/>\f$b_1 = 1,\; b_2=1\f$
c1 = 1, c2=1 <br/>\f$c_1 = 1,\; c_2=1\f$
a = 0 1 1 2 .... <br/>\f$a = \begin{bmatrix}0& 1& 1& 2& \ldots\end{bmatrix}\f$
This way you can find the 10^18 fibonacci number%MOD. <br/>This way you can find the \f$10^{18}\f$ fibonacci number%MOD.
I have given a general way to use it. The program takes the input of B and C I have given a general way to use it. The program takes the input of B and C
matrix. matrix.
Steps for Matrix Expo Steps for Matrix Expo
1. Create vector F1 : which is the copy of B. 1. Create vector F1 : which is the copy of B.
2. Create transpose matrix (Learn more about it on the internet) 2. Create transpose matrix (Learn more about it on the internet)
3. Perform T^(n-1) [transpose matrix to the power n-1] 3. Perform \f$T^{n-1}\f$ [transpose matrix to the power n-1]
4. Multiply with F to get the last matrix of size (1xk). 4. Multiply with F to get the last matrix of size (1\f$\times\f$k).
The first element of this matrix is the required result. The first element of this matrix is the required result.
*/ */
@ -25,16 +29,36 @@ using std::cin;
using std::cout; using std::cout;
using std::vector; using std::vector;
/*! shorthand definition for `int64_t` */
#define ll int64_t #define ll int64_t
#define endl '\n'
/*! shorthand definition for `std::endl` */
#define endl std::endl
/*! shorthand definition for `int64_t` */
#define pb push_back #define pb push_back
#define MOD 1000000007 #define MOD 1000000007
ll ab(ll x) { return x > 0LL ? x : -x; }
/** returns absolute value */
inline ll ab(ll x) { return x > 0LL ? x : -x; }
/** global variable k
* @todo @stepfencurryxiao add documetnation
*/
ll k; ll k;
/** global vector variables
* @todo @stepfencurryxiao add documetnation
*/
vector<ll> a, b, c; vector<ll> a, b, c;
// To multiply 2 matrix /** To multiply 2 matrices
vector<vector<ll>> multiply(vector<vector<ll>> A, vector<vector<ll>> B) { * \param [in] A matrix 1 of size (m\f$\times\f$n)
* \param [in] B \p matrix 2 of size (p\f$\times\f$q)\n\note \f$p=n\f$
* \result matrix of dimension (m\f$\times\f$q)
*/
vector<vector<ll>> multiply(const vector<vector<ll>> &A,
const vector<vector<ll>> &B) {
vector<vector<ll>> C(k + 1, vector<ll>(k + 1)); vector<vector<ll>> C(k + 1, vector<ll>(k + 1));
for (ll i = 1; i <= k; i++) { for (ll i = 1; i <= k; i++) {
for (ll j = 1; j <= k; j++) { for (ll j = 1; j <= k; j++) {
@ -46,9 +70,15 @@ vector<vector<ll>> multiply(vector<vector<ll>> A, vector<vector<ll>> B) {
return C; return C;
} }
// computing power of a matrix /** computing integer power of a matrix using recursive multiplication.
vector<vector<ll>> power(vector<vector<ll>> A, ll p) { * @note A must be a square matrix for this algorithm.
if (p == 1) return A; * \param [in] A base matrix
* \param [in] p exponent
* \return matrix of same dimension as A
*/
vector<vector<ll>> power(const vector<vector<ll>> &A, ll p) {
if (p == 1)
return A;
if (p % 2 == 1) { if (p % 2 == 1) {
return multiply(A, power(A, p - 1)); return multiply(A, power(A, p - 1));
} else { } else {
@ -57,10 +87,15 @@ vector<vector<ll>> power(vector<vector<ll>> A, ll p) {
} }
} }
// main function /*! Wrapper for Fibonacci
* \param[in] n \f$n^\text{th}\f$ Fibonacci number
* \return \f$n^\text{th}\f$ Fibonacci number
*/
ll ans(ll n) { ll ans(ll n) {
if (n == 0) return 0; if (n == 0)
if (n <= k) return b[n - 1]; return 0;
if (n <= k)
return b[n - 1];
// F1 // F1
vector<ll> F1(k + 1); vector<ll> F1(k + 1);
for (ll i = 1; i <= k; i++) F1[i] = b[i - 1]; for (ll i = 1; i <= k; i++) F1[i] = b[i - 1];
@ -90,8 +125,7 @@ ll ans(ll n) {
return res; return res;
} }
// 1 1 2 3 5 /** Main function */
int main() { int main() {
cin.tie(0); cin.tie(0);
cout.tie(0); cout.tie(0);

14
others/palindrome_of_number.cpp
View File

@ -1,3 +1,10 @@
/**
* @file
* @brief Check if a number is
* [palindrome](https://en.wikipedia.org/wiki/Palindrome) or not.
*
* This program cheats by using the STL library's std::reverse function.
*/
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
@ -8,17 +15,18 @@
#include <cstring> #include <cstring>
#endif #endif
/** Main function */
int main() { int main() {
int num; int num;
std::cout << "Enter number = "; std::cout << "Enter number = ";
std::cin >> num; std::cin >> num;
std::string s1 = std::to_string(num); std::string s1 = std::to_string(num); // convert number to string
std::string s2 = s1; std::string s2 = s1;
reverse(s1.begin(), s1.end()); std::reverse(s1.begin(), s1.end()); // reverse the string
if (s1 == s2) if (s1 == s2) // check if reverse and original string are identical
std::cout << "true"; std::cout << "true";
else else
std::cout << "false"; std::cout << "false";

131
others/paranthesis_matching.cpp
View File

@ -1,76 +1,75 @@
/**
* @file
* @brief Perform paranthesis matching. \note Do not know the application of
* this, however.
* @note Implementation is C-type and does not utilize the C++ constructs
* @todo implement as a C++ class
*/
#include <iostream> #include <iostream>
#include <string> #ifdef _MSC_VER
#include <string> // Visual Studio C requires this include
using namespace std; #else
#include <cstring>
#endif
/** check number */
#define MAX 100 #define MAX 100
// -------------- stack -------------- //! @{-------------- stack --------------
//! global stack
char stack[MAX]; char stack[MAX];
//! pointer to track stack index
int top = -1; int top = -1;
void push(char ch) //! push byte to stack variable
{ void push(char ch) { stack[++top] = ch; }
stack[++top] = ch;
//! pop a byte out of stack variable
char pop() { return stack[top--]; }
//! @}-------------- end stack -----------
/** return opening paranthesis corresponding to the close paranthesis
* @param[in] ch closed paranthesis character
*/
char opening(char ch) {
switch (ch) {
case '}':
return '{';
case ']':
return '[';
case ')':
return '(';
case '>':
return '<';
}
return '\0';
} }
char pop() int main() {
{ std::string exp;
return stack[top--]; int valid = 1, i = 0;
} std::cout << "Enter The Expression : ";
std::cin >> exp;
// -------------- end stack -----------
while (valid == 1 && i < exp.length()) {
char opening(char ch) if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<') {
{ push(exp[i]);
switch (ch) } else if (top >= 0 && stack[top] == opening(exp[i])) {
{ pop();
case '}': } else {
return '{'; valid = 0;
case ']': }
return '['; i++;
case ')': }
return '(';
case '>': // makes sure the stack is empty after processsing (above)
return '<'; if (valid == 1 && top == -1) {
} std::cout << "\nCorrect Expression";
} } else {
std::cout << "\nWrong Expression";
int main() }
{
return 0;
string exp;
int valid = 1, i = 0;
cout << "Enter The Expression : ";
cin >> exp;
while (valid == 1 && i < exp.length())
{
if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<')
{
push(exp[i]);
}
else if (top >= 0 && stack[top] == opening(exp[i]))
{
pop();
}
else
{
valid = 0;
}
i++;
}
// makes sure the stack is empty after processsing (above)
if (valid == 1 && top == -1)
{
cout << "\nCorrect Expression";
}
else
{
cout << "\nWrong Expression";
}
return 0;
} }

28
others/pascal_triangle.cpp
View File

@ -1,19 +1,38 @@
/**
* @file
* @brief Pascal's triangle implementation
*/
#ifdef _MSC_VER
#include <string> // required for Visual C
#else
#include <cstring> #include <cstring>
#endif
#include <iomanip>
#include <iostream> #include <iostream>
/**
* Print the triangle
* \param [in] arr 2D-array containing Pascal numbers
* \param [in] n depth of Pascal triangle to print
*/
void show_pascal(int **arr, int n) { void show_pascal(int **arr, int n) {
// pint Pascal's Triangle
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
for (int j = 0; j < n + i; ++j) { for (int j = 0; j < n + i; ++j) {
if (arr[i][j] == 0) if (arr[i][j] == 0)
std::cout << " "; std::cout << std::setw(4) << " ";
else else
std::cout << arr[i][j]; std::cout << std::setw(4) << arr[i][j];
} }
std::cout << std::endl; std::cout << std::endl;
} }
} }
/**
* Print the triangle
* \param [in,out] arr array containing Pascal numbers
* \param [in] n depth of Pascal triangle to print
* \result arr pointer returned
*/
int **pascal_triangle(int **arr, int n) { int **pascal_triangle(int **arr, int n) {
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
for (int j = n - i - 1; j < n + i; ++j) { for (int j = n - i - 1; j < n + i; ++j) {
@ -27,6 +46,9 @@ int **pascal_triangle(int **arr, int n) {
return arr; return arr;
} }
/**
* main function
*/
int main() { int main() {
int n = 0; int n = 0;

60
others/primality_test.cpp
View File

@ -1,32 +1,42 @@
/**
* @file
* @brief [Primality test](https://en.wikipedia.org/wiki/Primality_test)
* implementation.
*
* A simple and efficient implementation of a function to test if a number is
* prime, based on the fact that
* > Every Prime number, except 2 and 3, are of the form \f$6k\pm1\f$ for
* > integer values of k.
* This gives a 3x speed improvement.
*/
#include <iostream> #include <iostream>
using namespace std;
//A simple and efficient implementation of a function to test if a number is prime, based on the fact that /** Check if a number is prime
//Every Prime number, except 2 and 3 are of the form 6*k+1 or 6*k-1 for integer values of k. * \param[in] number number to check
* \returns true if prime else false
*/
bool IsPrime(int number) {
if (((!(number & 1)) && number != 2) || (number < 2) ||
(number % 3 == 0 && number != 3))
return false;
bool IsPrime(int number) for (int k = 1; 36 * k * k - 12 * k < number; ++k) {
{ if ((number % (6 * k + 1) == 0) || (number % (6 * k - 1) == 0))
if (((!(number & 1)) && number != 2) || (number < 2) || (number % 3 == 0 && number != 3)) return false;
return false; }
return true;
for (int k = 1; 36 * k * k - 12 * k < number; ++k)
{
if ((number % (6 * k + 1) == 0) || (number % (6 * k - 1) == 0))
return false;
}
return true;
} }
int main() /** main function */
{ int main() {
//Main Function // Main Function
cout << "Enter the value of n to check if Prime\n"; std::cout << "Enter the value of n to check if Prime\n";
int n; int n;
cin >> n; std::cin >> n;
if (IsPrime(n)) if (IsPrime(n))
cout << n << " is Prime" << endl; std::cout << n << " is Prime" << std::endl;
else else
cout << n << " is not Prime" << endl; std::cout << n << " is not Prime" << std::endl;
return 0; return 0;
} }

60
others/sieve_of_Eratosthenes.cpp
View File

@ -1,60 +0,0 @@
/*
* Sieve of Eratosthenes is an algorithm to find the primes
* that is between 2 to N (as defined in main).
*
* Time Complexity : O(N)
* Space Complexity : O(N)
*/
#include <iostream>
using namespace std;
#define MAX 10000000
int primes[MAX];
/*
* This is the function that finds the primes and eliminates
* the multiples.
*/
void sieve(int N)
{
primes[0] = 1;
primes[1] = 1;
for (int i = 2; i <= N; i++)
{
if (primes[i] == 1)
continue;
for (int j = i + i; j <= N; j += i)
primes[j] = 1;
}
}
/*
* This function prints out the primes to STDOUT
*/
void print(int N)
{
for (int i = 0; i <= N; i++)
if (primes[i] == 0)
cout << i << ' ';
cout << '\n';
}
/*
* NOTE: This function is important for the
* initialization of the array.
*/
void init()
{
for (int i = 0; i < MAX; i++)
primes[i] = 0;
}
int main()
{
int N = 100;
init();
sieve(N);
print(N);
}

121
others/smallest-circle.cpp
View File

@ -1,121 +0,0 @@
#include <iostream>
#include <vector>
#include <math.h>
using namespace std;
struct Point
{
double x, y;
Point(double a = 0.0, double b = 0.0)
{
x = a;
y = b;
}
};
double LenghtLine(Point A, Point B)
{
return sqrt(abs((B.x - A.x) * (B.x - A.x)) + abs((B.y - A.y) * (B.y - A.y)));
}
double TriangleArea(Point A, Point B, Point C)
{
double a = LenghtLine(A, B);
double b = LenghtLine(B, C);
double c = LenghtLine(C, A);
double p = (a + b + c) / 2;
return sqrt(p * (p - a) * (p - b) * (p - c));
}
bool PointInCircle(vector<Point> &P, Point Center, double R)
{
for (size_t i = 0; i < P.size(); i++)
{
if (LenghtLine(P[i], Center) > R)
return false;
}
return true;
}
double circle(vector<Point> P)
{
double minR = INT8_MAX;
double R;
Point C;
Point minC;
for (size_t i = 0; i < P.size() - 2; i++)
for (size_t j = i + 1; j < P.size(); j++)
for (size_t k = j + 1; k < P.size(); k++)
{
C.x = -0.5 * ((P[i].y * (P[j].x * P[j].x + P[j].y * P[j].y - P[k].x * P[k].x - P[k].y * P[k].y) + P[j].y * (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y * P[i].y) + P[k].y * (P[i].x * P[i].x + P[i].y * P[i].y - P[j].x * P[j].x - P[j].y * P[j].y)) / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y - P[i].y) + P[k].x * (P[i].y - P[j].y)));
C.y = 0.5 * ((P[i].x * (P[j].x * P[j].x + P[j].y * P[j].y - P[k].x * P[k].x - P[k].y * P[k].y) + P[j].x * (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y * P[i].y) + P[k].x * (P[i].x * P[i].x + P[i].y * P[i].y - P[j].x * P[j].x - P[j].y * P[j].y)) / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y - P[i].y) + P[k].x * (P[i].y - P[j].y)));
R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k]) * LenghtLine(P[k], P[i])) / (4 * TriangleArea(P[i], P[j], P[k]));
if (!PointInCircle(P, C, R))
{
continue;
}
if (R <= minR)
{
minR = R;
minC = C;
}
}
for (size_t i = 0; i < P.size() - 1; i++)
for (size_t j = i + 1; j < P.size(); j++)
{
C.x = (P[i].x + P[j].x) / 2;
C.y = (P[i].y + P[j].y) / 2;
R = LenghtLine(C, P[i]);
if (!PointInCircle(P, C, R))
{
continue;
}
if (R <= minR)
{
minR = R;
minC = C;
}
}
cout << minC.x << " " << minC.y << endl;
return minR;
}
void test()
{
vector<Point> Pv(5);
Pv.push_back(Point(0, 0));
Pv.push_back(Point(1, 3));
Pv.push_back(Point(4, 1));
Pv.push_back(Point(5, 4));
Pv.push_back(Point(3, -2));
cout << circle(Pv) << endl;
}
void test2()
{
vector<Point> Pv(4);
Pv.push_back(Point(0, 0));
Pv.push_back(Point(0, 2));
Pv.push_back(Point(2, 2));
Pv.push_back(Point(2, 0));
cout << circle(Pv) << endl;
}
void test3()
{
vector<Point> Pv(3);
Pv.push_back(Point(0.5, 1));
Pv.push_back(Point(3.5, 3));
Pv.push_back(Point(2.5, 0));
cout << circle(Pv) << endl;
}
int main()
{
test();
cout << endl;
test2();
cout << endl;
test3();
return 0;
}

205
others/smallest_circle.cpp Normal file
View File

@ -0,0 +1,205 @@
/**
* @file
* @brief Get centre and radius of the
* [smallest circle](https://en.wikipedia.org/wiki/Smallest-circle_problem)
* that circumscribes given set of points.
*
* @see [other
* implementation](https://www.nayuki.io/page/smallest-enclosing-circle)
*/
#include <cmath>
#include <iostream>
#include <vector>
/** Define a point */
struct Point {
double x, /**< abscissa */
y; /**< ordinate */
/** construct a point
* \param [in] a absicca (default = 0.0)
* \param [in] b ordinate (default = 0.0)
*/
explicit Point(double a = 0.f, double b = 0.f) {
x = a;
y = b;
}
};
/** Compute the Euclidian distance between two points \f$A\equiv(x_1,y_1)\f$ and
* \f$B\equiv(x_2,y_2)\f$ using the formula:
* \f[d=\sqrt{\left(x_1-x_2\right)^2+\left(y_1-y_2\right)^2}\f]
*
* \param [in] A point A
* \param [in] B point B
* \return ditance
*/
double LenghtLine(const Point &A, const Point &B) {
double dx = B.x - A.x;
double dy = B.y - A.y;
return std::sqrt((dx * dx) + (dy * dy));
}
/**
* Compute the area of triangle formed by three points using [Heron's
* formula](https://en.wikipedia.org/wiki/Heron%27s_formula).
* If the lengths of the sides of the triangle are \f$a,\,b,\,c\f$ and
* \f$s=\displaystyle\frac{a+b+c}{2}\f$ is the semi-perimeter then the area is
* given by \f[A=\sqrt{s(s-a)(s-b)(s-c)}\f]
* \param [in] A vertex A
* \param [in] B vertex B
* \param [in] C vertex C
* \returns area of triangle
*/
double TriangleArea(const Point &A, const Point &B, const Point &C) {
double a = LenghtLine(A, B);
double b = LenghtLine(B, C);
double c = LenghtLine(C, A);
double p = (a + b + c) / 2;
return std::sqrt(p * (p - a) * (p - b) * (p - c));
}
/**
* Check if a set of points lie within given circle. This is true if the
* distance of all the points from the centre of the circle is less than the
* radius of the circle
* \param [in] P set of points to check
* \param [in] Center coordinates to centre of the circle
* \param [in] R radius of the circle
* \returns True if P lies on or within the circle
* \returns False if P lies outside the circle
*/
bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R) {
for (size_t i = 0; i < P.size(); i++) {
if (LenghtLine(P[i], Center) > R)
return false;
}
return true;
}
/**
* Find the centre and radius of a circle enclosing a set of points.\n
* The function returns the radius of the circle and prints the coordinated of
* the centre of the circle.
* \param [in] P vector of points
* \returns radius of the circle
*/
double circle(const std::vector<Point> &P) {
double minR = INFINITY;
double R;
Point C;
Point minC;
/* This code is invalid and does not give correct result for TEST 3 */
// for each point in the list
for (size_t i = 0; i < P.size() - 2; i++)
// for every subsequent point in the list
for (size_t j = i + 1; j < P.size(); j++)
// for every subsequent point in the list
for (size_t k = j + 1; k < P.size(); k++) {
// here, we now have picked three points from the given set of
// points that we can use
// viz., P[i], P[j] and P[k]
C.x = -0.5 * ((P[i].y * (P[j].x * P[j].x + P[j].y * P[j].y -
P[k].x * P[k].x - P[k].y * P[k].y) +
P[j].y * (P[k].x * P[k].x + P[k].y * P[k].y -
P[i].x * P[i].x - P[i].y * P[i].y) +
P[k].y * (P[i].x * P[i].x + P[i].y * P[i].y -
P[j].x * P[j].x - P[j].y * P[j].y)) /
(P[i].x * (P[j].y - P[k].y) +
P[j].x * (P[k].y - P[i].y) +
P[k].x * (P[i].y - P[j].y)));
C.y = 0.5 * ((P[i].x * (P[j].x * P[j].x + P[j].y * P[j].y -
P[k].x * P[k].x - P[k].y * P[k].y) +
P[j].x * (P[k].x * P[k].x + P[k].y * P[k].y -
P[i].x * P[i].x - P[i].y * P[i].y) +
P[k].x * (P[i].x * P[i].x + P[i].y * P[i].y -
P[j].x * P[j].x - P[j].y * P[j].y)) /
(P[i].x * (P[j].y - P[k].y) +
P[j].x * (P[k].y - P[i].y) +
P[k].x * (P[i].y - P[j].y)));
R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k]) *
LenghtLine(P[k], P[i])) /
(4 * TriangleArea(P[i], P[j], P[k]));
if (!PointInCircle(P, C, R)) {
continue;
}
if (R <= minR) {
minR = R;
minC = C;
}
}
// for each point in the list
for (size_t i = 0; i < P.size() - 1; i++)
// for every subsequent point in the list
for (size_t j = i + 1; j < P.size(); j++) {
// check for diameterically opposite points
C.x = (P[i].x + P[j].x) / 2;
C.y = (P[i].y + P[j].y) / 2;
R = LenghtLine(C, P[i]);
if (!PointInCircle(P, C, R)) {
continue;
}
if (R <= minR) {
minR = R;
minC = C;
}
}
std::cout << minC.x << " " << minC.y << std::endl;
return minR;
}
/** Test case: result should be:
* \n Circle with
* \n radius 3.318493136080724
* \n centre at (3.0454545454545454, 1.3181818181818181)
*/
void test() {
std::vector<Point> Pv;
Pv.push_back(Point(0, 0));
Pv.push_back(Point(5, 4));
Pv.push_back(Point(1, 3));
Pv.push_back(Point(4, 1));
Pv.push_back(Point(3, -2));
std::cout << circle(Pv) << std::endl;
}
/** Test case: result should be:
* \n Circle with
* \n radius 1.4142135623730951
* \n centre at (1.0, 1.0)
*/
void test2() {
std::vector<Point> Pv;
Pv.push_back(Point(0, 0));
Pv.push_back(Point(0, 2));
Pv.push_back(Point(2, 2));
Pv.push_back(Point(2, 0));
std::cout << circle(Pv) << std::endl;
}
/** Test case: result should be:
* \n Circle with
* \n radius 1.821078397711709
* \n centre at (2.142857142857143, 1.7857142857142856)
* @todo This test fails
*/
void test3() {
std::vector<Point> Pv;
Pv.push_back(Point(0.5, 1));
Pv.push_back(Point(3.5, 3));
Pv.push_back(Point(2.5, 0));
Pv.push_back(Point(2, 1.5));
std::cout << circle(Pv) << std::endl;
}
/** Main program */
int main() {
test();
std::cout << std::endl;
test2();
std::cout << std::endl;
test3();
return 0;
}

6
others/sparse_matrix.cpp
View File

@ -1,10 +1,11 @@
/** @file /** @file
* A sparse matrix is a matrix which has number of zeroes greater than * A sparse matrix is a matrix which has number of zeroes greater than
* \f$\frac{m*n}{2}\f$, where m and n are the dimensions of the matrix. * \f$\frac{m\times n}{2}\f$, where m and n are the dimensions of the matrix.
*/ */
#include <iostream> #include <iostream>
/** main function */
int main() { int main() {
int m, n; int m, n;
int counterZeros = 0; int counterZeros = 0;
@ -30,7 +31,8 @@ int main() {
// counts the zero's // counts the zero's
for (int i = 0; i < m; i++) { for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) { for (int j = 0; j < n; j++) {
if (a[i][j] == 0) counterZeros++; // Counting number of zeroes if (a[i][j] == 0)
counterZeros++; // Counting number of zeroes
} }
} }

83
others/spiral_print.cpp
View File

@ -1,78 +1,81 @@
/**
* @file
* @brief Print the elements of a matrix traversing it spirally
*/
#include <iostream> #include <iostream>
using namespace std;
void genArray(int a[][10], int r, int c)
{
/** Arrange sequence of numbers from '1' in a matrix form
* \param [out] a matrix to fill
* \param [in] r number of rows
* \param [in] c number of columns
*/
void genArray(int **a, int r, int c) {
int value = 1; int value = 1;
for (int i = 0; i < r; i++) for (int i = 0; i < r; i++) {
{ for (int j = 0; j < c; j++) {
for (int j = 0; j < c; j++)
{
a[i][j] = value; a[i][j] = value;
cout << a[i][j] << " "; std::cout << a[i][j] << " ";
value++; value++;
} }
cout << endl; std::cout << std::endl;
} }
} }
void spiralPrint(int a[][10], int r, int c)
{
/** Traverse the matrix spirally and print the sequence of elements
* \param [in] a matrix to read from
* \param [in] r number of rows
* \param [in] c number of columns
*/
void spiralPrint(int **a, int r, int c) {
int startRow = 0, endRow = r - 1; int startRow = 0, endRow = r - 1;
int startCol = 0, endCol = c - 1; int startCol = 0, endCol = c - 1;
int cnt = 0; int cnt = 0;
while (startRow <= endRow && startCol <= endCol) while (startRow <= endRow && startCol <= endCol) {
{ /// Print start row
for (int i = startCol; i <= endCol; i++, cnt++) {
///Print start row std::cout << a[startRow][i] << " ";
for (int i = startCol; i <= endCol; i++, cnt++)
{
cout << a[startRow][i] << " ";
} }
startRow++; startRow++;
///Print the end col /// Print the end col
for (int i = startRow; i <= endRow; i++, cnt++) for (int i = startRow; i <= endRow; i++, cnt++) {
{ std::cout << a[i][endCol] << " ";
cout << a[i][endCol] << " ";
} }
endCol--; endCol--;
///Print the end row /// Print the end row
if (cnt == r * c) if (cnt == r * c) {
{
break; break;
} }
for (int i = endCol; i >= startCol; i--, cnt++) for (int i = endCol; i >= startCol; i--, cnt++) {
{ std::cout << a[endRow][i] << " ";
cout << a[endRow][i] << " ";
} }
endRow--; endRow--;
///Print the start Col /// Print the start Col
if (cnt == r * c) if (cnt == r * c) {
{
break; break;
} }
for (int i = endRow; i >= startRow; i--, cnt++) for (int i = endRow; i >= startRow; i--, cnt++) {
{ std::cout << a[i][startCol] << " ";
cout << a[i][startCol] << " ";
} }
startCol++; startCol++;
} }
} }
int main() /** main function */
{ int main() {
int a[10][10];
int r, c; int r, c;
cin >> r >> c; std::cin >> r >> c;
int **a = new int *[r];
for (int i = 0; i < r; i++) a[i] = new int[c];
genArray(a, r, c); genArray(a, r, c);
spiralPrint(a, r, c); spiralPrint(a, r, c);
for (int i = 0; i < r; i++) delete[] a[i];
delete[] a;
return 0; return 0;
} }

60
others/stairs_pattern.cpp
View File

@ -1,31 +1,35 @@
/* /**
This program is use to print the following pattern * @file
** @brief This program is use to print the following pattern<pre>
** \*\*
**** \*\*
**** \*\*\*\*
****** \*\*\*\*
****** \*\*\*\*\*\*
******** \*\*\*\*\*\*
******** \*\*\*\*\*\*\*\*
where number of pairs line is given by user ********</pre>
where number of pairs line is given by user
*/ */
#include<iostream> #include <iostream>
/** main function */
int main() { int main() {
int l, st = 2, x, r, z, n, sp; int l, st = 2, x, r, z, n, sp;
std::cout << "enter Index "; std::cout << "enter Index ";
std::cin >> x; std::cin >> x;
z = x; z = x;
for (r = 1; r <= x; r++) { for (r = 1; r <= x; r++) {
z = z - 1; z = z - 1;
for (n = 1; n <= 2; n++) { for (n = 1; n <= 2; n++) {
for (sp = 1; sp <= z; sp++) { for (sp = 1; sp <= z; sp++) {
std::cout << " "; std::cout << " ";
}
for (l = 1; l <= st; l++) {
std::cout << "*";
}
std::cout << std::endl;
}
st = st + 2;
}
} }
for (l = 1; l <= st; l++) {
std::cout << "*";
}
std::cout <<"\n";
}
st = st + 2;
}}

83
others/string_fibonacci.cpp
View File

@ -1,83 +0,0 @@
//This Programme returns the Nth fibonacci as a string.
//The method used is manual addition with carry and placing it in a string which is called string addition
//This makes it have no bounds or limits
#include <iostream>
#include <string>
using namespace std;
string add(string a, string b)
{
string temp = "";
// carry flag
int carry = 0;
// fills up with zeros
while ((int)a.length() < (int)b.length())
{
a = "0" + a;
}
// fills up with zeros
while ((int)b.length() < (int)a.length())
{
b = "0" + b;
}
// adds the numbers a and b
for (int i = a.length() - 1; i >= 0; i--)
{
char val = (char)(((a[i] - 48) + (b[i] - 48)) + 48 + carry);
if (val > 57)
{
carry = 1;
val -= 10;
}
else
{
carry = 0;
}
temp = val + temp;
}
// processes the carry flag
if (carry == 1)
{
temp = "1" + temp;
}
// removes leading zeros.
while (temp[0] == '0' && temp.length() > 1)
{
temp = temp.substr(1);
}
return temp;
}
void fib_Accurate(long long n)
{
string tmp = "";
string fibMinus1 = "1";
string fibMinus2 = "0";
for (long long i = 0; i < n; i++)
{
tmp = add(fibMinus1, fibMinus2);
fibMinus2 = fibMinus1;
fibMinus1 = tmp;
}
cout << fibMinus2;
}
int main()
{
int n;
cout << "Enter whatever number N you want to find the fibonacci of\n";
cin >> n;
cout << n << " th Fibonacci is \n";
fib_Accurate(n);
return 0;
}

128
others/tower_of_hanoi.cpp
View File

@ -1,73 +1,85 @@
/**
* @file
* @brief Solve the [Tower of
* Hanoi](https://en.wikipedia.org/wiki/Tower_of_Hanoi) problem.
*/
#include <iostream> #include <iostream>
using namespace std;
struct tower /**
{ * Define the state of tower
int values[10]; */
int top; struct tower {
} F, U, T; //! Values in the tower
int values[10];
//! top tower ID
int top;
};
void show() /** Display the towers */
{ void show(const struct tower *const F, const struct tower *const T,
cout << "\n\n\tF : "; const struct tower *const U) {
for (int i = 0; i < F.top; i++) std::cout << "\n\n\tF : ";
{ for (int i = 0; i < F->top; i++) {
cout << F.values[i] << "\t"; std::cout << F->values[i] << "\t";
} }
cout << "\n\tU : "; std::cout << "\n\tU : ";
for (int i = 0; i < U.top; i++) for (int i = 0; i < U->top; i++) {
{ std::cout << U->values[i] << "\t";
cout << U.values[i] << "\t"; }
} std::cout << "\n\tT : ";
cout << "\n\tT : "; for (int i = 0; i < T->top; i++) {
for (int i = 0; i < T.top; i++) std::cout << T->values[i] << "\t";
{ }
cout << T.values[i] << "\t";
}
} }
void mov(tower &From, tower &To) /** Move one disc from one tower to another
{ * \param [in,out] From tower to move disk *from*
--From.top; * \param [in,out] To tower to move disk *to*
To.values[To.top] = From.values[From.top]; */
++To.top; void mov(tower *From, tower *To) {
--From->top;
To->values[To->top] = From->values[From->top];
++To->top;
} }
void TH(int n, tower &From, tower &Using, tower &To) /**
{ * Recursive algorithm to solve the puzzle
* \param [in] n starting number of disks
if (n == 1) * \param [in,out] From tower to move disks from
{ * \param [in,out] Using temporary tower for the puzzle
mov(From, To); * \param [in,out] To tower to move disk to
show(); */
} void TH(int n, tower *From, tower *Using, tower *To) {
else if (n == 1) {
{ mov(From, To);
TH(n - 1, From, To, Using); show(From, To, Using);
mov(From, To); } else {
show(); TH(n - 1, From, To, Using);
TH(n - 1, Using, From, To); mov(From, To);
} show(From, To, Using);
TH(n - 1, Using, From, To);
}
} }
int main() /** Main function */
{ int main() {
F.top = 0; struct tower F, U, T;
U.top = 0;
T.top = 0;
int no; F.top = 0;
U.top = 0;
T.top = 0;
cout << "\nEnter number of discs : "; int no;
cin >> no;
for (int i = no; i > 0; i--) std::cout << "\nEnter number of discs : ";
{ std::cin >> no;
F.values[F.top++] = i;
};
show(); for (int i = no; i > 0; i--) {
TH(no, F, U, T); F.values[F.top++] = i;
}
return 0; show(&F, &T, &U);
TH(no, &F, &U, &T);
return 0;
} }

60
others/vector_important_functions.cpp
View File

@ -1,45 +1,43 @@
// A C++ program to demonstrate working of sort(), /**
// reverse() * @file
* @brief A C++ program to demonstrate working of std::sort(), std::reverse()
*/
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include <numeric> // For accumulate operation
#include <vector> #include <vector>
#include <numeric> //For accumulate operation
using namespace std;
int main() /** Main function */
{ int main() {
// Initializing vector with array values // Initializing vector with array values
int arr[] = {10, 20, 5, 23 ,42 , 15}; int arr[] = {10, 20, 5, 23, 42, 15};
int n = sizeof(arr)/sizeof(arr[0]); int n = sizeof(arr) / sizeof(arr[0]);
vector<int> vect(arr, arr+n); std::vector<int> vect(arr, arr + n);
cout << "Vector is: "; std::cout << "Vector is: ";
for (int i=0; i<n; i++) for (int i = 0; i < n; i++) std::cout << vect[i] << " ";
cout << vect[i] << " ";
// Sorting the Vector in Ascending order // Sorting the Vector in Ascending order
sort(vect.begin(), vect.end()); std::sort(vect.begin(), vect.end());
cout << "\nVector after sorting is: "; std::cout << "\nVector after sorting is: ";
for (int i=0; i<n; i++) for (int i = 0; i < n; i++) std::cout << vect[i] << " ";
cout << vect[i] << " ";
// Reversing the Vector // Reversing the Vector
reverse(vect.begin(), vect.end()); std::reverse(vect.begin(), vect.end());
cout << "\nVector after reversing is: "; std::cout << "\nVector after reversing is: ";
for (int i=0; i<6; i++) for (int i = 0; i < 6; i++) std::cout << vect[i] << " ";
cout << vect[i] << " ";
cout << "\nMaximum element of vector is: "; std::cout << "\nMaximum element of vector is: ";
cout << *max_element(vect.begin(), vect.end()); std::cout << *max_element(vect.begin(), vect.end());
cout << "\nMinimum element of vector is: "; std::cout << "\nMinimum element of vector is: ";
cout << *min_element(vect.begin(), vect.end()); std::cout << *min_element(vect.begin(), vect.end());
// Starting the summation from 0 // Starting the summation from 0
cout << "\nThe summation of vector elements is: "; std::cout << "\nThe summation of vector elements is: ";
cout << accumulate(vect.begin(), vect.end(), 0); std::cout << accumulate(vect.begin(), vect.end(), 0);
return 0; return 0;
} }

49
sorting/quick_sort.cpp
View File

@ -1,8 +1,40 @@
/* C implementation QuickSort */ /**
* @file
* @brief Quick sort algorithm
*
* Implementation Details -
* Quick Sort is a divide and conquer algorithm. It picks and element as
* pivot and partition the given array around the picked pivot. There
* are many different versions of quickSort that pick pivot in different
* ways.
*
* 1. Always pick the first element as pivot
* 2. Always pick the last element as pivot (implemented below)
* 3. Pick a random element as pivot
* 4. Pick median as pivot
*
* The key process in quickSort is partition(). Target of partition is,
* given an array and an element x(say) of array as pivot, put x at it's
* correct position in sorted array and put all smaller elements (samller
* than x) before x, and put all greater elements (greater than x) after
* x. All this should be done in linear time
*
*/
#include <cstdlib>
#include <iostream> #include <iostream>
/**
* This function takes last element as pivot, places
* the pivot element at its correct position in sorted
* array, and places all smaller (smaller than pivot)
* to left of pivot and all greater elements to right
* of pivot
*
*/
int partition(int arr[], int low, int high) { int partition(int arr[], int low, int high) {
int pivot = arr[high]; // pivot int pivot = arr[high]; // taking the last element as pivot
int i = (low - 1); // Index of smaller element int i = (low - 1); // Index of smaller element
for (int j = low; j < high; j++) { for (int j = low; j < high; j++) {
@ -21,20 +53,27 @@ int partition(int arr[], int low, int high) {
return (i + 1); return (i + 1);
} }
/**
* The main function that implements QuickSort
* arr[] --> Array to be sorted,
* low --> Starting index,
* high --> Ending index
*/
void quickSort(int arr[], int low, int high) { void quickSort(int arr[], int low, int high) {
if (low < high) { if (low < high) {
int p = partition(arr, low, high); int p = partition(arr, low, high);
quickSort(arr, low, p - 1); quickSort(arr, low, p - 1);
quickSort(arr, p + 1, high); quickSort(arr, p + 1, high);
} }
} }
// prints the array after sorting
void show(int arr[], int size) { void show(int arr[], int size) {
for (int i = 0; i < size; i++) std::cout << arr[i] << "\n"; for (int i = 0; i < size; i++) std::cout << arr[i] << " ";
std::cout << "\n";
} }
// Driver program to test above functions /** Driver program to test above functions */
int main() { int main() {
int size; int size;
std::cout << "\nEnter the number of elements : "; std::cout << "\nEnter the number of elements : ";