BLOQUE 04 MASTER SOBRE ARRAYS

EJERCICIO 2.
public static void main(String[] args) {
int posIni, posFin;
int a[] = UtilsArrays.creaArrayNumerosAzar(10, 0, 9);
UtilsArrays.mostrarArray(a);

do {
posIni = Utils.obtenerEnteroEntreLimites("Introduzca posición
Inicial: ", 0, 9);
posFin = Utils.obtenerEnteroEntreLimites("Introduzca posición
Final: ", 0, 9);
if (posIni >= posFin) {
System.out.println("Error. La posición inicial no puede
ser mayor que "
+ " la posición final");
}
} while (posIni >= posFin);

int aux = a[a.length - 1];

for (int i = a.length - 2; i > -1; i--) {

if (i < posIni || i > posFin) {
if (i == (posIni - 1)){
a[i + posFin - posIni + 2] = a[i];
}
else {
a[i + 1] = a[i];
}
}
}

a[0] = aux;

UtilsArrays.mostrarArray(a);
}

1
EJERCICIO 6.

public static void main(String[] args) {

int xAlfil, yAlfil;
int tablero[][] = UtilsArrays.creaEInicializaMatriz(8, 8, 0);

System.out.println("Tablero del ajedrez");

UtilsArrays.mostrarMatriz(tablero);

yAlfil = Utils.obtenerEnteroEntreLimites("Introduzca la fila del

Alfil", 1, 8) - 1;
xAlfil = Utils.obtenerEnteroEntreLimites("Introduzca la columna del
Alfil", 1, 8) - 1;

// Coloco el alfil en el tablero

tablero[yAlfil][xAlfil] = 2;

// Coloco valores en Diagonal principal sobre el alfil

for (int i = yAlfil - 1, j = xAlfil - 1; i > -1 && j > -1; i--, j--)
{
tablero[i][j] = 1;
}

// Coloco valores en Diagonal principal bajo el alfil

for (int i = yAlfil + 1, j = xAlfil + 1; i < tablero.length && j <
tablero[i].length ; i++, j++) {
tablero[i][j] = 1;
}

// Coloco valores en Diagonal secundaria sobre el alfil

for (int i = yAlfil - 1, j = xAlfil + 1; i > -1 && j <
tablero[i].length ; i--, j++) {
tablero[i][j] = 1;
}

// Coloco valores en Diagonal secundaria bajo el alfil

2
 for (int i = yAlfil + 1, j = xAlfil -1; i < tablero.length && j > -
1 ; i++, j--) {
tablero[i][j] = 1;
}

UtilsArrays.mostrarMatriz(tablero);
}

Bloque 05 - Arrays con métodos y matrices

EJERCICIO 1.
/**
*
* @param args
*/
public static void main(String[] args) {
int array[] = new int[] {1, 2, 3, 4};

int variable = valorPosicionMediaDeArray(array);

System.out.println(variable);
}

/**
*
* @param array
* @return
*/
public static int valorPosicionMediaDeArray (int array[]) {
if (array.length % 2 == 1) {
return array[array.length / 2];
}
else { // El array tiene una longitud par, se devuelve -1
return -1;
}
}

3
EJERCICIO 2.
/**
*
* @param args
*/
public static void main(String[] args) {
int array[] = new int[20];
int contadorAprobados = 0;
float porcentajeAprobados = 0;

// Inicializa y muestra un array

inicializaArrayConNumerosAzar(array);
visualizaArray(array);

// Recorro el array buscando números iguales o mayores a 5

for (int i = 0; i < array.length; i++) {
if (array[i] >= 5) {
contadorAprobados++;
}
}

// Imprimo los resultados

porcentajeAprobados = contadorAprobados / (float) array.length *
100;
System.out.println("Porcentaje de aprobados: " + porcentajeAprobados
+ "%");
System.out.println("Porcentaje de aprobados: " + (100 -
porcentajeAprobados) + "%");
}

/**
*
* @param array
*/
public static void inicializaArrayConNumerosAzar(int array[]) {
for (int i = 0; i < array.length; i++) {

4
 array[i] = (int) Math.round(Math.random() * 10);
}
}

/**
*
* @param array
*/
public static void visualizaArray(int array[]) {
System.out.print("Contenido del array: ");
for (int i = 0; i < array.length; i++) {
System.out.print(" " + array[i]);
}
System.out.println();
}
EJERCICIO 3.
public static void main(String[] args) {
float array[] = new float[20];
int contador = 0;

// Creo el array
for (int i = 0; i < array.length; i++) {
// Para crear el número flotante sumo una parte entera entre 0
y 100 y una
// parte decimal entre 0 y 100, dividida entre 100.
array[i] = numeroAzar() + numeroAzar() / 100f;
}

// Muestro el array
muestraArray(array);

// Contar cuantos números tienen su parte decimal menor o igual a

0.49
for (int i = 0; i < array.length; i++) {
if ( (array[i] - ((int) array[i])) <= 0.49) {
contador++;

5
 }
}

System.out.println("Números encontrados con parte decimal menor o

igual a 0.49: " + contador);
}

/**
*
* @return
*/
public static int numeroAzar () {
return (int) Math.round(Math.random() * 100);
}

/**
*
* @param array
*/
public static void muestraArray(float array[]) {
System.out.println("Contenido del array: ");
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
EJERCICIO 4.
public class Ejercicio04_Matrices {
/**
*
* @param args
*/
public static void main(String[] args) {

6
 int matriz[][] = new int[][] { {1, 0, 0, 0,
0},
{0, 7, 0,
0, 0},
{0, 0, 6,
0, 0},
{0, 0, 0,
18, 0},
{0, 0, 0,
0, 19}};

// inicializaMatriz(matriz);
mostrarMatriz(matriz);

// Comprobación de los diferentes métodos

System.out.println("Matriz positiva: " + esMatrizPositiva(matriz));
System.out.println("Matriz diagonal: " + esMatrizDiagonal(matriz));
System.out.println("Matriz triangular superior: " +
esMatrizTriangularSuperior(matriz));

int array2[] = arrayFromMatriz(matriz);

/**
*
* @param matriz
*/
public static void inicializaMatriz (int matriz[][]) {
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
matriz[i][j] = Utils.obtenerNumeroAzar();
}
}
}

7
/**
*
* @param matriz
*/
public static void mostrarMatriz (int matriz[][]) {
System.out.println("Contenido de la matriz");
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j] + "\t");
}
System.out.println();
}
}

/**
*
* @param matriz
* @return
*/
public static boolean esMatrizPositiva (int matriz[][]) {
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
if (matriz[i][j] < 0) {
return false;
}
}
}
return true;
}

