1)

import [Link].*;
public class SyGCalculoHorario
{
static int MAX=20;
iint []a=new int[MAX];

void sumaHhMmSs(int hh,int mm,int ss)

{
[Link](null," \n Horas: "+hh+" \n Minutos: "+mm+" \n Segundos: "+ss);
}

void menuElegir(int hh,int mm,int ss)

{
String cadena;
int opcion=0;
SyGCalculoHorario tiempo = new SyGCalculoHorario();
S

do{
cadena=[Link]("Elija una opción del menu \n 1) Ingrese Horas. \n 2) Ingrese Minutos. \n 3) I
ngrese Segundos. \n 4) Sumar Horas-Minutos-Segundos. \n 5) Resetear. \n 6) Salir.");
opcion=[Link](cadena);
}}while(opcion<1 && opcion>6 );

switch(opcion)
{
case 1:hh=hh+[Link]("Hora");break;
case 2:mm=mm+[Link]("Minuto");break;
case 3:ss=ss+[Link]("Segundo");break;
case 4:[Link](hh,mm,ss);break;
case 5:{hh=0;mm=0;ss=0;}break;
case 6:[Link](0);break;
default:[Link](null,"Ingrese una opción válida.");
}
[Link](hh,mm,ss);
}

int ingreseDatos(String time)

{
String cadena;
int n=0, acumulador=0;
cadena=[Link]("Cuantas datos Desea Ingresar: ");
n=[Link](cadena);
for(int i=0;i<n;i++)
{
cadena=[Link]("Ingrese "+time+" "+(i+1));
a[i]=[Link](cadena);
acumulador=acumulador+a[i];
}
return acumulador;
}

public static void main(String[] args)

{
SyGCalculoHorario ir = new SyGCalculoHorario();
i
[Link](0,0,0);
}
}
2)
import [Link].*;
public class SyGCodigo
{
void leerCodigo()
{
SyGCodigo codig = new SyGCodigo();
int cod=0;
do{
String cadena=[Link]("Ingrese su código Numérico de 4 Digitos. ");
cod=[Link](cadena);
if(cod>9999)
{
[Link](null,"El código ingresado no es de 4 digitos");
}
else if(cod>=0 && cod<1000)
{
[Link](null,"Código No Admitido por tener digito(s) ceros.");
}
else if(cod<0)
{
[Link](null,"El código ingresado no es de 4 digitos");
}
}}while(cod<1000 || cod>9999);

c
[Link](cod);
}

void admision(int cod)

{
int mod1=0, par=0, impar=0;
SyGCodigo codig = new SyGCodigo();
ffor(int i=1;i<=4;i++)
{
if(cod>=10)
mod1=cod%10;
else
mod1=cod;
if(mod1==0)
{
[Link](null,"Código No Admitido por tener digito(s) ceros.");
c
[Link]();

}
if(((mod1)%2)==0)
par++;
else
i
impar++;

c
cod=cod/10;
}

if(par>=3 || impar>=3)
[Link](null,"FALSE!!... Código INVÁLIDO");
else
[Link](null,"TRUE!!... Código ADMITIDO");
[Link](0);
}
 public static void main(String[] args)
{
SyGCodigo ir = new SyGCodigo();
[Link]();
}
}
3)

