Apuntes Duoc UC

Todo lo necesario para sobrevivir en la carrera de Ing. en Informática, Vespertino

21 jun. 2009

Ingenierìa de software

Acabo de crear un Wiki para subir el material de Ingeniería de Software

Encontré que el uso de Blog era poco colaborativo y algo egoísta, el WIKI en cambio es un mecanismo de colaboración para desarrollar contenido entre todos y sin censura.

Voy a ir subiendo el material que entrega el profe y desarrollar las tareas desde el enunciado hasta la entrega, pasando por los modelos de clases y todos los artefactos UML.

Espero que sea sólo la piedra basal para construir conocimiento entre todos.

El enlace en http://ingsw.pbworks.com

Aquí voy a subir contenido para la mayoría de los ramos!

23 sept. 2007

Sistema par manejo de notas


Un colegio necesita que se construya un sistema para la toma de ramos y el manejo de notas de sus alumnos.
La información que se maneja es:

De cada alumno se conoce:
• Nombre.
• Numero de matricula (generado por el sistema y correlativo).
• y un arreglo de las asignaturas que ha tomado este semestre.

Por su parte cada asignatura cuenta con la siguiente información:
• Nombre de la asignatura.
• Profesor que la imparte.
• Creditos.
• Y un arreglo de las notas obtenidas por el alumno durante el semestre.

Cada nota corresponde a un objeto que tiene dos atributos,
• la nota y
• su valor en porcentaje.

El sistema debe permitir:
• Ingresar Alumno
• Tomar ramos.
• Eliminar ramos.
• Modificar ramos.
• Ingresar notas.
• Ver promedios.
• Salir.

Se destaca en negrita los sustantivos que indican una clase y se señalan sus atributos.
Esto nos permite aplicar el siguiente método para resolver el problema;
- Distinguimos entre los sustantivos que se convierten en clases y que sostienen el desarrollo de la aplicación. Tienen las siguientes características;
• Todos sus atributos son privados
• El acceso a los atributos se realizan mediante métodos públicos (getters y setters)
• La interacción se realiza mediante una clase adicional, con métodos estáticos.

Esta clase adicional corresponde a la clase que actúa como interfaz con el usuario del sistema y contiene por lo general;
• El método "main"
• Un menu con opciones
• Un bloque "switch" para tomar decisiones.

La mejor estrategia es comenzar por las clases más pequeñas, en este caso "Notas" que luego es utilizada por la clase
Asignatura;
La clase Notas tiene dos atributos, que definimos como privados y para los que construimos los respectivos "get" y "set", además creamos un constructor vacío y uno (sobrecarga) con la carga de los atributos.

/**
* @(#)Nota.java
*
*
* @author
* @version 1.00 2007/9/22
*/


public class Nota {
private double valorNota;
private double valorPorcentaje;

public Nota() {
valorNota = 0;
valorPorcentaje = 0;
}

public Nota( double nota, double porc ) {
this.valorNota = nota;
this.valorPorcentaje = porc;
}

// ------------------ getter y setter
public double getNota( ) {
return this.valorNota;
}

//
public double getPorcentaje( ) {
return this.valorPorcentaje;
}

//
public void setNota( double nota ) {
this.valorNota = nota;
}

public void setPorcentaje( double porc ) {
this.valorPorcentaje;
}

}

Luego creamos la clase Asignatura, con los constructores apropiados (uno vacio y uno con la carga de atributos) tres atributos "normales" y un ArrayList con el objeto "Notas" construido previamente.
/**
* @(#)Asignatura.java
*
*
* @author
* @version 1.00 2007/9/22
*/
import java.util.ArrayList;

public class Asignatura {
private String nombre; // Nombre de la asignatura
private String profesor;
private int numCreditos;
private ArrayList notasAlumno;

public Asignatura() {
nombre = null;
profesor = null;
numCreditos = 0;
ArrayList notasAlumno = new ArrayList();
}

public Asignatura( String nombre, String profe, int creditos ) {
this.nombre = nombre;
this.profesor = profe;
this.numCreditos = creditos;
ArrayList notasAlumno = new ArrayList();
}


// ------------------ getter y setter
public String getNombre( ) {
return this.nombre ;
}

public String getProfesor( ) {
return this.profesor;
}

public int getCreditos( ) {
return this.numCreditos;
}

//_--------
public void setNombre( String nombre ) {
this.nombre = nombre;
}

public void setProfesor( String profe ) {
this.profesor = profe;
}

public void setCreditos( int creditos ) {
this.numCreditos = creditos;
}

}