8
/**
*
* @param matriz
* @return
*/
public static boolean esMatrizDiagonal (int matriz[][]) {
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
if (i != j && matriz[i][j] != 0) {
return false;
}
}
}
return true;
}

/**
*
* @param matriz
* @return
*/
public static boolean esMatrizTriangularSuperior (int matriz[][]) {
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < i; j++) {
if (matriz[i][j] != 0) {
return false;
}
}
}
return true;
}

public static boolean esMatrizDispersa (int matriz[][]) {

// Voy a comprobar cada una de las líneas

9
 for (int i = 0; i < matriz.length; i++) {
// Voy a suponer que no hay ceros en esta línea
boolean hayCeroEnLinea = false;
// Comienzo a buscar un cero en cada línea
for (int j = 0; j < matriz[i].length; j++) {
if (matriz[i][j] == 0) {
hayCeroEnLinea = true;
break;
}
}
// Cuando llego a esta línea de código tengo una variable
booleana que
// me indica si hay o no al menos un cero en la línea
if (!hayCeroEnLinea) {
return false;
}
}

// Voy a comprobar cada una de las columnas

for (int i = 0; i < matriz[0].length; i++) {
boolean hayCeroEnColumna = false;
for (int j = 0; j < matriz.length; j++) {
if (matriz[i][j] == 0) {
hayCeroEnColumna = true;
break;
}
}
if (!hayCeroEnColumna) {
return false;
}
}

// Si llego hasta aquí la matriz es dispersa

return true;
}

10
/**
*
* @param matriz
* @return
*/
public static int[] arrayFromMatriz (int matriz[][]) {
int array[] = new int[matriz.length * matriz[0].length];

int k = 0;
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
array[k] = matriz[i][j];
k++;
}
}

return array;
}

/**
*
* @param matriz
* @return
*/
public static boolean esMatrizSimetrica (int matriz[][]) {
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
if (i != j && matriz[i][j] != matriz[j][i]) {
return false;
}
}
}
return true;
}

11
/**
*
* @param matriz
* @return
*/
public static int[][] getMatrizTraspuesta (int matriz[][]) {
int traspuesta[][] = new int[matriz[0].length][matriz.length];

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

for (int j = 0; j < matriz[i].length; j++) {
traspuesta[i][j] = matriz[j][i];
}
}

return traspuesta;
}

