Ejercicio 55

#include <iostream>
 // se incluye la clase Estatuas  para despues llamar a sus métodos 
#include "Estatuas.h"

using namespace std;

// método para mostrar el vector 
void mostrar(Estatuas *obj)
{
    // recorremos el vector con el ciclo for 
    for (int i = 0; i < obj->getTamanoVector(); i++)
    {
        // si llegamos a la ultima posicion del vector cerramos con un corchete 
        if (i == obj->getTamanoVector()-1)
        {
            cout << obj->getVector(i) << "]" << endl;
        }
        else
        {
            // sino separamos cada valor del vector con una , 
            cout << obj->getVector(i) << ", ";
        }
    }
}

// método para mostrar todas estatuas ordenadas de 1 en 1 
void mostrarTodo(Estatuas *obj)
{
    // inicializamos una variable de tipo entera llamada tam en la suma del tamaño del vector mas las estatuas requeridas 
    int tam = obj->getTamanoVector()+obj->estatuasRequeridas();
    // recorremos el vector ordenado con el ciclo for 
    for (int i = 0; i < tam; i++)
    {
        // si llegamos a la ultima posicion 
        if (i == tam-1)
        {
            // si llegamos a la ultima posicion del vector cerramos con un corchete 
            cout << obj->getVectorOrdenado(i) << "]" << endl;
        }
        else
        {
            // sino separamos cada valor del vector con una , 
            cout << obj->getVectorOrdenado(i) << ", ";
        }
    }
}

int main(void)
{
    // creamos un objeto de la clase Estatuas (Instanciación) 
    Estatuas *obj = new Estatuas();
    // declaramos dos variables de tipo entero 
    int tam, dato;
    // pedimos el tamaño del vector 
    cout << "Digite tama" << (char) 164 << "o del vector" << endl;
    cout << ">> ";
    cin >> tam;
    // encapsulamos la variable tam 
    obj->setTamanoVector(tam);
    // creamos el vector 
    obj->crearVector();
    // recorremos el vector con el ciclo for 
    for (int i = 0; i < obj->getTamanoVector(); i++)
    {
        do
        {
            // pedimos el tamaño de la estatua en la posicion i 
            cout << "Digite tama" << (char) 164 << "o de la estatua " << i << endl;
            cout << ">> ";
            cin >> dato;
            // encapsumalos en la posicion la variable dato 
            obj->setVector(i, dato);
        }
        while (dato < 0); // repetiremos esto hasta si el dato es menor a 0 
    }
    //mostramos en pantalla el vector 
    cout << "Tama" << (char) 164 << "o de las estatuas de Timmy: [";
    mostrar(obj);
    // si el tamaño es mayor a 1 
    if (obj->getTamanoVector() > 1)
    {
        // mostramos las estatuas ordenas y todas las estatuas ordenadas de 1 en 1 
        obj->ordenar();
        cout << "Estatuas ordenadas: [";
        mostrar(obj);
        obj->crearVectorOrdenado();
        obj->llenarEstatuasFaltantes();
        cout << "Todas las estatuas ordenadas de 1 en 1: [";
        mostrarTodo(obj);
    }
    // mostramos la cantidad de estatuas necesitadas 
    cout << "Se necesitaron " << obj->estatuasRequeridas() << " estatuas para ordenarlas de 1 en 1." << endl;
}

#ifndef ESTATUAS_H
#define ESTATUAS_H
#include <iostream>

using namespace std;

class Estatuas
{
    public:
        Estatuas();
        virtual ~Estatuas();
        // declaramos los métodos publicos 
        void setTamanoVector(int val);
        int getTamanoVector();
        void setVector(int pos, int val);
        int getVector(int pos);
        void setVectorOrdenado(int pos, int val);
        int getVectorOrdenado(int pos);
        void crearVector();
        void crearVectorOrdenado();
        int mayorTamano();
        int menorTamano();
        void cambiar(int p1, int p2);
        void ordenar();
        int estatuasRequeridas();
        void llenarEstatuasFaltantes();
    protected:

    private:
        // declaramos los atributos privados 
        int tamano;
        int *vector;
        int *vector_ordenado;
};

#endif // ESTATUAS_H

#include "Estatuas.h"

Estatuas::Estatuas()
{
    // le asignamos valores por defecto a los atributos de la clase en el constructor 
    tamano = 0;
    vector = NULL;
    vector_ordenado = NULL;
}

