algoritmos dificiles (40)

import java.io.*;
public class EjecutaHipotenusa2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
double cateA=0, cateB=0;


Hipotenusa2 objHipotenusa = new Hipotenusa2();

System.out.println("n CALCULA HIPOTENUSAn");


try
{
System.out.println("------------ Lectura de datos ------------");
System.out.print("Teclee cateto A: ");
datoEntrada = flujoEntrada.readLine();
cateA = Double.parseDouble(datoEntrada);

System.out.print("Teclee cateto B: ");
datoEntrada = flujoEntrada.readLine();
cateB = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objHipotenusa.establecerA(cateA);
objHipotenusa.establecerB(cateB);

objHipotenusa.calcularC();

System.out.println("------------ Imprime resultado -----------");
System.out.println("Hipotenusa C = " + objHipotenusa.obtenerC());
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class Angulo3
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;


double tamAngulo=0, angRadianes, senAng, cosAng;

System.out.println("n CALCULOS LOGARITMICOS DE ANGULOn");


try
{
System.out.println("------------- Entrada del dato -------------");
System.out.print("Teclee tamaño del angulo en radianes: ");
datoEntrada = flujoEntrada.readLine();
tamAngulo = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


angRadianes = tamAngulo * (Math.PI /180);
senAng = Math.sin(angRadianes);
cosAng = Math.cos(angRadianes);


System.out.println("n------------------ Salida ------------------");
System.out.println("Angulo en radianes = " + angRadianes);
System.out.println("Seno = " + senAng);
System.out.println("Coseno = " + cosAng);
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaEmpleado7
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
String nomEmp="";
int hrsTra=0;
float cuoHr=0;


Empleado6 objEmpleado = new Empleado6();

System.out.println("nCALCULA SUELDO CON INCENTIVO DE UN EMPLEADOn");


try
{
System.out.println("------------ Lectura de datos -------------");
System.out.print("Teclee nombre: ");
datoEntrada = flujoEntrada.readLine();
nomEmp = datoEntrada;

System.out.print("Teclee horas trabajadas: ");
datoEntrada = flujoEntrada.readLine();
hrsTra = Integer.parseInt(datoEntrada);

System.out.print("Teclee cuota por hora: ");
datoEntrada = flujoEntrada.readLine();
cuoHr = Float.parseFloat(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objEmpleado.establecerNombreEmp(nomEmp);
objEmpleado.establecerHorasTrab(hrsTra);
objEmpleado.establecerCuotaHora(cuoHr);


objEmpleado.calcularSueldo();


System.out.println("----------- Imprime resultados ------------");
System.out.println("Nombre = " + objEmpleado.obtenerNombreEmp());
System.out.println("Sueldo = " + objEmpleado.obtenerSueldo());
}
}

---------------------------------------------------------------------------

import java.io.*;
public class EjecutaCliente2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
String nomCli="";
int tiCli=0, cant=0;
float preUni=0;


Cliente2 objCliente = new Cliente2();

System.out.println("n REALIZA CALCULOS DE UN CLIENTEn");


try
{
System.out.println("------------ Lectura de datos ------------");
System.out.print("Teclee nombre: ");
datoEntrada = flujoEntrada.readLine();
nomCli = datoEntrada;

System.out.print("Teclee tipo de cliente (1-4): ");
datoEntrada = flujoEntrada.readLine();
tiCli = Integer.parseInt(datoEntrada);

System.out.print("Teclee cantidad de piezas compradas: ");
datoEntrada = flujoEntrada.readLine();
cant = Integer.parseInt(datoEntrada);

System.out.print("Teclee precio unitario: ");
datoEntrada = flujoEntrada.readLine();
preUni = Float.parseFloat(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objCliente.establecerNombreClie(nomCli);
objCliente.establecerTipoClie(tiCli);
objCliente.establecerCantidad(cant);
objCliente.establecerPrecioUni(preUni);


objCliente.calcularSubTotal();
objCliente.calcularDescuento();
objCliente.calcularNetoPagar();


System.out.println("----------- Imprime resultados -----------");
System.out.println("Nombre = " + objCliente.obtenerNombreClie());
System.out.println("Subtotal = " + objCliente.obtenerSubTotal());
System.out.println("Descuento = " + objCliente.obtenerDescuento());
System.out.println("Neto a pagar = " + objCliente.obtenerNetoPagar());
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaPrecioArticulo2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
String desc="";
float cos=0;


PrecioArticulo2 objArticulo = new PrecioArticulo2();

System.out.println("n CALCULA PRECIO DE VENTA DE UN ARTICULOn");


try
{
System.out.println("--------------- Lectura de datos ---------------");
System.out.print("Teclee descripcion del articulo: ");
datoEntrada = flujoEntrada.readLine();
desc = datoEntrada;

System.out.print("Teclee costo de produccion: ");
datoEntrada = flujoEntrada.readLine();
cos = Float.parseFloat(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}

objArticulo.establecerDescripcion(desc);
objArticulo.establecerCosto(cos);


objArticulo.calcularPrecioVta();


System.out.println("-------------- Imprime resultados --------------");
System.out.println("Articulo = " + objArticulo.obtenerDescripcion());
System.out.println("Precio de venta = " + objArticulo.obtenerPrecioVta());
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaAreaTriangulo2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
double basTri=0, altuTri=0;


AreaTriangulo2 objTriangulo = new AreaTriangulo2();

System.out.println("n CALCULA AREA DE UN TRIANGULOn");


try
{
System.out.println("------------ Entrada de datos ------------");
System.out.print("Teclee base: ");
datoEntrada = flujoEntrada.readLine();
basTri = Double.parseDouble(datoEntrada);

System.out.print("Teclee altura: ");
datoEntrada = flujoEntrada.readLine();
altuTri = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objTriangulo.establecerBaseTria(basTri);
objTriangulo.establecerAlturaTria(altuTri);


objTriangulo.calcularAreaTria();


System.out.println("------------ Imprime resultado -----------");
System.out.println("Area = " + objTriangulo.obtenerAreaTria());
}
}

----------------------------------------------------------------------------

import java.io.*;

public class AreaTriangulo2
{

private double baseTria;
private double alturaTria;
private double areaTria;

public void establecerBaseTria(double base)
{
baseTria = base;
}

public void establecerAlturaTria(double altura)
{
alturaTria = altura;
}

public void calcularAreaTria()
{
areaTria = (baseTria *alturaTria) / 2;
}

public double obtenerAreaTria()
{
return areaTria;
}
}

---------------------------------------------------------------------------

import java.io.*;

public class Cliente2

{

private String nombreClie;
private int tipoClie, cantidad;
private float precioUni, subTotal, descuento, netoPagar;

public void establecerNombreClie(String nom)
{
nombreClie = nom;
}

public void establecerTipoClie(int tipo)
{
tipoClie = tipo;
}

public void establecerCantidad(int can)
{
cantidad = can;
}

public void establecerPrecioUni(float pre)
{
precioUni = pre;
}

public void calcularSubTotal()
{
subTotal = cantidad * precioUni;
}

public void calcularDescuento()
{
switch (tipoClie)
{
case 1:
descuento = subTotal * 0.05F;
break;
case 2:
descuento = subTotal * 0.08F;
break;
case 3:
descuento = subTotal * 0.12F;
break;
case 4:
descuento = subTotal * 0.15F;
break;
}
}

public void calcularNetoPagar()
{
netoPagar = subTotal - descuento;
}


public String obtenerNombreClie()
{
return nombreClie;
}

public float obtenerSubTotal()
{
return subTotal;
}

public float obtenerDescuento()
{
return descuento;
}

public float obtenerNetoPagar()
{
return netoPagar;
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaMayor4Numeros2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
int n1=0, n2=0, n3=0, n4=0;


Mayor4Numeros2 objMayor4Numeros = new Mayor4Numeros2();

System.out.println("n IMPRIME EL MAYOR DE 4 NUMEROSn");


try
{
System.out.println("------------ Lectura de datos ------------");
System.out.print("Teclee numero 1: ");
datoEntrada = flujoEntrada.readLine();
n1 = Integer.parseInt(datoEntrada);

System.out.print("Teclee numero 2: ");
datoEntrada = flujoEntrada.readLine();
n2 = Integer.parseInt(datoEntrada);

System.out.print("Teclee numero 3: ");
datoEntrada = flujoEntrada.readLine();
n3 = Integer.parseInt(datoEntrada);

System.out.print("Teclee numero 4: ");
datoEntrada = flujoEntrada.readLine();
n4 = Integer.parseInt(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objMayor4Numeros.establecerNumA(n1);
objMayor4Numeros.establecerNumB(n2);
objMayor4Numeros.establecerNumC(n3);
objMayor4Numeros.establecerNumD(n4);


objMayor4Numeros.calcularNuMayor();


System.out.println("----------- Imprime resultado ------------");
System.out.println("El mayor es = " + objMayor4Numeros.obtenerNuMayor());
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaEmpleado6
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
String nomEmp="";
int hrsTra=0;
float cuoHr=0;


Empleado6 objEmpleado = new Empleado6();

System.out.println("n CALCULA SUELDO DOBLE DE UN EMPLEADOn");

try
{
System.out.println("------------ Lectura de datos ------------");
System.out.print("Teclee nombre: ");
datoEntrada = flujoEntrada.readLine();
nomEmp = datoEntrada;

System.out.print("Teclee horas trabajadas: ");
datoEntrada = flujoEntrada.readLine();
hrsTra = Integer.parseInt(datoEntrada);

System.out.print("Teclee cuota por hora: ");
datoEntrada = flujoEntrada.readLine();
cuoHr = Float.parseFloat(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objEmpleado.establecerNombreEmp(nomEmp);
objEmpleado.establecerHorasTrab(hrsTra);
objEmpleado.establecerCuotaHora(cuoHr);


objEmpleado.calcularSueldo();


System.out.println("----------- Imprime resultados -----------");
System.out.println("Nombre = " + objEmpleado.obtenerNombreEmp());
System.out.println("Sueldo = " + objEmpleado.obtenerSueldo());
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaAlumno4
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
String nombre="";
float c1=0, c2=0, c3=0, c4=0;


Alumno4 objAlumno = new Alumno4();

System.out.println("n CALCULA PROMEDIO DE UN ALUMNOn");


try
{
System.out.println("------------ Lectura de datos -------------");
System.out.print("Teclee nombre: ");
datoEntrada = flujoEntrada.readLine();
nombre = datoEntrada;

System.out.print("Teclee calificacion 1: ");
datoEntrada = flujoEntrada.readLine();
c1 = Float.parseFloat(datoEntrada);

System.out.print("Teclee calificacion 2: ");
datoEntrada = flujoEntrada.readLine();
c2 = Float.parseFloat(datoEntrada);

System.out.print("Teclee calificacion 3: ");
datoEntrada = flujoEntrada.readLine();
c3 = Float.parseFloat(datoEntrada);

System.out.print("Teclee calificacion 4: ");
datoEntrada = flujoEntrada.readLine();
c4 = Float.parseFloat(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objAlumno.establecerNombreAlum(nombre);
objAlumno.establecerCalif1(c1);
objAlumno.establecerCalif2(c2);
objAlumno.establecerCalif3(c3);
objAlumno.establecerCalif4(c4);

objAlumno.calcularPromedio();
objAlumno.calcularObservacion();

System.out.println("----------- Imprime resultados ------------");
System.out.println("Nombre = " + objAlumno.obtenerNombreAlum());
System.out.println("Promedio = " + objAlumno.obtenerPromedio());
System.out.println("Observacion = " + objAlumno.obtenerObservacion());
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class Alumno4
{

private String nombreAlum;
private float calif1, calif2, calif3, calif4;
private float promedio;
private String observacion;

public void establecerNombreAlum(String nom)
{
nombreAlum = nom;
}

public void establecerCalif1(float ca1)
{
calif1 = ca1;
}

public void establecerCalif2(float ca2)
{
calif2 = ca2;
}

public void establecerCalif3(float ca3)
{
calif3 = ca3;
}

public void establecerCalif4(float ca4)
{
calif4 = ca4;
}

public void calcularPromedio()
{
promedio = (calif1 + calif2 + calif3 + calif4) / 4;
}

public void calcularObservacion()
{
if (promedio >= 60)
observacion = "Aprobado";
else
observacion = "Reprobado";
}


public String obtenerNombreAlum()
{
return nombreAlum;
}

public float obtenerPromedio()
{
return promedio;
}

public String obtenerObservacion()
{
return observacion;
}
}

--------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaLeyNewton2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
double f=0, a=0, m=0;
char resp=' ';


LeyNewton2 objNewton = new LeyNewton2();

System.out.println("nREALIZA CALCULOS CON LA SEGUNDA LEY NEWTONn");


try
{
System.out.println("------------ Lectura de datos ------------");
System.out.println("¿Que desea calcular?");
System.out.print("¿Fuerza (F), Aceleracion (A), Masa (M)?: ");
resp = (char)System.in.read();
System.in.skip(2);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


if (resp == 'F' || resp == 'f')
{
// Leer
try
{
System.out.print("Teclee Masa: ");
datoEntrada = flujoEntrada.readLine();
m = Double.parseDouble(datoEntrada);

System.out.print("Teclee Aceleracion: ");
datoEntrada = flujoEntrada.readLine();
a = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objNewton.establecerMasa(m);
objNewton.establecerAceleracion(a);


objNewton.calcularFuerza();


System.out.println("----------- Imprime resultado ------------");
System.out.println("Fuerza = " + objNewton.obtenerFuerza());
}

if (resp == 'A' || resp == 'a')
{

try
{
System.out.print("Teclee Masa: ");
datoEntrada = flujoEntrada.readLine();
m = Double.parseDouble(datoEntrada);

System.out.print("Teclee Fuerza: ");
datoEntrada = flujoEntrada.readLine();
f = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objNewton.establecerMasa(m);
objNewton.establecerFuerza(f);


objNewton.calcularAceleracion();


System.out.println("----------- Imprime resultado ------------");
System.out.println("Aceleracion = " + objNewton.obtenerAceleracion());
}

if (resp == 'M' || resp == 'm')
{

try
{
System.out.print("Teclee Fuerza: ");
datoEntrada = flujoEntrada.readLine();
f = Double.parseDouble(datoEntrada);

System.out.print("Teclee Aceleracion: ");
datoEntrada = flujoEntrada.readLine();
a = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objNewton.establecerFuerza(f);
objNewton.establecerAceleracion(a);


objNewton.calcularMasa();


System.out.println("----------- Imprime resultado ------------");
System.out.println("Masa = " + objNewton.obtenerMasa());
}
}
}

----------------------------------------------------------------------------

import java.io.*;
public class EjecutaDiceDia2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
int nDia=0;


DiceDia2 objDia = new DiceDia2();

System.out.println("n DICE NOMBRE DEL DIAn");


try
{
System.out.println("------------ Lectura del dato ------------");
System.out.print("Teclee numero de dia (1-7): ");
datoEntrada = flujoEntrada.readLine();
nDia = Integer.parseInt(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objDia.establecerNumDia(nDia);


objDia.calcularNombreDia();

System.out.println("----------- Imprime resultado ------------");
System.out.println("El dia es = " + objDia.obtenerNombreDia());
}
}

--------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class DiceDia2
{

private int numDia;
private String nombreDia;


public void establecerNumDia(int num)
{
numDia = num;
}

public void calcularNombreDia()
{
switch (numDia)
{
case 1:
nombreDia = "Domingo";
break;
case 2:
nombreDia = "Lunes";
break;
case 3:
nombreDia = "Martes";
break;
case 4:
nombreDia = "Miercoles";
break;
case 5:
nombreDia = "Jueves";
break;
case 6:
nombreDia = "Viernes";
break;
case 7:
nombreDia = "Sabado";
break;
default:
nombreDia = "No esta en el rango de 1 a 7";
}

}


public String obtenerNombreDia()
{
return nombreDia;
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaAngulo5
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;
double tamAng=0;


Angulo5 objAngulo = new Angulo5();

System.out.println("n CALCULOS LOGARITMICOS DE ANGULOn");


try
{
System.out.println("------------ Lectura del dato ------------");
System.out.print("Teclee tamaño del angulo en radianes: ");
datoEntrada = flujoEntrada.readLine();
tamAng = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objAngulo.establecerTamAngulo(tamAng);


objAngulo.calcularSenAng();
objAngulo.calcularCosAng();


System.out.println("----------- Imprime resultados -----------");
System.out.println("Seno = " + objAngulo.obtenerSenAng());
System.out.println("Coseno = " + objAngulo.obtenerCosAng());
}
}
---------------------------------------------------------------------------
import java.io.*;
public class Angulo5
{

private double tamAngulo;
private double senAng;
private double cosAng;


public void establecerTamAngulo(double ang)
{
tamAngulo = ang;
}

public void calcularSenAng()
{
senAng = Math.sin(tamAngulo);
}

public void calcularCosAng()
{
cosAng = Math.cos(tamAngulo);
}

public double obtenerSenAng()
{
return senAng;
}

public double obtenerCosAng()
{
return cosAng;
}
}
------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaRadianGrado2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
double radian=0, grad=0;


RadianGrado2 objRadianGrado = new RadianGrado2();

System.out.println("nCONVIERTE RADIANES A GRADOS Y GRADOS A RADIANESn");


try
{
System.out.println("------------ Lectura de datos ------------");
System.out.print("Teclee numero de radianes: ");
datoEntrada = flujoEntrada.readLine();
radian = Double.parseDouble(datoEntrada);

System.out.print("Teclee numero de grados: ");
datoEntrada = flujoEntrada.readLine();
grad = Double.parseDouble(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


objRadianGrado.establecerRadianes(radian);
objRadianGrado.establecerGrados(grad);

objRadianGrado.calcularNumRadianes();
objRadianGrado.calcularNumGrados();


System.out.println("------------ Imprime resultados -----------");
System.out.println("Numero de grados = " + objRadianGrado.obtenerNumGrados());
System.out.println("Numero de radianes = " + objRadianGrado.obtenerNumRadianes());
}
}
-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EjecutaEmpleado5{
public static void main(String args[]){

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;
String nomEmp;
int hrsTra;
float cuoHr;


Empleado5 objEmpleado = new Empleado5();

try{
System.out.println("------------ Lectura de datos ------------");
System.out.print("Teclee nombre: ");
datoEntrada = flujoEntrada.readLine();
nomEmp = datoEntrada;

System.out.print("Teclee horas trabajadas: ");
datoEntrada = flujoEntrada.readLine();
hrsTra = Integer.parseInt(datoEntrada);

System.out.print("Teclee cuota por hora: ");
datoEntrada = flujoEntrada.readLine();
cuoHr = Float.parseFloat(datoEntrada);


objEmpleado.establecerNombreEmp(nomEmp);
objEmpleado.establecerHorasTrab(hrsTra);
objEmpleado.establecerCuotaHora(cuoHr);
objEmpleado.calcularSueldo();

}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}


System.out.println("----------- Imprime resultados -----------");
System.out.println("Nombre = " + objEmpleado.obtenerNombreEmp());
System.out.println("Sueldo = " + objEmpleado.obtenerSueldo());
}
}

----------------------------------------------------------------------------

import java.io.*;
public class EjecutaAlumno3{
public static void main(String args[]){

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;
String nombre="";
float c1=0, c2=0, c3=0, c4=0;

Alumno3 objAlumno = new Alumno3();

System.out.println("n CALCULA PROMEDIO DE UN ALUMNOn");

try
{
System.out.println("------------ Lectura de datos ------------");
System.out.print("Teclee nombre: ");
datoEntrada = flujoEntrada.readLine();
nombre = datoEntrada;

System.out.print("Teclee calificacion 1: ");
datoEntrada = flujoEntrada.readLine();
c1 = Float.parseFloat(datoEntrada);

System.out.print("Teclee calificacion 2: ");
datoEntrada = flujoEntrada.readLine();
c2 = Float.parseFloat(datoEntrada);

System.out.print("Teclee calificacion 3: ");
datoEntrada = flujoEntrada.readLine();
c3 = Float.parseFloat(datoEntrada);

System.out.print("Teclee calificacion 4: ");
datoEntrada = flujoEntrada.readLine();
c4 = Float.parseFloat(datoEntrada);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}

objAlumno.establecerNombreAlum(nombre);
objAlumno.establecerCalif1(c1);
objAlumno.establecerCalif2(c2);
objAlumno.establecerCalif3(c3);
objAlumno.establecerCalif4(c4);
objAlumno.calcularPromedio();

System.out.println("----------- Imprime resultados -----------");
System.out.println("Nombre = " + objAlumno.obtenerNombreAlum());
System.out.println("Promedio = " + objAlumno.obtenerPromedio());
}
}




--------------------------------------------------------------------------------
import java.io.*;
public class ArregloCuatroDim1
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int numeros[][][][] = new int[4][3][5][5];
int ren1, col1, ren2, col2;

System.out.println("\nLEE NUMEROS EN UN ARREGLO TETRADIMENSIONAL");
System.out.println(" Y LOS IMPRIME EN LA PANTALLA");

try
{
System.out.println("-------- Entrada de datos --------");
for (ren1 = 0; ren1 <= 3; ren1++)
{
for (col1 = 0; col1 <= 2; col1++)
{
for (ren2 = 0; ren2 <= 4; ren2++)
{
for (col2 = 0; col2 <= 4; col2++)
{
System.out.print("Teclee a[" + ren1 + "," + col1 + "," + ren2 + "," + col2 + "]: ");
datoEntrada = flujoEntrada.readLine();
numeros[ren1][col1][ren2][col2] = Integer.parseInt(datoEntrada);
}
}
}
}

System.out.println("------------ Salida ------------");
for (ren1 = 0; ren1 <= 3; ren1++)
{
for (col1 = 0; col1 <= 2; col1++)
{
for (ren2 = 0; ren2 <= 4; ren2++)
{
for (col2 = 0; col2 <= 4; col2++)
{
System.out.print(numeros[ren1][col1][ren2][col2] + " ");
}
System.out.println();
}
System.out.println();
}
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}
-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ArregloCuatroDim2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int prod[][][][] = new int[6][3][4][5];
int pla, est, obr, dia;

System.out.println("\nLEE LA PRODUCCION EN UN ARREGLO DE 4 DIMENSIONES");
System.out.println("E IMPRIME EL REPORTE DE PRODUCCION EN LA PANTALLA");
System.out.println("PRODUCCION[PLANTA][ESTACION][OBRERO][DIA]");
System.out.println("-------- Entrada de datos --------");

try
{
for (pla = 0; pla <= 5; pla++)
{
for (est = 0; est <= 2; est++)
{
for (obr = 0; obr <= 3; obr++)
{
System.out.print(" Planta " + (pla+1) + " ");
System.out.println("Estacion " + (est+1));
System.out.println(" Obrero " + (obr+1));
for (dia = 0; dia <= 4; dia++)
{
System.out.print("Produccion dia " + (dia+1) + ": ");
datoEntrada = flujoEntrada.readLine();
prod[pla][est][obr][dia] = Integer.parseInt(datoEntrada);
}
}
}
}

System.out.println("\n REPORTE SEMANAL DE PRODUCCION");
for (pla = 0; pla <= 5; pla++)
{
System.out.println("----------------------------------------------");
System.out.println(" Planta " + (pla+1) );
System.out.println("----------------------------------------------");
for (est = 0; est <= 2; est++)
{
System.out.println(" Estacion " + (est+1));
System.out.println(" Dia 1 Dia 2 Dia 3 Dia 4 Dia 5");
System.out.println(" ----- ----- ----- ----- -----");
for (obr = 0; obr <= 2; obr++)
{
System.out.print("Obrero - " + (obr+1) + " ");
for (dia = 0; dia <= 4; dia++)
{
System.out.print(prod[pla][est][obr][dia] + " ");
}
System.out.println();
}
System.out.println(" ----- ----- ----- ----- -----");
}
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ArregloCuatroDim3
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int prod[][][][] = new int[6][3][4][5];
int pla, est, obr, dia, totEst, totDia, totObr, totPlanta, totProd;

System.out.println("\nLEE LA PRODUCCION EN UN ARREGLO DE 4 DIMENSIONES");
System.out.println("E IMPRIME EL REPORTE DE PRODUCCION EN LA PANTALLA");
System.out.println("PRODUCCION[PLANTA][ESTACION][OBRERO][DIA]");
System.out.println("-------- Entrada de datos --------");

try
{
for (pla = 0; pla <= 5; pla++)
{
for (est = 0; est <= 2; est++)
{
for (obr = 0; obr <= 3; obr++)
{
System.out.print(" Planta " + (pla+1) + " ");
System.out.println("Estacion " + (est+1));
System.out.println(" Obrero " + (obr+1));
for (dia = 0; dia <= 4; dia++)
{
System.out.print("Produccion dia " + (dia+1) + ": ");
datoEntrada = flujoEntrada.readLine();
prod[pla][est][obr][dia] = Integer.parseInt(datoEntrada);
}
}
}
}

System.out.println("\n REPORTE SEMANAL DE PRODUCCION");
totProd = 0;
for (pla = 0; pla <= 5; pla++)
{
System.out.println("----------------------------------------------");
System.out.println(" Planta " + (pla+1) );
System.out.println("----------------------------------------------");
totPlanta = 0;
for (est = 0; est <= 2; est++)
{
System.out.println(" Estacion " + (est+1));
System.out.println(" Dia 1 Dia 2 Dia 3 Dia 4 Dia 5 Total");
System.out.println(" ----- ----- ----- ----- ----- -----");
for (obr = 0; obr <= 2; obr++)
{
System.out.print("Obrero - " + (obr+1) + " ");
totObr = 0;
for (dia = 0; dia <= 4; dia++)
{
System.out.print(prod[pla][est][obr][dia] + " ");
totObr = totObr + prod[pla][est][obr][dia];
}
System.out.println(totObr);
}
System.out.println(" ----- ----- ----- ----- ----- -----");
System.out.print(" Totales ");
totEst = 0;
for (dia = 0; dia <= 4; dia++)
{
totDia = 0;
for (obr = 0; obr <= 2; obr++)
{
totDia = totDia + prod[pla][est][obr][dia];
}
System.out.print(totDia + " ");
totEst = totEst + totDia;
}
System.out.println(totEst);
System.out.println("----------------------------------------------");
totPlanta = totPlanta + totEst;
}
System.out.println(" Total produccion planta " + totPlanta);
System.out.println("----------------------------------------------");
totProd = totProd + totPlanta;
}
System.out.println("Total general de produccion " + totProd);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ArregloCuatroDim4
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int prod[][][][] = new int[6][3][4][5];
int pla, est, obr, dia, totEst, totDia, totObr, totPlanta, totProd,
mayEst=0, mayProdEst, mayPla=0, mayProdPla;

System.out.println("\nLEE LA PRODUCCION EN UN ARREGLO DE 4 DIMENSIONES");
System.out.println("E IMPRIME EL REPORTE DE PRODUCCION EN LA PANTALLA");
System.out.println("PRODUCCION[PLANTA][ESTACION][OBRERO][DIA]");
System.out.println("-------- Entrada de datos --------");

try
{
for (pla = 0; pla <= 5; pla++)
{
for (est = 0; est <= 2; est++)
{
for (obr = 0; obr <= 3; obr++)
{
System.out.print(" Planta " + (pla+1) + " ");
System.out.println("Estacion " + (est+1));
System.out.println(" Obrero " + (obr+1));
for (dia = 0; dia <= 4; dia++)
{
System.out.print("Produccion dia " + (dia+1) + ": ");
datoEntrada = flujoEntrada.readLine();
prod[pla][est][obr][dia] = Integer.parseInt(datoEntrada);
}
}
}
}

System.out.println("\n REPORTE SEMANAL DE PRODUCCION");
totProd = 0;
mayProdPla = 0;
for (pla = 0; pla <= 5; pla++)
{
System.out.println("----------------------------------------------");
System.out.println(" Planta " + (pla+1) );
System.out.println("----------------------------------------------");
totPlanta = 0;
mayProdEst = 0;
for (est = 0; est <= 2; est++)
{
System.out.println(" Estacion " + (est+1));
System.out.println(" Dia 1 Dia 2 Dia 3 Dia 4 Dia 5 Total");
System.out.println(" ----- ----- ----- ----- ----- -----");
for (obr = 0; obr <= 2; obr++)
{
System.out.print("Obrero - " + (obr+1) + " ");
totObr = 0;
for (dia = 0; dia <= 4; dia++)
{
System.out.print(prod[pla][est][obr][dia] + " ");
totObr = totObr + prod[pla][est][obr][dia];
}
System.out.println(totObr);
}
System.out.println(" ----- ----- ----- ----- ----- -----");
System.out.print(" Totales ");
totEst = 0;
for (dia = 0; dia <= 4; dia++)
{
totDia = 0;
for (obr = 0; obr <= 2; obr++)
{
totDia = totDia + prod[pla][est][obr][dia];
}
System.out.print(totDia + " ");
totEst = totEst + totDia;
}
System.out.println(totEst);
System.out.println("----------------------------------------------");
totPlanta = totPlanta + totEst;
if (totEst > mayProdEst)
{
mayProdEst = totEst;
mayEst = est + 1;
}
}
System.out.println(" Total produccion planta " + totPlanta);
System.out.println(" Estacion mas productiva = " + mayEst);
System.out.println("Produccion de estacion mas productiva = " + mayProdEst);
System.out.println("----------------------------------------------");
totProd = totProd + totPlanta;
if (totPlanta > mayProdPla)
{
mayProdPla = totPlanta;
mayPla = pla + 1;
}
}
System.out.println("Total general de produccion " + totProd);
System.out.println(" Planta mas productiva = " + mayPla);
System.out.println("Produccion de planta mas productiva = " + mayProdPla);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ArregloTresDim1
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int numeros[][][] = new int[4][5][5];
int pri, seg, ter;

try
{

System.out.println("-------- Entrada de datos --------");
for (pri = 0; pri <= 3; pri++)
{
for (seg = 0; seg <= 4; seg++)
{
for (ter = 0; ter <= 4; ter++)
{
System.out.print("Teclee a[" + pri + "," + seg + "," + ter + "]: ");
datoEntrada = flujoEntrada.readLine();
numeros[pri][seg][ter] = Integer.parseInt(datoEntrada);
}
}
}

System.out.println("------------ Salida ------------");
for (pri = 0; pri <= 3; pri++)
{
System.out.println("----------- Matriz " + pri + " -----------");
for (seg = 0; seg <= 4; seg++)
{
for (ter = 0; ter <= 4; ter++)
{
System.out.print(numeros[pri][seg][ter] + " ");

}
System.out.println();
}
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ArregloTresDim2
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int prod[][][] = new int[6][4][5];
int pla, est, dia;

System.out.println("\nLEE LA PRODUCCION EN UN ARREGLO DE TRES DIMENSIONES");
System.out.println("E IMPRIME EL REPORTE DE PRODUCCION EN LA PANTALLA");
System.out.println("PRODUCCION[PLANTA][ESTACION][DIA]");
System.out.println("-------- Entrada de datos --------");

try
{
for (pla = 0; pla <= 5; pla++)
{
for (est = 0; est <= 3; est++)
{
System.out.print(" Planta " + (pla+1) + " ");
System.out.println("Estacion " + (est+1));
for (dia = 0; dia <= 4; dia++)
{
System.out.print("Produccion dia " + (dia+1) + ": ");
datoEntrada = flujoEntrada.readLine();
prod[pla][est][dia] = Integer.parseInt(datoEntrada);
}
}
}

for (pla = 0; pla <= 5; pla++)
{
System.out.println("\n------------ Planta " + (pla+1) + " ------------");
System.out.println(" Dia 1 Dia 2 Dia 3 Dia 4 Dia 5");
System.out.println(" ----- ----- ----- ----- -----");
for (est = 0; est <= 3; est++)
{
System.out.print("Estacion-" + (est+1) + " ");
for (dia = 0; dia <= 4; dia++)
{
System.out.print(prod[pla][est][dia] + " ");
}
System.out.println();
}
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ArregloTresDim3
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int prod[][][] = new int[6][4][5];
int pla, est, dia, totEst, totDia, totPlanta, totProd;

System.out.println("\nLEE LA PRODUCCION EN UN ARREGLO DE TRES DIMENSIONES");
System.out.println("E IMPRIME EL REPORTE DE PRODUCCION EN LA PANTALLA");
System.out.println("PRODUCCION[PLANTA][ESTACION][DIA]");
System.out.println("-------- Entrada de datos --------");

try
{
for (pla = 0; pla <= 5; pla++)
{
for (est = 0; est <= 3; est++)
{
System.out.print(" Planta " + (pla+1) + " ");
System.out.println("Estacion " + (est+1));
for (dia = 0; dia <= 4; dia++)
{
System.out.print("Produccion dia " + (dia+1) + ": ");
datoEntrada = flujoEntrada.readLine();
prod[pla][est][dia] = Integer.parseInt(datoEntrada);
}
}
}

System.out.println("\n REPORTE SEMANAL DE PRODUCCION");
totProd = 0;
for (pla = 0; pla <= 5; pla++)
{
System.out.println("\n------------------- Planta " + (pla+1) + " ------------------");
System.out.println(" Dia 1 Dia 2 Dia 3 Dia 4 Dia 5 TOTAL");
System.out.println(" ----- ----- ----- ----- ----- -----");
for (est = 0; est <= 3; est++)
{
System.out.print("Estacion-" + (est+1) + " ");
totEst = 0;
for (dia = 0; dia <= 4; dia++)
{
System.out.print(prod[pla][est][dia] + " ");
totEst = totEst + prod[pla][est][dia];
}
System.out.println(totEst);
}
System.out.println(" ----- ----- ----- ----- ----- -----");
System.out.print(" Totales ");
totPlanta = 0;
for (dia = 0; dia <= 4; dia++)
{
totDia = 0;
for (est = 0; est <= 3; est++)
{
totDia = totDia + prod[pla][est][dia];
}
System.out.print(totDia + " ");
totPlanta = totPlanta + totDia;
}
System.out.println(totPlanta);
totProd = totProd + totPlanta;
}
System.out.println(" Total general de produccion = " + totProd);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ArregloTresDim4
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int prod[][][] = new int[6][4][5];
int pla, est, dia, totEst, totDia, totPlanta, totProd,
mayPla, mayProdPla, mayEst=0, mayProdEst=0;

System.out.println("\nLEE LA PRODUCCION EN UN ARREGLO DE TRES DIMENSIONES");
System.out.println("E IMPRIME EL REPORTE DE PRODUCCION EN LA PANTALLA");
System.out.println("PRODUCCION[PLANTA][ESTACION][DIA]");
System.out.println("-------- Entrada de datos --------");

try
{
for (pla = 0; pla <= 5; pla++)
{
for (est = 0; est <= 3; est++)
{
System.out.print(" Planta " + (pla+1) + " ");
System.out.println("Estacion " + (est+1));
for (dia = 0; dia <= 4; dia++)
{
System.out.print("Produccion dia " + (dia+1) + ": ");
datoEntrada = flujoEntrada.readLine();
prod[pla][est][dia] = Integer.parseInt(datoEntrada);
}
}
}

System.out.println("\n REPORTE SEMANAL DE PRODUCCION");
totProd = 0;
mayProdPla = 0;
for (pla = 0; pla <= 5; pla++)
{
System.out.println("\n------------------- Planta " + (pla+1) + " ------------------");
System.out.println(" Dia 1 Dia 2 Dia 3 Dia 4 Dia 5 TOTAL");
System.out.println(" ----- ----- ----- ----- ----- -----");
mayProdEst = 0;
for (est = 0; est <= 3; est++)
{
System.out.print("Estacion-" + (est+1) + " ");
totEst = 0;
for (dia = 0; dia <= 4; dia++)
{
System.out.print(prod[pla][est][dia] + " ");
totEst = totEst + prod[pla][est][dia];
}
System.out.println(totEst);
if (totEst > mayProdEst)
{
mayProdEst = totEst;
mayEst = est + 1;
}
}
System.out.println(" ----- ----- ----- ----- ----- -----");
System.out.print(" Totales ");
totPlanta = 0;
for (dia = 0; dia <= 4; dia++)
{
totDia = 0;
for (est = 0; est <= 3; est++)
{
totDia = totDia + prod[pla][est][dia];
}
System.out.print(totDia + " ");
totPlanta = totPlanta + totDia;
}
System.out.println(totPlanta);
System.out.println(" Estacion mas productiva = " + mayEst);
System.out.println("Produccion de estacion mas productiva = " + mayProdEst);
if (totPlanta > mayProdPla)
{
mayProdPla = totPlanta;
mayPla = pla + 1;
}
totProd = totProd + totPlanta;
}
System.out.println(" Total general de produccion = " + totProd);
System.out.println("\n Planta mas productiva = " + mayEst);
System.out.println("Produccion de planta mas productiva = " + mayProdEst);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class Capitales
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

String estados[][] = new String[32][2];
String estado;
int r;
char desea=' ';

System.out.println("\n ESTADOS Y CAPITALES");

try
{

System.out.println("---------- Entrada de datos ----------");
for (r = 0; r <= 31; r++)
{
System.out.print("Teclee estado[" + r + "]: ");
datoEntrada = flujoEntrada.readLine();
estados[r][0] = datoEntrada;

System.out.print("Teclee capital[" + r + "]: ");
datoEntrada = flujoEntrada.readLine();
estados[r][1] = datoEntrada;
}

System.out.print("\n¿Desea consultar capital(S/N)?: ");
desea = (char)System.in.read();
System.in.skip(2);
while (desea == 'S' || desea == 's')
{
System.out.print("Teclee el estado: ");
datoEntrada = flujoEntrada.readLine();
estado = datoEntrada;

r = -1;
do
{
r = r + 1;
if (estado.equals(estados[r][0]))
{
System.out.println("Capital = " + estados[r][1]);
}
} while (!estado.equals(estados[r][0]));

System.out.print("\n¿Desea consultar capital(S/N)?: ");
desea = (char)System.in.read();
System.in.skip(2);
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class CuadradoMagico
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int cuadrado[][] = new int[3][3];
int r, c, sumDiag1, sumDiag2, sumRen, sumCol, bandera;

try
{

System.out.println("-------- Entrada de datos --------");
for (r = 0; r <= 2; r++)
{
for (c = 0; c <= 2; c++)
{
System.out.print("Teclee a[" + r + "," + c + "]: ");
datoEntrada = flujoEntrada.readLine();
cuadrado[r][c] = Integer.parseInt(datoEntrada);
}
}

bandera = 0;
sumDiag1 = 0;
System.out.println("\n------ Cuadrado magico ------\n");
for (r = 0; r <= 2; r++)
{
System.out.print(" ");
sumRen = 0;
for (c = 0; c <= 2; c++)
{
System.out.print(cuadrado[r][c] + " ");
sumRen = sumRen + cuadrado[r][c];
if (r == c)
{
sumDiag1 = sumDiag1 + cuadrado[r][c];
}
}
System.out.println(" " + sumRen);

if (sumRen != 15)
{
bandera = 1;
}
}

System.out.println();
for (r = 0; r <= 2; r++)
{
sumCol = 0;
for (c = 0; c <= 2; c++)
{
sumCol = sumCol + cuadrado[r][c];
}
System.out.print(sumCol + " ");
if (sumCol != 15)
{
bandera = 1;
}
}

sumDiag2 = 0;
for (r = 0; r <= 2; r++)
{
sumDiag2 = sumDiag2 + cuadrado[r][2-r];
}

System.out.println("\n\nDiagonal 1 = " + sumDiag1);
System.out.println("Diagonal 2 = " + sumDiag2);

if (sumDiag1 != 15 || sumDiag2 != 15)
{
bandera = 1;
}

if (bandera == 0)
System.out.println("\nEs un cuadrado magico");
else
System.out.println("\nNo es un cuadrado magico");
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class DesviacionMedia
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int numeros[] = new int[15];
int r, sumatoria;
float media, desviacion;

System.out.println("\nCALCULA LA DESVIACION DE LA MEDIA\n");

try
{

System.out.println("-------- Entrada de datos --------");
sumatoria = 0;
for (r = 0; r <= 14; r++)
{
System.out.print("Teclee numeros[" + r + "]: ");
datoEntrada = flujoEntrada.readLine();
numeros[r] = Integer.parseInt(datoEntrada);
sumatoria = sumatoria + numeros[r];
}
media = sumatoria / (float)15;

System.out.println("\nELEMENTO DESVIACION");
System.out.println("---------------------");

for (r = 0; r <= 14; r++)
{
desviacion = numeros[r] - media;
System.out.println(" " + numeros[r] + " " + desviacion);
}
System.out.println("---------------------");
System.out.println("Media = " + media);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class Distribucion
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int rangos[][] = new int[15][3];
int i, c, r, numero;

System.out.println("\n DISTRIBUCION DE FRECUENCIAS");

try
{

System.out.println("---------- Entrada de datos ----------");
for (r = 0; r <= 14; r++)
{
System.out.print("Teclee rangos[" + r + ",1]: ");
datoEntrada = flujoEntrada.readLine();
rangos[r][0] = Integer.parseInt(datoEntrada);

System.out.print("Teclee rangos[" + r + ",2]: ");
datoEntrada = flujoEntrada.readLine();
rangos[r][1] = Integer.parseInt(datoEntrada);
rangos[r][2] = 0;
}

for (i = 1; i <= 50; i++)
{
System.out.print("Teclee numero: ");
datoEntrada = flujoEntrada.readLine();
numero = Integer.parseInt(datoEntrada);

r = -1;
do
{
r = r + 1;
if (numero >= rangos[r][0] && numero <= rangos[r][1])
{
rangos[r][2] = rangos[r][2] + 1;
}
} while (!(numero >= rangos[r][0] && numero <= rangos[r][1]));
}

System.out.println(" DISTRIBUCION DE FRECUANCIAS");
System.out.println("RANGO LIM.INFERIOR LIM.SUPERIOR No.OCURRENCIAS");
System.out.println("------------------------------------------------");
for (r = 0; r <= 14; r++)
{
System.out.print(" " + r + " ");
for (c = 0; c <= 2; c++)
{
System.out.print(rangos[r][c] + " ");
}
System.out.println();
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class EdadesSueldos
{
public static void main(String args[])

{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

String nombres[] = new String[15];
int edades[] = new int[15];
float sueldos[] = new float[15];
int i, edadMayor=0;
float sueldoMayor, totSueldos;
String empleadoMayor="";

System.out.println("\nPROCESA EDADES Y SUELDOS DE PERSONAS\n");

try
{
System.out.println("---------- Entrada de datos ----------");
for (i = 0; i <= 14; i++)
{
System.out.print("Teclee nombres[" + i + "]: ");
datoEntrada = flujoEntrada.readLine();
nombres[i] = datoEntrada;

System.out.print("Teclee edades[" + i + "]: ");
datoEntrada = flujoEntrada.readLine();
edades[i] = Integer.parseInt(datoEntrada);

System.out.print("Teclee sueldos[" + i + "]: ");
datoEntrada = flujoEntrada.readLine();
sueldos[i] = Float.parseFloat(datoEntrada);
}

System.out.println(" REPORTE DE EMPLEADOS");
System.out.println(" NOMBRE EDAD SUELDO");
System.out.println("---------------------------------------");
sueldoMayor = 0;
totSueldos = 0;
for (i = 0; i <= 14; i++)
{
System.out.println(nombres[i] + " " + edades[i] + " " + sueldos[i]);
totSueldos = totSueldos + sueldos[i];
if (sueldos[i] > sueldoMayor)
{
sueldoMayor = sueldos[i];
empleadoMayor = nombres[i];
edadMayor = edades[i];
}
}
System.out.println("---------------------------------------");
System.out.println("Total sueldos = " + totSueldos);
System.out.println("Empleado con mayor sueldo = " + empleadoMayor);
System.out.println("Edad del empleado con mayor sueldo = " + edadMayor);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class Fila
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int fila[] = new int[10];
int i, valor;
char desea=' ';

System.out.println("\n SIMULA UNA FILA\n");

try
{

System.out.println("---------- Entrada de datos ----------");
for (i = 0; i <= 9; i++)
{
System.out.print("Teclee elemento[" + i + "]: ");
datoEntrada = flujoEntrada.readLine();
fila[i] = Integer.parseInt(datoEntrada);
}

System.out.println("\n------------ Imprime fila ------------");
for (i = 0; i <= 9; i++)
{
System.out.print(fila[i] + " ");
}

System.out.print("\n\n¿Desea introducir un nuevo elemento(S/N)?: ");
desea = (char)System.in.read();
System.in.skip(2);
while (desea == 'S' || desea == 's')
{
System.out.print("Teclee el nuevo valor: ");
datoEntrada = flujoEntrada.readLine();
valor = Integer.parseInt(datoEntrada);
for (i = 8; i >= 0; i--)
{
fila[i+1] = fila[i];
}
fila[0] = valor;

System.out.println("\n--------- Imprime nueva fila ---------");
for (i = 0; i <= 9; i++)
{
System.out.print(fila[i] + " ");
}

System.out.print("\n\n¿Desea introducir un nuevo elemento(S/N)?: ");
desea = (char)System.in.read();
System.in.skip(2);
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class IgualdadMatrices
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int a[][] = new int[3][5];
int b[][] = new int[3][5];
int r, c, bandera;

try
{

System.out.println("-------- Entrada de datos --------");
System.out.println("------------ Matriz 1 ------------");
for (r = 0; r <= 2; r++)
{
for (c = 0; c <= 4; c++)
{
System.out.print("Teclee a[" + r + "," + c + "]: ");
datoEntrada = flujoEntrada.readLine();
a[r][c] = Integer.parseInt(datoEntrada);
}
}

System.out.println("------------ Matriz 2 ------------");
for (r = 0; r <= 2; r++)
{
for (c = 0; c <= 4; c++)
{
System.out.print("Teclee b[" + r + "," + c + "]: ");
datoEntrada = flujoEntrada.readLine();
b[r][c] = Integer.parseInt(datoEntrada);
}
}

System.out.println("------------- Salida -------------");
System.out.println("------------ Matriz 1 ------------");
for (r = 0; r <= 2; r++)
{
for (c = 0; c <= 4; c++)
{
System.out.print(a[r][c] + " ");
}
System.out.println();
}

System.out.println("\n------------ Matriz 2 ------------");
bandera = 0;
for (r = 0; r <= 2; r++)
{
for (c = 0; c <= 4; c++)
{
System.out.print(b[r][c] + " ");
if (a[r][c] != b[r][c])
{
bandera = 1;
}
}
System.out.println();
}
if (bandera == 0)
System.out.println("\nLas matrices son iguales");
else
System.out.println("\nLas matrices no son iguales");
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class MatrizNumeros
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int ren, col;
int numeros[][] = new int[4][5];

try
{

System.out.println("-------- Entrada de datos --------");
for (ren = 0; ren <= 3; ren++)
{
for (col = 0; col <= 4; col++)
{
System.out.print("Teclee numeros[" + ren + "," + col + "]: ");
datoEntrada = flujoEntrada.readLine();
numeros[ren][col] = Integer.parseInt(datoEntrada);
}
}

System.out.println("------------- Salida -------------");
for (ren = 0; ren <= 3; ren++)
{
for (col = 0; col <= 4; col++)
{
System.out.print(numeros[ren][col] + " ");
}
System.out.println();
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class MatrizVector
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);


String datoEntrada;

int a[][] = new int[5][6];
int x[] = new int[5];
int z[] = new int[5];
int r, c;

try
{
System.out.println("-------- Entrada de datos --------");
System.out.println("------------- Matriz -------------");
for (r = 0; r <= 4; r++)
{
for (c = 0; c <= 5; c++)
{
System.out.print("Teclee a[" + r + "," + c + "]: ");
datoEntrada = flujoEntrada.readLine();
a[r][c] = Integer.parseInt(datoEntrada);
}
}

System.out.println("------------- Vector -------------");
for (r = 0; r <= 4; r++)
{
System.out.print("Teclee x[" + r + "]: ");
datoEntrada = flujoEntrada.readLine();
x[r] = Integer.parseInt(datoEntrada);
}

for (r = 0; r <= 4; r++)
{
z[r] = 0;
for (c = 0; c <= 5; c++)
{
z[r] = z[r] + (x[r] * a[r][c]);
}
}

System.out.println("------------- Salida -------------");
System.out.println(" Matriz x z");
System.out.println("----------------------------------");
for (r = 0; r <= 4; r++)
{
for (c = 0; c <= 5; c++)
{
System.out.print(a[r][c] + " ");
}
System.out.println(x[r] + " " + z[r]);
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

--------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class Mayor20Numeros
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int numeros[] = new int[20];
int r, mayor, totIguales;

System.out.println("\nIMPRIME EL MAYOR DE UN ARREGLO DE NUMEROS\n");

try
{
System.out.println("-------- Entrada de datos --------");
for (r = 0; r <= 19; r++)
{
System.out.print("Teclee numeros[" + r + "]: ");
datoEntrada = flujoEntrada.readLine();
numeros[r] = Integer.parseInt(datoEntrada);
}

System.out.println("\nVECTOR DE NUMEROS");
System.out.println("-----------------");
for (r = 0; r <= 19; r++)
{
System.out.println(" " + numeros[r]);
}
System.out.println("-----------------");
mayor = numeros[0];
totIguales = 0;
for (r = 0; r <= 19; r++)
{
if (numeros[r] > mayor)
{
mayor = numeros[r];
totIguales = 1;
}
else
if (numeros[r] == mayor)
totIguales = totIguales + 1;
}
System.out.println("Numero mayor = " + mayor);
System.out.println("Total de veces que se presento = " + totIguales);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-----------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class MultiplicaMatrices
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

int a[][] = new int[2][3];
int b[][] = new int[3][4];
int p[][] = new int[2][4];
int r, c, i;

try
{

System.out.println("-------- Entrada de datos --------");
System.out.println("------------ Matriz 1 ------------");
for (r = 0; r <= 1; r++)
{
for (c = 0; c <= 2; c++)
{
System.out.print("Teclee a[" + r + "," + c + "]: ");
datoEntrada = flujoEntrada.readLine();
a[r][c] = Integer.parseInt(datoEntrada);
}
}

System.out.println("------------ Matriz 2 ------------");
for (r = 0; r <= 2; r++)
{
for (c = 0; c <= 3; c++)
{
System.out.print("Teclee a[" + r + "," + c + "]: ");
datoEntrada = flujoEntrada.readLine();
b[r][c] = Integer.parseInt(datoEntrada);
}
}

for (i = 0; i <= 1; i++)
{
for (c = 0; c <= 3; c++)
{
p[i][c] = 0;
for (r = 0; r <= 2; r++)
{
p[i][c] = p[i][c] + (a[i][r] * b[r][c]);
}
}
}

System.out.println("------------- Salida -------------");
System.out.println("------------ Matriz 1 ------------");
for (r = 0; r <= 1; r++)
{
for (c = 0; c <= 2; c++)
{
System.out.print(a[r][c] + " ");
}
System.out.println();
}

System.out.println("------------ Matriz 2 ------------");
for (r = 0; r <= 2; r++)
{
for (c = 0; c <= 3; c++)
{
System.out.print(b[r][c] + " ");
}
System.out.println();
}

System.out.println("------------ Matriz p ------------");
for (r = 0; r <= 1; r++)
{
for (c = 0; c <= 3; c++)
{
System.out.print(p[r][c] + " ");
}
System.out.println();
}
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}

-------------------------------------------------------------------------------------------------------------------------------------

import java.io.*;
public class ObrerosMatrices
{
public static void main(String args[])
{

InputStreamReader entrada = new InputStreamReader(System.in);
BufferedReader flujoEntrada = new BufferedReader(entrada);

String datoEntrada;

String obreros[] = new String[20];
int produccion[][] = new int[20][6];
int ren, col, totProd, toTotProd;

System.out.println("\nPROCESA PRODUCCION DE OBREROS\n");

try
{

System.out.println("-------------- Entrada de datos --------------");
for (ren = 0; ren <= 19; ren++)
{
System.out.print("Teclee obreros[" + ren + "]: ");
datoEntrada = flujoEntrada.readLine();
obreros[ren] = datoEntrada;
for (col = 0; col <= 5; col++)
{
System.out.print("Teclee produccion[" + ren + "," + col + "]: ");
datoEntrada = flujoEntrada.readLine();
produccion[ren][col] = Integer.parseInt(datoEntrada);
}
}

System.out.println(" REPORTE SEMESTRAL DE PRODUCCION");
System.out.print("NOMBRE DEL OBRERO MES1 MES2 ");
System.out.println("MES3 MES4 MES5 MES6 TOT.PRODUCCION");
System.out.print("-----------------------------------");
System.out.println("----------------------------------");
toTotProd = 0;
for (ren = 0; ren <= 19; ren++)
{
System.out.print(obreros[ren] + " ");
totProd = 0;
for (col = 0; col <= 5; col++)
{
System.out.print(produccion[ren][col] + " ");
totProd = totProd + produccion[ren][col];
}
System.out.println(totProd);
toTotProd = toTotProd + totProd;
}
System.out.println("--------------------------------------------");
System.out.println("Total " + toTotProd);
}
catch (IOException error)
{
System.err.println("Error " + error.getMessage());
}
}
}