UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

INGENIERIA DE SISTEMAS
PRACTICA DIRIGIDA DE ALGORITMICA II

TEMAS: OBJETOS Y ARREGLO DE OBJETOS

PREGUNTAS:

1. ¿Qué se entiende por un TDA?

Un tipo de dato abstracto (TDA) o tipo abstracto de datos (TAD) es un modelo matemático
compuesto por una colección de operaciones definidas sobre un conjunto de datos para el
modelo.

2. ¿Un objeto es una variable?

Un objeto es una variable porque se puede modificar su valor a lo largo del programa.
3. ¿Por qué se definen los arreglos de objetos?
Se definen cuando se tiene la necesidad de trabajar con una lista de objetos.
4. ¿Cómo se sabe si se necesita un arreglo de objetos?
Si es que se necesita usar una lista de objetos.
5. Mencione los pasos para definir un arreglo de objetos.
1)Objeto[] O
2)O=new Objeto[tamaniodelvector]
Luego de esto se ha creado un vector de objetos que tiene valor NULL;

DESARROLLAR:

EJERCICIO 1:
En un descentralizado de fútbol se presentan 12 equipos. Cada equipo pertenece a un club y es
dirigido por un director técnico; además el club tiene su presidente y un estadio donde juega, y los
puntos acumulados, presentar a los equipos en orden de sus puntos..
1.
Equipos de futbol
CLASE BASE
Clase Equipo
{ Cadena club
Cadena dt
Cadena presi
Cadena est
Entero punto

Equipo ()
{ club  “ “
dt  “ “
presi  “ “
 est  “ ”
punto  0
}

setClub (cadena a)
{ club  a }

cadena getClub ()
{ retorna club }

setDt (cadena b)
{ dt  b }

cadena getDt ()
{ retorna dt }

setPresi (cadena c)
{ presi  c }

cadena getPresi ()
{ retorna presi }

setEst (cadena d)
{ est  d }

cadena getEst ()
{ retorna est }

setPunto (entero e)
{ punto  e }

cadena getPunto ()
{ retorna punto }

Ingresar ()
{ Escribir (“ingrese el nombre del club: “)
Leer (club)
Escribir (“ingrese el nombre del director técnico: “)
Leer (club)
Escribir (“ingrese el nombre del presidente del club: “)
Leer (club)
Escribir (“ingrese el nombre del estadio que jugo: “)
Leer (club)
Escribir (“ingrese los puntos obtenidos: “)
Leer (club)
}
 MostrarDatos ()
{ Escribir (“El nombre del club es: “, club)
Escribir (“El nombre del director técnico es: “, dt)
Escribir (“El nombre del presidente del club es: “, presi)
Escribir (“El nombre del estadio que jugo es: “, est)
Escribir (“Los puntos obtenidos son: “, punto)
}
}