import [Link].*;
public class SyGTemperaturaMensual
{
static int MAX=5;
iint tempSup=25;

int[] almacenaArray()
{
int []arreglo=new int[MAX];
String cadena;
S

for(int i=0;i<MAX;i++)
{
do{
cadena=[Link]("Ingrese Temperatura "+ (i+1)+" : ");
arreglo[i]=[Link](cadena);
if((arreglo[i]<5)||(arreglo[i]>40))
{
[Link](null,"La temperatura debe ser de 5 y 40.");
}
}while((arreglo[i]<5)||(arreglo[i]>40));
}
return arreglo;
}
int temperaturaSuperada(int array[])
{

iint contador=0;

for(int i=0;i<[Link];i++)
{
if(array[i]>tempSup)
contador=contador+1;
}
[Link](null, "Las Temperaturas mayores a "+tempSup+" son: "+contador);
return contador;
}

int promedioTemperaturaSuperior(int temperaturaSuperiorA, int array[])

{
int contador=0, acu=0;
double promedioTemp=0;
for(int i=0;i<[Link];i++)
{
if(array[i]>tempSup)
{
acu=acu+array[i];
}
}
promedioTemp=acu/temperaturaSuperiorA;
[Link](null, "El promedio de la temperaturas superiores a "+tempSup+" es: "+promedioTemp);
return 0;
}

void temperaturaMaximaMensual(int array[])

{
 int tmp=0;
String cad="";
iint array2[] = new int[MAX];

for(int i=0;i<[Link];i++)
{
array2[i]=array[i];
}

int k=0,x=0,c=0;
for(int i=1;i<[Link];i++)
{
if(array2[i-1]<array2[i])
{ x=i;c++;}
//else
// rreturn 0;

for(int j=0;j<[Link]-i;j++)
{

if(array2[j]>array2[j+1])
{
kk=array2[j+1]; array2[j+1]=array2[j]; array2[j]=k;

}
}
[Link](null,"La temperatura: "+array2[MAX-1]+" Día: "+(x-1));

public static void main(String[] args)

{

int []array=new int[MAX];

int temperaturaSuperiorA=0;
int opcion=0;
String cadena;
int sup=25,retro=0;
SyGTemperaturaMensual temperatura = new SyGTemperaturaMensual();
do{
array=[Link]();
do
{ retro=1;
cadena=[Link]("Seleccione una opción: \n 1) Temperatura Máxima del Mes. \n 2)
Temperatura Superior a "+ sup +" ºC. \n 3) Promedio de temperaturas superiores a " +sup+ " ºC. \n 4) Reiniciar.\n 5) Salir.");
o
opcion=[Link](cadena);

switch(opcion)
{
case 1:[Link](array);break;
case 2:temperaturaSuperiorA=[Link](array);break;
case 3:
{
if(temperaturaSuperiorA>0)
[Link](temperaturaSuperiorA, array);
 else
[Link](null,"No hay tenperaturas superiores a "+sup);
}break;
case 4:retro=0;break;
case 5:[Link](0);break;
}
}while(retro==1);
}
}while(retro==0);

}
}
4)
//Utilizando el método Leer
public class SyGEvaluacion
{
static int[] ingresar(int[] Vector, String cad)
{
int h=0;
for(int i=0;i<[Link];i++)
{
[Link]("Ingresar "+ cad+ ":\t");
h=[Link]();[Link]("");
Vector[i]=h;
}
return Vector;
}
static void imprimir(int[] Temp)
{
ffor(int i=0;i<[Link];i++)
{
[Link](Temp[i]);
}
}

static void pPresente(int[] A)

{
int c=0;
for(int i=0;i<[Link];i++)
{
if(A[i]==1)
c++;
}
[Link]("La cantidad de alumnos presentes es :"+ c);
[Link]("El porcentaje de alumnos presentes es :"+ ((c*100)/([Link]))+"%");
}
static void promedio(int[] N, int[] A)
{
int sum=0,c=0;
double prom=0;
for(int i=0;i<[Link];i++)
{
if(A[i]==1)
{
c++;
sum=sum+(N[i]);
}
}
prom=sum/c;
[Link]("El promedio de los " + c + " alumnos presentes es :"+ prom);
}

static void aAprobados(int[] N, int[] A)

{
iint ca=0,cp=0;

for(int i=0;i<[Link];i++)
{
if(A[i]==1)
{
 cp++;
i
if(N[i]>5)
ca++;
}
}

[Link]("El porcentaje de alumnos prest. y aproba. es :"+ ((ca*100)/(cp))+"%");

}
static void mayor(int[] C, int[] N, int[] A)
{
iint may=0,i=0;

for(i=0;i<[Link];i++)
{
if(A[i]==1)
{
if(N[i]>may) may= N[i];
}

}
for(i=0;i<[Link];i++)
{
if(may==N[i] && A[i]==1)
[Link]("Codigo : " + C[i] + " y su Nota : " + N[i]);
}
}
public static void main(String args[])
{
int max=0;
d
do{
[Link]("Cuantos registros desea ingresar :\t");
max=[Link]();[Link]("");
if(max<1)
[Link]("¿Acaso quieres engañar a la maquina?, Ingrese un valor válido!!");
}while(max<1);
int [] Codigo= new int[max];
int [] Asistencia= new int[max];
int [] Nota= new int[max];
[Link]("----------------------------------------");
iingresar(Codigo,"codigo [0001 - 9999]");

[Link]("----------------------------------------");
iingresar(Asistencia,"asistencia [1. Presente] [0. Ausente] ");

[Link]("----------------------------------------");
iingresar(Nota,"nota [00 - 20]");

[Link]("----------------------------------------");
[Link]("------------- REPORTE ----------------");
pPresente(Asistencia);
promedio(Nota,Asistencia);
aAprobados(Nota,Asistencia);
mayor(Codigo,Nota,Asistencia);
[Link]("----------------------------------------");
}
}
5)
import [Link].*;
ppublic class SyGFraccion{

void mostrarFraccionSimplificada(int numerador, int denominador)

{
int div=0;
if((numerador % denominador)==0)
{
div=numerador/denominador;
[Link](null,""+div);
}
else if((denominador % numerador)==0)
{
div=denominador/numerador;
[Link](null,"1/"+div);
}
else
J
[Link](null,""+numerador+"/"+denominador);

void ingresaFraccion()
{
int numerador=0, denominador=0;
String cadena;
cadena=[Link]("Ingrese Numerador : ");
numerador=[Link](cadena);
cadena=[Link]("Ingrese Denominador : ");
denominador=[Link](cadena);
mostrarFraccionSimplificada(numerador,denominador);
}
public static void main(String[] args)
{
String cadena;
int opcion=0;
SyGFraccion fraccional = new SyGFraccion();
do
{
cadena=[Link]("0. Salir. ----- [Otro] Continuar");
opcion=[Link](cadena);
if(opcion==0)
[Link](0);
e
else
f
[Link]();

}
}while(opcion!=0);
}
}
6)
import [Link].*;
public class SyGMultiOperaciones
{
static String cadena,cadenaNumerica;
static int eligeOpcion()
{
iint opcion=0;

cadena=[Link]("Calcular:\n 1)Promedio de Digitos\n 2)Cambiar de Base\n 3)Factorial\n 4)Número de

Dígitos\n 5)Dígitos Impares\n 6)Reiniciar\n 7)Salir");
opcion=[Link](cadena);
return opcion;
}

