├── .gitignore ├── Ejemplos ├── 01-EntradaSalida.kt ├── 02-Condicionales.kt ├── 03-Bucles.kt ├── 04-Funciones.kt ├── 05-Valor-referencia.kt ├── 05-ValorReferencia.java ├── 06-Ambito-variable.kt ├── 06-AmbitoVariables.java └── 07-Recursividad.kt ├── Ejercicios ├── Ejercicios01.pdf ├── Ejercicios02.pdf ├── Ejercicios03.pdf ├── Ejercicios04.pdf ├── Ejercicios05.pdf └── Ejercicios06.pdf ├── README.md ├── Soluciones └── Tema02-02 │ ├── .gitignore │ ├── .idea │ ├── .gitignore │ ├── inspectionProfiles │ │ └── Project_Default.xml │ ├── kotlinc.xml │ ├── libraries │ │ └── KotlinJavaRuntime.xml │ ├── misc.xml │ ├── modules.xml │ ├── prettier.xml │ └── uiDesigner.xml │ ├── Tema01-02.iml │ └── src │ └── main │ └── kotlin │ ├── Ej13.kt │ ├── Ej31.kt │ ├── Ej33.kt │ └── Ej37.kt └── images ├── parametros.gif └── recursividad.webp /.gitignore: -------------------------------------------------------------------------------- 1 | *.pptx 2 | .DS_Store 3 | upload.sh 4 | Ejercicios/*.docx 5 | UD02.pdf 6 | Apuntes 7 | Soluciones/2022-2023 8 | Ejemplos/2022-2023 9 | -------------------------------------------------------------------------------- /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 | } -------------------------------------------------------------------------------- /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 | } -------------------------------------------------------------------------------- /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 | } -------------------------------------------------------------------------------- /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 | } -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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 | } -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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/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 | } -------------------------------------------------------------------------------- /Ejercicios/Ejercicios01.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/Ejercicios/Ejercicios01.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios02.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/Ejercicios/Ejercicios02.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios03.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/Ejercicios/Ejercicios03.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios04.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/Ejercicios/Ejercicios04.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios05.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/Ejercicios/Ejercicios05.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicios06.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/Ejercicios/Ejercicios06.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Programación - 02 Programación Estructurada y Modular 2 | 3 | Tema 02 Programación Estructurada y Modular. 1DAW. Curso 2023/2024. 4 | 5 | ![imagen](https://raw.githubusercontent.com/joseluisgs/Programacion-00-2022-2023/master/images/programacion.png) 6 | 7 | 8 | - [Programación - 02 Programación Estructurada y Modular](#programación---02-programación-estructurada-y-modular) 9 | - [Contenidos](#contenidos) 10 | - [Tipos y Operaciones](#tipos-y-operaciones) 11 | - [Lenguajes tipados y no tipados](#lenguajes-tipados-y-no-tipados) 12 | - [Operaciones](#operaciones) 13 | - [Variables y constantes](#variables-y-constantes) 14 | - [Algoritmo](#algoritmo) 15 | - [Programación Estructurada](#programación-estructurada) 16 | - [Secuencias](#secuencias) 17 | - [Condicionales](#condicionales) 18 | - [Bucles](#bucles) 19 | - [Comentarios](#comentarios) 20 | - [Programación Modular](#programación-modular) 21 | - [Funciones](#funciones) 22 | - [Procedimientos](#procedimientos) 23 | - [Parámetros](#parámetros) 24 | - [Paso por valor, copia y paso por referencia](#paso-por-valor-copia-y-paso-por-referencia) 25 | - [Ámbito de variables](#ámbito-de-variables) 26 | - [Parámetros nombrados](#parámetros-nombrados) 27 | - [Parámetros opcionales o con valor por defecto](#parámetros-opcionales-o-con-valor-por-defecto) 28 | - [Parámetros variables o indeterminados](#parámetros-variables-o-indeterminados) 29 | - [Recursividad](#recursividad) 30 | - [Paquete o módulo](#paquete-o-módulo) 31 | - [Referencias](#referencias) 32 | - [Autor](#autor) 33 | - [Contacto](#contacto) 34 | - [Licencia de uso](#licencia-de-uso) 35 | 36 | ## Contenidos 37 | 1. Tipos y Operaciones 38 | 2. Constantes y Variables 39 | 3. Algoritmos 40 | 4. Programación Estructurada 41 | 5. Programación Modular 42 | 43 | ## Tipos y Operaciones 44 | Los tipos de datos nos sirven para clasificar nuestra información de entrada y salida y trabajar con ellos. Un tipo lo define en base al valor que puede almacenar y las operaciones que se pueden realizar con él. 45 | - Tipos simples: Se llama tipo de dato a una clase concreta de objetos o valores: Números, Caracter, Lógicos, etc. 46 | - Tipos compuestos: arrays, listas, etc, que los veremos más adelante. 47 | 48 | ```kotlin 49 | // Tipos de datos 50 | // Tipos simples 51 | // Números 52 | var numero: Int = 1 53 | var numero: Double = 1.0 54 | var numero: Float = 1.0f 55 | var numero: Long = 1L 56 | var numero: Short = 1 57 | var numero: Byte = 1 58 | // Caracteres 59 | var caracter: Char = 'a' 60 | // Lógicos 61 | var logico: Boolean = true 62 | // Cadenas 63 | var cadena: String = "Hola" 64 | // Tipos compuestos 65 | // Arrays 66 | var array: Array = arrayOf(1, 2, 3) 67 | var array: IntArray = intArrayOf(1, 2, 3) 68 | var array: Array = arrayOf("Hola", "Adiós") 69 | var array: Array = arrayOf(true, false) 70 | // Matrices 71 | var matriz: Array> = arrayOf(arrayOf(1, 2, 3), arrayOf(4, 5, 6)) 72 | var matriz: Array = arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, 5, 6)) 73 | ``` 74 | 75 | ### Lenguajes tipados y no tipados 76 | - Lenguajes tipados: Los lenguajes tipados son aquellos que requieren que el programador declare el tipo de dato que se va a utilizar en cada variable. En estos lenguajes, el compilador o intérprete comprueba que el tipo de dato de cada variable coincida con el tipo de dato que se ha declarado. 77 | - Lenguajes débilmente tipados y/o tipado dinámico: Los lenguajes debilmente tipados son aquellos que no requieren que el programador declare el tipo de dato que se va a utilizar en cada variable. El compilador o intérprete deduce el tipo de dato de cada variable en tiempo de ejecución. 78 | 79 | ### Operaciones 80 | - Aritméticas: +, -, *, /, %, ++, -- 81 | - Relacionales: ==, !=, >, <, >=, <= 82 | - Lógicas: &&, ||, ! 83 | - Asignación: =, +=, -=, *=, /=, %= 84 | 85 | ### Variables y constantes 86 | A la hora de almacenar datos en memoria, debemos analizar cómo vamos a utilizarlos. Si vamos a modificarlos, debemos utilizar variables, si no, debemos utilizar constantes. 87 | - Constantes: Son valores que no cambian durante la ejecución del programa. Se declaran con la palabra reservada const/val. Son inmutables. 88 | - Variables: Son valores que cambian durante la ejecución del programa. Se declaran con la palabra reservada let/var. Son mutables. 89 | 90 | Se debe aplicar código limpio y buenas prácticas de programación. para nombrarlas. 91 | 92 | ```kotlin 93 | // Constantes 94 | const val NUMERO_PI = 3.1416 95 | val NUMERO_E = 2.7182 96 | // Variables 97 | var nombreAlumno = "José Luis" 98 | var edadAlumno = 18 99 | ``` 100 | ## Algoritmo 101 | Un algoritmo es una secuencia ordenada de pasos que conducen a la solución de un problema. Tienen tres características: 102 | - Son precisos en el orden de realización de los pasos. 103 | - Están bien definidos de forma que usando un algoritmo varias veces con los mismos datos, dé la misma solución. 104 | - Son finitos, deben acabarse en algún momento. 105 | 106 | Los algoritmos deben representarse de forma independiente del lenguaje de programación que luego usaremos. 107 | 108 | Usaremos ordinogramas o diagramas de flujo para representarlos y pseudocódigo 109 | 110 | ![diagrama](https://www.economia360.org/wp-content/uploads/2020/11/simbolog%C3%ADa-600x420.jpg) 111 | 112 | ![pseudocodigo](https://i.pinimg.com/474x/ce/c0/9c/cec09c70e1076353e80e41fa74df0dc8.jpg) 113 | 114 | ## Programación Estructurada 115 | La programación estructurada es un paradigma de programación que se basa en la estructuración de los programas en tres elementos básicos: 116 | - Secuencia: Los programas se ejecutan secuencialmente, es decir, una instrucción tras otra. 117 | - Condicionales: Los programas pueden ejecutar una parte de código u otra dependiendo de una condición. 118 | - Bucles: Los programas pueden ejecutar una parte de código varias veces. 119 | 120 | ![secuencia](https://www.edix.com/es/wp-content/uploads/sites/2/2021/07/estructuras-programacion-estructurada-1024x352.jpg) 121 | 122 | ### Secuencias 123 | Las secuencias son la base de la programación estructurada. Se ejecutan una tras otra, de arriba a abajo. 124 | 125 | ```kotlin 126 | // Secuencia 127 | println("Hola") 128 | println("¿Cómo estás?") 129 | // leemos el nombre 130 | val nombre = readln() 131 | println("Encantado de conocerte $nombre") 132 | ``` 133 | ### Condicionales 134 | Los condicionales nos permiten ejecutar una parte de código u otra dependiendo de una condición. 135 | 136 | Pueden ser: 137 | - Condicionales simples: Se ejecuta una parte de código u otra dependiendo de una condición (if). La parte de código que se ejecuta se llama rama verdadera y la otra rama falsa. La parte asociada a else es opcional. 138 | 139 | ```kotlin 140 | // Condicionales simples 141 | if (edadAlumno >= 18) { 142 | println("Eres mayor de edad") 143 | } else { 144 | println("Eres menor de edad") 145 | } 146 | ``` 147 | - Condicionales múltiples: Pueden tener varios casos (if-else-if-else). Se ejecuta una parte de código u otra dependiendo de una condición. 148 | 149 | ```kotlin 150 | // Condicionales múltiples 151 | if (edadAlumno >= 18) { 152 | println("Eres mayor de edad") 153 | } else if (edadAlumno >= 16) { 154 | println("Casi eres mayor de edad") 155 | } else { 156 | println("Eres menor de edad") 157 | } 158 | ``` 159 | 160 | Tambien podemos usar switch-case o when para simplificar el if else y evitar efecto Hoduken. 161 | ```kotlin 162 | // Condicionales múltiples 163 | when (edadAlumno) { 164 | 18 -> println("Eres mayor de edad") 165 | 16 -> println("Casi eres mayor de edad") 166 | else -> println("Eres menor de edad") 167 | } 168 | ``` 169 | 170 | ### Bucles 171 | Los bucles nos permiten ejecutar una parte de código varias veces. Existen varios tipos 172 | - Indefinidos: Se ejecutan hasta que se cumple una condición (while). Se ejecuta una parte de código mientras se cumpla una condición. Si queremos que se ejecute al menos una vez, debemos usar do-while. Es importante manejar correctamente las variables que se usan en la condición (banderas o flags) para evitar bucles infinitos. 173 | 174 | ```kotlin 175 | // Bucles indefinidos 176 | // Ejemplo while 177 | var i = 0 178 | while (i < 10) { 179 | println(i) 180 | i++ 181 | } 182 | 183 | // Ejemplo do-while 184 | var i = 0 185 | do { 186 | println(i) 187 | i++ 188 | } while (i < 10) 189 | ``` 190 | 191 | ![bucle](https://preview.redd.it/6wksqjmmyw321.jpg?width=640&crop=smart&auto=webp&s=d7a1c5d72af69db7c22ec6e662ec020ff267549c) 192 | 193 | - Definidos: Se ejecutan un número determinado de veces (for) en base a un paso de iteración. Si el paso es 1 no se suele indicar. 194 | 195 | ```kotlin 196 | // Bucles definidos 197 | // Ejemplo for 198 | for (i in 0..10) { 199 | println(i) 200 | } 201 | 202 | // Con paso 2 203 | for (i in 0..10 step 2) { 204 | println(i) 205 | } 206 | 207 | // descedente 208 | for (i in 10 downTo 0) { 209 | println(i) 210 | } 211 | 212 | // Descedente con paso 3 213 | for (i in 10 downTo 0 step 3) { 214 | println(i) 215 | } 216 | ``` 217 | 218 | ### Comentarios 219 | Los comentarios son fragmentos de código que no se ejecutan. Se usan para documentar el código y explicar lo que hace. Pueden ser de una línea o de varias. 220 | 221 | ```kotlin 222 | // Comentarios 223 | // Comentario de una línea 224 | 225 | /* 226 | Comentario de varias líneas 227 | Para que los veas 228 | */ 229 | ``` 230 | 231 | ## Programación Modular 232 | La programación modular es un paradigma de programación que se basa en la modularización de los programas en funciones (y procedimientos). Las funciones son bloques de código que realizan una tarea concreta y devuelven un valor. Los procedimientos son bloques de código que realizan una tarea concreta pero no devuelven ningún valor. 233 | Las ventajas que ofrece la programación modular son: 234 | - Facilita la resolución del problema. 235 | - Aumenta la claridad y legibilidad de todo el programa. 236 | - Permite que varios programadores trabajen en el mismo proyecto. 237 | - Reduce el tiempo de desarrollo ya que se pueden reutilizar esos módulos en varios programas. 238 | - Aumenta la fiabilidad porque es más sencillo diseñar y depurar módulos y el mantenimiento en mas fácil. 239 | 240 | La descomposición modular se basa en la técnica “Divide y Vencerás” (DAC o Divide And Conquer), esta técnica tiene dos pasos: 241 | - Identificación de los subproblemas y construcción de los módulos que lo resuelven. 242 | - Combinación de los módulos para resolver el problema original. 243 | 244 | ![DAC](https://aprendiendoarduino.files.wordpress.com/2015/03/3c62c-dibujo-bmp.jpg) 245 | 246 | ### Funciones 247 | Las funciones son bloques de código que realizan una tarea concreta y devuelven un valor. 248 | 249 | ```kotlin 250 | // Funciones 251 | fun suma(a: Int, b: Int): Int { 252 | return a + b 253 | } 254 | 255 | fun main() { 256 | println(suma(2, 3)) 257 | } 258 | ``` 259 | 260 | ### Procedimientos 261 | Los procedimientos son bloques de código que realizan una tarea concreta pero no devuelven ningún valor. 262 | 263 | ```kotlin 264 | // Procedimientos 265 | fun suma(a: Int, b: Int) { 266 | println(a + b) 267 | } 268 | 269 | fun main() { 270 | suma(2, 3) 271 | } 272 | ``` 273 | 274 | ### Parámetros 275 | Los parámetros son variables que se pasan a una función o procedimiento. Con ellos podemos modificar el comportamiento de la función o procedimiento y devolver un resultado diferente. Desde el lugar donde llamamos a la función se les asigna los valores a estos parámetros 276 | 277 | ```kotlin 278 | // Parámetros son a y b 279 | fun suma(a: Int, b: Int): Int { 280 | return a + b 281 | } 282 | 283 | fun main() { 284 | // Los valores 2 y 3 se asignan a los parámetros a y b 285 | println(suma(2, 3)) 286 | } 287 | ``` 288 | ### Paso por valor, copia y paso por referencia 289 | - Paso por valor: Se crea una copia del valor del parámetro y se pasa a la función. Si se modifica el valor del parámetro dentro de la función, no se modifica el valor original. Es el modelo que hemos estado utilizando hasta ahora y significa que las variables del algoritmo principal que le pasamos al subalgoritmo, no pueden ser modificadas en su valor por dicho subalgoritmo. 290 | 291 | ```kotlin 292 | // Paso por valor 293 | fun suma(a: Int, b: Int): Int { 294 | a = a + 1 295 | return a + b 296 | } 297 | fun main() { 298 | var a = 2 299 | var b = 3 300 | println(suma(a, b)) 301 | println(a) // El valor de a no ha cambiado, porque pasa por valor 302 | } 303 | ``` 304 | - Paso por referencia: Se pasa la dirección de memoria, por lo tanto si modificamos el parámetro dentro de la función, se modifica el valor original. El parámetro del subalgoritmo, es decir, las modificaciones que sufra el parámetro, se reflejan en la variable que usamos en la llamada. En pseudocódigo reflejaremos esta situación con la palabra “Ref”. En los lenguajes actuales los tipos de datos simples pasan siempre por valor y los tipos compuestos pueden pasar por referencia. El paso por referencia se usa sobre todo cuando el subalgoritmo tiene que devolver más de un valor o trabajamos con objetos o estructuras de almacenamiento o colecciones, donde no es necesario indicar el Ref (lo veremos más adelante). OJO, en Kotlin o Java no existe Ref para indicar que un paso de parámetros se pasa por referencia, es solo una ilustración didáctica de cómo podría indicarse. Como se ha indicado *los tipos simples pasan por valor y los compuestos (arrays, colecciones u objetos) por referencia*. 305 | ```kotlin 306 | // Paso por referencia, simulamos una llamada con Ref, que no existe en todos los lenguajes 307 | fun suma(a: Ref(Int), b: Ref(Int)): Int { 308 | a = a + 1 309 | return a + b 310 | } 311 | 312 | fun sumElementosArrray(array: Array): Int { 313 | var suma = 0 314 | for (i in array) { 315 | suma += i 316 | } 317 | // Cambio un elemento del array 318 | array[0] = 100 319 | return suma 320 | } 321 | 322 | fun main() { 323 | var a = 2 324 | var b = 3 325 | println(suma(a, b)) 326 | println(a) // El valor de a ha cambiado, porque pasa por referencia 327 | 328 | var array = arrayOf(1, 2, 3, 4, 5) 329 | println(sumElementosArrray(array)) 330 | println(array[0]) // El valor del array ha cambiado, porque pasa por referencia 331 | } 332 | ``` 333 | ![Paso por valor y paso por referencia](./images/parametros.gif) 334 | 335 | ### Ámbito de variables 336 | El ámbito de una variable es el lugar donde se puede utilizar. Las variables pueden tener ámbito local o global. Las variables locales solo se pueden utilizar dentro de la función o procedimiento donde se han declarado. Las variables globales se pueden utilizar en cualquier parte del programa. 337 | Se deben intentar no abusar de las variables globales ya que pueden provocar errores en el programa. 338 | 339 | ```kotlin 340 | // Ámbito de variables 341 | fun suma(a: Int, b: Int): Int { 342 | var c = 0 // Variable local 343 | var d = 0 // Variable local 344 | return a + b 345 | } 346 | 347 | var c = 0 // Variable global 348 | fun main() { 349 | var a = 2 // Variable local 350 | var b = 3 // Variable local 351 | println(suma(a, b)) 352 | println(c) // La variable c es global y se puede utilizar en cualquier parte del programa 353 | } 354 | ``` 355 | ### Parámetros nombrados 356 | Cuando usamos parámetros nombrados, podemos pasar los parámetros en cualquier orden. Esto nos permite pasar solo los parámetros que queramos y en el orden que queramos. Para usar parámetros nombrados, debemos indicar el nombre del parámetro y el valor que le queremos asignar. De esta manera nos facilita saber cómo usarlos, al no preocuparnos del orden de llamada, manteniendo el código más limpio. 357 | 358 | ```kotlin 359 | // Parámetros nombrados 360 | fun suma(a: Int, b: Int): Int { 361 | return a + b 362 | } 363 | 364 | fun main() { 365 | println(suma(a = 2, b = 3)) 366 | println(suma(b = 3, a = 2)) 367 | println(suma(a = 2, b = 3)) 368 | } 369 | ``` 370 | 371 | ### Parámetros opcionales o con valor por defecto 372 | Los parámetros opcionales o con valor por defecto son parámetros que tienen un valor por defecto asociado. Si no se le pasa ningún valor, se usa el valor por defecto. Si se le pasa un valor, se usa el valor que se le pasa. Esto nos permite tener funciones o procedimientos con parámetros opcionales. 373 | 374 | ```kotlin 375 | // Parámetros opcionales o con valor por defecto 376 | fun suma(a: Int, b: Int = 0): Int { 377 | return a + b 378 | } 379 | 380 | fun main() { 381 | println(suma(2)) // b = 0 382 | println(suma(2, 3)) 383 | } 384 | ``` 385 | ### Parámetros variables o indeterminados 386 | Los parámetros variables o indeterminados son parámetros que pueden tener un número indeterminado de valores. Esto nos permite tener funciones o procedimientos con un número indeterminado de parámetros. Usaremos vararg para indicar que el parámetro es variable. Siempre se recomienda poner el último en la lista de parámetros de una función. Al pasarlo a la función se tratan como un array (ver tema siguiente para saber cómo usarlo) 387 | 388 | ```kotlin 389 | // Parámetros variables o indeterminados 390 | fun suma(vararg numeros: Int): Int { 391 | var suma = 0 392 | for (i in numeros) { 393 | suma += i 394 | } 395 | return suma 396 | } 397 | 398 | fun main() { 399 | println(suma(2, 3, 4, 5, 6, 7, 8, 9, 10)) 400 | println(suma(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)) 401 | println(suma(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)) 402 | } 403 | ``` 404 | 405 | El Spread Operator nos permite pasar un array como parámetro cuando se espera una lista de argumentos. Para ello, debemos anteponer el operador * al array que queremos pasar como parámetro, y lo transformará en una sucesión de parámetros. 406 | 407 | ```kotlin 408 | // Spread Operator 409 | fun suma(vararg numeros: Int): Int { 410 | var suma = 0 411 | for (i in numeros) { 412 | suma += i 413 | } 414 | return suma 415 | } 416 | 417 | fun main() { 418 | println(suma(2, 3, 4, 5, 6, 7, 8, 9, 10)) // visto antes 419 | val array = arrayOf(2, 3, 4, 5, 6, 7, 8, 9, 10) 420 | println(suma(*array)) // Spread Operator descompone un array como sucesión de parámetros 421 | } 422 | ``` 423 | 424 | ### Recursividad 425 | La recursividad es una técnica que consiste en llamar a una función o procedimiento dentro de sí mismo. La función o procedimiento se llama a sí misma hasta que se cumple una condición que hace que la función o procedimiento deje de llamarse a sí misma (condición de parada o salida). Es importante siempre mostrar la condición de parada. 426 | Muchos problemas son mucho más sencillos de resolver con recursividad que con iteración. Por ejemplo, el cálculo de un factorial es mucho más sencillo de resolver con recursividad que con iteración. 427 | 428 | ```kotlin 429 | // Recursividad factorial de un número 430 | fun factorialRec(n: Int): Int { 431 | // condición de salida o caso base 432 | if (n == 0) { 433 | return 1 434 | } else { 435 | // llamada recursiva 436 | return n * factorialRec(n - 1) 437 | } 438 | } 439 | 440 | // Iteración factorial de un número 441 | fun factorialIter(n: Int): Int { 442 | var factorial = 1 443 | for (i in 1..n) { 444 | factorial *= i 445 | } 446 | return factorial 447 | } 448 | 449 | fun main() { 450 | println(factorialRec(5)) 451 | println(factorialIter(5)) 452 | } 453 | ``` 454 | 455 | ![recursividad](images/recursividad.webp) 456 | 457 | ### Paquete o módulo 458 | Un paquete o módulo es un conjunto de funciones y procedimientos que realizan una tarea concreta. Por ejemplo, un paquete de funciones matemáticas, un paquete de funciones de entrada y salida, un paquete de funciones de gestión de arrays, etc. Usamos estos paquetes para agrupar funciones y procedimientos que realizan una tarea concreta y que podemos reutilizar en otros programas o en otras partes del mismo. Es una forma de ordenar nuestro código por funcionalidades. 459 | 460 | ```kotlin 461 | // Paquete o módulo 462 | import kotlin.math.* // importamos el paquete kotlin.math 463 | 464 | fun main() { 465 | println(sqrt(4.0)) 466 | } 467 | ``` 468 | 469 | 470 | ## Referencias 471 | - https://es.wikipedia.org/wiki/Tipo_de_dato 472 | - https://es.wikipedia.org/wiki/Programaci%C3%B3n_estructurada 473 | - https://es.wikipedia.org/wiki/Programaci%C3%B3n_modular 474 | - https://es.stackoverflow.com/questions/1493/cu%C3%A1l-es-la-diferencia-entre-paso-de-variables-por-valor-y-por-referencia 475 | - https://es.wikipedia.org/wiki/Recursi%C3%B3n 476 | 477 | ## Autor 478 | 479 | Codificado con :sparkling_heart: por [José Luis González Sánchez](https://twitter.com/JoseLuisGS_) 480 | 481 | [![Twitter](https://img.shields.io/twitter/follow/JoseLuisGS_?style=social)](https://twitter.com/JoseLuisGS_) 482 | [![GitHub](https://img.shields.io/github/followers/joseluisgs?style=social)](https://github.com/joseluisgs) 483 | [![GitHub](https://img.shields.io/github/stars/joseluisgs?style=social)](https://github.com/joseluisgs) 484 | 485 | ### Contacto 486 | 487 |

