Dado un vector de 12 elementos enteros. Haga un algoritmo que muestre dos vectores: uno para mostrar los números positivos y el ultimo para mostrar los números negativos.
#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;
}
}