Estatuas::~Estatuas()
{
    //dtor 
}

// métodos Setters y Getters 
void Estatuas::setTamanoVector(int val)
{
    tamano = val;
}

int Estatuas::getTamanoVector()
{
    return tamano;
}

void Estatuas::setVector(int pos, int val)
{
    vector[pos] = val;
}

int Estatuas::getVector(int pos)
{
    return vector[pos];
}
void Estatuas::setVectorOrdenado(int pos, int val)
{
    vector_ordenado[pos] = val;
}

int Estatuas::getVectorOrdenado(int pos)
{
    return vector_ordenado[pos];
}

// método para crear el vector 
void Estatuas::crearVector()
{
    // le asignamos al vector de tipo entero un tamaño del valor de la variable tamano 
    vector = new int[tamano];
}

// método para crear el vector donde estaran todas estatuas que se requieren ordenadas de 1 en 1 
void Estatuas::crearVectorOrdenado()
{
    // inicializamos una variable de tipo entero llamada tam en el valor de la variable tam mas
    // el valor del método estatuasRequeridas 
    int tam = tamano+estatuasRequeridas();
    vector_ordenado = new int[tam];
}

// método para calcular el mayor tamaño entre todas las estatuas 
int Estatuas::mayorTamano()
{
    // inicializamos una variable de tipo entero llamada may en 0 
    int may = 0;
    // declaramos una variable de tipo entero llamada temp 
    int temp;
    // recorremos el vector con el ciclo for 
    for (int i = 0; i < getTamanoVector(); i++)
    {
        // le asignamos a la variable temp el valor de la posicion i del vector 
        temp = getVector(i);
        // si el valor de temp es mayor al valor de la variable may 
        if (temp > may)
        {
            // le asignamos a la variable may el valor de temp 
            may = temp;
        }
    }
    // retornamos el valor de may 
    return may;
}

// método para calcular el menor tamaño entre todas las estatuas 
int Estatuas::menorTamano()
{
    // inicializamos una variable de tipo entero llamada men en el valor que retorne el metodo mayorTamano 
    int men = mayorTamano();
    // declaramos una variable de tipo entero llamada temp 
    int temp;
    // recorremos el vector con el ciclo for 
    for (int i = 0; i < getTamanoVector(); i++)
    {
        // le asignamos a la variable temp el valor de la posicion i del vector 
        temp = getVector(i);
        // si el valor de temp es menor al valor de la variable men 
        if (temp < men)
        {
            // le asignamos a la variable men el valor de temp 
            men = temp;
        }
    }
    // retornamos el valor de men 
    return men;
}

// método para cambiar dos posiciones del vector 
void Estatuas::cambiar(int p1, int p2)
{
    // inicializamos una variable de tipo entero llamada temp en el valor que hay en posicion p1 del vector 
    int temp = getVector(p1);
    // en la posicion p1 del vector le asignamos el valor de la posicion p2 del vector 
    setVector(p1, getVector(p2));
    // en la posicion p2 del vector le asignamos el valor de la variable temp 
    setVector(p2, temp);
}

// método para ordenar los tamaños de las estatuas 
void Estatuas::ordenar()
{
    // recorremos con el ciclo for el vector 
    for (int i = 0; i < getTamanoVector(); i++)
    {
        // con este otro ciclo recorremos la siguiente posicion del vector 
        for (int j = i+1; j < getTamanoVector(); j++)
        {
            // si la posicion i es mayor a la posicion j del vector 
            if (getVector(i) > getVector(j))
            {
                // entonces cambiamos esas dos posiciones 
                cambiar(i, j);
            }
        }
    }
}

// método para calcular las estatuas requeridas 
int Estatuas::estatuasRequeridas()
{
    // retornamos el valor 
    return (mayorTamano() - menorTamano() + 1) - getTamanoVector();
}

// método para llenar las estatuas faltantes al nuevo vector ordenado 
void Estatuas::llenarEstatuasFaltantes()
{
    // inicializamos una variable de tipo entero llamada tam en el tamaño del vector mas las estatuas requeridas 
    int tam = getTamanoVector()+estatuasRequeridas();
    // inicializamos una variable de tipo entero llamada temp en el valor de la posicion  0 del vector 
    int temp = getVector(0);
    // recorremos el nuevo vector con el ciclo for 
    for (int i = 0; i < tam; i++)
    {
        // si estamos en la primera posicion del vector 
        if (i == 0)
        {
            // le asignamos en la posicion i el valor de temp 
            setVectorOrdenado(i, temp);
        }
        else
        {
            // sino incrementamos el valor de la variable temp 
            temp++;
            // le asignamos en la posicion i el valor de temp 
            setVectorOrdenado(i, temp);
        }
    }
}

