├── .gitignore ├── Ejemplos ├── 01-Arrays │ ├── .gitignore │ ├── .idea │ │ ├── .gitignore │ │ ├── dictionaries │ │ │ └── joseluisgs.xml │ │ ├── kotlinc.xml │ │ ├── misc.xml │ │ └── uiDesigner.xml │ └── src │ │ └── main │ │ └── kotlin │ │ ├── cadenas │ │ ├── 01-Definicion.kt │ │ ├── 02-Recorridos.kt │ │ ├── 03-Metodos.kt │ │ ├── 04-ArgumentosEntrada.kt │ │ └── 05-Ejemplos01.kt │ │ ├── exp_regulares │ │ ├── ExpRegulares.kt │ │ └── Split.kt │ │ ├── matrices │ │ ├── 01-Definicion.kt │ │ ├── 02-Recorrido.kt │ │ └── 03-Ejemplos01.kt │ │ ├── ordenacion │ │ ├── Algoritmos.kt │ │ └── Pruebas.kt │ │ ├── otros │ │ └── Menu.kt │ │ └── vectores │ │ ├── 01-Definicion.kt │ │ ├── 02-Recorrido.kt │ │ └── 03-Ejemplos01.kt ├── 02-PruebaMaven │ ├── .gitignore │ ├── .idea │ │ ├── .gitignore │ │ ├── encodings.xml │ │ ├── kotlinc.xml │ │ └── misc.xml │ ├── pom.xml │ └── src │ │ └── main │ │ └── kotlin │ │ ├── Main.kt │ │ └── colors │ │ └── MyColors.kt └── 03-InitJava │ ├── .idea │ ├── .gitignore │ ├── compiler.xml │ ├── encodings.xml │ ├── jarRepositories.xml │ └── misc.xml │ ├── pom.xml │ └── src │ ├── main │ └── java │ │ └── es │ │ └── joseluisgs │ │ ├── Main.java │ │ └── utils │ │ └── Prueba.java │ └── test │ └── java │ └── Testing.java ├── Ejercicios ├── Ejercicios01.pdf ├── Ejercicios02.pdf ├── Ejercicios03.pdf └── EjerciciosExamen.pdf ├── Extras ├── checked-exception.webp ├── davechild_regular-expressions.pdf └── error-exceptions.webp ├── README.md └── Soluciones ├── Binarios-Kotlin ├── .idea │ ├── .gitignore │ ├── compiler.xml │ ├── encodings.xml │ ├── jarRepositories.xml │ ├── libraries │ │ ├── Maven__org_apiguardian_apiguardian_api_1_1_0.xml │ │ ├── Maven__org_jetbrains_annotations_13_0.xml │ │ ├── Maven__org_jetbrains_kotlin_kotlin_stdlib_1_6_0.xml │ │ ├── Maven__org_jetbrains_kotlin_kotlin_stdlib_common_1_6_0.xml │ │ ├── Maven__org_jetbrains_kotlin_kotlin_stdlib_jdk7_1_6_0.xml │ │ ├── Maven__org_jetbrains_kotlin_kotlin_stdlib_jdk8_1_6_0.xml │ │ ├── Maven__org_jetbrains_kotlin_kotlin_test_1_6_0.xml │ │ ├── Maven__org_jetbrains_kotlin_kotlin_test_junit5_1_6_0.xml │ │ ├── Maven__org_junit_jupiter_junit_jupiter_api_5_6_0.xml │ │ ├── Maven__org_junit_jupiter_junit_jupiter_engine_5_6_0.xml │ │ ├── Maven__org_junit_platform_junit_platform_commons_1_6_0.xml │ │ ├── Maven__org_junit_platform_junit_platform_engine_1_6_0.xml │ │ └── Maven__org_opentest4j_opentest4j_1_2_0.xml │ ├── misc.xml │ ├── modules.xml │ ├── uiDesigner.xml │ └── vcs.xml ├── consoleApp.iml ├── pom.xml └── src │ ├── main │ └── kotlin │ │ ├── Binary │ │ └── Binary.kt │ │ └── Main.kt │ └── test │ └── kotlin │ └── BinaryTest.kt ├── Binarios ├── .gitignore ├── .idea │ ├── .gitignore │ ├── compiler.xml │ ├── discord.xml │ ├── encodings.xml │ ├── jarRepositories.xml │ ├── misc.xml │ ├── runConfigurations.xml │ ├── uiDesigner.xml │ ├── vcs.xml │ └── workspace-FoxMacPro.xml ├── pom.xml └── src │ ├── main │ └── java │ │ └── es │ │ └── dam │ │ └── joseluisgs │ │ └── Binary.java │ └── test │ └── java │ └── BinaryTest.java ├── MoscaMatriz-java ├── .gitignore ├── .idea │ ├── .gitignore │ ├── misc.xml │ ├── modules.xml │ ├── runConfigurations.xml │ └── vcs.xml ├── MoscaVector.iml └── src │ └── mosca │ └── Mosca.java └── Soluciones-03-Kotlin ├── .gitignore ├── .idea ├── .gitignore ├── GrepConsole.xml ├── encodings.xml ├── kotlinc.xml ├── misc.xml └── uiDesigner.xml ├── pom.xml └── src └── main └── kotlin ├── arrays ├── Ahorcado.kt ├── Funciones.kt ├── MoscaVector.kt ├── Revsersed.kt └── utils.kt ├── examen ├── ESLA.kt ├── LullGasol.kt ├── PilotoAutomatico.kt └── StarWars.kt ├── exp_regulares └── ExpRegulares.kt └── matrices ├── buscaminas └── Buscaminas.kt ├── doble_buffer └── DobleBuffer.kt └── mosca ├── Mosca.kt ├── mosca └── MoscaSimulator.kt └── types └── Types.kt /.gitignore: -------------------------------------------------------------------------------- 1 | *.pptx 2 | .DS_Store 3 | /Ejercicios/*.docx 4 | upload.sh 5 | /Soluciones-2021-2022 6 | UD03.pdf 7 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/.gitignore: -------------------------------------------------------------------------------- 1 | .gradle 2 | build/ 3 | !gradle/wrapper/gradle-wrapper.jar 4 | !**/src/main/**/build/ 5 | !**/src/test/**/build/ 6 | 7 | ### IntelliJ IDEA ### 8 | .idea/modules.xml 9 | .idea/jarRepositories.xml 10 | .idea/compiler.xml 11 | .idea/libraries/ 12 | *.iws 13 | *.iml 14 | *.ipr 15 | out/ 16 | !**/src/main/**/out/ 17 | !**/src/test/**/out/ 18 | 19 | ### Eclipse ### 20 | .apt_generated 21 | .classpath 22 | .factorypath 23 | .project 24 | .settings 25 | .springBeans 26 | .sts4-cache 27 | bin/ 28 | !**/src/main/**/bin/ 29 | !**/src/test/**/bin/ 30 | 31 | ### NetBeans ### 32 | /nbproject/private/ 33 | /nbbuild/ 34 | /dist/ 35 | /nbdist/ 36 | /.nb-gradle/ 37 | 38 | ### VS Code ### 39 | .vscode/ 40 | 41 | ### Mac OS ### 42 | .DS_Store 43 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Editor-based HTTP Client requests 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/.idea/dictionaries/joseluisgs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/.idea/uiDesigner.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/cadenas/01-Definicion.kt: -------------------------------------------------------------------------------- 1 | package cadenas 2 | 3 | fun main() { 4 | // Un string es inmutable 5 | val cadena = "Hola" 6 | println(cadena) 7 | println(cadena[0]) 8 | println(cadena[1]) 9 | // cadena[2] = "O" Es inmutable 10 | // cadena = "Adios" // No nos deja porque es val, constante 11 | 12 | var mensaje = "Hola" 13 | println(mensaje) 14 | // OJO; que en el fondo ha cambiado la referencia 15 | mensaje = "Adios" 16 | mensaje = "$mensaje mundo" 17 | mensaje += "!!" 18 | println(mensaje) 19 | 20 | // Se crean 1000 objetos String cambiando la refrencia 21 | for (i in (1..1000)) { 22 | mensaje += "!!" 23 | } 24 | println(mensaje) 25 | 26 | // Se crea un solo objeto String cambiando la referencia 27 | // Es mutable!!! 28 | val mensajeBuilder = StringBuilder() 29 | println(mensajeBuilder) 30 | mensajeBuilder.append("Hola") 31 | mensajeBuilder[0] = 'A' 32 | println(mensajeBuilder) 33 | for (i in (1..1000)) { 34 | mensajeBuilder.append("!!") 35 | } 36 | mensaje = mensajeBuilder.toString() 37 | println(mensaje) 38 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/cadenas/02-Recorridos.kt: -------------------------------------------------------------------------------- 1 | package cadenas 2 | 3 | fun main() { 4 | val cadena = "En un lugar de la Mancha de cuyo nombre no quiero acordarme" 5 | // También están indexados 6 | 7 | // Recorrido con for 8 | for (i in cadena.indices) { 9 | println(cadena[i]) 10 | } 11 | 12 | // Recorrido con for each 13 | for (i in cadena) { 14 | println(i) 15 | } 16 | 17 | // Recorrido con while 18 | var i = 0 19 | while (i < cadena.length) { 20 | println(cadena[i]) 21 | i++ 22 | } 23 | 24 | // for con until 25 | for (i in cadena.length - 1 downTo 0) { 26 | println(cadena[i]) 27 | } 28 | // for reverse y paso dos 29 | for (i in cadena.indices.reversed() step 2) { 30 | println(cadena[i]) 31 | } 32 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/cadenas/03-Metodos.kt: -------------------------------------------------------------------------------- 1 | package cadenas 2 | 3 | fun main() { 4 | var mensaje = "En un lugar de la Mancha de cuyo nombre no quiero acordarme" 5 | 6 | // Longitud 7 | println(mensaje.length) 8 | 9 | // imprimir el caracter de una posicion 10 | println(mensaje[4]) 11 | 12 | // pasar a mayúsculas 13 | println(mensaje.uppercase()) 14 | 15 | // pasar a minúsculas 16 | println(mensaje.lowercase()) 17 | 18 | // Contiene una subcadena 19 | println(mensaje.contains("lugar")) 20 | println(mensaje.contains("I love Kotlin")) 21 | 22 | // Pasar a array de caracteres 23 | val array = mensaje.toCharArray() 24 | array[0] = array[0].uppercaseChar() 25 | 26 | // De array de caracteres a string 27 | mensaje = array.concatToString() 28 | println(mensaje) 29 | 30 | // Obtener una subcadena entre indices 31 | println(mensaje.substring(3, 12)) 32 | 33 | // Obtener un array de cadenas, en base a un separador 34 | val palabras = mensaje.split(" ").toTypedArray() 35 | for (palabra in palabras) { 36 | println(palabra) 37 | } 38 | 39 | // Eliminar un caracter o subcadena 40 | println(mensaje.replace(" ", "")) 41 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/cadenas/04-ArgumentosEntrada.kt: -------------------------------------------------------------------------------- 1 | package cadenas 2 | 3 | // Argumentos de entrada 4 | fun main(args: Array) { 5 | // if (args.size == 0) { 6 | if (args.isEmpty()) { 7 | println("No hay argumentos de entrada") 8 | } else { 9 | println("Argumentos de entrada:") 10 | for (i in args.indices) { 11 | println("args[$i] = ${args[i]}") 12 | } 13 | } 14 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/cadenas/05-Ejemplos01.kt: -------------------------------------------------------------------------------- 1 | package cadenas 2 | 3 | fun main() { 4 | val mensaje = "En un lugar de la Mancha, de cuyo nombre no quiero acordarme..." 5 | 6 | // ¿Está acordarme? 7 | println(mensaje.contains("acordarme")) 8 | 9 | // Eliminar la coma , 10 | println(mensaje.replace(",", "")) 11 | 12 | // Poner la decima palabra en mayúsculas 13 | val palabras = mensaje.split(" ").toTypedArray() 14 | for (palabras in palabras) { 15 | println(palabras) 16 | } 17 | palabras[9] = palabras[9].uppercase() 18 | println(palabras[9]) 19 | 20 | val mensaje2 = palabras.joinToString(" ") 21 | println(mensaje2) 22 | 23 | // esto no se ve muy bien!!! 24 | val mensaje3 = palabras.contentToString() 25 | println(mensaje3) 26 | 27 | // No lo sabes o se te va de la cabeza!!! Hazlo tú!!!! 28 | val myBuilder = StringBuilder() 29 | for (palabra in palabras) { 30 | myBuilder.append(palabra) 31 | myBuilder.append(" ") 32 | } 33 | println(myBuilder.toString()) 34 | 35 | // Tomamos la última palabra 36 | // val ultimaPalabra = palabras[palabras.size - 1] 37 | var ultimaPalabra = palabras.last() 38 | // Las letras pares en mayúscula las impares en minúscula 39 | var ultimaPalabraMayusculaMinuscula = cambiarMayusculaMinuscula(ultimaPalabra) 40 | println(ultimaPalabraMayusculaMinuscula) 41 | // Lo juntamos 42 | palabras[palabras.size - 1] = ultimaPalabraMayusculaMinuscula 43 | val mensaje4 = palabras.joinToString(" ") 44 | println(mensaje4) 45 | 46 | // Todo con string builder 47 | val sb = StringBuilder(mensaje) 48 | // me quedo con la ultima 49 | ultimaPalabra = sb.substring(sb.lastIndexOf(" ") + 1) 50 | println(ultimaPalabra) 51 | // Cambio las letras pares en mayúscula las impares en minúscula 52 | ultimaPalabraMayusculaMinuscula = cambiarMayusculaMinuscula(ultimaPalabra) 53 | println(ultimaPalabraMayusculaMinuscula) 54 | // Lo juntamos 55 | // sb.replace(sb.lastIndexOf(" ") + 1, sb.length, ultimaPalabraMayusculaMinuscula) 56 | // val mensaje5 = sb.toString() 57 | val mensaje5 = sb.toString().replace(ultimaPalabra, ultimaPalabraMayusculaMinuscula) 58 | println(mensaje5) 59 | 60 | println(mensaje) 61 | val textoCifrado = cifrarCesar(mensaje, 90) 62 | println(textoCifrado) 63 | val textoDescifrado = cifrarCesar(textoCifrado, 90) 64 | println(textoDescifrado) 65 | } 66 | 67 | fun cifrarCesar(mensaje: String, desplazamiento: Int): String { 68 | val alafabeto = 69 | " " + 70 | "abcdefghijklmnñopqrstuvwxyz" + 71 | "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ1234567890" + 72 | ".,;:?¡!()[]{}@#\$%&/\\\"'çÇáéíóúÁÉÍÓÚ" + 73 | "àèìòùÀÈÌÒÙâêîôûÂÊÎÔÛäëïöüÄËÏÖÜãõÃÕ" 74 | 75 | val sb = StringBuilder() 76 | 77 | val desplazamiento = desplazamiento % alafabeto.length 78 | 79 | for (caracter in mensaje) { 80 | val posicion = alafabeto.indexOf(caracter) 81 | if (posicion == -1) { 82 | sb.append(caracter) 83 | } else { 84 | if (posicion + desplazamiento < 0) { 85 | sb.append(alafabeto[alafabeto.length + (posicion + desplazamiento)]) 86 | } else { 87 | sb.append(alafabeto[(posicion + desplazamiento) % alafabeto.length]) 88 | } 89 | } 90 | } 91 | return sb.toString() 92 | } 93 | 94 | fun cambiarMayusculaMinuscula(ultimaPalabra: String): String { 95 | // Opción a con Builder 96 | val myBuilder = StringBuilder() 97 | for (i in ultimaPalabra.indices) { 98 | if (i % 2 == 0) { 99 | myBuilder.append(ultimaPalabra[i].uppercase()) 100 | } else { 101 | myBuilder.append(ultimaPalabra[i].lowercase()) 102 | } 103 | } 104 | return myBuilder.toString() 105 | 106 | // La opción B es de nuevpo pasarlo a aun array de caracteres 107 | /*val array = ultimaPalabra.toCharArray() 108 | for (i in array.indices) { 109 | if (i % 2 == 0) { 110 | array[i] = array[i].uppercaseChar() 111 | } else { 112 | array[i] = array[i].lowercaseChar() 113 | } 114 | } 115 | return array.concatToString()*/ 116 | 117 | // opción C es solo con un string, se ve guay pero es ineficiente un objeto nuevo 118 | /*var resultado = "" 119 | for (i in ultimaPalabra.indices) { 120 | if (i % 2 == 0) { 121 | resultado += ultimaPalabra[i].uppercase() 122 | } else { 123 | resultado += ultimaPalabra[i].lowercase() 124 | } 125 | } 126 | return resultado*/ 127 | } 128 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/exp_regulares/ExpRegulares.kt: -------------------------------------------------------------------------------- 1 | package exp_regulares 2 | 3 | 4 | fun main() { 5 | println("Dime tu DNI: ") 6 | val dni = readln() 7 | 8 | val isDNI = isDNIValidoManual(dni.uppercase()) 9 | println("El DNI $dni es ${if (isDNI) "válido" else "inválido"}") 10 | when (isDNIValidoManualCodigoError(dni.uppercase())) { 11 | 0 -> println("El DNI $dni es válido") 12 | -1 -> println("El DNI $dni es inválido porque no tiene 9 caracteres") 13 | -2 -> println("El DNI $dni es inválido, no se ha introducido una letra válida") 14 | -3 -> println("El DNI $dni es inválido, no es la letra correcta") 15 | -4 -> println("El DNI $dni es inválido, no se ha introducido un número válido") 16 | } 17 | 18 | try { 19 | isDNIValidoExcepciones(dni.uppercase()) 20 | println("El DNI $dni válido") 21 | } catch (e: Exception) { 22 | println("El DNI $dni es inválido, ${e.message}") 23 | } 24 | 25 | try { 26 | isDNIValidoConExpRegular(dni.uppercase()) 27 | println("El DNI $dni válido") 28 | } catch (e: Exception) { 29 | println("El DNI $dni es inválido, ${e.message}") 30 | } 31 | 32 | try { 33 | isDNIValidoConExpRegular(dni.uppercase()) 34 | println("El DNI $dni válido") 35 | } catch (e: Exception) { 36 | println("El DNI $dni es inválido, ${e.message}") 37 | } 38 | } 39 | 40 | /** 41 | * Comprueba si un DNI es válido o no 42 | * @param dni DNI a comprobar 43 | * @return true si es válido, false si no lo es 44 | * 45 | * PROBLEMA: No ofrece información del tipo de error 46 | */ 47 | fun isDNIValidoManual(dni: String): Boolean { 48 | // Early return 49 | if (dni.length != 9) return false 50 | if (dni.last() !in 'A'..'Z') return false 51 | if (!checkLetraDNI(dni)) return false 52 | // Ver si el resto son números 53 | val numeros = dni.substring(0, dni.length - 1) 54 | for (c in numeros) { 55 | if (c !in '0'..'9') return false 56 | } 57 | return true 58 | } 59 | 60 | /** 61 | * Comprueba si la letra del DNI es correcta 62 | * @param dni DNI a comprobar 63 | * @return 0 si es correcta, -1..., -2..., -3..., -4... si no lo es 64 | */ 65 | fun isDNIValidoManualCodigoError(dni: String): Int { 66 | // Early return 67 | if (dni.length != 9) return -1 68 | if (dni.last() !in 'A'..'Z') return -2 69 | if (!checkLetraDNI(dni)) return -3 70 | // Ver si el resto son números 71 | val numeros = dni.substring(0, dni.length - 1) 72 | for (c in numeros) { 73 | if (c !in '0'..'9') return -4 74 | } 75 | return 0 76 | } 77 | 78 | fun isDNIValidoExcepciones(dni: String): Boolean { 79 | // Von excepciones con requiere y propias 80 | require(dni.length == 9) { "El DNI debe tener 9 caracteres" } 81 | require(dni.last() in 'A'..'Z') { "El DNI debe terminar en una letra entre A y Z" } 82 | require(checkLetraDNI(dni)) { "La letra del DNI no es correcta" } 83 | // Ver si el resto son números 84 | val numeros = dni.substring(0, dni.length - 1) 85 | for (c in numeros) { 86 | if (c !in '0'..'9') throw IllegalArgumentException("El DNI debe contener solo números") 87 | } 88 | return true 89 | } 90 | 91 | fun checkLetraDNI(dni: String): Boolean { 92 | val letras = "TRWAGMYFPDXBNJZSQVHLCKE" 93 | val numero = dni.substring(0, dni.length - 1).toInt() 94 | println("Número: $numero") 95 | val letra = dni.last() 96 | return letras[numero % 23] == letra 97 | } 98 | 99 | fun isDNIValidoConExpRegular(dni: String): Boolean { 100 | // Expresión regular 101 | val regex = Regex("[0-9]{8}[A-Z]") 102 | val regex2 = """\d{8}[A-Z]""".toRegex() 103 | if (!regex.matches(dni)) throw IllegalArgumentException("El DNI no tiene el formato correcto") 104 | if (!checkLetraDNI(dni)) throw IllegalArgumentException("La letra del DNI no es correcta") 105 | return true 106 | } 107 | 108 | fun isDNIValidoConExpRegularOpt(dni: String): Boolean { 109 | require(Regex("[0-9]{8}[A-Z]").matches(dni)) { "El DNI no tiene el formato correcto" } 110 | require(checkLetraDNI(dni)) { "La letra del DNI no es correcta" } 111 | return true 112 | } 113 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/exp_regulares/Split.kt: -------------------------------------------------------------------------------- 1 | package exp_regulares 2 | 3 | fun main() { 4 | val stringPalabras = " Hola, soy un string con varias palabras " 5 | println(stringPalabras) 6 | // Limpiamos los espacios en blanco al principio y al final 7 | val stringPalabrasSinBlancos = stringPalabras.trim() 8 | println(stringPalabrasSinBlancos) 9 | val palabrasArray = stringPalabrasSinBlancos 10 | .split(" ") 11 | .toTypedArray() 12 | 13 | // Sacar cuantas palabras tenemos 14 | println("El string tiene ${palabrasArray.size} palabras") 15 | // imprimir el array 16 | println(palabrasArray.contentToString()) 17 | 18 | val cadenaFromArray = palabrasArray.joinToString(" ") 19 | println(cadenaFromArray) 20 | 21 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/matrices/01-Definicion.kt: -------------------------------------------------------------------------------- 1 | package matrices 2 | 3 | fun main() { 4 | // Definimos una matriz en base a sus filas 5 | // Columnas 6 | // Es un array(filas) de arrays(columnas) 7 | 8 | // 3x3 con valores definidos 9 | val m1 = arrayOf( 10 | intArrayOf(1, 2, 3), 11 | intArrayOf(4, 5, 6), 12 | intArrayOf(7, 8, 9) 13 | ) 14 | 15 | // 3x3 con valores por defecto 16 | val m2 = Array(3) { IntArray(3) } 17 | val m21 = Array(3) { Array(3) { 0 } } 18 | 19 | // 3x3 de char 20 | val m3 = Array(3) { CharArray(3) } 21 | 22 | // 4x4 de boolean 23 | val m4 = Array(4) { BooleanArray(4) } 24 | 25 | // 5x7 string 26 | val m5 = Array(5) { Array(7) { "" } } 27 | 28 | // Para leer o escribir usamos dos indices 29 | println(m1[0][0]) 30 | m1[0][1] = 5 31 | println(m1[0][1]) 32 | 33 | 34 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/matrices/02-Recorrido.kt: -------------------------------------------------------------------------------- 1 | package matrices 2 | 3 | fun main() { 4 | val matrix = arrayOf( 5 | intArrayOf(1, 2, 3), 6 | intArrayOf(4, 5, 6), 7 | intArrayOf(7, 8, 9) 8 | ) 9 | 10 | // Recorremos con un while, la forma más incomoda 11 | var i = 0 // filas 12 | while (i < matrix.size) { 13 | var j = 0 // columnas 14 | while (j < matrix[i].size) { 15 | print("${matrix[i][j]} ") 16 | j++ 17 | } 18 | println() 19 | i++ 20 | } 21 | 22 | println() 23 | 24 | // con un for, la forma más cómoda 25 | for (i in matrix.indices) { 26 | for (j in matrix[i].indices) { 27 | print("${matrix[i][j]} ") 28 | } 29 | println() 30 | } 31 | 32 | println() 33 | 34 | // for each 35 | for (fila in matrix) { 36 | for (elemento in fila) { 37 | print("$elemento ") 38 | } 39 | println() 40 | } 41 | 42 | println() 43 | 44 | // for until 45 | for (i in 0 until matrix.size) { 46 | for (j in 0 until matrix[i].size) { 47 | print("${matrix[i][j]} ") 48 | } 49 | println() 50 | } 51 | 52 | println() 53 | 54 | // escribo las columnas a la inversa 55 | for (i in matrix.indices) { 56 | for (j in matrix[i].indices.reversed()) { 57 | print("${matrix[i][j]} ") 58 | } 59 | println() 60 | } 61 | 62 | println() 63 | 64 | // escribo las filas a la inversa 65 | for (i in matrix.indices.reversed()) { 66 | for (j in matrix[i].indices) { 67 | print("${matrix[i][j]} ") 68 | } 69 | println() 70 | } 71 | 72 | println() 73 | 74 | // Todo a la inversa 75 | for (i in matrix.indices.reversed()) { 76 | for (j in matrix[i].indices.reversed()) { 77 | print("${matrix[i][j]} ") 78 | } 79 | println() 80 | } 81 | 82 | println() 83 | 84 | 85 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/matrices/03-Ejemplos01.kt: -------------------------------------------------------------------------------- 1 | package matrices 2 | 3 | fun main() { 4 | val matrix = arrayOf( 5 | intArrayOf(1, 2, 3), 6 | intArrayOf(4, 5, 6), 7 | intArrayOf(7, 8, 9) 8 | ) 9 | 10 | printMatrix(matrix) 11 | 12 | val max = maximoMatrix(matrix) 13 | println("El maximo es $max") 14 | 15 | val min = minimoMatrix(matrix) 16 | println("El minimo es $min") 17 | 18 | val suma = sumaMatrix(matrix) 19 | println("La suma es $suma") 20 | 21 | val multiplicacion = multiplicacionMatrix(matrix) 22 | println("La multiplicacion es $multiplicacion") 23 | 24 | val media = mediaMatrix(matrix) 25 | println("La media es $media") 26 | 27 | batallaParesImparesMatrix(matrix) 28 | 29 | val matrix2 = clonarMatrix(matrix) 30 | println("Matrix original") 31 | printMatrix(matrix) 32 | println("Matrix clonada") 33 | printMatrix(matrix2) 34 | 35 | val iguales = igualdadMatrix(matrix, matrix2) 36 | println("Son iguales? $iguales") 37 | 38 | } 39 | 40 | fun sumaMatrix(matrix: Array): Any { 41 | var res = 0 42 | for (i in matrix.indices) { 43 | for (j in matrix[i].indices) { 44 | res += matrix[i][j] 45 | } 46 | } 47 | return res 48 | } 49 | 50 | fun igualdadMatrix(matrix: Array, matrix2: Array): Any { 51 | for (i in matrix.indices) { 52 | for (j in matrix[i].indices) { 53 | if (matrix[i][j] != matrix2[i][j]) { 54 | return false 55 | } 56 | } 57 | } 58 | return true 59 | } 60 | 61 | fun clonarMatrix(matrix: Array): Array { 62 | var res = Array(matrix.size) { IntArray(matrix[0].size) } 63 | // Recorremos y copiamos los valores 64 | for (i in matrix.indices) { 65 | for (j in matrix[i].indices) { 66 | res[i][j] = matrix[i][j] 67 | } 68 | } 69 | return res 70 | } 71 | 72 | 73 | fun batallaParesImparesMatrix(matrix: Array) { 74 | var sumaPar = 0 75 | var sumaImpar = 0 76 | for (i in matrix.indices) { 77 | for (j in matrix[i].indices) { 78 | if (matrix[i][j] % 2 == 0) { 79 | sumaPar += matrix[i][j] 80 | } else { 81 | sumaImpar += matrix[i][j] 82 | } 83 | } 84 | } 85 | when { 86 | sumaPar > sumaImpar -> println("Ganan los pares: $sumaPar vs $sumaImpar") 87 | sumaPar < sumaImpar -> println("Ganan los impares: $sumaImpar vs $sumaPar") 88 | else -> println("Empate: $sumaPar vs $sumaImpar") 89 | } 90 | } 91 | 92 | fun mediaMatrix(matrix: Array): Double { 93 | var sum = 0.0 94 | for (i in matrix.indices) { 95 | for (j in matrix[i].indices) { 96 | sum += matrix[i][j] 97 | } 98 | } 99 | return sum / (matrix.size * matrix[0].size) 100 | } 101 | 102 | fun multiplicacionMatrix(matrix: Array): Int { 103 | var res = 1 104 | for (i in matrix.indices) { 105 | for (j in matrix[i].indices) { 106 | res *= matrix[i][j] 107 | } 108 | } 109 | return res 110 | } 111 | 112 | fun minimoMatrix(matrix: Array): Int { 113 | var min = matrix[0][0] 114 | // con for each 115 | for (fila in matrix) { 116 | for (elemento in fila) { 117 | if (elemento < min) { 118 | min = elemento 119 | } 120 | } 121 | } 122 | return min 123 | } 124 | 125 | fun maximoMatrix(matrix: Array): Int { 126 | var max = matrix[0][0] 127 | for (i in matrix.indices) { 128 | for (j in matrix[i].indices) { 129 | if (matrix[i][j] > max) { 130 | max = matrix[i][j] 131 | } 132 | } 133 | } 134 | return max 135 | } 136 | 137 | fun printMatrix(matrix: Array) { 138 | for (i in matrix.indices) { 139 | for (j in matrix[i].indices) { 140 | print("${matrix[i][j]} ") 141 | } 142 | println() 143 | } 144 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/ordenacion/Algoritmos.kt: -------------------------------------------------------------------------------- 1 | package ordenacion 2 | 3 | /** 4 | * Método de ordenación de burbuja O(n²) 5 | */ 6 | fun bubbleSort(vector: IntArray) { 7 | for (i in 0 until vector.size - 1) { 8 | for (j in 0 until vector.size - 1 - i) { 9 | if (vector[j] > vector[j + 1]) { 10 | val aux = vector[j] 11 | vector[j] = vector[j + 1] 12 | vector[j + 1] = aux 13 | } 14 | } 15 | } 16 | } 17 | 18 | /** 19 | * Método de ordenación por selección O(n²) 20 | */ 21 | fun selectionSort(array: IntArray) { 22 | for (i in 0 until array.size - 1) { 23 | var min = i 24 | for (j in i + 1 until array.size) { 25 | if (array[j] < array[min]) { 26 | min = j 27 | } 28 | } 29 | val aux = array[i] 30 | array[i] = array[min] 31 | array[min] = aux 32 | } 33 | } 34 | 35 | /** 36 | * Método de ordenación por inserción O(n²) 37 | */ 38 | fun insertionSort(array: IntArray) { 39 | for (i in 1 until array.size) { 40 | var j = i 41 | while (j > 0 && array[j] < array[j - 1]) { 42 | val aux = array[j] 43 | array[j] = array[j - 1] 44 | array[j - 1] = aux 45 | j-- 46 | } 47 | } 48 | } 49 | 50 | fun shellSort(array: IntArray) { 51 | var h = 1 52 | while (h < array.size / 3) { 53 | h = 3 * h + 1 54 | } 55 | while (h >= 1) { 56 | for (i in h until array.size) { 57 | var j = i 58 | while (j >= h && array[j] < array[j - h]) { 59 | val aux = array[j] 60 | array[j] = array[j - h] 61 | array[j - h] = aux 62 | j -= h 63 | } 64 | } 65 | h /= 3 66 | } 67 | } 68 | 69 | fun pivot(array: IntArray, left: Int, right: Int): Int { 70 | var i = left 71 | var j = right 72 | var pivot = array[left] 73 | while (i < j) { 74 | while (array[i] <= pivot && i < j) { 75 | i++ 76 | } 77 | while (array[j] > pivot) { 78 | j-- 79 | } 80 | if (i < j) { 81 | val aux = array[i] 82 | array[i] = array[j] 83 | array[j] = aux 84 | } 85 | } 86 | array[left] = array[j] 87 | array[j] = pivot 88 | return j 89 | } 90 | 91 | fun quicksort(array: IntArray, left: Int, right: Int) { 92 | val piv: Int 93 | if (left < right) { 94 | piv = pivot(array, left, right) 95 | quicksort(array, left, piv - 1) 96 | quicksort(array, piv + 1, right) 97 | } 98 | } 99 | 100 | /** 101 | * Método de ordenación QuickSort 102 | */ 103 | fun quickSort(array: IntArray) { 104 | quicksort(array, 0, array.size - 1) 105 | } 106 | 107 | /** 108 | * Método de búsqueda lineal o secuencial 109 | */ 110 | fun linearSearch(array: IntArray, value: Int): Int { 111 | for (i in array.indices) { 112 | if (array[i] == value) { 113 | return i 114 | } 115 | } 116 | return -1 117 | } 118 | 119 | /** 120 | * Método de búsqueda binaria recursiva 121 | */ 122 | 123 | fun binarySearch(array: IntArray, value: Int, left: Int, right: Int): Int { 124 | if (left > right) { 125 | return -1 126 | } 127 | val middle = (left + right) / 2 128 | return when { 129 | array[middle] == value -> middle 130 | array[middle] > value -> binarySearch(array, value, left, middle - 1) 131 | else -> binarySearch(array, value, middle + 1, right) 132 | } 133 | } 134 | 135 | fun binarySearch(array: IntArray, value: Int): Int { 136 | return binarySearch(array, value, 0, array.size - 1) 137 | } 138 | 139 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/ordenacion/Pruebas.kt: -------------------------------------------------------------------------------- 1 | package ordenacion 2 | 3 | fun main() { 4 | val vectorInicial = IntArray(50_000) { (0..1000000000).random() } 5 | 6 | var timeIni = 0L 7 | var timeFin = 0L 8 | 9 | // Probamos burbuja 10 | val vectorBurbuja = vectorInicial.clone() 11 | timeIni = System.currentTimeMillis() 12 | bubbleSort(vectorBurbuja) 13 | timeFin = System.currentTimeMillis() 14 | println("Tiempo burbuja: ${timeFin - timeIni} ms") 15 | // println("Contenido vector burbuja: ${vectorBurbuja.contentToString()}") 16 | // println("¿Está ordenado? ${vectorBurbuja.contentEquals(vectorInicial.sortedArray())}") 17 | 18 | // Probamos selección 19 | val vectorSeleccion = vectorInicial.clone() 20 | timeIni = System.currentTimeMillis() 21 | selectionSort(vectorSeleccion) 22 | timeFin = System.currentTimeMillis() 23 | println("Tiempo selección: ${timeFin - timeIni} ms") 24 | // println("Contenido vector selección: ${vectorSeleccion.contentToString()}") 25 | // println("¿Está ordenado? ${vectorSeleccion.contentEquals(vectorInicial.sortedArray())}") 26 | 27 | // Probamos inserción 28 | val vectorInsercion = vectorInicial.clone() 29 | timeIni = System.currentTimeMillis() 30 | insertionSort(vectorInsercion) 31 | timeFin = System.currentTimeMillis() 32 | println("Tiempo inserción: ${timeFin - timeIni} ms") 33 | // println("Contenido vector inserción: ${vectorInsercion.contentToString()}") 34 | //println("¿Está ordenado? ${vectorInsercion.contentEquals(vectorInicial.sortedArray())}") 35 | 36 | // Probamos shell 37 | val vectorShell = vectorInicial.clone() 38 | timeIni = System.currentTimeMillis() 39 | shellSort(vectorShell) 40 | timeFin = System.currentTimeMillis() 41 | println("Tiempo shell: ${timeFin - timeIni} ms") 42 | // println("Contenido vector shell: ${vectorShell.contentToString()}") 43 | // println("¿Está ordenado? ${vectorShell.contentEquals(vectorInicial.sortedArray())}") 44 | 45 | // Probamos quicksort 46 | val vectorQuick = vectorInicial.clone() 47 | timeIni = System.currentTimeMillis() 48 | quickSort(vectorQuick) 49 | timeFin = System.currentTimeMillis() 50 | println("Tiempo quick: ${timeFin - timeIni} ms") 51 | // println("Contenido vector quicksort: ${vectorQuick.contentToString()}") 52 | //println("¿Está ordenado? ${vectorQuick.contentEquals(vectorInicial.sortedArray())}") 53 | 54 | // Contra el método de ordenación de Kotlin: Doble Pivot QuickSort 55 | val vectorKotlin = vectorInicial.clone() 56 | timeIni = System.currentTimeMillis() 57 | vectorKotlin.sortedArray() 58 | timeFin = System.currentTimeMillis() 59 | println("Tiempo kotlin: ${timeFin - timeIni} ms") 60 | 61 | val elementoParaBuscar = vectorInicial.random() 62 | 63 | timeIni = System.nanoTime() 64 | linearSearch(vectorInicial, elementoParaBuscar) 65 | timeFin = System.nanoTime() 66 | println("Tiempo búsqueda lineal: ${timeFin - timeIni} ns") 67 | 68 | // Busqueda binaria 69 | val vectorOrdenado = vectorInicial.sortedArray() 70 | timeIni = System.nanoTime() 71 | binarySearch(vectorOrdenado, elementoParaBuscar) 72 | timeFin = System.nanoTime() 73 | println("Tiempo búsqueda binaria: ${timeFin - timeIni} ns") 74 | 75 | // Búsqueda de Kotlin 76 | timeIni = System.nanoTime() 77 | vectorOrdenado.binarySearch(elementoParaBuscar) 78 | timeFin = System.nanoTime() 79 | println("Tiempo búsqueda binaria de Kotlin: ${timeFin - timeIni} ns") 80 | 81 | 82 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/otros/Menu.kt: -------------------------------------------------------------------------------- 1 | package otros 2 | 3 | import kotlin.system.exitProcess 4 | 5 | fun main() { 6 | do { 7 | val opcion = menuOpciones() 8 | println("Has elegido la opción $opcion") 9 | procesarOpcionMenu(opcion) 10 | } while (opcion != 0) 11 | } 12 | 13 | fun procesarOpcionMenu(opcion: Int) { 14 | when (opcion) { 15 | 1 -> println("Acción opción 1") 16 | 2 -> println("Acción opción 2") 17 | 3 -> println("Acción opción 3") 18 | 4 -> { 19 | println("Adíos... \uD83D\uDC4B") 20 | exitProcess(0) 21 | } // Salimos 22 | } 23 | } 24 | 25 | fun menuOpciones(): Int { 26 | do { 27 | // Presentamos la opción 28 | println("[1] Opción 1") 29 | println("[2] Opción 2") 30 | println("[3] Opción 3") 31 | println("[4] Salir") 32 | 33 | // Leer opción 34 | val opcion = readln().toIntOrNull() ?: 0 35 | // Early return 36 | if (opcion in 1..4) { 37 | return opcion 38 | } 39 | println("Opción incorrecta. Pulse una opción entre 1 y 4") 40 | } while (true) 41 | } 42 | 43 | -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/vectores/01-Definicion.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | println("Mis Arrays") 3 | 4 | // Definiciones de arrays 5 | val intArray = intArrayOf(1, 2, 3, 4, 5) // array inicializado 6 | val intArrayDeUnElemento = intArrayOf(5) // array de 1 elemento 7 | val intArray2: Array = arrayOf(1, 2, 3, 4, 5) // array inicializado 8 | val intArrayDeUnElemento2: Array = arrayOf(5) // array de un elemento 9 | val intArray3 = IntArray(5) { 6 } // array de 5 elementos con valor 6 10 | val intArray4 = IntArray(5) { 0 } // array de 5 elementos con valores 0 11 | val intArray5 = IntArray(5) // array de 5 elementos con valores por defecto 12 | val intArray6 = Array(5) { 0 } // array de 5 elementos con valores 0 13 | 14 | println(intArray6.joinToString()) 15 | println(intArray6.size) 16 | println(intArray6[0]) 17 | println(intArray6[1]) 18 | intArray6[1] = 5 19 | println(intArray6.joinToString()) 20 | 21 | // Doubles 22 | val doubleArray = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0) // array inicializado 23 | val doubleArrayDeUnElemento = doubleArrayOf(5.0) // array de 1 elementos 24 | val doubleArray2: Array = arrayOf(1.0, 2.0, 3.0, 4.0, 5.0) // array inicializado 25 | val doubleArrayDeUnElemento2: Array = arrayOf(5.0) 26 | val doubleArray3 = DoubleArray(5) { 6.0 } // array de 5 elementos con valor 6 27 | val doubleArray4 = DoubleArray(5) { 0.0 } // array de 5 elementos con valores 0 28 | val doubleArray5 = DoubleArray(5) // array de 5 elementos con valores 29 | val doubleArray6 = Array(5) { 0.0 } // array de 5 elementos con valores 0 30 | 31 | println(doubleArray6.joinToString()) 32 | println(doubleArray6.size) 33 | println(doubleArray6[0]) 34 | println(doubleArray6[1]) 35 | doubleArray6[1] = 5.0 36 | println(doubleArray6.joinToString()) 37 | 38 | // Strings 39 | val stringArray = arrayOf("uno", "dos", "tres", "cuatro", "cinco") // array inicializado 40 | val stringArray2 = Array(5) { "0" } // array de 5 elementos con valores 0 41 | val stringArray3 = Array(5) { "" } // array de 5 elementos con valores "" 42 | val stringArray4 = Array(5) { "0" } // array de 5 elementos con valores "0" 43 | 44 | println(stringArray4.joinToString()) 45 | println(stringArray4.size) 46 | println(stringArray4[0]) 47 | println(stringArray4[1]) 48 | stringArray4[1] = "dos" 49 | println(stringArray4.joinToString()) 50 | 51 | // Booleans 52 | val booleanArray = booleanArrayOf(true, false, true, false, true) // array inicializado 53 | val booleanArray2 = Array(5) { false } // array de 5 elementos con valores false 54 | val booleanArray3 = Array(5) { true } // array de 5 elementos con valores true 55 | 56 | println(booleanArray3.joinToString()) 57 | println(booleanArray3.size) 58 | println(booleanArray3[0]) 59 | println(booleanArray3[1]) 60 | booleanArray3[1] = false 61 | println(booleanArray3.joinToString()) 62 | 63 | // println(booleanArray3[99]) // IndexOutOfBoundsException 64 | //println(booleanArray3[-1]) // IndexOutOfBoundsException 65 | 66 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/vectores/02-Recorrido.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val arrayInts = intArrayOf(1, 2, 3, 4, 5) 3 | 4 | // Recorrer con un while 5 | var i = 0 6 | while (i < arrayInts.size) { 7 | println(arrayInts[i]) 8 | i++ 9 | } 10 | 11 | println() 12 | 13 | // Recorrer con un for 14 | for (i in (0..arrayInts.size - 1)) { 15 | println(arrayInts[i]) 16 | } 17 | 18 | println() 19 | /* 20 | Equivalente en JAVA o C# 21 | for (int i = 0; i < arrayInts.size; i++) { 22 | println(arrayInts[i]) 23 | }*/ 24 | for (i in (0 until arrayInts.size)) { 25 | println(arrayInts[i]) 26 | } 27 | println() 28 | 29 | // Recorrer con un for y un indice 30 | for (i in (arrayInts.indices)) { 31 | println("Indice: $i, valor: ${arrayInts[i]}") 32 | } 33 | 34 | println() 35 | 36 | // Recorrer con un for each 37 | /* 38 | Equivalente en JAVa o C# 39 | for (int i : arrayInts) { 40 | println(i) 41 | */ 42 | for (i in arrayInts) { 43 | println(i) 44 | } 45 | 46 | println() 47 | 48 | // Solo los indices pares 49 | for (i in (arrayInts.indices step 2)) { 50 | println("Indice: $i, valor: ${arrayInts[i]}") 51 | } 52 | // Más feo!! 53 | for (i in (0 until arrayInts.size) step 2) { 54 | println(arrayInts[i]) 55 | } 56 | 57 | println() 58 | 59 | // Recorrer hacia atras con un while 60 | i = arrayInts.size - 1 61 | while (i >= 0) { 62 | println(arrayInts[i]) 63 | i-- 64 | } 65 | 66 | // Recorrerlo hacia atrás, desde el final hasta el principio 67 | for (i in (arrayInts.size - 1 downTo 0)) { 68 | println(arrayInts[i]) 69 | } 70 | 71 | println() 72 | 73 | for (i in (arrayInts.size - 1 downTo 0) step 2) { 74 | println(arrayInts[i]) 75 | } 76 | 77 | println() 78 | 79 | for (i in arrayInts.indices.reversed()) { 80 | println("Indice: $i, valor: ${arrayInts[i]}") 81 | } 82 | 83 | println() 84 | 85 | // usar withIndex 86 | for (element in arrayInts.withIndex()) { 87 | println("Indice: ${element.index}, valor: ${element.value}") 88 | } 89 | 90 | // Desestructurando 91 | for ((index, value) in arrayInts.withIndex()) { 92 | println("Indice: $index, valor: $value") 93 | } 94 | 95 | } -------------------------------------------------------------------------------- /Ejemplos/01-Arrays/src/main/kotlin/vectores/03-Ejemplos01.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val vectorEnteros = intArrayOf(-4, 1, -6, 4, 7, 5, 9) 3 | 4 | val max = maximo(vectorEnteros) 5 | println("El maximo es $max") 6 | 7 | val min = minimo(vectorEnteros) 8 | println("El minimo es $min") 9 | 10 | val suma = suma(vectorEnteros) 11 | println("La suma es $suma") 12 | 13 | val multiplicacion = multiplicacion(vectorEnteros) 14 | println("La multiplicacion es $multiplicacion") 15 | 16 | val media = media(vectorEnteros) 17 | println("La media es $media") 18 | 19 | // imprimir(vectorEnteros) 20 | println(vectorEnteros.contentToString()) 21 | println(vectorEnteros.joinToString(", ")) 22 | 23 | // Imprimir ascedente 24 | println("Ascendente") 25 | imprimirAscendente(vectorEnteros) 26 | 27 | // Imprimir descendente 28 | println("Descendente") 29 | imprimirDescendente(vectorEnteros) 30 | 31 | // Batalla de pares contra impares 32 | when (batallaParesImpares(vectorEnteros)) { 33 | 0 -> println( 34 | "Empate: ${sumaElementosPosicionPares(vectorEnteros) - sumaElementosPosicionImpares(vectorEnteros)} Pares: ${ 35 | sumaElementosPosicionPares( 36 | vectorEnteros 37 | ) 38 | } Impares: ${sumaElementosPosicionImpares(vectorEnteros)}" 39 | ) 40 | 41 | 1 -> println( 42 | "Ganan los pares: Pares: ${sumaElementosPosicionPares(vectorEnteros)} vs Impares: ${ 43 | sumaElementosPosicionImpares( 44 | vectorEnteros 45 | ) 46 | }" 47 | ) 48 | 49 | -1 -> println( 50 | "Ganan los impares: Impares: ${sumaElementosPosicionImpares(vectorEnteros)} vs Pares: ${ 51 | sumaElementosPosicionPares( 52 | vectorEnteros 53 | ) 54 | }" 55 | ) 56 | } 57 | 58 | // importante los arrays van por referencia, por eso es fundamental 59 | // usar var y val -- Pues no!! siempre pasan por referencia!!!! 60 | val vectorInmutable = intArrayOf(1, 2, 3, 4, 5) 61 | var vectorMutable = intArrayOf(1, 2, 3, 4, 5) 62 | println("Vector inmutable: ${vectorInmutable.contentToString()}") 63 | println("Vector mutable: ${vectorMutable.contentToString()}") 64 | sumaMasUno(vectorInmutable) 65 | sumaMasUno(vectorMutable) 66 | println("Vector inmutable: ${vectorInmutable.contentToString()}") 67 | println("Vector mutable: ${vectorMutable.contentToString()}") 68 | 69 | // No se copina vectores igualando, se igualan las referencias!!! 70 | val vectorInmutable2 = vectorInmutable // Son la misma referencia con distinto nombre 71 | vectorInmutable2[0] = 100 72 | println("Vector inmutable: ${vectorInmutable.contentToString()}") 73 | 74 | // Copiar clonar vectores 75 | val vectorInmutable3 = clone(vectorInmutable) 76 | vectorInmutable3[0] = 200 77 | println("Vector inmutable: ${vectorInmutable.contentToString()}") 78 | println("Vector inmutable3: ${vectorInmutable3.contentToString()}") 79 | 80 | // Igualdad vs Identidad 81 | // dos elementos son iguales si tienen el mismo contenido 82 | // dos elementos son identicos si son la misma referencia 83 | // Identidad 84 | if (vectorInmutable === vectorInmutable2) { 85 | println("Son la misma referencia") 86 | } else { 87 | println("No son la misma referencia") 88 | } 89 | val vectorInmutable4 = clone(vectorInmutable) 90 | // iguales 91 | if (igualdad(vectorInmutable, vectorInmutable4)) { 92 | println("Son iguales") 93 | } else { 94 | println("No son iguales") 95 | } 96 | 97 | 98 | } 99 | 100 | /** 101 | * Compara dos vectores y devuelve true si son iguales en contenido 102 | * @param origen Vector de origen 103 | * @param destino Vector de destino 104 | * @return true si son iguales, false en caso contrario 105 | */ 106 | fun igualdad(origen: IntArray, destino: IntArray): Boolean { 107 | if (origen.size != destino.size) { 108 | return false 109 | } 110 | for (i in origen.indices) { 111 | if (origen[i] != destino[i]) { 112 | return false 113 | } 114 | } 115 | return true 116 | } 117 | 118 | /** 119 | * Clona un vector de enteros 120 | * @param vector Vector de enteros 121 | * @return Clon del vector 122 | */ 123 | fun clone(vector: IntArray): IntArray { 124 | val vectorClonado = IntArray(vector.size) 125 | for (i in vector.indices) { 126 | vectorClonado[i] = vector[i] 127 | } 128 | return vectorClonado 129 | 130 | } 131 | 132 | /** 133 | * Suma 1 a todos los elementos del vector 134 | * @param vector Vector de enteros 135 | */ 136 | fun sumaMasUno(vector: IntArray) { 137 | for (i in vector.indices) { 138 | vector[i]++ 139 | } 140 | } 141 | 142 | 143 | /** 144 | * Devuleve la suma de elementos de un vector de enteros 145 | * de las posiciones pares 146 | * @param vectorEnteros Vector de enteros 147 | * @return Suma de los elementos de las posiciones pares 148 | */ 149 | fun sumaElementosPosicionPares(vectorEnteros: IntArray): Int { 150 | var suma = 0 151 | for (i in vectorEnteros.indices) { 152 | if (i % 2 == 0) { 153 | suma += vectorEnteros[i] 154 | } 155 | } 156 | return suma 157 | } 158 | 159 | /** 160 | * Devuelve el resultado de la resta entre números en posición par 161 | * menos los números en posición impar 162 | * @param vectorEnteros Vector de enteros 163 | * @return Resultado de la resta: positivo si gana los pares, negativo si gana los impares o 0 si empatan 164 | */ 165 | fun batallaParesImpares(vectorEnteros: IntArray): Int { 166 | val sumaPar = sumaElementosPosicionPares(vectorEnteros) 167 | val sumaImpar = sumaElementosPosicionImpares(vectorEnteros) 168 | return when { 169 | sumaPar > sumaImpar -> { 170 | 1 171 | } 172 | 173 | sumaPar < sumaImpar -> { 174 | -1 175 | } 176 | 177 | else -> { 178 | 0 179 | } 180 | } 181 | } 182 | 183 | /** 184 | * Devuleve la suma de elementos de un vector de enteros 185 | * de las posiciones impares 186 | * @param vectorEnteros Vector de enteros 187 | * @return Suma de los elementos de las posiciones impares 188 | */ 189 | fun sumaElementosPosicionImpares(vectorEnteros: IntArray): Int { 190 | var suma = 0 191 | for (i in vectorEnteros.indices) { 192 | if (i % 2 != 0) { 193 | suma += vectorEnteros[i] 194 | } 195 | } 196 | return suma 197 | } 198 | 199 | /** 200 | * Imprime el vector en orden ascendente 201 | * @param vectorEnteros 202 | */ 203 | fun imprimirDescendente(vectorEnteros: IntArray) { 204 | for (i in vectorEnteros.indices.reversed()) { 205 | println(vectorEnteros[i]) 206 | } 207 | } 208 | 209 | /** 210 | * Imprime el vector en orden ascendente 211 | * @param vectorEnteros 212 | */ 213 | fun imprimirAscendente(vectorEnteros: IntArray) { 214 | for (i in vectorEnteros.indices) { 215 | println(vectorEnteros[i]) 216 | } 217 | } 218 | 219 | /** 220 | * Devuelve la media de los elementos de un vector 221 | * @param vectorEnteros Vector de enteros 222 | * @return media de los elementos del vector 223 | */ 224 | fun media(vectorEnteros: IntArray): Double { 225 | var suma = 0.0 226 | for (i in vectorEnteros) { 227 | suma += i 228 | } 229 | return suma / vectorEnteros.size 230 | } 231 | 232 | /** 233 | * Devuelve la multiplicación de todos los elementos del vector 234 | * @param vectorEnteros Vector de enteros 235 | * @return multiplicación de todos los elementos del vector 236 | */ 237 | fun multiplicacion(vectorEnteros: IntArray): Int { 238 | var resultado = 1 239 | for (i in vectorEnteros.indices) { 240 | resultado *= vectorEnteros[i] 241 | } 242 | return resultado 243 | } 244 | 245 | /** 246 | * Devuelve la suma de los elementos de un vector 247 | * @param vectorEnteros Vector de enteros 248 | * @return suma de los elementos del vector 249 | */ 250 | fun suma(vectorEnteros: IntArray): Int { 251 | var suma = 0 252 | for (i in vectorEnteros.indices) { 253 | suma += vectorEnteros[i] 254 | } 255 | return suma 256 | } 257 | 258 | /** 259 | * Devuelve el maximo de un vector de enteros 260 | * @param vectorEnteros Vector de enteros 261 | * @return El mínimo de los elementos del vector 262 | */ 263 | fun minimo(vectorEnteros: IntArray): Int { 264 | var min = vectorEnteros[0] 265 | for (i in vectorEnteros.indices) { 266 | if (vectorEnteros[i] < min) { 267 | min = vectorEnteros[i] 268 | } 269 | } 270 | return min 271 | } 272 | 273 | /** 274 | * Devuelve el máximo de un vector de enteros 275 | * @param vectorEnteros Vector de enteros 276 | * @return El máximo del vector 277 | */ 278 | fun maximo(vectorEnteros: IntArray): Int { 279 | var max = vectorEnteros[0] 280 | /*for (i in vectorEnteros.indices) { 281 | if (vectorEnteros[i] > max) { 282 | max = vectorEnteros[i] 283 | } 284 | }*/ 285 | // for each 286 | for (elemento in vectorEnteros) { 287 | if (elemento > max) { 288 | max = elemento 289 | } 290 | } 291 | return max 292 | } 293 | -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/.gitignore: -------------------------------------------------------------------------------- 1 | .gradle 2 | build/ 3 | !gradle/wrapper/gradle-wrapper.jar 4 | !**/src/main/**/build/ 5 | !**/src/test/**/build/ 6 | 7 | ### IntelliJ IDEA ### 8 | .idea/modules.xml 9 | .idea/jarRepositories.xml 10 | .idea/compiler.xml 11 | .idea/libraries/ 12 | *.iws 13 | *.iml 14 | *.ipr 15 | out/ 16 | !**/src/main/**/out/ 17 | !**/src/test/**/out/ 18 | 19 | ### Eclipse ### 20 | .apt_generated 21 | .classpath 22 | .factorypath 23 | .project 24 | .settings 25 | .springBeans 26 | .sts4-cache 27 | bin/ 28 | !**/src/main/**/bin/ 29 | !**/src/test/**/bin/ 30 | 31 | ### NetBeans ### 32 | /nbproject/private/ 33 | /nbbuild/ 34 | /dist/ 35 | /nbdist/ 36 | /.nb-gradle/ 37 | 38 | ### VS Code ### 39 | .vscode/ 40 | 41 | ### Mac OS ### 42 | .DS_Store 43 | -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Editor-based HTTP Client requests 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | PruebaMaven 8 | es.joseluisgs 9 | 1.0-SNAPSHOT 10 | jar 11 | 12 | consoleApp 13 | 14 | 15 | UTF-8 16 | official 17 | 1.8 18 | 19 | 20 | 21 | 22 | mavenCentral 23 | https://repo1.maven.org/maven2/ 24 | 25 | 26 | 27 | 28 | 29 | src/main/kotlin 30 | src/test/kotlin 31 | 32 | 33 | org.jetbrains.kotlin 34 | kotlin-maven-plugin 35 | 1.7.20 36 | 37 | 38 | compile 39 | compile 40 | 41 | compile 42 | 43 | 44 | 45 | test-compile 46 | test-compile 47 | 48 | test-compile 49 | 50 | 51 | 52 | 53 | 54 | maven-surefire-plugin 55 | 2.22.2 56 | 57 | 58 | maven-failsafe-plugin 59 | 2.22.2 60 | 61 | 62 | org.codehaus.mojo 63 | exec-maven-plugin 64 | 1.6.0 65 | 66 | MainKt 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | com.diogonunes 77 | JColor 78 | 5.5.1 79 | 80 | 81 | org.jetbrains.kotlin 82 | kotlin-test-junit5 83 | 1.7.20 84 | test 85 | 86 | 87 | org.junit.jupiter 88 | junit-jupiter-engine 89 | 5.8.2 90 | test 91 | 92 | 93 | org.jetbrains.kotlin 94 | kotlin-stdlib-jdk8 95 | 1.7.20 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/src/main/kotlin/Main.kt: -------------------------------------------------------------------------------- 1 | import colors.fBright 2 | import colors.fError 3 | import colors.fNormal 4 | import colors.fWarning 5 | import com.diogonunes.jcolor.Ansi.colorize 6 | import com.diogonunes.jcolor.Attribute.* 7 | 8 | fun main() { 9 | println(colorize("Hello World!", BOLD(), BRIGHT_YELLOW_TEXT(), GREEN_BACK())) 10 | 11 | println(colorize("Esto es un texto warning", fWarning)); 12 | 13 | println(colorize("Esto es un texto warning", fError)); 14 | 15 | println (fNormal.format("O usar las funciones de colores ") + fBright.format(" Y combinarlos")) 16 | 17 | } -------------------------------------------------------------------------------- /Ejemplos/02-PruebaMaven/src/main/kotlin/colors/MyColors.kt: -------------------------------------------------------------------------------- 1 | package colors 2 | 3 | import com.diogonunes.jcolor.AnsiFormat 4 | import com.diogonunes.jcolor.Attribute.* 5 | 6 | 7 | var fInfo = AnsiFormat(CYAN_TEXT()) 8 | var fError = AnsiFormat(YELLOW_TEXT(), RED_BACK()) 9 | var fWarning = AnsiFormat(GREEN_TEXT(), BLUE_BACK(), BOLD()) 10 | var fNormal = AnsiFormat(MAGENTA_BACK(), YELLOW_TEXT()) 11 | var fBright = AnsiFormat(BRIGHT_MAGENTA_BACK(), BRIGHT_YELLOW_TEXT()) -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Editor-based HTTP Client requests 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/.idea/compiler.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/.idea/jarRepositories.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 9 | 10 | 14 | 15 | 19 | 20 | -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 7 | 8 | 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | es.joseluisgs 8 | InitJava 9 | 1.0-SNAPSHOT 10 | 11 | 12 | 17 13 | 17 14 | UTF-8 15 | 16 | 17 | 18 | 19 | org.junit.jupiter 20 | junit-jupiter-api 21 | 5.9.0 22 | test 23 | 24 | 25 | org.junit.jupiter 26 | junit-jupiter-engine 27 | 5.9.0 28 | test 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/src/main/java/es/joseluisgs/utils/Prueba.java: -------------------------------------------------------------------------------- 1 | package es.joseluisgs.utils; 2 | 3 | public class Prueba { 4 | public static int dividir(int a, int b) { 5 | if (b == 0) { 6 | throw new ArithmeticException("No se puede dividir por 0"); 7 | } 8 | return a / b; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Ejemplos/03-InitJava/src/test/java/Testing.java: -------------------------------------------------------------------------------- 1 | import org.junit.jupiter.api.BeforeAll; 2 | import org.junit.jupiter.api.BeforeEach; 3 | import org.junit.jupiter.api.Test; 4 | import org.junit.jupiter.api.TestInstance; 5 | 6 | import static es.joseluisgs.utils.Prueba.dividir; 7 | import static org.junit.jupiter.api.Assertions.*; 8 | 9 | @TestInstance(TestInstance.Lifecycle.PER_CLASS) 10 | public class Testing { 11 | 12 | 13 | @BeforeAll 14 | // cuidado con el static!!! 15 | static void initAll() { 16 | System.out.println("BeforeAll"); 17 | } 18 | 19 | @BeforeEach 20 | void setUpTest() { 21 | System.out.println("setUpTest"); 22 | } 23 | 24 | @Test 25 | public void trueIsTrue() { 26 | assertTrue(true); 27 | } 28 | 29 | @Test 30 | public void falseIsFalse() { 31 | assertEquals("Hola", "Hola"); 32 | } 33 | 34 | @Test 35 | public void assertAllTest() { 36 | assertAll( 37 | () -> assertEquals("Hola", "Hola"), 38 | () -> assertEquals("Adios", "Adios") 39 | ); 40 | } 41 | 42 | @Test 43 | public void testException() { 44 | Exception exception = assertThrows(ArithmeticException.class, () -> { 45 | dividir(5, 0); 46 | }); 47 | String expectedMessage = "No se puede dividir por 0"; 48 | String actualMessage = exception.getMessage(); 49 | assertEquals(expectedMessage, actualMessage); 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicios01.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-03-2022-2023/5421584d9a69c6314248f4ba2b05fac2a50b3866/Ejercicios/Ejercicios01.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios02.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-03-2022-2023/5421584d9a69c6314248f4ba2b05fac2a50b3866/Ejercicios/Ejercicios02.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios03.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-03-2022-2023/5421584d9a69c6314248f4ba2b05fac2a50b3866/Ejercicios/Ejercicios03.pdf -------------------------------------------------------------------------------- /Ejercicios/EjerciciosExamen.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-03-2022-2023/5421584d9a69c6314248f4ba2b05fac2a50b3866/Ejercicios/EjerciciosExamen.pdf -------------------------------------------------------------------------------- /Extras/checked-exception.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-03-2022-2023/5421584d9a69c6314248f4ba2b05fac2a50b3866/Extras/checked-exception.webp -------------------------------------------------------------------------------- /Extras/davechild_regular-expressions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-03-2022-2023/5421584d9a69c6314248f4ba2b05fac2a50b3866/Extras/davechild_regular-expressions.pdf -------------------------------------------------------------------------------- /Extras/error-exceptions.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-03-2022-2023/5421584d9a69c6314248f4ba2b05fac2a50b3866/Extras/error-exceptions.webp -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Editor-based HTTP Client requests 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/compiler.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/jarRepositories.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 9 | 10 | 14 | 15 | 19 | 20 | 24 | 25 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_apiguardian_apiguardian_api_1_1_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_jetbrains_annotations_13_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_jetbrains_kotlin_kotlin_stdlib_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_jetbrains_kotlin_kotlin_stdlib_common_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_jetbrains_kotlin_kotlin_stdlib_jdk7_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_jetbrains_kotlin_kotlin_stdlib_jdk8_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_jetbrains_kotlin_kotlin_test_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_jetbrains_kotlin_kotlin_test_junit5_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_junit_jupiter_junit_jupiter_api_5_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_junit_jupiter_junit_jupiter_engine_5_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_junit_platform_junit_platform_commons_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_junit_platform_junit_platform_engine_1_6_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/libraries/Maven__org_opentest4j_opentest4j_1_2_0.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 7 | 8 | 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/uiDesigner.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/consoleApp.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 14 | 17 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | consoleApp 8 | es.joseluisgs.dam 9 | 1.0-SNAPSHOT 10 | jar 11 | 12 | consoleApp 13 | 14 | 15 | UTF-8 16 | official 17 | 11 18 | 19 | 20 | 21 | 22 | mavenCentral 23 | https://repo1.maven.org/maven2/ 24 | 25 | 26 | 27 | 28 | src/main/kotlin 29 | src/test/kotlin 30 | 31 | 32 | org.jetbrains.kotlin 33 | kotlin-maven-plugin 34 | 1.6.0 35 | 36 | 37 | compile 38 | compile 39 | 40 | compile 41 | 42 | 43 | 44 | test-compile 45 | test-compile 46 | 47 | test-compile 48 | 49 | 50 | 51 | 52 | 53 | maven-surefire-plugin 54 | 2.22.2 55 | 56 | 57 | maven-failsafe-plugin 58 | 2.22.2 59 | 60 | 61 | org.codehaus.mojo 62 | exec-maven-plugin 63 | 1.6.0 64 | 65 | MainKt 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | org.jetbrains.kotlin 74 | kotlin-test-junit5 75 | 1.6.0 76 | test 77 | 78 | 79 | org.junit.jupiter 80 | junit-jupiter-engine 81 | 5.6.0 82 | test 83 | 84 | 85 | org.jetbrains.kotlin 86 | kotlin-stdlib-jdk8 87 | 1.6.0 88 | 89 | 90 | 91 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/src/main/kotlin/Binary/Binary.kt: -------------------------------------------------------------------------------- 1 | import kotlin.math.abs 2 | import kotlin.math.max 3 | import kotlin.math.pow 4 | 5 | // Mi librería de Datos para trabajar con Binarios 6 | 7 | /** 8 | * Lee un número binario desde la consola 9 | */ 10 | fun readBinary(): IntArray { 11 | var line: String 12 | // Leemos un número y solo debe tener 0s y 1s 13 | do { 14 | println("Intrdouzca el número binario: ") 15 | line = readLine().toString(); // Leemos de la consola y lo pasamos a String 16 | } while (!isBinary(line)) 17 | 18 | // Ahora los tranformamos a vector de enteros 19 | return toIntVector(line) 20 | } 21 | 22 | /** 23 | * Transforma una cadena de 1 y 0 en un vector de enteros de 1 y 0 24 | */ 25 | fun toIntVector(line: String): IntArray { 26 | val res = IntArray(line.length) // Con esto creamos en vector [] 27 | for (i in res.indices) { 28 | // cada caracter a string lo tengo que pasar a entero, la otra forma es Character.getNumericValue(number) 29 | res[i] = line[i].toString().toInt() 30 | } 31 | return res 32 | } 33 | 34 | /** 35 | * Comprueba si una cadena es un número binario, es decir solo tiene 1s y 0s 36 | */ 37 | fun isBinary(line: String): Boolean { 38 | var isBinary = true 39 | var i = 0 40 | while (i < line.length && isBinary) { 41 | isBinary = line[i] == '0' || line[i] == '1' 42 | i++ 43 | } 44 | return isBinary 45 | } 46 | 47 | /** 48 | * Imprime un vector binario 49 | */ 50 | fun printBinary(binary: IntArray) { 51 | for (i in binary) { 52 | print(i) 53 | } 54 | println() 55 | } 56 | 57 | /** 58 | * Trasforma un vector de binarios en un entero 59 | */ 60 | fun binaryToDecimal(num: IntArray): Int { 61 | var res = 0 62 | for (i in num.indices.reversed()) { 63 | res += (num[i] * 2.0.pow((num.size - i - 1))).toInt() 64 | } 65 | return res 66 | } 67 | 68 | /** 69 | * da la vuelta a un vector, no es necesario gracias a Kotlin 70 | */ 71 | fun reverse(num: IntArray): IntArray { 72 | val res = IntArray(num.size) 73 | // invertimos el vector 74 | for (i in num.indices) { 75 | res[i] = num[num.size - 1 - i] 76 | } 77 | return res 78 | } 79 | 80 | /** 81 | * Redimensiona in vector 82 | */ 83 | fun resize(num: IntArray, max: Int): IntArray { 84 | val res = IntArray(max) 85 | // lo coloco de atras adelante, los 0 que añado se quedan al comienzo 86 | var j = max - 1 87 | for (i in num.indices.reversed()) { 88 | res[j] = num[i] 89 | j-- 90 | } 91 | return res 92 | } 93 | 94 | /** 95 | * Suma dos vectores binarios 96 | */ 97 | fun add(num1: IntArray, num2: IntArray): IntArray { 98 | // Debemos tener el mismo tamaño 99 | var num1 = num1 100 | var num2 = num2 101 | val max = max(num1.size, num2.size) 102 | 103 | if (num1.size < num2.size) num1 = resize(num1, max) else num2 = resize(num2, max) 104 | 105 | // Ahora los sumamos, es uno mas para el acarreo el vector que tenemos 106 | val res = IntArray(max + 1) 107 | var carry = 0 108 | // Lo voy a hacer sin invertir 109 | var j = max 110 | for (i in num1.indices.reversed()) { 111 | // sumamos el carry y el elemento de la posición i 112 | val sum = num1[i] + num2[i] + carry 113 | // si la suma es mayor que 1, el carry es 1 114 | carry = if (sum > 1) 1 else 0 115 | // el resto es el resultado, porque el módulo es 1 o 2 116 | res[j] = sum % 2 117 | j-- 118 | } 119 | // si el carry es 1, lo metemos al final (o posición 0) 120 | if (carry == 1) { 121 | res[0] = 1 122 | } 123 | return res 124 | } 125 | 126 | /** 127 | * Resto dos vectores 128 | */ 129 | fun subtract(num1: IntArray, num2: IntArray): IntArray { 130 | // Debemos tener el mismo tamaño 131 | var num1 = num1 132 | var num2 = num2 133 | val max = max(num1.size, num2.size) 134 | // con el ternario 135 | //int max = num1.length > num2.length ? num1.length : num2.length; 136 | 137 | // Ahora los dos vectores deben tener el mismo tamaño 138 | if (num1.size < num2.size) num1 = resize(num1, max) else num2 = resize(num2, max) 139 | 140 | // Ahora los restamos, el tamaño siempre es el del mayor 141 | val res = IntArray(max) 142 | var carry = 0 143 | // Lo voy a hacer sin invertir 144 | var j = max - 1 145 | for (i in num1.indices.reversed()) { 146 | // restamos el carry y el elemento de la posición i 147 | val sum = num1[i] - num2[i] - carry 148 | // si la resta es menor que 0, el carry es 1 149 | carry = if (sum < 0) 1 else 0 150 | res[j] = abs(sum % 2) 151 | j-- 152 | } 153 | return res 154 | } 155 | -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/src/main/kotlin/Main.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Main de Binarios 3 | */ 4 | 5 | // Lo bueno que tiene Kotlin es que no necesitamos iniciar nada, solo una función llamada main 6 | fun main(args: Array) { 7 | println("Hola Kotlin DAM - Binarios") 8 | 9 | println("Trabajando con Binarios") 10 | 11 | // Leemos un número binario y lo transformamos en vector de enterios de 1 y 0 12 | val binary = readBinary(); 13 | printBinary(binary); 14 | 15 | // Pasamos a decimal 16 | val dec = binaryToDecimal(binary); 17 | println("Decimal: $dec"); 18 | 19 | val num1 = intArrayOf(1, 1, 1) // Es {1,1,1}; 20 | val num2 = intArrayOf(1, 0, 0, 0) // {1,0,0,0}; 21 | 22 | // Vamos a sumar 23 | 24 | // Vamos a sumar 25 | print("num1: ") 26 | printBinary(num1) 27 | print("num2: ") 28 | printBinary(num2) 29 | print("Suma: ") 30 | val sum = add(num1, num2) 31 | printBinary(sum) 32 | 33 | val sub = subtract(num2, num1) 34 | print("Resta: ") 35 | printBinary(sub) 36 | 37 | 38 | } -------------------------------------------------------------------------------- /Soluciones/Binarios-Kotlin/src/test/kotlin/BinaryTest.kt: -------------------------------------------------------------------------------- 1 | import org.junit.jupiter.api.* 2 | import org.junit.jupiter.api.Assertions.* 3 | import org.junit.jupiter.api.Assertions.assertAll 4 | 5 | 6 | @DisplayName("Test de Binarios") 7 | @TestMethodOrder(MethodOrderer.OrderAnnotation::class) 8 | @TestInstance(TestInstance.Lifecycle.PER_CLASS) // Para el Beforeall 9 | class BinaryTest { 10 | 11 | @BeforeAll 12 | fun setUp() { 13 | println("Before All") 14 | } 15 | @Test 16 | fun isBinaryTest() { 17 | // True siempre es igual a true :) 18 | val isBinary = "01011010" 19 | val notBinaryLetters = "aaaa" 20 | val notBinaryNumbers = "aaaa" 21 | assertAll( 22 | { assertTrue(isBinary(isBinary), "Caso Correcto") }, 23 | { assertFalse(isBinary(notBinaryNumbers), "Caso Falso con Numeros") }, 24 | { assertFalse(isBinary(notBinaryLetters), "Caso Falso con Letras") } 25 | ); 26 | } 27 | 28 | @Test 29 | fun toIntVectorTest() { 30 | val binary = "01011010" 31 | val vector = intArrayOf(0, 1, 0, 1, 1, 0, 1, 0) 32 | assertArrayEquals(vector, toIntVector(binary)) 33 | } 34 | 35 | @Test 36 | fun reverseTest() { 37 | val vector = intArrayOf(0, 1, 0, 1, 1, 0, 1, 1) 38 | val vectorReverse = intArrayOf(1, 1, 0, 1, 1, 0, 1, 0) 39 | assertArrayEquals(vectorReverse, reverse(vector)) 40 | } 41 | 42 | @Test 43 | fun binaryToDecimalTest() { 44 | val binary = intArrayOf(1, 0, 0) 45 | val decimal = 4 46 | assertEquals(decimal, binaryToDecimal(binary)) 47 | } 48 | 49 | @Test 50 | fun resizeTest() { 51 | val binary = intArrayOf(1, 1, 0) 52 | val max = 4 53 | val binaryResize = intArrayOf(0, 1, 1, 0) 54 | assertArrayEquals(binaryResize, resize(binary, max)) 55 | } 56 | 57 | @Test 58 | fun addTest() { 59 | val num1 = intArrayOf(1, 1, 1) 60 | val num2 = intArrayOf(1, 0, 0, 1) 61 | val res = intArrayOf(1, 0, 0, 0, 0) 62 | assertArrayEquals(res, add(num1, num2)) 63 | } 64 | 65 | @Test 66 | fun subtractTest() { 67 | val num1 = intArrayOf(1, 0, 0, 0) 68 | val num2 = intArrayOf(1, 1, 1) 69 | val res = intArrayOf(0, 0, 0, 1) 70 | assertArrayEquals(res, subtract(num1, num2)) 71 | } 72 | 73 | } -------------------------------------------------------------------------------- /Soluciones/Binarios/.gitignore: -------------------------------------------------------------------------------- 1 | # Project exclude paths 2 | /target/ 3 | src/main/resources/.env 4 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Datasource local storage ignored files 5 | /dataSources/ 6 | /dataSources.local.xml 7 | # Editor-based HTTP Client requests 8 | /httpRequests/ 9 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/compiler.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/discord.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 7 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/jarRepositories.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 9 | 10 | 14 | 15 | 19 | 20 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 10 | 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/runConfigurations.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 9 | 10 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/uiDesigner.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /Soluciones/Binarios/.idea/workspace-FoxMacPro.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 20 | 21 | 22 | 23 | 24 | 29 | 30 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 74 | 75 | 76 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 1636990834256 95 | 103 | 104 | 105 | 106 | 108 | 109 | 118 | 120 | 121 | 122 | 123 | -------------------------------------------------------------------------------- /Soluciones/Binarios/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | es.joseluisgs.dam 8 | Binarios 9 | 1.0-SNAPSHOT 10 | 11 | 12 | UTF-8 13 | 11 14 | 11 15 | 16 | 17 | 18 | 19 | org.junit.jupiter 20 | junit-jupiter 21 | 5.8.1 22 | test 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /Soluciones/Binarios/src/main/java/es/dam/joseluisgs/Binary.java: -------------------------------------------------------------------------------- 1 | package es.dam.joseluisgs; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Binary { 6 | public static void main(String[] args) { 7 | System.out.println("Números Binarios"); 8 | 9 | // Leemos un número binario y lo transformamos a vector de enteros 10 | // importante ver como una operación la he ido descomponiendo en pasos 11 | //int[] binary = readBinary(); 12 | //System.out.print("Binary: "); 13 | //printBinary(binary); 14 | 15 | // Pasamos a decimal 16 | //int dec = binaryToDecimal(binary); 17 | //System.out.println("Decimal: " + dec); 18 | 19 | // A partir de aquí voy a usar dos numeros para no meterlos siempre 20 | int[] num1 = {1,1,1}; 21 | int[] num2 = {1,0,0,0}; 22 | 23 | // Vamos a sumar 24 | System.out.print("num1: "); 25 | printBinary(num1); 26 | System.out.print("num2: "); 27 | printBinary(num2); 28 | System.out.print("Suma: "); 29 | int[] sum = add(num1, num2); 30 | printBinary(sum); 31 | 32 | int [] sub = subtract(num2, num1); 33 | System.out.print("Resta: "); 34 | printBinary(sub); 35 | 36 | } 37 | 38 | public static int[] add(int[] num1, int[] num2) { 39 | // Debemos tener el mismo tamaño 40 | int max = Math.max(num1.length, num2.length); 41 | // con el ternario 42 | //int max = num1.length > num2.length ? num1.length : num2.length; 43 | 44 | // Ahora los dos vectores deben tener el mismo tamaño 45 | if (num1.length < num2.length) 46 | num1 = resize(num1, max); 47 | else 48 | num2 = resize(num2, max); 49 | 50 | // printBinary(num1); 51 | // printBinary(num2); 52 | 53 | // Ahora los sumamos, es uno mas para el acarreo 54 | int[] res = new int[max+1]; 55 | int carry = 0; 56 | // Lo voy a hacer sin invertir 57 | int j = max; 58 | for (int i = num1.length -1; i>=0; i--) { 59 | // sumamos el carry y el elemento de la posición i 60 | int sum = num1[i] + num2[i] + carry; 61 | // si la suma es mayor que 1, el carry es 1 62 | carry = sum > 1 ? 1 : 0; 63 | // el resto es el resultado, porque el módulo es 1 o 2 64 | res[j] = sum % 2; 65 | j--; 66 | } 67 | // si el carry es 1, lo metemos al final (o posición 0) 68 | if(carry == 1) { 69 | res[0] = 1; 70 | } 71 | 72 | // printBinary(res); 73 | 74 | return res; 75 | 76 | } 77 | 78 | public static int[] subtract(int[] num1, int[] num2) { 79 | // Debemos tener el mismo tamaño 80 | int max = Math.max(num1.length, num2.length); 81 | // con el ternario 82 | //int max = num1.length > num2.length ? num1.length : num2.length; 83 | 84 | // Ahora los dos vectores deben tener el mismo tamaño 85 | if (num1.length < num2.length) 86 | num1 = resize(num1, max); 87 | else 88 | num2 = resize(num2, max); 89 | 90 | // printBinary(num1); 91 | // printBinary(num2); 92 | 93 | // Ahora los restamos, el tamaño siempre es el del mayor 94 | int[] res = new int[max]; 95 | int carry = 0; 96 | // Lo voy a hacer sin invertir 97 | int j = max-1; 98 | for (int i = num1.length -1; i>=0; i--) { 99 | // restamos el carry y el elemento de la posición i 100 | int sum = num1[i] - num2[i] - carry; 101 | // si la resta es menor que 0, el carry es 1 102 | carry = sum < 0 ? 1 : 0; 103 | res[j] = Math.abs(sum % 2); 104 | j--; 105 | } 106 | // printBinary(res); 107 | return res; 108 | 109 | } 110 | 111 | public static int[] resize(int[] num, int max) { 112 | int[] res = new int[max]; 113 | // lo coloco de atras adelante, los 0 que añado se quedan al comienzo 114 | int j = max - 1; 115 | for (int i = num.length -1 ; i >= 0; i--) { 116 | res[j] = num[i]; 117 | j--; 118 | } 119 | return res; 120 | } 121 | 122 | public static int binaryToDecimal(int[] num) { 123 | // Tal y como hemos visto en clase hay que hacerle un reverse 124 | // int[] numReverse = reverse(num); 125 | // int res = 0; 126 | // for (int i = 0; i < numReverse.length; i++) { 127 | // // cada elemento lo multiplicamos por 2 elevado a la potencia 128 | // // de su posición 129 | // res += numReverse[i] * Math.pow(2, i); 130 | // } 131 | // sin invertir 132 | int res = 0; 133 | for (int i = num.length -1; i>= 0; i--) { 134 | res += num[i]*Math.pow(2,num.length-i-1); 135 | } 136 | 137 | return res; 138 | } 139 | 140 | public static int[] reverse(int[] num) { 141 | int[] res = new int[num.length]; 142 | // invertimos el vector 143 | for (int i = 0; i < num.length; i++) { 144 | res[i] = num[num.length - 1 - i]; 145 | } 146 | return res; 147 | } 148 | 149 | public static int[] readBinary() { 150 | Scanner in = new Scanner(System.in); 151 | String line; 152 | // Leemos un número y solo debe tener 0s y 1s 153 | do { 154 | System.out.println("Intrdouzca el número binario: "); 155 | line = in.nextLine(); 156 | } while(!isBinary(line)); 157 | 158 | // Ahora los tranformamos a vector de enteros 159 | return toIntVector(line); 160 | } 161 | 162 | public static int[] toIntVector(String line) { 163 | int[] res = new int[line.length()]; 164 | for (int i = 0; i < res.length; i++) { 165 | // cada caracter lo tengo que pasar a entero 166 | res[i] = Character.getNumericValue(line.charAt(i)); 167 | } 168 | return res; 169 | } 170 | 171 | public static boolean isBinary(String line) { 172 | boolean isBinary = true; 173 | for (int i = 0; i < line.length() && isBinary; i++) { 174 | isBinary = line.charAt(i) == '0' || line.charAt(i) == '1'; 175 | } 176 | return isBinary; 177 | } 178 | 179 | public static void printBinary(int[] binary) { 180 | for (int i: binary) { 181 | System.out.print(i); 182 | } 183 | System.out.println(); 184 | } 185 | } 186 | -------------------------------------------------------------------------------- /Soluciones/Binarios/src/test/java/BinaryTest.java: -------------------------------------------------------------------------------- 1 | import es.dam.joseluisgs.Binary; 2 | import org.junit.jupiter.api.Assertions; 3 | import org.junit.jupiter.api.DisplayName; 4 | import org.junit.jupiter.api.Test; 5 | 6 | import static org.junit.jupiter.api.Assertions.*; 7 | 8 | @DisplayName("Test de Binarios") 9 | public class BinaryTest { 10 | 11 | @Test 12 | public void isBinaryTest() { 13 | // True siempre es igual a true :) 14 | String isBinary = "01011010"; 15 | String notBinaryLetters = "aaaa"; 16 | String notBinaryNumbers = "aaaa"; 17 | Assertions.assertAll( 18 | () -> assertTrue(Binary.isBinary(isBinary), "Caso Correcto"), 19 | () -> assertFalse(Binary.isBinary(notBinaryNumbers), "Caso Falso con Numeros"), 20 | () -> assertFalse(Binary.isBinary(notBinaryLetters), "Caso Falso con Letras") 21 | ); 22 | } 23 | 24 | @Test 25 | public void toIntVectorTest() { 26 | String binary = "01011010"; 27 | int[] vector = {0,1,0,1,1,0,1,0}; 28 | assertArrayEquals(vector, Binary.toIntVector(binary)); 29 | } 30 | 31 | @Test 32 | public void reverseTest() { 33 | int[] vector = {0,1,0,1,1,0,1,1}; 34 | int[] vectorReverse = {1,1,0,1,1,0,1,0}; 35 | assertArrayEquals(vectorReverse, Binary.reverse(vector)); 36 | } 37 | 38 | @Test 39 | public void binaryToDecimalTest() { 40 | int[] binary = {1,0,0}; 41 | int decimal = 4; 42 | assertEquals(decimal, Binary.binaryToDecimal(binary)); 43 | } 44 | 45 | @Test 46 | public void resizeTest() { 47 | int[] binary = {1,1,0}; 48 | int max = 4; 49 | int[] binaryResize = {0,1,1,0}; 50 | 51 | assertArrayEquals(binaryResize, Binary.resize(binary, max)); 52 | } 53 | 54 | @Test 55 | public void addTest() { 56 | int[] num1 = {1,1,1}; 57 | int[] num2 = {1,0,0,1}; 58 | int[] res = {1,0,0,0,0}; 59 | 60 | assertArrayEquals(res, Binary.add(num1, num2)); 61 | } 62 | 63 | @Test 64 | public void subtractTest() { 65 | int[] num1= {1,0,0,0}; 66 | int[] num2= {1,1,1}; 67 | int[] res = {0,0,0,1}; 68 | 69 | assertArrayEquals(res, Binary.subtract(num1, num2)); 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/.gitignore: -------------------------------------------------------------------------------- 1 | out/ 2 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Datasource local storage ignored files 5 | /dataSources/ 6 | /dataSources.local.xml 7 | # Editor-based HTTP Client requests 8 | /httpRequests/ 9 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/.idea/runConfigurations.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 9 | 10 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/MoscaVector.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /Soluciones/MoscaMatriz-java/src/mosca/Mosca.java: -------------------------------------------------------------------------------- 1 | package mosca; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Mosca { 6 | public static void main(String[] args){ 7 | System.out.println("La Mosca Vector"); 8 | int numCasillas = 10; 9 | final int MOSCA = 1; 10 | 11 | int numIntentos = 5; 12 | 13 | numIntentos = getNumIntentos(); 14 | 15 | 16 | // Pedir tamaño de Matriz 17 | numCasillas = pedirNumeroCasillas(); 18 | 19 | // Crear la matriz 20 | int[][] casillas = new int[numCasillas][numCasillas]; 21 | 22 | // Todas las casillas son 0 menos la de la mosca 23 | iniciarCasillas(casillas); 24 | 25 | // Situar la mosca en el vector 26 | situarMosca(casillas, MOSCA); 27 | imprimirCasillas(casillas); 28 | 29 | boolean estaMuerta = false; 30 | int[] posMosca = {0,0}; 31 | 32 | do { 33 | // Pedirle la posición donde vas a dar un tortazo 34 | posMosca = posicionGolpear(casillas); 35 | 36 | // Anlizamos el Golpeo 37 | estaMuerta = analizarGolpeo(MOSCA, casillas, estaMuerta, posMosca); 38 | numIntentos --; 39 | System.out.println("Te quedan " + numIntentos + " intentos"); 40 | } while(!estaMuerta && numIntentos>0); 41 | 42 | if (estaMuerta) 43 | System.out.println("¡Has cazado a la maldita mosca!"); 44 | else 45 | System.out.println("¡Has perdido!"); 46 | 47 | System.out.println("Estaba en: {" 48 | + (posMosca[0]+1) + ", " 49 | + (posMosca[1]+1) + 50 | "}"); 51 | imprimirCasillas(casillas); 52 | 53 | } 54 | 55 | private static int getNumIntentos() { 56 | Scanner sc = new Scanner(System.in); 57 | int intentos = 0; 58 | 59 | do { 60 | System.out.println("Introduce el número de intentos máximos, mayor a 1"); 61 | intentos = sc.nextInt() ; 62 | } while (intentos<1); 63 | 64 | return intentos; 65 | 66 | } 67 | 68 | private static boolean analizarGolpeo(int MOSCA, int[][] casillas, boolean estaMuerta, int[] posMosca) { 69 | // Logica del juego 70 | // Acertamos 71 | if(casillas[posMosca[0]][posMosca[1]] == MOSCA) { 72 | estaMuerta = true; 73 | 74 | // Analizamos los limites 75 | } 76 | // else { 77 | // // Eje X horizontal 78 | // boolean o = posMosca[0] != 0 && casillas[posMosca[0] -1][posMosca[1]]== MOSCA; 79 | // boolean e = posMosca[0] != casillas.length-1 && casillas[posMosca[0] +1][posMosca[1]]== MOSCA; 80 | // // Eje Y vertical 81 | // boolean n = posMosca[1] != 0 && casillas[posMosca[0]][posMosca[1]-1]== MOSCA; 82 | // boolean s = posMosca[1] != casillas.length-1 && casillas[posMosca[0]][posMosca[1]+1]== MOSCA; 83 | // 84 | // // Diagonal superior izquierda 85 | // boolean no = posMosca[0] != 0 && posMosca[1] != 0 && casillas[posMosca[0]-1][posMosca[1]-1]== MOSCA; 86 | // // Diagonal superior derecha 87 | // boolean ne = posMosca[0] != 0 && posMosca[1] != casillas.length-1 && casillas[posMosca[0]-1][posMosca[1]+1]== MOSCA; 88 | // // Diagnal inferior izquierda 89 | // boolean so = posMosca[0] != casillas.length-1 && posMosca[1] != 0 && casillas[posMosca[0]+1][posMosca[1]-1]== MOSCA; 90 | // // Diagnal inferior derecha 91 | // boolean se = posMosca[0] != casillas.length-1 && posMosca[1] != casillas.length-1 && casillas[posMosca[0]+1][posMosca[1]+1]== MOSCA; 92 | // 93 | // if(o || e || n || s || no || ne || so || se) { 94 | // // Revoloteamos 95 | // System.out.println("¡CASI!"); 96 | // iniciarCasillas(casillas); 97 | // situarMosca(casillas, MOSCA); 98 | // } 99 | // } 100 | 101 | for(int i=-1;i<=1;i++){ 102 | for(int j=-1;j<=1;j++){ 103 | if (posMosca[0] + i >=0 && posMosca[0] + i=0 && posMosca[0]+j= casillas.length); 129 | 130 | do { 131 | System.out.println("Introduce la posición de la Columna a atacar: "); 132 | posMosca[1] = sc.nextInt() -1; 133 | System.out.println("La posición Columna elegida es: " + (posMosca[1] +1)); 134 | } while (posMosca[1]<0 || posMosca[1]>= casillas.length); 135 | 136 | return (posMosca); 137 | } 138 | 139 | private static void situarMosca(int[][] casillas, int mosca) { 140 | 141 | int fila = getPosicion(casillas); 142 | int columna = getPosicion(casillas ); 143 | 144 | casillas[fila][columna] = mosca; 145 | } 146 | 147 | private static int getPosicion(int[][] casillas) { 148 | int fila; 149 | do { 150 | fila = (int) (Math.random() * casillas.length); 151 | //System.out.println(s + (fila + 1)); 152 | } while (fila < 0 || fila >= casillas.length); 153 | return fila; 154 | } 155 | 156 | private static void iniciarCasillas(int[][] casillas) { 157 | for (int i = 0; i < casillas.length; i++) { 158 | for (int j = 0; j < casillas[i].length; j++) { 159 | casillas[i][j] = 0; 160 | } 161 | } 162 | } 163 | 164 | /** 165 | * 166 | * @return 167 | */ 168 | private static int pedirNumeroCasillas() { 169 | Scanner sc = new Scanner(System.in); 170 | int numCasillas; 171 | do { 172 | System.out.println("Dime el número de casillas, siempre mayor a 5"); 173 | numCasillas = sc.nextInt(); 174 | System.out.println("Tamaño de vector es:" + numCasillas); 175 | } while (numCasillas<5); 176 | return numCasillas; 177 | } 178 | 179 | static void imprimirCasillas(int[][] casillas) { 180 | //System.out.print("{ "); 181 | for(int[] fila: casillas){ 182 | System.out.print("{ "); 183 | for(int columna: fila){ 184 | System.out.print(columna + " "); 185 | } 186 | System.out.println("} "); 187 | } 188 | //System.out.println("}"); 189 | } 190 | } 191 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/.gitignore: -------------------------------------------------------------------------------- 1 | .gradle 2 | build/ 3 | !gradle/wrapper/gradle-wrapper.jar 4 | !**/src/main/**/build/ 5 | !**/src/test/**/build/ 6 | 7 | ### IntelliJ IDEA ### 8 | .idea/modules.xml 9 | .idea/jarRepositories.xml 10 | .idea/compiler.xml 11 | .idea/libraries/ 12 | *.iws 13 | *.iml 14 | *.ipr 15 | out/ 16 | !**/src/main/**/out/ 17 | !**/src/test/**/out/ 18 | 19 | ### Eclipse ### 20 | .apt_generated 21 | .classpath 22 | .factorypath 23 | .project 24 | .settings 25 | .springBeans 26 | .sts4-cache 27 | bin/ 28 | !**/src/main/**/bin/ 29 | !**/src/test/**/bin/ 30 | 31 | ### NetBeans ### 32 | /nbproject/private/ 33 | /nbbuild/ 34 | /dist/ 35 | /nbdist/ 36 | /.nb-gradle/ 37 | 38 | ### VS Code ### 39 | .vscode/ 40 | 41 | ### Mac OS ### 42 | .DS_Store 43 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Editor-based HTTP Client requests 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/.idea/GrepConsole.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 23 | 24 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | 11 | 13 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/.idea/uiDesigner.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | groupId 8 | Soluciones-03 9 | 1.0-SNAPSHOT 10 | 11 | 12 | 17 13 | 17 14 | UTF-8 15 | 1.7.20 16 | 17 | 18 | 19 | 20 | 21 | 22 | com.diogonunes 23 | JColor 24 | 5.5.1 25 | 26 | 27 | org.jetbrains.kotlin 28 | kotlin-stdlib-jdk8 29 | ${kotlin.version} 30 | 31 | 32 | org.jetbrains.kotlin 33 | kotlin-test 34 | ${kotlin.version} 35 | test 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | org.jetbrains.kotlin 44 | kotlin-maven-plugin 45 | ${kotlin.version} 46 | 47 | 48 | compile 49 | compile 50 | 51 | compile 52 | 53 | 54 | 55 | src/main/kotlin 56 | src/main/java 57 | 58 | 59 | 60 | 61 | test-compile 62 | test-compile 63 | 64 | test-compile 65 | 66 | 67 | 68 | src/test/kotlin 69 | src/test/java 70 | 71 | 72 | 73 | 74 | 75 | ${maven.compiler.target} 76 | 77 | 78 | 79 | 80 | 81 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/arrays/Ahorcado.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | println("Juego del Ahorcado") 3 | 4 | val palabra = palabraAleatoriaDiccionario() 5 | // println("La palabra a adivinar es: $palabra") 6 | 7 | // val arrayLetras = palabra.toCharArray() 8 | // val arrayBooleanLetras = BooleanArray(arrayLetras.size) 9 | 10 | val arrayLetras = arrayLetras(palabra) 11 | // println("Array de letras: ${printArray(arrayLetras)}") 12 | val arrayBooleanLetras = arrayBoolean(palabra) 13 | // println("Array de booleans: ${arrayBooleanLetras.contentToString()}") 14 | 15 | var intentos = palabra.length + 3 // Le damos tres vidas! 16 | var adivinado = false 17 | 18 | do { 19 | println("Intentos: $intentos") 20 | println("Palabra:") 21 | imprimirPalabraSecreta(arrayLetras, arrayBooleanLetras) 22 | 23 | val letra = pedirLetra() 24 | println("Letra introducida: $letra") 25 | adivinado = comprobarLetra(letra, arrayLetras, arrayBooleanLetras) 26 | 27 | intentos-- 28 | } while (intentos > 0 && !adivinado) 29 | 30 | if (adivinado) { 31 | println("Has adivinado la palabra") 32 | println("Lo has conseguido en $intentos intentos") 33 | } else { 34 | println("Has perdido") 35 | } 36 | println("La palabra era: $palabra") 37 | } 38 | 39 | fun imprimirPalabraSecreta( 40 | arrayLetras: CharArray, 41 | arrayBooleanLetras: BooleanArray 42 | ) { 43 | 44 | require(arrayLetras.size == arrayBooleanLetras.size) { 45 | "Los arrays deben tener el mismo tamaño" 46 | } 47 | check(arrayLetras.isNotEmpty()) { 48 | "Los arrays no pueden estar vacíos" 49 | } 50 | 51 | for (i in arrayLetras.indices) { 52 | if (arrayBooleanLetras[i]) { 53 | print("${arrayLetras[i]} ") 54 | } else { 55 | print("_ ") 56 | } 57 | } 58 | println() 59 | } 60 | 61 | fun comprobarLetra( 62 | letra: Char, 63 | arrayLetras: CharArray, 64 | arrayBooleanLetras: BooleanArray 65 | ): Boolean { 66 | // Recorremos en busca de la letra 67 | for (i in arrayLetras.indices) { 68 | if (arrayLetras[i] == letra) { 69 | arrayBooleanLetras[i] = true 70 | } 71 | } 72 | 73 | // solo si todas las letras son true, adivinado es true 74 | for (i in arrayBooleanLetras.indices) { 75 | if (!arrayBooleanLetras[i]) { 76 | return false 77 | } 78 | } 79 | return true 80 | } 81 | 82 | fun pedirLetra(): Char { 83 | do { 84 | println("Introduce una letra: ") 85 | val letra = readln().lowercase().firstOrNull() ?: ' ' 86 | // val input = readln().lowercase() 87 | // val letra = if (input.length == 1) input[0] else ' ' 88 | if (letra.isLetter()) { 89 | return letra 90 | } else { 91 | println("No has introducido una letra") 92 | } 93 | } while (true) 94 | } 95 | 96 | fun arrayLetras(palabra: String): CharArray { 97 | val arrayLetras = CharArray(palabra.length) 98 | for (i in palabra.indices) { 99 | arrayLetras[i] = palabra[i] 100 | } 101 | return arrayLetras 102 | } 103 | 104 | fun arrayBoolean(palabra: String): BooleanArray { 105 | return BooleanArray(palabra.length) 106 | } 107 | 108 | fun palabraAleatoriaDiccionario(): String { 109 | val listaPalabras = arrayOf( 110 | "portatil", "arbol", "hormiga", "regleta" 111 | ) 112 | return listaPalabras.random() 113 | // val randomIndex = (listaPalabras.indices).random() 114 | // return listaPalabras[randomIndex] 115 | } 116 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/arrays/Funciones.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val c = suma(1, 2) 3 | println(c) 4 | val d = suma(numeroB = 2, numeroA = 1) 5 | println(d) 6 | val e = incremento(3, 2) 7 | println(e) 8 | val f = incremento(incremento = 2, numero = 3) 9 | println(f) 10 | try { 11 | val g = incrementoPositivo(3, -2) 12 | println(g) 13 | } catch (e: Exception) { 14 | println(e.message) 15 | } 16 | 17 | try { 18 | val h = dividir(3, 0) 19 | println(h) 20 | } catch (e: Exception) { 21 | println(e.message) 22 | // Finally es opcional 23 | } finally { 24 | println("Esto se ejecuta siempre") 25 | } 26 | 27 | println(dividir(3, 2)) 28 | 29 | } 30 | 31 | fun suma(numeroA: Int, numeroB: Int): Int { 32 | return numeroA + numeroB 33 | } 34 | 35 | // Esta sobre-cargada 36 | fun suma(numeroA: Double, numeroB: Double): Double { 37 | return numeroA + numeroB 38 | } 39 | 40 | /** 41 | * Incrementa un numero en un incremento 42 | * @param numero el numero a incrementar 43 | * @param incremento el incremento. Por defecto 1 44 | * @return el numero incrementado 45 | */ 46 | fun incremento(numero: Int, incremento: Int = 1): Int { 47 | return numero + incremento 48 | } 49 | 50 | // solucion con sobrecarga!!! 51 | /* 52 | fun incremento(numero: Int): Int { 53 | return numero + 1 54 | }*/ 55 | 56 | 57 | /** 58 | * Incrementa un numero en un incremento positivo 59 | * @param numero el numero a incrementar 60 | * @param incremento el incremento. Por defecto 1, y siempre positivo 61 | * @return el numero incrementado 62 | * @throws Exception si el incremento es negativo 63 | */ 64 | fun incrementoPositivo(numero: Int, incremento: Int = 1): Int { 65 | /*if (incremento < 0) { 66 | throw IllegalArgumentException("El incremento no puede ser negativo") 67 | }*/ 68 | check(incremento >= 0) { "El incremento no puede ser negativo" } 69 | return numero + incremento 70 | } 71 | 72 | /** 73 | * Divide dos numeros enteros 74 | * @param dividendo el dividendo de la division 75 | * @param divisor el divisor de la division. Nunca 0 76 | * @return el resultado de la division 77 | * @throws Exception si el divisor es 0 78 | */ 79 | fun dividir(dividendo: Int, divisor: Int): Int { 80 | /*if (numeroB == 0) { 81 | throw IllegalArgumentException("El numero B no puede ser 0") 82 | }*/ 83 | require(divisor != 0) { "El numero B no puede ser 0" } 84 | 85 | return dividendo / divisor 86 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/arrays/MoscaVector.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val tamaño = 5 3 | var intentos = 5 4 | var cazada = false 5 | 6 | var vector = crearVectorMosca(tamaño) 7 | 8 | do { 9 | // Donde esta la mosca 10 | val posicion = pedirPosicion(tamaño) 11 | // Analizar golpe 12 | // hemos utilizado un inline 13 | when (analizarGolpeJugador(posicion, vector)) { 14 | 0 -> { 15 | println("Has fallado") 16 | } 17 | 18 | 1 -> { 19 | println("Uy, casi has dado a la mosca") 20 | // Porque debemos sortear la mosca otra vez al moverse 21 | vector = crearVectorMosca(tamaño) 22 | } 23 | 24 | 2 -> { 25 | println("Has cazado a la mosca") 26 | cazada = true 27 | } 28 | } 29 | intentos-- 30 | } while (intentos > 0 && !cazada) 31 | 32 | if (cazada) { 33 | println("Eres un gran cazador de moscas") 34 | println("Lo has conseguido en $intentos intentos") 35 | } else { 36 | println("Has perdido") 37 | 38 | } 39 | mostrarVectorMosca(vector) 40 | println("La mosca estaba en la posición ${getPosicionMosca(vector)}") 41 | } 42 | 43 | // Renombrar nombre y parámetros 44 | fun analizarGolpeJugador(posicionAGolpear: Int, vectorPosiciones: IntArray): Int { 45 | // Utilizamos un early return! 46 | // ¡Hemos acertado!! 47 | if (vectorPosiciones[posicionAGolpear] == 1) { 48 | return 2 49 | } 50 | // Extraer a método 51 | return comprobarPosicionEnLimitesVector(posicionAGolpear, vectorPosiciones) 52 | } 53 | 54 | private fun comprobarPosicionEnLimitesVector(posicionAGolpear: Int, vectorPosiciones: IntArray): Int { 55 | // Comprobamos a derecha e izquierda 56 | // Sin salirnos de los límites por la izquierda 57 | // sin salirnos 58 | if (posicionAGolpear > 0 && vectorPosiciones[posicionAGolpear - 1] == 1) { 59 | return 1 60 | } 61 | // Sin salirnos de los limites por la derecha 62 | // sin salirnos 63 | return if (posicionAGolpear < vectorPosiciones.size - 1 && vectorPosiciones[posicionAGolpear + 1] == 1) { 64 | 1 65 | } else { 66 | 0 67 | } 68 | } 69 | 70 | fun pedirPosicion(tamaño: Int): Int { 71 | var posicion = 0 72 | do { 73 | println("Introduce la posicion de la mosca: ") 74 | posicion = readln().toIntOrNull() ?: 0 75 | } while (posicion <= 0 || posicion > tamaño) 76 | return posicion - 1 77 | } 78 | 79 | fun crearVectorMosca(tamaño: Int): IntArray { 80 | val vector = IntArray(tamaño) { 0 } 81 | // Sorteo de la posicion de la mosca 82 | val posicionMosca = (0 until tamaño).random() 83 | vector[posicionMosca] = 1 84 | return vector 85 | } 86 | 87 | fun mostrarVectorMosca(vector: IntArray) { 88 | print("[") 89 | for (i in vector.indices) { 90 | if (i <= vector.size - 2) { 91 | print("${casillaVectorMosca(vector[i])}, ") 92 | } else { 93 | print(casillaVectorMosca(vector[i])) 94 | } 95 | } 96 | println("]") 97 | } 98 | 99 | fun casillaVectorMosca(numero: Int) = when (numero) { 100 | 0 -> " " 101 | 1 -> "\uD83D\uDD4A️" 102 | else -> "Error" 103 | } 104 | 105 | 106 | fun getPosicionMosca(vector: IntArray): Int { 107 | for (i in vector.indices) { 108 | if (vector[i] == 1) { 109 | return i + 1 110 | } 111 | } 112 | return -1 113 | } 114 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/arrays/Revsersed.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val array = intArrayOf(1, 2, 3, 4, 5) 3 | printArray(array) 4 | val reversedArray= reversedArray(array) 5 | printArray(reversedArray) 6 | 7 | val arrayDos = intArrayOf(5, 4, 3, 2, 1) 8 | 9 | // son capicuas!!! 10 | if(compareArray(reversedArray, arrayDos)) { 11 | println("Son capicuas") 12 | } else { 13 | println("No son capicuas") 14 | } 15 | 16 | val capicua = intArrayOf(1, 2, 3, 2, 1) 17 | printArray(capicua) 18 | val reversedCapicua = reversedArray(capicua) 19 | printArray(reversedCapicua) 20 | if(compareArray(reversedCapicua, capicua)) { 21 | println("Son capicuas") 22 | } else { 23 | println("No son capicuas") 24 | } 25 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/arrays/utils.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Devuelve un array invertido 3 | * @param array el array a invertir 4 | * @return el array invertido 5 | */ 6 | fun reversedArray(array: IntArray): IntArray { 7 | val result = IntArray(array.size) 8 | for (i in array.indices) { 9 | result[i] = array[array.size - i - 1] 10 | } 11 | return result 12 | } 13 | 14 | /** 15 | * Imprime un array 16 | * @param array el array a imprimir 17 | */ 18 | fun printArray(array: IntArray) { 19 | print("[") 20 | for (i in array.indices) { 21 | if (i <= array.size - 2) { 22 | print("${array[i]}, ") 23 | } else { 24 | print("${array[i]}") 25 | } 26 | } 27 | println("]") 28 | } 29 | 30 | fun printArray(array: CharArray) { 31 | print("[") 32 | for (i in array.indices) { 33 | if (i <= array.size - 2) { 34 | print("${array[i]}, ") 35 | } else { 36 | print("${array[i]}") 37 | } 38 | } 39 | println("]") 40 | } 41 | 42 | 43 | /** 44 | * Compara dos arrays 45 | * @param arrayUno el primer array 46 | * @param arrayDos el segundo array a comparar 47 | * @return true si son iguales, false si no lo son 48 | */ 49 | fun compareArray(arrayUno: IntArray, arrayDos: IntArray): Boolean { 50 | for (i in arrayUno.indices) { 51 | if (arrayUno[i] != arrayDos[i]) { 52 | return false 53 | } 54 | } 55 | return true 56 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/examen/ESLA.kt: -------------------------------------------------------------------------------- 1 | package examen 2 | 3 | fun main(args: Array) { 4 | // Constantes 5 | val NUM_SOLDADOS = 2000 6 | val SOLDADOS_COTIGENCIA = 20 7 | var almacen = 39000 8 | val LIMITE_ALMACEN = 3900 9 | val TIEMPO_MAXIMO = 7200 10 | val TIEMPO_CHECK = 200 11 | val TOTAL_CONTINGENCIAS = NUM_SOLDADOS / SOLDADOS_COTIGENCIA 12 | 13 | var contigenciasVivas = NUM_SOLDADOS / SOLDADOS_COTIGENCIA 14 | val contigencias = IntArray(contigenciasVivas) { 400 } 15 | val URUK_PROBABILIDAD = 20 16 | val TIEMPO_ATAQUE = 50 17 | var temporizador = 0 18 | 19 | println("*** El Señor de los Anillos ***") 20 | println("*** Batalla de Mordor ***") 21 | initContengicas(contigencias) 22 | printContigencias(contigencias) 23 | 24 | do { 25 | // Al final 26 | // temporizador ++; // No lo necesito porque ya espero una oleada 27 | // Actúan Marry y Pippin abasteciendo las tropas 28 | if (temporizador % TIEMPO_CHECK == 0) { 29 | // como no puedo hacer paso por referencia por eso lo devuelvo 30 | almacen = abastecerTropas(almacen, contigencias) 31 | } 32 | // Simulando batalla 33 | // ¿Que tropa esta siendo atacada? Como no puedo hacer paso por referencia por eso lo devuelvo 34 | contigenciasVivas = ataqueEnemigo(contigenciasVivas, contigencias, URUK_PROBABILIDAD) 35 | 36 | // Espero otra oleada, esto opcional, comentar si no se usa 37 | esperarTime(TIEMPO_ATAQUE) 38 | temporizador += TIEMPO_ATAQUE 39 | } while (temporizador < TIEMPO_MAXIMO && almacen > LIMITE_ALMACEN) 40 | printReport(almacen, LIMITE_ALMACEN, contigenciasVivas, TOTAL_CONTINGENCIAS, contigencias) 41 | } 42 | 43 | /** 44 | * abastecerTropas con el almacen 45 | * @param almacen Int Almacen de armas, como no puedo por el paso por referencia, lo devuelvo 46 | * @param contigencias IntArray Contigencias 47 | * @return Int Devuelve el almacen actualizado 48 | */ 49 | private fun abastecerTropas(almacen: Int, contigencias: IntArray): Int { 50 | var futuroAlmacen = almacen // si no Kotlin me bloquea la rasignación 51 | println(" --> Merry y Pippin Comprueban estado de contiengecias") 52 | for (i in contigencias.indices) { 53 | if (contigencias[i] != 400 && contigencias[i] != -1) { 54 | futuroAlmacen = restablcerContingencia(contigencias, i, futuroAlmacen) 55 | } 56 | } 57 | return futuroAlmacen // Devuelvo el almacen porque ha cambiado ya que no hay paso por referencia en tipos simples 58 | } 59 | 60 | /** 61 | * Imprime el informe de la batalla 62 | * @param almacen Int Almacen de armas 63 | * @param limiteAlmacen Int Limite de almacen 64 | * @param contigenciasVivas Int Contigencias vivas 65 | * @param totalContingencias Int Total de contingencias 66 | * @param contigencias IntArray Contigencias 67 | */ 68 | private fun printReport( 69 | almacen: Int, 70 | limiteAlmacen: Int, 71 | contigenciasVivas: Int, 72 | totalContingencias: Int, 73 | contigencias: IntArray 74 | ) { 75 | if (almacen < limiteAlmacen) { 76 | println("Has perdido la batalla, te has quedado sin suministros") 77 | } else { 78 | println("Se ha terminado el programa porque se ha alcanzado el tiempo máximo") 79 | } 80 | println("Almacen: $almacen") 81 | println("Contingencias vivas: $contigenciasVivas") 82 | println("Contingencias muertas: " + (totalContingencias - contigenciasVivas)) 83 | println("Contingencias: ") 84 | printContigencias(contigencias) 85 | } 86 | 87 | /** 88 | * Simula el ataque de los enemigos 89 | * @param contigenciasVivas Int Contigencias vivas como no puedo por el paso por referencia, lo devuelvo 90 | * @param contigencias IntArray Contigencias 91 | * @param uruk_probabilidad Int Probabilidad de que sea un uruk hai 92 | * @return Int Devuelve el numero de contigencias vivas actualizado 93 | */ 94 | private fun ataqueEnemigo(contigenciasVivas: Int, contigencias: IntArray, URUK_PROBABILIDAD: Int): Int { 95 | var contigenciasActuales = contigenciasVivas 96 | val numContingencia = alerta(contigenciasActuales, contigencias) // ¿Que contingencia es atacada? 97 | val enemigos = tropasEnemigas() // ¿Cuantos enemigos son? 98 | val isUrukHai: Boolean = isUrukHai(URUK_PROBABILIDAD) // ¿Es un uruk hai? lo veremos // ¿hay uruk hai? 99 | println("Contiencia: $numContingencia esta siendo atacada") 100 | println("Tropas enemigas que nos atacan: $enemigos y tienen UrukHai: $isUrukHai") 101 | var victoriaEnOleada = true 102 | if (contigencias[numContingencia] > enemigos) { 103 | contigencias[numContingencia] -= enemigos 104 | victoriaEnOleada = if (isUrukHai) { 105 | sorteo(75) 106 | } else { 107 | sorteo(85) 108 | } 109 | } else if (contigencias[numContingencia] < enemigos && enemigos < 10) { 110 | contigencias[numContingencia] -= enemigos 111 | victoriaEnOleada = if (isUrukHai) { 112 | sorteo(35) 113 | } else { 114 | sorteo(45) 115 | } 116 | } else if (contigencias[numContingencia] < enemigos && enemigos >= 10) { 117 | contigencias[numContingencia] -= enemigos 118 | victoriaEnOleada = false 119 | } 120 | 121 | // Ha caido la contingencia 122 | if (!victoriaEnOleada) { 123 | contigenciasActuales-- 124 | contigencias[numContingencia] = -1 125 | } 126 | return contigenciasActuales 127 | } 128 | 129 | /** 130 | * Inicia las contingencias con 400 soldados 131 | * @param contigencias 132 | */ 133 | private fun initContengicas(contigencias: IntArray) { 134 | for (i in contigencias.indices) { 135 | contigencias[i] = 400 136 | } 137 | } 138 | 139 | /** 140 | * Imprime las contingencias 141 | * @param contigencias 142 | */ 143 | private fun printContigencias(contigencia: IntArray) { 144 | // No utlizo las funciones de Kotlin contentToString() 145 | print("contingencia: { ") 146 | for (j in contigencia) { 147 | if (j == -1) { 148 | print("\uD83D\uDC80 ") 149 | } else { 150 | print("$j ") 151 | } 152 | } 153 | println("}") 154 | } 155 | 156 | /** 157 | * Restablece la contingencia 158 | * @param contigencias IntArray Contigencias 159 | * @param numContingencia Int Numero de contingencia 160 | * @param almacen Int Almacen de armas como no puedo por el paso por referencia, lo devuelvo 161 | * @return Int Devuelve el almacen actualizado ya que no hay paso por referencia en tipos simples 162 | */ 163 | private fun restablcerContingencia(contigencia: IntArray, numContingencia: Int, almacen: Int): Int { 164 | var futuroAlmacen = almacen 165 | futuroAlmacen -= 400 - contigencia[numContingencia] 166 | contigencia[numContingencia] = 400 167 | return futuroAlmacen 168 | } 169 | 170 | /** 171 | * Genera un numero aleatorio entre 1 y 100 172 | */ 173 | private fun sorteo(probabilidad: Int): Boolean { 174 | return (1..100).random() < probabilidad 175 | } 176 | 177 | /** 178 | * Devuelve la contigencia que es atacada 179 | * @param contigenciasVivas Int Contigencias vivas 180 | * @param contigencias IntArray Contigencias 181 | * @return Int Devuelve la contigencia que es atacada 182 | */ 183 | private fun alerta(totalContingencias: Int, contigencias: IntArray): Int { 184 | var contingencia = 0 185 | do { 186 | contingencia = (0 until totalContingencias).random() 187 | if (estadoContingencia(contigencias, contingencia) == -1) { 188 | contingencia = -1 189 | } 190 | } while (contingencia == -1) 191 | return contingencia 192 | } 193 | 194 | /** 195 | * Devuelve el estado de la contingencia 196 | * @param contigencias IntArray Contigencias 197 | * @param numContingencia Int Numero de contingencia 198 | * @return Int Devuelve el estado de la contingencia 199 | */ 200 | private fun estadoContingencia(contigencias: IntArray, numContingencia: Int): Int { 201 | return contigencias[numContingencia] 202 | } 203 | 204 | /** 205 | * Devuelve el numero de tropas enemigas 206 | * @return Int Devuelve el numero de tropas enemigas 207 | */ 208 | private fun tropasEnemigas(): Int { 209 | return (1..15).random() 210 | } 211 | 212 | /** 213 | * Devuelve si es un uruk hai 214 | * @param uruk_probabilidad Int Probabilidad de que sea un uruk hai 215 | * @return Boolean Devuelve si es un uruk hai 216 | */ 217 | private fun isUrukHai(probabilidad: Int): Boolean { 218 | return sorteo(probabilidad) 219 | } 220 | 221 | /** 222 | * Para el programa un tiempo determinado 223 | * @param tiempo Int Tiempo en milisegundos 224 | * @throws InterruptedException Excepcion de interrupcin del hilo main 225 | */ 226 | private fun esperarTime(tiempo: Int) { 227 | Thread.sleep(tiempo.toLong()) 228 | } 229 | 230 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/examen/LullGasol.kt: -------------------------------------------------------------------------------- 1 | package examen 2 | 3 | fun main() { 4 | val NUM_RONDAS = 3 5 | val NUM_LANZAMIENTOS = 5 6 | val puntuacionLlul = IntArray(NUM_RONDAS) // { 0 } 7 | val puntuacionGasol = IntArray(NUM_RONDAS) // { 0 } 8 | 9 | juegoLanzamientos(NUM_RONDAS, NUM_LANZAMIENTOS, puntuacionLlul, puntuacionGasol) 10 | 11 | imprimirResultados(puntuacionLlul, puntuacionGasol) 12 | } 13 | 14 | private fun juegoLanzamientos( 15 | NUM_RONDAS: Int, 16 | NUM_LANZAMIENTOS: Int, 17 | puntuacionLlul: IntArray, 18 | puntuacionGasol: IntArray 19 | ) { 20 | // repetimos el juego NUM_RONDAS veces 21 | for (i in 0..NUM_RONDAS - 1) { 22 | println("Ronda ${i + 1}") 23 | // repetimos el lanzamiento NUM_LANZAMIENTOS veces 24 | for (j in 0 until NUM_LANZAMIENTOS) { 25 | println("Lanzamiento Llul: ${j + 1}") 26 | // Llul lanza 27 | if (j < NUM_LANZAMIENTOS - 1) { 28 | puntuacionLlul[i] += lanzamiento(lanzamiento = j, probabilidad = 0.5, puntuacion = 1) 29 | } else { 30 | puntuacionLlul[i] += lanzamiento(lanzamiento = j, probabilidad = 0.5, puntuacion = 2) 31 | } 32 | // Gasol lanza 33 | println("Lanzamiento Gasol: ${j + 1}") 34 | // Llul lanza 35 | if (j < NUM_LANZAMIENTOS - 1) { 36 | puntuacionGasol[i] += lanzamiento(lanzamiento = j, probabilidad = 0.33, puntuacion = 1) 37 | } else { 38 | puntuacionGasol[i] += lanzamiento(lanzamiento = j, probabilidad = 0.33, puntuacion = 2) 39 | } 40 | } 41 | } 42 | } 43 | 44 | fun lanzamiento(lanzamiento: Int, probabilidad: Double, puntuacion: Int): Int { 45 | val resultado = Math.random() 46 | return if (resultado < probabilidad) { 47 | println("Lanzamiento ${lanzamiento + 1}: acierto y tiene $puntuacion puntos") 48 | puntuacion 49 | } else { 50 | println("Lanzamiento ${lanzamiento + 1}: fallo") 51 | 0 52 | } 53 | } 54 | 55 | fun imprimirResultados(puntuacionLlul: IntArray, puntuacionGasol: IntArray) { 56 | // analizamos cada ronda 57 | for (i in puntuacionLlul.indices) { 58 | println("Resultados de la ronda ${i + 1}") 59 | // si la puntuación de Llul es mayor que la de Gasol 60 | if (puntuacionLlul[i] > puntuacionGasol[i]) { 61 | println("Gana Llul en la ronda ${i + 1} con ${puntuacionLlul[i]} puntos") 62 | } else if (puntuacionLlul[i] < puntuacionGasol[i]) { 63 | println("Gana Gasol en la ronda ${i + 1} con ${puntuacionGasol[i]} puntos") 64 | } else { 65 | println("Empate en la ronda ${i + 1} con ${puntuacionLlul[i]} puntos") 66 | } 67 | println("Llul: ${puntuacionLlul.contentToString()} puntos") 68 | println("Gasol: ${puntuacionGasol.contentToString()} puntos") 69 | } 70 | 71 | // necesitamos los puntos totales de cada jugador 72 | val puntosLull = sumaPuntosTotal(puntuacionLlul) 73 | val puntosGasol = sumaPuntosTotal(puntuacionGasol) 74 | 75 | // ¿Quién ha ganado? when para no repetir el if como antes 76 | println("Resultados finales") 77 | when { 78 | puntosLull > puntosGasol -> println("Gana Llul con $puntosLull puntos") 79 | puntosLull < puntosGasol -> println("Gana Gasol con $puntosGasol puntos") 80 | else -> println("Empate con $puntosLull puntos") 81 | } 82 | } 83 | 84 | fun sumaPuntosTotal(puntuacion: IntArray): Int { 85 | var suma = 0 86 | for (i in puntuacion.indices) { 87 | suma += puntuacion[i] 88 | } 89 | return suma 90 | } 91 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/examen/PilotoAutomatico.kt: -------------------------------------------------------------------------------- 1 | package examen 2 | 3 | var ALTITUD_INDEX = 0 4 | var VELOCIDAD_INDEX = 1 5 | var parametrosVuelo = IntArray(2) 6 | var constantesVuelo = IntArray(2) 7 | const val MAX_TIME = 5000 8 | const val PROBABILIDAD_FALLO = 1 // 1% 9 | 10 | fun main() { 11 | var cronometro = 0 12 | 13 | // Pedimos los parámetros de vuelo 14 | pedirParametrosDeVuelo() 15 | 16 | // Experimento es que empiece cerca de la alitud fijada por arriba o abajo 17 | parametrosVuelo[ALTITUD_INDEX] = constantesVuelo[ALTITUD_INDEX] + (-200..200).random() 18 | parametrosVuelo[VELOCIDAD_INDEX] = constantesVuelo[VELOCIDAD_INDEX] + (-200..200).random() 19 | 20 | do { 21 | println("Hola soy el piloto automático mi tiempo es $cronometro") 22 | // Comprobar y corregir altitud 23 | val altitud = altitud() // Por utilizar estas funciones 24 | if (constantesVuelo[ALTITUD_INDEX] > altitud) { 25 | println("Subiendo el avión de altura") 26 | aumentar('a') 27 | } else if (constantesVuelo[ALTITUD_INDEX] < altitud) { 28 | println("Bajando el avión de altura") 29 | disminuir('a') 30 | } 31 | 32 | // Comprobar y corregir velocidad 33 | // Es una locura hacerlo así se haría como la altura!!!! 34 | val velocidad = IntArray(1) // Por utilizar estas funciones 35 | velocidad(velocidad) 36 | if (constantesVuelo[VELOCIDAD_INDEX] > velocidad[0]) { 37 | println("Acelerando el avión de velocidad") 38 | aumentar('v') 39 | } else if (constantesVuelo[VELOCIDAD_INDEX] < velocidad[0]) { 40 | println("Desacelerando el avión de velocidad") 41 | disminuir('v') 42 | } 43 | 44 | println("Altura actual: ${parametrosVuelo[ALTITUD_INDEX]}") 45 | println("Velocidad actual: ${parametrosVuelo[VELOCIDAD_INDEX]}") 46 | 47 | 48 | // Al final 49 | esperar(200) 50 | cronometro += 200 51 | } while (cronometro <= MAX_TIME && !falloSistema()) 52 | 53 | if (cronometro > MAX_TIME) { 54 | println("El piloto automático ha terminado su tiempo de ejecución") 55 | } else { 56 | println("El piloto automático ha detectado un fallo en el sistema volviendo a control manual") 57 | } 58 | } 59 | 60 | fun pedirParametrosDeVuelo() { 61 | do { 62 | println("Introduce la altura de vuelo (entre 1000 y 5000 metros)") 63 | constantesVuelo[ALTITUD_INDEX] = readln().toIntOrNull() ?: 0 64 | } while (constantesVuelo[ALTITUD_INDEX] < 1000 || constantesVuelo[ALTITUD_INDEX] > 5000) 65 | 66 | do { 67 | println("Introduce la velocidad de vuelo (entre 500 y 700 km/h)") 68 | constantesVuelo[VELOCIDAD_INDEX] = readln().toIntOrNull() ?: 0 69 | } while (constantesVuelo[VELOCIDAD_INDEX] < 500 || constantesVuelo[VELOCIDAD_INDEX] > 700) 70 | } 71 | 72 | fun falloSistema() = ((1..100).random() <= PROBABILIDAD_FALLO) 73 | 74 | 75 | fun altitud(): Int { 76 | return parametrosVuelo[ALTITUD_INDEX] 77 | } 78 | 79 | // Esto es una locura hacerlo así para un solo parámetro y se haría como la altura 80 | fun velocidad(parametros: IntArray) { 81 | parametros[0] = parametrosVuelo[VELOCIDAD_INDEX] 82 | } 83 | 84 | fun esperar(tiempo: Int) { 85 | Thread.sleep(tiempo.toLong()) 86 | } 87 | 88 | fun aumentar(parametro: Char) { 89 | when (parametro) { 90 | 'a' -> parametrosVuelo[ALTITUD_INDEX] += 10 91 | 'v' -> parametrosVuelo[VELOCIDAD_INDEX] += 10 92 | } 93 | } 94 | 95 | fun disminuir(parametro: Char) { 96 | when (parametro) { 97 | 'a' -> parametrosVuelo[ALTITUD_INDEX] -= 10 98 | 'v' -> parametrosVuelo[VELOCIDAD_INDEX] -= 10 99 | } 100 | } 101 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/examen/StarWars.kt: -------------------------------------------------------------------------------- 1 | package examen 2 | 3 | const val LUKE = -1 4 | const val LIBRE = 0 5 | const val ESPACIO = 7 6 | const val MAX_ENEMIGOS = 25 7 | const val TIME_MAX = 10_000 8 | const val MAX_ENERGIA = 10 9 | const val ESPERA = 1000 10 | const val PROB_DAÑO = 25 11 | 12 | var escudosEnergia = MAX_ENERGIA 13 | var enemigosAbatidos = 0 14 | var espacio = Array(ESPACIO) { IntArray(ESPACIO) } 15 | 16 | fun main() { 17 | println("En una galaxia muy muy lejana...") 18 | 19 | // Enemigos 20 | val enemigos = pedirEnemigos() 21 | 22 | iniciarEspacio(espacio, enemigos) 23 | println("El espacio Inicial antes de la batalla:") 24 | printEspacio(espacio) 25 | 26 | // Batalla 27 | val escudosEnergia = batallaEstelar(enemigos) 28 | 29 | informeResultados(espacio, enemigos, escudosEnergia) 30 | 31 | } 32 | 33 | private fun batallaEstelar(enemigos: Int): Int { 34 | 35 | var time = 0 36 | 37 | // doble_buffer 38 | var matrixLectura = clonarMatriz(espacio) 39 | do { 40 | // doble_buffer 41 | val matrixEscritura = clonarMatriz(matrixLectura) 42 | 43 | // Acción de Luke 44 | realizarAccionLuke(matrixLectura, matrixEscritura) 45 | 46 | // Recibimos daño!! 47 | escudosEnergia += probabilidadDaño(PROB_DAÑO) 48 | 49 | // Cambiamos las matrices doble_buffer 50 | matrixLectura = clonarMatriz(matrixEscritura) 51 | 52 | printEspacio(matrixLectura) 53 | Thread.sleep(ESPERA.toLong()) 54 | time += ESPERA 55 | } while (time < TIME_MAX && enemigosAbatidos != enemigos && escudosEnergia > 0) 56 | 57 | // Para que estacio sea la última matriz 58 | espacio = clonarMatriz(matrixLectura) 59 | 60 | return escudosEnergia 61 | } 62 | 63 | fun realizarAccionLuke(matrixLectura: Array, matrixEscritura: Array) { 64 | // Donde esta luke? 65 | val posicionLuke = buscarLuke(matrixLectura) 66 | println("Luke esta en la posicion: ${posicionLuke[0] + 1}, ${posicionLuke[1] + 1}") 67 | // Miramos en las 8 direcciones y masacramos a los enemigos 68 | for (i in -1..1) { 69 | for (j in -1..1) { 70 | if (posicionLuke[0] + i in 0 until ESPACIO 71 | && posicionLuke[1] + j >= 0 72 | && posicionLuke[1] + j < ESPACIO 73 | ) { 74 | if (matrixLectura[posicionLuke[0] + i][posicionLuke[1] + j] > 0) { 75 | // Si fuera masacre ponemos LIBRE 76 | println("Luke ha masacrado a un enemigo en la posicion: ${posicionLuke[0] + i + 1} ${posicionLuke[1] + j + 1}") 77 | matrixEscritura[posicionLuke[0] + i][posicionLuke[1] + j]-- 78 | enemigosAbatidos++ 79 | } 80 | } 81 | } 82 | } 83 | 84 | // Movemos a Luke a una posicion aleatoria libre 85 | val nuevaPosicionLuke = moverLuke(matrixLectura) 86 | println("Luke se ha movido a la posicion: ${nuevaPosicionLuke[0] + 1}, ${nuevaPosicionLuke[1] + 1}") 87 | matrixEscritura[nuevaPosicionLuke[0]][nuevaPosicionLuke[1]] = LUKE 88 | // La antigua posicion de luke la ponemos LIBRE 89 | matrixEscritura[posicionLuke[0]][posicionLuke[1]] = LIBRE 90 | 91 | } 92 | 93 | fun moverLuke(matrixLectura: Array): IntArray { 94 | val posicionLibre = IntArray(2) { -1 } 95 | do { 96 | posicionLibre[0] = (0 until ESPACIO).random() 97 | posicionLibre[1] = (0 until ESPACIO).random() 98 | } while (matrixLectura[posicionLibre[0]][posicionLibre[1]] != LIBRE) 99 | 100 | return posicionLibre 101 | } 102 | 103 | fun buscarLuke(matrixLectura: Array): IntArray { 104 | for (i in matrixLectura.indices) { 105 | for (j in matrixLectura[i].indices) { 106 | if (matrixLectura[i][j] == LUKE) { 107 | return intArrayOf(i, j) 108 | } 109 | } 110 | } 111 | return intArrayOf(-1, -1) 112 | } 113 | 114 | fun probabilidadDaño(limite: Int): Int { 115 | val probabilidad = (1..100).random() 116 | return if (probabilidad <= limite) { 117 | println("Luke ha recibido un golpe, su escudo ha perdido un punto de energía") 118 | -1 119 | } else { 120 | 0 121 | } 122 | } 123 | 124 | private fun informeResultados(espacio: Array, enemigos: Int, escudosEnergia: Int) { 125 | println("El espacio Final despues de la batalla:") 126 | printEspacio(espacio) 127 | // Analisis de resultados 128 | if (enemigosAbatidos == enemigos) { 129 | println("\uD83C\uDF89 ¡¡¡ Han ganado al imperio, Luke ha sobrevivido !!!") 130 | } else if (escudosEnergia == 0) { 131 | println("\uD83D\uDC80 Han ganado los imperiales, has muerto") 132 | } else { 133 | println("✨ Has tardado demasiado, pero Luke ha sobrevivido y escapa") 134 | } 135 | println("Enemigos restantes: ${enemigos - enemigosAbatidos}") 136 | println("Escudos y Energia restantes: $escudosEnergia") 137 | println("Enemigos abatidos: $enemigosAbatidos") 138 | 139 | } 140 | 141 | fun printEspacio(espacio: Array) { 142 | for (fila in espacio) { 143 | for (columna in fila) { 144 | when (columna) { 145 | LUKE -> print(" L ") 146 | LIBRE -> print(" . ") 147 | else -> print(" $columna ") 148 | } 149 | } 150 | println() 151 | } 152 | println() 153 | } 154 | 155 | fun pedirEnemigos(): Int { 156 | do { 157 | print("¿Cuántos enemigos quieres? ") 158 | val enemigos = readln().toIntOrNull() ?: 0 159 | if (enemigos in 1..MAX_ENEMIGOS) 160 | return enemigos 161 | else 162 | println("El número de enemigos debe estar entre 1 y $MAX_ENEMIGOS") 163 | } while (true) 164 | } 165 | 166 | fun iniciarEspacio(espacio: Array, enemigos: Int) { 167 | 168 | // Ponemos todo a cero 169 | for (i in 0 until ESPACIO) { 170 | for (j in 0 until ESPACIO) { 171 | espacio[i][j] = LIBRE 172 | } 173 | } 174 | 175 | // Colocamos a Luke en una posicion aleatoria 176 | val filaLuke = (0 until ESPACIO).random() 177 | val columnaLuke = (0 until ESPACIO).random() 178 | espacio[filaLuke][columnaLuke] = LUKE 179 | 180 | // Para cada enemigo, se pueden poner en cualquier posicion 181 | // que no sea la de Luke 182 | repeat(enemigos) { 183 | // Buscamos una posicion que no esté luke e incrementamos 184 | var fila: Int 185 | var columna: Int 186 | do { 187 | fila = (0 until ESPACIO).random() 188 | columna = (0 until ESPACIO).random() 189 | } while (espacio[fila][columna] == LUKE) 190 | // Colocamos el enemigo // Aumentamos el valor en esa casilla 191 | espacio[fila][columna]++ 192 | } 193 | } 194 | 195 | fun clonarMatriz(matriz: Array): Array { 196 | val clon = Array(matriz.size) { IntArray(matriz[0].size) } 197 | for (i in matriz.indices) { 198 | for (j in matriz[0].indices) { 199 | clon[i][j] = matriz[i][j] 200 | } 201 | } 202 | return clon 203 | } 204 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/exp_regulares/ExpRegulares.kt: -------------------------------------------------------------------------------- 1 | package exp_regulares 2 | 3 | fun main() { 4 | println("Dime tu DNI: ") 5 | val dni = readln() 6 | 7 | val isDNI = isDNIValidoManual(dni.uppercase()) 8 | println("El DNI $dni es ${if (isDNI) "válido" else "inválido"}") 9 | when (isDNIValidoManualCodigoError(dni.uppercase())) { 10 | 0 -> println("El DNI $dni es válido") 11 | -1 -> println("El DNI $dni es inválido porque no tiene 9 caracteres") 12 | -2 -> println("El DNI $dni es inválido, no se ha introducido una letra válida") 13 | -3 -> println("El DNI $dni es inválido, no es la letra correcta") 14 | -4 -> println("El DNI $dni es inválido, no se ha introducido un número válido") 15 | } 16 | 17 | try { 18 | isDNIValidoExcepciones(dni.uppercase()) 19 | println("El DNI $dni válido") 20 | } catch (e: Exception) { 21 | println("El DNI $dni es inválido, ${e.message}") 22 | } 23 | 24 | try { 25 | isDNIValidoConExpRegular(dni.uppercase()) 26 | println("El DNI $dni válido") 27 | } catch (e: Exception) { 28 | println("El DNI $dni es inválido, ${e.message}") 29 | } 30 | 31 | try { 32 | isDNIValidoConExpRegular(dni.uppercase()) 33 | println("El DNI $dni válido") 34 | } catch (e: Exception) { 35 | println("El DNI $dni es inválido, ${e.message}") 36 | } 37 | } 38 | 39 | /** 40 | * Comprueba si un DNI es válido o no 41 | * @param dni DNI a comprobar 42 | * @return true si es válido, false si no lo es 43 | * 44 | * PROBLEMA: No ofrece información del tipo de error 45 | */ 46 | fun isDNIValidoManual(dni: String): Boolean { 47 | // Early return 48 | if (dni.length != 9) return false 49 | if (dni.last() !in 'A'..'Z') return false 50 | if (!checkLetraDNI(dni)) return false 51 | // Ver si el resto son números 52 | val numeros = dni.substring(0, dni.length - 1) 53 | for (c in numeros) { 54 | if (c !in '0'..'9') return false 55 | } 56 | return true 57 | } 58 | 59 | /** 60 | * Comprueba si la letra del DNI es correcta 61 | * @param dni DNI a comprobar 62 | * @return 0 si es correcta, -1..., -2..., -3..., -4... si no lo es 63 | */ 64 | fun isDNIValidoManualCodigoError(dni: String): Int { 65 | // Early return 66 | if (dni.length != 9) return -1 67 | if (dni.last() !in 'A'..'Z') return -2 68 | if (!checkLetraDNI(dni)) return -3 69 | // Ver si el resto son números 70 | val numeros = dni.substring(0, dni.length - 1) 71 | for (c in numeros) { 72 | if (c !in '0'..'9') return -4 73 | } 74 | return 0 75 | } 76 | 77 | fun isDNIValidoExcepciones(dni: String): Boolean { 78 | // Von excepciones con requiere y propias 79 | require(dni.length == 9) { "El DNI debe tener 9 caracteres" } 80 | require(dni.last() in 'A'..'Z') { "El DNI debe terminar en una letra entre A y Z" } 81 | require(checkLetraDNI(dni)) { "La letra del DNI no es correcta" } 82 | // Ver si el resto son números 83 | val numeros = dni.substring(0, dni.length - 1) 84 | for (c in numeros) { 85 | if (c !in '0'..'9') throw IllegalArgumentException("El DNI debe contener solo números") 86 | } 87 | return true 88 | } 89 | 90 | fun checkLetraDNI(dni: String): Boolean { 91 | val letras = "TRWAGMYFPDXBNJZSQVHLCKE" 92 | val numero = dni.substring(0, dni.length - 1).toInt() 93 | println("Número: $numero") 94 | val letra = dni.last() 95 | return letras[numero % 23] == letra 96 | } 97 | 98 | fun isDNIValidoConExpRegular(dni: String): Boolean { 99 | // Expresión regular 100 | val regex = Regex("[0-9]{8}[A-Z]") 101 | val regex2 = """\d{8}[A-Z]""".toRegex() 102 | if (!regex.matches(dni)) throw IllegalArgumentException("El DNI no tiene el formato correcto") 103 | if (!checkLetraDNI(dni)) throw IllegalArgumentException("La letra del DNI no es correcta") 104 | return true 105 | } 106 | 107 | fun isDNIValidoConExpRegularOpt(dni: String): Boolean { 108 | require(Regex("[0-9]{8}[A-Z]").matches(dni)) { "El DNI no tiene el formato correcto" } 109 | require(checkLetraDNI(dni)) { "La letra del DNI no es correcta" } 110 | return true 111 | } 112 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/matrices/doble_buffer/DobleBuffer.kt: -------------------------------------------------------------------------------- 1 | package matrices.doble_buffer 2 | 3 | const val MAX = 5 4 | fun main() { 5 | val matrix = Array(MAX) { IntArray(MAX) } 6 | 7 | initMatrix(matrix) 8 | printMatrix(matrix) 9 | 10 | //sinDobleBuffer(matrix) 11 | 12 | conDobleBuffer(matrix) 13 | 14 | println("FIN!") 15 | 16 | } 17 | 18 | /** 19 | * No esta bien 20 | */ 21 | fun sinDobleBuffer(matrix: Array) { 22 | val timeMax = 10_000 23 | var time = 0 24 | do { 25 | moverLosUnosSinDobleBuffer(matrix) 26 | printMatrix(matrix) 27 | Thread.sleep(1000) 28 | time += 1_000 29 | } while (time < timeMax) 30 | } 31 | 32 | /** 33 | * No esta bien porque vamos machacando los valores de la matriz 34 | * a la misma vez que el bucle los lee por lo tanto 35 | * estamos mutando la matriz mientras la leemos 36 | */ 37 | fun moverLosUnosSinDobleBuffer(matrix: Array) { 38 | for (fila in matrix.indices) { 39 | for (columna in matrix[fila].indices) { 40 | if (matrix[fila][columna] == 1) { 41 | // Mover aleatoriamente a una posicion que tenga un 0 42 | var esCero = false 43 | do { 44 | val nuevaFila = (0 until MAX).random() 45 | val nuevaColumna = (0 until MAX).random() 46 | if (matrix[nuevaFila][nuevaColumna] == 0) { 47 | matrix[fila][columna] = 0 48 | matrix[nuevaFila][nuevaColumna] = 1 49 | esCero = true 50 | } 51 | } while (!esCero) 52 | } 53 | } 54 | } 55 | } 56 | 57 | // Ponemos 0 o 1 si la posición está vacía 58 | fun initMatrix(matrix: Array) { 59 | val maxUnos = 10 60 | // sorteo de 10 posiciones mientras que no sea 0 61 | repeat(10) { 62 | var esCero = false 63 | do { 64 | val fila = (0 until MAX).random() 65 | val columna = (0 until MAX).random() 66 | if (matrix[fila][columna] == 0) { 67 | matrix[fila][columna] = 1 68 | esCero = true 69 | } 70 | } while (!esCero) 71 | } 72 | } 73 | 74 | fun printMatrix(matrix: Array) { 75 | println() 76 | for (i in matrix.indices) { 77 | for (j in matrix[i].indices) { 78 | print(matrix[i][j]) 79 | } 80 | println() 81 | } 82 | } 83 | 84 | fun conDobleBuffer(matrix: Array) { 85 | val timeMax = 10_000 86 | var time = 0 87 | var matrixLectura = clonarMatriz(matrix) 88 | do { 89 | // Intercambiamos las matrices 90 | val matrixEscritura = clonarMatriz(matrixLectura) 91 | 92 | // Acción 93 | moverLosUnosConDobleBuffer(matrixLectura, matrixEscritura) 94 | 95 | // Intercambiamos de nuevo 96 | matrixLectura = clonarMatriz(matrixEscritura) 97 | 98 | printMatrix(matrixLectura) 99 | Thread.sleep(1000) 100 | time += 1_000 101 | } while (time < timeMax) 102 | } 103 | 104 | fun clonarMatriz(matrixLectura: Array): Array { 105 | val matrixEscritura = Array(MAX) { IntArray(MAX) } 106 | for (fila in matrixLectura.indices) { 107 | for (columna in matrixLectura[fila].indices) { 108 | matrixEscritura[fila][columna] = matrixLectura[fila][columna] 109 | } 110 | } 111 | return matrixEscritura 112 | } 113 | 114 | fun moverLosUnosConDobleBuffer(matrixLectura: Array, matrixEscritura: Array) { 115 | for (fila in matrixLectura.indices) { 116 | for (columna in matrixLectura[fila].indices) { 117 | if (matrixLectura[fila][columna] == 1) { 118 | // Mover aleatoriamente a una posicion que tenga un 0 119 | var esCero = false 120 | do { 121 | val nuevaFila = (0 until MAX).random() 122 | val nuevaColumna = (0 until MAX).random() 123 | if (matrixEscritura[nuevaFila][nuevaColumna] == 0) { 124 | matrixEscritura[fila][columna] = 0 125 | matrixEscritura[nuevaFila][nuevaColumna] = 1 126 | esCero = true 127 | } 128 | } while (!esCero) 129 | } 130 | } 131 | } 132 | } 133 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/matrices/mosca/Mosca.kt: -------------------------------------------------------------------------------- 1 | package matrices.mosca 2 | 3 | import matrices.mosca.types.Columnas 4 | import matrices.mosca.types.Coordenada 5 | import matrices.mosca.types.Matriz 6 | import mosca.* 7 | 8 | 9 | /** 10 | * Mosca en la Matriz 11 | */ 12 | fun main() { 13 | println("Mosca Matriz") 14 | var numCasillas = 10 15 | val MOSCA = 1 16 | 17 | // pedir numero de intentos 18 | var numIntentos = getNumeroIntentos() 19 | // Pedir tamaño de Matriz 20 | numCasillas = getNumeroCasillas() 21 | 22 | val casillas = Matriz(numCasillas) { Columnas(numCasillas) } 23 | 24 | // Todas las casillas son 0 menos la de la mosca 25 | iniciarCasillas(casillas) 26 | 27 | // Situar la mosca en el vector 28 | situarMosca(casillas, MOSCA) 29 | imprimirCasillas(casillas) 30 | 31 | var estaMuerta = false 32 | var posMosca: Coordenada 33 | 34 | println("Atrapa a la Mosca") 35 | 36 | do { 37 | // Pedirle la posición donde vas a dar un tortazo 38 | posMosca = posicionGolpear(casillas) 39 | 40 | // Anlizamos el Golpeo 41 | estaMuerta = analizarGolpeo(MOSCA, casillas, posMosca) 42 | imprimirCasillas(casillas) 43 | 44 | numIntentos-- 45 | if (numIntentos > 0) { 46 | println("Te quedan $numIntentos intentos") 47 | } 48 | } while (!estaMuerta && numIntentos > 0) 49 | 50 | if (estaMuerta) 51 | println("¡Has cazado a la maldita mosca!") 52 | else 53 | println("¡Has perdido!") 54 | 55 | posMosca = buscarMosca(MOSCA, casillas) 56 | if (posMosca[0] != -1) 57 | println("La mosca está en la posición: {${posMosca[0] + 1},${posMosca[1] + 1}}") 58 | imprimirCasillas(casillas) 59 | 60 | } 61 | 62 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/matrices/mosca/mosca/MoscaSimulator.kt: -------------------------------------------------------------------------------- 1 | package mosca 2 | 3 | import matrices.mosca.types.Coordenada 4 | import matrices.mosca.types.Matriz 5 | 6 | 7 | /** 8 | * Obtiene el número de Intentos 9 | */ 10 | fun getNumeroIntentos(): Int { 11 | var intentos = 0 12 | do { 13 | println("Introduce el número de intentos máximos, mayor a 1") 14 | // Si no lo puede comveretir da null 15 | intentos = readln().toIntOrNull() ?: 0 16 | } while (intentos < 1) 17 | return intentos 18 | } 19 | 20 | fun getNumeroCasillas(): Int { 21 | var numCasillas: Int 22 | do { 23 | println("Dime el número de casillas, siempre mayor a 5") 24 | numCasillas = readln().toIntOrNull() ?: 0 25 | println("Tamaño de vector es: $numCasillas") 26 | } while (numCasillas < 5) 27 | return numCasillas 28 | } 29 | 30 | fun imprimirCasillas(casillas: Matriz) { 31 | for (fila in casillas) { 32 | print("{ ") 33 | for (columna in fila) { 34 | print("$columna ") 35 | } 36 | println("} ") 37 | } 38 | } 39 | 40 | fun iniciarCasillas(casillas: Matriz) { 41 | // i recorre todos los indices 42 | for (i in casillas.indices) { 43 | // j recorre todos los elementos de cada indice 44 | for (j in casillas.indices) { 45 | // Se inicializa el valor de cada casilla a 0 46 | casillas[i][j] = 0 47 | } 48 | } 49 | } 50 | 51 | fun getPosicion(casillas: Matriz): Int { 52 | var fila: Int 53 | do { 54 | fila = (casillas.indices).random() 55 | } while (fila < 0 || fila >= casillas.size) 56 | return fila 57 | } 58 | 59 | fun situarMosca(casillas: Matriz, mosca: Int) { 60 | val fila: Int = getPosicion(casillas) 61 | val columna: Int = getPosicion(casillas) 62 | casillas[fila][columna] = mosca 63 | } 64 | 65 | fun posicionGolpear(casillas: Matriz): Coordenada { 66 | val posMosca: Coordenada = intArrayOf(0, 0) 67 | do { 68 | println("Introduce la posición de la Fila a atacar: ") 69 | posMosca[0] = (readln().toIntOrNull() ?: 0) - 1 70 | println("La posición Fila elegida es: " + (posMosca[0] + 1)) 71 | } while (posMosca[0] < 0 || posMosca[0] >= casillas.size) 72 | do { 73 | println("Introduce la posición de la Columna a atacar: ") 74 | posMosca[1] = (readln().toIntOrNull() ?: 0) - 1 75 | println("La posición Columna elegida es: " + (posMosca[1] + 1)) 76 | } while (posMosca[1] < 0 || posMosca[1] >= casillas.size) 77 | return posMosca 78 | } 79 | 80 | fun analizarGolpeo(MOSCA: Int, casillas: Matriz, posMosca: Coordenada): Boolean { 81 | // Logica del juego 82 | // Acertamos 83 | if (casillas[posMosca[0]][posMosca[1]] == MOSCA) { 84 | return true 85 | } 86 | // Analizamos los limites 87 | for (i in -1..1) { 88 | for (j in -1..1) { 89 | if (posMosca[0] + i >= 0 90 | && posMosca[0] + i < casillas.size 91 | && posMosca[1] + j >= 0 92 | && posMosca[1] + j < casillas.size 93 | ) { 94 | if (casillas[posMosca[0] + i][posMosca[1] + j] == MOSCA) { 95 | println("¡CASI!") 96 | iniciarCasillas(casillas) 97 | situarMosca(casillas, MOSCA) 98 | return false 99 | } 100 | } 101 | } 102 | } 103 | return false 104 | } 105 | 106 | // Vamos a buscar la mosca 107 | fun buscarMosca(mosca: Int = 1, casillas: Matriz): Coordenada { 108 | for (i in casillas.indices) { 109 | for (j in casillas[i].indices) { 110 | if (casillas[i][j] == mosca) { 111 | //println("La mosca está en la posición: " + (i + 1) + "," + (j + 1)) 112 | return intArrayOf(i, j) 113 | } 114 | } 115 | } 116 | return intArrayOf(-1, -1) 117 | } 118 | 119 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-03-Kotlin/src/main/kotlin/matrices/mosca/types/Types.kt: -------------------------------------------------------------------------------- 1 | package matrices.mosca.types 2 | 3 | // TypeAlias 4 | typealias Matriz = Array 5 | typealias Columnas = IntArray 6 | typealias Coordenada = IntArray --------------------------------------------------------------------------------