UNIVERSIDAD NACIONAL DE

INGENIERÍA
FACULTAD DE INGENIERÍA ELÉCTRICA Y ELECTRÓNICA

TAREA DE PROGRAMACION

PROFESOR:
Arturo Vilca

ESPECIALIDAD:
Ingeniería Electrónica

INTEGRANTES:

HUAMÁN GUIA Paul Jhefry (20162536H)

2017
PROBLEMA 01:
1. Análisis
Tenemos que crear las siguientes variables para el programa:

 Diagonal mayor (tipo double)

 Diagonal menor (tipo double)
 Angulo que forman entre las diagonales (tipo double)
porque tenemos que convertir en radianes.
 Lado1 para hallar un lado del paralelogramo.
 Lado2 para hallar el otro del paralelogramo.
 Perímetro para sumar dos veces lado1 y lado2; y en el caso
del rombo y cuadrado 4 veces el lado.
 Area para hallar respectivamente de cada clase.
2. Diagrama UML
Paralelogramo
+dmayor:double
+dmenor:double
+angulo:double
+Paralelogramo()
+Paralelogramo(dmayor:double,dmenor:double,angulo:double)
-eDmayor(dmayor:double)=void
+lDmayor():double
-eDmemor(dmenor:double)=void
+lDmenor():double
-eAngulo(angulo:double)=void
+lAngulo():doublé
+lado2():double
+lado1():double
+area():double
+perímetro():double

Rombo
+dmayor:double
+dmenor:double
+angulo=90:double
+Rombo()
+Rombo(dmayor:double,dmenor:double)
-eDmayor(dmayor:double)=void
+lDmayor():double
-eDmemor(dmenor:double)=void
+lDmenor():double
-eAngulo(angulo:double)=void
+lAngulo():doublé
+lado():double
+area():double
+perimetro():double

Cuadrado
+dmayor:double
+dmenor:double
+angulo=90:double
+Cuadrado()
+Cuadrado(diagonal:double)
-eDiagonal(dmayor:double)=void
+lDiagonal():double
-eAngulo(angulo:double)=void
+lAngulo():doublé
+lado():double
+area():double
+perimetro():double

3. Codificacion:

/* Programa : Paralelogramo
* Autor : HUAMÁN GUIA, Paul Jhefry
* Codigo : 20162536H
* Sección: " O "
*/
 Clase Paraleogramo:

public class Paralelogramo{

protected double dmayor;
protected double dmenor;
protected double angulo;

public Paralelogramo(){

public Paralelogramo(double dmayor, double dmenor,

double angulo) {
this.dmayor = dmayor;
this.dmenor = dmenor;
this.angulo = angulo;
}

public void escribirDmayor(double dmayor){

this.dmayor=dmayor;
}
 public void escribirDmenor(double dmenor){
this.dmenor=dmenor;
}

public void escribirAngulo(double angulo){

this.angulo=angulo;
}

public double leerDmayor() {

return dmayor;
}

public double leerDmenor() {

return dmenor;
}

public double leerAngulo() {

return angulo;
}

public double lado1(){

//convierto en radianoes el angulo entre
diagonales
double angulo1=(angulo*Math.PI)/180;

//por matematica llegamos a que el lado1 vale la

siguiente expresion
return (Math.sqrt(Math.pow(dmayor,
2)+Math.pow(dmenor, 2)
-2*dmayor*dmenor*Math.cos(angulo1)))/2;
}

public double lado2(){

//convertimos el angulo
double angulo1=(angulo*Math.PI)/180;

//por matematica llegamos a que el lado2 vale la

siguiente expresion
return (Math.sqrt(Math.pow(dmayor,
2)+Math.pow(dmenor, 2)
+2*dmayor*dmenor*Math.cos(angulo1)));
 }

public double area(){

double angulo1=(angulo*Math.PI)/180;
return (dmayor*dmenor*Math.sin(angulo1))/2;
}

public double perimetro(){

//hallamos el perimetro
return(2*lado2()+2*lado1());
}
}
 Clase Rombo:

/* Programa : Paralelogramo
* Autor : HUAMÁN GUIA, Paul Jhefry
* Codigo : 20162536H
* Sección: " O "
*/

public class Rombo extends Paralelogramo{

public Rombo(){

public Rombo(double dmayor,double dmenor){

super(dmayor,dmenor,90);
}

public double lado(){

double a=Math.sqrt(Math.pow(dmayor/2,
2)+Math.pow(dmenor/2, 2));
return a;
}

@Override
public double area(){
return super.area();
}

@Override
public double perimetro(){
 return 4*lado();
}
}

