Solución reto #50 en Swift

README.md

@@ -82,8 +82,7 @@ Tienes toda la información extendida sobre los retos de programación semanales
 * **#47** - 21/11/22 - [`VOCAL MÁS COMÚN`](https://github.com/mouredev/Weekly-Challenge-2022-Swift/blob/main/WeeklyChallenge2022.playground/Pages/Challenge47.xcplaygroundpage/Contents.swift)
 * **#48** - 28/11/22 - [`EL CALENDARIO DE ADEVIENTO 2022`](https://github.com/mouredev/Weekly-Challenge-2022-Swift/blob/main/WeeklyChallenge2022.playground/Pages/Challenge48.xcplaygroundpage/Contents.swift)
 * **#49** - 05/12/22 - [`EL DETECTOR DE HANDLES`](https://github.com/mouredev/Weekly-Challenge-2022-Swift/blob/main/WeeklyChallenge2022.playground/Pages/Challenge49.xcplaygroundpage/Contents.swift)
-* **#50** - 12/12/22 - [`LA ENCRIPTACIÓN DE KARACA`](https://github.com/mouredev/Weekly-Challenge-2022-Swift/blob/main/WeeklyChallenge2022.playground/Pages/Challenge50.xcplaygroundpage/Contents.swift)
-* **#51** - 19/12/22 - `Publicación nuevo reto...`
+* **#50** - 12/12/22 - `Publicación nuevo reto...`
 
 <a href="https://youtu.be/ydH_B5KuqGs"><img src="http://i3.ytimg.com/vi/ydH_B5KuqGs/maxresdefault.jpg" style="height: 50%; width:50%;"/></a>
 
@@ -161,4 +160,4 @@ Soy ingeniero de software desde hace más de 12 años. Desde hace 4 años combin
 
 ### En mi perfil de GitHub tienes más información
 