Clase Descentralizado
{ Equipo equi [ ]
Entero i
Entero tamaño

Descentralizado (entero a)
{ tamaño  a
i0
equi  new Equipo [ tamaño]
}

AgregarEquipo()
{ Escribir (“******INGRESO DE DATOS******”)
Equipo aux
Para k desde 0 hasta tamaño
Escribir (“Digite los datos del club “, (k+1))
Aux  new Equipo()
Aux.Ingresar()
equi[k]  aux
i++
k++
Finpara
}

Ordena rPuntos()
{ Equipo aux
Para j desde 0 hasta tamaño
Para k dese j+1 hasta tamaño
Si (equi.[j].getPunto() < equi.[k].getPunto())
aux  new Equipo()
aux  equi[j]
equi[j]  equi[k]
equi[k]  aux
Finsi
k++
Finpara
 j++
Finpara

MostrarDatos()
{ Escribir (“******DATOS DE LOS ESTUDIANTES******”)
Para j desde 0 hasta i
Equi[j].Mostrardatos()
j++
Finpara
}
}

Clase Principal
{ main()
{ Descentralizado obj  new Descentralizado(12)
Obj.AgregarEquipo()
Obj.OrdenarPuntos()
Obj.MostrarDatos()
}
}

EJERCICIO 2:
Una empresa tiene unos 20 trabajadores, cada registra su código, nombre, horas trabajadas y
cargo, según el cargo se le paga, si es obrero 100 por hora, si es empleado el doble y si es asesor
el triple. Presentar en un reporte los datos de los trabajadores y su sueldo.

Clase Base

Clase Trabajador{

Privado:

cadena codigo

cadena nombret

entero horas

cadena cargo

entero paga
Publico:

Trabajador(){

codigo=””

nombret=””

horas=0

cargo=””

paga=0

set.codigo(cadena c){

codigo=c

cadena get.codigo(){

retorna codigo

set.nombret(cadena n){

código=n

cadena get.nombret(){

retorna nombret

set.horas(entero h){

horas=h

entero get.horas(){

retorna horas

}
set.cargo(cadena car){

cargo=car

cadena get.cargo(){

retorna cargo

Ingresar(){

escribir(“Ingrese codigo”)

leer(codigo)

escribir(“Ingrese nombre”)

leer(nombret)

escribir(“Ingrese horas trabajadas”)

leer(horas)

escribir(“Ingrese cargo”)

leer(cargo)

Pagar(){

Si (cargo==obrero)

Paga=horasx100

Sino si (cargo==empleado)

Paga=horasx200

Sino si (cargo==operario)

Paga=horasx300

Sino

escribir(“Cargo no valido, hable con el administrador para recibir su paga”)

Fin si
}

Mostrar(){

escribir(“Codigo, nombre, horas trabajadas, cargo, salario”)

escribir(código, nombret, horas, cargo, paga)

Clase Empresa{

Trabajador[] tr

entero i

entero t

empresa (entero m){

t=m

tr=new Trabajador[m]

i=0

adicionar_trabajador(Trabajador A){

si (i<t)

tr[i]=a

i++

sino escribir (“vector lleno”)

fin si

Mostrar1(){

Para j desde 0 hasta i

tr[j].mostrar()
Fin para

Clase Principal{

main(){

Empresa obj=new Empresa(5)

Trabajador A=new Trabajador()

A.Ingresar()

obj.adicionar_trabajador(A)

obj.Mostrar1()

EJERCICIO 3:
Gestión de unos cursos escolares.
Se considera una cantidad de 5 cursos con sus respectivos profesores, consideramos en cada
curso información referente a si esta activo o no, presentar los cursos que están activos y los que
no lo están, con sus datos.
Clase cursos{

Privado:

cadena nombrec

cadena profe

cadena act

Publico:

cursos(){

nombrec=””

profe=””

act=””
 }

cadena: getNombrec(){ return nombrec}

procedimiento: setNombrec(cadena nombre){ nombrec ← nombre}

cadena: getProfe(){ return profe}

procedimiento : setProfe(profe1){ profe←profe}

cadena: getAct(){ return nombrec}

procedimiento: setAct(cadena act1){act ←act1}

Procedimiento :ingresar(){

escribir(“Ingrese nombre del curso”)

leer(nombre)

escribir(“Ingrese nombre del profesor es ”)

leer(profe)

escribir(“El curso esta activo?”)

leer(act)

Procedimiento :Mostrar(){

escribir(“El curso es : ”+nombrec)

escribir(“Su nombre del profesor es: ”+profe)

esciribir(“El estado del curso es ”+act)

Clase unidad{

Privado:

Cursos [] cur

Entero i
 Entero t

Publico:

Procedimento Unidad(){

i←0

t←4

cur=new Cursos[t]

Cursos[]: getCur(){ return cur }

Entero: getI(){ return i}

Entero: getT(){ return t}

Procedimiento: adicionarCurso(){

Cursos Auxi

Escribir(“Ingreso de datos”)

Para(i←0 Hasta t-1 t++){

Escribir(“Ingrese datos del curso “ +(i+1));

Auxi=new Cursos();

Auxi.ingresar()

cur[k] ←auxi

i++

Clase Principal{

Procedimiento: Main(){

Unidad obj=new Unidad()

 obj.adicionarCurso()

obj.MostrarA()