L.C.M. of a Set of Numbers in C++ - Maths Programming for Kids

#pragma once

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

class LCM {
public:
    LCM(vector<unsigned>);
    virtual ~LCM();
    unsigned getLCM(void);
private:
    int LCMFactors(void);

    unsigned * set_of_numbers;
    unsigned * arg_copy; // Java passes arrays by reference; make a copy.
    size_t array_length;
    vector<unsigned> all_factors; // factors common to our set_of_numbers

    unsigned int index; // index into array common_factors
    bool state_check; // variable to keep state
    unsigned int calc_result;
};

#include "stdafx.h"
#include "LCM.h"

// descending sort function
bool isGreater(int i, int j) { return i > j; }


LCM::LCM(vector<unsigned> group) {
    all_factors = {};
    group.shrink_to_fit();
    sort(group.begin(), group.end());

    array_length = group.size();
    set_of_numbers = new unsigned[array_length];
    arg_copy = new unsigned[array_length];
    index = 0;

    //iterate through and retrieve members
    for (unsigned number : group) {
        set_of_numbers[index] = number;
        index++;
    }
    // Sort array in descending order
    sort(set_of_numbers, set_of_numbers + array_length, isGreater);

    index = 2;
    state_check = false;
}

/**
* Our function checks 'set_of_numbers'; If it finds a factor common to all
* for it, it records this factor; then divides 'set_of_numbers' by the
* common factor found and makes this the new 'set_of_numbers'. It continues
* recursively until all common factors are found.
*
*/
int LCM::LCMFactors() {
    //  Copy 'set_of_numbers' into 'arg_copy'
    for (unsigned count=0; count < array_length; count++ ) {
        arg_copy[count] = set_of_numbers[count];
    }
    // sort in descending order
    sort(arg_copy, arg_copy + array_length, isGreater);

    while (index <= arg_copy[0]) {
        state_check = false;
        for (unsigned j = 0; j < array_length; j++) {
            if ((set_of_numbers[j] % index) == 0) {
                set_of_numbers[j] /= index;
                if (state_check == false) {
                    all_factors.push_back(index);
                }
                state_check = true;
            }
        }
        if (state_check == true) {
            return LCMFactors();
        }
        index++;
    }

    return 0;
}

/**
* Just calls out and collects the prepared factors.
*
* @param - None.
*/
unsigned LCM::getLCM() {
    index = 2;
    LCMFactors();
    all_factors.shrink_to_fit();

    //iterate through and retrieve members
    calc_result = 1;
    for (unsigned factor : all_factors) {
        calc_result *= factor;
    }

    return calc_result;
}


LCM::~LCM() {
    delete[] set_of_numbers;
    delete[] arg_copy;
}

// Arithmetic.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "LCM.h"

#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

int main() {
    try {
        cout << "\n    Welcome to our demonstration sequels\n";
        cout << "Hope you enjoy (and follow) the lessons.\n\n";

        vector<unsigned> set;

        /*
         * Find L.C.M
         */
        set = {2, 5, 7};

        stringstream aux;
        string render_result = "The LCM of ";
        for (unsigned number : set) {
            aux.str("");
            aux << number;
            render_result += aux.str() + "; ";
        }
        render_result += " is:  ";

        LCM lcm(set);
        cout << "\n\n" << render_result << lcm.getLCM() << "\n";

    } catch (exception& e) {
        cout << "\n" << e.what() << "\n";
    }
    return 0;
}