Nos falta la clase Alumno, que la construyo más adelante.

Seguimos con el Menu;
El Menu se prepara creando una clase de tipo "Interfaz" llamada "appRamo" donde "main()" hace lo siguiente;
- llama al menu
- segun la opcion, llama a la acción apropiada
- si la opcion es salir, despedirse y salir
- si no, volver a mostrar el menu

/**
* @(#)appRamos.java
*
*
* @author
* @version 1.00 2007/9/22
*/
import java.util.ArrayList;


public class appRamos {


public static void main (String [] arg)
{
int opc;
opc = mainMenu();

switch ( opc ) {
case 1:
ingresaAlumno();
break;
case 2:
break;
case 3:
break;
case 0:
System.out.println("Gracias...");
break;

} // switch
} // main

public static int mainMenu ()
{
int op;

System.out.println("Ingreso de Datos");
System.out.println("1.- Ingresar Alumno");
System.out.println("2.- Tomar ramos");
System.out.println("3.- Eliminar ramos");
System.out.println("4.- Modificar ramos");
System.out.println("5.- Ingresar notas");
System.out.println("6.- Ver promedios");
System.out.println("0.- Salir");

do {
System.out.print("\nIngrese opcion: ");
op = Leer.datoInt();
} while ((op <> 6));

} // main

private static void ingresaAlumno()
{
String strNombre;
String strRut;
Alumno a;

System.out.println("Ingrese Nombre");
strNombre =Leer.dato();

System.out.println("Ingrese rut ");
strRut = Leer.dato();

Alumno a=new Alumno(strNombre,strRut );
curso.add(uno);

} // ingresaAlumno()
}

En la noche sigo completando el programa...

Continuara....

16 ago. 2007

Bases de Datos; Tarea 1, Venta de pasaje

La Tarea 1 es diseñar un Modelo E/R que represente la venta de pasajes de una Agencia de Viajes a cualquier destino, y por cualquier medio (aéreo, terrestre o marítimo).
Su modelo debe incluir las Relaciones existentes y la cardinalidad entre ellas: 1-1, 1-n, o n-m según corresponda.
Indicar además las claves o llaves primarias (pk) para cada entidad y las llaves foráneas (fk) en cada relación.

Su modelo debe responder como mínimo las siguientes consultas:
1. Cuáles son los programas nacionales?
2. Que hoteles hay en Europa?
3. Cual fue el último viaje de un cliente?
4. Cual fue el destino mas solicitado?
5. Cómo puedo pagar el viaje?
6. Hay clientes morosos?
7. Dónde puedo comprar un pasaje?


Solución


Primero hay que reconocer algunas Entidades en los sustantivos de las preguntas;
Programas
Destino
Origen
Hoteles
Agencia
Pago
Viaje
Cliente
Punto de Venta (donde comprar)
Pasaje
Ciudad (Pais/Continente)


Para construir el modelo, voy a usar DIA (se puede descargar aquí)

Me agota explicar paso-a-paso, asi que voy a poner la solución completa.

11 ago. 2007

Volviendo a clases, segundo semestre

Primera semana de clases, ya conocí a todos los profesores y creo que me llevé una excelente primera impresión de todos.

Este semestre nos toca empezar en serio a programar.
Esta vez el DUOC se aseguró y POO lo enseña Juan Corvalan y Sonia Arriagada, excelentes profesionales y sobre todo, docentes de vocación.

A diferencia de otros profesores, no insisten mucho con el tema asistencia, a diferencia de otros profesores, no se nos pasaría por la cabeza faltar a alguna de sus clases.

Del resto de los profesores que me tocaron, cero falta, todos saben muy bien su tema y con algunos matices, se nota que este semestre, sí vamos a aprender!

A diferencia del semestre pasado, no creo que pueda eximirme de algùn ramo y parece que de verdad me voy a aburrir en algunos como álgebra y ética.

Así que.. de nuevo a correr entre los horarios, de nuevo a llegar tarde, de nuevo a tratar de equilibrar la vida entre la familia, los estudios y el trabajo y si alcanza el tiempo, respirar.

A todos mis compañeros, les deseo la mejor de las suertes

¡Animo!

16 jul. 2007

Clase animal