public static void main(String[] args)

{
int opcion=0,promedio=0,numDigitos=0,impares=0,faq=0,retro=0;
do{
cadenaNumerica=[Link]("Ingrese un número");
int numeroEntero=[Link](cadenaNumerica);

d
do{
retro=1;
opcion=eligeOpcion();
switch(opcion)
{
case 1: promedio=promedioDigitos(numeroEntero);
[Link](null,"Promedio de Dígitos: "+promedio);break;
case 2: cambiarBase(cadenaNumerica);break;
case 3: {
faq=factorial(numeroEntero);
if(faq!=0)
[Link](null,"Factorial: "+faq);
}
}break;
case 4: numDigitos=numeroDigitos(numeroEntero);
[Link](null,"Número de Dígitos: "+numDigitos);break;

case 5: impares=numDigitosImpares(numeroEntero);
[Link](null,"Número de Dígitos Impares: "+impares);break;

case 6: retro=0;break;
r
case 7: [Link](0);break;
S

}
}while(retro==1);
}while(retro==0);
}

static int promedioDigitos(int numeroEntero)

{
int num=0,mod=0,c=0,prom=0,sum=0;
while(numeroEntero!=0)
{
mod=numeroEntero%10;
numeroEntero=numeroEntero/10;
c++;
sum=sum+mod;
 [Link](""+mod);
}

return sum/c;
}