// se importa paquete JOptionPane para dibujar un cuadro de dialogo en pantalla
// que muestre información o para llenar información 
import javax.swing.JOptionPane;

public class Main
{
    // método para mostrar el vector 
    public static void mostrar(Estatuas obj, String cadena)
    {
        String datos = cadena;
        // recorremos el vector con el ciclo for 
        for (int i = 0; i < obj.getTamañoVector(); i++)
        {
            // si el llegamos a la ultima posicion del vector cerramos con un corchete 
            if (i == obj.getTamañoVector()-1)
            {
                datos += obj.getVector(i) + "]";
            }
            else
            {
                // sino separamos cada valor del vector con una , 
                datos += obj.getVector(i) + ", ";
            }
        }
        JOptionPane.showMessageDialog(null, datos);
    }

    // método para mostrar todas estatuas ordenadas de 1 en 1 
    public static void mostrarTodo(Estatuas obj)
    {
        String datos = "Todas las estatuas ordenadas de 1 en 1: [";
        // inicializamos una variable de tipo entera llamada tam en la suma del tamaño del vector mas las estatuas requeridas 
        int tam = obj.getTamañoVector()+obj.estatuasRequeridas();
        // recorremos el vector ordenado con el ciclo for 
        for (int i = 0; i < tam; i++)
        {
            // si llegamos a la ultima posicion 
            if (i == tam-1)
            {
                // si el llegamos a la ultima posicion del vector cerramos con un corchete 
                datos += obj.getVectorOrdenado(i) + "]";
            }
            else
            {
                // sino separamos cada valor del vector con una , 
                datos += obj.getVectorOrdenado(i) + ", ";
            }
        }
        JOptionPane.showMessageDialog(null, datos);
    }
    
    public static void main(String[] args)
    {
        // creamos un objeto de la clase Estatuas (Instanciación) 
        Estatuas obj = new Estatuas();
        // pedimos el tamaño del vector 
        int tam = Integer.parseInt(JOptionPane.showInputDialog("Digite tamaño del vector:"));
        // encapsulamos la variable tam 
        obj.setTamañoVector(tam);
        // creamos el vector 
        obj.crearVector();
        // declaramos una variable de tipo entero llamada dato 
        int dato;
        // recorremos el vector con el ciclo for 
        for (int i = 0; i < obj.getTamañoVector(); i++)
        {
            do
            {
                // pedimos el tamaño de la estatua en la posicion i 
                dato = Integer.parseInt(JOptionPane.showInputDialog("Digite tamaño de la estatua " + i));
                // encapsumalos en la posicion la variable dato 
                obj.setVector(i, dato);
            }
            while (dato < 0); // repetiremos esto hasta si el dato es menor a 0 
        }
        //mostramos en pantalla el vector 
        mostrar(obj, "Tamaño de las estatuas de Timmy: [");
        // si el tamaño es mayor a 1 
        if (obj.getTamañoVector() > 1)
        {
            // mostramos las estatuas ordenas y todas las estatuas ordenadas de 1 en 1 
            obj.ordenar();
            mostrar(obj, "Estatuas ordenadas: [");
            obj.crearVectorOrdenado();
            obj.llenarEstatuasFaltantes();
            mostrarTodo(obj);
        }
        // mostramos la cantidad de estatuas necesitadas 
        JOptionPane.showMessageDialog(null, "Se necesitaron " + obj.estatuasRequeridas() + " estatuas para ordenarlas de 1 en 1.");
    }
}

public class Estatuas
{
    // se declaran los atributos privados de la clase 
    private int tamaño;
    private int [] vector;
    private int [] vector_ordenado;
    
    public Estatuas()
    {
        // le asignamos valores por defecto a los atributos de la clase en el constructor 
        tamaño = 0;
        vector = null;
        vector_ordenado = null;
    }
    
    // métodos Setters y Getters 
    public void setTamañoVector(int val)
    {
        tamaño = val;
    }

    public int getTamañoVector()
    {
        return tamaño;
    }

    public void setVector(int pos, int val)
    {
        vector[pos] = val;
    }

