Ejercicio 22

#include <iostream>
// se incluye la clase Calcular para despues llamar a sus metodos 
#include "Calcular.h"

using namespace std;

// implementacion del metodo para mostrar los numeros positivos 
void mostrarPositivos(Calcular* obj)
{
    cout << "DATOS POSITIVOS:" << endl;
    // recorremos con el ciclo for hasta el tamaño del vector que contiene los numeros positivos 
    for(int i = 0; i < obj->getTamPos(); i++)
    {
        cout << obj->getPositivos(i) << " ";// mostramos en pantalla los valores positivos del vector 
    }
    cout << endl;// saltamos una linea para que no quede todo en una sola linea... 
}

// implementacion del metodo para mostrar los numeros negativos 
void mostrarNegativos(Calcular* obj)
{
    cout << "DATOS NEGATIVOS:" << endl;
    // recorremos con el ciclo for hasta el tamaño del vector que contiene los numeros negativos 
    for(int i = 0; i < obj->getTamNeg(); i++)
    {
        cout << obj->getNegativos(i) << " ";// mostramos en pantalla los valores negativos del vector 
    }
}

int main(void)
{
    // se crea un objeto de la clase Calcular (Instanciaciación) 
    Calcular *obj = new Calcular();
    int n;// se define una variable de tipo n llamada "n" 
    for(int i = 0; i < 12; i++)// con el ciclo for pediremos 12 veces los datos 
    {
        // pedimos el numero de la posicion "i" 
        cout << "Digite numero de la posicion " << i << endl;
        cin >> n;// guardamos el numero en "n" 
        obj->setNum(i, n);// encapsulamos la variable "n" 
    }
    obj->contar();// llamamos al metodo contar() 
    obj->clasificar();// llamamos al metodo clasificar() 

    mostrarPositivos(obj);// llamamos al metodo mostrarPositivos() y le pasamos un objeto de la clase Calcular (obj) 
    mostrarNegativos(obj);// llamamos al metodo mostrarNegativos() y le pasamos un objeto de la clase Calcular (obj) 
}
     

#ifndef CALCULAR_H
#define CALCULAR_H


class Calcular
{
    public:
        Calcular();
        virtual ~Calcular();

        // se definen los metodos publicos: 
        // metodo contar(), sera el que cuente el tamaño de los vectores: "positivos" y "negativos" 
        void contar();
        // metodo para clasificar los numeros negativos y positivos 
        void clasificar();
        // metodos Setters y Getters de la clase... 
        void setNum(int pos, int val);
        int getNum(int pos);
        void setPositivos(int pos, int val);
        int getPositivos(int pos);
        void setNegativos(int pos, int val);
        int getNegativos(int pos);
        void setTamPos(int n);
        int getTamPos();
        void setTamNeg(int n);
        int getTamNeg();

    protected:

    private:// se definen 5 atributos y 1 metodo privados: 
        // crearVectores() y necesitara de dos parametros: "pos" para el tamaño del vector
        // "positivos" y "neg" para el de "negativos" 
        void crearVectores(int pos, int neg);
        int *num;// 1 vector de tipo entero llamado "num" con 12 posiciones 
        int *positivos;// 1 vector de tipo entero llamado "positivos" 
        int *negativos;// 1 vector de tipo entero llamado "negativos" 
        int pos;// una variable de tipo entero llamada "pos" 
        int neg;// una variable de tipo entero llamada "neg" 
};

#endif // CALCULAR_H 
     

#include "Calcular.h"

// implementacion del constructor de la clase Calcular 
Calcular::Calcular()
{
    // se le asignan por defecto los siguiente valores: 
    num = new int [12];// a "num" se le asigna un tamaño de 12 posiciones 
    pos = 0;// a pos se le asigna 0 
    neg = 0;// a neg se le asigna 0 
}

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

// implementacion del metodo para crear los vectores "positivos" y "negativos" 
void Calcular::crearVectores(int pos, int neg)
{
    // al vector "positivos" le asignamos el tamaño que haya en la variable "pos" 
    positivos = new int [pos];
    // al vector "negativos" le asignamos el tamaño que haya en la variable "neg" 
    negativos = new int [neg];
}