public static void cambiarBase(String cadenaNumerica)

{
CambiarBase sistema = new CambiarBase();
sistema.desde_base_decimal(cadenaNumerica);
}
static int factorial(int numeroEntero)
{
iint faq=0;

if(numeroEntero==0)
faq=1;
else if(numeroEntero<0)
[Link](null,"No existe factorial de numeros negativos.");
else if(numeroEntero>0)
for(faq=numeroEntero;numeroEntero>1;numeroEntero--)
faq*=(numeroEntero-1);
return faq;
}

static int numeroDigitos(int numeroEntero)

{
int c=0;
while(numeroEntero!=0)
{
numeroEntero=numeroEntero/10;
c++;
}
return c;
}

static int numDigitosImpares(int numeroEntero)

{
int c=0,mod=0;
while(numeroEntero!=0)
{
mod=numeroEntero%10;
numeroEntero=numeroEntero/10;
if(mod%2!=0) c++;
}
rreturn c;
}

}
7)
public class SyGPotencia
{

static int base, exp, j;

public static void main(String args[])
{
if([Link]<2 ||[Link]>2 )
[Link]("Ingrese dos parámetros [Base] [Exponente]");
else
{
int base = [Link](args[0]);
iint exp = [Link](args[1]);

[Link](base + "^" + exp + " = ");

j = pot(base,exp);
[Link](j + "");
}
}

static int pot(int base, int exp)

{
int result=1,exponente=exp;
float resultDecimal=0;
iif(exp<0) exponente=-exp;

for(int i=1;i<=exponente;++i)
{
result*=base;
}

if(exp<0)
{
exponente=-exp;
r
resultDecimal=1/result;
[Link]("1/"+result+" = "+resultDecimal);
S
[Link](0);
}
else if(base==0 && exp!=0)
result=0;
else if(base==0 && exp==0)
{
[Link]("Indefinido");
[Link](0);
}
rreturn result;

}
}
8)
public class SyGMcd_Mcm
{
sstatic int MAX=2;
static int mcd(int a, int b)
{
int x=0,nuevob=0;
x = a;
if (a < b)
{
a = b;
b = x;
[Link](a+" \t"+b);
S
return mcd(a,b);
}
else if (b != 0)
{
nuevob = a % b;
a = b;
b = nuevob;
[Link](a+" \t"+b);
return mcd(a,b);
}
return a;
}

static int mcm(int a, int b)

{
int m=0;
m=mcd(a,b);
return(m*(a/m)*(b/m));
}

public static void main(String[] args)

{
int d=0,a=0,b=0,c=0,e=0;
if([Link]<3 || [Link]>3 )
[Link]("\nIngrese 3 números como parámetros...\n");
else
{
a=[Link](args[0]);
b=[Link](args[1]);
c=[Link](args[2]);
[Link]("\n\n");
/*----Máximo Común Divisor------*/
d=mcd(a,b);
[Link]("---------");
e=mcd(d,c);
[Link]("MCD ("+a+","+b+","+c+") = "+e+"\n\n");
S

/*----Mínimo Común Múltiplo------*/

d
d=mcm(a,b);
[Link]("---------");
e=mcm(d,c);
[Link]("MCM ("+a+","+b+","+c+") = "+e+"\n\n");
}
}
}
9)
//Calculo de la promedio, mediana, moda, máximo y mínimo
import [Link].*;
public class SyGCalculoMicroEstadistico
{
static int MAX=5;
static int elijeOpcion()
{
int opcion=0;
String cadena=[Link]("Calcular: \n 1)Promedio Ponderado.\n 2)Moda.\n 3)Mediana.\n
4)Máximo.\n 5)Mínimo.\n 6)Reiniciar.\n 7)Salir.");
o
opcion=[Link](cadena);

return opcion;
}

static int moda(int numero[],int frecuencia[])

