diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Amonsalve.java" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Amonsalve.java" new file mode 100644 index 0000000000..0b412d3ff4 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Amonsalve.java" @@ -0,0 +1,21 @@ +package com.mycompany.amonsalve; + +public class Amonsalve { + + public static void main(String[] args) { + int numero=100; + for(int i=1;i<=numero;i++){ + if(i%3 == 0 && i%5 == 0){ + System.out.println("fizzbuzz"); + } + else if(i%3 == 0){ + System.out.println("fizz"); + } + else if(i%5 == 0){ + System.out.println("buzz"); + }else{ + System.out.println(i); + } + } + } +} diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/dPenedo.js" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/dPenedo.js" new file mode 100644 index 0000000000..8510e28832 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/dPenedo.js" @@ -0,0 +1,33 @@ +// / +// 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". +// + +function isMultiple(number, divider){ + return number % divider == 0 +} + + +function printNumbers(number){ + const listNumber = number + for (let index = 1; index <= listNumber; index++) { + const multipleOf3 = isMultiple(index, 3) + const multipleOf5 = isMultiple(index, 5) + if (multipleOf3 && multipleOf5){ + console.log("fizzbuzz") + }else if(multipleOf3){ + console.log("fizz") + }else if(multipleOf5){ + console.log("buzz") + } + else{ + console.log(index) + } + } +} + +printNumbers(100) \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/patriciotrujilllo.js" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/patriciotrujilllo.js" new file mode 100644 index 0000000000..0284b5056e --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/patriciotrujilllo.js" @@ -0,0 +1,26 @@ +/* + * 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". + */ + +function fizzBuzz() { + for (let i = 1; i <= 100; i++) { + if (i % 5 === 0 && i % 3 === 0) { + console.log('fizzbuzz') + } + else if (i % 5 === 0) { + console.log('buzz') + } + else if (i % 3 === 0) { + console.log('fizz') + } + else { + console.log(i) + } + } +} +fizzBuzz() \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/MThem97.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/MThem97.py" new file mode 100644 index 0000000000..582180a7c2 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/MThem97.py" @@ -0,0 +1,15 @@ + +r=range(1,101) +for number in r: + if number % 5==0 and number % 3==0: + print('fizzbuzz') + if number % 3==0: + print('fizz') + if number % 5==0: + print('buzz') + else: + print(number) + + + + diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/dPenedo.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/dPenedo.py" index edcd5c6b29..58437a4510 100644 --- "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/dPenedo.py" +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/dPenedo.py" @@ -20,4 +20,5 @@ def es_multiplo(numero, divisor): print("fizz") elif multiplo_de_5: print("buzz") - print(i) + else: + print(i) diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/jaimegamm.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/jaimegamm.py" new file mode 100644 index 0000000000..dd8a0f8e27 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/jaimegamm.py" @@ -0,0 +1,17 @@ + +# * 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". + +for numero in range(1, 101): + if numero % 3 == 0 and numero % 5 == 0: + print(f"fizzbuzz {numero}") + elif numero % 3 == 0: + print(f"fizz {numero}") + elif numero % 5 == 0: + print(f"buzz {numero}") + else: + print(numero) \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/ruby/mauricionc.rb" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/ruby/mauricionc.rb" new file mode 100644 index 0000000000..b71d6ad726 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/ruby/mauricionc.rb" @@ -0,0 +1,11 @@ +(1..100).each do |n| + if n % 3 == 0 && n % 5 == 0 + puts "fizzbuzz" + elsif n % 3 == 0 + puts "fizz" + elsif n % 5 == 0 + puts "buzz" + else + puts n + end +end diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/rust/blackriper.rs" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/rust/blackriper.rs" new file mode 100644 index 0000000000..fd127bc153 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/rust/blackriper.rs" @@ -0,0 +1,15 @@ +fn bizz_fuzz() { + for i in 1..=100 { + if i % 3 == 0 && i % 5 == 0 { + println!("fizzbuzz"); + } else if i % 3 == 0 { + println!("fizz"); + } else if i % 5 == 0 { + println!("buzz"); + } + } +} + +fn main() { + bizz_fuzz(); +} diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/scala/avelasquezhe84.scala" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/scala/avelasquezhe84.scala" new file mode 100644 index 0000000000..99e3795b06 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/scala/avelasquezhe84.scala" @@ -0,0 +1,9 @@ +// Scala 3 + +@main def fizzbuzz() = + (1 to 100).foreach(i => + if i % 15 == 0 then println("fizzbuzz") + else if i % 3 == 0 then println("fizz") + else if i % 5 == 0 then println("buzz") + else println(i) + ) diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..31c70ab037 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,19 @@ +import Foundation + +(1 ... 100).forEach { + var result: String = "" + + if $0 % 3 == 0 { + result.append("fizz") + } + + if $0 % 5 == 0 { + result.append("buzz") + } + + if result.isEmpty { + result.append($0.description) + } + + print(result) +} \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/typescript/dPenedo.ts" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/typescript/dPenedo.ts" new file mode 100644 index 0000000000..7332c40f95 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/typescript/dPenedo.ts" @@ -0,0 +1,33 @@ +// / +// 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". +// + +function isMultiple(number: number, divider: number) { + return number % divider == 0 +} + + +function printNumbers(number: number) { + const listNumber = number + for (let index = 1; index <= listNumber; index++) { + const multipleOf3 = isMultiple(index, 3) + const multipleOf5 = isMultiple(index, 5) + if (multipleOf3 && multipleOf5) { + console.log("fizzbuzz") + } else if (multipleOf3) { + console.log("fizz") + } else if (multipleOf5) { + console.log("buzz") + } + else { + console.log(index) + } + } +} + +printNumbers(100) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/c#/patriciotrujilllo.cs" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/c#/patriciotrujilllo.cs" new file mode 100644 index 0000000000..bdd4ec09db --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/c#/patriciotrujilllo.cs" @@ -0,0 +1,42 @@ +/* + * Escribe un programa que reciba un texto y transforme lenguaje natural a + * "lenguaje hacker" (conocido realmente como "leet" o "1337"). Este lenguaje + * se caracteriza por sustituir caracteres alfanuméricos. + * - Utiliza esta tabla (https://www.gamehouse.com/blog/leet-speak-cheat-sheet/) + * con el alfabeto y los números en "leet". + * (Usa la primera opción de cada transformación. Por ejemplo "4" para la "a") + */ + +using System; +using System.Collections.Generic; + +namespace Leet +{ + public class Program + { + public static void Main() + { + Console.Write("Ingrese una palabra para ser traducida al lenguaje Hacker: "); + string text = Console.ReadLine(); + var diccionario = new Dictionary + { + {'a', "4"}, {'b', "8"}, {'c', "<"}, {'d', "|)"}, {'e', "3"}, + {'f', "|="}, {'g', "6"}, {'h', "#"}, {'i', "1"}, {'j', "_|"}, + {'k', "|<"}, {'l', "1"}, {'m', "/\\/\\\\"}, {'n', "|\\|"}, {'o', "0"}, + {'p', "|*"}, {'q', "(_,)"}, {'r', "|2"}, {'s', "5"}, {'t', "7"}, + {'u', "|_|"}, {'v', "\\/"}, {'w', "\\/\\/\\"}, {'x', "><"}, {'y', "'/"}, + {'z', "2"}, {'1', "L"}, {'2', "R"}, {'3', "E"}, {'4', "A"}, + {'5', "S"}, {'6', "b"}, {'7', "T"}, {'8', "B"}, {'9', "g"}, {'0', "o"} + }; + + var textCovert = ""; + + foreach (var caracter in text.ToLower()) + { + textCovert += diccionario.ContainsKey(caracter) ? diccionario[caracter] : caracter.ToString(); + } + + Console.WriteLine(textCovert); + } + } +} \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/jaimegamm.js" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/jaimegamm.js" new file mode 100644 index 0000000000..09c9fad98c --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/jaimegamm.js" @@ -0,0 +1,66 @@ +/* + * Escribe un programa que reciba un texto y transforme lenguaje natural a + * "lenguaje hacker" (conocido realmente como "leet" o "1337"). Este lenguaje + * se caracteriza por sustituir caracteres alfanuméricos. + * - Utiliza esta tabla (https://www.gamehouse.com/blog/leet-speak-cheat-sheet/) + * con el alfabeto y los números en "leet". + * (Usa la primera opción de cada transformación. Por ejemplo "4" para la "a") + */ + +let lenguaje_hacker = { + "a": "4", + "b": "I3", + "c": "[", + "d": ")", + "e": "3", + "f": "|=", + "g": "&", + "h": "#", + "i": "1", + "j": ",_|", + "k": ">|" , + "l": "1", + "m": "|\\/|", + "n": "|\\|" , + "o": "0", + "p": "|*", + "q": "(_,)", + "r": "I2", + "s": "5", + "t": "7", + "u": "(_)", + "v": "\\/", + "w": "\\/\\/", + "x": "><", + "y": "j", + "z": "2", + "1": "L", + "2": "R", + "3": "E", + "4": "A", + "5": "S", + "6": "b", + "7": "T", + "8": "B", + "9": "g", + "0": "O" +} + +function leet_converter(text){ + leet_text = "" + text = text.toLowerCase(); + for (var i = 0; i < text.length; i++) { + var letra = text.charAt(i); + if(letra in lenguaje_hacker){ + leet_text += lenguaje_hacker[letra] + }else{ + leet_text += letra + } + } + return leet_text; +} + + +text = "Hola Mundo" +console.log("Texto original: " + text) +console.log("Texto en leet: "+leet_converter(text)) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/patriciotrujilllo.js" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/patriciotrujilllo.js" new file mode 100644 index 0000000000..b2f794491d --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/patriciotrujilllo.js" @@ -0,0 +1,24 @@ +/* + * Escribe un programa que reciba un texto y transforme lenguaje natural a + * "lenguaje hacker" (conocido realmente como "leet" o "1337"). Este lenguaje + * se caracteriza por sustituir caracteres alfanuméricos. + * - Utiliza esta tabla (https://www.gamehouse.com/blog/leet-speak-cheat-sheet/) + * con el alfabeto y los números en "leet". + * (Usa la primera opción de cada transformación. Por ejemplo "4" para la "a") + */ + +function Transform(word) { + const diccionario = { + a: '4', b: 'I3', c: '[', d: ')', e: '3', f: '|=', g: '&', h: '#', + i: '1', j: ',_|', k: '>|', l: '1', m: '/\\/\\', n: '^/', o: '0', + p: '|*', q: '(_,)', r: 'I2', s: '5', t: '7', u: '(_)', v: '\\/', + w: '\\/\\/', x: '><', y: 'j', z: '2', 1: 'L', 2: 'R', 3: 'E', + 4: 'A', 5: 'S', 6: 'b', 7: 'T', 8: 'B', 9: 'g', 0: 'o' + } + + let leetWord = word.split('').map(caracter => (diccionario[caracter])) + + return leetWord.join('') +} + +console.log(Transform('abc')) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jaimegamm.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jaimegamm.py" new file mode 100644 index 0000000000..da04571fed --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jaimegamm.py" @@ -0,0 +1,68 @@ +""" +# Reto #1: EL "LENGUAJE HACKER" +#### Dificultad: Fácil | + +## Enunciado + +``` +/* + * Escribe un programa que reciba un texto y transforme lenguaje natural a + * "lenguaje hacker" (conocido realmente como "leet" o "1337"). Este lenguaje + * se caracteriza por sustituir caracteres alfanuméricos. + * - Utiliza esta tabla (https://www.gamehouse.com/blog/leet-speak-cheat-sheet/) + * con el alfabeto y los números en "leet". + * (Usa la primera opción de cada transformación. Por ejemplo "4" para la "a") + */ +``` +#### Tienes toda la información extendida sobre los retos de programación semanales en **[retosdeprogramacion.com/semanales2023](https://retosdeprogramacion.com/semanales2023)**. + +Sigue las **[instrucciones](../../README.md)**, consulta las correcciones y aporta la tuya propia utilizando el lenguaje de programación que quieras. + +> Recuerda que cada semana se publica un nuevo ejercicio y se corrige el de la semana anterior en directo desde **[Twitch](https://twitch.tv/mouredev)**. Tienes el horario en la sección "eventos" del servidor de **[Discord](https://discord.gg/mouredev)**. +""" + +leetme = { + 'A': '4', + 'B': 'I3', + 'C': '[', + 'D': ')', + 'E': '3', + 'F': '|=', + 'G': '&', + 'H': '#', + 'I': '1', + 'J': ',_|', + 'K': '>|', + 'L': '1', + 'M': '/\\/\\', + 'N': '^/', + 'O': '0', + 'P': '|*', + 'Q': '(_,)', + 'R': '|2', + 'S': '5', + 'T': '7', + 'U': '(_)', + 'V': '\\/', + 'W': '\\/\\/', + 'X': '><', + 'Y': 'j', + 'Z': '2', + ' ': ' ', + '!': '!', + '?': '?', + '.': '.', + 'Ñ': 'ñ' +} + +def leet_converter(text): + leet_text = "" + for char in text: + leet_text += leetme.get(char.upper(), char) + return leet_text + +if __name__ == "__main__": + input_text = input("Introduce el texto a convertir a leet: ") + result = leet_converter(input_text) + print("Texto original: ", input_text) + print("Texto en leet: ", result) diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/ruby/mauricionc.rb" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/ruby/mauricionc.rb" new file mode 100644 index 0000000000..d3d165979a --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/ruby/mauricionc.rb" @@ -0,0 +1,41 @@ +LEET_ALPHABET = { + "A" => "4", + "B" => "I3", + "C" => "[", + "D" => ")", + "E" => "3", + "F" => "|=", + "G" => "&", + "H" => "#", + "I" => "1", + "J" => ",_|", + "K" => ">|", + "L" => "1", + "M" => "/\\/\\", + "N" => "^/", + "O" => "0", + "P" => "|*", + "Q" => "(_,)", + "R" => "I2", + "S" => "5", + "T" => "7", + "U" => "(_)", + "V" => "\\/", + "W" => "\\/\\/", + "X" => "><", + "Y" => "j", + "Z" => "2", + "0" => "o", + "1" => "L", + "2" => "R", + "3" => "E", + "4" => "A", + "5" => "S", + "6" => "b", + "7" => "T", + "8" => "B", + "9" => "g", +} + +text = gets.chomp.split(" ") +puts text.map { |t| t.split("").map { |ch| t = LEET_ALPHABET[ch.upcase] || LEET_ALPHABET[ch] || ch }.join("") }.join(" ") diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/scala/avelasquezhe84.scala" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/scala/avelasquezhe84.scala" new file mode 100644 index 0000000000..c131a277d2 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/scala/avelasquezhe84.scala" @@ -0,0 +1,12 @@ +// Scala 3 + +@main def main(args: String*) = + println(args.map(w => translate(w.toLowerCase())).mkString(" ")) + +def translate(word: String): String = + val w = word.toList.map(_.toString()) + val az = ('a' to 'z').map(_.toString()) + val leet = List("4", "I3", "[", ")", "3", "|=", "&", "#", "1", ",_|", ">|", "1", "/\\/\\", "^/", "0", "|*", "(_,)", "I2", "5", "7", "(_)", "\\/", "\\/\\", "><", "j", "2") + val substitutions = (az zip leet).toMap + val res = w.map(c => substitutions.getOrElse(c, c)) + res.mkString \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..61d3e97137 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,26 @@ +import Foundation + +let crypto: [Character: String] = [ + "A": "4", "B": "I3", "C": "[", "D": ")", + "E": "3", "F": "|=", "G": "6", "H": "#", + "I": "1", "J": ",_|", "K": ">|", "L": "1", + "M": "/\\/\\", "N": "^/", "O": "0", "P": "|*", + "Q": "(_,)", "R": "I2", "S": "5", "T": "7", + "U": "(_)", "V": "\\/", "W": "\\/\\/", "X": "><", + "Y": "j", "Z": "2", + "1": "L", "2": "R", "3": "E", "4": "A", + "5": "S", "6": "b", "7": "T", "8": "B", + "9": "g", "0": "o" +] + +func Encrypt(_ word: String) -> String { + var encryptedWord: String = "" + + word.uppercased().forEach { + encryptedWord.append(crypto[$0, default: " "]) + } + + return encryptedWord +} + +print(Encrypt("Hello world in 2024")) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/typescript/dPenedo.ts" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/typescript/dPenedo.ts" new file mode 100644 index 0000000000..16982f94eb --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/typescript/dPenedo.ts" @@ -0,0 +1,62 @@ +// Escribe un programa que reciba un texto y transforme lenguaje natural a +// "lenguaje hacker" (conocido realmente como "leet" o "1337"). Este lenguaje +// se caracteriza por sustituir caracteres alfanuméricos. +// - Utiliza esta tabla (https://www.gamehouse.com/blog/leet-speak-cheat-sheet/) +// con el alfabeto y los números en "leet". +// (Usa la primera opción de cada transformación. Por ejemplo "4" para la "a") + +const leetDictionary = { + A: "4", + B: "|3", + C: "[", + D: ")", + E: "3", + F: "|=", + G: "&", + H: "#", + I: "1", + J: ",_|", + K: ">|", + L: "1", + M: "/\\/\\", + N: "^/", + O: "0", + P: "|*", + Q: "(_,)", + R: "I2", + S: "5", + T: "7", + U: "(_)", + V: "\\/", + W: "\\/\\/", + X: "><", + Y: "j", + Z: "2", + 0: "o", + 1: "L", + 2: "R", + 3: "E", + 4: "A", + 5: "S", + 6: "b", + 7: "T", + 8: "B", + 9: "g", +}; + +function convert_text(normal_text: string): string { + let new_text = ""; + for (let char of normal_text) { + const upperChar = char.toUpperCase(); + if (upperChar in leetDictionary) { + new_text += leetDictionary[upperChar]; + } else { + new_text += char; + } + } + return new_text; +} +const originalText = + "Un texto de prueba para ver si funciona el diccionario Leet"; +const convertedText = convert_text(originalText); +console.log(convertedText); diff --git a/Retos/Reto #10 - LA API [Media]/python/jelambrar96.py b/Retos/Reto #10 - LA API [Media]/python/jelambrar96.py new file mode 100644 index 0000000000..042d7255a0 --- /dev/null +++ b/Retos/Reto #10 - LA API [Media]/python/jelambrar96.py @@ -0,0 +1,37 @@ +#!/usr/bin/python3 + +""" +# Reto #10: La API +/* + * Llamar a una API es una de las tareas más comunes en programación. + * + * Implementa una llamada HTTP a una API (la que tú quieras) y muestra su + * resultado a través de la terminal. Por ejemplo: Pokémon, Marvel... + * + * Aquí tienes un listado de posibles APIs: + * https://github.com/public-apis/public-apis + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + + + +import json +import requests + +url = "https://openlibrary.org/search.json?title=the+lord+of+the+rings" + +response = requests.get(url) +json_data = json.loads(response.text) +print(json.dumps(json_data, indent=4)) + + + diff --git a/Retos/Reto #10 - LA API [Media]/swift/jcalderita.swift b/Retos/Reto #10 - LA API [Media]/swift/jcalderita.swift new file mode 100644 index 0000000000..0fbce27014 --- /dev/null +++ b/Retos/Reto #10 - LA API [Media]/swift/jcalderita.swift @@ -0,0 +1,19 @@ +import Foundation + +struct Character: Codable, Hashable { + let id: UUID + let name: String +} + +if let url = URL(string: "https://hp-api.onrender.com/api/characters") { + do { + let data = try Data(contentsOf: url) + let characters = try JSONDecoder().decode([Character].self, from: data) + print(characters + .map { $0.name } + .formatted(.list(type: .and)) + ) + } catch { + print(error) + } +} \ No newline at end of file diff --git "a/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/jelambrar96.py" "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/jelambrar96.py" new file mode 100644 index 0000000000..dd70403bd5 --- /dev/null +++ "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/jelambrar96.py" @@ -0,0 +1,34 @@ +#!/usr/bin/python3 + +""" +# Reto #11: URL params +/* + * Dada una URL con parámetros, crea una función que obtenga sus valores. + * No se pueden usar operaciones del lenguaje que realicen esta tarea directamente. + * + * Ejemplo: En la url https://retosdeprogramacion.com?year=2023&challenge=0 + * los parámetros serían ["2023", "0"] + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + +import json + +def getParams(url): + cadena_dividida = url.split("?", 1)[1] + valores = cadena_dividida.split("&") + dict_params = dict([ tuple(item.split("=", 1)) for item in valores if item]) + return dict_params + +if __name__ == '__main__': + url = "https://retosdeprogramacion.com?year=2023&challenge=0" + params = getParams(url) + print(json.dumps(params, indent=4)) diff --git "a/Retos/Reto #11 - URL PARAMS [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..221c0dc34f --- /dev/null +++ "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,9 @@ +import Foundation + +let url: String = "https://retosdeprogramacion.com?year=2023&challenge=0" + +let urlParts = url.components(separatedBy: "=").dropFirst() + +if !urlParts.isEmpty { + print(urlParts.compactMap { $0.components(separatedBy: "&").first }) +} \ No newline at end of file diff --git "a/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..faa2f3e77d --- /dev/null +++ "b/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,17 @@ +import Foundation + +func hasFriday13(month: Int, year: Int) -> Bool { + let calendar = Calendar(identifier: .gregorian) + var components = DateComponents() + components.year = year + components.month = month + components.day = 13 + + guard let date = calendar.date(from: components) else { + return false + } + + return calendar.component(.weekday, from: date) == 6 +} + +print(hasFriday13(month: 9, year: 2024)) \ No newline at end of file diff --git a/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/c++/dylanb55.cpp b/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/c++/dylanb55.cpp new file mode 100644 index 0000000000..deebac685a --- /dev/null +++ b/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/c++/dylanb55.cpp @@ -0,0 +1,99 @@ +#include +#include +#include +using namespace std; + +string palabras[8] = {"arbol", "camion","perro","auto","vasija","paralelepipedo","mouredev","java"}; + + +string seleccionPalabra(string palabras[8]){ + + srand(time(NULL)); + int numero_aleatorio = rand() % 8; + return palabras[numero_aleatorio]; +}; + +string mostrarTablero(){ + string tablero = seleccionPalabra(palabras); + int largo = tablero.size(); + + for(int i = 0;i 1: + bandera = self._adivina_palabra(letra) + else: + bandera = self._adivina_letra(letra) + if self._modo_vida and bandera == False: + self._vidas -= 1 + elif not self._modo_vida: + self._vidas -= 1 + + def _adivina_palabra(self, letra): + if letra == self._palabra: + self._mascara = [ True for item in self._palabra ] + return True + return False + + def _adivina_letra(self, letra): + bandera = False + brandera_repetir = False + for i,item in enumerate(self._palabra): + if item == letra and self._mascara[i] == False: + bandera = True + self._mascara[i] = True + if item == letra and self._mascara[i] == True and bandera == False: + brandera_repetir = True + if brandera_repetir: + print("Has repetido la letra ", letra) + return False + return bandera + + def obtener_vidas(self): + return self._vidas + + def obtener_modo(self): + return self._modo_vida + + + +def juego(palabra, vidas=None, modo_vida=True): + + print("BIENVIENIDO al juego de ADIVINA la palabra") + + # -------------------------------------------------- + # contruimos el objeto + # -------------------------------------------------- + + pasapalabra = Pasapalabra(palabra, vidas, modo_vida) + + # -------------------------------------------------- + + # -------------------------------------------------- + # vamos a mostrar entre el 40% y el 80% + # -------------------------------------------------- + + set_palabra = set(palabra) + len_set_palabra = len(set_palabra) + + lim_in = int(ceil(len_set_palabra * 0.4)) + lim_su = int(floor(len_set_palabra * 0.8)) + rand_limite = randint(lim_in, lim_su) + + lista_letras_mostrar = list(set_palabra) + shuffle(lista_letras_mostrar) + lista_letras_mostrar = lista_letras_mostrar[rand_limite:] + + for item in lista_letras_mostrar: + pasapalabra.adivina(item) + + # -------------------------------------------------- + + # -------------------------------------------------- + # main loop + # -------------------------------------------------- + + while True: + + print() + print("Adivina la palabra") + print() + pasapalabra.mostrar_palabra(sep=" ") + print() + vidas = pasapalabra.obtener_vidas() + print("tienes", vidas, "vidas" if pasapalabra.obtener_modo() else "intentos") + print("❤︎" * vidas) + print() + + temp_palabra = input() + pasapalabra.adivina(temp_palabra) + + if pasapalabra.ganar(): + print("FELICIDADES HAS ADIVINADO LA PALABRA") + pasapalabra.mostrar_palabra() + break + + if pasapalabra.obtener_vidas() == 0: + print("LO SIENTO; NO GANASTE") + print("la palabra era: ", palabra) + break + + # -------------------------------------------------- + +if __name__ == '__main__': + + palabra = choice(LIST_PALABRAS) + palabra = preprocesar_cadena(palabra) + juego(palabra) diff --git "a/Retos/Reto #14 - OCTAL Y HEXADECIMAL [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #14 - OCTAL Y HEXADECIMAL [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..fb586a245e --- /dev/null +++ "b/Retos/Reto #14 - OCTAL Y HEXADECIMAL [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,32 @@ +import Foundation + +func octal(num: Int) -> Int { + func convert(num: Int, rest: [Int] = []) -> [Int] { + guard num != 0 else { return rest } + + return convert(num: num / 8, rest: [num % 8] + rest) + } + + let rest = convert(num: num) + return rest.reduce(0) { + $0 * 10 + $1 + } +} + +func hexadecimal(num: Int) -> String { + let hexValues = ["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"] + func convert(num: Int, hex:[String] = []) -> [String] { + guard num > 15 else { return [hexValues[num]] + hex } + + return convert(num: num / 16, hex: [hexValues[num % 16]] + hex) + } + + let hex = convert(num: num) + return hex.reduce("") { + "\($0)\($1)" + } +} + + +print(octal(num: 456)) +print(hexadecimal(num: 456)) diff --git "a/Retos/Reto #15 - AUREBESH [F\303\241cil]/python/jelambrar96.py" "b/Retos/Reto #15 - AUREBESH [F\303\241cil]/python/jelambrar96.py" new file mode 100644 index 0000000000..d8f89da40c --- /dev/null +++ "b/Retos/Reto #15 - AUREBESH [F\303\241cil]/python/jelambrar96.py" @@ -0,0 +1,100 @@ +#!/usr/bin/python3 + +""" +# Reto #15: Aurebesh +/* + * Crea una función que sea capaz de transformar Español al lenguaje básico del universo + * Star Wars: el "Aurebesh". + * - Puedes dejar sin transformar los caracteres que no existan en "Aurebesh". + * - También tiene que ser capaz de traducir en sentido contrario. + * + * ¿Lo has conseguido? Nómbrame en twitter.com/mouredev y escríbeme algo en Aurebesh. + * + * ¡Que la fuerza os acompañe! + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + +# import json + +DICT_TO_AUREBEK_MONO = { + "a": "aurebek", + "c": "cresh", + "j": "jenth", + "k": "krill", + "s": "senth", + "t": "trill", + "z": "zerek", + "b": "besh", + "d": "dorn", + "f": "forn", + "g": "grek", + "h": "herf", + "l": "leth", + "m": "mern", + "n": "nern", + "p": "peth", + "r": "resh", + "w": "wesk", + "x": "xesh", + "y": "yirt", + "e": "esk", + "i": "isk", + "o": "osk", + "q": "qek", + "u": "usk", + "v": "vev" +} + +DICT_AUREBECK_TWO = { + "ch": "cherek", + "kh": "krenth", + "oo": "orenth", + "eo": "onith", + "th": "thesh", + "ae": "enth", + "sh": "shen", + "ng": "nen" +} + + +def traducir_palabra_espanol_a_aurebesh(palabra): + for k, v in DICT_AUREBECK_TWO.items(): + palabra = palabra.replace(k, v.upper()) + for k, v in DICT_TO_AUREBEK_MONO.items(): + palabra = palabra.replace(k, v.upper()) + return palabra.lower() + + +def traducir_palabra_aurebesh_a_espanol(palabra): + for v, k in DICT_TO_AUREBEK_MONO.items(): + palabra = palabra.replace(k, v.upper()) + for v, k in DICT_AUREBECK_TWO.items(): + palabra = palabra.replace(k, v.upper()) + return palabra.lower() + + +if __name__ == '__main__': + + lista_palabras = [ + 'industria', 'escribir', 'mientras', 'listo', 'exigir', 'buscar', 'parecer', + 'primavera', 'causa', 'inventar', 'prisa', 'viajes', 'miedo', 'siglo', + 'hacer', 'historia', 'particular,', 'llegar', 'nunca', 'fruta', 'suelo', + 'llamada', 'desear', 'perro', 'movimiento', 'pista', 'querido', 'estrella', + 'bastante', 'decir', 'dejar', 'diccionario', 'tratar'] + + for item in lista_palabras: + lower_item = item.lower() + aurebeck_item = traducir_palabra_espanol_a_aurebesh(lower_item) + espanol_item = traducir_palabra_aurebesh_a_espanol(aurebeck_item) + print(lower_item, aurebeck_item, espanol_item, sep="\t-\t") + + diff --git "a/Retos/Reto #15 - AUREBESH [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #15 - AUREBESH [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..b63cebbc78 --- /dev/null +++ "b/Retos/Reto #15 - AUREBESH [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,46 @@ +import Foundation + +let latin = [ + "A", "B", "C", "D", "E", + "F", "G", "H", "I", "J", + "K", "L", "M", "N", "O", + "P", "Q", "R", "S", "T", + "U", "V", "W", "X", "Y", "Z" +] + +let aurebesh = [ + "Aurek", "Besh", "Cresh", "Dorn", "Enth", + "Forn", "Grek", "Herf", "Isk", "Jenth", + "Krill", "Leth", "Mern", "Nern", "Osk", + "Peth", "Qek", "Resh", "Senth", "Trill", + "Usk", "Vev", "Wesk", "Xesh", "Yirt", "Zerek" +] + +func translate(sentence: String, latinToAurebesh: Bool) -> String { + if latinToAurebesh { + return sentence.uppercased().map { char in + guard let idx = latin.firstIndex(of: String(char)) else { return String(char) } + + return aurebesh[idx] + }.joined() + } else { + let separatedAurebesh = sentence.reduce(into: [String]()) { (result, character) in + if character.isUppercase || character.isWhitespace || character.isNumber { + result.append(String(character)) + } else { + result[result.endIndex-1].append(character) + } + } + + return separatedAurebesh.map { word in + guard let idx = aurebesh.firstIndex(of: word) else { return word } + + return latin[idx] + }.joined() + } +} + +let translateAurebesh = translate(sentence: "May the Force be with you", latinToAurebesh: true) +print(translateAurebesh) +let translateLatin = translate(sentence: translateAurebesh, latinToAurebesh: false) +print(translateLatin) \ No newline at end of file diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/c++/evaapinaa.cpp b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/c++/evaapinaa.cpp new file mode 100644 index 0000000000..10cf699dc7 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/c++/evaapinaa.cpp @@ -0,0 +1,97 @@ +/* + * Escribe un programa que muestre cómo transcurre un juego de tenis y quién lo ha ganado. + * El programa recibirá una secuencia formada por "P1" (Player 1) o "P2" (Player 2), según quien + * gane cada punto del juego. + * + * - Las puntuaciones de un juego son "Love" (cero), 15, 30, 40, "Deuce" (empate), ventaja. + * - Ante la secuencia [P1, P1, P2, P2, P1, P2, P1, P1], el programa mostraría lo siguiente: + * 15 - Love + * 30 - Love + * 30 - 15 + * 30 - 30 + * 40 - 30 + * Deuce + * Ventaja P1 + * Ha ganado el P1 + * - Si quieres, puedes controlar errores en la entrada de datos. + * - Consulta las reglas del juego si tienes dudas sobre el sistema de puntos. + */ + +#include +#include +#include + +using namespace std; + +// Inicializamos la tabla con las puntuaciones +map < int , string > Puntuaciones = { + {0, "Love"}, + {1, "15"}, + {2, "30"}, + {3, "40"} +}; + +void PartidoTenis(string puntos[], int longitud) { + int contadorP1 = 0; + int contadorP2 = 0; + + for(int i = 0; i < longitud; i++) { + + // Tratamiento de errores + if((puntos[i] != "P1") && (puntos[i] != "P2")) { + cout << "Los datos no se han introducido correctamente." << endl; + break; + } + // En caso de no haber error, contamos P1 y P2 + else if(puntos[i] == "P1") { + contadorP1++; + } + else if(puntos[i] == "P2") { + contadorP2++; + } + + // Impresion de puntos + if (contadorP1 == 3 && contadorP2 == 3) { + cout << "Deuce" << endl; + } + + else if (contadorP1 >= 4 || contadorP2 >= 4) { + + int diff = contadorP1-contadorP2; // Actualizando en cada iteracion + + if (diff == 0) { + cout << "Deuce" << endl; + } + else if (diff == 1) { + cout << "Ventaja P1" << endl; + } + else if (diff == -1) { + cout << "Ventaja P2" << endl; + } + else if (diff >= 2) { + cout << "Ha ganado P1" << endl; + cout << "Fin del partido" << endl; + return; // Termina la función cuando hay un ganador + } + else { + cout << "Ha ganado P2" << endl; + cout << "Fin del partido" << endl; + return; // Termina la función cuando hay un ganador + } + } + + else { + cout << Puntuaciones[contadorP1] << " - " << Puntuaciones[contadorP2] << endl; + } + } +} + +int main() { + + string puntos[] = {"P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"}; // Secuencia de puntos + int longitud = sizeof(puntos) / sizeof(puntos[0]); // Longitud del array de puntos + + PartidoTenis(puntos,longitud); // Juego + + return 0; +} diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/jaimegamm.js b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/jaimegamm.js new file mode 100644 index 0000000000..c4d61f4069 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/jaimegamm.js @@ -0,0 +1,67 @@ +/* + * Escribe un programa que muestre cómo transcurre un juego de tenis y quién lo ha ganado. + * El programa recibirá una secuencia formada por "P1" (Player 1) o "P2" (Player 2), según quien + * gane cada punto del juego. + * + * - Las puntuaciones de un juego son "Love" (cero), 15, 30, 40, "Deuce" (empate), ventaja. + * - Ante la secuencia [P1, P1, P2, P2, P1, P2, P1, P1], el programa mostraría lo siguiente: + * 15 - Love + * 30 - Love + * 30 - 15 + * 30 - 30 + * 40 - 30 + * Deuce + * Ventaja P1 + * Ha ganado el P1 + * - Si quieres, puedes controlar errores en la entrada de datos. + * - Consulta las reglas del juego si tienes dudas sobre el sistema de puntos. + */ + + +puntuaciones = ["Love", "15", "30", "40"] +jugador_actual = "" + +function jugar_tenis(secuencia){ + score_p1 = 0 + score_p2 = 0 + for (let i = 0; i < secuencia.length; i++){ + let jugada = secuencia[i]; + if (jugada === "P1") { + score_p1 += 1 + }else if(jugada === "P2") { + score_p2 += 1 + } else { + console.error("Error: Entrada inválida") + return + } + puntuacion_actual = mostrar_puntuacion(score_p1, score_p2) + console.log(puntuacion_actual) + if ("Ha ganado" === puntuacion_actual) + break + } + return +} + +function mostrar_puntuacion (score_p1, score_p2){ + if (score_p1 === score_p2){ + if(score_p1 < 3) + return puntuaciones[score_p1] +" -All"; + else + return "Deuce" + }else if(score_p1 >= 4 || score_p2 >= 4){ + diff = Math.abs(score_p1 - score_p2) + if(diff == 1) + return "Ventaja" + else + return "Ha ganado " + }else{ + return puntuaciones[score_p1] + " - " +puntuaciones[score_p2] + } +} + + + +secuencia_juego = ["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"] + + +jugar_tenis(secuencia_juego) \ No newline at end of file diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jaimegamm.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jaimegamm.py new file mode 100644 index 0000000000..a2dc23d387 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jaimegamm.py @@ -0,0 +1,63 @@ +""" +Escribe un programa que muestre cómo transcurre un juego de tenis y quién lo ha ganado. +El programa recibirá una secuencia formada por "P1" (Player 1) o "P2" (Player 2), según quien +gane cada punto del juego. + +- Las puntuaciones de un juego son "Love" (cero), 15, 30, 40, "Deuce" (empate), ventaja. +- Ante la secuencia [P1, P1, P2, P2, P1, P2, P1, P1], el programa mostraría lo siguiente: +15 - Love +30 - Love +30 - 15 +30 - 30 +40 - 30 +Deuce +Ventaja P1 +Ha ganado el P1 +- Si quieres, puedes controlar errores en la entrada de datos. +- Consulta las reglas del juego si tienes dudas sobre el sistema de puntos. +""" + +puntuaciones = ["Love", "15", "30", "40"] +jugador_actual = "" + +def jugar_tenis(secuencia): + score_p1 = 0 + score_p2 = 0 + for jugada in secuencia: + if jugada == "P1": + score_p1 += 1 + elif jugada == "P2": + score_p2 += 1 + else: + print("Error: Entrada inválida") + return + + puntuacion_actual = mostrar_puntuacion(score_p1, score_p2) + print(puntuacion_actual) + + if "Ha ganado" in puntuacion_actual: + break + + return + +def mostrar_puntuacion(score_p1, score_p2): + if score_p1 == score_p2: + if score_p1 < 3: + return f"{puntuaciones[score_p1]} - All" + else: + return "Deuce" + elif score_p1 >= 4 or score_p2 >= 4: + diff = abs(score_p1 - score_p2) + if diff == 1: + return f"Ventaja {jugador_actual}" + else: + return f"Ha ganado el {jugador_actual}" + else: + return f"{puntuaciones[score_p1]} - {puntuaciones[score_p2]}" + + +# Secuencia de prueba +secuencia_juego = ["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"] + +# Iniciar el juego +jugar_tenis(secuencia_juego) \ No newline at end of file diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jelambrar96.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jelambrar96.py new file mode 100644 index 0000000000..5ac06b99ef --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jelambrar96.py @@ -0,0 +1,76 @@ +#!/usr/bin/python3 + +""" +RETO #2 EL PARTIDO DE TENIS +/* + * Escribe un programa que muestre cómo transcurre un juego de tenis y quién lo ha ganado. + * El programa recibirá una secuencia formada por "P1" (Player 1) o "P2" (Player 2), según quien + * gane cada punto del juego. + * + * - Las puntuaciones de un juego son "Love" (cero), 15, 30, 40, "Deuce" (empate), ventaja. + * - Ante la secuencia [P1, P1, P2, P2, P1, P2, P1, P1], el programa mostraría lo siguiente: + * 15 - Love + * 30 - Love + * 30 - 15 + * 30 - 30 + * 40 - 30 + * Deuce + * Ventaja P1 + * Ha ganado el P1 + * - Si quieres, puedes controlar errores en la entrada de datos. + * - Consulta las reglas del juego si tienes dudas sobre el sistema de puntos. + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + + +labels = ["Love", 15, 30, 40] + + +def tenis(lista_jugadores): + + if len(lista_jugadores) < 4: + print("Fallo") + return + + p1_count, p2_count = 0, 0 + + for item in lista_jugadores: + + if "P1" == item: + p1_count += 1 + elif "P2" == item: + p2_count += 1 + + # print(p1_count, p2_count) + + if "P1" == item and p1_count - p2_count > 1 and p1_count > 3: + print("Ha ganado el jugador 1") + break + if "P2" == item and p2_count - p1_count > 1 and p2_count > 3: + print("Ha ganado el jugador 2") + break + + if p1_count > 3 or p2_count > 3: + if p1_count == p2_count: + print("Deuce") + elif p1_count > p2_count: + print("Ventaja P1") + elif p2_count > p1_count: + print("Ventaja P2") + else: + print(labels[p1_count], "-", labels[p2_count]) + +if __name__ == '__main__': + tenis(["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"]) + + + diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/swift/jcalderita.swift b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/swift/jcalderita.swift new file mode 100644 index 0000000000..3c291a812b --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/swift/jcalderita.swift @@ -0,0 +1,47 @@ +import Foundation + +let points: [Int: String] = [ + 0: "Love", + 1: "15", + 2: "30", + 3: "40" +] + +final class Player { + let name: String + var point: Int + + init(name: String, point: Int) { + self.name = name + self.point = point + } +} + +func score(l: Player, r: Player) { + let diff = l.point - r.point + + switch diff { + case 2... where l.point > 3: + print("\(l.name) wins") + case ..<(-1) where r.point > 3: + print("\(r.name) wins") + case 1 where l.point > 3: + print("\(l.name) Advantage") + case -1 where r.point > 3: + print("\(r.name) Advantage") + case 0: + print("Deuce") + default: + print("\(points[l.point, default: ""]) - \(points[r.point, default: ""])") + } +} + +var p1 = Player(name: "Player 1", point: 0) +var p2 = Player(name: "Player 2", point: 0) + +let set = [p1, p1, p2, p2, p1, p2, p1, p2, p1, p2, p2, p2] + +set.forEach { player in + player.point += 1 + score(l: p1, r: p2) +} \ No newline at end of file diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/typescript/dPenedo.ts b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/typescript/dPenedo.ts new file mode 100644 index 0000000000..f26be58e40 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/typescript/dPenedo.ts @@ -0,0 +1,87 @@ +// +// Escribe un programa que muestre cómo transcurre un juego de tenis y quién lo ha ganado. +// El programa recibirá una secuencia formada por "P1" (Player 1) o "P2" (Player 2), según quien +// gane cada punto del juego. +// +// - Las puntuaciones de un juego son "Love" (cero), 15, 30, 40, "Deuce" (empate), ventaja. +// - Ante la secuencia [P1, P1, P2, P2, P1, P2, P1, P1], el programa mostraría lo siguiente: +// 15 - Love +// 30 - Love +// 30 - 15 +// 30 - 30 +// 40 - 30 +// Deuce +// Ventaja P1 +// Ha ganado el P1 +// - Si quieres, puedes controlar errores en la entrada de datos. +// - Consulta las reglas del juego si tienes dudas sobre el sistema de puntos. +// + +const scores = ['Love', '15', '30', '40']; +type Players = 'P1' | 'P2'; + +function showResults(score1: string, score2: string) { + console.log(`Player 1: ${score1} || Player 2: ${score2}`); + console.log('****************************'); +} +function victoryFor(player: Players) { + if (player == 'P1') { + console.log('Victory for Player 1'); + } else { + console.log('Victory for Player 2'); + } + console.log('+++++++++++++++++++++++++'); +} + +function playGame(players: Players[]) { + let deuce: boolean = false; + let countP1 = 0; + let countP2 = 0; + + console.log('****************************'); + for (let index = 0; index < players.length; index++) { + const player = players[index]; + if (player == 'P1') { + console.log('Point for Player 1'); + countP1++; + if (countP1 > 3 && !deuce) { + victoryFor('P1'); + break; + } + } else if (player == 'P2') { + console.log('Point for Player 2'); + countP2++; + if (countP2 > 3 && !deuce) { + victoryFor('P2'); + break; + } + } + if (countP1 >= 3 && countP2 >= 3 && countP1 === countP2) { + deuce = true; + console.log('Deuce'); + console.log('============================'); + } else if (deuce) { + let difference = countP1 - countP2; + if (difference === 0) { + console.log('Deuce'); + } else if (difference >= 2) { + victoryFor('P1'); + break; + } else if (difference <= -2) { + victoryFor('P2'); + break; + } else if (difference === 1) { + console.log('Advantage for Player 1 '); + console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>'); + } else if (difference === -1) { + console.log('Advantage for Player 2 '); + console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>'); + } + } else { + showResults(scores[countP1], scores[countP2]); + } + } +} + +let secuence: Players[] = ['P1', 'P1', 'P2', 'P1', 'P2', 'P1', 'P1']; +playGame(secuence); diff --git "a/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/c++/dylanb55.cpp" "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/c++/dylanb55.cpp" new file mode 100644 index 0000000000..efece6b2d1 --- /dev/null +++ "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/c++/dylanb55.cpp" @@ -0,0 +1,32 @@ +#include +#include +using namespace std; + +int main(){ + int rango; + int divisores = 0; + vector primos; + cout << "Digite el rango" << endl; + cin >> rango; + + //Algoritmo para encontrar numeros primos y guardarlos en nuestro vector + for(int i = 1; i<=rango;i++){ + for(int j = 1;j<=rango;j++){ + if(i % j == 0){ + divisores++; + } + } + if(divisores == 2){ + primos.push_back(i); + } + + divisores = 0; + } + + //Algoritmo para encontrar los primos gemelos + for(int i = 0;i 0: + print(start) + start -= 1 + time.sleep(seconds) + + print("Booooommmm 💥") + +countdown(10, 1) \ No newline at end of file diff --git "a/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/jelambrar96.py" "b/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/jelambrar96.py" new file mode 100644 index 0000000000..8bc7f873a2 --- /dev/null +++ "b/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/jelambrar96.py" @@ -0,0 +1,48 @@ +#!/usr/bin/python3 + +""" +# Reto #29: El carácter infiltrado +/* + * Crea una función que reciba dos cadenas de texto casi iguales, + * a excepción de uno o varios caracteres. + * La función debe encontrarlos y retornarlos en formato lista/array. + * - Ambas cadenas de texto deben ser iguales en longitud. + * - Las cadenas de texto son iguales elemento a elemento. + * - No se pueden utilizar operaciones propias del lenguaje + * que lo resuelvan directamente. + * + * Ejemplos: + * - Me llamo mouredev / Me llemo mouredov -> ["e", "o"] + * - Me llamo.Brais Moure / Me llamo brais moure -> [" ", "b", "m"] + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + + + +def caracter_infiltrado(cadena_1, cadena_2): + assert len(cadena_1) == len(cadena_2), "ERROR: las cadenas deben ser de igual longitud" + caracteres_distintos = [ c2 for c1, c2 in zip(cadena_1, cadena_2) if c1 != c2 ] + return caracteres_distintos + +if __name__ == '__main__': + + cadena_1 = "Me llamo mouredev" + cadena_2 = "Me llemo mouredov" + print(cadena_1, cadena_2, sep=' - ') + print(caracter_infiltrado(cadena_1, cadena_2)) + + print() + + cadena_1 = "Me llamo.Brais Moure" + cadena_2 = "Me llamo brais moure" + print(cadena_1, cadena_2, sep=' - ') + print(caracter_infiltrado(cadena_1, cadena_2)) diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/c++/evaapinaa.cpp" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/c++/evaapinaa.cpp" new file mode 100644 index 0000000000..ac8ea0386b --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/c++/evaapinaa.cpp" @@ -0,0 +1,59 @@ +/* + * Escribe un programa que sea capaz de generar contraseñas de forma aleatoria. + * Podrás configurar generar contraseñas con los siguientes parámetros: + * - Longitud: Entre 8 y 16. + * - Con o sin letras mayúsculas. + * - Con o sin números. + * - Con o sin símbolos. + * (Pudiendo combinar todos estos parámetros entre ellos) + */ + +#include +#include +#include + +using namespace std; + +void genPassword(int longitud) { + + string contrasena; + string caracteres = "abcdefghijklmnopqrstuvwxyz"; + bool incluirMayus,incluirNum,incluirSimb; + + cout << "Desea incluir letras mayusculas? (0/1): "; + cin >> incluirMayus; + + cout << "Desea incluir numeros? (0/1): "; + cin >> incluirNum; + + cout << "Desea incluir simbolos? (0/1): "; + cin >> incluirSimb; + + if (incluirMayus) caracteres += "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + if (incluirNum) caracteres += "0123456789"; + if (incluirSimb) caracteres += "!@#$%^&*()_+=-[]{}|;:,.<>?"; + + cout << "\nGenerando contasena..." << endl; + + for(int i=0;i " << contrasena << endl; + +} + +int main(){ + + srand(time(NULL)); + + int longitud; + + cout << "Introduzca la longitud (entre 8-16): "; + cin >> longitud; + + genPassword(longitud); + + return 0; +} \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/jaimegamm.js" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/jaimegamm.js" new file mode 100644 index 0000000000..097f371485 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/jaimegamm.js" @@ -0,0 +1,63 @@ +/* + * Escribe un programa que sea capaz de generar contraseñas de forma aleatoria. + * Podrás configurar generar contraseñas con los siguientes parámetros: + * - Longitud: Entre 8 y 16. + * - Con o sin letras mayúsculas. + * - Con o sin números. + * - Con o sin símbolos. + * (Pudiendo combinar todos estos parámetros entre ellos) + */ + + +function generar_contrasena(longitud, incluir_mayusculas, incluir_numeros, incluir_simbolos){ + if(longitud<8 || longitud >16) + return "Error: La longitud de la contraseña debe estar entre 8 y 16." + + contraseñas = "" + temp = 0 + for (let i = 0; i < longitud; i++) { + temp = numeroAleatorio(temp) + + if(incluir_mayusculas.toUpperCase() ==="SI" && temp === 1) + contraseñas += caracterAleatorioEntreNumeros(65, 90) + else if(incluir_numeros.toUpperCase() ==="SI" && temp === 2) + contraseñas += caracterAleatorioEntreNumeros(48, 57) + else if(incluir_simbolos.toUpperCase() ==="SI" && temp === 3) + contraseñas += caracterAleatorioEntreNumeros(33, 47) + else + contraseñas += caracterAleatorioEntreNumeros(97, 122) + } + return contraseñas +} + +function numeroAleatorio(temp){ + aleatorio = Math.floor(Math.random() * 4) + 1; + if(temp === aleatorio) + return numeroAleatorio(aleatorio) + else + return aleatorio +} + +function caracterAleatorioEntreNumeros(num1, num2) { + // Obtener el rango y generar un índice aleatorio + const rango = Math.abs(num2 - num1) + 1; + const indiceAleatorio = Math.floor(Math.random() * rango); + // Obtener el carácter correspondiente al índice aleatorio + const caracterAleatorio = String.fromCharCode(Math.min(num1, num2) + indiceAleatorio); + + // Devolver el carácter aleatorio + return caracterAleatorio; + } + + +console.log(generar_contrasena(8,"si","si","si")) +console.log(generar_contrasena(9,"no","si","si")) +console.log(generar_contrasena(10,"si","no","si")) +console.log(generar_contrasena(11,"si","si","no")) +console.log(generar_contrasena(12,"no","no","no")) +console.log(generar_contrasena(13,"no","si","si")) +console.log(generar_contrasena(200,"no","si","si")) +//console.log(caracterAleatorioEntreNumeros(122, 122)) +//const numeroAleatorio = Math.floor(Math.random() * 5) + 1; + +//console.log(numeroAleatorio); \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/jaimegamm.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/jaimegamm.py" new file mode 100644 index 0000000000..0c17e3c080 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/jaimegamm.py" @@ -0,0 +1,31 @@ +import random +import string + +def generar_contrasena(longitud, incluir_mayusculas, incluir_numeros, incluir_simbolos): + caracteres = string.ascii_letters if incluir_mayusculas else string.ascii_lowercase + caracteres += string.digits if incluir_numeros else '' + caracteres += string.punctuation if incluir_simbolos else '' + + if len(caracteres) == 0: + print("Error: Debes incluir al menos un tipo de caracter en la contraseña.") + return None + + contrasena = ''.join(random.choice(caracteres) for _ in range(longitud)) + return contrasena + +def main(): + print("Generador de Contraseñas Aleatorias") + longitud = int(input("Longitud de la contraseña (entre 8 y 16): ")) + incluir_mayusculas = input("¿Incluir letras mayúsculas? (si/no): ").lower() == 'si' + incluir_numeros = input("¿Incluir números? (si/no): ").lower() == 'si' + incluir_simbolos = input("¿Incluir símbolos? (si/no): ").lower() == 'si' + + if 8 <= longitud <= 16: + contrasena = generar_contrasena(longitud, incluir_mayusculas, incluir_numeros, incluir_simbolos) + if contrasena: + print("Contraseña generada: ", contrasena) + else: + print("Error: La longitud de la contraseña debe estar entre 8 y 16.") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/restevean.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/restevean.py" new file mode 100644 index 0000000000..b87d559d5e --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/restevean.py" @@ -0,0 +1,54 @@ +import random +import string + + +def generate_password(length, use_uppercase, use_numbers, use_symbols): + allowed_chars = string.ascii_lowercase + if use_uppercase: + allowed_chars += string.ascii_uppercase + if use_numbers: + allowed_chars += string.digits + if use_symbols: + allowed_chars += string.punctuation + if length < 8 or length > 16: + # raise ValueError("La longitud debe estar entre 8 y 16") + length = 8 + + return ''.join(random.choice(allowed_chars) for _ in range(length)) + + +def generate_password_2(length=8, use_uppercase=True, use_numbers=True, use_symbols=True): + lowercase_letters = "abcdefghijklmnopqrstuvwxyz" + uppercase_letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" if use_uppercase else "" + numbers = "0123456789" if use_numbers else "" + symbols = "!@#$%^&*()" if use_symbols else "" + + allowed_chars = lowercase_letters + uppercase_letters + numbers + symbols + if length < 8 or length > 16: + # raise ValueError("La longitud debe estar entre 8 y 16") + length = 8 + + return ''.join(random.choice(allowed_chars) for _ in range(length)) + + +def main(): + password = generate_password(16, False, False, False) + print(password) + password = generate_password(16, False, False, True) + print(password) + password = generate_password(16, False, True, True) + print(password) + password = generate_password(16, True, True, True) + print(password) + password = generate_password_2(16, False, False, False) + print(password) + password = generate_password_2(16, False, False, True) + print(password) + password = generate_password_2(16, False, True, True) + print(password) + password = generate_password_2(16, True, True, True) + print(password) + + +if __name__ == '__main__': + main() diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/scala/avelasquezhe84.scala" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/scala/avelasquezhe84.scala" new file mode 100644 index 0000000000..be5bada961 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/scala/avelasquezhe84.scala" @@ -0,0 +1,17 @@ +// usage: scala-cli avelasquezhe84.scala 8 -u -s -n -> generates 8 char password with lower, upper, symbols and numbers + +@main def main(args: String*) = + val lower = ('a' to 'z').toList + val upper = ('A' to 'Z').toList + val symbols = (' ' to '/').toList ++: + (':' to '@').toList ++: + ('[' to '`').toList ++: + ('{' to '~').toList + val nums = ('0' to '9').toList + var chars = lower + if args.contains("-u") then chars = chars ++ upper + if args.contains("-s") then chars = chars ++ symbols + if args.contains("-n") then chars = chars ++ nums + val length = args(0).toInt + val password = (1 to length).map(_ => chars(scala.util.Random.nextInt(chars.length))).mkString + println(password) diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/swift/jcalderita.swift" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/swift/jcalderita.swift" new file mode 100644 index 0000000000..99c997ec5d --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/swift/jcalderita.swift" @@ -0,0 +1,15 @@ +import Foundation + +func generatePassword() -> String { + let characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+{}|:<>?" + let length = Int.random(in: 8 ... 16) + + return String((1 ... length).compactMap { _ in + characters.randomElement() + }) + } + +print(generatePassword()) +print(generatePassword()) +print(generatePassword()) +print(generatePassword()) \ No newline at end of file diff --git "a/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/python/jelambrar96.py" "b/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/python/jelambrar96.py" new file mode 100644 index 0000000000..7332e7c331 --- /dev/null +++ "b/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/python/jelambrar96.py" @@ -0,0 +1,81 @@ +#!/usr/bin/python3 + +""" +# Reto #31: El ábaco +/* + * Crea una función que sea capaz de leer el número representado por el ábaco. + * - El ábaco se representa por un array con 7 elementos. + * - Cada elemento tendrá 9 "O" (aunque habitualmente tiene 10 para realizar operaciones) + * para las cuentas y una secuencia de "---" para el alambre. + * - El primer elemento del array representa los millones, y el último las unidades. + * - El número en cada elemento se representa por las cuentas que están a la izquierda del alambre. + * + * Ejemplo de array y resultado: + * ["O---OOOOOOOO", + * "OOO---OOOOOO", + * "---OOOOOOOOO", + * "OO---OOOOOOO", + * "OOOOOOO---OO", + * "OOOOOOOOO---", + * "---OOOOOOOOO"] + * + * Resultado: 1.302.790 + */ +""" + +import random + + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + + +def abaco_a_numero(lista_string): + lista_string = lista_string[::-1] + digitos = [ abaco_a_digito(item) for item in lista_string ] + return sum([ item * 10 ** i for i, item in enumerate(digitos) ]) + + +def digito_a_abaco(numero: int): + return "0" * numero + "---" + "0"*(10 - numero) + + +def abaco_a_digito(cadena: str): + return len(cadena.split("---")[0]) + + +def numero_a_abaco(numero: int): + lista_cifras = [] + while numero > 0: + cifra = numero % 10 + numero //= 10 + lista_cifras.append(cifra) + lista_cifras = lista_cifras + (7 - len(lista_cifras)) * [0] + lista_cifras = lista_cifras[::-1] + return [ digito_a_abaco(item) for item in lista_cifras] + + +def dibujar_abaco(abaco: list): + for item in abaco: + print(item) + + +if __name__ == '__main__': + + for i in range(10): + + numero = random.randint(1, 9999999) + print("Numero original:", numero) + abaco = numero_a_abaco(numero) + dibujar_abaco(abaco) + numero_traducido = abaco_a_numero(abaco) + print("Numero traducido: ", numero_traducido) + + print() + diff --git a/Retos/Reto #38 - LAS SUMAS [Media]/go/texelh4ck.go b/Retos/Reto #38 - LAS SUMAS [Media]/go/texelh4ck.go new file mode 100644 index 0000000000..e3a842902c --- /dev/null +++ b/Retos/Reto #38 - LAS SUMAS [Media]/go/texelh4ck.go @@ -0,0 +1,50 @@ +/* +================================================ + + Author: texelh4ck + +================================================ +*/ +package main + +import ( + "fmt" + "sort" +) + +func combinator(list []int, target int) [][]int { + var result [][]int + + var find func(start int, r int, temp []int) + find = func(start int, r int, temp []int) { + // Agrega el resultado correcto a result + if r == 0 { + result = append(result, temp) + return + } + + if start == len(list) || r < 0 { + return + } + + for i := start; i < len(list); i++ { + if i > 0 && list[i] == list[i-1] { + continue + } + temp = append(temp, list[i]) + find(i+1, r-list[i], temp) + temp = temp[:len(temp)-1] // Quita el último elemento agregado + } + } + + // Ordena la lista + sort.Ints(list) + // Ejecuta el algoritmo backtrack + find(0, target, []int{}) + return result +} + +func main() { + + fmt.Println(combinator([]int{1, 3, 4, 2}, 7)) +} diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/jaimegamm.js b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/jaimegamm.js new file mode 100644 index 0000000000..5da0da88b4 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/jaimegamm.js @@ -0,0 +1,45 @@ +/*# Reto #4: PRIMO, FIBONACCI Y PAR +#### Dificultad: Media | Publicación: 23/01/23 | Corrección: 30/01/23 + +## Enunciado + + * Escribe un programa que, dado un número, compruebe y muestre si es primo, fibonacci y par. + * Ejemplos: + * - Con el número 2, nos dirá: "2 es primo, fibonacci y es par" + * - Con el número 7, nos dirá: "7 es primo, no es fibonacci y es impar" + +*/ + +function esPrimo(numero) { + for (let i = 2; i < numero; i++) { + if (numero % i === 0) { + return false; + } + } + return numero > 1; +} + +function esPar(numero) { + return numero % 2 === 0; +} + +function esFibonacci(numero) { + const sqrt5 = Math.sqrt(5); + const phi = (1 + sqrt5) / 2; + + const a = phi * numero; + return Number.isInteger(a) && a > 0; +} + +function analizarNumero(numero) { + const esPrimoResultado = esPrimo(numero) ? "es primo" : "no es primo"; + const esParResultado = esPar(numero) ? "es par" : "es impar"; + const esFibonacciResultado = esFibonacci(numero) ? "es fibonacci" : "no es fibonacci"; + + console.log(`${numero} ${esPrimoResultado}, ${esFibonacciResultado} y ${esParResultado}`); +} + +// Ejemplos de uso: +analizarNumero(2); +analizarNumero(7); + diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/jaimegamm.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/jaimegamm.py new file mode 100644 index 0000000000..bd67b8bb28 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/jaimegamm.py @@ -0,0 +1,48 @@ +''' * Escribe un programa que, dado un número, compruebe y muestre si es primo, fibonacci y par. + * Ejemplos: + * - Con el número 2, nos dirá: "2 es primo, fibonacci y es par" + * - Con el número 7, nos dirá: "7 es primo, no es fibonacci y es impar"''' + +def es_primo(numero): + if numero < 2: + return False + for i in range(2, int(numero**0.5) + 1): + if numero % i == 0: + return False + return True + +def es_fibonacci(numero): + a, b = 0, 1 + while a <= numero: + if a == numero: + return True + a, b = b, a + b + return False + +def es_par(numero): + return numero % 2 == 0 + +def main(): + numero = int(input("Ingrese un número: ")) + + if es_primo(numero): + primo_str = "es primo" + else: + primo_str = "no es primo" + + if es_fibonacci(numero): + fibonacci_str = "es fibonacci" + else: + fibonacci_str = "no es fibonacci" + + if es_par(numero): + par_str = "es par" + else: + par_str = "es impar" + + resultado = f"{numero} {primo_str}, {fibonacci_str} y {par_str}" + print(resultado) + main() + +if __name__ == "__main__": + main() diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/thonys07.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/thonys07.py new file mode 100644 index 0000000000..8759c6b612 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/thonys07.py @@ -0,0 +1,55 @@ +""" + * Escribe un programa que, dado un número, compruebe y muestre si es primo, fibonacci y par. + * Ejemplos: + * - Con el número 2, nos dirá: "2 es primo, fibonacci y es par" + * - Con el número 7, nos dirá: "7 es primo, no es fibonacci y es impar" + +""" +from math import sqrt + + +def primos (n): + if n > 1: + for i in range(2, n): + if n % i == 0: + return False + return True + + else: return False + +def cuadrado_perfecto(n): + raiz = int(n**0.5) + return n == raiz**2 +def fibonacci(n): + if cuadrado_perfecto(5*n**2+4) or cuadrado_perfecto(5*n**2-4) : + return True + else: + return False +def par(n): + if n % 2 == 0: + return True + else: + return False + +def prim_fibo_par(): + n=int(input("Ingresa un numero: ")) + resultado=f"el numero {n} " + if primos(n): + resultado+="es primo, " + else: + resultado+="no es primo, " + if fibonacci(n): + resultado+="es fibonacci " + else: + resultado+="no es fibonacci " + if par(n): + resultado+="y es par" + else: + resultado+="y es impar" + + print(resultado) + + +prim_fibo_par() + + \ No newline at end of file diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/scala/avelasquezhe84.scala b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/scala/avelasquezhe84.scala new file mode 100644 index 0000000000..77367bcd98 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/scala/avelasquezhe84.scala @@ -0,0 +1,32 @@ +import scala.math.sqrt +import scala.math.floor + +@main def main(args: String*) = + val number = args(0).toInt + val prime = if isPrime(number) then "es primo" else "no es primo" + val fibonacci = if isFibonacci(number) then "es fibonacci" else "no es fibonacci" + val even = if isEven(number) then "es par" else "es impar" + println(s"$number $prime, $fibonacci, $even") + + +def isEven(num: Int): Boolean = num % 2 == 0 + +def isPrime(num: Int): Boolean = + if num < 0 then false + else if num < 4 then true + else if isEven(num) then false + else + val upperLimit = floor(sqrt(num)).toInt + val factors = (2 to upperLimit).toList + val res = factors.map(f => num % f == 0) + !res.contains(true) + +// A number is Fibonacci if and only if one or both of (5*n2 + 4) or (5*n2 – 4) is a perfect square +// Source: http://en.wikipedia.org/wiki/Fibonacci_number#Recognizing_Fibonacci_numbers + +def isFibonacci(num: Int): Boolean = + isPerfectSquare(5*num*num+4) || isPerfectSquare(5*num*num-4) + +def isPerfectSquare(num: Int): Boolean = + val s = sqrt(num).toInt + s * s == num \ No newline at end of file diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/swift/jcalderita.swift b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/swift/jcalderita.swift new file mode 100644 index 0000000000..533d30dba1 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/swift/jcalderita.swift @@ -0,0 +1,51 @@ +import Foundation + +func isPrime(_ num: Int) -> Bool { + guard num > 1 else { + return false + } + + return (1 ... num) + .filter { num % $0 == 0 } + .count == 2 +} + +func isFibonacci(_ num: Int) -> Bool { + let numberPart = 5 * num * num + + let isPerfectSquare: (Int) -> Bool = { n in + let total = numberPart + n + let result = Int(sqrt(Double(total))) + + return result * result == total + } + + return isPerfectSquare(4) || isPerfectSquare(-4) +} + +func isPrimeFibonacciEven(_ num: Int) -> String { + var msg: String = num.description + + if isPrime(num) { + msg.append(" es primo,") + } else { + msg.append(" no es primo,") + } + + if isFibonacci(num) { + msg.append(" fibonacci ") + } else { + msg.append(" no es fibonacci ") + } + + if num % 2 == 0 { + msg.append("y es par.") + } else { + msg.append("y es impar.") + } + + return msg +} + +print(isPrimeFibonacciEven(2)) +print(isPrimeFibonacciEven(7)) \ No newline at end of file diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/jelambrar96.py" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/jelambrar96.py" new file mode 100644 index 0000000000..f7bd8eb8fb --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/jelambrar96.py" @@ -0,0 +1,36 @@ +#!/usr/bin/python3 + +""" +# Reto #40: Tabla de multiplicar +/* + * Crea un programa que sea capaz de solicitarte un número y se + * encargue de imprimir su tabla de multiplicar entre el 1 y el 10. + * - Debe visualizarse qué operación se realiza y su resultado. + * Ej: 1 x 1 = 1 + * 1 x 2 = 2 + * 1 x 3 = 3 + * ... + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + +def tabla_multiplicar(numero: int): + for i in range(1, 11): + print(f"{numero} x {i} = {numero * i}") + + +if __name__ == '__main__': + + print("Tablas del multiplicar del 1 al 10\n") + + for i in range(1,11): + tabla_multiplicar(i) + print() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/evaapinaa.java" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/evaapinaa.java" new file mode 100644 index 0000000000..01cfbde664 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/evaapinaa.java" @@ -0,0 +1,139 @@ +package reto; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import java.util.Scanner; +import java.util.concurrent.atomic.AtomicBoolean; + +/* + * Crea un juego interactivo por terminal en el que tendrás que adivinar + * el resultado de diferentes + * operaciones matemáticas aleatorias (suma, resta, multiplicación + * o división de dos números enteros). + * - Tendrás 3 segundos para responder correctamente. + * - El juego finaliza si no se logra responder en ese tiempo. + * - Al finalizar el juego debes mostrar cuántos cálculos has acertado. + * - Cada 5 aciertos debes aumentar en uno el posible número de cifras + * de la operación (cada vez en un operando): + * - Preguntas 1 a 5: X (entre 0 y 9) operación Y (entre 0 y 9) + * - Preguntas 6 a 10: XX (entre 0 y 99) operación Y (entre 0 y 9) + * - Preguntas 11 a 15: XX operación YY + * - Preguntas 16 a 20: XXX (entre 0 y 999) operación YY + * ... + */ + + +// SOLUCIÓN IMPLEMENTADA CON THREADS + +public class Adivinanzas { + + // Constante tiempo en milisegundos + public static final int MILISEGUNDOS = 3000; + + public static int contadorAciertos = 0; + public static Random randomIndice = new Random(); + public static List operaciones = new ArrayList(); + public static final Scanner scanner = new Scanner(System.in); + public static AtomicBoolean continuar = new AtomicBoolean(true); + public static int incrementadorX = 1; + public static int incrementadorY = 1; + public static int turno = 0; + + public static void main(String[] args) { + + Collections.addAll(operaciones, "+", "-", "*", "/"); // Añadir al array las operaciones que vamos a necesitar + + while (continuar.get()) { + juegoAdivinanzas(); // Mientras la variable continuar sea true, el juego sigue + } + } + + // Función para resolver la operación generada, e imprimirla + public static int resolver(String operacion, int num1, int num2) { + + int resultadoOperacion = 0; + + // Switch para traducir las operaciones + switch (operacion) { + case "+": + resultadoOperacion = num1 + num2; break; + case "-": + resultadoOperacion = num1 - num2; break; + case "*": + resultadoOperacion = num1 * num2; break; + case "/": + if (num2 == 0) { + num2++; // Evitamos la división entre 0 + resultadoOperacion = num1 / num2; + } + break; + } + + System.out.println(num1 + " " + operacion + " " + num2 + ": "); + + return resultadoOperacion; + } + + // Método principal del juego + public static void juegoAdivinanzas() { + int resultado; + Random random = new Random(); + + try { + + // Hilo temporizador. Duerme durante 3 segundos, si no se responde finaliza el programa + Thread hiloTiempo = new Thread(() -> { + try { + Thread.sleep(MILISEGUNDOS); + System.out.println("\n¡Tiempo agotado!"); + System.out.println("Juego finalizado. Número de aciertos: " + contadorAciertos); + continuar.set(false); + scanner.close(); + System.exit(0); + } catch (InterruptedException e) { + } + + }); + + // Iniciar el hilo temporizador + hiloTiempo.start(); + + try { + // generamos una operación a resolver y comparamos su resultado con la entrada + resultado = resolver(operaciones.get(randomIndice.nextInt(operaciones.size())), + random.nextInt(10 * incrementadorX), random.nextInt(10 * incrementadorY)); + int resultadoUser = Integer.parseInt(scanner.next()); + if (resultado == resultadoUser) { + contadorAciertos++; + if (contadorAciertos % 5 == 0) { + // Variable turno, para incrementar el número de cifras en el operando correspondiente + turno = (turno + 1) % 4; + switch (turno) { + case 0: + incrementadorY *= 10; break; + case 1: + incrementadorX *= 10; break; + case 2: + incrementadorY *= 10; break; + case 3: + incrementadorX *= 10; break; + } + } + } + } finally { + // Si se introduce un resultado, el hilo finaliza y se reinicia para el próximo + hiloTiempo.interrupt(); + } + } catch (NumberFormatException e) { + // Si no se introduce un entero válido, finaliza + System.err.println("Número no válido. " + e.getMessage()); + System.out.println("Juego finalizado. Número de aciertos: " + contadorAciertos); + scanner.close(); + System.exit(0); + } + + } + +} diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/javascript/patriciotrujilllo.js" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/javascript/patriciotrujilllo.js" new file mode 100644 index 0000000000..6bd6e4a3f6 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/javascript/patriciotrujilllo.js" @@ -0,0 +1,85 @@ +/* + * ¿Conoces el calendario de aDEViento de la comunidad (https://adviento.dev)? + * 24 días, 24 regalos sorpresa relacionados con desarrollo de software. + * Desde el 1 al 24 de diciembre. + * + * Crea un programa que simule el mecanismo de participación: + * - Mediante la terminal, el programa te preguntará si quieres añadir y borrar + * participantes, mostrarlos, lanzar el sorteo o salir. + * - Si seleccionas añadir un participante, podrás escribir su nombre y pulsar enter. + * - Si seleccionas añadir un participante, y este ya existe, avisarás de ello. + * (Y no lo duplicarás) + * - Si seleccionas mostrar los participantes, se listarán todos. + * - Si seleccionas eliminar un participante, podrás escribir su nombre y pulsar enter. + * (Avisando de si lo has eliminado o el nombre no existe) + * - Si seleccionas realizar el sorteo, elegirás una persona al azar + * y se eliminará del listado. + * - Si seleccionas salir, el programa finalizará. + */ + +const readline = require('node:readline/promises') + +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout +}) +let arr = [] + +async function adviento() { + + const res = await rl.question(`Escoja la accion a realiza\n + 1-Agregar participante \n + 2-Eliminar participante \n + 3-Mostrar participantes\n + 4-Comenzar sorteo\n + 5-Salir\n`) + console.log(`Escogio la opcion: ${res}`) + + if (res === '1') { + const person = await rl.question(`Ingrese al participante: `) + const duplicate = arr.includes(person) + if (duplicate) { + console.log(`${person} ya ha existe en la lista`) + } + else { + arr.push(person) + console.log(`Se agrego a: ${person}`) + } + adviento() + } + else if (res === '2') { + const person = await rl.question(`Ingrese el participante a Eliminar: `) + const exists = arr.includes(person) + if (exists) { + arr = arr.filter(word => word !== person) + console.log(arr) + console.log(`Se elimino a ${person}`) + } + else { + console.log(`No existe ${person} en la lista`) + } + adviento() + } + else if (res === '3') { + let a = 0 + arr.forEach(element => { + a += 1 + console.log(`${a}-${element}`) + }) + adviento() + } + else if (res === '4') { + const indice = Math.floor(Math.random() * arr.length) + console.log(`Se ha escogido a: ${arr[indice]}`) + arr = arr.filter(win => win !== arr[indice]) + adviento() + } + else if (res === '5') { + rl.close() + } + else { + console.log(`Opcion no valida`) + adviento() + } +} +adviento() \ No newline at end of file diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/LautaroG2020.py b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/LautaroG2020.py new file mode 100644 index 0000000000..1de5757e0a --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/LautaroG2020.py @@ -0,0 +1,95 @@ +# /* +# * Crea un programa que simule la competición de dos coches en una pista. +# * - Los dos coches estarán representados por 🚙 y 🚗. Y la meta por 🏁. +# * - Cada pista tendrá entre 1 y 3 árboles 🌲 colocados de forma aleatoria. +# * - Las dos pistas tendrán una longitud configurable de guiones bajos "_". +# * - Los coches comenzarán en la parte derecha de las pistas. Ejemplo: +# * 🏁____🌲_____🚙 +# * 🏁_🌲____🌲___🚗 +# * +# * El juego se desarrolla por turnos de forma automática, y cada segundo +# * se realiza una acción sobre los coches (moviéndose a la vez), hasta que +# * uno de ellos (o los dos a la vez) llega a la meta. +# * - Acciones: +# * - Avanzar entre 1 a 3 posiciones hacia la meta. +# * - Si al avanzar, el coche finaliza en la posición de un árbol, +# * se muestra 💥 y no avanza durante un turno. +# * - Cada turno se imprimen las pistas y sus elementos. +# * - Cuando la carrera finalice, se muestra el coche ganador o el empate. +# */ + +from enum import Enum +import os +import random +import time + +class Textures(Enum): + EMPTY = "_" + TREE = "🌲" + FINISH = "🏁" + CRASH = "💥" + CAR1 = "🚙" + CAR2 = "🚗" + +class Car: + def __init__(self, name: str, texture: str, position: int): + self.name = name + self.texture = texture + self.position = position + self.crashed = False + + def move(self, distance: int, trees: list): + if self.crashed: + self.crashed = False + self.texture = Textures.CAR1.value if self.name == "Car1" else Textures.CAR2.value + return + + if self.position - distance in trees: + self.position -= distance + self.crashed = True + self.texture = Textures.CRASH.value + return + + self.position -= distance + +class Race: + def __init__(self, length: int, trees: int): + self.length = length + self.trees = random.sample(range(1, length - 1), trees) + self.car1 = Car("Car1", Textures.CAR1.value, length - 1) + self.car2 = Car("Car2", Textures.CAR2.value, length - 1) + self.track1 = [Textures.EMPTY.value] * length + self.track2 = [Textures.EMPTY.value] * length + + def _generate_track(self): + self.track1[0] = Textures.FINISH.value + self.track2[0] = Textures.FINISH.value + for tree in self.trees: + self.track1[tree] = Textures.TREE.value + self.track2[tree] = Textures.TREE.value + + def _print_track(self): + print("Pista 1".center(50, "-") + "\n") + print("".join(self.track1[:self.car1.position]) + (self.car1.texture) + "".join(self.track1[self.car1.position + 1:])) + print("Pista 2".center(50, "-") + "\n") + print("".join(self.track2[:self.car2.position]) + (self.car2.texture) + "".join(self.track2[self.car2.position + 1:])) + + + def start(self): + self._generate_track() + while self.car1.position >= 0 and self.car2.position >= 0: + self.car1.move(random.randint(1, 3), self.trees) + self.car2.move(random.randint(1, 3), self.trees) + self._print_track() + time.sleep(0.2) + os.system('cls') + + if self.car1.position == 0 and self.car2.position == 0: + return print("Empate") + if self.car1.position <= 0: + return print("El auto 1 ganó") + if self.car2.position <= 0: + return print("El auto 2 ganó") + +race = Race(20, 5) +race.start() diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/lucasjappert.py b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/lucasjappert.py new file mode 100644 index 0000000000..720b907d4b --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/lucasjappert.py @@ -0,0 +1,109 @@ +''' + * Crea un programa que simule la competición de dos coches en una pista. + * - Los dos coches estarán representados por 🚙 y 🚗. Y la meta por 🏁. + * - Cada pista tendrá entre 1 y 3 árboles 🌲 colocados de forma aleatoria. + * - Las dos pistas tendrán una longitud configurable de guiones bajos "_". + * - Los coches comenzarán en la parte derecha de las pistas. Ejemplo: + * 🏁____🌲_____🚙 + * 🏁_🌲____🌲___🚗 + * + * El juego se desarrolla por turnos de forma automática, y cada segundo + * se realiza una acción sobre los coches (moviéndose a la vez), hasta que + * uno de ellos (o los dos a la vez) llega a la meta. + * - Acciones: + * - Avanzar entre 1 a 3 posiciones hacia la meta. + * - Si al avanzar, el coche finaliza en la posición de un árbol, + * se muestra 💥 y no avanza durante un turno. + * - Cada turno se imprimen las pistas y sus elementos. + * - Cuando la carrera finalice, se muestra el coche ganador o el empate. +''' + +MAX_NUMBER_OF_TREES_BY_TRACK = 10 +TRACK_LENGTH: int = 50 +SLEEP_IN_SECONDS_TO_USE_IN_THE_WHILE_LOOP: float = 0.2 + +from enum import Enum +import os +import time +import random + +class Car: + def __init__(self, texture: str, position: int, id: int): + self.texture = texture + self.position = position + self.missed_turn = False + self.id = id + + def update(self, trees_positions_of_track1: list[int]): + if self.missed_turn: + self.missed_turn = False + return + + self.position -= random.randint(1, 3) + if self.position < 0: self.position = 0 + + self.missed_turn = self.position in trees_positions_of_track1 + +class Textures(Enum): + tree = "🌲" + car1 = "🚙" + car2 = "🚗" + road_part = "_" + explotion = "💥" + flag = "🏁" + +def _get_random_positions_of_trees(): + trees_positions: list[int] = [] + while MAX_NUMBER_OF_TREES_BY_TRACK > len(trees_positions): + random_position = random.randint(1, TRACK_LENGTH-2) + if random_position not in trees_positions: + trees_positions.append(random_position) + return trees_positions + +def _get_part_of_track(car: Car, part_of_track_index: int, trees_positions: list[int]): + if car.position == part_of_track_index == 0: return car.texture + + if part_of_track_index == 0: return Textures.flag.value + + if part_of_track_index in trees_positions: + if car.position == part_of_track_index: return Textures.explotion.value + return Textures.tree.value + + if car.position == part_of_track_index: return car.texture + + return Textures.road_part.value + +def _print_results(car1: Car, car2: Car): + separator = "##################################################" + if car1.position == 0 == car2.position: + return print(f"{separator}\n La carrera ha finalizado con un EMPATE \n{separator}") + + if car1.position == 0: return print(f"{separator}\n Ha ganado el AUTO {car1.texture} \n{separator}") + if car2.position == 0: return print(f"{separator}\n Ha ganado el AUTO {car2.texture} \n{separator}") + +def _print_track_car(car: Car, trees_positions_of_track: list[int]): + text_track = "" + for track_index in range(TRACK_LENGTH): + text_track += _get_part_of_track(car, track_index, trees_positions_of_track) + print(text_track) + +def start_race(): + car1 = Car(Textures.car1.value, TRACK_LENGTH - 1, 1) + car2 = Car(Textures.car2.value, TRACK_LENGTH - 1, 2) + trees_positions_of_track1 = _get_random_positions_of_trees() + trees_positions_of_track2 = _get_random_positions_of_trees() + + while (0 not in [car1.position, car2.position]): + os.system("cls") + + car1.update(trees_positions_of_track1) + car2.update(trees_positions_of_track2) + + _print_track_car(car1, trees_positions_of_track1) + _print_track_car(car2, trees_positions_of_track2) + + time.sleep(SLEEP_IN_SECONDS_TO_USE_IN_THE_WHILE_LOOP) + + _print_results(car1, car2) + +start_race() \ No newline at end of file diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/c++/dylanb55.cpp" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/c++/dylanb55.cpp" new file mode 100644 index 0000000000..1d03d0b322 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/c++/dylanb55.cpp" @@ -0,0 +1,54 @@ +#include +#include + + +int main(){ + + int suma = 0; + std::string palabra; + char rpt; + do{ + + suma = 0; + std::cout << "Ingrese una palabra para calcular si llegara a 100 puntos: " << std::endl; + std::getline(std::cin,palabra); + + + //Transformamos la palabra a mayusculas para evitar problemas + for(int i = 0; i < palabra.length(); i++){ + palabra[i] = toupper(palabra[i]); + } + + + //Si existen espacios en la palabra los borraremos para evitar problemas con el algoritmo de obtencion de puntos + + palabra.erase(remove(palabra.begin(), palabra.end(), ' '), palabra.end()); + + //Obteniendo los puntos de la palabra + for(int i = 0; i < palabra.length();i++){ + suma+= palabra[i] - 64; + } + + if(suma > 100){ + std::cout << "Tu palabra sumo " << suma << " lo cual es mayor a 100 puntos" << std::endl; + std::cout << "Desea volver a intentarlo? (S/N) " << std::endl; + std::cin >> rpt; + } + + else if(suma < 100){ + std::cout << "Tu palabra sumo " << suma << " lo cual es menor a 100 puntos" << std::endl; + std::cout << "Desea volver a intentarlo? (S/N) " << std::endl; + std::cin >> rpt; + } + else{ + std::cout << "Enhorahora buena tu palabra sumo los 100 puntos" << std::endl; + std::cout << "Fin del juego" << std::endl; + } + + std::cin.ignore(); + + }while(rpt == 'S' or rpt == 's' and suma != 100); + + + return 0; +} diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/javascript/patriciotrujilllo.js" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/javascript/patriciotrujilllo.js" new file mode 100644 index 0000000000..163792a801 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/javascript/patriciotrujilllo.js" @@ -0,0 +1,46 @@ +/* + * La última semana de 2021 comenzamos la actividad de retos de programación, + * con la intención de resolver un ejercicio cada semana para mejorar + * nuestra lógica... ¡Hemos llegado al EJERCICIO 100! Gracias 🙌 + * + * Crea un programa que calcule los puntos de una palabra. + * - Cada letra tiene un valor asignado. Por ejemplo, en el abecedario + * español de 27 letras, la A vale 1 y la Z 27. + * - El programa muestra el valor de los puntos de cada palabra introducida. + * - El programa finaliza si logras introducir una palabra de 100 puntos. + * - Puedes usar la terminal para interactuar con el usuario y solicitarle + * cada palabra. + */ + +const readline = require('node:readline') + +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout +}) + +function wordCounter(word) { + const alfabeto = 'abcdefghijklmnñopqrstuvwxyz'; + let sum = 0 + word.toLowerCase().split('').forEach(letra => { + const contador = alfabeto.indexOf(letra) + 1 + console.log(`La letra ${letra} tiene un valor de ${contador}`) + sum += contador + }) + // const array = alfabeto.split('').findIndex(l => l === letra) + 1 + return sum +} +let sum = 0 + +function Question() { + if (sum !== 100) { + rl.question('Ingrese una palabra para conseguir los 100 puntos: ', (word) => { + sum = wordCounter(word) + Question() + }) + } + else { + rl.close() + } +} +Question() diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/ericc91.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/ericc91.py" new file mode 100644 index 0000000000..87989b76b1 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/ericc91.py" @@ -0,0 +1,37 @@ +"""/* + * La última semana de 2021 comenzamos la actividad de retos de programación, + * con la intención de resolver un ejercicio cada semana para mejorar + * nuestra lógica... ¡Hemos llegado al EJERCICIO 100! Gracias 🙌 + * + * Crea un programa que calcule los puntos de una palabra. + * - Cada letra tiene un valor asignado. Por ejemplo, en el abecedario + * español de 27 letras, la A vale 1 y la Z 27. + * - El programa muestra el valor de los puntos de cada palabra introducida. + * - El programa finaliza si logras introducir una palabra de 100 puntos. + * - Puedes usar la terminal para interactuar con el usuario y solicitarle + * cada palabra. + */""" + +#word=str(input("Entre una palabra: ")) +letter={} +cont=0 +for i in range(ord('a'), ord('n')+1): + cont+=1 + letter[chr(i)]=cont +letter["ñ"]=15 +for l in range(ord('o'),ord('z')+1): + cont+=1 + letter[chr(l)]=cont+1 + +while True: + word=input("Introduce una palabra: ") + if len(word.split()) > 1: + print("Error: Por favor, introduce solo una palabra.") + continue + sum=0 + for i in word.lower(): + sum+=letter.get(i) + print(f'Lo siento, la palabra {word} tiene {sum} puntos.') + if sum == 100: + print(f"Felicidades, la palabra {word} tiene {sum} puntos") + break \ No newline at end of file diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/jelambrar96.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/jelambrar96.py" new file mode 100644 index 0000000000..61eb286975 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/jelambrar96.py" @@ -0,0 +1,56 @@ +#!/usr/bin/python3 + +""" +# Reto #47: La palabra de 100 puntos +/* + * La última semana de 2021 comenzamos la actividad de retos de programación, + * con la intención de resolver un ejercicio cada semana para mejorar + * nuestra lógica... ¡Hemos llegado al EJERCICIO 100! Gracias 🙌 + * + * Crea un programa que calcule los puntos de una palabra. + * - Cada letra tiene un valor asignado. Por ejemplo, en el abecedario + * español de 27 letras, la A vale 1 y la Z 27. + * - El programa muestra el valor de los puntos de cada palabra introducida. + * - El programa finaliza si logras introducir una palabra de 100 puntos. + * - Puedes usar la terminal para interactuar con el usuario y solicitarle + * cada palabra. + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + + + +LISTA_LETRAS = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', + 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', + 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] + + +def puntos_palabra(palabra: str): + puntos = sum([ LISTA_LETRAS.index(item) for item in palabra ]) + puntos += len(palabra) + return puntos + + +def main(): + while True: + palabra = input("Escriba una palabra que llegue a 100 puntos: ") + palabra = palabra.lower() + puntos = puntos_palabra(palabra) + if puntos == 100: + print("Has ganado, tu palabra tiene 100 puntos") + break + print(f"Su palabra tiene un valor de {puntos} puntos") + + +if __name__ == '__main__': + main() + + diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/jaimegamm.js" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/jaimegamm.js" new file mode 100644 index 0000000000..c366cf0c3d --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/jaimegamm.js" @@ -0,0 +1,8 @@ +/* +Escribe un !Hola Mundo! en todos los lenguajes de programación que puedas. +Seguro que hay algún lenguaje que te llama la atención y nunca has utilizado, +o quizás quieres dar tus primeros pasos... ¡Pues este es el momento! +A ver quién se atreve con uno de esos lenguajes que no solemos ver por ahí... +*/ + +console.log("¡Hola Mundo!"); \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/jaimegamm.py" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/jaimegamm.py" new file mode 100644 index 0000000000..a24b7843ee --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/jaimegamm.py" @@ -0,0 +1,8 @@ +""" +Escribe un !Hola Mundo! en todos los lenguajes de programación que puedas. +Seguro que hay algún lenguaje que te llama la atención y nunca has utilizado, +o quizás quieres dar tus primeros pasos... ¡Pues este es el momento! +A ver quién se atreve con uno de esos lenguajes que no solemos ver por ahí... +""" + +print("¡Hola Mundo!") \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..d952bb0d84 --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,3 @@ +import Foundation + +print("Hello World!!!") \ No newline at end of file diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/jaimegamm.js b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/jaimegamm.js new file mode 100644 index 0000000000..de77166436 --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/jaimegamm.js @@ -0,0 +1,74 @@ +// # ## Enunciado +// # ``` +// # /* +// # * Crea un programa que calcule quien gana más partidas al piedra, +// # * papel, tijera, lagarto, spock. +// # * - El resultado puede ser: "Player 1", "Player 2", "Tie" (empate) +// # * - La función recibe un listado que contiene pares, representando cada jugada. +// # * - El par puede contener combinaciones de "🗿" (piedra), "📄" (papel), +// # * "✂️" (tijera), "🦎" (lagarto) o "🖖" (spock). +// # * - Ejemplo. Entrada: [("🗿","✂️"), ("✂️","🗿"), ("📄","✂️")]. Resultado: "Player 2". +// # * - Debes buscar información sobre cómo se juega con estas 5 posibilidades. +// # */ +// # ``` +// # ## Enunciado +// # ``` +// # /* +// # * Crea un programa que calcule quien gana más partidas al piedra, +// # * papel, tijera, lagarto, spock. +// # * - El resultado puede ser: "Player 1", "Player 2", "Tie" (empate) +// # * - La función recibe un listado que contiene pares, representando cada jugada. +// # * - El par puede contener combinaciones de "🗿" (piedra), "📄" (papel), +// # * "✂️" (tijera), "🦎" (lagarto) o "🖖" (spock). +// # * - Ejemplo. Entrada: [("🗿","✂️"), ("✂️","🗿"), ("📄","✂️")]. Resultado: "Player 2". +// # * - Debes buscar información sobre cómo se juega con estas 5 posibilidades. +// # */ +// # ``` + +function calcularGanador(partidas) { + // Reglas del juego + const reglas = { + "🗿": ["✂️", "🦎"], + "📄": ["🗿", "🖖"], + "✂️": ["📄", "🦎"], + "🦎": ["📄", "🖖"], + "🖖": ["🗿", "✂️"] + }; + + // Contadores de victorias para cada jugador + let jugador1Victorias = 0; + let jugador2Victorias = 0; + + // Iterar a través de las partidas + partidas.forEach(partida => { + const jugadaJugador1 = partida[0]; + const jugadaJugador2 = partida[1]; + + // Verificar si las jugadas son válidas + if (reglas.hasOwnProperty(jugadaJugador1) && reglas.hasOwnProperty(jugadaJugador2)) { + + // Verificar el ganador de la partida + if (reglas[jugadaJugador1].indexOf(jugadaJugador2) !== -1) { + jugador1Victorias++; + } else if (reglas[jugadaJugador2].indexOf(jugadaJugador1) !== -1) { + jugador2Victorias++; + } + } else { + console.error("Jugadas no válidas:", jugadaJugador1, jugadaJugador2); + } + }); + + // Determinar el resultado final + if (jugador1Victorias > jugador2Victorias) { + return "Player 1"; + } else if (jugador2Victorias > jugador1Victorias) { + return "Player 2"; + } else { + return "Tie"; + } + } + + // Ejemplo de uso + const partidasEjemplo = [["🗿", "🖖"], ["🖖", "🦎"], ["📄", "🦎"]]; + const resultado = calcularGanador(partidasEjemplo); + console.log(resultado); \ No newline at end of file diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/jaimegamm.py b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/jaimegamm.py new file mode 100644 index 0000000000..02c94c3d87 --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/jaimegamm.py @@ -0,0 +1,57 @@ +## +## Crea un programa que calcule quien gana más partidas al piedra, +## papel, tijera, lagarto, spock. +## - El resultado puede ser: "Player 1", "Player 2", "Tie" (empate) +## - La función recibe un listado que contiene pares, representando cada jugada. +## - El par puede contener combinaciones de "🗿" (piedra), "📄" (papel), +## "✂️" (tijera), "🦎" (lagarto) o "🖖" (spock). +## - Ejemplo. Entrada: [("🗿","✂️"), ("✂️","🗿"), ("📄","✂️")]. Resultado: "Player 2". +## - Debes buscar información sobre cómo se juega con estas 5 posibilidades. +##/ + +def calcular_ganador(partidas): + reglas = { + ("🗿", "✂️"): "Player 1", + ("✂️", "🗿"): "Player 2", + ("🗿", "📄"): "Player 2", + ("📄", "🗿"): "Player 1", + ("📄", "✂️"): "Player 2", + ("✂️", "📄"): "Player 1", + ("✂️", "🦎"): "Player 2", + ("🦎", "✂️"): "Player 1", + ("🦎", "🖖"): "Player 2", + ("🖖", "🦎"): "Player 1", + ("🖖", "🗿"): "Player 2", + ("🗿", "🖖"): "Player 1", + ("📄", "🦎"): "Player 2", + ("🦎", "📄"): "Player 1", + ("🖖", "📄"): "Player 2", + ("📄", "🖖"): "Player 1", + ("✂️", "🖖"): "Player 2", + ("🖖", "✂️"): "Player 1", + } + + score_player_1 = 0 + score_player_2 = 0 + + for jugada in partidas: + if jugada[0] == jugada[1]: + continue # Empate, no cambia el marcador + + ganador = reglas.get(tuple(sorted(jugada))) + if ganador == "Player 1": + score_player_1 += 1 + elif ganador == "Player 2": + score_player_2 += 1 + + if score_player_1 > score_player_2: + return "Player 1" + elif score_player_2 > score_player_1: + return "Player 2" + else: + return "Tie" + +# Ejemplo de uso: +partidas = [("🗿", "✂️"), ("✂️", "🗿"), ("📄", "✂️")] +resultado = calcular_ganador(partidas) +print(resultado) \ No newline at end of file diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/swift/jcalderita.swift b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/swift/jcalderita.swift new file mode 100644 index 0000000000..a98071705f --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/swift/jcalderita.swift @@ -0,0 +1,68 @@ +import Foundation + +enum Option: String, CaseIterable { + case rock = "🗿" + case paper = "📄" + case scissors = "✂️" + case lizard = "🦎" + case spock = "🖖" +} + +let winsAgainst: [Option: [Option]] = [ + .rock: [.scissors, .lizard], + .paper: [.rock, .spock], + .scissors: [.paper, .lizard], + .lizard: [.spock, .paper], + .spock: [.scissors, .rock] +] + +final class Player { + let name: String + var option: Option + var score: Int = 0 + + init(name: String) { + self.name = name + self.option = Option.allCases.randomElement()! + } +} + +func playGame(bestOf: Int, player1: Player, player2: Player) { + guard bestOf % 2 == 1 else { + print("It's necessary a odd number.") + return + } + + if bestOf / 2 >= bestOf - player1.score || bestOf / 2 >= bestOf - player2.score { + print("\(player1.score > player2.score ? player1.name: player2.name) win") + } else { + let playerNewGame: (Player) -> String = { player in + let result = "\(player.name) play \(player.option.rawValue)" + player.option = Option.allCases.randomElement()! + return result + } + + let playerWin: ((Player, Player)) -> Bool = { whoWin in + winsAgainst[whoWin.0.option]?.contains(whoWin.1.option) ?? false + } + + var win: String = "Tie" + let win1 = playerWin((player1, player2)) + let win2 = playerWin((player2, player1)) + + if win1 && !win2 { + player1.score += 1 + win = "\(player1.name) win" + } else if win2 && !win1 { + player2.score += 1 + win = "\(player2.name) win" + } + print("\(playerNewGame(player1)) \(playerNewGame(player2)) \(win)") + playGame(bestOf: bestOf, player1: player1, player2: player2) + } +} + +let p1 = Player(name:"Player 1") +let p2 = Player(name:"Player 2") + +playGame(bestOf: 7, player1: p1, player2: p2) \ No newline at end of file diff --git a/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/JackDev21.js b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/JackDev21.js new file mode 100644 index 0000000000..01610c53a3 --- /dev/null +++ b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/JackDev21.js @@ -0,0 +1,102 @@ +/* + * Crea un programa que simule el comportamiento del sombrero seleccionador del + * universo mágico de Harry Potter. + * - De ser posible realizará 5 preguntas (como mínimo) a través de la terminal. + * - Cada pregunta tendrá 4 respuestas posibles (también a selecciona una a través de terminal). + * - En función de las respuestas a las 5 preguntas deberás diseñar un algoritmo que + * coloque al alumno en una de las 4 casas de Hogwarts (Gryffindor, Slytherin , Hufflepuff y Ravenclaw) + * - Ten en cuenta los rasgos de cada casa para hacer las preguntas y crear el algoritmo seleccionador. + * Por ejemplo, en Slytherin se premia la ambición y la astucia. + */ + +const readline = require('readline-sync'); + +let gryffindor = 0; +let hufflepuff = 0; +let slytherin = 0; +let ravenclaw = 0; + + +const preguntas = [ + { + pregunta: "¿Amanecer o atardecer? ", + respuestas: ["Amanecer", "Atardecer"], + puntos: { gryffindor: 1, hufflepuff: 1, ravenclaw: 0, slytherin: 1 } + }, + { + pregunta: "¿Cuando muera, quiero que la gente me recuerde como? : ", + respuestas: ["El Bueno", "El Grande", "El Sabio", "El Audaz"], + puntos: { gryffindor: 1, hufflepuff: 2, ravenclaw: 1, slytherin: 2 } + }, + { + pregunta: "¿Qué tipo de instrumento te agrada más escuchar?: ", + respuestas: ["El violín", "La trompeta", "El piano", "La batería"], + puntos: { gryffindor: 1, hufflepuff: 1, ravenclaw: 1, slytherin: 2 } + }, + { + pregunta: "¿Cuál es tu asignatura favorita en la escuela?: ", + respuestas: ["Defensa Contra las Artes Oscuras", "Herbología", "Pociones", "Adivinación"], + puntos: { gryffindor: 1, hufflepuff: 1, ravenclaw: 2, slytherin: 1 } + }, + { + pregunta: "¿Qué cualidad valoras más en un amigo?: ", + respuestas: ["Valentía", "Lealtad", "Inteligencia", "Ambición"], + puntos: { gryffindor: 2, hufflepuff: 1, ravenclaw: 1, slytherin: 2 } + } +]; + + +const hacerPregunta = (pregunta, respuestas) => { + console.log(pregunta); + respuestas.forEach((respuesta, index) => { + console.log(` ${index + 1}.) ${respuesta}`); + }); + const respuestaIndex = parseInt(readline.question('Elige una respuesta (1 - 4): ')); + if (respuestaIndex >= 1 && respuestaIndex <= 4) { + return respuestaIndex; + } else { + console.log('Respuesta incorrecta'); + return hacerPregunta(pregunta, respuestas); + } +} + +preguntas.forEach(pregunta => { + const respuesta = hacerPregunta(pregunta.pregunta, pregunta.respuestas); + comprobarRespuesta(respuesta, pregunta.puntos); +}); + + +const comprobarRespuesta = (respuesta, puntos) => { + if (respuesta === 1) { + gryffindor += puntos.gryffindor; + } else if (respuesta === 2) { + hufflepuff += puntos.hufflepuff; + } else if (respuesta === 3) { + ravenclaw += puntos.ravenclaw; + } else if (respuesta === 4) { + slytherin += puntos.slytherin; + } +} + +console.log('==============='); +console.log('El Sombrero Seleccionador'); +console.log('==============='); + + + +console.log("Gryffindor: ", gryffindor); +console.log("Ravenclaw: ", ravenclaw); +console.log("Hufflepuff: ", hufflepuff); +console.log("Slytherin: ", slytherin); + +const puntuacionMaxima = Math.max(gryffindor, ravenclaw, hufflepuff, slytherin); + +if (gryffindor === puntuacionMaxima) { + console.log('🦁 ¡Gryffindor!'); +} else if (ravenclaw === puntuacionMaxima) { + console.log('🦅 ¡Ravenclaw!'); +} else if (hufflepuff === puntuacionMaxima) { + console.log('🦡 ¡Hufflepuff!'); +} else if (slytherin === puntuacionMaxima) { + console.log('🐍 ¡Slytherin!'); +} diff --git a/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/jaimegamm.js b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/jaimegamm.js new file mode 100644 index 0000000000..3fd5ee3d32 --- /dev/null +++ b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/jaimegamm.js @@ -0,0 +1,112 @@ +/* + * Crea un programa que simule el comportamiento del sombrero seleccionador del + * universo mágico de Harry Potter. + * - De ser posible realizará 5 preguntas (como mínimo) a través de la terminal. + * - Cada pregunta tendrá 4 respuestas posibles (también a selecciona una a través de terminal). + * - En función de las respuestas a las 5 preguntas deberás diseñar un algoritmo que + * coloque al alumno en una de las 4 casas de Hogwarts (Gryffindor, Slytherin , Hufflepuff y Ravenclaw) + * - Ten en cuenta los rasgos de cada casa para hacer las preguntas y crear el algoritmo seleccionador. + * Por ejemplo, en Slytherin se premia la ambición y la astucia. + */ + +const readlineSync = require('readline-sync'); + +function hacerPregunta(pregunta, opciones){ + console.log("-----------------------------------------------------------------") + console.log(pregunta) + console.log("-----------------------------------------------------------------") + for (let i = 0; i < opciones.length; i++) { + const opcion = opciones[i]; + console.log((i+1) + ". " + opcion); + } + const respuesta = readlineSync.questionInt('Selecciona una opcion (1-4): '); + if (respuesta >= 1 && respuesta <= 4) { + return respuesta + } else { + console.log("Por favor, ingresa un número válido.") + return hacerPregunta(pregunta, opciones); + } +} + +function sombrero_seleccionador(){ + preguntas = [ + "¿Qué cualidad valoras más en un amigo?", + "¿Qué tipo de magia prefieres?", + "En una situación difícil, ¿eres?", + "¿Qué animal mágico te gustaría tener como mascota?", + "¿Cuál es tu asignatura favorita en Hogwarts?" + ] + + respuestas_casas = { + "Gryffindor": 0, + "Slytherin": 0, + "Hufflepuff": 0, + "Ravenclaw": 0 + } + + lista_opciones = [ + [ + "Valiente", + "Ambicioso", + "Leal", + "Inteligente" + ], + [ + 'Encantamientos', + 'Transformaciones', + 'Defensa Contra las Artes Oscuras', + 'Pociones', + ], + [ + "Valentía", + "Ambición", + "Lealtad", + "Inteligencia" + ], + [ + "Hippogriff", + "Thestral", + "Niffler", + "Blast-Ended Skrewt" + ], + [ + 'Defensa Contra las Artes Oscuras', + 'Pociones', + 'Transformaciones', + 'Astronomía' + ] + ] + + numero_lista = 0; + preguntas.forEach(pregunta => { + respuesta = hacerPregunta(pregunta, lista_opciones[numero_lista]); + numero_lista += 1; + if (respuesta === 1){ + respuestas_casas["Gryffindor"] += 1 + }else if (respuesta === 2){ + respuestas_casas["Slytherin"] += 1 + }else if (respuesta === 3){ + respuestas_casas["Hufflepuff"] += 1 + }else{ + respuestas_casas["Ravenclaw"] += 1 + } + }); + + let maxpuntuacion = 0; + let casa_seleccionada; + for(const casa in respuestas_casas){ + const puntuacion = respuestas_casas[casa] + if(puntuacion > maxpuntuacion){ + maxpuntuacion = puntuacion; + casa_seleccionada = casa; + } + } + console.log("-----------------------------------------------------------------") + console.log("-----------------------------------------------------------------") + console.log(`Casa seleccionada: ${casa_seleccionada}`); + console.log("-----------------------------------------------------------------") + console.log("-----------------------------------------------------------------") +} + + +sombrero_seleccionador() \ No newline at end of file diff --git a/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jaimegamm.py b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jaimegamm.py new file mode 100644 index 0000000000..3ce70ddf42 --- /dev/null +++ b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jaimegamm.py @@ -0,0 +1,69 @@ +""" +/* + * Crea un programa que simule el comportamiento del sombrero selccionador del + * universo mágico de Harry Potter. + * - De ser posible realizará 5 preguntas (como mínimo) a través de la terminal. + * - Cada pregunta tendrá 4 respuestas posibles (también a selecciona una a través de terminal). + * - En función de las respuestas a las 5 preguntas deberás diseñar un algoritmo que + * coloque al alumno en una de las 4 casas de Hogwarts (Gryffindor, Slytherin , Hufflepuff y Ravenclaw) + * - Ten en cuenta los rasgos de cada casa para hacer las preguntas y crear el algoritmo seleccionador. + * Por ejemplo, en Slytherin se premia la ambición y la astucia. + */ +""" + +def hacer_pregunta(pregunta, opciones): + print(pregunta) + for i, opcion in enumerate(opciones, start=1): + print(f"{i}. {opcion}") + + while True: + try: + respuesta = int(input("Selecciona tu respuesta (1-4): ")) + if 1 <= respuesta <= 4: + return respuesta + else: + print("Por favor, ingresa un número válido.") + except ValueError: + print("Por favor, ingresa un número entero.") + +def sombrero_seleccionador(): + preguntas = [ + "¿Qué cualidad valoras más en un amigo?", + "¿Qué tipo de magia prefieres?", + "En una situación difícil, ¿qué harías?", + "¿Qué animal mágico te gustaría tener como mascota?", + "¿Cuál es tu asignatura favorita en Hogwarts?" + ] + + respuestas_casas = { + "Gryffindor": 0, + "Slytherin": 0, + "Hufflepuff": 0, + "Ravenclaw": 0 + } + + for pregunta in preguntas: + respuesta = hacer_pregunta(pregunta, ["Valentía", "Ambición", "Lealtad", "Inteligencia"]) + + if pregunta == preguntas[0]: + respuestas_casas["Gryffindor"] += respuesta + respuestas_casas["Slytherin"] += respuesta + elif pregunta == preguntas[1]: + respuestas_casas["Slytherin"] += respuesta + respuestas_casas["Ravenclaw"] += respuesta + elif pregunta == preguntas[2]: + respuestas_casas["Gryffindor"] += respuesta + respuestas_casas["Hufflepuff"] += respuesta + elif pregunta == preguntas[3]: + respuestas_casas["Slytherin"] += respuesta + respuestas_casas["Hufflepuff"] += respuesta + elif pregunta == preguntas[4]: + respuestas_casas["Ravenclaw"] += respuesta + respuestas_casas["Hufflepuff"] += respuesta + + casa_seleccionada = max(respuestas_casas, key=respuestas_casas.get) + print(f"\n¡Bienvenido a {casa_seleccionada}!") + +if __name__ == "__main__": + print("Bienvenido al Simulador del Sombrero Seleccionador") + sombrero_seleccionador() diff --git a/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jelambrar96.py b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jelambrar96.py new file mode 100644 index 0000000000..85c325a23e --- /dev/null +++ b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jelambrar96.py @@ -0,0 +1,154 @@ +#!/usr/bin/python3 + +""" +# Reto #7: El sombrero seleccionador +/* + * Crea un programa que simule el comportamiento del sombrero seleccionador del + * universo mágico de Harry Potter. + * - De ser posible realizará 5 preguntas (como mínimo) a través de la terminal. + * - Cada pregunta tendrá 4 respuestas posibles (también a selecciona una a través de terminal). + * - En función de las respuestas a las 5 preguntas deberás diseñar un algoritmo que + * coloque al alumno en una de las 4 casas de Hogwarts (Gryffindor, Slytherin , Hufflepuff y Ravenclaw) + * - Ten en cuenta los rasgos de cada casa para hacer las preguntas y crear el algoritmo seleccionador. + * Por ejemplo, en Slytherin se premia la ambición y la astucia. + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + + +import random + + +def preguntar(texto_pregunta, valores_validos): + while True: + print() + entrada = input(texto_pregunta) + indice = valores_validos.index(entrada) + if indice >= 0: + return entrada, indice + print("Respuesta Invalida") + + +def unzip(zipped_iterables): + """ + Unzips a list of zipped iterables and returns a tuple of lists. + + :param zipped_iterables: A list of zipped iterables + :return: A tuple of lists where each list contains the corresponding elements of the zipped iterables + """ + unzipped = tuple(map(list, zip(*zipped_iterables))) + return unzipped + + +PREGUNTAS = [ + "¿Cómo te definirías?", + "¿Cuál es tu clase favorita?", + "¿Dónde pasarías más tiempo?", + "¿Cuál es tu color favorito?", + "¿Cuál es tu mascota?", +] + +ESCUELAS = [ + "gryffindor", + "hufflepuff", + "ravenclaw", + "slytherin" +] + +OPCIONES = [ + [ + "Valiente", + "Leal", + "Sabio", + "Ambicioso", + ], + [ + "Vuelo", + "Pociones", + "Defensa contra las artes oscuras", + "Animales fantásticos", + ], + [ + "Invernadero", + "Biblioteca", + "En la sala común", + "Explorando", + ], + [ + "Rojo", + "Azul", + "Verde", + "Amarillo", + ], + [ + "Sapo", + "Lechuza", + "Gato", + "Serpiente", + ], +] + + +def main(use_random=True): + + # resultado para cada escuela + resultados = [0, 0, 0, 0] + # opcion para cada escuela + respuestas_validas = ['1', '2', '3', '4'] + + # se iteran las preguntas + for i, item in enumerate(PREGUNTAS): + # se seleccioan las preguntas y las opciones + pregunta = PREGUNTAS[i] + lista_opciones = OPCIONES[i] + + # se desordean las opciones y las preguntas de tal manera que las + # preguntas sigan en el mismo indice que las opciones + if use_random: + zipped = [item for item in zip(respuestas_validas, lista_opciones)] + random.shuffle(zipped) + temp_respuestas_validas, temp_opciones = unzip(zipped) + else: + temp_respuestas_validas, temp_opciones = respuestas_validas, lista_opciones + + # se agrega un numero a las opciones + temp_opciones = [ (str(j+1) + ". " + jitem) for j, jitem in enumerate(temp_opciones)] + # se genera el texto de las preguntas + texto_pregunta = pregunta + "\n" + "\n".join(temp_opciones) + "\n" + + # se toma el indice + __, indice = preguntar(texto_pregunta, respuestas_validas) + # se busca el valor + numero_respuesta = int(temp_respuestas_validas[indice]) + resultados[numero_respuesta - 1] += 1 + + + # se organiza aleatoriamente con el fin de que en caso de un empate + # se haga una seleccion aleatoria + zipped = list(zip(resultados, ESCUELAS)) + random.shuffle(zipped) + random_resultados, random_ESCUELAS = unzip(zipped) + + # se busca el maximo valor y el maximo indice + maximo_valor = max(random_resultados) + maximo_indice = random_resultados.index(maximo_valor) + escuela_seleccionada = random_ESCUELAS[maximo_indice].upper() + + # print(f"\n¡{escuela_seleccionada}!") + return escuela_seleccionada + + + +if __name__ == '__main__': + escuela_seleccionada = main() + print(f"\n¡{escuela_seleccionada}!") + + diff --git a/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/swift/jcalderita.swift b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/swift/jcalderita.swift new file mode 100644 index 0000000000..fbc3812a89 --- /dev/null +++ b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/swift/jcalderita.swift @@ -0,0 +1,194 @@ +import Foundation + +let questions: [String] = [ + "Moon or Stars?", + "Left or Right?", + "Black or White?", + "Dawn or Dusk?", + "Forest or River?", + "If you were attending Hogwarts, which pet would you choose to take with you?", + "Once every century, the Flutterby bush produces flowers that adopt their scent to attract the unwary. If it lured you, it would smell of", + "How would you like to be known to history?", + "Late at night, walking alone down the street, you hear a peculiar cry that you believe to have a magical source. Do you", + "If you could have any power, which would you choose?", + "A troll has gone berserk in the Headmaster’s study at Hogwarts. It is about to smash, crush and tear several irreplaceable items and treasures. In which order would you rescue these objects from the troll’s club, if you could?", + "What kind of instrument most pleases your ear?", + "What are you most looking forward to learning at Hogwarts?", + "Which road tempts you most?", + "Which of the following would you most hate people to call you?", + "Which would you rather be", + "After you have died, what would you most like people to do when they hear your name?", + "A Muggle confronts you and says that they are sure you are a witch or wizard. Do you", + "You enter an enchanted garden. What would you be most curious to examine first?", + "Four boxes are placed before you. Which would you try and open?", + "Given the choice, would you rather invent a potion that would guarantee you", + "One of your house mates has cheated in a Hogwarts exam by using a Self-Spelling Quill. Now he has come top of the class in Charms, beating you into second place. Professor Flitwick is suspicious of what happened. He draws you to one side after his lesson and asks you whether or not your classmate used a forbidden quill. What do you do?", + "Which of the following do you find most difficult to deal with?", + "Which of the following would you most like to study?", + "Which nightmare would frighten you most?", + "You and two friends need to cross a bridge guarded by a river troll who insists on fighting one of you before he will let all of you pass. Do you", + "Four goblets are placed before you. Which would you choose to drink?" +] + +let gryffindorAnswers: [String] = [ + "Stars", + "Right", + "Tails", + "Black", + "Dawn", + "Forest", + "Tabby Cat", + "A crackling log fire", + "The Bold", + "Draw your wand and try to discover the source of the noise?", + "The power of invisibility.", + "First, a mysterious handwritten book full of strange runes. Then student records going back 1000 years. Finally, a nearly perfected cure for dragon pox.", + "The Drum", + "Secrets about the castle.", + "The twisting, leaf-strewn path through woods.", + "Selfish", + "Praised?", + "Ask for more stories about your adventures.", + "Agree, and walk away, leaving them to wonder whether you are bluffing?", + "The statue of an old wizard with a strangely twinkling eye.", + "The small pewter box, unassuming and plain, with a scratched message upon it that reads /“I open only for the worthy./”", + "Glory?", + "Tell Professor Flitwick that he ought to ask your classmate (and resolve to tell your classmate that if he doesn’t tell the truth, you will).", + "Loneliness", + "Ghosts", + "An eye at the keyhole of the dark, windowless room in which you are locked.", + "Volunteer to fight?", + "The golden liquid so bright that it hurts the eye and which makes sunspots dance all around the room." +] + +let slytherinAnswers: [String] = [ + "Moon", + "Left", + "Tails", + "Black", + "Dusk", + "River", + "Siamese Cat", + "The sea", + "The Great", + "Draw your wand and stand your ground?", + "The power to change the past.", + "First, student records going back 1000 years.Then a mysterious handwritten book full of strange runes. Finally, a nearly perfected cure for dragon pox.", + "The Violin", + "Hexes and jinxes", + "The narrow, dark, lantern-lit alley", + "Ordinary", + "Feared?", + "I don’t care what people think of me after I’m dead; it’s what they think of me while I’m alive that counts.", + "Agree, and ask whether they’d like a free sample of a jinx?", + "The bubbling pool, in the depths of which something luminous is swirling.", + "The gleaming jet black box with a silver lock and key, marked with a mysterious rune that you know to be the mark of Merlin.", + "Power?", + "You would not wait to be asked to tell Professor Flitwick the truth. If you knew that somebody was using a forbidden quill, you would tell the teacher before the exam started.", + "Cold", + "Vampires", + "Being forced to speak in such a silly voice that hardly anyone can understand you, and everyone laughs at you.", + "Suggest that all three of you should fight (without telling the troll)?", + "The mysterious black liquid that gleams like ink, and gives off fumes that make you see strange visions." +] + +let ravenclawAnswers: [String] = [ + "Moon", + "Left", + "Heads", + "White", + "Dawn", + "Forest", + "Tawny owl", + "Fresh parchment", + "The Wise", + "Withdraw into the shadows to await developments, while mentally reviewing the most appropriate defensive and offensive spells, should trouble occur?", + "The power to change your appearance at will.", + "First, a mysterious handwritten book full of strange runes. Then a nearly perfected cure for dragon pox. Finally, student records going back 1000 years.", + "The Piano", + "Every area of magic I can.", + "The cobbled street lined with ancient buildings", + "Ignorant", + "Imitated?", + "Think with admiration of your achievements.", + "Ask what makes them think so?", + "The silver-leafed tree bearing golden apples.", + "The ornate golden casket, standing on clawed feet, whose inscription warns that both secret knowledge and unbearable temptation lie within.", + "Wisdom?", + "Tell Professor Flitwick the truth. If your classmate is prepared to win by cheating, he deserves to be found out. Also, as you are both in the same house, any points he loses will be regained by you, for coming first in his place.", + "Hunger", + "Goblins", + "Standing on top of something very high and realizing suddenly that there are no hand- or footholds, nor any barrier to stop you falling.", + "Attempt to confuse the troll into letting all three of you pass without fighting?", + "The foaming, frothing, silvery liquid that sparkles as though containing ground diamonds." +] + +let hufflepuffAnswers: [String] = [ + "Stars", + "Right", + "Heads", + "White", + "Dusk", + "River", + "Common toad", + "Home", + "The Good", + "Proceed with caution, keeping one hand on your concealed wand and an eye out for any disturbance?", + "The power of superhuman strength.", + "First, student records going back 1000 years. Then a nearly perfected cure for dragon pox. Finally, a mysterious handwritten book full of strange runes.", + "The trumpet", + "All about magical creatures, and how to befriend/care for them.", + "The wide, sunny, grassy lane", + "Cowardly", + "Liked?", + "Miss you, but smile.", + "Tell them that you are worried about their mental health, and offer to call a doctor.", + "The fat red toadstools that appear to be talking to each other.", + "The small tortoiseshell box, embellished with gold, inside which some small creature seems to be squeaking.", + "Love?", + "Lie and say you don’t know (but hope that somebody else tells Professor Flitwick the truth).", + "Being ignored", + "Trolls", + "Waking up to find that neither your friends nor your family have any idea who you are.", + "Suggest drawing lots to decide which of you will fight?", + "The smooth, thick, richly purple drink that gives off a delicious smell of chocolate and plums." +] + + +final class House { + let name: String + private(set) var score: Int = 0 + let answers: [String] + + init(name: String, answers: [String]) { + self.name = name + self.answers = answers + } + + func correctAnswer(idx: Int, answer: String) { + if answers[idx] == answer { + score += 1 + } + } +} + +let gryffindor = House(name: "Gryffindor", answers: gryffindorAnswers) +let slytherin = House(name: "Slytherin", answers: slytherinAnswers) +let ravenclaw = House(name: "Ravenclaw", answers: ravenclawAnswers) +let hufflepuff = House(name: "Hufflepuff", answers: hufflepuffAnswers) + +let houses = [gryffindor, slytherin, ravenclaw, hufflepuff] + +questions.enumerated().forEach { (index, question) in + let answer = houses.randomElement()!.answers[index] + print("\(question) - \(answer)") + houses.forEach { house in + house.correctAnswer(idx: index, answer: answer) + } +} + +let selection = houses.sorted { first, second in + first.score > second.score +}.first!.name + +print("You are \(selection)") \ No newline at end of file diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/JackDev21.js b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/JackDev21.js new file mode 100644 index 0000000000..975900446f --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/JackDev21.js @@ -0,0 +1,22 @@ +/* + * Crea un generador de números pseudoaleatorios entre 0 y 100. + * - No puedes usar ninguna función "random" (o semejante) del lenguaje de programación seleccionado. + * + * Es más complicado de lo que parece... + */ + + + +const random = () => { + let now = new Date(); + let time = now.getMilliseconds() % 101; + return time; +} + +const results = new Set(); + +while (results.size < 100) { + results.add(random()); +} + +console.log(Array.from(results)); \ No newline at end of file diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/jaimegamm.js b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/jaimegamm.js new file mode 100644 index 0000000000..1de58be6d5 --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/jaimegamm.js @@ -0,0 +1,24 @@ +/* + * Crea un generador de números pseudoaleatorios entre 0 y 100. + * - No puedes usar ninguna función "random" (o semejante) del lenguaje de programación seleccionado. + * + * Es más complicado de lo que parece... + */ + +// Inicialización de variables +let seed = 42; // Puedes cambiar el valor inicial (semilla) +const a = 1664525; +const c = 1013904223; +const m = 2**32; + +// Función para generar números pseudoaleatorios entre 0 y 100 +function generarPseudoAleatorio() { + seed = (a * seed + c) % m; + return (seed % 101); // Módulo 101 para obtener valores entre 0 y 100 +} + +// Ejemplo de uso +for (let i = 0; i < 10; i++) { + let numeroAleatorio = generarPseudoAleatorio(); + console.log(numeroAleatorio); +} \ No newline at end of file diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jaimegamm.py b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jaimegamm.py new file mode 100644 index 0000000000..48a41e993d --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jaimegamm.py @@ -0,0 +1,20 @@ +# +#Crea un generador de números pseudoaleatorios entre 0 y 100. +#No puedes usar ninguna función "random" (o semejante) del lenguaje de programación seleccionado. +# +# + +class PseudoRandomGenerator: + def __init__(self, seed): + self.seed = seed + + def random(self): + self.seed = (self.seed * 1103515245 + 12345) & 0x7fffffff + return (self.seed // 65536) % 100 + +# Ejemplo de uso +seed = 42 # Cambia la semilla según desees +prng = PseudoRandomGenerator(seed) + +for _ in range(10): + print(prng.random()) diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jelambrar96.py b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jelambrar96.py new file mode 100644 index 0000000000..9f92ec645c --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jelambrar96.py @@ -0,0 +1,64 @@ +#!/usr/bin/python3 + +""" +# Reto #8: El generador pseudoaleatorio +/* + * Crea un generador de números pseudoaleatorios entre 0 y 100. + * - No puedes usar ninguna función "random" (o semejante) del lenguaje de programación seleccionado. + * + * Es más complicado de lo que parece... + */ +""" + +__author__ = "Jorge Lambraño - jelambrar96" +__copyright__ = "Copyright 2024, retos-programacion-2023" +__credits__ = ["Brais Moure - mouredev"] +__license__ = "GPL" +__version__ = "1.0.1" +__maintainer__ = "Jorge Lambraño" +__email__ = "jelambrar@gmail.com" +__status__ = "Production" + + +import time + + +def linear_congruential_generator(x_0, a_const, b_const, module, n_iterations): + assert module > 0, f'm={module}' + assert a_const > 0 and a_const < module, f'a={a_const}' + assert b_const >= 0 and b_const < module, f'b={b_const}' + assert x_0 > 0 and x_0 < module, f'x_0={x_0}' + x_final = x_0 + for __ in range(n_iterations): + x_final = (x_final + a_const + b_const) % module + return x_final + + +def random_integer_generator(min_value: int, max_value: int): + range_value = max_value - min_value + # take from microseconds + # print(time.time()) + semilla = 1 + int(time.time() * 1000 * 1000) % (range_value - 1) + a = 1 + int(time.time() * 1000) % (range_value - 1) + b = int(time.time()) % range_value + n = 10 + ( semilla % 32 ) + # print("a: ", a) + # print("b: ", b) + # print("n: ", n) + # print("semilla: ", semilla) + return min_value + linear_congruential_generator(semilla, a, b, range_value, n) + + +if __name__ == '__main__': + # for i in range(20): + # print(random_integer_generator(0, 100)) + # time.sleep(0.01) + + from collections import Counter + + lista = [ random_integer_generator(0, 100) for i in range(100)] + for item in lista: + print (item) + print(Counter(lista)) + + diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/swift/jcalderita.swift b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/swift/jcalderita.swift new file mode 100644 index 0000000000..cb9285c27c --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/swift/jcalderita.swift @@ -0,0 +1,5 @@ +import Foundation + +(1 ... 10).forEach { _ in + print(Calendar.current.component(.nanosecond, from: Date()) % 101) +} \ No newline at end of file diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/java/danielzx9.java" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/java/danielzx9.java" new file mode 100644 index 0000000000..efefc198e6 --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/java/danielzx9.java" @@ -0,0 +1,71 @@ +import java.util.HashSet; +import java.util.Set; +// # Reto #9: Heterograma, isograma y pangrama +// #### Dificultad: Fácil | Publicación: 27/02/23 | Corrección: 06/03/23 + +// ## Enunciado + +// ``` +// /* +// * Crea 3 funciones, cada una encargada de detectar si una cadena de +// * texto es un heterograma, un isograma o un pangrama. +// * - Debes buscar la definición de cada uno de estos términos. +// */ +// ``` +// #### Tienes toda la información extendida sobre los retos de programación semanales en **[retosdeprogramacion.com/semanales2023](https://retosdeprogramacion.com/semanales2023)**. + +// Sigue las **[instrucciones](../../README.md)**, consulta las correcciones y aporta la tuya propia utilizando el lenguaje de programación que quieras. + +// > Recuerda que cada semana se publica un nuevo ejercicio y se corrige el de la semana anterior en directo desde **[Twitch](https://twitch.tv/mouredev)**. Tienes el horario en la sección "eventos" del servidor de **[Discord](https://discord.gg/mouredev)**. + +public class danielzx9 { + + public static boolean esHeterograma(String texto) { + Set caracteres = new HashSet<>(); + for (char c : texto.toCharArray()) { + if (Character.isLetter(c)) { + if (caracteres.contains(c)) { + return false; + } + caracteres.add(c); + } + } + return true; + } + + public static boolean esIsograma(String texto) { + Set caracteres = new HashSet<>(); + for (char c : texto.toCharArray()) { + if (Character.isLetter(c)) { + char letra = Character.toLowerCase(c); + if (caracteres.contains(letra)) { + return false; + } + caracteres.add(letra); + } + } + return true; + } + + public static boolean esPangrama(String texto) { + Set letras = new HashSet<>(); + for (char c : texto.toCharArray()) { + if (Character.isLetter(c)) { + letras.add(Character.toLowerCase(c)); + } + } + return letras.size() == 26; + } + + + public static void main(String[] args) { + String ejemplo = "valor"; + + // Prueba de las funciones + System.out.println("Es Heterograma: " + esHeterograma(ejemplo)); + System.out.println("Es Isograma: " + esIsograma(ejemplo)); + System.out.println("Es Pangrama: " + esPangrama(ejemplo)); + } + + +} diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/javascript/JackDev21.js" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/javascript/JackDev21.js" new file mode 100644 index 0000000000..07a664e0bc --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/javascript/JackDev21.js" @@ -0,0 +1,59 @@ +/* + * Crea 3 funciones, cada una encargada de detectar si una cadena de + * texto es un heterograma, un isograma o un pangrama. + * - Debes buscar la definición de cada uno de estos términos. + */ + + + +const esHeterograma = (str) => { + let heterograma = true; + let letrasEncontradas = new Set(); + const alfabeto = "abcdefghijklmnopqrstuvwxyzñ"; + + for (let i = 0; i < str.length && heterograma; i++) { + let letra = str[i].toLowerCase(); + if (letrasEncontradas.has(letra)) { + heterograma = false; + } else if (alfabeto.includes(letra)) { + letrasEncontradas.add(letra); + } + } + return heterograma; +} + + +const esIsograma = (str) => { + let letrasEncontradas = new Set(); + + for (let letra of str.toLowerCase()) { + if (/[a-zñ]/.test(letra)) { + if (letrasEncontradas.has(letra)) { + return false; + } + letrasEncontradas.add(letra); + } + } + + return true; +} + + +const esPangrama = (str) => { + const alfabeto = "abcdefghijklmnopqrstuvwxyz"; + + for (let letra of alfabeto) { + if (!str.toLowerCase().includes(letra)) { + return false; + } + } + + return true; +} + + +const texto = "murcielago"; + +console.log(`¿Es un heterograma? ${esHeterograma(texto)}`); +console.log(`¿Es un isograma? ${esIsograma(texto)}`); +console.log(`¿Es un pangrama? ${esPangrama(texto)}`); \ No newline at end of file diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/swift/jcalderita.swift" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/swift/jcalderita.swift" new file mode 100644 index 0000000000..c692b93f80 --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/swift/jcalderita.swift" @@ -0,0 +1,37 @@ +import Foundation + +let characters = Set("abcdefghijklmnopqrstuvwxyz") + +func transformSentence(_ sentence: String) -> String { + sentence.trimmingCharacters(in: .whitespaces).lowercased() +} + +func isHeterogram(_ sentence: String) -> Bool { + let compare = transformSentence(sentence) + return compare.count == Set(compare).count +} + +func isIsogram(_ sentence: String) -> Bool { + let compare = transformSentence(sentence) + return compare.count != Set(compare).count +} + +func isPangram(_ sentence: String) -> Bool { + let compare = transformSentence(sentence) + return characters.subtracting(compare).isEmpty +} + +print("Yuxtaponer es heterograma: \(isHeterogram("yuxtaponer"))") +print("Centrifugado es heterograma: \(isHeterogram("centrifugado"))") +print("Luteranismo es heterograma: \(isHeterogram("luteranismo"))") +print("Adulterinos es heterograma: \(isHeterogram("adulterinos"))") +print("Hiperblanduzcos es heterograma: \(isHeterogram("hiperblanduzcos"))") +print("Acondicionar es heterograma: \(isHeterogram("acondicionar"))") + +print("\nAcondicionar es isograma: \(isIsogram("acondicionar"))") +print("Escritura es isograma: \(isIsogram("escritura"))") +print("Intestinos es isograma: \(isIsogram("intestinos"))") +print("Papelera es isograma: \(isIsogram("papelera"))") +print("Hiperblanduzcos es isograma: \(isIsogram("hiperblanduzcos"))") + +print("\n'Benjamín pidió una bebida de kiwi y fresa. Noé, sin vergüenza, la más exquisita champaña del menú' es pangrama: \(isPangram("Benjamín pidió una bebida de kiwi y fresa. Noé, sin vergüenza, la más exquisita champaña del menú"))")