TALLER # 1:

Dado dos vectores A y B de tamaño n y p respectivamente, se desea crear un tercer vector resultante a
partir de A y B, dicho vector resultante debe contener los valores NO COMUNES (es decir, los valores
de A que no estén en B y los de B que no estén en A), a su vez, debe quedar ordenado en la media en
que se va construyendo dicho vector y además no podrá contener valores repetidos.

Diseñar clase:

Clase Nocomunes
{
//Atributos
Entero: vec[ ], n, i

//Definicion de métodos

//Metodo constructor: permite inicializar los atributos de la clase, y segundo, crear o

//instalar objetos en memoria
//Cada que se instancia una clase (que se crea un objeto), se invocara el constructor por
//defecto (constructor por defecto es aquel que tiene el mismo nombre de la clase).
//Una clase puede tener varios métodos constructores, se invocara a aquel que coincida
// con el numero de parámetros al momento de instanciar la clase
// Tanto el método constructor como el método destructor no retorna ningún tipo de
//dato, ni siquiera void (ni siquiera nulo)

Nocomunes(Entero: 7+5)
{
n=12 //1) se inicializa el tamaño del vector
vec = nuevo entero[n] //2) creando el objeto vector en memoria
}

// Metodo destructor
//Lo que hace es liberar el espacio ocupado por los objetos creados en memoria
~Nocomunes( )
{
Eliminar(vec)
}

nulo Crear_vector()
{
Para (i=1, n, 1) haga
Imprima: “Ingrese un valor en la posición:”, i
Lea vec[i]
FinPara
}

nulo Imprirmir_vector(Entero: tam)

{
Para (i=1, tam, 1) haga
Imprima: vec[i]
FinPara
}
nulo Ordenar_vector() //Burbuja
{
Entero: j, aux
Para (i=1, n-1, 1) haga
Para (j=1, n-i, 1) haga
Si (vec[j] < vec[j+1]) entonces
aux = vec[j]
vec[j] = vec[j+1]
vec[j+1] = aux
FinSi
FinPara
FinPara
}
/*
nulo Ordenar_vector() //Seleccion
{
Entero: j, aux
Para (i=1, n-1, 1) haga
Para (j=i+1, n, 1) haga
Si (vec[i] < vec[j]) entonces
aux = vec[i]
vec[i] = vec[j]
vec[j] = aux
FinSi
FinPara
FinPara
}
*/

nulo UnirNocomunes(Nocomunes B)
{
Entero: j=1, k=0, val,swA=0, swB=0,sw=0 //con J recorro el vector B y con K recorro el vector C
Nocomunes C = nuevo Nocomunes(n+B.n)

vec[ . . . . . . . . . . . .], n=12, i

C Nocomunes(),~Nocomunes(), Crear_vector(), Imprimir_vector(), Ordenar_vector()

i=1 //para recorrer el vector A

Mientras (i <= n and j<=B.n) haga
Si (vec[i] = B.vec[j]) entonces
i = i +1
j=j+1
Sino
Si (vec[i] < B.vec[j] ) entonces
Si (swA=0) entonces //significa que es el primer valor del vector A
val = vec[i]
swA = 1
sw=0
Sino
Si (vec[i] <> vec[i-1])entonces //significa que el valor A ya no es primer valor
val = vec[i]
sw=0
 Sino
sw=1 // signica que el valor vec[i] se repite en la posicion vec[i-1]
FinSi
FinSi
i=i+1
Sino
Si (swB=0) entonces //significa que es el primer valor del vector B
val = B.vec[j]
swB = 1
sw=0
Sino
Si (B.vec[j] <> B.vec[j-1])entonces //significa que el valor B no es primer valor
val = B.vec[j]
sw=0
Sino
sw=1
FinSi
FinSi
j=j+1
FinSi
Si (sw=0) entonces // valida que no tenga un valor anterior repetido
Si (k = 0) entonces
k=k+1
C.vec[k] = val
Sino
Si (val <> C.vec[k]) entonces
k=k+1
C.vec[k] = val
FinSi
FinSi
FinSi
FinSi
FinMQ
Si (i <= n) entonces
Mientras (i <= n) haga
k=k+1
C.vec[k] = vec[i]
i=i+1
FinMQ
Sino
Mientras (j <= B.n) haga
k=k+1
C.vec[k] = B.vec[j]
j=j+1
FinMQ
FinSi
C.Imprimir_vector(k)
}
} // fin de la clase
Diseñar programa principal (es otra clase):

Inicio
Entero: n, p
Imprima: “Ingrese el tamaño del vector A:”
Lea n=7
Imprima: “Ingrese el tamaño del vector B:”
Lea p=5
//Vamos a instanciar la clase (es decir, vamos a crear los objetos A y B)
//Sintaxis: NombClase NombObj = nuevo NombClase([parámetros])
Nocomunes A = nuevo Nocomunes(n)
Nocomunes B = nuevo Nocomunes(p)

A vec[ , , , , , , ,], n=7, i

Nocomunes(),~Nocomunes(), Crear_vector(), Imprimir_vector(), Ordenar_vector()

B vec[ , , , , ,], n=5, i

Nocomunes(),~Nocomunes(), Crear_vector(), Imprimir_vector(), Ordenar_vector()

//Como ejecutar un método de la clase

//Sintaxis: <NombObj>.<Nombmetodo([Parametros])>

//Vamos a crear el vector A (llenar el vector de valores)

A.Crear_vector( ) // vec=[6,7,1,2,3,8,5]
A.Imprimir_vector(n) // 6,7,1,2,3,8,5

//Vamos a crear el vector B (llenar el vector de valores)

B.Crear_vector( ) // vec=[5,6,3,4,1]
B.Imprimir_vector(p) // 5,6,3,4,1

--------------------------------1er Piso---------------------------------

// Vamos a ordenar el vector A

A.Ordenar_vector( )  vec=[1,2,3,5,6,7,8]
A.Imprmir_vector(n)  1,2,3,5,6,7,8

// Vamos a ordenar el vector B

B.Ordenar_vector( )  vec=[1,3,4,5,6]
B.Imprmir_vector(p)  1,3,4,5,6

--------------------------------2do Piso---------------------------------
 A.UnirNocomunes(B)

Ejemplos:
// A = nuevo int[n]
// A = nuevo int[n][m]
// A = nuevo Nocomunes(n) (se creo un objeto del tipo de la clase)

Compromiso:
- Hacer la prueba de escritorio al metodo UnirNocomunes()
- Codificar el ejercico en java
- Consultar sobre el metodo Get, Set (POO)

Inicio // programa principal

//----------------------- Termina segundo piso

A.UnirNocomunes(B)