From 47af70eb684888dcb44a6c2fadca96771cbaffa3 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Sat, 5 Oct 2024 10:13:16 +0500
Subject: [PATCH] Digit Separation Algorithm added

---
 greedy_algorithms/digit_separation.cpp | 129 +++++++++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 greedy_algorithms/digit_separation.cpp

diff --git a/greedy_algorithms/digit_separation.cpp b/greedy_algorithms/digit_separation.cpp
new file mode 100644
index 000000000..49b3b4260
--- /dev/null
+++ b/greedy_algorithms/digit_separation.cpp
@@ -0,0 +1,129 @@
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <vector>
+#include <cassert>
+
+/**
+ * @brief A class that provides methods to separate the digits of a large
+ * positive number.
+ */
+class DigitSeparation {
+ public:
+    /**
+     * @brief Default constructor for the DigitSeparation class.
+     */
+    DigitSeparation() {}
+
+    /**
+     * @brief Separates the digits of a large positive number into a vector in
+     * reverse order.
+     *
+     * @param largeNumber The large number to separate digits from.
+     * @return A vector of digits in reverse order.
+     */
+    std::vector<long long> digitSeparationReverseOrder(
+        long long largeNumber) const;
+
+    /**
+     * @brief Separates the digits of a large positive number into a vector in
+     * forward order.
+     *
+     * @param largeNumber The large number to separate digits from.
+     * @return A vector of digits in forward order.
+     */
+    std::vector<long long> digitSeparationForwardOrder(
+        long long largeNumber) const;
+};
+
+/**
+ * @brief Implementation of digitSeparationReverseOrder method.
+ *
+ * @param largeNumber The large number to separate digits from.
+ * @return A vector of digits in reverse order.
+ */
+std::vector<long long> DigitSeparation::digitSeparationReverseOrder(
+    long long largeNumber) const {
+    std::vector<long long> result;
+    if (largeNumber != 0) {
+        while (largeNumber != 0) {
+            result.push_back(std::abs(largeNumber % 10));
+            largeNumber /= 10;
+        }
+    } else {
+        result.push_back(0);
+    }
+    return result;
+}
+
+/**
+ * @brief Implementation of digitSeparationForwardOrder method.
+ *
+ * @param largeNumber The large number to separate digits from.
+ * @return A vector of digits in forward order.
+ */
+std::vector<long long> DigitSeparation::digitSeparationForwardOrder(
+    long long largeNumber) const {
+    std::vector<long long> result = digitSeparationReverseOrder(largeNumber);
+    std::reverse(result.begin(), result.end());
+    return result;
+}
+
+int main() {
+    DigitSeparation ds;
+
+    // Test case: Positive number
+    long long number = 1234567890;
+    std::vector<long long> expectedReverse = {0, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+    std::vector<long long> expectedForward = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
+
+    // Testing reverse order
+    std::vector<long long> reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+
+    // Testing forward order
+    std::vector<long long> forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Single digit number
+    number = 5;
+    expectedReverse = {5};
+    expectedForward = {5};
+
+    reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+
+    forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Zero
+    number = 0;
+    expectedReverse = {0};
+    expectedForward = {0};
+
+    reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+
+    forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Large number
+    number = 987654321012345;
+    expectedReverse = {5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    expectedForward = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5};
+
+    reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+
+    forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Negative number
+    number = -987654321012345;
+    expectedReverse = {5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    expectedForward = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5};
+
+    std::cout << "All tests passed!" << std::endl;
+
+    return 0;
+}