Macros

ALGORITMOS
RESUELTOS EN
JAVA
Ing. Humberto Silvera Reynaga
Temas:
1. Algoritmos secuenciales
2. Algoritmos de selección
3. Algoritmos de selección multiple
4. Algoritmos de repetición (do-while)
5. Algoritmos de repetición (while)
6. Algoritmos de repetición anidadas
7. Algoritmos de repetición (for)
8. Modularidad con procedimiento y funciones
(public static)
9. Recursividad
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+" años, y "+peso+" Kgr");
}
}
//... Algoritmo que lee las notas de un estudiante e imprime el promedio

import java.io.*;
public class b_promedio {
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: ");
System.out.print("Ingresar tercera nota: ");
//... 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 {
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 {
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 {
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 {
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("---------------");
System.out.println("Suma: "+parteEnt+"+"+parteImag+"i");
//... Realizar la diferencia de complejos
parteEnt= nro1Ent-nro2Ent;
parteImag= nro1Imag-nro2Imag;
System.out.println("Resta: "+parteEnt+"+"+parteImag+"i");
//... Realizar el producto de complejos
parteEnt= nro1Ent*nro2Ent-nro1Imag*nro2Imag;
parteImag= nro1Ent*nro2Imag+nro2Ent*nro1Imag;
System.out.println("Producto: "+parteEnt+"+"+parteImag+"i");
}
}
//... Algoritmo que calcula la resultante de dos fuerzas

import java.io.*;
public class g_resultante {
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 {
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 {
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 {
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 {
BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
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;
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 número de tres digitos
import java.io.*;
public class l_UnidDec {
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 {
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;
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 {
int nro, unid, dec, cent, nroInv;
//... leer numero
//... 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 número de tres digitos

import java.io.*;
public class o_invertir {
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;
nro= nro/10;
//... Tercera etapa
ultDig= nro%10;
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 {
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;
System.out.println("Billetes de S/. 100 :"+b100);
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 {
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 SELECCIÓN
/* 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 {
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 {
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 {
int nro;
//... Leer numero
//... 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 año del siglo 20 es bisiesto o no

import java.io.*;
public class d_Bisiesto {
int anio;
//... Ingresar año
System.out.print("Leer año:"); anio= Integer.parseInt(teclado.readLine());
//... verificar si el año 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 {
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 {
int nro1, nro2, aux;
//... leer numeros
//... 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 {
int nro1, nro2, nro3, mayor;
//... Leer tres numero
//... 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 {
//... Leer numeros
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 {
//... Leer numeros
//... 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 {
int nro1, nro2, nro3, aux;
//... Leer numeros
//... 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 {
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 {
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 {
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 {
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 exámenes 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 {
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 compañeros 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 {
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 {
int nro, unidad, decena, centena;
//... Leer numero de tres digitos
//... 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 {
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 {
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 {
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 año: "); 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)//... Año 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 {
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 año: "); 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 año: "); 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)
else
if(diaA>diaB)
else
if(diaB>diaA)
else System.out.println("Las fechas son iguales");
}
}
//... Algoritmo que determina la mayor de dos fechas
import java.io.*;
public class v_mayorFechas {
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 año: "); 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 año: "); anioB= Integer.parseInt(teclado.readLine());
//... Determinas la mayor fecha
nroFechaA= anioA*10000+mesA*100+diaA;
nroFechaB= anioB*10000+mesB*100+diaB;
if(nroFechaA>nroFechaB)
else
if(nroFechaB>nroFechaA)
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 {
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 {
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 {
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 SELECCIÓN MULTIPLE
//... Algoritmo que lee el mes y año de una fecha y determina el numero de dias
import java.io.*;
public class a_nroDias {
int mes, anio, nroDias= 0;
//... Leer mes y año
System.out.print("Leer mes: "); mes= Integer.parseInt(teclado.readLine());
System.out.print("Leer año: "); anio= Integer.parseInt(teclado.readLine());
//... Determinar numero de dias del mes
switch(mes){
case 1: nroDias= 31; break; case 3: nroDias= 31; break;
case 12: nroDias= 31;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 REPETICIÓN (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) {
String mensaje= "Programar es facil:";
int k= 1;
//... Imprimiendo
System.out.println(mensaje+k);
k= k+1;
k= k+1;
k= k+1;
k= k+1;
}
}
//... Algoritmo que imprime y cuenta cinco veces "Programar es facil"

public class b_contador {
String mensaje;
int k;
//... Inicializando variables
mensaje= "Programar es facil:";
k= 1;
//... Imprimiendo y contando
k++;
k++;
k++;
k++;
}
}
//... Algoritmo que imprime programar es facil 10 veces

public class c_repeat {
String mensaje; int k;
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 {
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 {
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 {
int n, k, impar;
//... Leer n
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 {
int n, k, impar;
//... Leer n
//... 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 {
int n, k ,mult;
//... Leer N
//... 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 {
int n, k, cuadrado, cubo;
//... Leer numero de elementos
//... 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 {
int n, k;
double cuadrado, cubo;
//... Imprimir numero, cuadrado y cubo
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 {
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:");
System.out.print("Ingresar segunda nota:");
System.out.print("Ingresar tercera nota:");
//... 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 {
int n, k, suma;
//... Leer n-primeros
//... Calcular la suma de los n-primeros
suma= 0;
do{
suma= suma + k;
k++;
}while(n>=k);
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 año 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 {
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*/
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 {
int numerador= 1, denominador= 100;
double suma= 0;
do{ suma= ((1.0)*numerador/denominador)+suma;
numerador++;
denominador--;
}while(denominador != 0);
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 {
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;
System.out.println("El resultado de la expresion sera: "+suma);
}
}

12 – 22 + 32 – 42 + 52 – 62 + ... + 992 -1002 */
public class p_expresion {
int suma= 0, k= 1;
do{
if(k%2==0)
suma= suma-(k*k);
else
suma= suma+(k*k);
k++;
}while(k <= 100);
}
}
12 – 22 + 32 – 42 + 52 – 62 + ... + 992 -1002 */
public class q_expresion {
int suma= 0, k= 1;
do{ suma= suma+(k*k); //... Suma impares
k++;
suma= suma-(k*k); //... Resta pares
k++;
}while(k <= 100);
}
}

12 – 22 + 32 – 42 + 52 – 62 + ... + 992 -1002 */
public class r_expresion {
int k= 1, signo = -1, suma= 0;
//... Calculando expresion
do{ signo= signo*(-1);
suma= suma + signo*(k*k);
k++;
}while(k<= 100);
//... Imprimir suma
}
}
//... Algoritmo que calcula el promedio aritmetico de n-estudiante

import java.io.*;
public class s_promedioN {
teclado= new BufferedReader(new InputStreamReader(System.in));
int n, k, nota, suma;
double promedio;
System.out.print("Ingresar nro de estudiantes: ");
k= 1; suma= 0;
do{ System.out.print("Ingresar nota estudiante "+k+": ");
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 REPETICIÓN (WHILE)
//... Algoritmo que imprime los n-primeros enteros positivos

import java.io.*;
public class a_nEnteros {
int n, k;
//... Leer n
//... 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 {
int n, k, factorial;
//... Leer n
//... 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 {
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
int nro1, nro2, resto;
//... Ingresar numeros
System.out.print("Ingresar primer numero: ");
nro1= Integer.parseInt(teclado.readLine());
System.out.print("Ingresar segundo numero:");
//... 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 {
int nro, nroDigitos;
//... Leer numero
//... 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 {
int dividendo, divisor, cociente, resto;
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 {
int nro1, nro2, factor1, factor2, producto;
System.out.print("Ingresar primer numero: ");
System.out.print("Ingresar segundo numero: ");
//... 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;
}
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 {
int nro, exponente, potencia, k;
//... Leer numero y potencia
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 {
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 {
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 REPETICIÓN ANIDADAS
//... Algoritmo que que calcule el factorial de los n-primeros enteros positivos
import java.io.*;
public class a_factorial {
int n, k, j, factorial;
//... Leer n
//... 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 REPETICIÓN (FOR)
/* Algoritmo que imprime el numero, el cuadrado y el cubo de los n-primeros enteros

positivos */
import java.io.*;
public class a_cuadradoCubo {
int n;
//... Leer n
//... 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 {
int n, nro;
float promedio= 0;
//... Leer n
//... 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 {
int n, menor, mayor, aprob, desap, reprob, nota;
float promedio;
//... Ingresar numero de estudiantes
System.out.print("Ingresar numero de estudiantes: ");
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+": ");
//... 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
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 {
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
int n, penultimo, ultimo, fibonacci;
//... Leer n
System.out.print("Leer n-esimo termino: "); n= Integer.parseInt(teclado.readLine());
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);
//... 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{
//... 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 años 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());
//... 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 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
// Declarar variable de lectura
}
}
/* 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("* 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.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
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:
tablaMultiplicacion(nro);
break;
case 4:
tablaDividir(nro);
break;
case 5:
tablaPotencia(nro);
break;
}
}while(opcion<6);
}
}
//… Escribir un programa que muestre en la pantalla las areas geométricas

import java.io.*;
public class c_figuraGeometrica {
public static void menu(){
System.out.println("**********************************");
System.out.println("*AREAS GEOMETRICAS *");
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.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());
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;
}
//... 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 aplicación
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 además 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
System.out.println("xxx: "+jeep(5,3));
}
}

Macros

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Macros

Caricato da

Copyright:

Formati disponibili

ALGORITMOS

Ing. Humberto Silvera Reynaga

//... Algoritmo que lee las notas de un estudiante e imprime el promedio

//... Algoritmo que evalua la funcion: f(x)= 2X2 + 4X - 5

//... Algoritmo que transforma las coordenadas polares de un punto a coordenadas

//... Algoritmo que calcula la suma de dos numeros complejos

//... Algoritmo que calcula la resultante de dos fuerzas

//... Algoritmo que calcula la distancia entre dos puntos

/* Se compra N-articulos a un precio unitario X.

/* Un ciclista parte de la plaza de armas de Andahuaylas a las HH horas MM minutos y SS

//... Algoritmo que invierte un número de tres digitos

//... Algoritmo que calcula la hipotenusa de un triangulo

/* Una empresa comercial ofrece dos tipos de descuentos:

//... Escribir un algoritmo que divida 2 numeros

//... Algoritmo que indica si un año del siglo 20 es bisiesto o no

//... Algoritmo que determina el mayor de dos numeros

//... Algoritmo que determina el mayor de tres numeros

//... Algoritmo ue determina el mayor de tres numeros

//... Algoritmo que calcula el mayor de tres numeros

//... Algoritmo que ordena tres numeros diferentes de forma ascendente

/* Algoritmo que resuelve el siguiente sistema de ecuaciones:

System.out.println("Leer segunda ecuacion");

/* La nota final de un estudiante se obtiene como el promedio aritmetico de tres examenes

/* El profesor de uan asignatura durante un semestre tomo cuatro exámenes parciales. Al

/* Dos compañeros de colegio: Juan y Mario, comparten los gastos de habitacion y

/* Algoritmo que determina si un numero de 3 digitos es igual a la suma de los cubos de

/* La municipalidad provincial de andahuaylas cobra el impuesto predial urbano de acuerdo

//... Algoritmo que transforma coordenadas rectangulares a polares

//... Imprimir coordenadas polares

/* Algoritmo que lee un fecha (dd/mm/aa) y determina la fecha correspondiente al dia

//... Agregar a fecha un dia

//... Algoritmo que determina el myor de dos fechas

//... Algoritmo que determina de que tipo de triangulo se trata

//... Algoritmo que determina la hora leida mas un segundo despues

case 4: nroDias= 30; break; case 6: nroDias= 30; break;

//... Algoritmo que imprime y cuenta cinco veces "Programar es facil"

//... Algoritmo que imprime programar es facil 10 veces

//... Algoritmo que valida el ingreso de notas

//... Algoritmo que imprime los n-primeros numeros impares (positivos)

/* Algoritmo que imprima el numero, el cuadrado y el cubo de los n-primeros numeros

/* El centro meteorologio de la UNAJMA se tiene registrado las temperaturas diarias

/* Algoritmo que evalue la siguiente expresion:

/* Algoritmo que evalue la siguiente expresion:

/* Algoritmo que evalue la siguiente expresion:

//... Algoritmo que calcula el promedio aritmetico de n-estudiante

//... Algoritmo que imprime los n-primeros enteros positivos

//... Algoritmo que calcula el factorial de un numero entero positivo

//... Algoritmo que calcula el maximo comun divisor de dos numeros

//... Algoritmo que determina el numero de digitos de un numero entero positivo

/* Algoritmo que determina la potencia de un numero elevado a la n (n-entero positivo) */

//... Algoritmo que invierte un numero

/* Algoritmo que imprime el numero, el cuadrado y el cubo de los n-primeros enteros

//... Algoritmo que permite calcular el promedio aritmetico de n- numeros

//… Algoritmo que imprime la serie fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

//… Escribir un programa que muestre en la pantalla las areas geométricas

Potrebbero piacerti anche