488 | Cualquier cosa que necesites házmelo saber por si puedo ayudarte 💬. 489 |

490 |

491 | 492 | 494 |    495 | 496 | 498 |    499 | 500 | 502 |    503 | 504 | 506 |    507 | 508 | 510 |    511 | 512 | 514 | 515 |

516 | 517 | ## Licencia de uso 518 | 519 | Este repositorio y todo su contenido está licenciado bajo licencia **Creative Commons**, si desea saber más, vea 520 | la [LICENSE](https://joseluisgs.dev/docs/license/). Por favor si compartes, usas o modificas este proyecto cita a su 521 | autor, y usa las mismas condiciones para su uso docente, formativo o educativo y no comercial. 522 | 523 | Licencia de Creative Commons
524 | JoseLuisGS 525 | by 526 | José Luis González Sánchez is licensed under 527 | a Creative Commons 528 | Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.
Creado a partir de la obra 529 | en https://github.com/joseluisgs. -------------------------------------------------------------------------------- /Soluciones/Tema02-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/Tema02-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/Tema02-02/.idea/inspectionProfiles/Project_Default.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | -------------------------------------------------------------------------------- /Soluciones/Tema02-02/.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | -------------------------------------------------------------------------------- /Soluciones/Tema02-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/Tema02-02/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Soluciones/Tema02-02/.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Soluciones/Tema02-02/.idea/prettier.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | -------------------------------------------------------------------------------- /Soluciones/Tema02-02/.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/Tema02-02/Tema01-02.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /Soluciones/Tema02-02/src/main/kotlin/Ej13.kt: -------------------------------------------------------------------------------- 1 | fun sumar(a: Int, b: Int): Int { 2 | return a + b 3 | } 4 | 5 | fun restar(a: Int, b: Int): Int { 6 | return a - b 7 | } 8 | 9 | fun dividir(a: Int, b: Int): Int { 10 | // While para dividir a entre b 11 | var cociente = 0 12 | var resto = a 13 | while (resto >= b) { 14 | resto -= b // resto = resto - b 15 | cociente++ // cociente = cociente + 1 16 | } 17 | return cociente 18 | } 19 | 20 | fun modulo(a: Int, b: Int): Int { 21 | // While para dividir a entre b 22 | /*var cociente = 0 23 | var resto = a 24 | while (resto >= b) { 25 | resto -= b // resto = resto - b 26 | cociente++ // cociente = cociente + 1 27 | } 28 | return resto*/ 29 | // val division = dividir(a, b) 30 | // return restar(a, multiplicar(division, b)) 31 | return restar(a, multiplicar(dividir(a, b), b)) 32 | } 33 | 34 | fun multiplicar(a: Int, b: Int): Int { 35 | // for 36 | var resultado = 0 37 | for (i in 1..b) { 38 | resultado += a 39 | } 40 | return resultado 41 | } 42 | 43 | fun potencia(a: Int, b: Int): Int { 44 | // for 45 | var resultado = 1 46 | for (i in 1..b) { 47 | // resultado *= a 48 | resultado = multiplicar(resultado, a) 49 | } 50 | return resultado 51 | } 52 | 53 | fun main() { 54 | println("Suma: ${sumar(2, 3)}") 55 | println("Resta: ${restar(2, 3)}") 56 | println("División: ${dividir(10, 3)}") 57 | println("Módulo: ${modulo(10, 3)}") 58 | println("Multiplicación: ${multiplicar(2, 3)}") 59 | println("Potencia: ${potencia(2, 3)}") 60 | } 61 | -------------------------------------------------------------------------------- /Soluciones/Tema02-02/src/main/kotlin/Ej31.kt: -------------------------------------------------------------------------------- 1 | fun esPrimo(numero: Int): Boolean { 2 | var esPrimo = true 3 | 4 | when (numero) { 5 | 0, 1 -> esPrimo = false 6 | 2 -> esPrimo = true 7 | else -> { 8 | for (i in 2..numero / 2) { 9 | if (numero % i == 0) { 10 | esPrimo = false 11 | break 12 | } 13 | } 14 | } 15 | } 16 | return esPrimo 17 | } 18 | 19 | fun esPrimoConWhile(numero: Int): Boolean { 20 | var esPrimo = true 21 | var i = 2 22 | while (i < numero && esPrimo) { 23 | if (numero % i == 0) { 24 | esPrimo = false 25 | } 26 | i++ 27 | } 28 | return esPrimo 29 | } 30 | 31 | fun listaPrimos(numero: Int) { 32 | for (i in 2..numero) { 33 | if (esPrimo(i)) { 34 | println(i) 35 | } 36 | } 37 | } 38 | 39 | fun primosGemelos(numero: Int) { 40 | for (i in 2..numero) { 41 | if (esPrimo(i) && esPrimo(i + 2)) { 42 | println("$i y ${i + 2} son primos gemelos") 43 | } 44 | } 45 | } 46 | 47 | fun main() { 48 | println("Es primo 10 ${esPrimoConWhile(10)}") 49 | println("Es primo 11 ${esPrimoConWhile(11)}") 50 | println("Es primo 10 ${esPrimo(12)}") 51 | println("Es primo 11 ${esPrimo(11)}") 52 | 53 | // println("Lista de primos hasta 100") 54 | //listaPrimos(1000) 55 | println("Lista de primos gemelos hasta 1000") 56 | primosGemelos(1000) 57 | 58 | 59 | } -------------------------------------------------------------------------------- /Soluciones/Tema02-02/src/main/kotlin/Ej33.kt: -------------------------------------------------------------------------------- 1 | fun loteria() { 2 | for (i in 1..6) { 3 | println("El número es: ${(1..49).random()}") 4 | } 5 | } 6 | 7 | fun quiniela() { 8 | for (i in 1..15) { 9 | val sorteo = (1..3).random() 10 | if (i < 15) { 11 | println("El partido $i ha salido $sorteo") 12 | } else { 13 | println("El pleno al 15 ha salido $sorteo") 14 | } 15 | } 16 | } 17 | 18 | fun main() { 19 | loteria() 20 | quiniela() 21 | } -------------------------------------------------------------------------------- /Soluciones/Tema02-02/src/main/kotlin/Ej37.kt: -------------------------------------------------------------------------------- 1 | const val MAX_INTENTOS = 5 2 | const val NUM_MIN = 1 3 | const val NUM_MAX = 10 4 | 5 | fun main() { 6 | println("El número secreto") 7 | do { 8 | val numeroSecreto = numeroSecreto(NUM_MIN, NUM_MAX) 9 | var intentos = 0 10 | var acertado = false 11 | // for (i in 1..5) { 12 | // while (!(intentos >= 5 || acertado)) { 13 | while (intentos < MAX_INTENTOS && !acertado) { 14 | intentos++ 15 | println("Introduce un número secreto: ") 16 | val miNumero = readInt() 17 | /* if (miNumero == numeroSecreto) { 18 | println("Has acertado") 19 | break 20 | } else { 21 | if (miNumero > numeroSecreto) { 22 | println("El número secreto es menor") 23 | } else { 24 | println("El número secreto es mayor") 25 | } 26 | }*/ 27 | when { 28 | miNumero == numeroSecreto -> { 29 | println("Has acertado") 30 | // break 31 | acertado = true 32 | } 33 | 34 | miNumero > numeroSecreto -> println("El número secreto es menor") 35 | else -> println("El número secreto es mayor") 36 | } 37 | } 38 | } while (salir() != "N") 39 | println("Adios") 40 | } 41 | 42 | fun salir(): String { 43 | println("¿Desea jugar? (S/N)") 44 | return readln() 45 | } 46 | 47 | fun numeroSecreto(min: Int, max: Int): Int { 48 | return (min..max).random() 49 | } 50 | 51 | 52 | fun readInt(): Int { 53 | var numero = readln().toIntOrNull() 54 | while (numero == null) { 55 | println("Introduce un número válido") 56 | numero = readln().toIntOrNull() 57 | } 58 | return numero 59 | } -------------------------------------------------------------------------------- /images/parametros.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/images/parametros.gif -------------------------------------------------------------------------------- /images/recursividad.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/joseluisgs/Programacion-02-2023-2024/2abeff675539b9caaea64ef5be928e376cb7dfdf/images/recursividad.webp --------------------------------------------------------------------------------