// implementacion del metodo para contar el tamaño de los vectores: "positivos" y "negativos" 
void Calcular::contar()
{
    // se recorre el vector "num" 
    for(int i = 0; i < 12; i++)
    {
        // si el valor en la posicion "i" del vector "num" es menor que 0, entonces: 
        if(num[i] < 0)
        {
            // la variable neg incrementa 
            neg++;
        }
        else// sino 
        {
            // la variable pos incrementa 
            pos++;
        }
    }
    // se llama al metodo crearVectores() y le asignamos los parametros "pos" y "neg" que seran los
    // tamaños de los vectores "positivos" y "negativos" 
    crearVectores(pos, neg);
    // se llama el metodo setTamPos() y le asignamos pos, sera el tamaño que hay en el vector "positivos" 
    setTamPos(pos);
    // se llama el metodo setTamNeg() y le asignamos pos, sera el tamaño que hay en el vector "negativos" 
    setTamNeg(neg);
}

// implementacion del  metodo para clasificar los numeros negativos y positivos en sus respectivos vectores 
void Calcular::clasificar()
{
    // se definen las variable aux1 y aux2 
    int aux1, aux2;
    // le asignamos a aux1 y aux2 el valor de 0 
    aux1 = 0;
    aux2 = 0;

    // recorremos el vector "num" con el ciclo for 
    for(int i = 0; i < 12; i++)
    {
        // si el valor en la posicion "i" del vector "num" es menor que 0, entonces: 
        if(num[i] < 0)
        {
            // en la posicion aux1 del vector "negativos" se le asigna el valor que hay en la
            // posicion "i" del vector "num" 
            negativos[aux1] = num[i];
            // se incrementa aux1 
            aux1++;
        }
        else// sino 
        {
            // en la posicion aux2 del vector "positivos" se le asigna el valor que hay en la
            //posicion "i" del vector "num" 
            positivos[aux2] = num[i];
            // se incrementa aux2 
            aux2++;
        }
    }
}

// implementacion de los metodos Setters y Getters de los atributos de la clase 
void Calcular::setNum(int pos, int val)
{
    num[pos] = val;
}

int Calcular::getNum(int pos)
{
    return num[pos];
}

void Calcular::setPositivos(int pos, int val)
{
    positivos[pos] = val;
}

int Calcular::getPositivos(int pos)
{
    return positivos[pos];
}

void Calcular::setNegativos(int pos, int val)
{
    negativos[pos] = val;
}

int Calcular::getNegativos(int pos)
{
    return negativos[pos];
}

void Calcular::setTamPos(int n)
{
    pos = n;
}

int Calcular::getTamPos()
{
    return pos;
}

void Calcular::setTamNeg(int n)
{
    neg = n;
}

int Calcular::getTamNeg()
{
    return neg;
}
     

// 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
{
    public static void main(String[] args)
    {
        // se crea un objeto de la clase Calcular (Instanciaciación) 
        Calcular obj = new Calcular();
        int n;// se define una variable de tipo n llamada "n" 
        for(int i = 0; i < 12; i++)// con el ciclo for pediremos 12 veces los datos 
        {
            // guardamos los datos en la variable "n" y los convertimos a enteros con el metodo parseInt() 
            n = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite numero de la posicion " + i));
            obj.setNum(i, n);// encapsulamos la variable "n" 
        }
        obj.contar();// llamamos al metodo contar() 
        obj.clasificar();//llamamos al metodo clasificar() 
        mostrarPositivos(obj);// llamamos al metodo mostrarPositivos() y le pasamos un objeto de la clase Calcular (obj) 
        mostrarNegativos(obj);// llamamos al metodo mostrarNegativos() y le pasamos un objeto de la clase Calcular (obj) 
    }
    
    // implementacion del metodo para mostrar los numeros positivos 
    public static void mostrarPositivos(Calcular obj)
    {
        // se definen la variable datosVector de tipo string y se le asigna " " 
        String datosVector = "";
        
        // recorremos con el ciclo for hasta el tamaño del vector que contiene los numeros positivos 
        for(int i = 0; i < obj.getTamPos(); i++)
        {
            // acumularemos la variable datosVector con los datos que haya en getPositivos(i) 
            datosVector = datosVector + String.valueOf(obj.getPositivos(i) + " ");
        }
        // se muestra el valor acumulado en datosVector en un mensaje de dialogo 
        JOptionPane.showMessageDialog(null, "DATOS POSITIVOS:\n" + datosVector);
    }
    
    // implementacion del metodo para mostrar los numeros negativos 
    public static void mostrarNegativos(Calcular obj)
    {
        // se definen la variable datosVector de tipo string y se le asigna " " 
        String datosVector = "";
        
        // recorremos con el ciclo for hasta el tamaño del vector que contiene los numeros negativos 
        for(int i = 0; i < obj.getTamNeg(); i++)
        {
            // acumularemos la variable datosVector con los datos que haya en getNegativos(i) 
            datosVector = datosVector + String.valueOf(obj.getNegativos(i) + " ");
        }
        // se muestra el valor acumulado en datosVector en un mensaje de dialogo 
        JOptionPane.showMessageDialog(null, "DATOS NEGATIVOS:\n" + datosVector);
    }
}
     

