digit_separation.cpp File Reference

Separates digits from numbers in forward and reverse order. More...

#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <vector>

Include dependency graph for digit_separation.cpp:

Go to the source code of this file.

Classes
class	greedy_algorithms::DigitSeparation
	A class that provides methods to separate the digits of a large positive number. More...

Namespaces
namespace	greedy_algorithms
	for string class

Functions
static void	tests ()
	self test implementation
int	main ()
	main function

Detailed Description

Separates digits from numbers in forward and reverse order.

See also

https://www.log2base2.com/c-examples/loop/split-a-number-into-digits-in-c.html

The DigitSeparation class provides two methods to separate the digits of large integers: digitSeparationReverseOrder and digitSeparationForwardOrder. The digitSeparationReverseOrder method extracts digits by repeatedly applying the modulus operation (% 10) to isolate the last digit, then divides the number by 10 to remove it. This process continues until the entire number is broken down into its digits, which are stored in reverse order. If the number is zero, the method directly returns a vector containing {0} to handle this edge case. Negative numbers are handled by taking the absolute value, ensuring consistent behavior regardless of the sign.

Author

Muhammad Junaid Khalid

Definition in file digit_separation.cpp.

Function Documentation

main()

int main

(

void

)

main function

Returns

0 on successful exit

Definition at line 138 of file digit_separation.cpp.

           {
    tests();  // run self test implementation
 
    return 0;
}

tests()

static void tests ( )

static

self test implementation

Returns

void

Definition at line 83 of file digit_separation.cpp.

                    {
    greedy_algorithms::DigitSeparation ds;
 
    // Test case: Positive number
    std::int64_t number = 1234567890;
    std::vector<std::int64_t> expectedReverse = {0, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    std::vector<std::int64_t> expectedForward = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    std::vector<std::int64_t> reverseOrder =
        ds.digitSeparationReverseOrder(number);
    assert(reverseOrder == expectedReverse);
    std::vector<std::int64_t> 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};
    reverseOrder = ds.digitSeparationReverseOrder(number);
    assert(reverseOrder == expectedReverse);
    forwardOrder = ds.digitSeparationForwardOrder(number);
    assert(forwardOrder == expectedForward);
}