POR FIN TERMINE!


El profe dejo el siguiente ejercicio que, según él, se parece a lo que va a preguntar en el examen.
  1. Construir una clase Animal que tiene como atributos(80 Ptos):

  • tipo de animal (puede ser Vaca, Gallina o Cabra)

  • producción: array de largo 30 que guardará la producción diaria del animal (se asumirá que el mes tiene 30 días y los datos se obtendrán en forma aleatoria en el rango 0 a 10 extremos inclusive)

  • valor: guardará el valor por el litro de leche o de un huevo dependiendo del caso, según la siguiente tabla :

Tipo Animal

Vaca

Gallina

Cabra

Valor

150

30

110

La clase tiene además los siguientes métodos:

  • constructor sin parámetros

  • constructor con parámetros que reciba el tipo de animal, e inicialice el array

  • accesador para tipo de animal y valor

  • método de impresión que imprima el tipo de animal, la producción diaria y el valor.

  • comer: este método aumenta la producción en un 20% de lo ingerido en el día que comió, es decir debe recibir el número del día y la cantidad comida.


Incluyo la solución para la clase Animal y al final la segunda parte del ejercicio;


/**
*
* @author Chubasco
*/

import java.io.*;

public class Animal
{
// atributos
private int tipo;
private int[] produccion; // array de largo 30 que guardará
// la producción diaria del animal
private double valor; // valor por el litro de leche o de un huevo
static final int numDias = 30; // var auxiliar

// ---------------------------------------------------------- //
/**
* Constructor
*/
// ---------------------------------------------------------- //
public Animal()
{
tipo = 0;
valor = 0;
produccion = new int[numDias];
for (int i=0; i < numDias; i++)
produccion[i]= 0;
}

// ---------------------------------------------------------- //
/**
* Constructor, recibe como parametro el tipo
* de animal según la sgte tabla
* 0 : gallina
* 1 : cabra
* 2 : vaca
*/
public Animal( int pTipoDeAnminal)
{
switch (pTipoDeAnminal) {
case(0) : tipo = 0;
valor = 30;
break;
case(1) : tipo = 1;
valor = 110;
break;
case(2) : tipo = 2;
valor = 150;
break;
} // end switch
produccion = new int[numDias];
/**
* Crea en forma aleatoria la produccion
* se escogen en forma aleatoria en el rango 0 a 10
*/
for (int i=0; i < numDias; i++){
// random()*11 = 0 - 10,999999999
produccion[i]= (int) (Math.random()*11);
} // for
} // constructor

/**
* mostrarInformacion
*/
public void mostrarInformacion() {
String info="";
System.out.print( " día : producción : " );
for (int j=0; j < this.numDias; j++) {
info = (j+1)+ ":" + this.getProduccion(j)
System.out.print( info + " / " );
} //
} // mostrarInformacion




public double getValor(){
return valor;
} // getValor





public int getTipo(){
return tipo;
} // getValor

/*
* 0 : gallina
* 1 : cabra
* 2 : vaca
*/
public String getNombreTipo(){
String retorno="";
switch (tipo) {
case(0) : retorno = "gallina";
break;
case(1) : retorno = "cabra";
break;
case(2) : retorno = "vaca";
break;
} // end switch
return retorno;
} // getValor




/**
*
*/
public int getProduccion( int dia ){
return produccion[dia];
} // getValor

// este método aumenta la producción en un 20% de
// lo ingerido en el día que comió, debe
// recibir el número del día y la cantidad comida.
public void comer( int dia, int cantComida ){
produccion[dia]=produccion[dia]+(int)(cantComida/5);
} // getValor




/**
*
*/
public int totalProduccion(){
int cp=0;

for (int i=0; i < produccion.length; i++)
cp=cp+produccion[i];
return cp;
} // totalProduccion




// verdadero si el numero es impar
private boolean esImpar( int num ) {
return ((num % 2)==1);
}





// totalGanadoDiasImpares
/**
*
*/
public double totalGanadoDiasImpares() {
double ct=0;

for (int i=0; i < produccion.length; i++) {
if ( esImpar(i+1)){ // i=0 corresponde al día 1!
ct = ct + this.getProduccion(i)*this.getValor();
} // endif
}
return ct;
} // totalGanadoDiasImpares



} // fin de la clase animal


Clase menuGranja

