Tarea VII - Logica Computacional

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 7

Espacio para subir asignación de la Unidad VII

Estimad@ participante
Te invito a que realices los siguientes problemas de diagramas de flujos de series, vectores y matrices.
Consultar los diagramas de flujo resueltos que serán las guías para que puedas realizar los propuestos. Si
te hace falta más información consultas las páginas web que están en materiales del curso.

1. 1.  Dado un vector de números reales:

 a. Escriba un método max que nos devuelva el máximo de los valores incluidos


en el vector.
Int maximo(int v[], int tam) {
Int I, max;
Max = v[0];
For (i=0; i<tam; i++) {
If (v[i] > max)
Max = v[i];
Return max;
}

 b. Escriba un método min que nos devuelva el mínimo de los valores incluidos


en el vector.
Int minimo(int v[], int tam) {

Int I, min;

min = v[0];

For (i=0; i<tam; i++) {

If (v[i] < min)

min = v[i];

Return min;
}

 c. Escriba un método medio que nos devuelva la media de los valores incluidos


en el vector.
Int med(int v[], int tam) {

Int I, med;

med = v[0];

For (i=0; i<tam; i++) {

If (v[i] / med)

med = v[i];

Return med;

 d. Escriba un método varianza que nos devuelva la varianza de los valores


incluidos en el vector.
public static void varianza(int[] values){
float varianza = 0;
int mediaAritmetica = 0;

for(int i=0; i < values.length; i++)mediaAritmetica += values[i];

mediaAritmetica = mediaAritmetica / values.length;

for(int i=0; i < values.length; i++){


varianza += Math.pow(values[i] - mediaAritmetica, 2);
}

varianza = varianza / values.length;

System.out.println(String.format("Varianza %.2f", varianza));


}
 e. Escriba un método mediano que nos devuelva la mediana de los valores
incluidos en el vector.
public static void mediana(int[] values){
Arrays.sort(values);

float mediana = 0;

if(values.length % 2 == 0){
int primerValor = values[values.length / 2];
int segundoValor = values[(values.length / 2) + 1];

mediana = (primerValor + segundoValor) / 2;


} else {
mediana = values[Math.round(values.length / 2)];
}

System.out.println(String.format("Mediana %.2f", mediana));


}

 f. Escriba un método moda que nos devuelva la moda de los valores incluidos
en el vector
public static void moda(int[] values){
Map<String, String> map = new HashMap<String, String>();

for(int i=0; i< values.length; i++){


int value = values[i];
String key = String.format("%2d", value);

if(map.containsKey(key)){
int temp = Integer.parseInt(map.get(key).trim());

map.put(key, String.format("%2d", temp + 1));


} else {
map.put(key, "1");
}
}
 g. Escriba un método percentil(n) que nos devuelva el valor correspondiente al
percentil n en el conjunto de valores del vector.
public double Percentile(double[] sequence, double excelPercentile)
{
Array.Sort(sequence);
int N = sequence.Length;
double n = (N - 1) * excelPercentile + 1;
// Another method: double n = (N + 1) * excelPercentile;
if (n == 1d) return sequence[0];
else if (n == N) return sequence[N - 1];
else
{
int k = (int)n;
double d = n - k;
return sequence[k - 1] + d * (sequence[k] - sequence[k - 1]);
}
}

 2. Implemente una clase en Java, llamada Serie, que encapsule un vector de


números reales e incluya métodos (no estáticos) que nos permitan calcular
todos los valores mencionados en el ejercicio anterior a partir de los datos
encapsulados por un objeto de tipo Serie.
public Serie(int[] values){
this.vector = new ArrayList();

for(int i=0; i<values.length; i++){


this.vector.add(new Integer(values[i]));
}
 3. Dado un vector de números reales, escriba un método que nos devuelva el
máximo y el mínimo de los valores incluidos en el vector.
public void minValue(){
Object[] values = this.vector.toArray();

Arrays.sort(values);

System.out.println(String.format("Valor minimo %02d", values[0]));


}

public void maxValue(){


Object[] values = this.vector.toArray();

Arrays.sort(values);

System.out.println(String.format("Valor minimo %02d", values[values.length - 1]));


}

4. Dado un vector, implemente un método que inserte un elemento en una


posición dada del vector.
 NOTA: Insertar un elemento en el vector desplaza una posición hacia la derecha a los elementos del
vector que han de quedar detrás del elemento insertado. Además, la inserción ocasiona la
“desaparición” del último elemento del vector.

Vector mivector = new Vector();


[Posición 0] -> Elemento 1
[Posición 1] -> Elemento 2
[Posición 2] -> Elemento 3
mivector.add("Elemento Uno");
mivector.add("Elemento Dos");
mivector.add("Elemento Tres");
[Posición 0] -> Elemento 1
[Posición 1] -> Nuevo elemento
[Posición 2] -> Elemento 2
[Posición 3] -> Elemento 3
mivector.add(1,"Nuevo elemento");
 
 

Actividad II
Crear una clase Matriz para manipular matrices que encapsule un array
bidimensional de números reales.
public class Vector {
public int n;
double[] x;

public class Matriz{


public int n;
private double[][] x;

Incluya en la clase métodos que nos permitan acceder y modificar de forma


segura los elementos de la matriz (esto es, las variables de instancia deben ser
privadas y los métodos han de comprobar la validez de sus parámetros).
public String toString(){
String texto=" ";
for(int i=0; i<n; i++){
texto+="\t "+(double)Math.round(1000*x[i])/1000;
}
texto+="\n";
return texto;
}

Escriba un método que nos permita sumar matrices.


public static Matriz suma(Matriz a, Matriz b){
Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
resultado.x[i][j]=a.x[i][j]+b.x[i][j];
}
}
return resultado;
}

c. Implemente un método que nos permita multiplicar matrices.


public static Matriz producto(Matriz a, Matriz b){
Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
for(int k=0; k<a.n; k++){
resultado.x[i][j]+=a.x[i][k]*b.x[k][j];
}
}
}
return resultado;
}

d. Cree un método con el que se obtenga la traspuesta de una matriz.

int[][] matriz = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};


int[][] matrizT = new int[matriz[0].length][matriz.length];
for (int x=0; x < matriz.length; x++) {
for (int y=0; y < matriz[x].length; y++) { ... }
}
}
matrizT[y][x] = matriz[x][y];
for (int x=0; x < matriz.length; x++) {
for (int y=0; y < matriz[x].length; y++) {
matrizT[y][x] = matriz[x][y];
}
}

También podría gustarte