 Clase Cuadrado:

/* Programa : Paralelogramo
* Autor : HUAMÁN GUIA, Paul Jhefry
* Codigo : 20162536H
* Sección: " O "
*/
public class Cuadrado extends Rombo{

public Cuadrado(){

}
public Cuadrado(double diagonal){
dmayor=diagonal;
dmenor=diagonal;
angulo=90;

}
@Override
public double lado(){
double a=Math.sqrt(Math.pow(dmayor/2,
2)+Math.pow(dmenor/2, 2));
return a;
}

@Override
public double area(){
return lado()*lado();
}

@Override
public double perimetro(){

return 4*lado();
}
}

4. Pruebas:
/* Programa : Paralelogramo
* Autor : HUAMÁN GUIA, Paul Jhefry
* Codigo : 20162536H
* Sección: " O "
*/

public class Prueba{

public static void main(String[] args){
//creo una objeto p1 de un paralelogramo
Paralelogramo p1 = new Paralelogramo(15,9,65);
//escribimos la diagonal mayor, diaginal menor y
el
//angulo que forman las diagonales

//imprimos los datos del paralegramo

System.out.println("Los datos del Paralelogramo
es: ");
System.out.println("La diagonal mayor es
"+p1.leerDmayor());
System.out.println("La diagonal menor es
"+p1.leerDmenor());
System.out.println("Un lado es "+p1.lado2());
System.out.println("El otro lado es
"+p1.lado1());
System.out.println("El angulo entre las
diagonales es "+p1.leerAngulo());
System.out.println("El perimetro es
"+p1.perimetro());
System.out.println("El area es "+p1.area());

//Para el rombo solo necesitamos los datos de las

diagonales
//ya que la diagonales siempre forman 90 grados

Rombo r1 = new Rombo(15,6);

System.out.println("\nLos datos del Rombo es: ");

System.out.println("La diagonal mayor es
"+r1.leerDmayor());
System.out.println("La diagonal menor es
"+r1.leerDmenor());
System.out.println("El lado es "+r1.lado());
System.out.println("El angulo entre las
diagonales es "+r1.leerAngulo());
 System.out.println("El perimetro es
"+r1.perimetro());
System.out.println("El area es "+r1.area());

//Para el cuadrado solo necesitamos la diagonal ya

que
// tienen angulos definidos y los lados son
iguales
Cuadrado c1 = new Cuadrado(4);
//datos del cuadrado
System.out.println("\nLos datos del Cuadrado es:
");
System.out.println("La diagonal mayor es
"+c1.leerDmayor());
System.out.println("El lado es "+c1.lado());
System.out.println("El angulo entre las
diagonales es "+c1.leerAngulo());
System.out.println("El perimetro es
"+c1.perimetro());
System.out.println("El area es "+c1.area());

}
}
PROBLEMA 02:
1. Análisis
Para el problema necesitamos 5 metodos:
 ingresoLlamadas en la cual ingresa un numero y los
minutos llamados.(esos dos datos se almacenan en 2
arreglos respectivamente).
 calculoMinTotal en la cual halla los minutos
realizados a todos los números llamados.
 calculoMinCel en la cual halla los minutos
realizados a un cierto numero.
 calculoLlamadas en la cual halla la cantidad de
veces llamadas a un cierto numero.
 Procedimiento en la cual nos dan los datos del
SIM.
Variables usadas en mi clase:
Dos arreglos para almacenar los números y los minutos
respectivamente de cada llamada.
Un crédito inicial.
El numero SIM(numero principal).
2. Diagrama UML
SIM
Numero:int
int[] lista=new int[10000]
int[] min=new int[10000]
crédito:double;
int m=0
+SIM()
+SIM(int numero, double credito)
+getNumero(numero:int)
+getCredito(credito:double):double
-setNumero(numero:int)=void
-setCredito(crédito:double)=void
-ingresoLlamadas(numerox:int,minx:int)
+calculoMinTotal():void
+calculoMinCel(numeroy:int):int
+calculoLlamadas(numeroy:int):int
-procedimiento():void

3. Codificacion:
public class SIM{
private int numero;
//creo arreglo muy grande para almacenar los numeros
// ya que no sabemos cuantos numeros llamaran
private int[] lista=new int[10000];
private int[] min=new int[10000];
private double credito;
private int m=0;

public SIM(){

public SIM(int numero, double credito) {

this.numero = numero;
this.credito = credito;

public int getNumero() {

return numero;
}

public double getCredito() {

return credito;
}

public void setNumero(int numero) {

this.numero = numero;
}

public void setCredito(double credito) {

this.credito = credito;
}

public void ingresoLlamadas(int numerox,int minx){

credito=credito-minx*0.20;
 lista[m]=numerox;
min[m]=minx;
m++;

public double calculoMinTotal(){

//calculo de los minutos totales que hablo
double suma=0;
for(int i=0;i<min.length;i++){
suma=suma+min[i];
}
return suma;
}

public int calculoMinCel(int numeroy){

int n=0;
//calculo de los minutos hacia un numero
for(int j=0;j<lista.length;j++){
//condicion que busca el numero seleccionado
if(lista[j]==numeroy){
n=n+min[j];
}
}

return n;
}

public int calculoLLamadas(int numeroy){

//calculo de cantidad de veces llamadas a un numero
int n=0;
for(int j=0;j<lista.length;j++){
if(lista[j]==numeroy){
n++;
}
}

return n;
}
public void procedimiento(){
int[] lista1=new int[m];
int[] min1=new int[m];
int i;
//
 System.out.println("Datos de la SIM: ");
System.out.println("Su numero SIM es "+getNumero());
System.out.println("Su credito final es "+getCredito());
for(i=0;i<lista1.length;i++){
lista1[i]=lista[i];
}
for(i=0;i<min1.length;i++){
min1[i]=min[i];
}

System.out.println("La lista de los numeros llamados : ");

for(i=0;i<lista1.length;i++){
System.out.println("Con el numero "+lista1[i]+" hablo "
+min[i]+" minutos");
}
}

4. Pruebas:
import java.util.Scanner;

public class Prueba{

public static void main(String arg[]){
SIM num1 = new SIM();
//iniciamos el numero y credito inicial
//automaticamente mi lista es 0,
//es decir no imprime ni un numero en la lista
num1.setNumero(960917317);
num1.setCredito(150);
//ingreso de los numeros con sus respectivos minutos llamados
//asumos que el minuto cuesta 0.20 centimos
num1.ingresoLlamadas(991854507, 15);
num1.ingresoLlamadas(999181527,2);
num1.ingresoLlamadas(992256325, 3);
num1.ingresoLlamadas(975384804,12);
num1.ingresoLlamadas(975585684, 4);
num1.ingresoLlamadas(975384804,8);
num1.ingresoLlamadas(999181527, 10);
num1.ingresoLlamadas(919154527, 5);
 num1.ingresoLlamadas(975384804, 30);
num1.ingresoLlamadas(3514949, 25);
//llamo al metodo que me representa el numero SIM
//y la lista de numeros y mi credito final
num1.procedimiento();

System.out.println("La cantidad de minutos realizados "

+ "a todos los numeros "+num1.calculoMinTotal());

Scanner entrada= new Scanner(System.in);

//para analizar un numero
System.out.println("Ingrese un numero "
+ "para ver la cantidad de veces y minutos llamados: ");

int n = entrada.nextInt();

//impresion de los datos hacia un numero n

System.out.println("Los minutos totales hacia el "
+ "numero "+n+" es "+num1.calculoMinCel(n));

System.out.println("La cantidad de llamadas hacia"

+ " el numero "+n+" es "+num1.calculoLLamadas(n));

}
}

5. Observacion:
No pasar del crédito entregado.

PROBLEMA 03:
6. Análisis
Para el problema nos piden 2 métodos de la clase
ManejarMatriz;
Para el método verificarDiagonales:
 Creamos una variable boolean para el true y false
(asi sabremos si es verdad o falso).(tipo boolean
)
 Una matriz con un análisis con un contador(ya que
la igualdad de elementos depende del orden la
matriz), es decir la igualdad será n-1. Donde n es
el orden de la matriz.(matriz tipo int[][],cont=0)
Para el método extraerArreglo:
 Primero calculamos la cantidad de elementos que
cumplen la condición.(arreglo tipo int )
 Luego almacenamos los elementos en el arreglo
 Retornamos el arreglo.

7. Diagrama UML
ManejarMatriz
+ Matriz:int[][]
+ x:int
- ManejarMatriz()
+ verificarDiagonales(matriz:int[][])
+ extraerArreglo(matriz:int[][]),x:int)

8. Codificación:
/* Programa : Matriz
* Autor : HUAMÁN GUIA, Paul Jhefry
* Codigo : 20162536H
* Sección: " O "
*/
public class ManejarMatriz{
private int[][] matriz;
private int x;

public ManejarMatriz(){

public void setMatriz(int[][] matriz) {

this.matriz = matriz;
}

public void setX(int x) {

this.x = x;
}

public int[][] getMatriz() {

return matriz;
}

public int getX() {

return x;
}

public boolean verificarDiagonales(int[][] matriz){

boolean opcion=false;
int i,j,m,cont=0;
//comparo los elementos de la diagonal principal de
la matriz
for(j=1;j<matriz.length;j++){
if(matriz[0][0]==matriz[j][j]){
 cont++;
j=matriz.length;
}
}
//compara los elementos de las diagonales
siguientes
for(i=1;i<matriz.length-1;i++){
m=0;
for(j=i+1;j<matriz.length;j++){
if(matriz[0][i]==matriz[1+m][i+m+1]){
//para que cumpla la condicion mi
contador
//tiene que ser igual al orden de la
matriz -1
cont++;
//cambio j al maximo para que pase a
la siguiente columna
//porque basta que sea igual solo un
elemento
j=matriz.length;
}
m++;
}
}

//si es igual al orden menos 1 sera verdadero

//cumplira con la condicion
if(cont==matriz.length-1){
opcion=true;
}
return opcion;
}

public int[] extraerArreglo(int [][]M, int x)

{
int n=0;
//primero determino cuantos elementos tiene mi
arreglo
for(int i=0; i<M.length; i+=2)
{
for(int j=0; j<M.length; j++)
{
boolean q= true;
 for(int k=0; k<M.length; k++)
{//comparo si son iguales
if(M[i][j]==M[x][k])
{
q=false;
break;
}
}
//en caso de que llegue a ser verdad
aumentara
//hasta tener el numero de elementos
del arreglo pedido
if(q==true)
n++;
}
}

//ahora al arreglo lo relleno con los datos que

anteriormente compare
int [] Arreglo = new int[n];
int n1=0;
for(int i=0; i<M.length; i+=2)
{
for(int j=0; j<M.length; j++)
{
boolean q= true;
for(int k=0; k<M.length; k++)
{
if(M[i][j]==M[x][k])
{
q=false;
break;
}
}
if(q==true)
{//almaceno los elementos al arreglo
Arreglo[n1]= M[i][j];
n1++;
}
}
}

return Arreglo;
 }

9. Prueba.
 Para matriz que cumple y no cumple.

 Para una matriz que cumple.