    public int getVector(int pos)
    {
        return vector[pos];
    }
    
    public void setVectorOrdenado(int pos, int val)
    {
        vector_ordenado[pos] = val;
    }

    public int getVectorOrdenado(int pos)
    {
        return vector_ordenado[pos];
    }

    // método para crear el vector 
    public void crearVector()
    {
        // le asignamos al vector de tipo entero un tamaño del valor de la variable tamaño 
        vector = new int[tamaño];
    }

    // método para crear el vector donde estaran todas estatuas que se requieren ordenadas de 1 en 1 
    public void crearVectorOrdenado()
    {
        // inicializamos una variable de tipo entero llamada tam en el valor de la variable tam mas
        // el valor del método estatuasRequeridas 
        int tam = tamaño+estatuasRequeridas();
        vector_ordenado = new int[tam];
    }

    // método para calcular el mayor tamaño entre todas las estatuas 
    public int mayorTamaño()
    {
        // inicializamos una variable de tipo entero llamada may en 0 
        int may = 0;
        // declaramos una variable de tipo entero llamada temp 
        int temp;
        // recorremos el vector con el ciclo for 
        for (int i = 0; i < getTamañoVector(); i++)
        {
            // le asignamos a la variable temp el valor de la posicion i del vector 
            temp = getVector(i);
            // si el valor de temp es mayor al valor de la variable may 
            if (temp > may)
            {
                // le asignamos a la variable may el valor de temp 
                may = temp;
            }
        }
        // retornamos el valor de may 
        return may;
    }

    // método para calcular el menor tamaño entre todas las estatuas 
    public int menorTamaño()
    {
        // inicializamos una variable de tipo entero llamada men en el valor que retorne el metodo mayorTamano 
        int men = mayorTamaño();
        // declaramos una variable de tipo entero llamada temp 
        int temp;
        // recorremos el vector con el ciclo for 
        for (int i = 0; i < getTamañoVector(); i++)
        {
            // le asignamos a la variable temp el valor de la posicion i del vector 
            temp = getVector(i);
            // si el valor de temp es menor al valor de la variable men 
            if (temp < men)
            {
                // le asignamos a la variable men el valor de temp 
                men = temp;
            }
        }
        // retornamos el valor de men 
        return men;
    }

    // método para cambiar dos posiciones del vector 
    public void cambiar(int p1, int p2)
    {
        // inicializamos una variable de tipo entero llamada temp en el valor que hay en posicion p1 del vector 
        int temp = getVector(p1);
        // en la posicion p1 del vector le asignamos el valor de la posicion p2 del vector 
        setVector(p1, getVector(p2));
        // en la posicion p2 del vector le asignamos el valor de la variable temp 
        setVector(p2, temp);
    }

    // método para ordenar los tamaños de las estatuas 
    public void ordenar()
    {
        // recorremos con el ciclo for el vector 
        for (int i = 0; i < getTamañoVector(); i++)
        {
            // con este otro ciclo recorremos la siguiente posicion del vector 
            for (int j = i+1; j < getTamañoVector(); j++)
            {
                // si la posicion i es mayor a la posicion j del vector 
                if (getVector(i) > getVector(j))
                {
                    // entonces cambiamos esas dos posiciones 
                    cambiar(i, j);
                }
            }
        }
    }

    // método para calcular las estatuas requeridas 
    public int estatuasRequeridas()
    {
        // retornamos el valor 
        return (mayorTamaño() - menorTamaño() + 1) - getTamañoVector();
    }

    // método para llenar las estatuas faltantes al nuevo vector ordenado 
    public void llenarEstatuasFaltantes()
    {
        // inicializamos una variable de tipo entero llamada tam en el tamaño del vector mas las estatuas requeridas 
        int tam = getTamañoVector()+estatuasRequeridas();
        // inicializamos una variable de tipo entero llamada temp en el valor de la posicion  0 del vector 
        int temp = getVector(0);
        // recorremos el nuevo vector con el ciclo for 
        for (int i = 0; i < tam; i++)
        {
            // si estamos en la primera posicion del vector 
            if (i == 0)
            {
                // le asignamos en la posicion i el valor de temp 
                setVectorOrdenado(i, temp);
            }
            else
            {
                // sino incrementamos el valor de la variable temp 
                temp++;
                // le asignamos en la posicion i el valor de temp 
                setVectorOrdenado(i, temp);
            }
        }
    }
}