public class Calcular
{
    // se definen los atributos privados:
    private int[] num;// 1 vector de tipo entero llamado "num"
    private int[] positivos;// 1 vector de tipo entero llamado "positivos"
    private int[] negativos;// 1 vector de tipo entero llamado "negativos"
    private int pos;// una variable de tipo entero llamada "pos"
    private int neg;// una variable de tipo entero llamada "neg"
    
    // implementacion del constructor de la clase Calcular
    public Calcular()
    {
        // se le asignan por defecto los siguiente valores:
        num = new int [12];// a "num" se le asigna un tamaño de 12 posiciones
        pos = 0;// a pos se le asigna 0
        neg = 0;// a neg se le asigna 0
    }
    
    // implementacion del metodo privado para crear los vectores para los positivos y negativos
    private void crearVectores(int pos, int neg)
    {
        // al vector "positivos" le asignamos el tamaño que haya en la variable "pos"
        positivos = new int [pos];
        // al vector "negativos" le asignamos el tamaño que haya en la variable "neg"
        negativos = new int [neg];
    }
    
    // implementacion del metodo para contar el tamaño de los vectores: "positivos" y "negativos"
    public void contar()
    {
        // se recorre el vector "num"
        for(int i = 0; i < 12; i++)
        {
            // si el valor en la posicion "i" del vector "num" es menor que 0, entonces:
            if(num[i] < 0)
            {
                // la variable neg incrementa
                neg++;
            }
            else // sino
            {
                // la variable pos incrementa
                pos++;
            }
        }
        // se llama al metodo crearVectores() y le asignamos los parametros "pos" y "neg" que seran los
        // tamaños de los vectores "positivos" y "negativos"
        crearVectores(pos, neg);
        
        // se llama el metodo setTamPos() y le asignamos pos, sera el tamaño que hay en el vector "positivos"
        setTamPos(pos);
        
        // se llama el metodo setTamNeg() y le asignamos pos, sera el tamaño que hay en el vector "negativos"
        setTamNeg(neg);
    }
    
    // implementacion del  metodo para clasificar los numeros negativos y positivos en sus respectivos vectores
    public void clasificar()
    {
        // se definen las variable aux1 y aux2
        int aux1, aux2;
        // le asignamos a aux1 y aux2 el valor de 0
        aux1 = 0;
        aux2 = 0;
        
        // recorremos el vector "num" con el ciclo for
        for(int i = 0; i < 12; i++)
        {
            // si el valor en la posicion "i" del vector "num" es menor que 0, entonces:
            if(num[i] < 0)
            {
                // en la posicion aux1 del vector "negativos" se le asigna el valor que hay en la
                // posicion "i" del vector "num"
                negativos[aux1] = num[i];
                // se incrementa aux1
                aux1++;
            }
            else // sino
            {
                // en la posicion aux2 del vector "positivos" se le asigna el valor que hay en la
                // posicion "i" del vector "num"
                positivos[aux2] = num[i];
                // se incrementa aux2
                aux2++;
            }
        }
    }
    
    // implementacion de los metodos Setters y Getters de los atributos de la clase
    public void setNum(int pos, int val)
    {
        num[pos] = val;
    }
    
    public int getNum(int pos)
    {
        return num[pos];
    }
    
    public void setPositivos(int pos, int val)
    {
        positivos[pos] = val;
    }
    
    public int getPositivos(int pos)
    {
        return positivos[pos];
    }
    
    public void setNegativos(int pos, int val)
    {
        negativos[pos] = val;
    }
    
    public int getNegativos(int pos)
    {
        return negativos[pos];
    }
    
    public void setTamPos(int n)
    {
        pos = n;
    }
    
    public int getTamPos()
    {
        return pos;
    }
    
    public void setTamNeg(int n)
    {
        neg = n;
    }
    
    public int getTamNeg()
    {
        return neg;
    }
}