Corresponde a la segunda parte del trabajo.
Les recuerdo que en las buenas prácticas de programación, se requiere de, al menos, dos clases;
La clase que Plan que contiene el objeto principal, atributos privados y métodos públicos para "tocar" los datos.
La clase "Test" donde encontramos el menu, las entradas y salidas, las opciones y por supuesto la clase main

La clase "Plan" no debe ser manipulada directamente por el usuario!
La clase "Test" tiene métodos y variables estáticas y es la que se "ve"

Incluyo entonces el menu de esta tarea, que por supuesto, corresponde a una clase de tipo "Test"



/**
* @author Chubasco
*/

import java.io.*;

public class menuGranja
{

final static int maxAnimales = 30;
static int numAnimales = 0;
static Animal inventarioGranja[];

/**
* imprime
*/
private static void imprime( String mensaje){
System.out.print(mensaje);
} // imprimeLn

/**
* imprimeLn
*/
private static void imprimeLn( String mensaje){
System.out.println(mensaje);
} // imprimeLn


/**
*
*/
private static int leeInt(String mensaje )
{
int retorno=0;

System.out.print(mensaje);

try {
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
// resultado
retorno = Integer.parseInt(in.readLine());
}
catch (Exception e) {
System.out.print("Error al leer teclado");
} // fin del try
return (int)retorno;
}





/**
* leeMenu
* Imprime las opciones y entrega como resultado,
* la opcion selecionada
*/
public static int leeMenu( String mensaje, int maximo)
{
int retorno = 0;
do {
retorno = leeInt(mensaje);
} while ((retorno <1) &&(retorno > maximo)) ;
return retorno ;
}




/**
* menu
* Imprime el menu completo opciones y entrega
* como resultado, la opcion selecionada
*/
public static int menu( )
{
imprimeLn("--------------------------------------\n");
imprimeLn(" Granja");
imprimeLn(" ======");
imprimeLn("1.Crear Animal ");
imprimeLn("2.Mostrar Información");
imprimeLn("3.Comer");
imprimeLn("4.Total Producción");
imprimeLn("5.Total ganado días impares");
imprimeLn("6.Salir.");

return leeMenu("Ingresa opción :", 6);
// imprimeLn("------------------------------------------\n\n");
}




// Opción 1
private static void creaAnimal() {
int a=0;
a=inventarioGranja.length;
if (inventarioGranja.length>numAnimales) {
imprimeLn("Tipo de animal?");
a=leeMenu("1) Gallina / 2) Cabra / 3) Vaca [1/2/3]: ",3);
inventarioGranja[numAnimales++] = new Animal(a-1);
} else {
imprimeLn("No se puede seguir agregando animales");
} // endif
}




// opcion 2
private static void mostrarInformacion(){
String linea = "";

// ;
//
for (int i=0; i < numAnimales; i++) {
linea = (inventarioGranja[i].getTipo()+1)+": "
linea = linea + inventarioGranja[i].getNombreTipo();
imprimeLn( linea );
imprime( "Producción para el mes:" );
inventarioGranja[i].mostrarInformacion();
imprimeLn( "/");
} // for
} // mostrarInformacion();






private static void darDeComer( Animal a )
{
int diaComida = 0;
int cantComida = 0;

do {
diaComida = leeInt("Indique el día que comio :");
} while (( diaComida < 1) && ( diaComida > a.numDias));

do {
cantComida = leeInt("Indique la cantidad comida");
} while ( cantComida <= 0);
a.comer(diaComida,cantComida);
} // darDeComer






/**
* mostrarProduccion
*/
private static void mostrarProduccion(){
String linea;
//
imprimeLn( " Mostrar producción total x animal ");
imprimeLn( " ----------------------------------- ");
for (int i=0; i < numAnimales; i++) {
linea = (i+1)+": "+inventarioGranja[i].getNombreTipo();
imprime( linea );
linea = " - Producción total:"
linea = linea + inventarioGranja[i].totalProduccion();
imprimeLn( linea );
imprimeLn( " -------------------------------- ");
} // fin del for
} // fin de mostrarProduccion()





/**
* mostrarProduccionImpares
*/
private static void mostrarProduccionImpares(){
String linea;
//
imprimeLn( " Mostrar ganancia total x animal ");
imprimeLn( " (sólo días impares) ");
imprimeLn( " ----------------------------------- ");
for (int i=0; i < numAnimales; i++) {
linea = (i+1)+": "+inventarioGranja[i].getNombreTipo()
imprime( linea );
linea = " - Ganancia días impares:";
linea = linea + inventarioGranja[i].totalGanadoDiasImpares();
imprimeLn( linea );
imprimeLn( " -------------------------------- ");
} // fin de for
} // fin de mostrarProduccionImpares





/**
* Bloque principal
*/
public static void main( String[] args)
{
int opcion=0;
inventarioGranja = new Animal[maxAnimales];

do {
opcion = menu();
switch(opcion) {
case(1) : creaAnimal();
break;

case(2) : mostrarInformacion();
break;

case(3) : if ( numAnimales > 0)
darDeComer(inventarioGranja[numAnimales-1]);
else
imprimeLn("No hay animales...");
break;

case(4) : if ( numAnimales > 0)
mostrarProduccion();
else
imprimeLn("No hay animales...");
break;

case(5) :if ( numAnimales > 0)
mostrarProduccionImpares();
else
imprimeLn("No hay animales...");
break;

case(6) : imprimeLn("Saliendo...");
break;

} // end switch
} while (opcion!=6); //

} // main
}