-[![Web](https://img.shields.io/badge/GitHub-MoureDev-14a1f0?style=for-the-badge&logo=github&logoColor=white&labelColor=101010)](https://github.com/mouredev)
+[![Web](https://img.shields.io/badge/GitHub-MoureDev-14a1f0?style=for-the-badge&logo=github&logoColor=white&labelColor=101010)](https://github.com/mouredev)

WeeklyChallenge2022.playground/Pages/Challange4.jaimefere.xcplaygroundpage/Contents.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+/*
+ * Reto #4
+ * ÁREA DE UN POLÍGONO
+ * Fecha publicación enunciado: 24/01/22
+ * Fecha publicación resolución: 31/01/22
+ * Dificultad: FÁCIL
+ *
+ * Enunciado: Crea UNA ÚNICA FUNCIÓN (importante que sólo sea una) que sea capaz de calcular y retornar el área de un polígono.
+ * - La función recibirá por parámetro sólo UN polígono a la vez.
+ * - Los polígonos soportados serán Triángulo, Cuadrado y Rectángulo.
+ * - Imprime el cálculo del área de un polígono de cada tipo.
+ *
+ * Información adicional:
+ * - Usa el canal de nuestro discord (https://mouredev.com/discord) "🔁reto-semanal" para preguntas, dudas o prestar ayuda la acomunidad.
+ * - Puedes hacer un Fork del repo y una Pull Request al repo original para que veamos tu solución aportada.
+ * - Revisaré el ejercicio en directo desde Twitch el lunes siguiente al de su publicación.
+ * - Subiré una posible solución al ejercicio el lunes siguiente al de su publicación.
+ *
+ */
+
+struct Polygon {
+    private var hasFourVertices: Bool
+    private var sideA: Double
+    private var sideB: Double
+    private var sideC: Double
+
+    init(hasFourVertices:Bool, sideA: Double, sideB: Double = 0.0, sideC: Double = 0.0) {
+        self.hasFourVertices = hasFourVertices
+        self.sideA = sideA
+        self.sideB = (sideB == 0.0) ? sideA : sideB
+        self.sideC = (sideC == 0.0) ? self.sideB : sideC
+    }
+
+    func getArea() -> Double {
+        if(hasFourVertices) {
+            return sideA * sideB
+        } else {
+            let semiperimeter = (sideA + sideB + sideC) / 2.0
+            return sqrt(semiperimeter * (semiperimeter - sideA) * (semiperimeter - sideB) * (semiperimeter - sideC))
+        }
+    }
+}
+
+print(Polygon.init(hasFourVertices: true, sideA: 4).getArea())
+print(Polygon.init(hasFourVertices: true, sideA: 7, sideB: 4).getArea())
+print(Polygon.init(hasFourVertices: false, sideA: 3, sideB: 4, sideC: 5).getArea())
+print(Polygon.init(hasFourVertices: false, sideA: 3, sideB: 4).getArea())   // isosceles
+print(Polygon.init(hasFourVertices: false, sideA: 3).getArea())             // equilateral

WeeklyChallenge2022.playground/Pages/Challenge0.jaimefere.xcplaygroundpage/Contents.swift

@@ -0,0 +1,32 @@
+import Foundation
+
+/*
+ * Reto #0
+ * EL FAMOSO "FIZZ BUZZ"
+ * Fecha publicación enunciado: 27/12/21
+ * Fecha publicación resolución: 03/01/22
+ * Dificultad: FÁCIL
+ *
+ * Enunciado: Escribe un programa que muestre por consola (con un print) los números de 1 a 100 (ambos incluidos y con un salto de línea entre cada impresión), sustituyendo los siguientes:
+ * - Múltiplos de 3 por la palabra "fizz".
+ * - Múltiplos de 5 por la palabra "buzz".
+ * - Múltiplos de 3 y de 5 a la vez por la palabra "fizzbuzz".
+ *
+ * Información adicional:
+ * - Usa el canal de nuestro discord (https://mouredev.com/discord) "🗓reto-semanal" para preguntas, dudas o prestar ayuda la acomunidad.
+ * - Puedes hacer un Fork del repo y una Pull Request al repo original para que veamos tu solución aportada.
+ * - Revisaré el ejercicio en directo desde Twitch el lunes siguiente al de su publicación.
+ * - Subiré una posible solución al ejercicio el lunes siguiente al de su publicación.
+ *
+ */
+//let startTime = NSDate()
+(1...100).forEach { num in
+    if(num % 5 == 0) {
+        print("\(num % 3 == 0 ? "fizz" : "")buzz")
+    } else if(num % 3 == 0) {
+        print("fizz")
+    } else {
+        print(num)
+    }
+}
+//print("execution time: \(NSDate().timeIntervalSince(startTime as Date) * 1000) ms")

WeeklyChallenge2022.playground/Pages/Challenge0.openai.xcplaygroundpage/Contents.swift

@@ -0,0 +1,35 @@
+import Foundation
+
+/*
+ * Reto #0
+ * EL FAMOSO "FIZZ BUZZ"
+ * Fecha publicación enunciado: 27/12/21
+ * Fecha publicación resolución: 03/01/22
+ * Dificultad: FÁCIL
+ *
+ * Enunciado: Escribe un programa en Swift que muestre por consola (con un print) los números de 1 a 100 (ambos incluidos y con un salto de línea entre cada impresión), sustituyendo los siguientes:
+ * - Múltiplos de 3 por la palabra "fizz".
+ * - Múltiplos de 5 por la palabra "buzz".
+ * - Múltiplos de 3 y de 5 a la vez por la palabra "fizzbuzz".
+ *
+ * Resuelto: Sí
+ " Iteracciones: 1
+ * Explicación: El código utiliza un bucle for para recorrer los números del 1 al 100. Para cada número, se comprueba si es múltiplo de 3 y de 5, de 3 o de 5, y se imprime el número sustituido por la palabra correspondiente, o bien se imprime el número sin modificar si no es múltiplo de ninguno de los dos números.
+ *
+ */
+
+for number in 1...100 {
+    if number % 3 == 0 && number % 5 == 0 {
+        // El número es múltiplo de 3 y de 5
+        print("fizzbuzz")
+    } else if number % 3 == 0 {
+        // El número es múltiplo de 3
+        print("fizz")
+    } else if number % 5 == 0 {
+        // El número es múltiplo de 5
+        print("buzz")
+    } else {
+        // El número no es múltiplo ni de 3 ni de 5
+        print(number)
+    }
+}

WeeklyChallenge2022.playground/Pages/Challenge1.jaimefere.xcplaygroundpage/Contents.swift

@@ -0,0 +1,37 @@
+import Foundation
+
+/*
+ * Reto #1
+ * ¿ES UN ANAGRAMA?
+ * Fecha publicación enunciado: 03/01/22
+ * Fecha publicación resolución: 10/01/22
+ * Dificultad: MEDIA
+ *
+ * Enunciado: Escribe una función que reciba dos palabras (String) y retorne verdadero o falso (Bool) según sean o no anagramas.
+ * Un Anagrama consiste en formar una palabra reordenando TODAS las letras de otra palabra inicial.
+ * NO hace falta comprobar que ambas palabras existan.
+ * Dos palabras exactamente iguales no son anagrama.
+ *
+ * Información adicional:
+ * - Usa el canal de nuestro discord (https://mouredev.com/discord) "🔁reto-semanal" para preguntas, dudas o prestar ayuda la acomunidad.
+ * - Puedes hacer un Fork del repo y una Pull Request al repo original para que veamos tu solución aportada.
+ * - Revisaré el ejercicio en directo desde Twitch el lunes siguiente al de su publicación.
+ * - Subiré una posible solución al ejercicio el lunes siguiente al de su publicación.
+ *
+ */
+
+func areAnagrams(wordA: String, wordB: String) -> Bool {
+    return wordA.count == wordB.count && (wordA.lowercased().enumerated().filter { (index, c) in
+        String(c) == String(Array(wordB)[index]).lowercased() ||  // que cumpla que TODAS las letras están en otra posición (reordenadas)
+        wordA.split(separator: c).count != wordB.split(separator: c).count
+    }.isEmpty)
+}
+
+print(areAnagrams(wordA: "Roma", wordB: ""))
+print(areAnagrams(wordA: "Roma", wordB: "Roma"))
+print(areAnagrams(wordA: "Roma", wordB: "romana"))
+print(areAnagrams(wordA: "Roma", wordB: "Peru"))
+print(areAnagrams(wordA: "Roma", wordB: "ramo"))
+print(areAnagrams(wordA: "Roma", wordB: "mora"))
+print(areAnagrams(wordA: "Roma", wordB: "moar"))
+print(areAnagrams(wordA: "Roma", wordB: "amor"))

WeeklyChallenge2022.playground/Pages/Challenge1.openai.xcplaygroundpage/Contents.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+/*
+ * Reto #1
+ * ¿ES UN ANAGRAMA?
+ * Fecha publicación enunciado: 03/01/22
+ * Fecha publicación resolución: 10/01/22
+ * Dificultad: MEDIA
+ *
+ * Enunciado: Escribe una función en Swift que reciba dos palabras (String) y retorne verdadero o falso (Bool) según sean o no anagramas.
+ * - Un Anagrama consiste en formar una palabra reordenando TODAS las letras de otra palabra inicial.
+ * - NO hace falta comprobar que ambas palabras existan.
+ * - Dos palabras exactamente iguales no son anagrama.
+ *
+ * Resuelto: No, en los casos en los que debe devolver falso a veces devuelve true.
+ * Explicación: Para resolver este problema, podríamos utilizar un diccionario para contar la cantidad de ocurrencias de cada letra en cada palabra. Luego, comparar los dos diccionarios para ver si son iguales. Si lo son, entonces las palabras son anagramas.
+ * Nota: no exige poner el nombre de los parámetros de la función. Utiliza tabulación de 2 espacios.
+ *
+ */
+
+func esAnagrama(_ palabra1: String, _ palabra2: String) -> Bool {
+  // Primero, convertimos las palabras a minúsculas
+  let palabra1 = palabra1.lowercased()
+  let palabra2 = palabra2.lowercased()
+
+  // Creamos un diccionario vacío para contar las ocurrencias de cada letra
+  var contador1 = [Character: Int]()
+  var contador2 = [Character: Int]()
+
+  // Recorremos las dos palabras y contamos las ocurrencias de cada letra
+  for letra in palabra1 {
+    contador1[letra, default: 0] += 1
+  }
+  for letra in palabra2 {
+    contador2[letra, default: 0] += 1
+  }
+
+  // Comparamos los diccionarios para ver si son iguales
+  return contador1 == contador2
+}
+
+// ChatGPT
+// Debería devolver verdadero
+esAnagrama("casa", "acas")
+// Debería devolver falso
+esAnagrama("casa", "casa")
+esAnagrama("casa", "saca")
+esAnagrama("casa", "baso")
+
+// Brais
+print(esAnagrama("amor", "roma"))
+
+// Jaime
+print(esAnagrama("Roma", ""))
+print(esAnagrama("Roma", "Roma"))
+print(esAnagrama("Roma", "romana"))
+print(esAnagrama("Roma", "Peru"))
+print(esAnagrama("Roma", "ramo"))
+print(esAnagrama("Roma", "mora"))
+print(esAnagrama("Roma", "moar"))
+print(esAnagrama("Roma", "amor"))
+
+
+

WeeklyChallenge2022.playground/Pages/Challenge10.jaimefere.xcplaygroundpage/Contents.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+/*
+ * Reto #10
+ * EXPRESIONES EQUILIBRADAS
+ * Fecha publicación enunciado: 07/03/22
+ * Fecha publicación resolución: 14/03/22
+ * Dificultad: MEDIA
+ *
+ * Enunciado: Crea un programa que comprueba si los paréntesis, llaves y corchetes de una expresión están equilibrados.
+ * - Equilibrado significa que estos delimitadores se abren y cieran en orden y de forma correcta.
+ * - Paréntesis, llaves y corchetes son igual de prioritarios. No hay uno más importante que otro.
+ * - Expresión balanceada: { [ a * ( c + d ) ] - 5 }
+ * - Expresión no balanceada: { a * ( c + d ) ] - 5 }
+ *
+ * Información adicional:
+ * - Usa el canal de nuestro discord (https://mouredev.com/discord) "🔁reto-semanal" para preguntas, dudas o prestar ayuda a la comunidad.
+ * - Puedes hacer un Fork del repo y una Pull Request al repo original para que veamos tu solución aportada.
+ * - Revisaré el ejercicio en directo desde Twitch el lunes siguiente al de su publicación.
+ * - Subiré una posible solución al ejercicio el lunes siguiente al de su publicación.
+ *
+ */
+
+func isBalanced(expression: String) -> Bool {
+    let openBrackets = ["{","(","["]
+    let closeBrackets = ["}",")","]"]
+    let onlyBrackets = expression.filter{ openBrackets.contains(String($0)) || closeBrackets.contains(String($0)) }
+
+    if(onlyBrackets.count == 2) {
+        return (onlyBrackets == "{}" || onlyBrackets == "()" || onlyBrackets == "[]")
+    } else {
+        let firstCloseBracketIndex = onlyBrackets.firstIndex(where: { closeBrackets.contains(String($0)) } )
+        if(firstCloseBracketIndex == nil || onlyBrackets[...firstCloseBracketIndex!].count < 2) {
+            return false
+        } else {
+            let currentCouple = String(onlyBrackets[onlyBrackets.index(firstCloseBracketIndex!, offsetBy: -1)..<onlyBrackets.index(firstCloseBracketIndex!, offsetBy: 1)])
+            let prevExpression = String(onlyBrackets[..<onlyBrackets.index(firstCloseBracketIndex!, offsetBy: -1)])
+            let restExpression = String(onlyBrackets[onlyBrackets.index(firstCloseBracketIndex!, offsetBy: 1)..<onlyBrackets.endIndex])
+            return isBalanced(expression: currentCouple) && isBalanced(expression: "\(prevExpression)\(restExpression)")
+        }
+    }
+}
+
+let balancedExpressions = ["{ [ a * ( c + d ) ] - 5 }", "[()]{}{[()()]()}", "{[{}{}]}[()]", "{{}{}}", "[]{}()"]
+balancedExpressions.forEach { exp in
+    print("\(exp) \(!isBalanced(expression: exp) ? "NO " : "")está balanceada")
+}
+print()
+let notBalancedExpressions = ["{ a * ( c + d ) ] - 5 }", "[(])", "{()}[)", "{(})", "{"]
+notBalancedExpressions.forEach { exp in
+    print("\(exp) \(!isBalanced(expression: exp) ? "NO " : "")está balanceada")
+}

WeeklyChallenge2022.playground/Pages/Challenge10.openai.xcplaygroundpage/Contents.swift

@@ -0,0 +1,80 @@
+import Foundation
+
+/*
+ * Reto #10
+ * EXPRESIONES EQUILIBRADAS
+ * Fecha publicación enunciado: 07/03/22
+ * Fecha publicación resolución: 14/03/22
+ * Dificultad: MEDIA
+ *
+ * Enunciado: Crea un programa en Swift que comprueba si los paréntesis, llaves y corchetes de una expresión están equilibrados.
+ * - Equilibrado significa que estos delimitadores se abren y cieran en orden y de forma correcta.
+ * - Paréntesis, llaves y corchetes son igual de prioritarios. No hay uno más importante que otro.
+ * - Expresión balanceada: { [ a * ( c + d ) ] - 5 }
+ * - Expresión no balanceada: { a * ( c + d ) ] - 5 }
+ *
+ * Resuelto: Sí
+ " Iteracciones: 1
+ * Explicación: Para resolver este problema, podemos utilizar una pila, un tipo de dato que nos permite agregar elementos en un orden determinado y recuperarlos en orden inverso.
+ Para comprobar si los delimitadores de una expresión están equilibrados, podemos iterar sobre cada carácter de la expresión y hacer lo siguiente:
+ Si el carácter es un delimitador de apertura, lo agregamos a la pila.
+ Si el carácter es un delimitador de cierre, verificamos si el último elemento de la pila es el delimitador de apertura correspondiente. Si lo es, eliminamos el elemento de la pila. Si no lo es, la expresión no está equilibrada.
+ Al finalizar la iteración, si la pila está vacía, significa que todos los delimitadores de apertura y cierre se encuentran en pares y en orden correcto, por lo que la expresión está equilibrada. Si la pila no está vacía, significa que hay delimitadores de apertura que no tienen su correspondiente delimitador de cierre, por lo que la expresión no está equilibrada.
+ *
+ */
+
+// Crea un diccionario de caracteres para los delimitadores abiertos y cerrados
+let delimiters = ["{": "}", "[": "]", "(": ")"]
+
+// Función para verificar si la expresión es equilibrada
+func isBalanced(_ expression: String) -> Bool {
+    // Crea una pila para guardar los delimitadores abiertos
+    var stack = [String]()
+
+    // Itera sobre cada caracter en la expresión
+    for character in expression {
+        // Si el caracter es un delimitador abierto, agrégalo a la pila
+        if delimiters.keys.contains(String(character)) {
+            stack.append(String(character))
+        }
+        // Si el caracter es un delimitador cerrado, comprueba si se corresponde con el último delimitador abierto en la pila
+        else if delimiters.values.contains(String(character)) {
+            // Si la pila está vacía o el último delimitador abierto no se corresponde con el delimitador cerrado, la expresión no es equilibrada
+            if stack.isEmpty || delimiters[stack.last!] != String(character) {
+                return false
+            }
+            // Si el delimitador cerrado se corresponde con el último delimitador abierto en la pila, elimina el delimitador abierto de la pila
+            stack.removeLast()
+        }
+    }
+
+    // Si la pila está vacía al final de la iteración, significa que todos los delimitadores abiertos fueron cerrados en orden y de forma correcta, por lo que la expresión es equilibrada
+    return stack.isEmpty
+}
+
+// Ejemplos de expresiones equilibradas
+print(isBalanced("{ [ a * ( c + d ) ] - 5 }"))
+print(isBalanced("[ 1 + 2 ] + { 3 - 4 }"))
+
+// Brais cases
+print(isBalanced("{a + b [c] * (2x2)}}}}"))               // false
+print(isBalanced("{ [ a * ( c + d ) ] - 5 }"))            // true
+print(isBalanced("{ a * ( c + d ) ] - 5 }"))              // false
+print(isBalanced("{a^4 + (((ax4)}"))                      // false
+print(isBalanced("{ ] a * ( c + d ) + ( 2 - 3 )[ - 5 }")) // false
+print(isBalanced("{{{{{{(}}}}}}"))                        // false
+print(isBalanced("(a"))                                   // false
+
+// Jaime cases
+print(isBalanced("{ [ a * ( c + d ) ] - 5 }"))    // true
+print(isBalanced("[()]{}{[()()]()}"))             // true
+print(isBalanced("{[{}{}]}[()]"))                 // true
+print(isBalanced("{{}{}}"))                       // true
+print(isBalanced("[]{}()"))                       // true
+print(isBalanced("a+2"))                          // true
+print(isBalanced("{ a * ( c + d ) ] - 5 }"))      // false
+print(isBalanced("{()}[)"))                       // false
+print(isBalanced("[(])"))                         // false
+print(isBalanced("{(})"))                         // false
+print(isBalanced("{"))                            // false
+

WeeklyChallenge2022.playground/Pages/Challenge10.xcplaygroundpage/Contents.swift

@@ -47,6 +47,7 @@ func isBalanced(expression: String) -> Bool {
             }
         }
     }
+}
 
     return stack.isEmpty
 }