From dbeea11b71daed49dba009e6b643196af45cd26c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=20Mu=C3=B1oz?= Date: Mon, 11 Nov 2024 10:36:02 +0100 Subject: [PATCH] feat --- .../Ejercicio04_EncontrarPalabraMasLarga.java | 2 +- .../bloque06/Ej01_EjerciciosMatrices.java | 18 +- .../bloque07_tresEnRaya/TresEnRaya.java | 161 ++++++++++++++++++ ...icoEnArrayRespetandoIntervaloInterior.java | 41 +++++ .../ejercicios/bloque08/Ej03_LetraDNI.java | 32 ++++ .../bloque08/Ej04_MinYMaxEnMatriz.java | 65 +++++++ .../Ej06_PosiblesMovimientosAlfil.java | 53 ++++++ .../Ejercicio01_arrayImparesYPares.java | 66 +++++++ 8 files changed, 423 insertions(+), 15 deletions(-) create mode 100644 src/tutorialJava/capitulo4_Arrays/ejercicios/bloque07_tresEnRaya/TresEnRaya.java create mode 100644 src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej02_CiclicoEnArrayRespetandoIntervaloInterior.java create mode 100644 src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej03_LetraDNI.java create mode 100644 src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej04_MinYMaxEnMatriz.java create mode 100644 src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej06_PosiblesMovimientosAlfil.java create mode 100644 src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ejercicio01_arrayImparesYPares.java diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque05/Ejercicio04_EncontrarPalabraMasLarga.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque05/Ejercicio04_EncontrarPalabraMasLarga.java index 57ea3a4..f748181 100644 --- a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque05/Ejercicio04_EncontrarPalabraMasLarga.java +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque05/Ejercicio04_EncontrarPalabraMasLarga.java @@ -6,7 +6,7 @@ public class Ejercicio04_EncontrarPalabraMasLarga { public static void main(String[] args) { - System.out.println("Palabra más larga: " + + System.out.println("Contar ocurrencias: " + palabraMasLarga("rafa está afónico hoy")); } diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque06/Ej01_EjerciciosMatrices.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque06/Ej01_EjerciciosMatrices.java index ca650ba..670640f 100644 --- a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque06/Ej01_EjerciciosMatrices.java +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque06/Ej01_EjerciciosMatrices.java @@ -1,6 +1,8 @@ package tutorialJava.capitulo4_Arrays.ejercicios.bloque06; -import tutorialJava.UtilsArrays; +import java.util.Iterator; + +import tutorialJava.Utils; public class Ej01_EjerciciosMatrices { @@ -19,20 +21,8 @@ public class Ej01_EjerciciosMatrices { imprimeMatriz(m); System.out.println("Es positiva: " + esMatrizPositiva(m)); System.out.println("Es diagonal: " + esMatrizDiagonal(m)); - System.out.println("Es triangular superior: " + esMatrizTriangularSuperior(m)); System.out.println("Es dispersa: " + esMatrizDispersa(m)); - int array[] = arrayFromMatriz(m); - UtilsArrays.imprimeArray(array); - - System.out.println("Es simétrica: " + esMatrizSimetrica(m)); - - int traspuesta[][] = dameMatrizTraspuesta(m); - imprimeMatriz(traspuesta); - - matrizOpuesta(m); - imprimeMatriz(m); - int t[][] = eliminaFila(m, 2); imprimeMatriz(t); } @@ -218,7 +208,7 @@ public class Ej01_EjerciciosMatrices { * @param m * @return */ - public static void matrizOpuesta (int m[][]) { + public static void dameMatrizOpuesta (int m[][]) { for (int i = 0; i < m.length; i++) { for (int j = 0; j < m[i].length; j++) { m[i][j] = -m[i][j]; diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque07_tresEnRaya/TresEnRaya.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque07_tresEnRaya/TresEnRaya.java new file mode 100644 index 0000000..0550411 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque07_tresEnRaya/TresEnRaya.java @@ -0,0 +1,161 @@ +package tutorialJava.capitulo4_Arrays.ejercicios.bloque07_tresEnRaya; + +import tutorialJava.Utils; +import tutorialJava.UtilsArrays; + +public class TresEnRaya { + + /** + * + * @param args + */ + public static void main(String[] args) { +// int t[][] = new int[3][3]; + int t[][] = new int[][] {{2, 1, 1}, + {1, 2, 2}, + {2, 2, 0}}; + int turno = 1; + +// inicializaTablero(t); + + do { + // Muestro tablero + imprimieTablero(t); + + // Pido jugada a jugador (turno) + pidoJugadaAJugador(t, turno); + + // Cambiar turno + turno = cambiaTurno(turno); + + } while (ganadorDelJuego(t) == 0 && !hayEmpate(t)); + + // Imprimo ganador o empate + int ganador = ganadorDelJuego(t); + if (ganador != 0) { + System.out.println("Ha ganado el jugador " + ganador); + } + else { + System.out.println("Hay un empate"); + } + } + + + /** + * + * @param t + */ + public static void inicializaTablero(int t[][]) { + // Ponemos todos los valores a "0" + for (int i = 0; i < t.length; i++) { + for (int j = 0; j < t[i].length; j++) { + t[i][j] = 0; + } + } + } + + + /** + * + * @param t + */ + public static void imprimieTablero(int t[][]) { + System.out.println("\nTablero actual: "); + UtilsArrays.imprimeMatriz(t); + } + + /** + * + * @param t + * @return + */ + public static int ganadorDelJuego(int t[][]) { + // Compruebo cada fila + for (int i = 0; i < t.length; i++) { + if (t[i][0] == t[i][1] && t[i][1] == t[i][2]) { + return t[i][0]; + } + } + + // Compruebo cada columna + for (int i = 0; i < t[0].length; i++) { + if (t[0][i] == t[1][i] && t[1][i] == t[2][i]) { + return t[0][i]; + } + } + + // Compruebo las diagonales + if (t[0][0] == t[1][1] && t[1][1] == t[2][2]) { + return t[0][0]; + } + + if (t[0][2] == t[1][1] && t[1][1] == t[2][0]) { + return t[0][2]; + } + + // si llego hasta aquí, sé que el juego no se ha acabado. + return 0; + } + + + /** + * + * @return + */ + public static boolean hayEmpate (int t[][]) { + for (int i = 0; i < t.length; i++) { + for (int j = 0; j < t[i].length; j++) { + if (t[i][j] == 0) { + return false; + } + } + } + return true; + } + + /** + * + * @param t + * @param jugador + */ + public static void pidoJugadaAJugador (int t[][], int jugador) { + int filaJugada = 0, columnaJugada = 0; + boolean casillaOcupada = false; + + System.out.println("Turno del jugador: " + jugador); + + do { + casillaOcupada = false; + filaJugada = Utils.obtenerEnteroEntreLimites("Introduzca la fila de su jugada: ", 0, 2); + columnaJugada = Utils.obtenerEnteroEntreLimites("Introduzca la columna de su jugada: ", 0, 2); + + if (t[filaJugada][columnaJugada] != 0) { + System.out.println("La posición que ha pedido está ocupada, vuelva a intentarlo."); + casillaOcupada = true; + } + } while (casillaOcupada); + + // Establezco la jugada del usuario + t[filaJugada][columnaJugada] = jugador; + } + + + /** + * + * @param turno + * @return + */ + public static int cambiaTurno(int turno) { + return (turno % 2) + 1; + } +} + + + + + + + + + + diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej02_CiclicoEnArrayRespetandoIntervaloInterior.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej02_CiclicoEnArrayRespetandoIntervaloInterior.java new file mode 100644 index 0000000..5eef365 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej02_CiclicoEnArrayRespetandoIntervaloInterior.java @@ -0,0 +1,41 @@ +package tutorialJava.capitulo4_Arrays.ejercicios.bloque08; + +import tutorialJava.Utils; +import tutorialJava.UtilsArrays; + +public class Ej02_CiclicoEnArrayRespetandoIntervaloInterior { + + public static void main(String[] args) { + int posIni, posFin; + int a[] = new int[10]; + UtilsArrays.inicializaArray(a, 0, 9); + UtilsArrays.imprimeArray(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.imprimeArray(a); + } + +} diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej03_LetraDNI.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej03_LetraDNI.java new file mode 100644 index 0000000..60df866 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej03_LetraDNI.java @@ -0,0 +1,32 @@ +package tutorialJava.capitulo4_Arrays.ejercicios.bloque08; + +import java.util.Scanner; + +public class Ej03_LetraDNI { + + public static void main(String[] args) { + String letrasDNI = "TRWAGMYFPDXBNJZSQVHLCKE"; + Scanner sc = new Scanner(System.in); + int valorDni = 0; + + boolean dniIntroducidoValido; + do { + try { + System.out.println("Introduzca su DNI sin letra: "); + String dniSinLetra = sc.nextLine(); + valorDni = Integer.parseInt(dniSinLetra); + dniIntroducidoValido = true; + } + catch (Exception e) { + System.err.println("DNI introducido no es válido"); + dniIntroducidoValido = false; + } + } while (!dniIntroducidoValido); + + System.out.println(); + + char letraDni = letrasDNI.charAt(valorDni % 23); + System.out.println("Letra DNI: " + letraDni); + } + +} diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej04_MinYMaxEnMatriz.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej04_MinYMaxEnMatriz.java new file mode 100644 index 0000000..bbb782a --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej04_MinYMaxEnMatriz.java @@ -0,0 +1,65 @@ +package tutorialJava.capitulo4_Arrays.ejercicios.bloque08; + +import tutorialJava.Utils; +import tutorialJava.UtilsArrays; + +public class Ej04_MinYMaxEnMatriz { + + public static void main(String[] args) { + + int m[][] = UtilsArrays.creaEInicializaMatriz(6, 10, -1); + + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + // Genero un número al azar que no existe en la matriz + int azar; + do { + azar = Utils.obtenerNumeroAzar(0, 1000); + } while (existeValorEnMatriz(m, azar)); + + // Aquí sé que el valor de 'azar' no se encuentra repetido + m[i][j] = azar; + } + } + + UtilsArrays.imprimeMatriz(m); + + // Obtengo min y max + int min = m[0][0]; + int max = m[0][0]; + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + if (m[i][j] > max) max = m[i][j]; + if (m[i][j] < min) min = m[i][j]; + } + } + + System.out.println("Máximo: " + max + " - Mínimo: " + min); + } + + /** + * + * @param m + * @param valorBuscado + * @return + */ + public static boolean existeValorEnMatriz (int m[][], int valorBuscado) { + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + if (m[i][j] == valorBuscado) { + return true; + } + } + } + return false; + } +} + + + + + + + + + diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej06_PosiblesMovimientosAlfil.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej06_PosiblesMovimientosAlfil.java new file mode 100644 index 0000000..59e8366 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ej06_PosiblesMovimientosAlfil.java @@ -0,0 +1,53 @@ +package tutorialJava.capitulo4_Arrays.ejercicios.bloque08; + +import java.util.Scanner; + +import tutorialJava.Utils; +import tutorialJava.UtilsArrays; + +public class Ej06_PosiblesMovimientosAlfil { + + public static void main(String[] args) { +// String cabecerasFilas = "abcdefgh"; + int xAlfil, yAlfil; + int tablero[][] = UtilsArrays.creaEInicializaMatriz(8, 8, 0); + + System.out.println("Tablero del ajedrez"); + UtilsArrays.imprimeMatriz(tablero); + +// System.out.println("Dame la letra de la fila: "); +// Scanner sc = new Scanner(System.in); +// char letraFila = sc.nextLine().charAt(0); +// yAlfil = cabecerasFilas.indexOf(letraFila); + + 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 + for (int i = yAlfil + 1, j = xAlfil -1; i < tablero.length && j > -1 ; i++, j--) { + tablero[i][j] = 1; + } + + UtilsArrays.imprimeMatriz(tablero); + } + +} diff --git a/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ejercicio01_arrayImparesYPares.java b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ejercicio01_arrayImparesYPares.java new file mode 100644 index 0000000..f2922d8 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/ejercicios/bloque08/Ejercicio01_arrayImparesYPares.java @@ -0,0 +1,66 @@ +package tutorialJava.capitulo4_Arrays.ejercicios.bloque08; + +import tutorialJava.UtilsArrays; + +public class Ejercicio01_arrayImparesYPares { + + public static void main(String[] args) { + int a[] = new int[20]; + + UtilsArrays.inicializaArray(a, 0, 100); + UtilsArrays.imprimeArray(a); + + ordenaParesEImpares(a); + + UtilsArrays.imprimeArray(a); + } + + /** + * + * @param a + */ + public static void ordenaParesEImpares (int a[]) { + + while ( !(posicionUltimoPar(a) < posicionPrimerImpar(a))) { + int primeraPosImpar = posicionPrimerImpar(a); + int ultimaPosPar = posicionUltimoPar(a); + + int aux = a[primeraPosImpar]; + a[primeraPosImpar] = a[ultimaPosPar]; + a[ultimaPosPar] = aux; + } + } + + + public static int posicionUltimoPar (int a[]) { + int posicion = 0; + for (int i = 0; i < a.length; i++) { + if (a[i] % 2 == 0) { + posicion = i; + } + } + return posicion; + } + + + public static int posicionPrimerImpar (int a[]) { + for (int i = 0; i < a.length; i++) { + if (a[i] % 2 == 1) { + return i; + } + } + return -1; + } + + + +} + + + + + + + + +