/**
*
* @param matriz
* @return
*/
public static int[][] getMatrizOpuesta (int matriz[][]) {
int opuesta[][] = new int[matriz.length][matriz[0].length];

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

for (int j = 0; j < matriz[i].length; j++) {
opuesta[i][j] = -matriz[i][j];
}
}

return opuesta;
}

12
 public static int[][] removeRowFromMatriz (int matriz[][], int numRow) {
int newMatriz[][] = new int[matriz.length-1][matriz[0].length];
int k = 0;

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

if (i != numRow) {
for (int j = 0; j < matriz[i].length; j++) {
newMatriz[k][j] = matriz[i][j];
}
// Después de haber copiado los elementos de una fila
// aumento el valor de k, para apuntar a una nueva fila
de la nueva matriz
k++;
}
}

return newMatriz;
}
Bloque 06 - Por entretenernos un rato
EJERCICIO 1.

/**
*
* @param args
*/
public static void main(String[] args) {
// Declaración de variables
int apuesta[] = new int[7];
boolean numEncontradoEnPosicionesPrevias;

// Un bucle que recorre el array de izquiera a derecha

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

13
 // No sé cuántas veces tendré que genera un número al azar para
asegurarme
// de que no existe en los valores que se sitúan a la izquierda
de la
// posición marcada por el valor de la "i".
do {
numEncontradoEnPosicionesPrevias = false;
apuesta[i] = (int) Math.round(Math.random() * (49 - 1) +
1);

// Busco el valor de la posición de "i" en las posiciones

a la izquierda
// de ese valor
for (int j = 0; j < i; j++) {
if (apuesta[i] == apuesta[j]) {
numEncontradoEnPosicionesPrevias = true;
}
}
} while (numEncontradoEnPosicionesPrevias == true);
}

// Recorro y muestro el array

for (int i = 0; i < apuesta.length; i++) {
System.out.print(apuesta[i] + " ");
}
}

EJERCICIO 2.
/**
*
* @param args
*/
public static void main(String[] args) {
// Declaración de variables
char matriz[][] = new char[10][30];

14
 int asteriscosEnCadaLinea;

// Relleno toda la matriz de espacios en blanco

for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
matriz[i][j] = ' ';
}
}

// Recorro todas las filas

for (int i = 0; i < matriz.length; i++) {
// Determina la cantidad de asteriscos a introducir en cada
línea
asteriscosEnCadaLinea = (int) Math.round(Math.random() * 30);

// Llenar tantos asteriscos desde la izquierda como indique la

variable
for (int j = 0; j < asteriscosEnCadaLinea; j++) {
matriz[i][j] = '*';
}

// Imprimo en consola
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j]);
}
System.out.println();
}

}
EJERCICIO 2.

public static void main(String[] args) {

15
 int numAzar, suma = 0, contador = 0;
float media;

do {
numAzar = (int) Math.round(Math.random() * 1000);
suma += numAzar;
contador++;
media = suma / (float) contador;
} while (media < 499.5 || media > 500.5);

System.out.println("He necesitado " + contador + " números para

tener una media " +
" de " + media);
}
EJERCICIO 4.
public static void main(String[] args) {
// Declaración de variables
char matriz[][] = new char[20][10];
int posicionAzarFila, posicionAzarColumna;

// La relleno de espacios en blanco

for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
if (i == 0 || i == (matriz.length - 1) || j == 0 || j ==
(matriz[0].length - 1)) {
matriz[i][j] = '*';
}
else {
matriz[i][j] = ' ';
}
}
}

// Posición del 0 con valores al azar en fila y columna

16
 posicionAzarFila = (int) Math.round(Math.random() * (matriz.length -
2 - 1) + 1);
posicionAzarColumna = (int) Math.round(Math.random() *
(matriz[0].length - 2 - 1) + 1);
// Coloco el cero
matriz[posicionAzarFila][posicionAzarColumna] = '0';

// Imprimo en consola
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j]);
}
System.out.println();
}

EJERCICIO 5.
public static void main(String[] args) {
// Declaración de variables
char matriz[][] = new char[20][10];
int probabilidad50;

// La relleno de espacios en blanco

for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
if (i == 0 || i == (matriz.length - 1) || j == 0 || j ==
(matriz[0].length - 1)) {
matriz[i][j] = '*';
}
else {
// Relleno de 0 y 1 al 50% de probabilidad

17
 probabilidad50 = (int) Math.round(Math.random());
if (probabilidad50 == 0) {
matriz[i][j] = '0';
}
else {
matriz[i][j] = '1';
}
}
}
}

// Imprimo en consola
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j]);
}
System.out.println();
}
}

18