{
iint moda=0,frec=0;

for(int j=0;j<[Link];j++)
if(frecuencia[j]>frec)
{
frec=frecuencia[j];
moda=numero[j];
}
rreturn moda;

static int mediana(int numero[],int frecuencia[])

{
iint med=0,medi=0,indice=0;

int[] frecuenciaAcumulada = new int[MAX];

iint[] frecuenciaAcumuladaOrdenada = new int[MAX];
f
frecuenciaAcumulada[0]=frecuencia[0];
for(int j=1;j<[Link];j++)
f
frecuenciaAcumulada[j]=frecuenciaAcumulada[j-1]+frecuencia[j];

frecuenciaAcumuladaOrdenada=ordenaArreglo(frecuenciaAcumulada);
m
med=frecuenciaAcumuladaOrdenada[MAX-1]/2;

i k=0;
int
while(med>frecuenciaAcumuladaOrdenada[k])
k
k++;

m
medi=frecuenciaAcumuladaOrdenada[k];

return medi;
}

static int promedioPonderado(int numero[],int frecuencia[])

{
int sum=0,prom=0,n=0;
 for(int i=0;i<[Link];i++)
{
sum=sum+(frecuencia[i]*numero[i]);
n=n+frecuencia[i];
}
prom=sum/n;
return prom;
}

static int maximo(int numero[],int frecuencia[])

{
int[] frecuenciaOrdenada = new int[MAX];
f
frecuenciaOrdenada=ordenaArreglo(frecuencia);

return frecuenciaOrdenada[MAX-1];
}
static int minimo(int numero[],int frecuencia[])
{
int[] frecuenciaOrdenada = new int[MAX];
f
frecuenciaOrdenada=ordenaArreglo(frecuencia);

return frecuenciaOrdenada[0];
}

static int[] ordenaArreglo(int arreglo[])

{

int k=0;
for(int i=1;i<[Link];i++)
{
for(int j=0;j<[Link]-i;j++)
{
if(arreglo[j]>arreglo[j+1])
{k=arreglo[j+1]; arreglo[j+1]=arreglo[j]; arreglo[j]=k;}
}
}
rreturn arreglo;

public static void main(String[] args)

{
int opcion=0,retro=0;
int numero[]=new int[MAX];
int frecuencia[]=new int[MAX];
String cadena;
do{
retro=0;
for(int i=0;i<[Link];i++)
{
cadena=[Link]("Igrese numero "+(i+1)+" :");
numero[i]=[Link](cadena);
cadena=[Link]("Igrese su frecuencia : ");
f
frecuencia[i]=[Link](cadena);

}
d
do{
opcion=elijeOpcion();
 iint moda=0,mediana=0,maximo=0,minimo=0,promedio=0;

switch(opcion)
{
case 1: promedio=promedioPonderado(numero,frecuencia);
[Link](null,"Promedio: "+promedio);break;
case 2: moda=moda(numero,frecuencia);
[Link](null,"Moda: "+moda);break;
case 3: mediana=mediana(numero,frecuencia);
[Link](null,"Mediana: "+mediana);break;
case 4: maximo=maximo(numero,frecuencia);
[Link](null,"Máximo: "+maximo);break;
case 5: minimo=minimo(numero,frecuencia);
[Link](null,"Mínimo: "+minimo);break;
case 6: retro=1;break;
case 7: [Link](0);
default: [Link](null,"Ingrese una opción válida...");

}
}while(retro==0);
}
}while(retro==1);
}
}
10)
//Imprime en pantalla la siguiente serie: 1,3,5,7,9,...2n-1 [n = cantidad de numeros impares]
public class SyGCantidadDeImpares
{
static void construyeSerieDeImpares(int numImpares)
{
int i=1,impar=1;
//String signo;
String coma;
S

while(i<=2*numImpares-1)
{
if (i==2*numImpares-1)
coma="";
else
coma=", ";
muestraSerieDeImpares(i,coma);
i+=2;
}

static void muestraSerieDeImpares(int i,String coma)

{

[Link](i+coma);
}

public static void main(String[] args)

{

int numImpares=[Link](args[0]);
if([Link]>1)
[Link]("Ingrese sólo un parámetro [número de impares a mostrar...]");
else if(numImpares<=0)
[Link]("Ingrese un parámetro válido [mayor a 0]");
else
{
construyeSerieDeImpares(numImpares);
[Link]("");
}
}
}
11)
//Imprime en pantalla la siguiente serie: 1 - 1/3 + 1/5 - 1/7 + 1/9 - ...+ 1/(2n-1) [n = cantidad de fracciones]
public class SyGCantidadDeFracciones
{
static void construyeSerieFraccional(int numFracciones)
{
int i=1,den=1;
String signo;
while(i<=numFracciones)
{
if (i%2==0)
signo="+";
else
signo="-";
if(i==numFracciones)
ssigno=" ";

muestraSerieFraccional(den,signo);
den+=2;
i++;
}
}

static void muestraSerieFraccional(int den,String signo)

{
[Link](1+"/"+den+" "+signo+" ");
}

public static void main(String[] args)

{

int numFracciones=[Link](args[0]);
if([Link]>1)
[Link]("Ingrese sólo un parámetro [número de fracciones a mostrar...]");
else if(numFracciones<=0)
[Link]("Ingrese un parámetro válido [mayor a 0]");
else
{
construyeSerieFraccional(numFracciones);
[Link]("");
}
}
}
12)
//LIstar los numeros según el numero de digitos indicado
//Considero solo hasta numeros menores a 100000 (5 digitos), por el hecho de k buscar numeros primos a partir de 6 digitos, el proceso se
hace muy lento.
public class SyGNumerosPrimos
{
public static void main(String arg[])
{
int numDigitos=0;
int ndigitos=0;
numDigitos=[Link](arg[0]);
if(numDigitos<=0)
[Link]("Ingrese como parámetro, un numero de digitos correcto (mayor que 0): ");
for(int i = 1; i <= 99999; i++ )
{
ndigitos=contarDigitos(i);
if(ndigitos==numDigitos)
if (primo(i) == true)
[Link](i);
}
}

public static boolean primo(int num)

{
boolean p = false;

if (num < 4) p = true;

else
{
if (num % 2 == 0) p = false;
else
{
int contador = 0;
int i = 1;
int limite = (num - 1) / 2;
if (limite % 2 == 0) limite--;

while(i <= limite)

{
if (num % i == 0) contador++;
i += 2;
if (contador == 2) i = limite + 1;
}

if (contador == 1) p = true;
}
}

return p;
}

public static int contarDigitos(int numeroEntero)

{
int divisionEntera = numeroEntero;

int contador=0;

while (divisionEntera != 0)
 {
divisionEntera = divisionEntera / 10;
contador++;
}
return contador;
}

}
13)
//Identifica los numeros capicuas dando 2 parámetros como rango.
public class SyGNumerosCapicuas
{
static SyGNumerosCapicuas numero = new SyGNumerosCapicuas();

void defineCapicuas(int limiteMin,int limiteMax)

{
SyGNumerosCapicuas num = new SyGNumerosCapicuas();
int numeroInvertidoOut[]=new int[limiteMax-limiteMin+1];
int j=0;
for(int i=limiteMin;i<=limiteMax;i++)
{
numeroInvertidoOut[j]=[Link](i);

if(i==numeroInvertidoOut[j])
{
[Link](i+" \t es capicua.");
}
j++;
}
}

int invertirNumero(int i)
{

int numeroAux=0;

int numeroInvertido=0;
numeroAux=i;

numeroInvertido=numeroAux%10;

while(numeroAux>9)
{
numeroAux=numeroAux/10;
numeroInvertido=numeroInvertido*10 + numeroAux%10;
}
return numeroInvertido;
}

public static void main(String[] args)

{
SyGNumerosCapicuas numero = new SyGNumerosCapicuas();
int limiteMax=0,limiteMin=0;
if([Link]<=1||[Link]>2)
[Link]("Ingrese solo los parámetros [Rango Minimo - Rango Máximo]: ");
else if([Link]==2)
{

limiteMin=[Link](args[0]);
limiteMax=[Link](args[1]);
[Link](limiteMin,limiteMax);

}
}
}
14)
public class SyGPiramideNumerica
{

public static void main(String[] arg)

{
int limite=0;
limite=[Link](arg[0]);
for(int i=1; i<=limite;i++)
{
for(int j=1;j<=i;j++)
{
[Link](i);
}
[Link]("");
}

}
}
 ANEXO 1
