Skip to content

Commit b3037bf

Browse files
namanmodi65namanmodi65
authored
Merge branch 'TheAlgorithms:master' into master
2 parents 2c96392 + dd36279 commit b3037bf

File tree

3 files changed

+548
-29
lines changed

3 files changed

+548
-29
lines changed

‎greedy_algorithms/digit_separation.cpp‎

Lines changed: 142 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,142 @@
1+
/**
2+
* @file digit_separation.cpp
3+
* @brief Separates digits from numbers in forward and reverse order
4+
* @see https://www.log2base2.com/c-examples/loop/split-a-number-into-digits-in-c.html
5+
* @details The DigitSeparation class provides two methods to separate the
6+
* digits of large integers: digitSeparationReverseOrder and
7+
* digitSeparationForwardOrder. The digitSeparationReverseOrder method extracts
8+
* digits by repeatedly applying the modulus operation (% 10) to isolate the
9+
* last digit, then divides the number by 10 to remove it. This process
10+
* continues until the entire number is broken down into its digits, which are
11+
* stored in reverse order. If the number is zero, the method directly returns a
12+
* vector containing {0} to handle this edge case. Negative numbers are handled
13+
* by taking the absolute value, ensuring consistent behavior regardless of the
14+
* sign.
15+
* @author [Muhammad Junaid Khalid](https://github.com/mjk22071998)
16+
*/
17+
18+
#include <algorithm> /// For reveresing the vector
19+
#include <cassert> /// For assert() function to check for errors
20+
#include <cmath> /// For abs() function
21+
#include <cstdint> /// For int64_t data type to handle large numbers
22+
#include <iostream> /// For input/output operations
23+
#include <vector> /// For std::vector to store separated digits
24+
25+
/**
26+
* @namespace
27+
* @brief Greedy Algorithms
28+
*/
29+
namespace greedy_algorithms {
30+
31+
/**
32+
* @brief A class that provides methods to separate the digits of a large
33+
* positive number.
34+
*/
35+
class DigitSeparation {
36+
public:
37+
/**
38+
* @brief Default constructor for the DigitSeparation class.
39+
*/
40+
DigitSeparation() {}
41+
42+
/**
43+
* @brief Implementation of digitSeparationReverseOrder method.
44+
*
45+
* @param largeNumber The large number to separate digits from.
46+
* @return A vector of digits in reverse order.
47+
*/
48+
std::vector<std::int64_t> digitSeparationReverseOrder(
49+
std::int64_t largeNumber) const {
50+
std::vector<std::int64_t> result;
51+
if (largeNumber != 0) {
52+
while (largeNumber != 0) {
53+
result.push_back(std::abs(largeNumber % 10));
54+
largeNumber /= 10;
55+
}
56+
} else {
57+
result.push_back(0);
58+
}
59+
return result;
60+
}
61+
62+
/**
63+
* @brief Implementation of digitSeparationForwardOrder method.
64+
*
65+
* @param largeNumber The large number to separate digits from.
66+
* @return A vector of digits in forward order.
67+
*/
68+
std::vector<std::int64_t> digitSeparationForwardOrder(
69+
std::int64_t largeNumber) const {
70+
std::vector<std::int64_t> result =
71+
digitSeparationReverseOrder(largeNumber);
72+
std::reverse(result.begin(), result.end());
73+
return result;
74+
}
75+
};
76+
77+
} // namespace greedy_algorithms
78+
79+
/**
80+
* @brief self test implementation
81+
* @return void
82+
*/
83+
static void tests() {
84+
greedy_algorithms::DigitSeparation ds;
85+
86+
// Test case: Positive number
87+
std::int64_t number = 1234567890;
88+
std::vector<std::int64_t> expectedReverse = {0, 9, 8, 7, 6, 5, 4, 3, 2, 1};
89+
std::vector<std::int64_t> expectedForward = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
90+
std::vector<std::int64_t> reverseOrder =
91+
ds.digitSeparationReverseOrder(number);
92+
assert(reverseOrder == expectedReverse);
93+
std::vector<std::int64_t> forwardOrder =
94+
ds.digitSeparationForwardOrder(number);
95+
assert(forwardOrder == expectedForward);
96+
97+
// Test case: Single digit number
98+
number = 5;
99+
expectedReverse = {5};
100+
expectedForward = {5};
101+
reverseOrder = ds.digitSeparationReverseOrder(number);
102+
assert(reverseOrder == expectedReverse);
103+
forwardOrder = ds.digitSeparationForwardOrder(number);
104+
assert(forwardOrder == expectedForward);
105+
106+
// Test case: Zero
107+
number = 0;
108+
expectedReverse = {0};
109+
expectedForward = {0};
110+
reverseOrder = ds.digitSeparationReverseOrder(number);
111+
assert(reverseOrder == expectedReverse);
112+
forwardOrder = ds.digitSeparationForwardOrder(number);
113+
assert(forwardOrder == expectedForward);
114+
115+
// Test case: Large number
116+
number = 987654321012345;
117+
expectedReverse = {5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
118+
expectedForward = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5};
119+
reverseOrder = ds.digitSeparationReverseOrder(number);
120+
assert(reverseOrder == expectedReverse);
121+
forwardOrder = ds.digitSeparationForwardOrder(number);
122+
assert(forwardOrder == expectedForward);
123+
124+
// Test case: Negative number
125+
number = -987654321012345;
126+
expectedReverse = {5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
127+
expectedForward = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5};
128+
reverseOrder = ds.digitSeparationReverseOrder(number);
129+
assert(reverseOrder == expectedReverse);
130+
forwardOrder = ds.digitSeparationForwardOrder(number);
131+
assert(forwardOrder == expectedForward);
132+
}
133+
134+
/**
135+
* @brief main function
136+
* @return 0 on successful exit
137+
*/
138+
int main() {
139+
tests(); // run self test implementation
140+
141+
return 0;
142+
}

