Vous êtes sur la page 1sur 0

ALGORITMOS

RESUELTOS EN
JAVA
Ing. Humberto Silvera Reynaga
Temas:
1. Algoritmos secuenciales
2. Algoritmos de seleccin
3. Algoritmos de seleccin multiple
4. Algoritmos de repeticin (do-while)
5. Algoritmos de repeticin (while)
6. Algoritmos de repeticin anidadas
7. Algoritmos de repeticin (for)
ESTRUCTURAS SECUENCIALES
/* 1.- Elaborar en lenguajes Java un Algoritmo que lea el nombre y apellido de
un estudiante y luego lo imprima
*/
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));
//... Leer nombre de la persona
System.out.print("Ingresar nombre:");
String nombre= teclado.readLine();
//... Leer apellido paterno de la persona
System.out.print("Ingresar apellido paterno:");
String aPaterno= teclado.readLine();
//... Leer apellido materno de la persona
System.out.print("Ingresar apellido materno:");
String aMaterno= teclado.readLine();
//... Imprimir el ingreso de datos
System.out.println();
System.out.println("El estudiante es");
System.out.println("Nombre:"+nombre);
System.out.println("Apellido Paterno:"+aPaterno);
System.out.println("Apellido Materno:"+aMaterno);
}
}
/* 2.- Elaborar en lenguajes Java un Algoritmo que lee las tres notas de un
estudiante y luego imprima el promedio final
*/
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));
//... Leer notas
System.out.print("Ingresar primera nota:");
int nota1= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar segunda nota:");
int nota2= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar tercera nota:");
int nota3= Integer.parseInt(teclado.readLine());
//... Calcular el promedio
double promedio= (nota1+nota2+nota3)/3.0;
float rta= (float)promedio;//... Redondear
//... Imprimir promedio
System.out.println("El promedio sera:"+rta);
}
}
/* 3.- Elaborar en lenguajes Java un Algoritmo que convierte una distancia
medida en pulgadas a una distancia en 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));
//... Leer distancia en pulgadas
System.out.print("Ingresar medida en pulgadas:");
int pulgada= Integer.parseInt(teclado.readLine());
//... Convertir distancia a centimetros
double centimetros= pulgada*2.54;
//... Imprimir nuva medida en centimetros
System.out.println(pulgada+" en centimetros sera:"+centimetros+" cm");
}
}
/* 4.- Elaborar en lenguajes Java un Algoritmo que evalua la siguiente funcion:
f(x)= 2X
2
+ 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));
//... Leer el valor de X
System.out.print("Leer X:");
int X= Integer.parseInt(teclado.readLine());
//... Calcular la funcion
double Fx= 2*Math.pow(X,2)+4*X-5;
//... Redondeando
float fx= (float)Fx;//... redondear
//... Imprimir la funcion resultado
System.out.println("f(x):2X2 + 4X - 5="+fx);
}
}
/* 5.- Elaborar en lenguajes Java un 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));
//... Leer coordenadas polares de un punto
System.out.print("Leer Radio:");
int radio= Integer.parseInt(teclado.readLine());
System.out.print("Leer Angulo:");
int angulo= Integer.parseInt(teclado.readLine());
//... Calcular la absisa y la ordenada del punto
double angRadianes= angulo*Math.PI/180;
double X= radio*Math.cos(angRadianes);
double Y= radio*Math.sin(angRadianes);
//... Redondeando los valores
float x= (float)X;//... redondear
float y= (float)Y;
//... Escribir las coordenadas rectangulares del punto
System.out.println("Coordenadas rectangulares: ("+x+","+y+")");
}
}
/* 6.- Elaborar en lenguajes Java un 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));
//... Leer numero complejos
System.out.print("Ingresar Primer complejo (parte real):");
int nro1Real= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar Primer complejo (parte imaginaria):");
int nro1Imag= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar Segundo complejo (parte real):");
int nro2Real= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar Segundo complejo (parte imaginaria):");
int nro2Imag= Integer.parseInt(teclado.readLine());
//... Realizar la suma de complejos
int sumaReal= nro1Real+nro2Real;
int sumaImag= nro1Imag+nro2Imag;
//... Imprimir resultados
System.out.println(nro1Real+"+"+nro1Imag+"i");
System.out.println(nro2Real+"+"+nro2Imag+"i");
System.out.println("--------");
System.out.println(sumaReal+"+"+sumaImag+"i");
}
}
/* 7.- Elaborar en lenguajes Java un Algoritmo que lea dos fuerzas y un angulo
en sexagesimal y calcula la resultante de las 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));
//... Leer las fuerzas y anglos en grados sexagesimales
System.out.print("Leer primera fuerza (Kg-f):");
int fuerza1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segunda fuerza (Kg-f):");
int fuerza2= Integer.parseInt(teclado.readLine());
System.out.print("Leer angulo:");
int angulo= Integer.parseInt(teclado.readLine());
//... Calcular fuerza
double cosenoAngulo= Math.cos(angulo*Math.PI/180);
doubl resultante= Math.sqrt(Math.pow(fuerza1,2)+Math.pow(fuerza2,2)+
2*fuerza1*fuerza2*cosenoAngulo);
float rta= (float)resultante;//... redondear
System.out.println("La fuerza resultante sera:"+rta+" Kg-f");
}
}
/* 8.- Elaborar en lenguajes Java un Algoritmo que calcula la distancia entre
dos puntos en el plano cartesiano
*/
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));
//... Leer absisa y ordenada de dos puntos
System.out.print("Leer absisa del primer punto (X1):");
int X1= Integer.parseInt(teclado.readLine());
System.out.print("Leer ordenada del primer punto (Y1):");
int Y1= Integer.parseInt(teclado.readLine());
System.out.print("Leer absisa del segundo punto (X2):");
int X2= Integer.parseInt(teclado.readLine());
System.out.print("Leer ordenada del segundo punto (Y2):");
int Y2= Integer.parseInt(teclado.readLine());
//... Calcular la distancia entre dos puntos
double distancia= Math.sqrt(Math.pow(X2-X1,2)+Math.pow(Y2-Y1,2));
float rta= (float)distancia;//... Redondear
System.out.println("La distancia entre dos puntos sera:"+rta);
}
}
/* 9.- Elaborar en lenguajes Java un Algoritmo que calcule el siguiente
problema:
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.
Determinar 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));
//... Leer tiempo
System.out.print("Leer tiempo (minutos):");
int minTiempo= Integer.parseInt(teclado.readLine());
//... Calcular la distancia y la tortuga
double distancia= minTiempo*(400-0.6);
float rta= (float)distancia;//... Redondeando
//... Imprimir la distancia entre la liebre y la tortuga
System.out.println("Distancia entre la Liebre y la Tortuga:");
System.out.println(rta+" mt");
}
}
/* 10.- 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.
Elaborar en lenguajes Java 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));
//... Leer altura inicial y numero de rebotes
System.out.print("Leer altura inicial:");
int h= Integer.parseInt(teclado.readLine());
System.out.print("Leer numero de rebote:");
int n= Integer.parseInt(teclado.readLine());
//... Calcular la altura final
double fFinal= Math.pow(3.0/4,n)*h;
//... Imprimir la altura final al cabo de n-rebotes
System.out.println("Altura final:"+fFinal);
}
}
/* 11.- Se compra N-articulos a un precio unitario X.
Elaborar en lenguajes Java 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;
teclado = new BufferedReader(new InputStreamReader(System.in));
//... Leer la cantidad y precio unitario de un articulo
System.out.print("Ingresar cantidad:");
int cantidad= Integer.parseInt(teclado.readLine());
System.out.print("Leer precio unitario:");
int pUnitario= Integer.parseInt(teclado.readLine());
//... Calcular impuesto y precio total
int pVenta= cantidad*pUnitario;
double IGV= pVenta*18.0/100;
double pTotal= pVenta+IGV;
//... Imprimir resultados
System.out.println("El IGV sera de:"+IGV);
System.out.println("El precio de venta sera de:"+pTotal);
}
}
/* 12.- Elaborar en lenguajes Java un Algoritmo que calcula las unidades y
decenas de un numero de dos 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));
//... Leer numero
System.out.print("Leer numero:");
int nro= Integer.parseInt(teclado.readLine());
//... Calcular las unidades y decenas
int decena= nro/10;
int unidad= nro%10;
System.out.println(nro+" tiene: "+decena+" decenas "+unidad+" unidades");
}
}
/* 13.- 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
UAP es de T segundo.
Elaborar en lenguajes Java 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));
//... Leer la hora de partida y el tiempo de viaje
System.out.print("Leer hora de partida:");
int HH= Integer.parseInt(teclado.readLine());
System.out.print("Leer minutos de partida:");
int MM= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundos de partida:");
int SS= Integer.parseInt(teclado.readLine());
System.out.print("Duracion del viaje (segundos):");
int T= Integer.parseInt(teclado.readLine());
//... Calcular la hora de llegada
int tTotal= (HH*3600+MM*60+SS)+T;
HH= tTotal/3600;
HH= HH%24;//... Calculando las horas
MM= (tTotal%3600)/60;
SS= (tTotal%3600)%60;
System.out.println("Hora de Llegada: "+HH+":"+MM+":"+SS);
}
}
/* 14.- Elaborar en lenguajes Java un 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));
//... leer numero
System.out.print("Leer numero:");
int nro= Integer.parseInt(teclado.readLine());
//... Invertir numero
int uni= nro%10;
int dec= (nro/10)%10;
int cen= nro/100;
System.out.println("El numero invertido sera:"+(uni*100+dec*10+cen));
}
}
/* 15.- Elaborar en lenguajes Java un 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));
//... Leer numero
System.out.print("Ingresar numero:");
int nro= Integer.parseInt(teclado.readLine());
//... Invertir numero
int nroInv= 0;
int ultDig= nro%10;
nroInv= nroInv*10+ultDig;
nro= nro/10;
ultDig= nro%10;
nroInv= nroInv*10+ultDig;
nro= nro/10;
ultDig= nro%10;
nroInv= nroInv*10+ultDig;
System.out.println("Numero invertido:"+nroInv);
}
}
/* 16.- Elaborar en lenguajes Java un 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));
//... Leer monto
System.out.print("Leer monto:");
int monto= Integer.parseInt(teclado.readLine());
//... Calcular numero de billetes
int b100= monto/100;
int resto= monto%100;
int b50= resto/50;
resto= resto%50;
int b20= resto/20;
resto= resto%20;
int b10= resto/10;
resto= resto%10;
int m5= resto/5;
int 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);
}
}
ESTRUCTURAS SELECTIVAS
/* 1.- 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
Elaborar en lenguajes Java un escribir un algoritmo que lea el nmero 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));
//... Leer precio unitario y numero de unidades
System.out.print("Leer precio unitario:");
int pUni= Integer.parseInt(teclado.readLine());
System.out.print("Leer numero de unidades:");
int nroUni= Integer.parseInt(teclado.readLine());
//... Calcular el importe de la venta neta
int impBruto= pUni*nroUni;
double descuento= 0;
if(impBruto>=200) //... Calculando los descuentos
descuento= impBruto*(10.0/100);
else
descuento= impBruto*(5.0/100);
//... Calculando el importe neto
double impNeto= impBruto-descuento;
System.out.println("El importe de la venta neta sera:"+impNeto);
}
}
/* 2.- Elaborar en lenguajes Java un algoritmo que divida 2 numeros reales
*/
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));
//... Leer dividendo y divisor
System.out.print("Ingresar dividendo:");
float dividendo= Float.parseFloat(teclado.readLine());
System.out.print("Ingresar divisor:");
float divisor= Float.parseFloat(teclado.readLine());
float cociente= 0;
//... Efectuar la division
if(divisor!=0){
cociente= dividendo/divisor;
System.out.println(dividendo+"/"+divisor+"="+cociente);
}
else System.out.println(dividendo+"/"+divisor+"=Division por cero");
}
}
/* 3.- Elaborar en lenguajes Java un 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));
//... Leer numero
System.out.print("Leer numero:");
int nro= Integer.parseInt(teclado.readLine());
//... Verificar si es apr o impar
if(nro%2==1)
System.out.println(nro+" es Impar");
else System.out.println(nro+" es Par");
}
}
/*4.- Elaborar en lenguajes Java un Algoritmo que ingresado un ao indique si
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));
//... Ingresar ao
System.out.print("Leer ao:");
int 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");
}
}
/*5.- Elaborar en lenguajes Java un 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));
//... Leer numeros
System.out.print("Leer primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
if(nro1>nro2)
System.out.println(nro1+" es el mayor");
else
if(nro1<nro2)
System.out.println(nro2+" es el mayor");
else
System.out.println("Son iguales");
}
}
/* 6.- Elaborar en lenguajes Java un 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));
//... leer numeros
System.out.print("Leer primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
//... Ordenando numeros
int aux= 0;
if(nro1>nro2){ //... Intercambiar
aux= nro1;
nro1= nro2;
nro2= aux;
}
System.out.println("Los numeros ordenados seran: "+nro1+", "+nro2);
}
}
/* 7.- Elaborar en lenguajes Java un 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));
//... Leer tres numero
System.out.print("Leer primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
System.out.print("Leer tercer numero:");
int nro3= Integer.parseInt(teclado.readLine());
//... Deterimnar el numero mayor
int mayor= 0;
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);
}
}
/* 8.- Elaborar en lenguajes Java un Algoritmo que 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));
//... Leer numeros
System.out.print("Leer primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
System.out.print("Leer tercer numero:");
int nro3= Integer.parseInt(teclado.readLine());
//... Calcula el mayor
int mayor= 0;
if(nro1>nro2)
mayor= nro1;
else
mayor= nro2;
if(mayor<nro3)
mayor= nro3;
//... Imprimir el mayor numero
System.out.println("El mayor sera:"+mayor);
}
}
/* 9.- Elaborar en lenguajes Java un 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));
//... Leer numeros
System.out.print("Leer primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
System.out.print("Leer tercer numero:");
int nro3= Integer.parseInt(teclado.readLine());
//... calcular el mayor
int mayor= nro1;
if (mayor<nro2)
mayor= nro2;
if (mayor<nro3)
mayor= nro3;
//... Imprimir el mayor numero
System.out.println("El mayor sera:"+mayor);
}
}
/* 10.- Elaborar en lenguajes Java un 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));
//... Leer numeros
System.out.print("Leer primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
System.out.print("Leer tercer numero:");
int nro3= Integer.parseInt(teclado.readLine());
//... Ordenas en forma ascendente
int aux= 0;
if(nro1>nro3){ //... Intercambiar
aux= nro1;
nro1= nro3;
nro3= 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);
}
}
/* 11.- Elaborar en lenguajes Java un 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));
//... Leer coeficientes
System.out.println("Leer primera ecuacion");
System.out.print("Leer coeficiente a (aX):");
int a= Integer.parseInt(teclado.readLine());
System.out.print("Leer coeficiente b (bY):");
int b= Integer.parseInt(teclado.readLine());
System.out.print("Leer resultado c:");
int c= Integer.parseInt(teclado.readLine());
System.out.println("Leer segunda ecuacion");
System.out.print("Leer coeficiente d (dX):");
int d= Integer.parseInt(teclado.readLine());
System.out.print("Leer coeficiente e (eY):");
int e= Integer.parseInt(teclado.readLine());
System.out.print("Leer resultado f:");
int f= Integer.parseInt(teclado.readLine());
//... Calcular X, Y
if(a*e-b*d != 0){
float x= (float)(c*e-b*f)/(a*e-b*d);
float y= (float)(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");
}
}
/* 12.- La empresa de agua potable, tiene dos tarifas que esta de acuerdo al
consumo del usuario.
Para los primeros 40m
3
cobra S/ 0.50 y para el consumo por encima de 40m
3
cobra S/ 0.80 por m3
Elaborar en lenguajes Java 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));
//... Leer el consumo de agua
System.out.print("Leer consumo de agua (m3):");
int consumo= Integer.parseInt(teclado.readLine());
//... Calcular el monto total a cobrar
double montoCobrar= 0;
if(consumo<=40)
montoCobrar= consumo*(0.5);
else
montoCobrar= 40*(0.5)+(consumo-40)*(0.8);
//... Incluido IGV
montoCobrar= montoCobrar+(montoCobrar*18/100);
float rta= (float)montoCobrar;//... Redondeando
//... Imprimir monto a cobrar
System.out.println("Para "+consumo+"m3 el cobro sera de S/"+rta);
}
}
/* 13.- 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));
//... Leer notas
System.out.print("Leer primera nota:");
int nota1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segunda nota:");
int nota2= Integer.parseInt(teclado.readLine());
System.out.print("Leer tercera nota:");
int nota3= Integer.parseInt(teclado.readLine());
//... Calcular promedio y tipo de nota
double promedio= (nota1+nota2+nota3)/(3.0);
float rta= (float)promedio; //... Redondear
String 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: "+rta+" ("+observacion+")");
}
}
/* 14.- Elaborar en lenguajes Java un Algoritmo que encuentra la solucion de
una ecuacion de segundo grado (Baskara): aX
2
+ 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));
//... Leer coeficientes
System.out.print("Leer primer coeficiente (a):");
int a= Integer.parseInt(teclado.readLine());
System.out.print("Leer segundo coeficiente (b):");
int b= Integer.parseInt(teclado.readLine());
System.out.print("Leer tercer coeficiente (c):");
int c= Integer.parseInt(teclado.readLine());
//... Hallar la solcion cuadratica
if(a != 0)
if(Math.pow(b,2)-4*a*c>=0){
double x= (-b+Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a);
double y= (-b-Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a);
System.out.println("X="+x+" Y="+y);
}
else
System.out.println("No existe solucion en los reales");
else
System.out.println("No es una ecuacion cuadratica");
}
}
/* 15.- El profesor de una asignatura durante un semestre tomo cuatro
exmenes parciales. Al final del semestre les informa a sus estudiantes que
pueden calcular su promedio final eliminando la nota ms baja y promediando
las tres restantes.
Elaborar en lenguajes Java un algoritmo para calcular la nota final del
estudiante
*/
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));
//... Leer notas
System.out.print("Leer primera nota:");
int nota1= Integer.parseInt(teclado.readLine());
System.out.print("Leer segunda nota:");
int nota2= Integer.parseInt(teclado.readLine());
System.out.print("Leer tercera nota:");
int nota3= Integer.parseInt(teclado.readLine());
System.out.print("Leer cuarta nota:");
int nota4= Integer.parseInt(teclado.readLine());
//... Calcular promedio final
//... Hallando la menor nota
int notaMenor= nota1;
if(notaMenor>nota2)
notaMenor= nota2;
if(notaMenor>nota3)
notaMenor= nota3;
if(notaMenor>nota4)
notaMenor= nota4;
//... Hallando la nota final
double pFinal= (nota1+nota2+nota3+nota4-notaMenor)/(3.0);
float rta= (float)pFinal;
//... Imprimir promedio final
System.out.println("La nota final sera:"+rta);
}
}
/* 16.- 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.
Elaborar en lenguajes Java 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));
//... Leer gastos
System.out.print("Leer Gastos de Juan:");
int gastoJ= Integer.parseInt(teclado.readLine());
System.out.print("leer Gastos de Mario:");
int gastoM= Integer.parseInt(teclado.readLine());
String mensaje= "";
double monto= 0;
//... Calcular deudas
if(gastoJ == gastoM)
mensaje= "No se deben";
else
if(gastoJ>gastoM){
mensaje= "Juan debe a Mario";
monto= (gastoJ-gastoM)/(2.0);
}
else{
mensaje= "Mario debe a Juan";
monto= (gastoM-gastoJ)/(2.0);
}
//... Imprimir resultados
System.out.println(mensaje+": S/"+monto);
}
}
/* 17.- Elaborar en lenguajes Java un 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));
//... Leer numero de tres digitos
System.out.print("Leer numero:");
int nro= Integer.parseInt(teclado.readLine());
//... Descomponer numero en sus digitos
int unidad= nro%10;
int decena= (nro%10)/10;
int 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");
}
}
/* 18.- 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.
Elaborar en lenguajes Java 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));
//... Leer el valor del predio
System.out.print("Leer el valor del predio:");
int valor= Integer.parseInt(teclado.readLine());
//... Calcular el impuesto
double impuesto= 0;
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:"+impuesto);
}
}
/* 19.- Elaborar en lenguajes Java un 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;
teclado = new BufferedReader(new InputStreamReader(System.in));
//... Leer coordenadas rectangulares
System.out.print("Leer coordenada x:");
int x= Integer.parseInt(teclado.readLine());
System.out.print("Leer coordenada y:");
int y= Integer.parseInt(teclado.readLine());
//... Transformar coordenadas rectangulares a polares
double angulo, 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);
float r= (float)radio;
float a= (float)angulo;
//... Imprimir coordenadas polares
System.out.println("Radio:"+ r+", Angulo:"+a);
}
}
/* 20.- Elaborar en lenguajes Java un 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));
//... Leer fecha
System.out.print("Leer dia:");
int dia= Integer.parseInt(teclado.readLine());
System.out.print("Leer mes:");
int mes= Integer.parseInt(teclado.readLine());
System.out.print("Leer ao:");
int anio= Integer.parseInt(teclado.readLine());
int nroDias= 0;
//... 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);
}
}
/* 21.- Elaborar en lenguajes Java un Algoritmo que determina el mayor 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));
//... Leer primera fecha
System.out.println("Leer primera fecha");
System.out.print("Leer dia:");
int diaA= Integer.parseInt(teclado.readLine());
System.out.print("Leer mes:");
int mesA= Integer.parseInt(teclado.readLine());
System.out.print("Leer ao:");
int anioA= Integer.parseInt(teclado.readLine());
//... Leer segunda fecha
System.out.println("Leer segunda fecha");
System.out.print("Leer dia:");
int diaB= Integer.parseInt(teclado.readLine());
System.out.print("Leer mes:");
int mesB= Integer.parseInt(teclado.readLine());
System.out.print("Leer ao:");
int anioB= Integer.parseInt(teclado.readLine());
int dia= 0, mes= 0, anio= 0;
//... Determinar la fecha mayor
if(anioA>anioB){
dia= diaA;
mes= mesA;
anio= anioA;
}
else
if(anioA<anioB){
dia= diaB;
mes= mesB;
anio= anioB;
}
else
if(mesA>mesB){
dia= diaA;
mes= mesA;
anio= anioA;
}
else
if(mesA<mesB){
dia= diaB;
mes= mesB;
anio= anioB;
}
else
if(diaA>diaB){
dia= diaA;
mes= mesA;
anio= anioA;
}
else
if(diaA<diaB){
dia= diaB;
mes= mesB;
anio= anioB;
}
else
System.out.println("Las fechas son iguales");
//... Imprimir la fecha mayor
System.out.println("La mayor fecha sera:"+dia+"/"+mes+"/"+anio);
}
}
/* 22.- Elaborar en lenguajes Java un 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));
//... Leer primera fecha
System.out.println("Leer primera fecha");
System.out.print("Leer dia:");
int diaA= Integer.parseInt(teclado.readLine());
System.out.print("Leer mes:");
int mesA= Integer.parseInt(teclado.readLine());
System.out.print("Leer ao:");
int anioA= Integer.parseInt(teclado.readLine());
//... Leer segunda fecha
System.out.println("Leer segunda fecha");
System.out.print("Leer dia:");
int diaB= Integer.parseInt(teclado.readLine());
System.out.print("Leer mes:");
int mesB= Integer.parseInt(teclado.readLine());
System.out.print("Leer ao:");
int anioB= Integer.parseInt(teclado.readLine());
//... Determinas la mayor fecha
int nroFechaA= anioA*10000+mesA*100+diaA;
int nroFechaB= anioB*10000+mesB*100+diaB;
int dia= 0, mes= 0, anio= 0;
if(nroFechaA>nroFechaB){
dia= diaA;
mes= mesA;
anio= anioA;
}
else
if(nroFechaA<nroFechaB){
dia= diaB;
mes= mesB;
anio= anioB;
}
else
System.out.println("Las fechas son iguales");
//... Imprimir fecha mayor
System.out.println("La mayor fecha sera: "+dia+"/"+mes+"/"+anio);
}
}
ESTRUCTURAS SELECTIVA MLTIPLE
/* 1.- Elaborar en lenguajes Java un Algoritmo que lee el mes y ao de una
fecha y determine 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));
//... Leer mes y ao
System.out.print("Leer mes:");
int mes= Integer.parseInt(teclado.readLine());
System.out.print("Leer ao:");
int anio= Integer.parseInt(teclado.readLine());
//... Determinar numero de dias del mes
int nroDias= 0;
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;
}
System.out.println("El "+mes+"/"+anio+" contiene:"+nroDias+" dias");
}
}
ESTRUCTURAS REPETITIVA (DO - WHILE)
/* 1.- Elaborar en lenguajes Java un Algoritmo que imprime y cuenta cinco
veces "Programar es facil"
*/
public class a_contador {
public static void main(String[] args) {
//... Inicializando variables
String mensaje= "Programar es facil:";
int 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);
}
}
/* 2.- Elaborar en lenguajes Java un Algoritmo que imprime "Programar es facil"
y los multiplos de 5 (cinco veces)
*/
public class b_acumulador {
public static void main(String[] args) {
//... Inicializando variables
String mensaje= "Programar es facil:";
int k= 5;
//... Imprimiendo
System.out.println(mensaje+k);
k= k+5;
System.out.println(mensaje+k);
k= k+5;
System.out.println(mensaje+k);
k= k+5;
System.out.println(mensaje+k);
k= k+5;
System.out.println(mensaje+k);
}
}
/* 3.- Elaborar en lenguajes Java un Algoritmo que imprime programar es facil
10 veces
*/
public class c_repeat {
public static void main(String[] args) {
//... Inicializando variables
String mensaje= "Programar es facil:";
int k= 1;
//... Imprimiendo mensajes
do{
System.out.println(mensaje+k);
k++;
}while(k<=10);
}
}
/* 4.- Elaborar en lenguajes Java un 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));
//... Leendo los n-primeros numeros
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Imrimir los n primero enteros positivos
int k= 1; //... Inicializando variables
do{
System.out.println(k+" es entero positivo");
k++;
}while(k<=n);
}
}
/* 5.- Elaborar en lenguajes Java un 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));
//... Inicializando variables
int nota= 0;
//... 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");
}
}
/* 6.- Elaborar en lenguajes Java un 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));
//... Leer n
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Inicializando variables
int k=1, impar= 0;
do{
impar= 2*k - 1;
System.out.println("Impar positivo:"+impar);
k++;
}while(k <= n);
}
}
/* 7.- Elaborar en lenguajes Java un 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;
teclado = new BufferedReader(new InputStreamReader(System.in));
//... Leer n
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Inicializar variables
int impar= 0, k= n;
do{
impar= 2*k - 1;
System.out.println("Impar positivo:"+impar);
k--;
}while(k != 0);
}
}
/* 8.- Elaborar en lenguajes Java un Algoritmo que imprime la tabla de
multiplicar de un numero
*/
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));
//... Leer N
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Construir tabla de multiplicar
int k= 1, mult= 0; //... Inicializar variables
do{
mult= n*k;
System.out.println(n+" x "+k+" = "+mult);
k++;
}while(k<=12);
}
}
/* 9.- Elaborar en lenguajes Java un 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));
//... Leer numero de elementos
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Imprimir numero, cuadrado y cubo
int k= 1; //... Inicializar variables
int cuadrado= 0, cubo= 0;
do{
cuadrado= k*k;
cubo= k*k*k;
System.out.println("Nro:"+k+", cuadrado:"+cuadrado+", cubo:"+cubo);
k++;
}while(k <= n);
}
}
/* 10.- Elaborar en lenguajes Java un 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));
//... Leer numero de elementos
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Imprimir numero, cuadrado y cubo
int k= 1; //... Inicializar variables
double cuadrado= 0, cubo= 0;
do{
cuadrado= Math.pow(k,2);
cubo= Math.pow(k,3);
System.out.println("Nro:"+k+", cuadrado:"+cuadrado+", cubo:"+cubo);
k++;
}while(k <= n);
}
}
/* 11.- Se tiene una relacion de n-estudiantes, para cada uno se tiene tres
notas.
Elaborar en lenguajes Java 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));
//... Ingresar datos
System.out.print("Ingresar numero de estudiantes:");
int n= Integer.parseInt(teclado.readLine());
//... Calcular el promedio de los n-estudiantes
int k= 1, nota1= 0, nota2= 0, nota3= 0; //... Inicializando variables
double promedio= 0;
float rta;
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());
promedio= (nota1+nota2+nota3)/(3.0);
rta= (float)promedio; //... Redondear
System.out.println("Promedio del estudiante "+k+" sera:"+rta);
k++;
}while(k <= n);
}
}
/* 12.- Elaborar en lenguajes Java un 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));
//... Leer n-primeros
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Calcular la suma de los n-primeros
int k= 1, suma= 0; //... Inicializar variables
do{
suma= suma + k;
k++;
}while(k <= n);
//... Imprimir resultados
System.out.println("La suma de los "+n+"-primeros sera:"+suma);
}
}
/* 13.- El centro meteorologio de la UAP se tiene registrado las temperaturas
diarias minimas del ao 2010. Elaborar en lenguajes Java 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));
/* Leer temperaturas diarias minimas y determinar el numero de dias
con helada o sin helada*/
//... Inicializando variables
int temperatura= 0, helada= 0, sinHelada= 0, dia= 1;
do{
System.out.print("Ingresar temperatura para el dia "+dia+":");
temperatura= Integer.parseInt(teclado.readLine());
if(temperatura<=0)
helada++;
else
sinHelada++;
dia++;
}while(dia<=5);
System.out.println("Los dias con helada fue de:"+helada+" dias");
System.out.println("los dias sin helada fue de:"+sinHelada+" dias");
}
}
/* 14.- Elaborar en lenguajes Java un 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
float numerador= 1, denominador= 100;
float suma= 0;
do{
suma= suma + (numerador/denominador);
numerador++;
denominador--;
}while(denominador != 0);
//... Imprimir resultados
System.out.println("La suma de la expresion sera:"+suma);
}
}
/* 15.- Elaborar en lenguajes Java un Algoritmo que evalue la siguiente
expresion: 1
2
2
2
+ 3
2
4
2
+ 5
2
6
2
+ ... + 99
2
-100
2
*/
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("Imprimir resultado de la expresion:"+suma);
}
}
/* 16.- Elaborar en lenguajes Java un Algoritmo que evalue la siguiente
expresion: 1
2
2
2
+ 3
2
4
2
+ 5
2
6
2
+ ... + 99
2
-100
2
*/
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("Imprimir resultado de la expresion:"+suma);
}
}
/* 17.- Elaborar en lenguajes Java un Algoritmo que evalue la siguiente
expresion: 1
2
2
2
+ 3
2
4
2
+ 5
2
6
2
+ ... + 99
2
-100
2
*/
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("Imprimir resultado de la expresion:"+suma);
}
}
/* 18.- Elaborar en lenguajes Java un Algoritmo que evalue la siguiente
expresion: 1
2
2
2
+ 3
2
4
2
+ 5
2
6
2
+ ... + 99
2
-100
2
*/
public class r_expresion {
public static void main(String[] args) {
//... Inicializando variables
int contador= 1, signo = -1, suma= 0;
//... Calculando expresion
do{
signo= signo*(-1);
suma= suma + signo*(contador*contador);
contador++;
}while(contador<= 100);
//... Imprimir suma
System.out.println("La suma de la expresion sera:"+suma);
}
}
/* 19.- Elaborar en lenguajes Java un Algoritmo que calcula el promedio
aritmetico de n-numeros
*/
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));
//... Leer numero de elementos
System.out.print("Leer n:");
float n= Integer.parseInt(teclado.readLine());
//... Calcular promedio aritmetico
int k= 1, elemento= 0, suma= 0;
do{
System.out.print("Ingresar elemento "+k+":");
elemento= Integer.parseInt(teclado.readLine());
suma= suma+elemento;
k++;
}while(k <= n);
//... Imprimir el promedio
System.out.println("El promedio aritmetico sera:"+(suma/n));
}
}
ESTRUCTURAS REPETITIVAS (WHILE)
/* 1.- Elaborar en lenguajes Java un 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));
//... Leer n
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Imprimir los n- primeros enteros positivos
int k= 1;
while(k<=n){
System.out.println("Entero positivo:"+k);
k++;
}
}
}
/* 2.- Elaborar en lenguajes Java un 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));
//... Leer n
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Calcular factorial
int k= 1, factorial= 1;
while(k<=n){
factorial= factorial*k;
k++;
}
//... Imprimir factorial
System.out.println("El factorial de "+n+" sera:"+factorial);
}
}
/* 3.- Elaborar en lenguajes Java un 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;
teclado= new BufferedReader(new InputStreamReader(System.in));
//... Ingresar numeros
System.out.print("Ingresar primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
//... calcular el MCD de dos numeros
int resto= 0;
while(nro1%nro2 != 0){
resto= nro1%nro2;
nro1= nro2;
nro2= resto;
}
//... Imprimir MCD
System.out.println("El MCD sera:"+nro2);
}
}
/* 4.- Elaborar en lenguajes Java un 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));
//... Leer numero
System.out.print("Leer numero:");
int nro= Integer.parseInt(teclado.readLine());
//... Calcular numero de digitos
int nroDigitos= 0;
while(nro>0){
nro= nro/10;
nroDigitos++;
}
System.out.println("Numero de digitos:"+nroDigitos);
}
}
/* 5.- Elaborar en lenguajes Java un 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));
//... Ingresar numeros
System.out.print("Ingresar dividendo:");
int dividendo= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar divisor:");
int divisor= Integer.parseInt(teclado.readLine());
//... calcular el cociente y del residuo
int cociente= 0, resto= dividendo;
while(resto-divisor >= 0){
resto= resto - divisor;
cociente++;
}
System.out.println("Cociente:"+cociente+", Desiduo:"+resto);
}
}
/* 6.- Elaborar en lenguajes Java un 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));
//... Ingresar numeros
System.out.print("Ingresar primer numero:");
int nro1= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar segundo numero:");
int nro2= Integer.parseInt(teclado.readLine());
//... Calcular la multiplicacion rusa
int factor1= nro1, factor2= nro2, producto= 0;
while(factor2>0){
if(factor2%2 != 0) //... Impar
producto= producto+factor1;
factor1= factor1*2;
factor2= factor2/2;
}
//... Imprimir resultados
System.out.println(nro1+"x"+nro2+"="+producto);
}
}
/* 7.- Elaborar en lenguajes Java un 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));
//... Leer numero y potencia
System.out.print("Leer numero:");
int nro= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar exponente:");
int exponente= Integer.parseInt(teclado.readLine());
//... Calculando la potencia
int k= 1, potencia= nro;
while(k<exponente){
potencia= potencia*nro;
k++;
}
System.out.println(nro+" elevado a la "+exponente+" sera:"+potencia);
}
}
ESTRUCTURAS REPETITIVAS (ANIDADAS)
/* 1.- Elaborar en lenguajes Java un 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));
//... Leer n
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Calculando el factorial de los n-primeros enteros
int i= 1, j, factorial;
while(i<=n){
j= 1;
factorial= 1;
while(j<=i){ //... Calculando factorial
factorial= factorial*j;
j++;
}
System.out.println("Factorial de "+i+" sera:"+factorial);
i++;
}
}
}
ESTRUCTURAS REPETITIVA (FOR)
/*1.- Elaborar en lenguajes Java un 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));
//... Leer n
System.out.print("Leer n:");
int 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));
}
}
/* 2.- 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));
//... Leer n
System.out.print("Leer n:");
int n= Integer.parseInt(teclado.readLine());
//... Calculando promedio aritmetico
int elemento= 0;
float promedio= 0;
for(int i= 1; i<=n; i++){
System.out.print("Ingresar elemento "+i+":");
elemento= Integer.parseInt(teclado.readLine());
promedio= promedio + elemento;
}
promedio= promedio/n;
System.out.println("El promedio aritmetico sera:"+promedio);
}
}
/* 3.- Elaborar en lenguajes Java un 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));
//... Ingresar numero de estudiantes
System.out.print("Ingresar numero de estudiantes:");
int n= Integer.parseInt(teclado.readLine());
//... Inicializando variables
int menor= 20, mayor= 0, aprob= 0, desap= 0, reprob= 0, nota= 0;
float 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<=10)
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("Existen "+aprob+" aprobados");
System.out.println("Existen "+desap+" desaprobados");
System.out.println("Existen "+reprob+" reprobados");
System.out.println("El promedio aritmetico sera:"+promedio);
}
}