lucywaifu.cpp

#include <iostream>
#include <algorithm>
#include <array>

class User {
protected:
	static int* data;
	static int* auxData1;
	static int* auxData2;
	int tamannoAD1;
	int tamannoAD2;


public:
	void initialize(int size) {
		data = new int[size];
		auxData1 = new int[size];
		auxData2 = new int[size];
		tamannoAD1 = 0;
		tamannoAD2 = 0;
	}

	~User() {
	    if (data)
		{
		    delete[] data;
		    data = nullptr;
		}
		if(auxData1)
		{
		    delete[] auxData1;
		    auxData1 = nullptr;
		}
		if (auxData2)
		{
		    delete[] auxData2;
		    auxData2 = nullptr;
		}
	}

	void array(int size) {
		for (int i = 0; i < size; i++) {
			std::cout << "Introduzca un valor para el arreglo: ";
			std::cin >> data[i];
			std::cout << "Se encuentra en la posicion " << i + 1 << " faltan " << (size)-(i + 1) << " para terminar." << std::endl << "\n";
		}
	}

	virtual void orderData(int size) {
		std::sort(data, data + size);
	}

	virtual void printData(int size) {
		std::cout << "\n" << "Arreglo completo." << std::endl;
		for (int j = 0; j < size; j++) {
			std::cout << " [ " << data[j] << " ] ";
		}
		std::cout << "\n";
	}

	void balance(int size) {
		int k = 0;
		int aux = 0;

		//aux es la suma de los valores del arreglo completo, lo que se hace es separar todos los numeros que sumados sean menores al segundo siguiente puesto del arreglo
		while (k < size - 1 or aux < data[k + 1]) {
			aux = aux + data[k];
			auxData1[k] = data[k];
			k++;
			tamannoAD1++;
		}

		//aqui obtenemos el valor mas grande del arreglo y lo posicionamos en el segundo arreglo
		for (; k < size; k++) {
			auxData2[tamannoAD2] = data[k];
			tamannoAD2++;
		}
	}

	void secondBalance(int size) {
		int sumData = 0, sumAD1 = 0, sumAD2 = 0;
		int idealData;

		for (int j = 0; j < size; j++) {
			sumData = sumData + data[j];
		} //obtiene la suma total del arreglo original y obtiene un numero ideal al que las cargas de los 2 arreglos auxiliares deben acercarse
		idealData = sumData / 2;

		for (int j = 0; j < tamannoAD1; j++) {
			sumAD1 = sumAD1 + auxData1[j];
		} //obtiene la suma del arreglo auxiliar 1

		for (int j = 0; j < tamannoAD2; j++) {
			sumAD2 = sumAD2 + auxData2[j];
		} //obtiene la suma del arreglo auxiliar 2

		int k = 0;
		int ADCount = 1;
		bool resetK = false;
		while (sumAD2 < idealData) {
			if (resetK == true) {
				k = 0;
				resetK = false;
				ADCount++;
				auxData1[size - 2] = 0;
				size = size - 1;
			}
			else {
				auxData2[ADCount] = auxData1[k];
				auxData1[k] = 0;

				sumAD1 = 0;
				for (int i = 0; i < tamannoAD1; i++) {
					sumAD1 = sumAD1 + auxData1[i];
				} //obtiene la suma del arreglo auxiliar 1

				sumAD2 = 0;
				for (int j = 0; j < size; j++) {
					sumAD2 = sumAD2 + auxData2[j];
				} //obtiene la suma del arreglo auxiliar 2

				if (sumAD2 < idealData and k != size - 2) { //Comprueba si se tendra que hacer otra iteracion, en caso de ser asi, devuelve el valor tomado por auxData2 a auxData1
					std::cout << "\nCondicion en curso\n";
					auxData1[k] = auxData2[ADCount];
				}

				if (k == size - 2) {
					resetK = true;
				}

				k++;
			}
		}
		std::cout << "\nSuma del arreglo 1: " << sumAD1 << "\n";
		std::cout << "\nSuma del arreglo 2: " << sumAD2 << "\n";

		
		std::cout << "\n" << "Primer arreglo: " << std::endl << "\n";
		for (int t = 0; t < tamannoAD1; t++) {
			std::cout << " [ " << auxData1[t] << " ] ";
		}
		std::cout << "\n";

		std::cout << "\n" << "Segundo arreglo: " << std::endl << "\n";
		for (int p = 0; p < size; p++) {
			std::cout << " [ " << auxData2[p] << " ] ";
		}
		std::cout << "\n";
		
	}
};
int* User::data = nullptr;
int* User::auxData1 = nullptr;
int* User::auxData2 = nullptr;

class Router1 : public User {
public:
	void orderData(int size) override {
		std::sort(auxData1, auxData1 + size);
	}

	void printData(int size) override {
		std::cout << "\n" << "Primer arreglo desde funcion heredada: " << std::endl << "\n";
		for (int t = 0; t < tamannoAD1; t++) {
			std::cout << " [ " << auxData1[t] << " ] ";
		}
		std::cout << "\n";
	}
};

class Router2 : public User {
public:
	void orderData(int size) override {
		std::sort(auxData2, auxData2 + size);
	}

	void printData(int size) override {
		std::cout << "\n" << "Segundo arreglo desde funcion heredada: " << std::endl << "\n";
		for (int p = 0; p < size; p++) {
			std::cout << " [ " << auxData2[p] << " ] ";
		}
		std::cout << "\n";
	}
};

int main() {
	User objetoBase;
	Router1 objetoSub1;
	Router2 objetoSub2;

	User* puntero1 = &objetoBase;
	User* puntero2 = &objetoSub1;
	User* puntero3 = &objetoSub2;
	int size;

	std::cout << "Por favor introduzca el tamanno del arreglo: ";
	std::cin >> size;
	puntero1->initialize(size);
	puntero1->array(size);
	puntero1->orderData(size);
	puntero1->printData(size);
	puntero1->balance(size);
	puntero1->secondBalance(size);

	puntero2->printData(size);
	std::cin.get();
	puntero2->orderData(size);

	puntero3->orderData(size);
	puntero3->printData(size);
}