├── .gitignore ├── Ejercicios ├── Ejercicios01.pdf ├── Ejercicios02.pdf ├── Ejercicios03.pdf ├── Ejercicios04.pdf ├── Ejercicios05.pdf └── Ejercicios06.pdf ├── Soluciones ├── Soluciones-02-Ejercicios-Resto │ ├── src │ │ └── main │ │ │ └── kotlin │ │ │ ├── Ej-06-08.kt │ │ │ ├── Ej-99.kt │ │ │ ├── Ej-06-09.kt │ │ │ ├── Ej-17.kt │ │ │ ├── Ej-18.kt │ │ │ ├── Ej-2-23.kt │ │ │ ├── utils │ │ │ └── Entradas.kt │ │ │ ├── Ej-06-16.kt │ │ │ └── Ej-04-07.kt │ ├── .idea │ │ ├── vcs.xml │ │ ├── .gitignore │ │ ├── misc.xml │ │ ├── modules.xml │ │ ├── kotlinc.xml │ │ ├── libraries │ │ │ └── KotlinJavaRuntime.xml │ │ └── uiDesigner.xml │ ├── .gitignore │ └── Soluciones-02-Ejercicios-02.iml └── Soluciones-02-Ejercicios-02 │ ├── .idea │ ├── vcs.xml │ ├── .gitignore │ ├── misc.xml │ ├── modules.xml │ ├── kotlinc.xml │ ├── libraries │ │ └── KotlinJavaRuntime.xml │ ├── workspace-foxhound.xml │ └── uiDesigner.xml │ ├── .gitignore │ ├── src │ └── main │ │ └── kotlin │ │ ├── estructurada │ │ ├── Ej-27.kt │ │ ├── Ej-07.kt │ │ ├── Ej-01.kt │ │ ├── Ej-03.kt │ │ ├── Ej-06.kt │ │ ├── Ej-22.kt │ │ ├── Ej-18.kt │ │ ├── Ej-04.kt │ │ ├── Ej-17.kt │ │ ├── Ej-16.kt │ │ ├── Ej-13.kt │ │ └── Ej-19.kt │ │ └── modular │ │ ├── Ej-32.kt │ │ ├── Ej-31.kt │ │ ├── Ej-33.kt │ │ ├── Ej-35.kt │ │ ├── Ej-37.kt │ │ └── Ej-37-foxhound.kt │ └── Soluciones-02-Ejercicios-02.iml ├── Ejemplos ├── 06-AmbitoVariables.java ├── 06-Ambito-variable.kt ├── 01-EntradaSalida.kt ├── 07-Recursividad.kt ├── 04-Funciones.kt ├── 05-Valor-referencia.kt ├── 03-Bucles.kt ├── 05-ValorReferencia.java └── 02-Condicionales.kt └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.pptx 2 | .DS_Store 3 | upload.sh 4 | Ejercicios/*.docx 5 | UD02.pdf 6 | Apuntes 7 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicios01.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2022-2023/HEAD/Ejercicios/Ejercicios01.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios02.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2022-2023/HEAD/Ejercicios/Ejercicios02.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios03.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2022-2023/HEAD/Ejercicios/Ejercicios03.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios04.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2022-2023/HEAD/Ejercicios/Ejercicios04.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios05.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2022-2023/HEAD/Ejercicios/Ejercicios05.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios06.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2022-2023/HEAD/Ejercicios/Ejercicios06.pdf -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-06-08.kt: -------------------------------------------------------------------------------- 1 | // Función esperar 2 | 3 | 4 | fun main() { 5 | println("Antes") 6 | Thread.sleep(1000) 7 | println("Después") 8 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/.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-02-Ejercicios-Resto/.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-02-Ejercicios-02/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-99.kt: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | // Problemas de redondeo 4 | 5 | fun main(args: Array) { 6 | var i = 10.0 7 | while (i >= 0.0) { 8 | println(i) 9 | i -= 0.1 10 | } 11 | 12 | /* var j = BigDecimal("10") 13 | while (j.compareTo(BigDecimal("0")) != 0) { 14 | println(j) 15 | j = j.subtract(BigDecimal("0.1")) 16 | }*/ 17 | } 18 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/.gitignore: -------------------------------------------------------------------------------- 1 | ### IntelliJ IDEA ### 2 | out/ 3 | !**/src/main/**/out/ 4 | !**/src/test/**/out/ 5 | 6 | ### Eclipse ### 7 | .apt_generated 8 | .classpath 9 | .factorypath 10 | .project 11 | .settings 12 | .springBeans 13 | .sts4-cache 14 | bin/ 15 | !**/src/main/**/bin/ 16 | !**/src/test/**/bin/ 17 | 18 | ### NetBeans ### 19 | /nbproject/private/ 20 | /nbbuild/ 21 | /dist/ 22 | /nbdist/ 23 | /.nb-gradle/ 24 | 25 | ### VS Code ### 26 | .vscode/ 27 | 28 | ### Mac OS ### 29 | .DS_Store -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/.gitignore: -------------------------------------------------------------------------------- 1 | ### IntelliJ IDEA ### 2 | out/ 3 | !**/src/main/**/out/ 4 | !**/src/test/**/out/ 5 | 6 | ### Eclipse ### 7 | .apt_generated 8 | .classpath 9 | .factorypath 10 | .project 11 | .settings 12 | .springBeans 13 | .sts4-cache 14 | bin/ 15 | !**/src/main/**/bin/ 16 | !**/src/test/**/bin/ 17 | 18 | ### NetBeans ### 19 | /nbproject/private/ 20 | /nbbuild/ 21 | /dist/ 22 | /nbdist/ 23 | /.nb-gradle/ 24 | 25 | ### VS Code ### 26 | .vscode/ 27 | 28 | ### Mac OS ### 29 | .DS_Store -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-27.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val LIMITE: Int = 100 3 | val SALIR = "s" 4 | 5 | var salida: Boolean = false // Bandera 6 | do { 7 | println("Introd uzca un número o s para salir: ") 8 | val numero = readln() 9 | println("El número es: $numero") 10 | if (numero == SALIR || numero.toInt() > LIMITE) { 11 | salida = true 12 | } 13 | } while (!salida) 14 | 15 | println("Fin del programa") 16 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-07.kt: -------------------------------------------------------------------------------- 1 | 2 | const val PI = 3.1416 3 | 4 | fun main() { 5 | var año = 0 6 | 7 | println("Ingrese el año") 8 | año = readln().toInt() 9 | 10 | // Es bisiesto si es divisible por 4 y no por 100, o si es divisible por 400 11 | if (año % 4 == 0 && año % 100 != 0 || año % 400 == 0) { 12 | println("El año $año es bisiesto") 13 | } else { 14 | println("El año $año no es bisiesto") 15 | } 16 | 17 | 18 | println("Fin") 19 | } 20 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/modular/Ej-32.kt: -------------------------------------------------------------------------------- 1 | package modular 2 | 3 | fun main() { 4 | val numInicial = 967 5 | val numFinal = 1679 6 | 7 | cribaEratostenes(numInicial, numFinal) 8 | } 9 | 10 | fun cribaEratostenes(numInicial: Int, numFinal: Int) { 11 | println("Lista de números primos entre $numInicial y $numFinal") 12 | for (i in numInicial..numFinal) { 13 | // println("$i: ${esPrimo(i)}") 14 | when (esPrimo(i)) { 15 | true -> println("$i: primo") 16 | false -> println("$i: no primo") 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-06-09.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val a = 'a' 3 | // Valor de a es 97 4 | println(a.code) 5 | val b = 97 6 | // Valor de b en caracter es 7 | println(b.toChar()) 8 | val c = '~' 9 | // Valor de c es 126 10 | println(c.code) 11 | val d = 126 12 | // Valor de d en caracter es 13 | println(d.toChar()) 14 | 15 | val letaInicial = 67 16 | val letraFinal = 90 17 | for (i in letaInicial..letraFinal) { 18 | println(i.toChar()) 19 | } 20 | 21 | for (i in 0..255) { 22 | println(i.toChar()) 23 | } 24 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-01.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | // Variables del programa 3 | var lado = 0.0 4 | var perimetro = 0.0 5 | var superficie = 0.0 6 | 7 | do{ 8 | print("Introduce el lado: ") 9 | lado = readln().toDouble() 10 | if (lado <= 0) { 11 | println("El lado debe ser mayor que 0") 12 | } 13 | }while(lado <= 0) 14 | 15 | perimetro = lado * 4 16 | superficie = lado * lado 17 | 18 | println("El perimetro es: $perimetro") 19 | println("La superficie es: $superficie") 20 | 21 | println("Fin") 22 | } 23 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-03.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | // constantes 3 | val PI = 3.1416 4 | // Variables del programa 5 | var radio = 0.0 6 | var area = 0.0 7 | var circunferencia = 0.0 8 | 9 | do { 10 | print("Introduce el radio: ") 11 | radio = readln().toDouble() 12 | if (radio <= 0) { 13 | println("El radio debe ser mayor que 0") 14 | } 15 | } while (radio <= 0) 16 | 17 | area = PI * radio * radio 18 | circunferencia = 2 * PI * radio 19 | 20 | println("El area es: $area") 21 | println("La circunferencia es: $circunferencia") 22 | 23 | println("Fin") 24 | } 25 | -------------------------------------------------------------------------------- /Ejemplos/06-AmbitoVariables.java: -------------------------------------------------------------------------------- 1 | class AmbitoVariables { 2 | 3 | public static int c = 12; 4 | 5 | public static void main(String args[]) { 6 | int a = 0; 7 | System.out.println(a); 8 | System.out.println(c); 9 | 10 | 11 | while(a < 10) { 12 | // int a = 10; // No me deja 13 | int b = 0; 14 | b = b + 1; 15 | a = a + 1; 16 | } 17 | 18 | while(a < 20) { 19 | int b = 0; 20 | b = b + 1; 21 | a = a + 1; 22 | } 23 | 24 | int b = 0; 25 | System.out.println(b); 26 | 27 | } 28 | 29 | public static void funcion(int a) { 30 | int b = 0; 31 | System.out.println("a = " + a); 32 | System.out.println("b = " + b); 33 | } 34 | } -------------------------------------------------------------------------------- /Ejemplos/06-Ambito-variable.kt: -------------------------------------------------------------------------------- 1 | 2 | var c = 10 3 | 4 | fun main() { 5 | var a = 0 // Ambito es todo main 6 | println(a) 7 | 8 | System.exit(0) 9 | 10 | while (a<10) { 11 | var a = 23 // !! La vas a a cagar y por eso es Warning de que prestes atención!! 12 | var b = a // Ambito es el while 13 | println(b) 14 | a++ 15 | println(a) 16 | } 17 | 18 | println(a) 19 | 20 | while (a<10) { 21 | var b = a // Ambito es el while 22 | println(b) 23 | a++ 24 | println(a) 25 | } 26 | 27 | println(a) 28 | 29 | var b = 10 30 | println(b) 31 | 32 | } 33 | 34 | fun funcion(a: Int) { 35 | var b = 0 // Ambito es todo funcion 36 | println(a) 37 | println(b) 38 | } 39 | 40 | 41 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-06.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | var numero = 0.0 3 | 4 | println("Introduce el numero") 5 | numero = readln().toDouble() 6 | 7 | if (numero > 0) { 8 | // Raiz cuadrada algoritmo 9 | // var raiz = Math.sqrt(numero) // con esto no aprendemos!!! 10 | var raiz = numero 11 | var temp = 0.0 12 | while (temp != raiz) { 13 | temp = raiz 14 | raiz = (numero / raiz + raiz) / 2 15 | } 16 | println("La raiz cuadrada de $numero es $raiz") 17 | 18 | } else { 19 | println("No se puede calcular la raíz cuadrada de un número negativo") 20 | } 21 | 22 | println("Fin") 23 | } 24 | -------------------------------------------------------------------------------- /Ejemplos/01-EntradaSalida.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | // Zona de declaración de variables y constantes 3 | val MAYORIA_EDAD = 18 4 | var edad = 18 5 | var nombre = "" 6 | 7 | // Dime tu edad 8 | // println escribe y salta de linea "\n" 9 | // print escribe y no salta de linea 10 | 11 | // leemos 12 | // readln lee una linea de texto 13 | // debemos hacer el cambio de Cadena a Entero 14 | 15 | print("Dime tu nombre: ") 16 | nombre = readln() 17 | print("Dime tu edad: ") 18 | edad = readln().toInt() 19 | 20 | // Proceso 21 | if (edad >= MAYORIA_EDAD) { 22 | println("Hola $nombre, eres mayor de edad") 23 | } else { 24 | println("Hola $nombre, eres menor de edad") 25 | } 26 | 27 | println("Fin del programa") 28 | 29 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-22.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | var a = 0 3 | var b = 0 4 | 5 | do { 6 | println("Ingrese a: ") 7 | a = readln().toInt() 8 | if (a < 0) { 9 | println("El valor de a no puede ser menor o igual a 0") 10 | } 11 | } while (a <= 0) 12 | 13 | do { 14 | println("Ingrese b: ") 15 | b = readln().toInt() 16 | if (b <= 0 || b > a) { 17 | println("El valor de b no puede ser menor o igual a 0 o menor que $a") 18 | } 19 | } while (b <= 0) 20 | 21 | // Sacamos los impares en este rango 22 | for (i in a..b) { 23 | if (i % 2 != 0) { 24 | println(i) 25 | } 26 | } 27 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-17.kt: -------------------------------------------------------------------------------- 1 | // importamos lo que necesitemos 2 | import utils.continuar 3 | import utils.leerDouble 4 | 5 | 6 | fun main() { 7 | var numNotas = 0 8 | var notaAcumulada = 0.0 9 | var media = 0.0 10 | println("Nota Media") 11 | 12 | do { 13 | do { 14 | val nota = leerDouble("Ingrese la nota: ") 15 | if (nota >= 0) { 16 | notaAcumulada += nota 17 | numNotas++ 18 | } else { 19 | println("Nota inválida") 20 | } 21 | } while (nota < 0) 22 | } while (continuar("Desea ingresar mas notas? (S/N) ")) 23 | media = notaAcumulada / numNotas 24 | println("La media de $numNotas notas es $media") 25 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/modular/Ej-31.kt: -------------------------------------------------------------------------------- 1 | package modular 2 | 3 | import kotlin.math.sqrt 4 | 5 | fun main() { 6 | val num = 13841 7 | 8 | val res = esPrimo(num) 9 | println("¿¡El número $num es primo?: $res") 10 | } 11 | 12 | 13 | fun esPrimo(num: Int): Boolean { 14 | // Early return, descartamos al principio los casos que no son primos 15 | // De esta manera ahorramos if elses anidados 16 | if (num < 2) { 17 | return false 18 | } 19 | if (num == 2) { 20 | return true 21 | } 22 | if (num % 2 == 0) { 23 | return false 24 | } 25 | for (i in 3..sqrt(num.toDouble()).toInt() step 2) { 26 | if (num % i == 0) { 27 | return false 28 | } 29 | } 30 | return true 31 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/modular/Ej-33.kt: -------------------------------------------------------------------------------- 1 | package modular 2 | 3 | fun main() { 4 | imprimirNumerosLoteria(6) 5 | } 6 | 7 | fun imprimirNumerosLoteria(maxNumeros: Int) { 8 | val NUM_MIN = 1 9 | val NUM_MAX = 49 10 | for (i in 1..maxNumeros) { 11 | println("Número $i: ${generarNumeroLoteria(NUM_MIN, NUM_MAX)}") 12 | } 13 | } 14 | 15 | /** 16 | * Genera un número aleatorio entre min y max 17 | * @param numMin Número mínimo 18 | * @param numMax Número máximo 19 | * @return Número aleatorio entre numMin y numMax 20 | */ 21 | fun generarNumeroLoteria(numMin: Int, numMax: Int): Int { 22 | // usando Math.random() y Math.floor() 23 | // Es como se debe hacer en java 24 | // return Math.floor(Math.random() * (numMax - numMin + 1) + numMin).toInt() 25 | return (numMin until numMax).random() 26 | } 27 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-18.kt: -------------------------------------------------------------------------------- 1 | // importamos lo que necesitemos 2 | import utils.continuar 3 | import utils.leerDouble 4 | 5 | 6 | fun main() { 7 | var numAprobados = 0 8 | var numSuspensos = 0 9 | println("Contador de alumnos") 10 | 11 | do { 12 | do { 13 | val nota = leerDouble("Ingrese la nota del alumno: ") 14 | if (nota in 0.0..10.0) { 15 | if (nota >= 5) { 16 | numAprobados++ 17 | } else { 18 | numSuspensos++ 19 | } 20 | } else { 21 | println("Nota inválida") 22 | } 23 | } while (nota !in 0.0..10.0) 24 | } while (continuar("Desea ingresar mas alumnos? (S/N) ")) 25 | println("Hay $numAprobados aprobados y $numSuspensos suspensos") 26 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-2-23.kt: -------------------------------------------------------------------------------- 1 | // Experimento con factorial 2 | 3 | fun main() { 4 | val num = 20L 5 | 6 | val iniT = System.nanoTime() 7 | val res = factorialIterativo(num) 8 | val finT = System.nanoTime() 9 | println("Iterativo: $res, tiempo: ${finT - iniT} ns") 10 | 11 | val iniT2 = System.nanoTime() 12 | val res2 = factorialRecursivo(num) 13 | val finT2 = System.nanoTime() 14 | println("Recursivo: $res2, tiempo: ${finT2 - iniT2} ns") 15 | 16 | } 17 | 18 | fun factorialIterativo(num: Long): Long { 19 | var res = 1L 20 | for (i in 1..num) { 21 | res *= i 22 | } 23 | return res 24 | } 25 | 26 | fun factorialRecursivo(num: Long): Long { 27 | return if (num == 1L) { 28 | 1L 29 | } else { 30 | num * factorialRecursivo(num - 1L) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/Soluciones-02-Ejercicios-02.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/Soluciones-02-Ejercicios-02.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-18.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val PRECIO_KM = 2.5 3 | val ESTANCIA_MAX = 7 4 | val DISTANCIA_MAX = 800 5 | val REBAJA = 0.7 6 | var precio = 0.0 7 | var distancia = 0.0 8 | var estancia = 0 9 | 10 | do { 11 | println("Ingrese la distancia: ") 12 | distancia = readln().toDouble() 13 | if (distancia < 0) { 14 | println("La distancia no puede ser menor a 0") 15 | } 16 | } while (distancia < 0) 17 | 18 | do { 19 | println("Ingrese la estancia: ") 20 | estancia = readln().toInt() 21 | if (estancia < 0) { 22 | println("La estancia no puede ser menor a 0") 23 | } 24 | } while (estancia < 0) 25 | 26 | precio = distancia * PRECIO_KM 27 | 28 | if (estancia > ESTANCIA_MAX && distancia > DISTANCIA_MAX) { 29 | precio *= REBAJA 30 | } 31 | 32 | println("Precio: $precio") 33 | } -------------------------------------------------------------------------------- /Ejemplos/07-Recursividad.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | var res = factorialIterativo(5) 3 | println(res) 4 | res = factorialRecursivo(5) 5 | println(res) 6 | 7 | res = fibonacciIterativo(5) 8 | println(res) 9 | res = fibonacciRecursivo(5) 10 | println(res) 11 | } 12 | 13 | fun factorialIterativo(num: Int): Int { 14 | var res = 1 15 | for (i in 1..num) { 16 | res *= i 17 | } 18 | return res 19 | } 20 | 21 | fun factorialRecursivo(num: Int): Int { 22 | if (num == 1) { 23 | return 1 24 | } 25 | return num * factorialRecursivo(num - 1) 26 | } 27 | 28 | fun fibonacciIterativo(num: Int): Int { 29 | var a = 0 30 | var b = 1 31 | var c = 0 32 | for (i in 1..num-1) { 33 | c = a + b 34 | a = b 35 | b = c 36 | } 37 | return c 38 | } 39 | 40 | fun fibonacciRecursivo(num: Int): Int { 41 | if (num == 1 || num == 2) { 42 | return 1 43 | } 44 | return fibonacciRecursivo(num - 1) + fibonacciRecursivo(num - 2) 45 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-04.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | var numero01 = 14.0 3 | var numero02 = 126.0 4 | var numero03 = 9.0 5 | var media = 0.0 6 | var mediaRedondeada = 0 7 | var mediaRedondeadaDosDecimales = 0.0 8 | 9 | println("Introduce el primer número") 10 | numero01 = readln().toDouble() 11 | println("Introduce el segundo número") 12 | numero02 = readln().toDouble() 13 | println("Introduce el tercer número") 14 | numero03 = readln().toDouble() 15 | 16 | media = (numero01 + numero02 + numero03) / 3 17 | var entera = media.toInt() 18 | var decimal = media - entera 19 | mediaRedondeadaDosDecimales = ((media * 100).toInt() / 100.0) 20 | 21 | 22 | if (decimal >= 0.5) { 23 | mediaRedondeada = entera + 1 24 | } else { 25 | mediaRedondeada = entera 26 | } 27 | 28 | 29 | println("La media es $media") 30 | println("La media redondeada es $mediaRedondeada") 31 | println("La media redondeada a dos decimales es $mediaRedondeadaDosDecimales") 32 | 33 | println("Fin") 34 | } 35 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-17.kt: -------------------------------------------------------------------------------- 1 | import kotlin.math.sqrt 2 | 3 | 4 | fun main() { 5 | var a = 0.0 6 | var b = 0.0 7 | var c = 0.0 8 | var discriminante = 0.0 9 | 10 | do { 11 | println("Ingrese a: ") 12 | a = readln().toDouble() 13 | 14 | } while (a == 0.0) 15 | 16 | do { 17 | println("Ingrese b: ") 18 | b = readln().toDouble() 19 | } while (b == 0.0) 20 | 21 | do { 22 | println("Ingrese c: ") 23 | c = readln().toDouble() 24 | } while (c == 0.0) 25 | 26 | // Calculamos el discriminante 27 | discriminante = b * b - 4 * a * c 28 | 29 | when { 30 | discriminante > 0.0 -> { 31 | println("dos soluciones reales") 32 | val raiz = sqrt(discriminante) 33 | val cociente = 2 * a 34 | val sol1 = (-b + raiz) / cociente 35 | val sol2 = (-b - raiz) / cociente 36 | println("Solución 1: $sol1") 37 | println("Solución 2: $sol2") 38 | } 39 | 40 | discriminante == 0.0 -> { 41 | println("una solución real") 42 | val sol = -b / (2 * a) 43 | println("Solución: $sol") 44 | } 45 | 46 | else -> println("no tiene solución real") 47 | } 48 | 49 | } -------------------------------------------------------------------------------- /Ejemplos/04-Funciones.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa o función principal 3 | * Siempre tiene que existir al menos 1 4 | */ 5 | fun main(){ 6 | // Procedimiento 7 | presentacion("Numeros Pares o Impares") 8 | 9 | do { 10 | // Función para leer un numero entero 11 | val numero = readInt("Ingrese un numero: ") 12 | 13 | // Función 14 | var res = isPar(numero) 15 | 16 | when (res) { 17 | true -> println("El numero $numero es par") 18 | false -> println("El numero $numero es impar") 19 | } 20 | 21 | // Función 22 | val continuar = continuar("Deseas continuar?") 23 | 24 | } while (continuar) 25 | 26 | } 27 | 28 | /** 29 | * Función que devuelve si un numer es par o impar 30 | */ 31 | fun isPar(numero: Int): Boolean { 32 | // var res = false 33 | // if (numero % 2 == 0) { 34 | // res = true 35 | // } else { 36 | // res = false 37 | // } 38 | // return res 39 | return numero % 2 == 0 40 | } 41 | 42 | /** 43 | * Función que indica si queremos continuar o no 44 | */ 45 | fun continuar(mensaje: String): Boolean { 46 | print("$mensaje (s/n): ") 47 | val continuar = readln() 48 | return continuar == "s" 49 | } 50 | 51 | fun presentacion(mensaje: String): Unit { 52 | println(mensaje) 53 | } 54 | 55 | fun readInt(mensaje: String): Int { 56 | print(mensaje) 57 | return readln().toInt() 58 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-16.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | var horas = 0 3 | var minutos = 0 4 | var segundos = 0 5 | 6 | do { 7 | println("Ingrese las horas: ") 8 | horas = readln().toInt() 9 | if (horas < 0 || horas > 23) { 10 | println("Las horas no pueden ser menor a 0 o mayor a 23") 11 | } 12 | } while (horas < 0 || horas > 23) 13 | 14 | do { 15 | println("Ingrese las minutos: ") 16 | minutos = readln().toInt() 17 | if (minutos < 0 || minutos > 59) { 18 | println("Los minutos no pueden ser menor a 0 o mayor a 59") 19 | } 20 | } while (minutos < 0 || minutos > 59) 21 | 22 | do { 23 | println("Ingrese las segundos: ") 24 | segundos = readln().toInt() 25 | if (segundos < 0 || segundos > 59) { 26 | println("Los segundos no pueden ser menor a 0 o mayor a 59") 27 | } 28 | } while (segundos < 0 || segundos > 59) 29 | 30 | segundos++ // segundos = segundos + 1 // segundos += 1 31 | if (segundos == 60) { 32 | segundos = 0 33 | minutos++ 34 | if (minutos == 60) { 35 | minutos = 0 36 | horas++ 37 | if (horas == 24) { 38 | horas = 0 39 | } 40 | } 41 | } 42 | 43 | println("La hora es $horas:$minutos:$segundos") 44 | 45 | } -------------------------------------------------------------------------------- /Ejemplos/05-Valor-referencia.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Programa o función principal 3 | * Siempre tiene que existir al menos 1 4 | */ 5 | fun main(){ 6 | // Procedimiento 7 | var num1 = 10 8 | var num2 = 20 9 | var res = sumar(num1, num2) 10 | println("1.- La suma de $num1 + $num2 = $res") 11 | 12 | res = sumar(10, 20) 13 | println("2.- La suma es: $res") 14 | 15 | val numero = 10 16 | res = pasoValor(numero) 17 | println("3.- paso por valor: $res") 18 | 19 | val numeros = intArrayOf(10) 20 | println(numeros[0]) 21 | res = pasoReferencia(numeros) 22 | println("3.- paso por valor: $res") 23 | println(numeros[0]) 24 | 25 | } 26 | 27 | fun sumar(a: Int, b: Int): Int{ 28 | println("Funcion sumar") 29 | println("a: $a") 30 | println("b: $b") 31 | return a + b 32 | } 33 | 34 | fun pasoValor(num: Int): Int { 35 | println("Paso valor") 36 | //return num * 2 37 | // val res = num * 2 38 | // return num 39 | // No se puede hacer porque se bloquea por el compilador de Kotlin 40 | // Al ser un paso por valor 41 | // num = num * 2 42 | // return num 43 | 44 | // Esto sí deja, si queremos modificar el valor debemos copiarlo a una variable local 45 | // val res = num * 2 46 | // return res 47 | 48 | // Esto también 49 | return num * 2 50 | } 51 | 52 | fun pasoReferencia(num: IntArray): Int { 53 | println("Paso referencia") 54 | num[0] = num[0] + 2 55 | return num[0] 56 | } 57 | 58 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/modular/Ej-35.kt: -------------------------------------------------------------------------------- 1 | package modular 2 | 3 | fun main() { 4 | var numAciertos = 0 5 | var numRondas = 0 6 | println("Juego de las apuestas") 7 | do { 8 | numRondas++ 9 | val secreto = valorAleatorio() 10 | val apuesta = leerValor("Ingrese su apuesta (1,X,2): ") 11 | 12 | if (secreto == apuesta) { 13 | println("Ganaste, el resultado era $secreto") 14 | numAciertos++ 15 | } else { 16 | println("Perdiste, el resultado era $secreto") 17 | } 18 | } while (continuar("¿Desea seguir jugando? s/n: ")) 19 | 20 | println("Ha acertado $numAciertos veces en $numRondas rondas") 21 | 22 | } 23 | 24 | /** 25 | * Genera un valor aleatorio entre 1 y 2 26 | * @param mensaje Mensaje a mostrar 27 | * @return Verdadero si es "S" o "s", falso en caso contrario 28 | */ 29 | fun continuar(mensaje: String): Boolean { 30 | print(mensaje) 31 | val respuesta = readln() 32 | return respuesta == "s" || respuesta == "S" 33 | } 34 | 35 | fun leerValor(mensaje: String): String { 36 | print(mensaje) 37 | return readln().uppercase() 38 | } 39 | 40 | /** 41 | * Genera un valor aleatorio entre 1, X y 2 42 | * @return Valor aleatorio: 1, X o 2 43 | */ 44 | fun valorAleatorio(): String { 45 | return when ((1..3).random()) { 46 | 1 -> "1" 47 | 2 -> "X" 48 | else -> "2" 49 | } 50 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/utils/Entradas.kt: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | // Funciones de utilidad para resolver los ejercicios 4 | 5 | /** 6 | * Lee un double por consola 7 | * @param mensaje Mensaje que se muestra al usuario 8 | * @return double leido 9 | */ 10 | fun leerDouble(mensaje: String): Double { 11 | do { 12 | print(mensaje) 13 | val entrada = readln().toDoubleOrNull() 14 | if (entrada != null) { 15 | return entrada // --> Me hace escapar del bucle 16 | } else { 17 | println("Entrada inválida. No es un Double") 18 | } 19 | } while (true) // Parezco infinito pero hay un return!! 20 | } 21 | 22 | fun leerEntero(mensaje: String): Int { 23 | do { 24 | print(mensaje) 25 | val entrada = readln().toIntOrNull() 26 | if (entrada != null) { 27 | return entrada // --> Me hace escapar del bucle 28 | } else { 29 | println("Entrada inválida. No es un Int") 30 | } 31 | } while (true) // Parezco infinito pero hay un return!! 32 | } 33 | 34 | fun continuar(mensaje: String): Boolean { 35 | do { 36 | print(mensaje) 37 | val entrada = readln() 38 | when (entrada) { 39 | "S", "s" -> return true 40 | "N", "n" -> return false 41 | else -> println("Entrada inválida. Debe ingresar S o N") 42 | } 43 | } while (true) // Parezco infinito pero hay un return!! 44 | } -------------------------------------------------------------------------------- /Ejemplos/03-Bucles.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | var tecla = "" 3 | var secreto ="a" 4 | var intentos = 0 5 | 6 | print("Adivina la tecla: ") 7 | tecla = readln() 8 | intentos = intentos + 1 9 | 10 | // Soy un bucle indefinido (while), me repito mienytras se cumpla la condicion 11 | while(tecla != secreto) { 12 | println("Has pulsa la tecla $tecla") 13 | intentos = intentos + 1 14 | print("Adivina la tecla: ") 15 | tecla = readln() 16 | } 17 | 18 | println("Has acertado en $intentos intentos que la tecla es $secreto") 19 | 20 | // Para no repetir lo de pedir las letras usamos do-while (indefinido) 21 | 22 | intentos = 0 23 | secreto = "b" 24 | do { 25 | print("Adivina la tecla: ") 26 | tecla = readln() 27 | println("Has pulsa la tecla $tecla") 28 | intentos = intentos + 1 29 | } while(tecla != secreto) 30 | 31 | println("Has acertado en $intentos intentos que la tecla es $secreto") 32 | 33 | // Bucle definido, indico las veces que se repite 34 | println("Bucle definido de 1 a 10") 35 | for (i in 1..10) { 36 | println("El valor de i es $i") 37 | } 38 | 39 | println("Bucle definido de 10 a 1") 40 | for (i in 10 downTo 1) { 41 | println("El valor de i es $i") 42 | } 43 | println("Bucle definido de 1 a 10 de 2 en 2") 44 | for (i in 1..10 step 2) { 45 | println("El valor de i es $i") 46 | } 47 | println("Bucle definido de 10 a 1 de 2 en 2") 48 | for (i in 10 downTo 1 step 2) { 49 | println("El valor de i es $i") 50 | } 51 | 52 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-13.kt: -------------------------------------------------------------------------------- 1 | // Mutiplicación y división entera en base a sumas y restas 2 | 3 | fun main() { 4 | var a = 0 5 | var b = 0 6 | 7 | do { 8 | println("Ingrese el primer número: ") 9 | a = readln().toInt() 10 | if (a < 0) { 11 | println("El primer número no puede ser menor a 0") 12 | } 13 | } while (a <= 0) 14 | 15 | do { 16 | println("Ingrese el segundo número: ") 17 | b = readln().toInt() 18 | /*if (b <= 0) { 19 | println("El segundo número no puede ser menor o igual a 0") 20 | } else {if (b > a) { 21 | println("El segundo número no puede ser mayor al primero")*/ 22 | when { 23 | b <= 0 -> println("El segundo número no puede ser menor o igual a 0") 24 | b > a -> println("El segundo número no puede ser mayor al primero") 25 | } 26 | } while (b <= 0 || b > a) 27 | 28 | // La multiplicacio es un bucle definido de sumas 29 | var i = 0 30 | var resultado = 0 31 | while (i < b) { 32 | resultado += a 33 | i++ 34 | } 35 | // Mejor con un for 36 | resultado = 0 37 | for (i in 1..b) { 38 | resultado += a 39 | } 40 | println("$a * $b = $resultado") 41 | 42 | // División conciente y resto en base a restas y bucle while 43 | var cociente = 0 44 | var resto = a 45 | while (resto >= b) { 46 | resto -= b 47 | cociente++ 48 | } 49 | println("$a / $b = $cociente, resto $resto") 50 | 51 | 52 | } -------------------------------------------------------------------------------- /Ejemplos/05-ValorReferencia.java: -------------------------------------------------------------------------------- 1 | class ValorReferencia { 2 | 3 | public static void main(String[] args) { 4 | int num1 = 10; 5 | int num2 = 20; 6 | 7 | int res = sumar(num1, num2); 8 | 9 | System.out.println("El resultado de la suma " + num1 + " + " + num2 + " = " + res); 10 | int numero = 10; 11 | res = pasoValor(numero); 12 | System.out.println("3.- paso por valor: " + res); 13 | System.out.println(numero); 14 | 15 | int[] numeros = new int[1]; 16 | numeros[0] = 10; 17 | System.out.println(numeros[0]); 18 | res = pasoReferencia(numeros); 19 | System.out.println("3.- paso por valor: " + res); 20 | System.out.println(numeros[0]); 21 | } 22 | 23 | public static int sumar(int a, int b) { 24 | a = 200; 25 | System.out.println("Funcion sumar"); 26 | System.out.println("a: " + a); 27 | System.out.println("b: " + b); 28 | return a + b; 29 | } 30 | 31 | public static int pasoValor(int num) { 32 | System.out.println("Paso valor"); 33 | // int res = num * 2; 34 | // return res; 35 | 36 | // num = num * 2; 37 | // return num; 38 | 39 | // Esto sí deja, si queremos modificar el valor debemos copiarlo a una variable local 40 | // val res = num * 2 41 | // return res 42 | 43 | // Esto también 44 | return num * 2; 45 | } 46 | 47 | public static int pasoReferencia(int[] num) { 48 | System.out.println("Paso referencia"); 49 | num[0] = num[0] + 2; 50 | return num[0]; 51 | } 52 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-06-16.kt: -------------------------------------------------------------------------------- 1 | import utils.continuar 2 | 3 | fun main() { 4 | var puntosJugador = 0 5 | var puntosOrdenador = 0 6 | 7 | println("Bienvenido/a al juego de los dados") 8 | 9 | do { 10 | puntosJugador += tirarJugador() 11 | puntosOrdenador += tirarOrdenador() 12 | 13 | } while (continuar("¿Desea continuar? (S/N): ")) 14 | 15 | // Escribir resultados 16 | mostrarResultados(puntosJugador, puntosOrdenador) 17 | 18 | } 19 | 20 | fun tirarOrdenador(): Int { 21 | var resultado = 0 22 | // Repetimos tres veces 23 | for (i in 1..3) { 24 | // Tiramos el dado 25 | val dado = tirarDado("Ordenador", i) 26 | // Mostramos el resultado 27 | // println("Dado $i: $dado") 28 | // Acumulamos el resultado 29 | resultado += dado 30 | } 31 | return resultado 32 | } 33 | 34 | fun tirarJugador(): Int { 35 | var resultado = 0 36 | // Repetimos tres veces 37 | for (i in 1..3) { 38 | // Tiramos el dado 39 | val dado = tirarDado("Jugador", i) 40 | // Mostramos el resultado 41 | println("Dado $i: $dado") 42 | // Acumulamos el resultado 43 | resultado += dado 44 | } 45 | return resultado 46 | } 47 | 48 | fun tirarDado(jugador: String, turno: Int): Int { 49 | println("Dado $jugador en turno $turno") 50 | return (1..6).random() 51 | } 52 | 53 | private fun mostrarResultados(puntosJugador: Int, puntosOrdenador: Int) { 54 | println("Resultados finales:") 55 | println("Puntos del jugador: $puntosJugador") 56 | println("Puntos del ordenador: $puntosOrdenador") 57 | if (puntosJugador > puntosOrdenador) { 58 | println("Ha ganado el jugador") 59 | } else if (puntosJugador < puntosOrdenador) { 60 | println("Ha ganado el ordenador") 61 | } else { 62 | println("Ha habido un empate") 63 | } 64 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/.idea/libraries/KotlinJavaRuntime.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 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/.idea/libraries/KotlinJavaRuntime.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 | -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/estructurada/Ej-19.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val TARIFA_DIURNA = 20 3 | val TARIFA_NOCTURNA = 30 4 | val INCREMENTO_DOMINGO_DIURNO = 10 5 | val INCREMENTO_DOMINGO_NOCTURNO = 15 6 | 7 | var dia = "" 8 | var numeroHoras = 0 9 | var turno = "" 10 | 11 | var salario = 0.0 12 | 13 | do { 14 | println("Ingrese el día: ") 15 | dia = readln() 16 | if (dia != "lunes" && dia != "martes" && dia != "miercoles" && dia != "jueves" && dia != "viernes" && dia != "sabado" && dia != "domingo") { 17 | println("El día no es válido") 18 | } 19 | } while (dia != "lunes" && dia != "martes" && dia != "miercoles" && dia != "jueves" && dia != "viernes" && dia != "sabado" && dia != "domingo") 20 | 21 | do { 22 | println("Ingrese el numero de horas: ") 23 | numeroHoras = readln().toInt() 24 | if (numeroHoras <= 0) { 25 | println("El numero de horas no puede ser menor a o igual 0") 26 | } 27 | } while (numeroHoras <= 0) 28 | 29 | do { 30 | println("Ingrese el turno: ") 31 | turno = readln() 32 | if (turno != "diurno" && turno != "nocturno") { 33 | println("El turno no es válido") 34 | } 35 | } while (turno != "diurno" && turno != "nocturno") 36 | 37 | when (turno) { 38 | "diurno" -> { 39 | when (dia) { 40 | "domingo" -> salario = numeroHoras * (TARIFA_DIURNA + INCREMENTO_DOMINGO_DIURNO).toDouble() 41 | else -> salario = (numeroHoras * TARIFA_DIURNA).toDouble() 42 | } 43 | } 44 | 45 | "nocturno" -> { 46 | when (dia) { 47 | "domingo" -> salario = (numeroHoras * (TARIFA_NOCTURNA + INCREMENTO_DOMINGO_NOCTURNO)).toDouble() 48 | else -> salario = (numeroHoras * TARIFA_NOCTURNA).toDouble() 49 | } 50 | } 51 | } 52 | 53 | println("Salario: $salario") 54 | 55 | // Repetimos con if anidados 56 | if (turno == "diurno") { 57 | if (dia == "domingo") { 58 | salario = numeroHoras * (TARIFA_DIURNA + INCREMENTO_DOMINGO_DIURNO).toDouble() 59 | } else { 60 | salario = (numeroHoras * TARIFA_DIURNA).toDouble() 61 | } 62 | } else { 63 | if (dia == "domingo") { 64 | salario = (numeroHoras * (TARIFA_NOCTURNA + INCREMENTO_DOMINGO_NOCTURNO)).toDouble() 65 | } else { 66 | salario = (numeroHoras * TARIFA_NOCTURNA).toDouble() 67 | } 68 | } 69 | } -------------------------------------------------------------------------------- /Ejemplos/02-Condicionales.kt: -------------------------------------------------------------------------------- 1 | fun main() { 2 | val APROBADO = 5.0 3 | val NOTABLE = 7.0 4 | val SOBRESALIENTE = 9.0 5 | val MAYORIA_EDAD = 18 6 | 7 | 8 | var calificacion = 0.0 9 | var nombre = "" 10 | var edad = 0 11 | 12 | print("Introduce tu nombre: ") 13 | nombre = readln() 14 | print("Dime tu edad: ") 15 | edad = readln().toInt() 16 | 17 | // Condicional simple 18 | if (edad >= MAYORIA_EDAD) { 19 | println("Hola $nombre, eres mayor de edad") 20 | } else { 21 | println("Hola $nombre, eres menor de edad") 22 | } 23 | 24 | 25 | print("Introduce tu calificación: ") 26 | calificacion = readln().toDouble() 27 | 28 | println("Hola $nombre, tu calificación es $calificacion") 29 | 30 | // Condicional múltiple 31 | // Modo if-else-if-else-if-else-if-else-if-else-if-else 32 | if (calificacion < APROBADO) { 33 | println("Has suspendido") 34 | } else if (calificacion < NOTABLE) { 35 | println("Has aprobado") 36 | } else if (calificacion < SOBRESALIENTE) { 37 | println("Has sacado un notable") 38 | } else { 39 | println("Has sacado un sobresaliente") 40 | } 41 | 42 | if (calificacion= APROBADO && calificacion < NOTABLE) { 59 | println("Has aprobado") 60 | } else if (calificacion >= NOTABLE && calificacion < SOBRESALIENTE) { 61 | println("Has sacado un notable") 62 | } else { 63 | println("Has sacado un sobresaliente") 64 | } 65 | 66 | if (calificacion= APROBADO) { 69 | if (calificacion < NOTABLE) { 70 | println("Has aprobado") 71 | } else if (calificacion >= NOTABLE) { 72 | if (calificacion < SOBRESALIENTE) { 73 | println("Has sacado un notable") 74 | } else { 75 | println("Has sacado un sobresaliente") 76 | } 77 | } 78 | } 79 | 80 | // Condicional multiple con when 81 | when{ 82 | calificacion < 0 || calificacion > 10 -> println("Calificación incorrecta") 83 | calificacion < APROBADO -> println("Has suspendido") 84 | calificacion >= APROBADO && calificacion < NOTABLE -> println("Has aprobado") 85 | calificacion >= NOTABLE && calificacion < SOBRESALIENTE -> println("Has sacado un notable") 86 | calificacion >= SOBRESALIENTE -> println("Has sacado un sobresaliente") 87 | else -> println("Calificación incorrecta") 88 | } 89 | 90 | println("Fin") 91 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/modular/Ej-37.kt: -------------------------------------------------------------------------------- 1 | package modular 2 | 3 | fun main() { 4 | var numIntentos = 0 5 | val MAX_INTENTOS = 5 6 | val NUM_MAX = 100 7 | val NUM_MIN = 1 8 | 9 | do { 10 | val secreto = numeroAleatorio(NUM_MIN, NUM_MAX) 11 | var acertado = false 12 | numIntentos = 0 13 | do { 14 | numIntentos++ 15 | val apuesta = leerEnteroIntervalo("Ingrese su apuesta ($NUM_MIN, $NUM_MAX): ", NUM_MIN, NUM_MAX) 16 | if (secreto == apuesta) { 17 | println("Has acertado, el número es $secreto") 18 | acertado = true 19 | } else if (secreto < apuesta) { 20 | println("El número es menor que $apuesta") 21 | } else { 22 | println("El número es mayor que $apuesta") 23 | } 24 | } while (numIntentos < MAX_INTENTOS && !acertado) 25 | 26 | if (!acertado) { 27 | println("Has agotado los $MAX_INTENTOS intentos. El número era $secreto") 28 | } else { 29 | println("Has acertado en $numIntentos intentos. El número era $secreto") 30 | } 31 | 32 | } while (continuarPartida("¿Desea seguir jugando? s/n: ")) 33 | 34 | } 35 | 36 | /* 37 | Usamos Try Catch cuando podemos tener una excepcioón, es decir un error en tiempo de ejecución 38 | En este caso la excepción se produce cuando no puede realizar el paso de una cadena a entero 39 | Solo debemos usarlo si creemos que va a existir una execpción porque es costoso manejarlo 40 | Porque en el fondo estamos dejando que el programa "explote" para luego corregirlo 41 | 42 | Esta esl a forma de Java 43 | 44 | fun leerEnteroIntervalo(mensaje: String, numMin: Int, numMax: Int): Int { 45 | var num = 0 46 | var correcto = false 47 | do { 48 | print(mensaje) 49 | // num = readln().toIntOrNull() ?: 0 50 | try { 51 | num = readln().toInt() 52 | correcto = true 53 | } catch (e: NumberFormatException) { 54 | System.err.println(e.message) 55 | correcto = false 56 | } 57 | } while (num < numMin || num > numMax) 58 | return num 59 | }*/ 60 | 61 | /** 62 | * Unsando los nulos 63 | */ 64 | 65 | fun leerEnteroIntervalo(mensaje: String, numMin: Int, numMax: Int): Int { 66 | var num: Int? 67 | do { 68 | print(mensaje) 69 | num = readln().toIntOrNull() 70 | if (num == null) println("No has metido un número") 71 | } while (num !in numMin..numMax) 72 | return num!! 73 | } 74 | 75 | /* 76 | En kotlin tenemos el operador elvis que si el casting falla al intentarlo usando su varianete orNull 77 | devuelve un valor por defecto que nos sirve para usarlo. 78 | */ 79 | /*fun leerEnteroIntervalo(mensaje: String, numMin: Int, numMax: Int): Int { 80 | var num: Int = 0 81 | do { 82 | print(mensaje) 83 | num = readln().toIntOrNull() ?: 0 84 | } while (num !in numMin..numMax) 85 | return num!! 86 | } 87 | */ 88 | 89 | 90 | fun numeroAleatorio(numMin: Int, numMax: Int): Int { 91 | return (numMin..numMax).random() 92 | } 93 | 94 | private fun continuarPartida(mensaje: String): Boolean { 95 | print(mensaje) 96 | val respuesta = readln() 97 | return respuesta == "s" || respuesta == "S" 98 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/src/main/kotlin/modular/Ej-37-foxhound.kt: -------------------------------------------------------------------------------- 1 | package modular 2 | 3 | fun main() { 4 | var numIntentos = 0 5 | val MAX_INTENTOS = 5 6 | val NUM_MAX = 100 7 | val NUM_MIN = 1 8 | 9 | do { 10 | val secreto = numeroAleatorio(NUM_MIN, NUM_MAX) 11 | var acertado = false 12 | numIntentos = 0 13 | do { 14 | numIntentos++ 15 | val apuesta = leerEnteroIntervalo("Ingrese su apuesta ($NUM_MIN, $NUM_MAX): ", NUM_MIN, NUM_MAX) 16 | if (secreto == apuesta) { 17 | println("Has acertado, el número es $secreto") 18 | acertado = true 19 | } else if (secreto < apuesta) { 20 | println("El número es menor que $apuesta") 21 | } else { 22 | println("El número es mayor que $apuesta") 23 | } 24 | } while (numIntentos < MAX_INTENTOS && !acertado) 25 | 26 | if (!acertado) { 27 | println("Has agotado los $MAX_INTENTOS intentos. El número era $secreto") 28 | } else { 29 | println("Has acertado en $numIntentos intentos. El número era $secreto") 30 | } 31 | 32 | } while (continuarPartida("¿Desea seguir jugando? s/n: ")) 33 | 34 | } 35 | 36 | /* 37 | Usamos Try Catch cuando podemos tener una excepcioón, es decir un error en tiempo de ejecución 38 | En este caso la excepción se produce cuando no puede realizar el paso de una cadena a entero 39 | Solo debemos usarlo si creemos que va a existir una execpción porque es costoso manejarlo 40 | Porque en el fondo estamos dejando que el programa "explote" para luego corregirlo 41 | 42 | Esta esl a forma de Java 43 | 44 | fun leerEnteroIntervalo(mensaje: String, numMin: Int, numMax: Int): Int { 45 | var num = 0 46 | var correcto = false 47 | do { 48 | print(mensaje) 49 | // num = readln().toIntOrNull() ?: 0 50 | try { 51 | num = readln().toInt() 52 | correcto = true 53 | } catch (e: NumberFormatException) { 54 | System.err.println(e.message) 55 | correcto = false 56 | } 57 | } while (num < numMin || num > numMax) 58 | return num 59 | }*/ 60 | 61 | /** 62 | * Unsando los nulos 63 | */ 64 | 65 | fun leerEnteroIntervalo(mensaje: String, numMin: Int, numMax: Int): Int { 66 | var num: Int? 67 | do { 68 | print(mensaje) 69 | num = readln().toIntOrNull() 70 | if (num == null) println("No has metido un número") 71 | } while (num !in numMin..numMax) 72 | return num!! 73 | } 74 | 75 | /* 76 | En kotlin tenemos el operador elvis que si el casting falla al intentarlo usando su varianete orNull 77 | devuelve un valor por defecto que nos sirve para usarlo. 78 | */ 79 | /*fun leerEnteroIntervalo(mensaje: String, numMin: Int, numMax: Int): Int { 80 | var num: Int = 0 81 | do { 82 | print(mensaje) 83 | num = readln().toIntOrNull() ?: 0 84 | } while (num !in numMin..numMax) 85 | return num!! 86 | } 87 | */ 88 | 89 | 90 | fun numeroAleatorio(numMin: Int, numMax: Int): Int { 91 | return (numMin..numMax).random() 92 | } 93 | 94 | private fun continuarPartida(mensaje: String): Boolean { 95 | print(mensaje) 96 | val respuesta = readln() 97 | return respuesta == "s" || respuesta == "S" 98 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-Resto/src/main/kotlin/Ej-04-07.kt: -------------------------------------------------------------------------------- 1 | // Constantes del programa 2 | const val TARIFA_DIURNA = 20 3 | const val TARIFA_NOCTURNA = 30 4 | const val INCREMENTO_DOMINGO_DIURNO = 10 5 | const val INCREMENTO_DOMINGO_NOCTURNO = 15 6 | 7 | fun main() { 8 | var dia = "" 9 | var numeroHoras = 0 10 | var turno = "" 11 | var salario = 0.0 12 | 13 | // Entrada de informacion 14 | dia = leerDia() 15 | numeroHoras = leerHoras() 16 | turno = leerTurno() 17 | 18 | // Procesamiento de informacion 19 | salario = calcularSalario(turno, dia, numeroHoras) 20 | 21 | // Salida de la información 22 | salidaSalario(salario, turno, dia, numeroHoras) 23 | } 24 | 25 | private fun salidaSalario(salario: Double, turno: String, dia: String, numeroHoras: Int) { 26 | var salario1 = salario 27 | println("Salario: $salario1") 28 | 29 | // Repetimos con if anidados 30 | if (turno == "diurno") { 31 | if (dia == "domingo") { 32 | salario1 = numeroHoras * (TARIFA_DIURNA + INCREMENTO_DOMINGO_DIURNO).toDouble() 33 | } else { 34 | salario1 = (numeroHoras * TARIFA_DIURNA).toDouble() 35 | } 36 | } else { 37 | if (dia == "domingo") { 38 | salario1 = (numeroHoras * (TARIFA_NOCTURNA + INCREMENTO_DOMINGO_NOCTURNO)).toDouble() 39 | } else { 40 | salario1 = (numeroHoras * TARIFA_NOCTURNA).toDouble() 41 | } 42 | } 43 | } 44 | 45 | private fun calcularSalario( 46 | turno: String, 47 | dia: String, 48 | numeroHoras: Int 49 | ): Double { 50 | var salario = 0.0 51 | when (turno) { 52 | "diurno" -> { 53 | when (dia) { 54 | "domingo" -> salario = numeroHoras * (TARIFA_DIURNA + INCREMENTO_DOMINGO_DIURNO).toDouble() 55 | else -> salario = (numeroHoras * TARIFA_DIURNA).toDouble() 56 | } 57 | } 58 | 59 | "nocturno" -> { 60 | when (dia) { 61 | "domingo" -> salario = (numeroHoras * (TARIFA_NOCTURNA + INCREMENTO_DOMINGO_NOCTURNO)).toDouble() 62 | else -> salario = (numeroHoras * TARIFA_NOCTURNA).toDouble() 63 | } 64 | } 65 | } 66 | return salario 67 | } 68 | 69 | private fun leerTurno(): String { 70 | var turno = "" 71 | do { 72 | println("Ingrese el turno: ") 73 | turno = readln() 74 | if (turno != "diurno" && turno != "nocturno") { 75 | println("El turno no es válido") 76 | } 77 | } while (turno != "diurno" && turno != "nocturno") 78 | return turno 79 | } 80 | 81 | private fun leerHoras(): Int { 82 | var numeroHoras = 0 83 | do { 84 | println("Ingrese el numero de horas: ") 85 | numeroHoras = readln().toInt() 86 | if (numeroHoras <= 0) { 87 | println("El numero de horas no puede ser menor a o igual 0") 88 | } 89 | } while (numeroHoras <= 0) 90 | return numeroHoras 91 | } 92 | 93 | private fun leerDia(): String { 94 | var dia = "" 95 | do { 96 | println("Ingrese el día: ") 97 | dia = readln() 98 | if (dia != "lunes" && dia != "martes" && dia != "miercoles" && dia != "jueves" && dia != "viernes" && dia != "sabado" && dia != "domingo") { 99 | println("El día no es válido") 100 | } 101 | } while (dia != "lunes" && dia != "martes" && dia != "miercoles" && dia != "jueves" && dia != "viernes" && dia != "sabado" && dia != "domingo") 102 | return dia 103 | } -------------------------------------------------------------------------------- /Soluciones/Soluciones-02-Ejercicios-02/.idea/workspace-foxhound.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 | 36 | 37 | 38 | 39 | 40 | 45 | 46 | 47 | 49 | 50 | 52 | 53 | 55 | 56 | 58 | 59 | 60 | 61 | 66 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 94 | 95 | 101 | 102 | 108 | 109 | 115 | 116 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 1664181421515 137 | 145 | 146 | 147 | 148 | 150 | 151 | 160 | 161 | 162 | 163 |