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

clang-format and clang-tidy fixes for 3d017c44

Browse Source
This commit is contained in:
github-actions 2020-10-18 20:10:44 +00:00
parent 0e2f1ae681
commit caf2ecc54e
2 changed files with 85 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
math/power_of_two.cpp
View File

@ -3,44 +3,45 @@
* @brief Implementation to check whether a number is a power of 2 or not.
*
* @details
* This algorithm uses bit manipulation to check if a number is a power of 2 or not.
* This algorithm uses bit manipulation to check if a number is a power of 2 or
* not.
*
* ### Algorithm
* Let the input number be n, then the bitwise and between n and n-1 will let us know
* whether the number is power of 2 or not
*
* Let the input number be n, then the bitwise and between n and n-1 will let us
* know whether the number is power of 2 or not
*
* For Example,
* If N= 32 then N-1 is 31, if we perform bitwise and of these two numbers then
* the result will be zero, which indicates that it is the power of 2
* If N=23 then N-1 is 22, if we perform bitwise and of these two numbers then
* the result will not be zero , which indicates that it is not the power of 2
* \note This implementation is better than naive recursive or iterative approach.
*
* \note This implementation is better than naive recursive or iterative
* approach.
*
* @author [Neha Hasija](https://github.com/neha-hasija17)
*/
#include <iostream> /// for std::cout
/**
* @brief Function to test above algorithm
* @param n description
* @returns void
*/
void power_of_two(int n){
/**
* This function finds whether a number is power of 2 or not
* @param n value for which we want to check
* prints the result, as "Yes, the number n is a power of 2" or
* "No, the number is not a power of 2" without quotes
*/
/// result stores the
/// bitwise and of n and n-1
int result = n & (n-1);
if(result==0)
std::cout<<"Yes, the number "<<n<<" is a power of 2";
else
std::cout<<"No, the number "<<n<<" is not a power of 2";
void power_of_two(int n) {
/**
* This function finds whether a number is power of 2 or not
* @param n value for which we want to check
* prints the result, as "Yes, the number n is a power of 2" or
* "No, the number is not a power of 2" without quotes
*/
/// result stores the
/// bitwise and of n and n-1
int result = n & (n - 1);
if (result == 0) {
std::cout << "Yes, the number " << n << " is a power of 2";
} else {
std::cout << "No, the number " << n << " is not a power of 2";
}
}
/**
@ -49,10 +50,10 @@ void power_of_two(int n){
*/
int main() {
int n = 0;
///n stores the input from the user
std::cout<<"enter a number "<<std::endl;
std::cin>>n;
///function call with @param n
/// n stores the input from the user
std::cout << "enter a number " << std::endl;
std::cin >> n;
/// function call with @param n
power_of_two(n);
return 0;
}

112
sorting/pancake_sort.cpp
View File

@ -1,26 +1,25 @@
/**
* @file
* @brief pancake sort sorts a disordered stack of pancakes by flipping any number of pancakes using a spatula using minimum number of flips.
* @brief pancake sort sorts a disordered stack of pancakes by flipping any
* number of pancakes using a spatula using minimum number of flips.
*
* @details
* Unlike a traditional sorting algorithm, which attempts to sort with the fewest comparisons possible,
* the goal is to sort the sequence in as few reversals as possible.
* Overall time complexity of pancake sort is O(n^2)
* For example: example 1:-
* Disordered pancake sizes: {2,5,3,7,8}
* Sorted: {2,3,5,7,8}
* For example: example 2:-
* Disordered pancake sizes: {22,51,37,73,81}
* Sorted: {22,37,51,73,81}
* Unlike a traditional sorting algorithm, which attempts to sort with the
* fewest comparisons possible, the goal is to sort the sequence in as few
* reversals as possible. Overall time complexity of pancake sort is O(n^2) For
* example: example 1:- Disordered pancake sizes: {2,5,3,7,8} Sorted:
* {2,3,5,7,8} For example: example 2:- Disordered pancake sizes:
* {22,51,37,73,81} Sorted: {22,37,51,73,81}
* @author [Divyansh Gupta](https://github.com/divyansh12323)
* @see more on [Pancake sort](https://en.wikipedia.org/wiki/Pancake_sorting)
* @see related problem at [Leetcode](https://leetcode.com/problems/pancake-sorting/)
*/
* @see related problem at
* [Leetcode](https://leetcode.com/problems/pancake-sorting/)
*/
#include <iostream> // for io operations
#include <vector> // for std::vector
#include <algorithm> // for std::is_sorted
#include <cassert> // for std::assert
#include <iostream> // for io operations
#include <vector> // for std::vector
/**
* @namespace sorting
@ -29,52 +28,54 @@
namespace sorting {
/**
* @namespace pancake_sort
* @brief Functions for [Pancake sort](https://en.wikipedia.org/wiki/Pancake_sorting) algorithm
* @brief Functions for [Pancake
* sort](https://en.wikipedia.org/wiki/Pancake_sorting) algorithm
*/
namespace pancake_sort {
/**
* @brief This implementation is for reversing elements in a a C-style array .
* @param [start,end] arr our vector of elements.
* @param start starting index of array
* @param end ending index of array
* @returns void
*/
template<typename T>
void reverse(std::vector<T> &arr, int start, int end) {
T temp; //Temporary variable
while (start <= end) {
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
/**
* @brief This implementation is for reversing elements in a a C-style array .
* @param [start,end] arr our vector of elements.
* @param start starting index of array
* @param end ending index of array
* @returns void
*/
template <typename T>
void reverse(std::vector<T> &arr, int start, int end) {
T temp; // Temporary variable
while (start <= end) {
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
/**
* @brief This implementation is for a C-style array input that gets modified in place.
* @param [start,end] arr our vector of elements.
* @param size size of given array
* @returns 0 on exit
*/
template<typename T>
int pancakeSort(std::vector<T> &arr, int size) {
for (int i = size; i > 1; --i) {
int max_index = 0, j; //intialize some variables.
T max_value = 0;
for (j = 0; j < i; j++) {
if (arr[j] >= max_value) {
max_value = arr[j];
max_index = j;
}
}
if (max_index != i - 1) //check for reversing
{
reverse(arr, 0, max_index);
reverse(arr, 0, i - 1);
}
/**
* @brief This implementation is for a C-style array input that gets modified in
* place.
* @param [start,end] arr our vector of elements.
* @param size size of given array
* @returns 0 on exit
*/
template <typename T>
int pancakeSort(std::vector<T> &arr, int size) {
for (int i = size; i > 1; --i) {
int max_index = 0, j = 0; // intialize some variables.
T max_value = 0;
for (j = 0; j < i; j++) {
if (arr[j] >= max_value) {
max_value = arr[j];
max_index = j;
}
}
return 0;
if (max_index != i - 1) // check for reversing
{
reverse(arr, 0, max_index);
reverse(arr, 0, i - 1);
}
}
return 0;
}
} // namespace pancake_sort
} // namespace sorting
@ -98,7 +99,8 @@ static void test() {
// example 2: vector of double
const int size2 = 8;
std::cout << "\nTest 2- as std::vector<double>...";
std::vector<double> arr2 = {23.56, 10.62, 200.78, 111.484, 3.9, 1.2, 61.77, 79.6};
std::vector<double> arr2 = {23.56, 10.62, 200.78, 111.484,
3.9, 1.2, 61.77, 79.6};
sorting::pancake_sort::pancakeSort(arr2, size2);
assert(std::is_sorted(arr2.begin(), arr2.end()));
std::cout << "Passed\n";