‎math/gcd_of_n_numbers.cpp‎

Lines changed: 102 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1,41 +1,114 @@
11
/**
22
* @file
3-
* @brief This program aims at calculating the GCD of n numbers by division
4-
* method
3+
* @brief This program aims at calculating the GCD of n numbers
4+
*
5+
* @details
6+
* The GCD of n numbers can be calculated by
7+
* repeatedly calculating the GCDs of pairs of numbers
8+
* i.e. \f$\gcd(a, b, c)\f$ = \f$\gcd(\gcd(a, b), c)\f$
9+
* Euclidean algorithm helps calculate the GCD of each pair of numbers
10+
* efficiently
511
*
612
* @see gcd_iterative_euclidean.cpp, gcd_recursive_euclidean.cpp
713
*/
8-
#include <iostream>
14+
#include <algorithm> /// for std::abs
15+
#include <array> /// for std::array
16+
#include <cassert> /// for assert
17+
#include <iostream> /// for IO operations
918

10-
/** Compute GCD using division algorithm
11-
*
12-
* @param[in] a array of integers to compute GCD for
13-
* @param[in] n number of integers in array `a`
14-
*/
15-
int gcd(int *a, int n) {
16-
int j = 1; // to access all elements of the array starting from 1
17-
int gcd = a[0];
18-
while (j < n) {
19-
if (a[j] % gcd == 0) // value of gcd is as needed so far
20-
j++; // so we check for next element
21-
else
22-
gcd = a[j] % gcd; // calculating GCD by division method
19+
/**
20+
* @namespace math
21+
* @brief Maths algorithms
22+
*/
23+
namespace math {
24+
/**
25+
* @namespace gcd_of_n_numbers
26+
* @brief Compute GCD of numbers in an array
27+
*/
28+
namespace gcd_of_n_numbers {
29+
/**
30+
* @brief Function to compute GCD of 2 numbers x and y
31+
* @param x First number
32+
* @param y Second number
33+
* @return GCD of x and y via recursion
34+
*/
35+
int gcd_two(int x, int y) {
36+
// base cases
37+
if (y == 0) {
38+
return x;
39+
}
40+
if (x == 0) {
41+
return y;
42+
}
43+
return gcd_two(y, x % y); // Euclidean method
44+
}
45+
46+
/**
47+
* @brief Function to check if all elements in the array are 0
48+
* @param a Array of numbers
49+
* @return 'True' if all elements are 0
50+
* @return 'False' if not all elements are 0
51+
*/
52+
template <std::size_t n>
53+
bool check_all_zeros(const std::array<int, n> &a) {
54+
// Use std::all_of to simplify zero-checking
55+
return std::all_of(a.begin(), a.end(), [](int x) { return x == 0; });
56+
}
57+
58+
/**
59+
* @brief Main program to compute GCD using the Euclidean algorithm
60+
* @param a Array of integers to compute GCD for
61+
* @return GCD of the numbers in the array or std::nullopt if undefined
62+
*/
63+
template <std::size_t n>
64+
int gcd(const std::array<int, n> &a) {
65+
// GCD is undefined if all elements in the array are 0
66+
if (check_all_zeros(a)) {
67+
return -1; // Use std::optional to represent undefined GCD
68+
}
69+
70+
// divisors can be negative, we only want the positive value
71+
int result = std::abs(a[0]);
72+
for (std::size_t i = 1; i < n; ++i) {
73+
result = gcd_two(result, std::abs(a[i]));
74+
if (result == 1) {
75+
break; // Further computations still result in gcd of 1
2376
}
24-
return gcd;
77+
}
78+
return result;
2579
}
80+
} // namespace gcd_of_n_numbers
81+
} // namespace math
2682

27-
/** Main function */
28-
int main() {
29-
int n;
30-
std::cout << "Enter value of n:" << std::endl;
31-
std::cin >> n;
32-
int *a = new int[n];
33-
int i;
34-
std::cout << "Enter the n numbers:" << std::endl;
35-
for (i = 0; i < n; i++) std::cin >> a[i];
83+
/**
84+
* @brief Self-test implementation
85+
* @return void
86+
*/
87+
static void test() {
88+
std::array<int, 1> array_1 = {0};
89+
std::array<int, 1> array_2 = {1};
90+
std::array<int, 2> array_3 = {0, 2};
91+
std::array<int, 3> array_4 = {-60, 24, 18};
92+
std::array<int, 4> array_5 = {100, -100, -100, 200};
93+
std::array<int, 5> array_6 = {0, 0, 0, 0, 0};
94+
std::array<int, 7> array_7 = {10350, -24150, 0, 17250, 37950, -127650, 51750};
95+
std::array<int, 7> array_8 = {9500000, -12121200, 0, 4444, 0, 0, 123456789};
3696

37-
std::cout << "GCD of entered n numbers:" << gcd(a, n) << std::endl;
97+
assert(math::gcd_of_n_numbers::gcd(array_1) == -1);
98+
assert(math::gcd_of_n_numbers::gcd(array_2) == 1);
99+
assert(math::gcd_of_n_numbers::gcd(array_3) == 2);
100+
assert(math::gcd_of_n_numbers::gcd(array_4) == 6);
101+
assert(math::gcd_of_n_numbers::gcd(array_5) == 100);
102+
assert(math::gcd_of_n_numbers::gcd(array_6) == -1);
103+
assert(math::gcd_of_n_numbers::gcd(array_7) == 3450);
104+
assert(math::gcd_of_n_numbers::gcd(array_8) == 1);
105+
}
38106

39-
delete[] a;
40-
return 0;
107+
/**
108+
* @brief Main function
109+
* @return 0 on exit
110+
*/
111+
int main() {
112+
test(); // run self-test implementation
113+
return 0;
41114
}

0 commit comments

Comments
 (0)