ALGORITMOS SECUENCIALES //... Algoritmo que Lee el nombre, apellido, edad, peso de un estudiante y lo imprime import java.io.

*; public class a_leer { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables String nombre, apellidos; int edad; float peso; //... Leer nombre de la persona System.out.print("Ingresar nombre: "); nombre= teclado.readLine(); //... Leer apellido paterno y materno de la persona System.out.print("Ingresar apellidos: "); apellidos= teclado.readLine(); //... Leer edad de la persona System.out.print("Ingresar edad: "); edad= Integer.parseInt(teclado.readLine()); //... Leer peso de la persona System.out.print("Ingresar peso (Kgr): "); peso= Float.parseFloat(teclado.readLine()); //... Imprimir el ingreso de datos System.out.println(); System.out.println("El estudiante es"); System.out.println("Nombre: "+nombre); System.out.println("Apellidos: "+apellidos); System.out.println("Edad y Peso: "+edad+" aos, y "+peso+" Kgr"); } } //... Algoritmo que lee las notas de un estudiante e imprime el promedio import java.io.*; public class b_promedio { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nota1, nota2, nota3; double promedio; //... Leer notas System.out.print("Ingresar primera nota: "); nota1= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar segunda nota: "); nota2= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar tercera nota: "); nota3= Integer.parseInt(teclado.readLine()); //... Calcular el promedio promedio= (nota1+nota2+nota3)/3.0; //... Imprimir promedio System.out.println("El promedio real: "+promedio); System.out.println("El promedio entero:"+(int)promedio); System.out.println("El promedio float:"+(float)promedio); System.out.println("El promedio redondeado: "+Math.round(promedio)); } }

//... Algoritmo que convierte una distancia medida en pulgadas a centimetros import java.io.*; public class c_convertir { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int pulgada; double centimetro; //... Leer distancia en pulgadas System.out.print("Ingresar medida en pulgadas: "); pulgada= Integer.parseInt(teclado.readLine()); //... Convertir distancia a centimetros centimetro= pulgada*2.54; //... Imprimir nueva medida en centimetros System.out.println("El equivalente: "+pulgada+"pulg = "+centimetro+"cm"); } } //... Algoritmo que evalua la funcion: f(x)= 2X2 + 4X - 5 import java.io.*; public class d_funcion { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int x; double Fx1, Fx2; //... Leer el valor de X System.out.print("Leer X:"); x= Integer.parseInt(teclado.readLine()); //... Calcular la funcion Fx1= 2*(x*x) + 4*x - 5; Fx2= 2*Math.pow(x,2) + 4*x - 5; //... Imprimir la funcion resultado System.out.println("f(x):2X2 + 4X - 5= "+Fx1); System.out.println("f(x):2X2 + 4X - 5= "+(float)Fx2); } } //... Algoritmo que transforma las coordenadas polares de un punto a coordenadas //... rectangulares en el primer cuadrante import java.io.*; public class e_coodenadas { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int radio, angulo; double angRadianes, x, y; //... Leer coordenadas polares de un punto System.out.print("Leer Radio: "); radio= Integer.parseInt(teclado.readLine()); System.out.print("Leer Angulo: "); angulo= Integer.parseInt(teclado.readLine()); //... Calcular la absisa y la ordenada del punto angRadianes= angulo*Math.PI/180;

x= radio*Math.cos(angRadianes); y= radio*Math.sin(angRadianes); //... Escribir las coordenadas rectangulares del punto System.out.println("Coordenadas rectangulares: ("+(float)x+","+(float)y+")"); } } //... Algoritmo que calcula la suma de dos numeros complejos import java.io.*; public class f_complejos { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1Ent, nro1Imag, nro2Ent, nro2Imag, parteEnt, parteImag; //... Leer numero complejos System.out.print("Ingresar Primer complejo (parte entera): "); nro1Ent= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar Primer complejo (parte imaginaria): "); nro1Imag= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar Segundo complejo (parte entera): "); nro2Ent= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar Segundo complejo (parte imaginaria):"); nro2Imag= Integer.parseInt(teclado.readLine()); //... Realizar la suma de complejos parteEnt= nro1Ent+nro2Ent; parteImag= nro1Imag+nro2Imag; //... Imprimir resultados System.out.println(nro1Ent+"+"+nro1Imag+"i"); System.out.println(nro2Ent+"+"+nro2Imag+"i"); System.out.println("---------------"); System.out.println("Suma: "+parteEnt+"+"+parteImag+"i"); //... Realizar la diferencia de complejos parteEnt= nro1Ent-nro2Ent; parteImag= nro1Imag-nro2Imag; //... Imprimir resultados System.out.println(nro1Ent+"+"+nro1Imag+"i"); System.out.println(nro2Ent+"+"+nro2Imag+"i"); System.out.println("---------------"); System.out.println("Resta: "+parteEnt+"+"+parteImag+"i"); //... Realizar el producto de complejos parteEnt= nro1Ent*nro2Ent-nro1Imag*nro2Imag; parteImag= nro1Ent*nro2Imag+nro2Ent*nro1Imag; //... Imprimir resultados System.out.println(nro1Ent+"+"+nro1Imag+"i"); System.out.println(nro2Ent+"+"+nro2Imag+"i"); System.out.println("---------------"); System.out.println("Producto: "+parteEnt+"+"+parteImag+"i"); } } //... Algoritmo que calcula la resultante de dos fuerzas import java.io.*; public class g_resultante { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado

BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int fuerza1, fuerza2, angulo; double angRadianes, resultante; //... Leer las fuerzas y anglos en grados sexagesimales System.out.print("Leer primera fuerza (Kg-f): "); fuerza1= Integer.parseInt(teclado.readLine()); System.out.print("Leer segunda fuerza (Kg-f): "); fuerza2= Integer.parseInt(teclado.readLine()); System.out.print("Leer angulo: "); angulo= Integer.parseInt(teclado.readLine()); //... Calcular la fuerza resultante angRadianes= angulo*Math.PI/180; resultante= Math.sqrt(Math.pow(fuerza1,2)+Math.pow(fuerza2,2)+ 2*fuerza1*fuerza2*Math.cos(angRadianes)); System.out.println("La fuerza resultante sera:"+(float)resultante+" Kg-f"); } } //... Algoritmo que calcula la distancia entre dos puntos import java.io.*; public class h_distanciaPuntos { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int x1, y1, x2, y2; double distancia; //... Leer absisa y ordenada de dos puntos System.out.print("Leer absisa del primer punto (X1):"); x1= Integer.parseInt(teclado.readLine()); System.out.print("Leer ordenada del primer punto (Y1):"); y1= Integer.parseInt(teclado.readLine()); System.out.print("Leer absisa del segundo punto (X2):"); x2= Integer.parseInt(teclado.readLine()); System.out.print("Leer ordenada del segundo punto (Y2):"); y2= Integer.parseInt(teclado.readLine()); //... Calcular la distancia entre dos puntos distancia= Math.sqrt(Math.pow(x2-x1,2)+Math.pow(y2-y1,2)); System.out.println("La distancia entre dos puntos sera:"+(float)distancia); } } /* Una liebre y una tortuga parten en el mismo instate, del mismo punto y en el mismo sentido. La liebre corre a razon de 400 metros por minuto y la tortuga a razon de 0.6 metros por minuto. Escribir un algoritmo que determine la distancia entre la liebre y la tortuga al cabo de T minutos */ import java.io.*; public class i_liebreTortuga { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int minTiempo;

double distancia; //... Leer tiempo System.out.print("Leer tiempo (minutos):"); minTiempo= Integer.parseInt(teclado.readLine()); //... Calcular la distancia y la tortuga distancia= minTiempo*(400-0.6); //... Imprimir la distancia entre la liebre y la tortuga System.out.println("Distancia: "+(float)distancia); } } /* Se deja caer una pelota desde una altura h. Al caer al suelo rebota hasta alcanzar los 3/4 de la altura inicial y luego vuelve a caer y rebotar hasta alcanzar los 3/4 de la altura anterior y asi sucesivamente. Escribir un algoritmo que calcule la altura que alcanzara en el n-esimo rebote. */ import java.io.*; public class j_rebote { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int ho, n; double hFinal; //... Leer altura inicial y numero de rebotes System.out.print("Leer altura inicial: "); ho= Integer.parseInt(teclado.readLine()); System.out.print("Leer numero de rebote:"); n= Integer.parseInt(teclado.readLine()); //... Calcular la altura final hFinal= Math.pow(3.0/4,n)*ho; //... Imprimir la altura final al cabo de n-rebotes System.out.println("Altura final:"+hFinal); } } /* Se compra N-articulos a un precio unitario X. Escribir un algoritmo que permita calcular el impuesto a pagar (18% sobre el precio de venta) asi como el importe total por la venta de los N-articulos */ import java.io.*; public class k_IGV { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int cant, pUnit, pVenta; double IGV, pTotal; //... Leer la cantidad y precio unitario de un articulo System.out.print("Ingresar cantidad (Unid): "); cant= Integer.parseInt(teclado.readLine()); System.out.print("Leer precio unitario (S/): "); pUnit= Integer.parseInt(teclado.readLine()); //... Calcular impuesto y precio total pVenta= cant*pUnit; IGV= pVenta*0.18; pTotal= pVenta+IGV; //... Imprimir resultados System.out.println("El IGV es de S/."+(float)IGV); System.out.println("El precio de venta es de S/. "+(float)pTotal); } }

//... Algoritmo que calcula las unidades, decenas y centena de un nmero de tres digitos import java.io.*; public class l_UnidDec { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro, unidad, decena, centena; //... Leer numero System.out.print("Leer numero: "); nro= Integer.parseInt(teclado.readLine()); //... Calcular las unidades y decenas unidad= nro%10; decena= (nro/10)%10; centena= nro/100; //... Imprimir System.out.println(nro+" tiene: "+centena+" centenas, "+decena+" decenas, "+ unidad+" unidades"); } } /* Un ciclista parte de la plaza de armas de Andahuaylas a las HH horas MM minutos y SS segundos. El tiempo de viaje hasta llegar a la universidad UNAJMA es de T minutos. Escribir un algoritmo que determine la hora de llegada a la universidad */ import java.io.*; public class m_horaLlegada { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int hh, mm, ss, T, tTotal; //... Leer la hora de partida y el tiempo de viaje System.out.print("Leer hora de partida: "); hh= Integer.parseInt(teclado.readLine()); System.out.print("Leer minutos de partida: "); mm= Integer.parseInt(teclado.readLine()); System.out.print("Leer segundos de partida: "); ss= Integer.parseInt(teclado.readLine()); System.out.print("Duracion del viaje (minutos): "); T= Integer.parseInt(teclado.readLine()); //... Calcular la hora de llegada tTotal= (hh*3600+mm*60+ss)+(T*60); hh= tTotal/3600; mm= (tTotal%3600)/60; ss= (tTotal%3600)%60; //... Imprimir resultados System.out.println("Hora de Llegada: "+hh+":"+mm+":"+ss); } } //... Algoritmo que invierte el orden de los digitos de un numero de tres digitos import java.io.*; public class n_invertir { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in));

//... Declarar variables int nro, unid, dec, cent, nroInv; //... leer numero System.out.print("Leer numero: "); nro= Integer.parseInt(teclado.readLine()); //... Invertir numero unid= nro%10; dec= (nro/10)%10; cent= nro/100; nroInv= unid*100+dec*10+cent; //... Imprimir resultado System.out.println("El numero invertido sera: "+nroInv); } } //... Algoritmo que invierte un nmero de tres digitos import java.io.*; public class o_invertir { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro, nroInv, ultDig; //... Leer numero System.out.print("Ingresar numero: "); nro= Integer.parseInt(teclado.readLine()); //... Invertir numero(primera etapa) nroInv= 0; ultDig= nro%10; nroInv= nroInv*10+ultDig; nro= nro/10; //... Segunda etapa ultDig= nro%10; nroInv= nroInv*10+ultDig; nro= nro/10; //... Tercera etapa ultDig= nro%10; nroInv= nroInv*10+ultDig; //... Imprimir resultados System.out.println("Numero invertido: "+nroInv); } } /* Algoritmo que calcule el numero minimo de billetes de 100, 50, 20, 10, monedas de 5 y 1 (Nuevos Soles) necesarias para cambiar un Cheque Bancario Nota: El cheque bancario no contiene centimos */ import java.io.*; public class p_billetes { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int monto, b100, b50, b20, b10, m5, m1, resto; //... Leer monto System.out.print("Leer monto: "); monto= Integer.parseInt(teclado.readLine());

//... Calcular numero de billetes b100= monto/100; resto= monto%100; b50= resto/50; resto= resto%50; b20= resto/20; resto= resto%20; b10= resto/10; resto= resto%10; m5= resto/5; m1= resto%5; //... Imprimir resultados System.out.println("Billetes de S/. 100 :"+b100); System.out.println("Billetes de S/. 50 :"+b50); System.out.println("Billetes de S/. 20 :"+b20); System.out.println("Billetes de S/. 10 :"+b10); System.out.println("Monedas de S/. 5 :"+m5); System.out.println("Monedas de S/. 1 :"+m1); } } //... Algoritmo que calcula la hipotenusa de un triangulo import java.io.*; public class q_hipotenusa { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int catetoAdiacente, catetoOpuesto; double hipotenusa; //... Leer lados System.out.println("Leer primer cateto: "); catetoAdiacente= Integer.parseInt(teclado.readLine()); System.out.println("Leer segundo cateto: "); catetoOpuesto= Integer.parseInt(teclado.readLine()); //... Calculando la hipotenusa hipotenusa= Math.sqrt(Math.pow(catetoAdiacente,2)+Math.pow(catetoOpuesto,2)); System.out.println("La hipotenusa sera: "+(float)hipotenusa); } }

ALGORITMOS DE SELECCIN /* Una empresa comercial ofrece dos tipos de descuentos: 10% si el importe de la venta es mayor o igual a S/ 200.00 5% si el importe de la venta es menor a S/ 200.00 Escribir un algoritmo que lea el numero de unidades vendidas y el precio unitario, luego que calcule el importe de la venta neta */ import java.io.*; public class a_descuento { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int pUnit, nroUnid, impBruto; double descuento, impNeto; //... Leer precio unitario y numero de unidades System.out.print("Leer precio unitario: "); pUnit= Integer.parseInt(teclado.readLine()); System.out.print("Leer numero de unidades:"); nroUnid= Integer.parseInt(teclado.readLine()); //... Calcular el importe de la venta neta impBruto= pUnit*nroUnid; if(impBruto>=200) //... Calculando los descuentos descuento= impBruto*(0.10); else descuento= impBruto*(0.05); //... Calculando el importe neto impNeto= impBruto-descuento; System.out.println("El importe de la venta neta sera: "+impNeto); } } //... Escribir un algoritmo que divida 2 numeros import java.io.*; public class b_divide { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int dividendo, divisor; double cociente; //... Leer dividendo y divisor System.out.print("Ingresar dividendo: "); dividendo= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar divisor:"); divisor= Integer.parseInt(teclado.readLine()); //... Efectuar la division if(divisor!=0){ cociente= (1.0)*dividendo/divisor; System.out.println(dividendo+"/"+divisor+"="+cociente); } else System.out.println(dividendo+"/"+divisor+"=Division por cero"); } }

//... Algoritmo que determina si un numero es par o impar import java.io.*; public class c_parImpar { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro; //... Leer numero System.out.print("Leer numero: "); nro= Integer.parseInt(teclado.readLine()); //... Verificar si es par o impar if(nro%2==0) System.out.println(nro+" es Par"); else System.out.println(nro+" es Impar"); } } //... Algoritmo que indica si un ao del siglo 20 es bisiesto o no import java.io.*; public class d_Bisiesto { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int anio; //... Ingresar ao System.out.print("Leer ao:"); anio= Integer.parseInt(teclado.readLine()); //... verificar si el ao es bisiesto o no if(anio%4==0) System.out.println(anio+" es Bisiesto"); else System.out.println(anio+" no es Bisiesto"); } } //... Algoritmo que determina el mayor de dos numeros import java.io.*; public class e_mayorDosNumeros { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, mayor; //... Leer numeros System.out.print("Leer 1er numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Leer 2do numero: "); nro2= Integer.parseInt(teclado.readLine()); if(nro1!=nro2){ if(nro1>nro2) mayor= nro1; else mayor= nro2; System.out.println(mayor+" es el mayor"); } else System.out.println("Son iguales"); } }

//... Algoritmo que permite ordenar dos numeros en forma ascedente import java.io.*; public class f_ordenar { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, aux; //... leer numeros System.out.print("Leer 1er numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Leer 2do numero: "); nro2= Integer.parseInt(teclado.readLine()); //... Ordenando numeros if(nro1>nro2){ //... Intercambiar aux= nro1; nro1= nro2; nro2= aux; } System.out.println(nro1+">"+nro2); } } //... Algoritmo que determina el mayor de tres numeros import java.io.*; public class g_mayorTres { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, nro3, mayor; //... Leer tres numero System.out.print("Leer 1er numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Leer 2do numero: "); nro2= Integer.parseInt(teclado.readLine()); System.out.print("Leer 3er numero: "); nro3= Integer.parseInt(teclado.readLine()); //... Deterimnar el numero mayor if(nro1>nro2) if(nro1>nro3) mayor= nro1; else mayor= nro3; else if(nro2>nro3) mayor= nro2; else mayor= nro3; //... Imprimir el mayor de los tres numeros System.out.println("El numero mayor sera: "+mayor); } } //... Algoritmo ue determina el mayor de tres numeros import java.io.*; public class h_mayorTres { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado;

teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, nro3, mayor; //... Leer numeros System.out.print("Leer 1er numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Leer 2do numero: "); nro2= Integer.parseInt(teclado.readLine()); System.out.print("Leer 3er numero:"); nro3= Integer.parseInt(teclado.readLine()); //... Calcula el mayor if(nro1>nro2) mayor= nro1; else mayor= nro2; if(mayor<nro3) mayor= nro3; //... Imprimir el mayor numero System.out.println("El mayor sera: "+mayor); } } //... Algoritmo que calcula el mayor de tres numeros import java.io.*; public class i_mayorTres { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, nro3, mayor; //... Leer numeros System.out.print("Leer 1er numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Leer 2do numero: "); nro2= Integer.parseInt(teclado.readLine()); System.out.print("Leer 3er numero: "); nro3= Integer.parseInt(teclado.readLine()); //... calcular el mayor mayor= nro1; if (mayor<nro2) mayor= nro2; if (mayor<nro3) mayor= nro3; //... Imprimir el mayor numero System.out.println("El mayor sera: "+mayor); } } //... Algoritmo que ordena tres numeros diferentes de forma ascendente import java.io.*; public class j_ordenarTres { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, nro3, aux; //... Leer numeros System.out.print("Leer 1er numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Leer 2do numero: "); nro2= Integer.parseInt(teclado.readLine()); System.out.print("Leer 3er numero: "); nro3= Integer.parseInt(teclado.readLine());

//... Ordenas en forma ascendente if(nro1>nro2){ //... Intercambiar aux= nro1; nro1= nro2; nro2= aux; } if(nro2>nro3){ //... Intercambio aux= nro2; nro2= nro3; nro3= aux; } if(nro1>nro2){ //... intercambio aux= nro1; nro1= nro2; nro2= aux; } //... Imprimir en orden ascendente System.out.println("Orden ascendente: "+nro1+"<"+nro2+"<"+nro3); } } /* Algoritmo que resuelve el siguiente sistema de ecuaciones: aX + bY = c dX + eY = f */ import java.io.*; public class k_ecuaciones { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int a, b, c, d, e, f; double x, y; //... Leer coeficientes System.out.println("Leer primera ecuacion"); System.out.print("Leer coeficiente a (aX): "); a= Integer.parseInt(teclado.readLine()); System.out.print("Leer coeficiente b (bY): "); b= Integer.parseInt(teclado.readLine()); System.out.print("Leer resultado c: "); c= Integer.parseInt(teclado.readLine()); System.out.println("Leer segunda ecuacion"); System.out.print("Leer coeficiente d (dX): "); d= Integer.parseInt(teclado.readLine()); System.out.print("Leer coeficiente e (eY): "); e= Integer.parseInt(teclado.readLine()); System.out.print("Leer resultado f: "); f= Integer.parseInt(teclado.readLine()); //... Calcular X, Y if(a*e-b*d != 0){ x= (c*e-b*f)/(a*e-b*d); y= (a*f-c*d)/(a*e-b*d); System.out.println("X="+x+", Y="+y); } else System.out.println("El Sistema de Ecuaciones: No tiene solucion"); } }

/* La empresa de agua potable, tiene dos tarifas que esta de acuerdo al consumo del usuario. Para los primeros 40m3 cobra S/ 0.50 y para el consumo por encima de 40m3 cobra S/ 0.80 por m3 Escribir un algoritmo que permita calcular el monto total a cobrar por un determinado consumo incluyendo el impuesto general a las ventas (IGV= 18%) */ import java.io.*; public class l_consumo { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int consumo; double montoCobrar; //... Leer el consumo de agua System.out.print("Leer consumo de agua (m3): "); consumo= Integer.parseInt(teclado.readLine()); //... Calcular el monto total a cobrar if(consumo<=40) montoCobrar= consumo*(0.5); else montoCobrar= 40*(0.5)+(consumo-40)*(0.8); //... Incluido IGV montoCobrar= montoCobrar+(montoCobrar*0.18); //... Imprimir monto a cobrar System.out.println("Para "+consumo+"m3 el cobro sera de S/"+(float)montoCobrar); } } /* La nota final de un estudiante se obtiene como el promedio aritmetico de tres examenes parciales. Escribir un algoritmo que calcule la nota final y determine si es aprobado, desaprobado, reprobado. */ import java.io.*; public class m_notaFinal { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nota1, nota2, nota3; double promedio; String observacion; //... Leer notas System.out.print("Leer primera nota: "); nota1= Integer.parseInt(teclado.readLine()); System.out.print("Leer segunda nota: "); nota2= Integer.parseInt(teclado.readLine()); System.out.print("Leer tercera nota: "); nota3= Integer.parseInt(teclado.readLine()); //... Calcular promedio y tipo de nota promedio= (nota1+nota2+nota3)/(3.0); observacion= "No se presento"; if(promedio<7) observacion= "Reprobado"; else if(promedio<11) observacion= "Desaprobado"; else observacion= "Aprobado"; //... Imprimir observacion y promedio System.out.println("Promedio Final: "+(float)promedio+" ("+observacion+")"); } }

/* Algoritmo que encuentra la solucion de una ecuacion de segundo grado (Baskara) aX2 + bX + c = 0 */ import java.io.*; public class n_ec2doGrado { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int a, b, c; double x1, x2; //... Leer coeficientes System.out.print("Leer primer coeficiente (a): "); a= Integer.parseInt(teclado.readLine()); System.out.print("Leer segundo coeficiente (b): "); b= Integer.parseInt(teclado.readLine()); System.out.print("Leer tercer coeficiente (c): "); c= Integer.parseInt(teclado.readLine()); //... Hallar la solcion cuadratica if(a != 0) if(Math.pow(b,2)-4*a*c>=0){ x1= (-b+Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a); x2= (-b-Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a); System.out.println("X1="+x1+", X2="+x2); } else System.out.println("No existe solucion en los reales"); else{ x2= (-1.0)*c/b; System.out.println("No es una ecuacion cuadratica, X1="+(float)x2); } } } /* El profesor de uan asignatura durante un semestre tomo cuatro exmenes parciales. Al final del semestre les informa a sus alumnos que pueden calcular sus promedios final eliminando la nota mas baja y promediando las tres restantes. Escribir un algoritmo para calcular la nota final del alumno */ import java.io.*; public class o_promedioFinal { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nota1, nota2, nota3, nota4, notaMenor; double pFinal; //... Leer notas System.out.print("Leer primera nota: "); nota1= Integer.parseInt(teclado.readLine()); System.out.print("Leer segunda nota: "); nota2= Integer.parseInt(teclado.readLine()); System.out.print("Leer tercera nota: "); nota3= Integer.parseInt(teclado.readLine()); System.out.print("Leer cuarta nota: "); nota4= Integer.parseInt(teclado.readLine()); //... Calcular promedio final //... Hallando la menor nota notaMenor= nota1; if(notaMenor>nota2) notaMenor= nota2;

if(notaMenor>nota3) notaMenor= nota3; if(notaMenor>nota4) notaMenor= nota4; //... Hallando la nota final pFinal= (nota1+nota2+nota3+nota4-notaMenor)/(3.0); //... Imprimir promedio final System.out.println("La nota final sera:"+(float)pFinal); } } /* Dos compaeros de colegio: Juan y Mario, comparten los gastos de habitacion y alimentacion. Van de compras juntos y conservan las notas de lo adquirido. Al final del mes, desean saber quien le debe a quien y cuanto. Escribir un algoritmo para resolver el problema. */ import java.io.*; public class p_deuda { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int gastoJ, gastoM; double monto; //... Leer gastos System.out.print("Leer Gastos de Juan: "); gastoJ= Integer.parseInt(teclado.readLine()); System.out.print("leer Gastos de Mario: "); gastoM= Integer.parseInt(teclado.readLine()); //... Calcular deudas if(gastoJ == gastoM) System.out.println("No se deben"); else if(gastoJ>gastoM){ monto= (gastoJ-gastoM)/(2.0); System.out.println("Mario debe a Juan S/."+(float)monto); } else{ monto= (gastoM-gastoJ)/(2.0); System.out.println("Juan debe a Mario S/."+(float)monto); } } } /* Algoritmo que determina si un numero de 3 digitos es igual a la suma de los cubos de sus digitos 371 es a la suma de sus cubos (digitos) 153 es a la suma de sus cubos (digitos) */ import java.io.*; public class q_sumaCubos { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro, unidad, decena, centena; //... Leer numero de tres digitos

System.out.print("Leer numero: "); nro= Integer.parseInt(teclado.readLine()); //... Descomponer numero en sus digitos unidad= nro%10; decena= (nro/10)%10; centena= (nro/10)/10; //... determinar si son iguales if(nro==(Math.pow(unidad,3)+Math.pow(decena,3)+Math.pow(centena,3))) System.out.println(nro+" es igual a la suma de sus cubos"); else System.out.println(nro+" no es igual a la suma de sus cubos"); } } /* La municipalidad provincial de andahuaylas cobra el impuesto predial urbano de acuerdo a la siguiente escala: - Valor del predio hasta S/ 10,000 exonerado el pago del impuesto predial - Valor del predio superior a S/ 10,000 e inferior a S/ 30,000 cobra el 0.5% del valor del predio - Valor del predio superio o igual a S/ 30,000 cobra el 0.8% del valor del predio Adicionalmente cobra por derechos administrativos (gastos en formatos y procesamiento de la informacion) una cuota fija de S/ 2.50 por cada contribuyente. Escribir un algoritmo que calcule el impuesto predial para un inmueble cualquiera */ import java.io.*; public class r_impuesto { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int valor; double impuesto; //... Leer el valor del predio System.out.print("Leer el valor del predio: "); valor= Integer.parseInt(teclado.readLine()); //... Calcular el impuesto if(valor<=10000) impuesto= 2.5; else if(valor<30000) impuesto= valor*(0.005)+2.5; else impuesto= valor*(0.008)+2.5; //... Imprimir el impuesto predial System.out.println("Para S/ "+valor+" el impuesto sera S/."+(float)impuesto); } } //... Algoritmo que transforma coordenadas rectangulares a polares import java.io.*; public class s_rectangularPolar { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int x, y; double angulo, radio;

//... Leer coordenadas rectangulares System.out.print("Leer coordenada x: "); x= Integer.parseInt(teclado.readLine()); System.out.print("Leer coordenada y: "); y= Integer.parseInt(teclado.readLine()); //... Transformar coordenadas rectangulares a polares radio= Math.sqrt(x*x+y*y); //... Calculando el radio if(x==0) if(y==0) angulo= 0; else if(y>0) angulo= 90; else angulo= 270; else if(x>0) if(y>0) angulo= Math.atan(y/x); else angulo= 360+ Math.atan(y/x); else angulo= 180+Math.atan(y/x); //... Imprimir coordenadas polares System.out.println("Radio:"+ (float)radio+", Angulo:"+(float)angulo); } } /* Algoritmo que lee un fecha (dd/mm/aa) y determina la fecha correspondiente al dia siguiente */ import java.io.*; public class t_diaSiguiente { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int dia, mes, anio, nroDias; //... Leer fecha System.out.print("Leer dia: "); dia= Integer.parseInt(teclado.readLine()); System.out.print("Leer mes: "); mes= Integer.parseInt(teclado.readLine()); System.out.print("Leer ao: "); anio= Integer.parseInt(teclado.readLine()); //... Determinar la fecha del dia siguiente if(mes==1 || mes==3 || mes==5 || mes==7 || mes==8|| mes==10 || mes==12) nroDias= 31; else if(mes==4 || mes==6 || mes==9 || mes==11) nroDias= 30; else if(anio%4==0)//... Ao bisiesto nroDias= 29; else nroDias= 28; //... Agregar a fecha un dia if(dia<nroDias) dia= dia+1;

else if(mes<12){ dia= 1; mes= mes+1; } else{ dia= 1; mes= 1; anio= anio+1; } //... Imprimir la fecha siguiente System.out.println("La fecha siguiente sera:"+dia+"/"+mes+"/"+anio); } } //... Algoritmo que determina el myor de dos fechas import java.io.*; public class u_mayorFechas { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int diaA, mesA, anioA, diaB, mesB, anioB; //... Leer primera fecha System.out.println("Leer primera fecha"); System.out.print("Leer dia: "); diaA= Integer.parseInt(teclado.readLine()); System.out.print("Leer mes: "); mesA= Integer.parseInt(teclado.readLine()); System.out.print("Leer ao: "); anioA= Integer.parseInt(teclado.readLine()); //... Leer segunda fecha System.out.println("Leer segunda fecha"); System.out.print("Leer dia: "); diaB= Integer.parseInt(teclado.readLine()); System.out.print("Leer mes: "); mesB= Integer.parseInt(teclado.readLine()); System.out.print("Leer ao: "); anioB= Integer.parseInt(teclado.readLine()); //... Determinar la fecha mayor if(anioA>anioB) System.out.println("La mayor fecha sera:"+diaA+"/"+mesA+"/"+anioA); else if(anioB>anioA) System.out.println("La mayor fecha sera:"+diaB+"/"+mesB+"/"+anioB); else if(mesA>mesB) System.out.println("La mayor fecha sera:"+diaA+"/"+mesA+"/"+anioA); else if(mesB>mesA) System.out.println("La mayor fecha sera:"+diaB+"/"+mesB+"/"+anioB); else if(diaA>diaB) System.out.println("La mayor fecha sera:"+diaA+"/"+mesA+"/"+anioA); else if(diaB>diaA) System.out.println("La mayor fecha sera:"+diaB+"/"+mesB+"/"+anioB); else System.out.println("Las fechas son iguales"); } }

//... Algoritmo que determina la mayor de dos fechas import java.io.*; public class v_mayorFechas { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int diaA, mesA, anioA, diaB, mesB, anioB, nroFechaA, nroFechaB; //... Leer primera fecha System.out.println("Leer primera fecha"); System.out.print("Leer dia: "); diaA= Integer.parseInt(teclado.readLine()); System.out.print("Leer mes: "); mesA= Integer.parseInt(teclado.readLine()); System.out.print("Leer ao: "); anioA= Integer.parseInt(teclado.readLine()); //... Leer segunda fecha System.out.println("Leer segunda fecha"); System.out.print("Leer dia: "); diaB= Integer.parseInt(teclado.readLine()); System.out.print("Leer mes: "); mesB= Integer.parseInt(teclado.readLine()); System.out.print("Leer ao: "); anioB= Integer.parseInt(teclado.readLine()); //... Determinas la mayor fecha nroFechaA= anioA*10000+mesA*100+diaA; nroFechaB= anioB*10000+mesB*100+diaB; if(nroFechaA>nroFechaB) System.out.println("La mayor fecha sera:"+diaA+"/"+mesA+"/"+anioA); else if(nroFechaB>nroFechaA) System.out.println("La mayor fecha sera:"+diaB+"/"+mesB+"/"+anioB); else System.out.println("Las fechas son iguales"); } } //... Algoritmo que determina de que tipo de triangulo se trata import java.io.*; public class w_tipoTriangulo { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int ladoA=0, ladoB=0, ladoC=0; //... Leer lados System.out.print("Leer primer lado: "); ladoA= Integer.parseInt(teclado.readLine()); System.out.print("Leer segundo lado: "); ladoB= Integer.parseInt(teclado.readLine()); System.out.print("Leer tercer lado: "); ladoC= Integer.parseInt(teclado.readLine()); if(ladoA==ladoB) if(ladoA==ladoC || ladoB==ladoC) System.out.println("Triangulo equilatero"); else System.out.println("Triangulo isoceles"); else if(ladoA==ladoC ||ladoB==ladoC) System.out.println("Triangulo isoceles"); else System.out.println("Triangulo escaleno"); } }

//... Algoritmo que determina que tipo de angulo es import java.io.*; public class x_angulo { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int angulo; //... Leer angulo System.out.println("Leer angulo: "); angulo= Integer.parseInt(teclado.readLine()); if (angulo<=0)System.out.println("No hay angulo"); else if(angulo<90)System.out.println("Angulo Agudo"); else if(angulo==90)System.out.println("Angulo Recto"); else if(angulo<180)System.out.println("Angulo Obtuso"); else if(angulo==180)System.out.println("Angulo Plano"); else if(angulo<360)System.out.println("Angulo Concavo"); else if(angulo==360)System.out.println("Angulo de una vuelta"); else System.out.println("Angulo mayor a una vuelta"); } } //... Algoritmo que determina la hora leida mas un segundo despues import java.io.*; public class y_horaMasUnSegundo { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int HH, MM, SS; //... Leer la hora System.out.println("Leer horas: "); HH= Integer.parseInt(teclado.readLine()); System.out.println("Leer minutos:"); MM= Integer.parseInt(teclado.readLine()); System.out.println("Leer segundos: "); SS= Integer.parseInt(teclado.readLine()); //... Calcular la hora mas un segundo despues SS++; if(SS>59){ SS= 0; MM++; } if(MM>59){ MM= 0; HH++; } if(HH>23){ HH= 0; } System.out.println("La nueva hora sera: "+HH+":"+MM+":"+SS); } }

ALGORITMOS DE SELECCIN MULTIPLE //... Algoritmo que lee el mes y ao de una fecha y determina el numero de dias import java.io.*; public class a_nroDias { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int mes, anio, nroDias= 0; //... Leer mes y ao System.out.print("Leer mes: "); mes= Integer.parseInt(teclado.readLine()); System.out.print("Leer ao: "); anio= Integer.parseInt(teclado.readLine()); //... Determinar numero de dias del mes switch(mes){ case 1: nroDias= 31; break; case 3: nroDias= 31; break; case 5: nroDias= 31; break; case 7: nroDias= 31; break; case 8: nroDias= 31; break; case 10: nroDias= 31; break; case 12: nroDias= 31;break; case 4: nroDias= 30; break; case 6: nroDias= 30; break; case 9: nroDias= 30; break; case 11: nroDias= 30; break; case 2:if(anio%4==0) nroDias= 29; else nroDias= 28; break; } if(nroDias!=0) System.out.println("El "+mes+"/"+anio+" contiene:"+nroDias+" dias"); else System.out.println("Fecha ingresada es incorrecta"); } }

ALGORITMOS DE REPETICIN (DO-WHILE) //... Algoritmo que imprime "Programar es facil" y los multiplos de 5 (cinco veces) public class a_acumulador { public static void main(String[] args) { //... Declarar variables String mensaje= "Programar es facil:"; int k= 1; //... Imprimiendo System.out.println(mensaje+k); k= k+1; System.out.println(mensaje+k); k= k+1; System.out.println(mensaje+k); k= k+1; System.out.println(mensaje+k); k= k+1; System.out.println(mensaje+k); } } //... Algoritmo que imprime y cuenta cinco veces "Programar es facil" public class b_contador { public static void main(String[] args) { //... Declarar variables String mensaje; int k; //... Inicializando variables mensaje= "Programar es facil:"; k= 1; //... Imprimiendo y contando System.out.println(mensaje+k); k++; System.out.println(mensaje+k); k++; System.out.println(mensaje+k); k++; System.out.println(mensaje+k); k++; System.out.println(mensaje+k); } } //... Algoritmo que imprime programar es facil 10 veces public class c_repeat { public static void main(String[] args) { //... Declarar variables String mensaje; int k; //... Inicializando variables mensaje= "Programar es facil:"; k= 1; //... Imprimiendo mensajes do{ System.out.println(mensaje+k); k++; }while(k<=10); } }

//... Algoritmo que imprime los n primeros enteros positivos import java.io.*; public class d_nEnteros { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k; //... Leendo los n-primeros numeros System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Imrimir los n primero enteros positivos k= 1; //... Inicializando variables do{ System.out.println(k+" es entero positivo"); k++; }while(k<=n); } } //... Algoritmo que valida el ingreso de notas import java.io.*; public class e_validarNota { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nota; //... Validando nota do{ System.out.print("Ingresar nota: "); nota= Integer.parseInt(teclado.readLine()); }while(nota<0 || nota>20); System.out.println("La nota "+nota+" es correcta"); } } //... Algoritmo que imprime los n-primeros numeros impares (positivos) import java.io.*; public class f_Nimpares { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, impar; //... Leer n System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Inicializando variables k=1; do{ impar= 2*k - 1; System.out.println("Impar positivo:"+impar); k++; }while(k <= n); } }

//... Algoritmo que imprime los n-primeros impares positivos (enteros) import java.io.*; public class g_nImpares { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, impar; //... Leer n System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Inicializar variables k= 1; do{ impar= 2*k - 1; System.out.println("Impar positivo:"+impar); k++; }while(n >= k); } } //... Algoritmo que imprime la tabla de multiplicar hasta el doce de un numero "n" import java.io.*; public class h_tablaMultiplicar { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k ,mult; //... Leer N System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Construir tabla de multiplicar k= 1; do{ mult= n*k; System.out.println(n+" x "+k+" = "+mult); k++; }while(k<=12); } } /* Algoritmo que imprima el numero, el cuadrado y el cubo de los n-primeros numeros enteros positivos */ import java.io.*; public class i_cuadradoCubo { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, cuadrado, cubo; //... Leer numero de elementos System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Imprimir numero, cuadrado y cubo k= 1; //... Inicializar variables do{ cuadrado= k*k; cubo= k*k*k; System.out.println("Nro:"+k+", cuadrado:"+cuadrado+", cubo:"+cubo); k++; }while(k <= n); } }

/* Algoritmo que imprima el numero, el cuadrado y el cubo de los n-primeros numeros enteros positivos */ import java.io.*; public class j_cuadradoCubo { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k; double cuadrado, cubo; //... Leer numero de elementos System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Imprimir numero, cuadrado y cubo k= 1; //... Inicializar variables do{ cuadrado= Math.pow(k,2); cubo= Math.pow(k,3); System.out.println("Nro:"+k+", cuadrado:"+cuadrado+", cubo:"+cubo); k++; }while(n>=k); } } /* Se tiene una relacion de n-estudiantes, para cada uno se tiene tres notas. Escribir un algoritmo que calcule el promedio de cada estudiante. */ import java.io.*; public class k_promedio { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, nota1, nota2, nota3; double promedio; //... Ingresar datos System.out.print("Ingresar numero de estudiantes: "); n= Integer.parseInt(teclado.readLine()); //... Calcular el promedio de los n-estudiantes k= 1;//... Inicializando variables do{ System.out.println("Estudiante "+k); System.out.print("Ingresar primera nota:"); nota1= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar segunda nota:"); nota2= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar tercera nota:"); nota3= Integer.parseInt(teclado.readLine()); //... Calcular el promedio promedio= (nota1+nota2+nota3)/(3.0); System.out.println("Promedio del estudiante "+k+" sera:"+(float)promedio); k++; }while(n>=k); } }

//... Algoritmo que calcula la suma de los n-primeros numeros enteros positivos import java.io.*; public class l_sumaPositivos { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, suma; //... Leer n-primeros System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Calcular la suma de los n-primeros k= 1; //... Inicializar variables suma= 0; do{ suma= suma + k; k++; }while(n>=k); //... Imprimir resultados System.out.println("La suma de los "+n+"-primeros sera:"+suma); } } /* El centro meteorologio de la UNAJMA se tiene registrado las temperaturas diarias minimas del ao 2010. Elaborar un algoritmo que permita determinar cuantos dias fueron con heladas y cuantos sin helada. Se considera un dia con helada cuando la temperatura minima de ese dia es menor o igual a cero. */ import java.io.*; public class m_temperatura { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nroDias, k, temperatura, conHelada, sinHelada; //... leer datos System.out.print("Ingresar nro de dias: "); nroDias= Integer.parseInt(teclado.readLine()); /* Leer temperaturas diarias minimas y determinar el numero de dias con helada o sin helada*/ //... Inicializando variables conHelada= 0; sinHelada= 0; k= 1; do{ System.out.print("Ingresar temperatura para el dia "+k+":"); temperatura= Integer.parseInt(teclado.readLine()); if(temperatura<=0) conHelada++; else sinHelada++; k++; }while(k<=nroDias); System.out.println("Hubo: "+conHelada+" dias con helada"); System.out.println("Hubo: "+sinHelada+" dias sin helada"); } }

/* Algoritmo que calcule la suma de la siguiente expresion: (1/100) + (2/99) + (3/98) + (4/97) + ... + (99/2) + (100/1) */ public class n_expresion { public static void main(String[] args) { //... Inicializando variables int numerador= 1, denominador= 100; double suma= 0; do{ suma= ((1.0)*numerador/denominador)+suma; numerador++; denominador--; }while(denominador != 0); //... Imprimir resultados System.out.println("El resultado de la expresion sera: "+(float)suma); } } /* Algoritmo que evalue la siguiente expresion: 12 22 + 32 42 + 52 62 + ... + 992 -1002 */ public class o_expresion { public static void main(String[] args) { //... Inicializar variables int par= 0, impar= 0, suma= 0, k= 1; do{ if(k%2==0) par= par+(k*k); else impar= impar+(k*k); k++; }while(k <= 100); suma= impar-par; //... Imprimir resultados System.out.println("El resultado de la expresion sera: "+suma); } } /* Algoritmo que evalue la siguiente expresion: 12 22 + 32 42 + 52 62 + ... + 992 -1002 */ public class p_expresion { public static void main(String[] args) { //... Inicializar variables int suma= 0, k= 1; do{ if(k%2==0) suma= suma-(k*k); else suma= suma+(k*k); k++; }while(k <= 100); //... Imprimir resultados System.out.println("El resultado de la expresion sera: "+suma); } }

/* Algoritmo que evalue la siguiente expresion: 12 22 + 32 42 + 52 62 + ... + 992 -1002 */ public class q_expresion { public static void main(String[] args) { //... Inicializar variables int suma= 0, k= 1; do{ suma= suma+(k*k); //... Suma impares k++; suma= suma-(k*k); //... Resta pares k++; }while(k <= 100); //... Imprimir resultados System.out.println("El resultado de la expresion sera: "+suma); } } /* Algoritmo que evalue la siguiente expresion: 12 22 + 32 42 + 52 62 + ... + 992 -1002 */ public class r_expresion { public static void main(String[] args) { //... Inicializando variables int k= 1, signo = -1, suma= 0; //... Calculando expresion do{ signo= signo*(-1); suma= suma + signo*(k*k); k++; }while(k<= 100); //... Imprimir suma System.out.println("El resultado de la expresion sera: "+suma); } } //... Algoritmo que calcula el promedio aritmetico de n-estudiante import java.io.*; public class s_promedioN { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, nota, suma; double promedio; //... Leer numero de elementos System.out.print("Ingresar nro de estudiantes: "); n= Integer.parseInt(teclado.readLine()); //... Inicializando variables k= 1; suma= 0; do{ System.out.print("Ingresar nota estudiante "+k+": "); nota= Integer.parseInt(teclado.readLine()); suma= suma+nota; k++; }while(n>=k); promedio= (1.0)*suma/n; //... Imprimir el promedio System.out.println("El promedio aritmetico sera:"+(float)promedio); } }

ALGORITMOS DE REPETICIN (WHILE) //... Algoritmo que imprime los n-primeros enteros positivos import java.io.*; public class a_nEnteros { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k; //... Leer n System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Imprimir los n- primeros enteros positivos k= 1; while(n>=k){ System.out.println("Entero positivo:"+k); k++; } } } //... Algoritmo que calcula el factorial de un numero entero positivo import java.io.*; public class b_factorial { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, factorial; //... Leer n System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Calcular factorial k= 1; factorial= 1; while(k<=n){ factorial= factorial*k; k++; } //... Imprimir factorial System.out.println("El factorial de "+n+" sera: "+factorial); } } //... Algoritmo que calcula el maximo comun divisor de dos numeros import java.io.*; public class c_MCD { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, resto; //... Ingresar numeros System.out.print("Ingresar primer numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar segundo numero:"); nro2= Integer.parseInt(teclado.readLine());

//... calcular el MCD de dos numeros while(nro1%nro2 != 0){ resto= nro1%nro2; nro1= nro2; nro2= resto; } //... Imprimir MCD System.out.println("El MCD sera: "+nro2); } } //... Algoritmo que determina el numero de digitos de un numero entero positivo import java.io.*; public class d_nroDigitos { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro, nroDigitos; //... Leer numero System.out.print("Leer numero: "); nro= Integer.parseInt(teclado.readLine()); //... Calcular numero de digitos nroDigitos= 0; while(nro>0){ nro= nro/10; nroDigitos++; } System.out.println("Numero de digitos: "+nroDigitos); } } /* Algoritmo que calcula el cociente y residio entero de la division de dos numeros enteros mediante restas sucesivas */ import java.io.*; public class e_cocienteResto { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int dividendo, divisor, cociente, resto; //... Ingresar numeros System.out.print("Ingresar dividendo: "); dividendo= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar divisor: "); divisor= Integer.parseInt(teclado.readLine()); //... calcular el cociente y del residuo cociente= 0; resto= dividendo; while(resto-divisor >= 0){ resto= resto - divisor; cociente++; } System.out.println("Cociente: "+cociente+", Desiduo: "+resto); } }

/* Algoritmo que permita calcular el producto de dos numero enteros positivos utilizando el algoritmo ruso de la multiplicacion */ import java.io.*; public class f_productoRuso { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro1, nro2, factor1, factor2, producto; //... Ingresar numeros System.out.print("Ingresar primer numero: "); nro1= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar segundo numero: "); nro2= Integer.parseInt(teclado.readLine()); //... Calcular la multiplicacion rusa factor1= nro1; factor2= nro2; producto= 0; while(factor2>0){ if(factor2%2 == 1) //... Impar producto= producto+factor1; factor1= factor1*2; factor2= factor2/2; } //... Imprimir resultados System.out.println(nro1+"x"+nro2+"="+producto); } } /* Algoritmo que determina la potencia de un numero elevado a la n (n-entero positivo) */ import java.io.*; public class g_potencia { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro, exponente, potencia, k; //... Leer numero y potencia System.out.print("Leer numero: "); nro= Integer.parseInt(teclado.readLine()); System.out.print("Ingresar exponente: "); exponente= Integer.parseInt(teclado.readLine()); //... Calculando la potencia k= 1; potencia= nro; while(exponente>k){ potencia= potencia*nro; k++; } System.out.println(nro+" elevado a la "+exponente+" sera:"+potencia); } }

//... Algoritmo que convierte un numero de base diez a base dos import java.io.*; public class h_binario { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado = new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro,binario= 0, diez= 1; //... Leer numero System.out.println("Leer numero: "); nro= Integer.parseInt(teclado.readLine()); //... Convertir a binario while(nro>0){ binario= (nro%2)*diez + binario; diez= diez*10; nro= nro/2; } System.out.println("El numero base dos sera:"+binario); } } //... Algoritmo que invierte un numero import java.io.*; public class i_invertirNumero { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int nro, nroInvertido= 0; //... Leer numero System.out.print("Leer Numero: "); nro= Integer.parseInt(teclado.readLine()); //... Invertir numero while(nro>0){ nroInvertido= nro%10 + nroInvertido*10; nro= nro/10; } System.out.println("Numero invertido: "+nroInvertido); } }

ALGORITMOS DE REPETICIN ANIDADAS //... Algoritmo que que calcule el factorial de los n-primeros enteros positivos import java.io.*; public class a_factorial { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, k, j, factorial; //... Leer n System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Calculando el factorial de los n-primeros enteros k= 1; while(n>=k){ j= k; factorial= 1; while(j>0){ //... Calculando factorial factorial= factorial*j; j--; } System.out.println("Factorial de "+k+" sera:"+factorial); k++; } } }

ALGORITMOS DE REPETICIN (FOR) /* Algoritmo que imprime el numero, el cuadrado y el cubo de los n-primeros enteros positivos */ import java.io.*; public class a_cuadradoCubo { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n; //... Leer n System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Imprimimiendo, numero cuadrado y cubos for(int i= 1; i<=n; i++) System.out.println("Nro:"+i+", Cuadrado:"+(i*i)+", Cubo:"+(i*i*i)); } } //... Algoritmo que permite calcular el promedio aritmetico de n- numeros import java.io.*; public class b_promedio { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, nro; float promedio= 0; //... Leer n System.out.print("Leer n: "); n= Integer.parseInt(teclado.readLine()); //... Calculando promedio aritmetico for(int i= 1; i<=n; i++){ System.out.print("Ingresar nro"+i+": "); nro= Integer.parseInt(teclado.readLine()); promedio= promedio + nro; } promedio= promedio/n; System.out.println("El promedio aritmetico sera:"+promedio); } } /* Algoritmo que determina la nota mas baja, la mas alta, el promedio, el numero de aprobados, desaprobado y reprobados */ import java.io.*; public class c_tipoNota { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, menor, mayor, aprob, desap, reprob, nota; float promedio; //... Ingresar numero de estudiantes System.out.print("Ingresar numero de estudiantes: "); n= Integer.parseInt(teclado.readLine());

//... Inicializando variables menor= 20; mayor= 0; aprob= 0; desap= 0; reprob= 0; promedio= 0; for(int i= 1; i<=n; i++){ System.out.print("Ingresar nota del estudiante "+i+": "); nota= Integer.parseInt(teclado.readLine()); //... Calculando requerimiento if(menor>nota) //... verificando si hay una nota menor menor= nota; if(mayor<nota) //... verificando si hay una nota mayor mayor= nota; //... Acumulando las notas promedio= promedio+nota; //... Calculando numero de aprobados, desaprobados y reprobados if(nota<7) reprob++; //... Incrementamos el numero de reprobados else if(nota<11) desap++; //... Incrementamos el numero de desaprobados else aprob++; //... Incrementamos el numero de aprobados } promedio= promedio/n; //... Calculando el promedio //... Imprimir resultados System.out.println("La nota mas baja sera: "+menor); System.out.println("La nota mas alta sera: "+mayor); System.out.println("Hay "+aprob+" estudiantes aprobados"); System.out.println("Hay "+desap+" estudiantes desaprobados"); System.out.println("Hay "+reprob+" estudiantes reprobados"); System.out.println("El promedio aritmetico sera:"+promedio); } } // Algoritmo que imprime la serie fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... import java.io.*; public class d_fibonacci { public static void main(String[] args) throws IOException{ //... Definimos variable para leer datos e ingresados desde el teclado BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in)); //... Declarar variables int n, penultimo, ultimo, fibonacci; //... Leer n System.out.print("Leer n-esimo termino: "); n= Integer.parseInt(teclado.readLine()); //... Inicializar variables penultimo=0; ultimo=1; fibonacci= 0; //... Calcula el enesimo numero de la serie if(n<2) System.out.println(penultimo); else{ System.out.print(penultimo); System.out.print(", "+ultimo); //... Imprimir serie for(int i=3;i<=n;i++){ fibonacci= penultimo+ultimo; System.out.print(", "+fibonacci); penultimo= ultimo; ultimo= fibonacci; } } System.out.println("... serie fibonacci"); } }

MODULARIDAD CON PROCEDIMIENTO Y FUNCIONES (PUBLIC STATIC) //... En esta seccion se creara un solo programa principal que contenga varios modulos import java.io.*; public class a_modulos { //...Programa modular que retorna el mayor de dos numeros public static int mayor(int nro1, int nro2){ if(nro1>nro2) return nro1; else return nro2; } //...Programa modular que retorna el menor de dos numeros public static int menor(int nro1, int nro2){ if(nro1>nro2) return nro2; else return nro1; } //...Programa modular que determina el mayor de tres numeros public static int mayor(int nro1, int nro2, int nro3){ return mayor(mayor(nro1,nro2),nro3); } //...Programa modular que determina el mayor de cuatro numeros public static int mayor(int nro1, int nro2, int nro3, int nro4){ return mayor(mayor(nro1,nro2),mayor(nro3, nro4)); } //...Programa modular que determina el menor de tres numeros public static int menor(int nro1, int nro2, int nro3){ return menor(menor(nro1,nro2),nro3); } //...Programa modular que determina el menor de cuatro numeros public static int menor(int nro1, int nro2, int nro3, int nro4){ return menor(menor(nro1,nro2),menor(nro3,nro4)); } //...Programa modular que ordena dos numeros de forma ascendente public static void ordenaAscendente(int nro1, int nro2){ if(nro1>nro2){ int aux= nro1; nro1= nro2; nro2= aux; } System.out.println(nro1+"<"+nro2); } //...Programa que valida las notas ingresadas desde el teclado public static int leerNota(BufferedReader teclado) throws IOException{ int nota; do{ System.out.print("Leer nota: "); nota= Integer.parseInt(teclado.readLine()); }while(nota<0 || nota>20); return nota; } //...Programa que valida un entero ingresadas desde el teclado public static int leerEntero(int min, int max, String texto, BufferedReader teclado) throws IOException{ int entero; do{ System.out.print(texto); entero= Integer.parseInt(teclado.readLine()); }while(entero<min || entero>max); return entero; }

//...Programa que calcula el promedio de tres notas, validandola public static double promedio(BufferedReader teclado) throws IOException{ int nota1= leerNota(teclado); int nota2= leerNota(teclado); int nota3= leerNota(teclado); //... Calcular promedio return (nota1+nota2+nota3)/3.0; } //...En un examen de suficiencia cuatro jurados emiten una nota entre cero //y veinte. para optener el promedio final solo se considera las notas //intermedias, descartandose la mas alta y la mas baja. Escribir un programa //modular para calcular el promedio public static double Suficiencia(BufferedReader teclado) throws IOException{ int nota1= leerNota(teclado); int nota2= leerNota(teclado); int nota3= leerNota(teclado); int nota4= leerNota(teclado); //... Calcuylando el mayor y el menor int mayor= mayor(mayor(nota1, nota2),mayor(nota3, nota4)); int menor= menor(menor(nota1, nota2),menor(nota3, nota4)); return (nota1+nota2+nota3+nota4-mayor-menor)/2.0; } //...Programa modular que calcula el factorialde un numero public static int factorial(int nro){ int fact= 1; for(int i=1; i<=nro; i++) fact= fact*i; //... Retornando el factorial del numero return fact; } //...Programa que convierte grados sexagesimales a radianes public static double sexRadianes(int angulo){ return angulo*Math.PI/180; } //...Escribir un programa modular que clacule el seno de un algulo a partir //de la siguiente expresion //Seno(x)=(x1/1!)-(x3/3!)+(x5/5!)-(x7/7!)+... //Donde x hay que convertirlo a radianes public static double seno(int angulo){ double expresion=0,angRadianes=sexRadianes(angulo),num=angRadianes; int den=1, signo= 1, impar= 1; do{ expresion= expresion+signo*(num/den); num= num*(angRadianes*angRadianes); impar= impar+2; den= den*(impar-1)*(impar); signo= signo*(-1); }while(0.0001<num/den); //... retornar el seno del angulo return expresion; }

//...Programa modular que dada dos fechas determine la fecha posterior (la fecha ultima) public static String fechaPosterior1(int d1,int m1,int a1,int d2,int m2,int a2){ if(a1>a2) return d1+"/"+m1+"/"+a1; else if(a1<a2) return d2+"/"+m2+"/"+a2; else //...Los aos son iguales if(m1>m2) return d1+"/"+m1+"/"+a1; else if(m1<m2) return d2+"/"+m2+"/"+a2; else //... Los meses son iguales if(d1>d2) return d1+"/"+m1+"/"+a1; else if(d1<d2) return d2+"/"+m2+"/"+a2; else return "Las fechas son iguales"; } //...Programa modular que dada dos fechas determine la fecha posterior //(la fecha ultima) public static String fechaPosterior2(int d1,int m1,int a1,int d2,int m2,int a2){ if(d1+m1*100+a1*10000!=d2+m2*100+a2*10000) if (d1+m1*100+a1*10000>d2+m2*100+a2*10000) return d1+"/"+m1+"/"+a1; else return d2+"/"+m2+"/"+a2; else return "Las fechas son iguales"; } //...Programa modular que valida un numero entre un maximo y un minimo public static int validaEntero(int min,int max,BufferedReader teclado) throws IOException{ int entero; do{ System.out.print("Leer nro Entero: "); entero= Integer.parseInt(teclado.readLine()); }while(entero<min || entero>max); //... Retornar numero validado return entero; } //...Programa modular que determina el numero de dias de una fecha ingresada public static int nroDias(int mes, int anio){ int nroD= 0; switch(mes){ case 1: nroD=31; break; case 3: nroD=31; break; case 5: nroD=31; break; case 7: nroD=31; break; case 8: nroD=31; break; case 10: nroD=31; break; case 12: nroD=31; break; case 4: nroD=30; break; case 6: nroD=30; break; case 9: nroD=30; break; case 11: nroD=30; break;

case 2: if(anio%4==0) nroD=29; else nroD=28; break; } return nroD; } //...Programa modular que determina la fecha anterior a la dada public static String fechaAnterior(int dia, int mes, int anio){ if(dia>1) dia= dia-1; else //... dia 01 if(mes>1){ mes= mes-1; dia= nroDias(mes,anio); } else{//...dia=1, mes=1 dia= 31; mes= 12; anio= anio-1; } return dia+"/"+mes+"/"+anio; } /* Se lee n-notas en un salon de clase y se desea determinar la nota mayor la nota menor, el promedio de notas, numero de aprobados, desaprobados y reprobados */ public static void nNotas(int nro,BufferedReader teclado)throws IOException{ //... Declarando e inicializando variables int nota, suma= 0, aprobado= 0, desaprobado= 0, reprobado= 0; int mayor= 0, menor= 20; float promedio; for(int i=1; i<=nro; i++){ nota= leerNota(teclado); //... Calculando la mayor y menos nota if(nota>mayor) mayor= nota; if(nota<menor) menor= nota; //... Sumando la nota ingresada suma= suma+nota; //... Determinar si la nota es aprobatoria, desaprobatoria o reprobatoria if(nota<7) reprobado++; else if(nota<11) desaprobado++; else aprobado++; } System.out.println("La nota mayor sera: "+mayor); System.out.println("La nota menor sera: "+menor); System.out.println("El numero de aprobados sera: "+aprobado); System.out.println("El numero de desaprobados sera: "+desaprobado); System.out.println("El numero de reprobados sera: "+reprobado); //... Calculando el promedio promedio= (float)suma/nro; System.out.println("El promedio sera:"+promedio); }

//...PROGRAMA PRINCIPAL public static void main(String[] args) throws IOException{ // Declarar variable de lectura BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); } } /* Escribir un programa que muestre en la pantalla las tablas de sumar y multiplicar de los numeros del uno al doce */ import java.io.*; public class b_tablas { public static void menu(){ System.out.println("*****************************"); System.out.println("*TABLA SUMA Y MULTIPLICACION*"); System.out.println("*****************************"); System.out.println("* 1.- Tabla de Sumar *"); System.out.println("* 2.- Tabla de Restar *"); System.out.println("* 3.- Tabla de Multiplicar *"); System.out.println("* 4.- Tabla de Dividir *"); System.out.println("* 5.- Tabla de Potencia *"); System.out.println("* 6.- Salir *"); System.out.println("*****************************"); System.out.print("Ingrese su opcion: "); } public static void tablaSuma(int nro){ for(int i= 1; i<=12; i++) System.out.println(nro+"+"+i+"="+(i+nro)); } public static void tablaRestar(int nro){ for(int i= 1; i<=12; i++) System.out.println(nro+"-"+i+"="+(nro-i)); } public static void tablaMultiplicacion(int nro){ for(int i= 1; i<=12; i++) System.out.println(nro+"x"+i+"="+(i*nro)); } public static void tablaDividir(int nro){ for(float i= 1; i<=12; i++) System.out.println(nro+"/"+i+"="+(nro/i)); } public static void tablaPotencia(int nro){ int potencia= nro; for(int i= 1; i<=12; i++){ System.out.println(nro+"^"+i+"="+potencia); potencia= potencia*nro; } } // PROGRAMA PRINCIPAL public static void main(String[] args) throws IOException{ // Declarar variable de lectura BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); int nro, opcion; do{ menu(); opcion= Integer.parseInt(teclado.readLine());

switch(opcion){ case 1: System.out.print("De que numero:"); nro= Integer.parseInt(teclado.readLine()); tablaSuma(nro); break; case 2: System.out.print("De que numero:"); nro= Integer.parseInt(teclado.readLine()); tablaRestar(nro); break; case 3: System.out.print("De que numero:"); nro= Integer.parseInt(teclado.readLine()); tablaMultiplicacion(nro); break; case 4: System.out.print("De que numero:"); nro= Integer.parseInt(teclado.readLine()); tablaDividir(nro); break; case 5: System.out.print("De que numero:"); nro= Integer.parseInt(teclado.readLine()); tablaPotencia(nro); break; } }while(opcion<6); } } // Escribir un programa que muestre en la pantalla las areas geomtricas import java.io.*; public class c_figuraGeometrica { public static void menu(){ System.out.println("**********************************"); System.out.println("*AREAS GEOMETRICAS *"); System.out.println("**********************************"); System.out.println("* 1.- Area del cuadrado *"); System.out.println("* 2.- Area del triangulo *"); System.out.println("* 3.- Area de la circunferencia *"); System.out.println("* 4.- Area del rectangulo *"); System.out.println("* 5.- Area del cubo *"); System.out.println("* 6.- Area de la piramide *"); System.out.println("* 7.- Area de la esfera *"); System.out.println("* 8.- Area del paralelepipedo *"); System.out.println("* 9.- Salir *"); System.out.println("**********************************"); System.out.print("Ingrese su opcion: "); } public static int leerEntero(int min, int max, String texto, BufferedReader teclado) throws IOException{ int entero; do{ System.out.print(texto); entero= Integer.parseInt(teclado.readLine()); }while(entero<min || entero>max); return entero; }

public static int areaCuadrado(int lado){ return lado*lado; } public static double areaTriangulo(int base, int altura){ return base*altura/2.0; } public static double areaCircunferencia(int radio){ return Math.PI*radio*radio; } public static int areaRectangulo(int baseMayor, int baseMenor){ return baseMayor*baseMenor; } public static int areaCubo(int lado){ return areaCuadrado(lado)*lado; } public static double areaPiramide(int base, int altura, int alturaP){ return areaTriangulo(base, altura)*alturaP;//... Hay que corregir } public static double areaEsfera(int radio){ return 4*areaCircunferencia(radio); } public static int areaParalelepipedo(int baseMayor, int baseMenor, int altura){ return areaRectangulo(baseMayor, baseMenor)*altura; } public static void main(String[] args) throws IOException{ // Declarar variable de lectura BufferedReader teclado; teclado= new BufferedReader(new InputStreamReader(System.in)); //... Inicializando varaibles int opcion; do{ menu(); opcion= Integer.parseInt(teclado.readLine()); switch(opcion){ case 1: int lado= leerEntero(0, 100, "Ingrese lado: ", teclado); System.out.println("El area sera: "+areaCuadrado(lado)); break; case 2: int base= leerEntero(0, 100, "Ingrese base: ", teclado); int altura= leerEntero(0, 100, "Ingrese altura: ", teclado); System.out.println("El area sera: "+areaTriangulo(base, altura)); break; case 3: int radio= leerEntero(0, 100, "Ingrese radio: ", teclado); System.out.println("Area sera: "+areaCircunferencia(radio)); break; case 4: int ladoMayor= leerEntero(0, 100, "Ingrese lado mayor: ", teclado); int ladoMenor= leerEntero(0, 100, "Ingrese lado menor: ", teclado); System.out.println("Area sera: "+areaRectangulo(ladoMayor, ladoMenor)); break; case 5: int ladoC= leerEntero(0, 100, "Ingrese lado: ", teclado); System.out.println("El area sera: "+areaCubo(ladoC)); break;

case 6: int baseT= leerEntero(0, 100, "Ingrese base: ", teclado); int alturaT= leerEntero(0, 100, "Ingrese altura: ", teclado); int alturaPi= leerEntero(0, 100, "Ingrese altura de la Piramide: ", teclado); System.out.println("El area sera: "+areaPiramide(baseT, alturaT, alturaPi)); break; case 7: int radioE= leerEntero(0, 100, "Ingrese radio: ", teclado); System.out.println("Area sera: "+areaEsfera(radioE)); break; case 8: int ladoMayorR= leerEntero(0, 100, "Ingrese lado mayor: ", teclado); int ladoMenorR= leerEntero(0, 100, "Ingrese lado menor: ", teclado); int alturaPa= leerEntero(0, 100, "Ingrese altura: ", teclado); System.out.println("Area sera: "+ areaParalelepipedo(ladoMayorR, ladoMenorR, alturaPa)); break; } }while(opcion<9); } }

RECURSIVIDAD //...Para este caso de recursividad los problemas se iran resolviendo en una sola aplicacin public class a_recursividad { //... Modulo recursivo que imprime los n-primeros numero naturales public static void nPrimeros(int nro){ if(nro>0){ nPrimeros(nro-1); System.out.print(nro+", "); } } //... Modulo recursivo que calcula la suma de los n-primeros numeros naturales public static int sumaNprimeros(int nro){ if(nro==0) return nro; else return nro+sumaNprimeros(nro-1); } //... Modulo recursivo que calcula el factorial de un numero public static int factorial(int nro){ if(nro==0) return 1; else return nro*factorial(nro-1); } //... Modulo recursivo que evalua el producto de dos numeros public static int producto(int nro1, int nro2){ if(nro2==0) return 0; else return nro1+producto(nro1, nro2-1); } //... Modulo recursivo que determina el MCD de dos numeros (Alg. euclides) public static int mcd(int nro1, int nro2){ if(nro1%nro2==0) return nro2; else return mcd(nro2, nro1%nro2); } //... Modulo que determina le n-esimo termino de la serie fibonacci public static int fibonacci(int nro){ if(nro<=2) return nro-1; else return fibonacci(nro-1)+fibonacci(nro-2); } //... Modulo que calcula la n-esima potencia de un numero public static int potencia(int nro, int potencia){ if(potencia==0) return 1; else return nro*potencia(nro, potencia-1); } //... Modulo que invierte una cadena public static String invertirCadena(String cadena){ if(cadena.length()<=1) return cadena; else return invertirCadena(cadena.substring(1, cadena.length()))+cadena.substring(0,1); }

//... Modulo que convierte un numero de base dos a base diez public static int binario(int nro){ if(nro<=1) return nro; else return binario(nro/2)*10+nro%2; } //... Modulo que calcule el cociente de la division entera de dos numeros public static int cociente(int nro1, int nro2){ if(nro1<nro2) return 0; else return 1+cociente(nro1-nro2, nro2); } //... Modulo que calcula la raiz cuadrada entera de un numero //... raizCuadrada(9,0) public static int raizCuadrada(int nro, int k){ if(k*k<=nro && nro<(k+1)*(k+1)) return k; else return raizCuadrada(nro,k+1); } //... Modulo que calcula el valor del coeficiente de un binomio cuadrado //... n k //... 0: 1 //... 1: 1 1 //... 2: 1 2 1 //... 3: 1 3 3 1 //... 4: 1 4 6 4 1 //... 5: 1 5 10 10 5 1 //... coeficienteBinomio(5,2) => 10 public static int coeficienteBinomio(int n, int k){ if(k<=0 || k==n) return 1; else return coeficienteBinomio(n-1, k-1)+coeficienteBinomio(n-1, k); } /* En una base militar en el desierto hay un Jeep y n-bidones de gasolina. El tanque de gasolina del Jeep tiene la capasidad para un bidon y adems puede cargar otro bidon. El Jeep puede recorrer D Km con un bido de gasolina. Escribir un modulo que calcule la distancia maxima que puede recorrer el Jeep */ public static float jeep(float distancia, int nroGalones){ if(nroGalones==1) return distancia; else return distancia/((nroGalones-1)*2-1) + jeep(distancia, nroGalones-1); } //... Modulo que determina las jugadas de las torres de hanoi //... hanoi('A','B','C',3); public static void hanoi(char izquierda, char centro, char derecha, int n){ if(n==1) System.out.println("mover disco "+n+" desde "+izquierda+" hasta "+derecha); else{ hanoi(izquierda,derecha,centro,n-1); System.out.println("mover disco "+n+" desde "+izquierda+" hasta "+derecha); hanoi(centro,izquierda,derecha,n-1); } } // PROGRAMA PRINCIPAL public static void main(String[] args) { System.out.println("xxx: "+jeep(5,3)); } }