Clase CambiarBase: Invocado desde el código número 6 (SyGMultioperaciones).
import [Link];
import [Link].*;
public class CambiarBase
{
static String numD="",pos="",conversion="";
static int sistO,sistD;
public static void main(String[] args)
{

public static void leer()

{

do{
sistD=[Link]([Link]("Ingrese el numero de la base del sistema destino"));
iif(sistD>9 || sistD<2 )
[Link](null,"Se admite bases de 2 a 9");
}while(sistD>9 || sistD<2);
sistO=10;
}

public static void desde_base_decimal(String numO)

{
leer();
numD="";
while([Link](numO)>=sistD)
{
p
pos=[Link]([Link](numO)%sistD);

numO=[Link]([Link](numO)/sistD);
numD+=pos;
}
pos=numO;
numD+=pos;
invertir_cadena(numD,sistD);
limpiarValores();
}

public static void limpiarValores()

{
numD="";pos="";conversion="";
sistO=0;sistD=0;
}

public static void invertir_cadena(String numD,int sistD)

{
for(int i=[Link]();i>0;i--)
{
conversion+=[Link]((i-1),i);
}
[Link](null,"Transformacion: \n"+"Es igual a: "+ conversion+" en base "+sistD);
}
}
 ANEXO 2
Clase Leer: Realizado en el curso de Estructura de Datos y Algoritmos. Invocado desde el código 4 (SyGEvaluacion).
import [Link].*;
public class Leer{
public static String dato(){
String sdato = "";
try{
// Definir un flujo de caracteres de entrada: flujoE
InputStreamReader isr =
new InputStreamReader([Link]);
BufferedReader flujoE=
new BufferedReader(isr);
// Leer. La entrada finaliza al pulsar la tecla Entrar
sdato = [Link]();
}
catch(IOException e){
[Link]("Error: " + [Link]());
}
return sdato; // devolver el dato tecleado
}

public static short datoShort(){

try{
return [Link](dato());
}
catch(NumberFormatException e){
// valor más pequeño
return Short.MIN_VALUE;
}
}

public static int datoInt(){

try{
return [Link](dato());
}
catch(NumberFormatException e){
// valor más pequeño
return Integer.MIN_VALUE;
}
}

public static long datoLong(){

try{
return [Link](dato());
}
catch(NumberFormatException e){
// valor más pequeño
return Long.MIN_VALUE;
}
}

public static float datoFloat(){

try{
Float f = new Float(dato());
return [Link]();
}
catch(NumberFormatException e){
// No es un Número; valor float.
 return [Link];
}
}

public static double datoDouble(){

try{
Double d = new Double(dato());
return [Link]();
}
catch(NumberFormatException e){
// No es un Número; valor double.
return [Link];
}
}

public static String datoString(){

return dato();
}

public static char datoChar(){

int c=0;
try{
InputStreamReader isr =
new InputStreamReader([Link]);
BufferedReader flujoE=
new BufferedReader(isr);
c=[Link]();
char car;
car=(char) c;
return car;
}
catch(IOException e){
return '\0';
}
}
}

Universidad Continental de Ciencias e Ingenierias

E.A.P Ingeniería Informática
V Semestre - 2008
Por:
Saforas Contreras Danny H.
Gutierrez Zuñiga César.
Nota: Los códigos fuente fueron compilados con javac y gcj sobre linux.