27 jun. 2007

Tarea Proyecto Automotriz

Para que funcione el cambio de precio, se deben realizar modificaciones en las clases Auto y Camioneta, si no, no funciona por la "visibilidad" de los objetos.

Dejo aquí la tarea resuelta :-)

Suerte!



// ************************************************* //
public class Auto {

private String marca;
private int anho;
private String color;
private Registro registroAuto;

/** constructor por defecto */
public Auto() {
this.marca = "desconcida";
this.anho = 0;
this.color = "desconocido";
/** por defecto se tomara que el precio es CERO y
* que NO es usado */
registroAuto = new Registro(0,false);
}
/** constructor por paso de parametros */
public Auto(String marca, int año, String color, double precio, boolean esUsado) {
this.marca = marca;
this.anho = anho;
this.color = color;
registroAuto = new Registro(precio,esUsado);
}

public int getAnho() {
return anho;
}
public void setAnho(int año) {
this.anho = anho;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getMarca() {
return marca;
}
public void setMarca(String marca) {
this.marca = marca;
}

//-----------------------
// -- Esto es necesario para la tarea
public void setPrecio(double precio) {
this.registroAuto.setPrecio(precio);
}

public double getPrecio() {
return this.registroAuto.getPrecio();
}

public boolean getEsUsado() {
return this.registroAuto.getEsUsado();
}

}

// ************************************************* //


/**
*
*/
public class Camioneta {
private String marca;
private int año;
private double capacidadKilos;
private Registro registroCamioneta;

public Camioneta(String marca, int año, double capacidadKilos, double precio, boolean esUsado) {
this.marca = marca;
this.año = año;
this.capacidadKilos = capacidadKilos;
registroCamioneta = new Registro(precio,esUsado);
}

public Registro getRegistroCamioneta() {
return registroCamioneta;
}
public void setRegistroCamioneta(Registro registroCamioneta) {
this.registroCamioneta = registroCamioneta;
}
public double getCapacidadKilos() {
return capacidadKilos;
}
public void setCapacidadKilos(double capacidadKilos) {
this.capacidadKilos = capacidadKilos;
}
public int getAño() {
return año;
}
public void setAño(int año) {
this.año = año;
}
public String getMarca() {
return marca;
}
public void setMarca(String marca) {
this.marca = marca;
}

//-----------------------
// -- Esto es necesario para la tarea
public void setPrecio(double precio) {
this.registroCamioneta.setPrecio(precio);
}

public double getPrecio() {
return this.registroCamioneta.getPrecio();
}

public boolean getEsUsado() {
return this.registroCamioneta.getEsUsado();
}

}


// ************************************************* //


/**
*/
public class Registro {
private double precio;
private boolean esUsado;

public Registro(double precio, boolean esUsado) {
this.precio = precio;
this.esUsado = esUsado;
}
public double getPrecio() {
return precio;
}
public void setPrecio(double precio) {
this.precio = precio;
}
public boolean getEsUsado() {
return esUsado;
}
public void setEsUsado(boolean esUsado) {
this.esUsado = esUsado;
}

}


// ************************************************* //
/**
*
*/
public class Automotora
{
// instance variables - replace the example below with your own
private static int maxAutos = 10;
private static int maxCamionetas = 5;

private static Auto[] coleccionAutos;
private static Camioneta[] coleccionCamionetas;
private static int numAutos;
private static int numCamionetas;

/**
* Constructor for objects of class Automotora
*/
public void Automotora()
{
// inicializa arreglos
} // Constructor
//-------------------------------------------------------------
/**
*
*/
public static boolean agregaAuto( Auto car)
{
boolean retorno;

if( numAutos < coleccionAutos.length ) {
coleccionAutos[numAutos++] = car;
retorno = true;
} else {
// Excede el numero de autos que soporta
Tipicas.mensaje("No se puede agregar más autos!");
retorno = false;
}

return retorno;
}

//-------------------------------------------------------------
/**
*
*/
public static boolean agregaCamioneta( Camioneta car)
{
boolean retorno;

if( numCamionetas < coleccionCamionetas.length ) {
coleccionCamionetas[numCamionetas++] = car;
retorno = true;
} else {
// Excede el numero de Camionetas que soporta
Tipicas.mensaje("No se puede agregar más Camionetas!");
retorno = false;
}

return retorno;
}

//-------------------------------------------------------------
/**
*
*/
public static void buscaAutoColor( String paramColor )
{
for (int i=0; i < numAutos; i++) {
if ( coleccionAutos[i].getColor() == paramColor) {
Tipicas.mensaje( "\nAuto en posición: " + i);
Tipicas.mensaje( " marca : "+ coleccionAutos[i].getMarca());
Tipicas.mensaje( " es de color " + paramColor + "\n");
} // endif

} // for
} // fin de buscaAutoColor

//-------------------------------------------------------------
/**
*
*/
public static void reducePrecio( Auto[] paramLista, double paramRebaja )
{
int x=0;
double nuevoPrecio;

while ( paramLista[x] != null ) {
nuevoPrecio = paramLista[x].getPrecio() - paramRebaja;
paramLista[x].setPrecio( nuevoPrecio );
x++;
} // wend
} // fin de reducePrecio

//--------//
/**
*
*/
public static void reducePrecio( Camioneta[] paramLista, double paramRebaja )
{
int x=0;
double nuevoPrecio;

while ( paramLista[x] != null ) {
nuevoPrecio = paramLista[x].getPrecio() - paramRebaja;
paramLista[x].setPrecio( nuevoPrecio );
x++;
} // wend
} // fin de reducePrecio


//-------------------------------------------------------------
/**
*
*/
public static void imprimeUsados()
{
int x=0;

Tipicas.mensaje("Lista de autos usados");
while ( coleccionAutos[x] != null ) {
if ( coleccionAutos[x].getEsUsado() )
{
Tipicas.mensaje( coleccionAutos[x].getMarca()+":");
Tipicas.mensaje( "año: " +coleccionAutos[x].getAnho()+"\n");
}
x++;
} // wend

x=0;
Tipicas.mensaje("Lista de camionetas usadas");
while ( coleccionCamionetas[x] != null ) {
if ( coleccionCamionetas[x].getEsUsado() )
{
Tipicas.mensaje( coleccionCamionetas[x].getMarca()+":");
Tipicas.mensaje( " año: "+ coleccionCamionetas[x].getAño()+"\n");
}
x++;
} // wend


} // fin de reducePrecio

//----------------------------------------------------
/**
*
*/
public static void main(String[] args)
{
Auto miAuto;
Auto miCamioneta;
//------ inicializo -------//
coleccionAutos = new Auto[maxAutos];
coleccionCamionetas = new Camioneta[maxCamionetas];
numAutos = 0;
numCamionetas = 0;


miAuto = new Auto( "Yaris", 2002, "Azul", 4123123, true);

agregaAuto( miAuto );
buscaAutoColor( "Azul" );

reducePrecio( coleccionCamionetas, 100000 );

} // main

}

// ************************************************* //
/**
* Funciones utiles que es bueno tener tener siempre a mano
*
* @author Mauricio Latorre
*/
import java.io.*;

public class Tipicas
{


//------------------------------------------
public static String ingresaString( String mensaje ) {
String retorno="";

System.out.print(mensaje);
try {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// resultado
retorno = in.readLine();
}
catch (Exception e) {
System.out.print("Error al leer teclado");
} // fin del try


return retorno;

} // Fin de metodo


//------------------------------------------
public static void mensaje( String mensaje ) {
System.out.print(mensaje);
} // Fin de metodo

}