Skip to content

Commit dd36279

Browse files
feat: Digit Separation Algorithm added (TheAlgorithms#2759)
* Digit Separation Algorithm added * feat: Added namespace greedy_algoriithms * "Updated digit separation code: added comments and docstrings, changed data types to std::int64_t, and reformatted code." * feat: Made test function and removed extra whitespaces * removed some more whitespaces * Update greedy_algorithms/digit_separation.cpp Co-authored-by: realstealthninja <[email protected]> * fix: terminate multiline comment * Update greedy_algorithms/digit_separation.cpp Co-authored-by: realstealthninja <[email protected]> * Update greedy_algorithms/digit_separation.cpp Co-authored-by: realstealthninja <[email protected]> * Update greedy_algorithms/digit_separation.cpp Co-authored-by: realstealthninja <[email protected]> * Update greedy_algorithms/digit_separation.cpp Co-authored-by: realstealthninja <[email protected]> * Corrected test function * Update greedy_algorithms/digit_separation.cpp Co-authored-by: realstealthninja <[email protected]> * Update greedy_algorithms/digit_separation.cpp Co-authored-by: realstealthninja <[email protected]> * remove redundant declaration Co-authored-by: realstealthninja <[email protected]> * Corrected tests Co-authored-by: realstealthninja <[email protected]> * file clang linted * "Moved method implementations from outside to inside class definition" * fowardOrder to forwardOrder on line 122 Co-authored-by: realstealthninja <[email protected]> * Removed Class scope resolution form digitSeparationReverseOrder function Co-authored-by: realstealthninja <[email protected]> * Removed Class scope resolution form digitSeparationForwardOrderfunction Co-authored-by: realstealthninja <[email protected]> * docs: documentation updated --------- Co-authored-by: realstealthninja <[email protected]>
1 parent 821d20c commit dd36279

File tree

1 file changed

+142
-0
lines changed

1 file changed

+142
-0
lines changed
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+
}

0 commit comments

Comments
 (0)