|
|||||||
|
|
|
|||||
|
|
|||||||
|
|||||||
|
|
|
|||||
|
|
|||||||
Profesor : Luis Caceres
Ayudante : Pedro Silva
Fecha : 15/04/2004
1) Implementar dos metodos en Java que realicen las siguientes funcionalidades :
a) Asignar a un arreglo de tamaño N, los valores máximos de cada fila de una matriz de dimensiones N x M, la cual almacena numeros enteros.
b) Asignar a un arreglo de tamaño M, los valores míminos de cada columna de una matriz de dimensiones N x M, la cual almacena numeros reales.
El encabezado de cada metodo debe ser de la forma :
public static void idFuncion ( tipo matriz[ ][ ], tipo arr[ ] )
ej : public static void asignarMaximosFila(int matriz[ ][ ], int arr[ ])
2) Se define como cuadrado magico, a una matriz entera de dimensiones N x N, la cual cumple con la caracteristica que la sumatoria de las filas, columnas y diagonales son identicas.
Se pide implementar un método que realice las siguientes tareas :
a) Asigne a un arreglo unidimensional de tamaño 2 * N + 2, las sumatorias por fila, columna y diagonales.
b) Realice una comparacion sobre el arreglo, para verificar si todos los elementos (sumas) son iguales.
c) En caso de ser todas las sumas iguales, retornar un valor booleano true y en caso contrario retornar false.
*nota : Al método, sólo se le debe pasar como argumento la matriz de tamaño N x N. La declaración y asignacion de tamaño del arreglo se debe hacer sólo dentro del método.
3) Basadose en el problema de un bloque de masa deslizandose sobre un plano horizontal con coeficiente de roce u, se pide implementar un programa que maneje arreglos y excepciones, para realizar las siguientes tareas :
a) Incluir un método que calcule la posición máxima de un bloque de masa, si la velocidad inicial es vi.
La formula para implementar el calculo es el siguiente :
x = vi^2 / 2ug
donde u = 0.25 (coef. de roce) y g = 9.8 (constante de gravedad).
b) El programa principal debera leer por teclado un serie de valores para la velocidad inicial, entre un rango valido que va desde la velocidad = 1.0 m/s hasta 10 m/s.
La lectura se detendrá cuando se ingrese un valor negativo para la velocidad.
c) El objetivo de este programa es poder cuantizar la longitud recorrida {1,2,3,4,...} y medir con que frecuencia se recorre cada tramo.
Para ello, se especifica que se debe crear un arreglo unidimensional de tamaño 10, el cual vaya almacenado a traves un sistema de conteo, cuantas veces el bloque recorrio tal tramo de longitud.
En caso que la longitud sea mayor que 9 mts, y no exista una posicion valida dentro del arreglo de conteo, deberá ser el bloque de captura de la excepcion correspondiente, el cual cuente cuantos intentos sobrepasaron el limite de almacenamiento.
Ejemplo : Lanzamientos a cierta velocidad
velocidades : 2.45 , 3.56 , 4.56 , 5.67 , ..... , 7.89 , 8.67 , 9.56.
v = 3.56; --> int x = (int) longitud(v); --> frecuencia[x]++;
frecuencia[i] --> { 1 , 6 , 2 , 5 , 1 , 4 , 2 , 6 , 2 , 5 }
Interpretación del arreglo de frecuencias :
1 lanzamiento que recorrio entre 0 y 1 mts.
6 lanzamientos que recorrieron entre 1 y 2 mts.
2 lanzamientos que recorrieron entre 2 y 3 mts.
:
:
5 lanzamientos que recorrieron entre 9 y 10 mts.
4 lanzamientos que recorrieron mas de 10 mts. (capturados en la excepcion).
4) Escriba un programa en lenguaje Java que permita ingresar una frase desde el teclado. El programa debe poseer un metodo que permita cada una de las palabras de la frase ingresada y mostrarla a través de la pantalla.
Por ejemplo, al ingresar segunda prueba solemne debe mostrar adnuges abeurp enmelos.
5) Demostrar con un ejemplo que en Java es posible definir arreglos bidimensionales de la forma a[i][j], donde
cada fila a[i] puede tener distinta longitud.
1)
public class MaxMinMatriz {
public static void asignarMaximosFila(int matriz[ ][ ], int arr[ ])
{
int f , c;
for(f = 0; f < matriz.length ; f++) /* recorrido por fila */
{
/* asigna como maximo, al primer elemento de la fila f, y ese valor
se almacena en la posicion f del arreglo arr (que contendra finalmente los maximos
de cada fila) */
arr[f] = matriz[f][0];
for(c = 1; c < matriz[f].length ; c++) /* fila fija, columna variable */
{
if(matriz[f][c] > arr[f])
arr[f] = matriz[f][c];
}
}
}
public static void asignarMinimosColumna(double matriz[ ][ ], double arr[ ])
{
int f , c;
for(c = 0; c < matriz[0].length ; c++) /* recorrido por columna */
{
/* asigna como minimo, al primer elemento de la columna c, y ese valor
se almacena en la posicion c del arreglo arr (que contendra finalmente los minimos
de cada columna) */
arr[c] = matriz[0][c];
for(f = 1; f < matriz.length ; f++) /* columna fija, fila variable */
{
if(matriz[f][c] < arr[c])
arr[c] = matriz[f][c];
}
}
}
public static void main(String[ ] args) {
/* declaracion e inicializacion de una matriz de 3 filas y 4 columnas */
int A[ ][ ] = { {12 , 23 ,3 ,44 }, {54 , 63 , 7 , 8} , { 31 , 52 , 43 , 22 } };
/* declaracion e inicializacion de una matriz de 5 filas y 2 columnas */
double B[ ][ ] = { {2.3 ,5.2 } , { 4.0 , 7.1 },{ 2.3 , 3.1} , {4.5 , 8.9} , {1.0 , 3.2} };
/* declaracion de los arreglos minimos y maximos */
int max[ ] = new int[ A.length ];
double min[ ] = new double[ B[0].length ];
/* llamada a los metodos de asignacion */
asignarMaximosFila(A,max);
asignarMinimosColumna(B,min);
int i;
String s = "Maximos por fila : ";
for(i = 0; i < max.length ; i++)
s += max[i] + "\t";
System.out.println(s);
s = "Minimos por columna : ";
for(i = 0; i < min.length; i++)
s += min[i] + "\t";
System.out.println(s);
}
}Bajar archivo
2)
/*
Notacion del ciclo for
**********************
El ciclo for esta compuesto de los siguientes elementos :
for ( A ; B ; C) inst
sig
donde se cumplen los siguientes pasos
1) se ejecuta A
2) si la expresion es verdadera se ejecuta inst, que puede ser un bloque de
instrucciones { }, o solo una sentencia o instruccion.
si la expresion es falsa, sale del ciclo y ejecuta la sentencia posterior a inst (sig)
3) Una vez que realiza la sentencia inst, ejecuta C
4) Vuelve a paso 2)
Esta notacion permite por ejemplo, incluir la sentencia inst, seguida de la
sentencia C, separado con una coma.
Ejemplo : 1 y 2 realizan lo mismo
1) int i, cont = 0;
for(i = 0; i < 3; i++ , cont++)
2) int cont = 0;
for(i = 0; i < 3; i++)
{
cont++;
}
Por lo tanto para ciclos for, que realizan una instruccion o sentencia,
en esta propuesta de solucion, se utilizara tal notación.
*/
public class CuadradoMagico {
/* M debe ser matriz cuadrada de dimension NxN */
public static boolean esMagico(int M[ ][ ])
{
int suma[ ] = new int[ 2 *( M.length + 1 ) ];
int f, c ,pos = 0;
/* asegurar que los valores del arreglo sean todos igual a cero */
for(int i = 0; i < suma.length; suma[i++] = 0);
/* suma por fila : por cada iteracion de la fila, agregamos una instruccion adicional
dentro del for, que corresponde al incremento de la posicion, en donde se quiere
almacenar la suma de la fila correspondiente. */
for(f = pos; f < M.length; f++, pos++)
for(c = 0; c < M.length; c++)
suma[pos] += M[f][c];
/* suma por columna */
for(c = 0; c < M.length ; c++ , pos++)
for(f = 0; f < M.length; f++ )
{
suma[pos] += M[f][c];
}
/* suma por diagonal principal sera almacenada en la posicion pos del arreglo suma
deberan ser generadas las combinaciones (0,0),(1,1), ... (M.length-1 , M.length-1).
En este caso se implementara el ciclo for, de la forma tradicional para notar las
diferencias.
*/
for(f = 0; f < M.length ; f++)
{
suma[pos] += M[f][f];
}
/*
Para hacer el recorrido de la otra diagonal debemos generar las combinaciones :
(M.length - 1 , 0)(M.length - 1 , 1) .. ( 1 , M.length )( 0 , M.length - 1)
para ver mejor si la matriz fuera de 3x3 la sumatoria seria :
s = M[2][0] + M[1][1] + M[0][2];
donde hay un decremento de la fila y un incremento de la columna.
En este caso especial, podemos hacer un ciclo for con dos inicializaciones
f = ultima fila y c = columna inicial
como la fila se va decrementando y la columna se va incrementando, se
especifican dos asignaciones : f-- y c++
y por ultimo , la condicion de borde correspondiente :
f >= 0 && c < M.length - 1
ya que corresponde a una matriz cuadrada, donde el numero de filas
es igual al de columnas ( M.length ).
*/
pos++; /* la siguiente posicion corresponde al ultimo elemento del
arreglo suma*/
for(f = M.length -1 , c = 0 ; f >= 0 && c < M.length ; f-- , c++)
{
suma[pos] += M[f][c];
}
/* Ahora comparamos el elemento cero del arreglo suma, con los demas elementos
para ver si todos son iguales.
Para ello, vamos a suponer que la matriz es magica, usando una variable auxiliar
de tipo boolean inicializada en true.
Si durante el ciclo de recorrido del arreglo se encuentra una suma diferente,
se asigna false a la variable y se procede a quebrar el ciclo con un break.
*/
boolean aux = true;
for(pos = 1; pos < suma.length ; pos++)
{
if(suma[pos] != suma[0])
{
aux = false;
break;
}
}
for(pos =0; pos < suma.length; pos++)
System.out.print(suma[pos]);
System.out.println();
/* finalmente retornamos el valor de aux, que en caso de ser true, quiere decir
que la matriz es magica */
return aux;
}
/* ejemplos de cuadrados magicos 3x3
4 9 2 10 15 8
A : 3 5 7 B : 9 11 13
8 1 6 14 7 12
Sum(A) = 15 , Sum(B) = 33
*/
public static void main(String[] args)
{
int A[ ][ ] = {{4,9,2} , {3,5,7} , {8,1,6} };
int B[ ][ ] = {{10,15,8} , {9,11,13} , {14,7,12} };
if ( esMagico(A) == true ) System.out.println("A es magica");
if ( esMagico(B) ) System.out.println("B es magica");
}
}Bajar archivo
3)
import java.io.*;
public class Deslizamiento {
public static double distancia(double vi)
{
return Math.pow(vi,2.0) / (2.0 * 0.25 * 9.8 );
}
public static void main(String[] args) {
int frecuencia[ ] = {0,0,0,0,0,0,0,0,0,0};
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
double v , dist = 0.0; int x , contFueraRango = 0;
do
{
v = 0.0;
try
{
System.out.print("Ingrese velocidad : ");
v = Double.parseDouble(in.readLine());
if (v >= 1.0 && v <= 10.0)
{
dist = distancia(v);
x = (int) dist;
frecuencia[x]++;
}
else
System.out.println("velocidad fuera de rango...");
}
catch (ArrayIndexOutOfBoundsException e )
{
contFueraRango++;
}
catch(NumberFormatException ef)
{
/* en caso que se ingrese para la velocidad una cadena de caracteres o
un formato no correspondiente a un numero */
System.out.println("Formato de Velocidad erroneo..");
}
catch(IOException ioe)
{
System.out.println(ioe.getMessage());
}
finally /* bloque finally se ejecuta siempre despues de los bloques try-catch */
{
if (v >= 1.0 && v <= 10.0)
System.out.println("Distancia(" + v + ") = " + dist);
}
} while(v >= 0.0);
String s = "\nTabla de frecuencias\n--------------------\n";
for(int i = 0 ; i < frecuencia.length ; i++)
{
s += i + " ... " + (i+1) + " mts :\t" + frecuencia[i] + "\n";
}
s += "10 ... + mts : " + contFueraRango;
System.out.println(s);
}
}Bajar archivo
4)
import java.io.*;
class Transponer
{
public static String invertir(String str )
{
int i = 0 , j = str.length() - 1;
char aux[] = str.toCharArray(); /* retorna el string como un arreglo de caracteres */
char tmp;
while(i < j)
{
tmp = aux[i];
aux[i] = aux[j];
aux[j] = tmp;
i++;
j--;
}
return new String(aux);
}
public static void main(String arg[]) throws IOException
{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String frase, resultado = "";
int i, pi, pf; /* posicion inicial y final del substring */
System.out.print("Ingrese frase : ");
frase = in.readLine();
pi = 0;
for(i = 0; i < frase.length(); i++)
{
if( frase.charAt(i) == ' ')
{
resultado += invertir( frase.substring(pi,i) ) + " ";
pi = i;
}
}
if (pi < frase.length())
{
System.out.println("ultimo sub : " + frase.substring(pi,frase.length()));
resultado += invertir(frase.substring(pi,frase.length()));
}
System.out.println(resultado);
}
}Bajar archivo
5)
class PruebaDimensiones {
public static void main(String[ ] args) {
/* declaracion de matriz de 3 filas, pero con la posibilidad de dimensionar
cada fila en forma posterior */
int matriz[ ][ ] = new int[3][ ];
matriz[0] = new int[2]; /* asigna 2 columnas a fila 0 */
matriz[1] = new int[1]; /* asigna 1 columna a fila 1 */
matriz[2] = new int[8]; /* asigna 8 columnas a fila 2 */
/*
estructura de la matriz
x x
x
x x x x x x x x
*/
int i;
System.out.println("Prueba 1 para matriz\n");
for(i = 0; i < matriz.length ; i++)
{
System.out.println("numero de columnas de fila " + i + " = " + matriz[i].length);
}
/*Declaracion e inicializacion de 4 filas, cada una con 2,4,8 y 2 columnas */
int C[ ][ ] = { {2,4} , {3,4,5,6} , {2,3,4,5,6,7,8,9} , {3} };
/*
estructura de la matriz C
2 4
3 4 5 6
2 3 4 5 6 7 8 9
3
*/
System.out.println("\n\nPrueba 2 para matriz\n");
for(i = 0; i < C.length ; i++)
{
System.out.println("\nnumero de columnas de fila " + i + " = " + C[i].length);
for(int j = 0; j < C[i].length ; j++)
System.out.print(C[i][j] + "\t");
}
/*
Por ejemplo es comun en programacion, definir estrcuturas de matrices
con dimensiones de columna diferentes...
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
x x x x x x x x x x
*/
}
}Bajar archivo