diff --git a/README.md b/README.md index 0b314c8736..d1263f2e31 100644 --- a/README.md +++ b/README.md @@ -61,9 +61,11 @@ Aquí encontrarás el listado de retos, su fecha de publicación, dificultad y e * **#41** - 16/10/23 | Difícil | [`LA CASA ENCANTADA`](./Retos/Reto%20%2341%20-%20LA%20CASA%20ENCANTADA%20%5BDifícil%5D/ejercicio.md) | Correcciones: [[MI SOLUCIÓN](./Retos/Reto%20%2341%20-%20LA%20CASA%20ENCANTADA%20%5BDifícil%5D/python/mouredev.py)] [[COMUNIDAD](./Retos/Reto%20%2341%20-%20LA%20CASA%20ENCANTADA%20%5BDifícil%5D/)] * **#42** - 23/10/23 | Difícil | [`PUNTO DE ENCUENTRO`](./Retos/Reto%20%2342%20-%20PUNTO%20DE%20ENCUENTRO%20%5BDifícil%5D/ejercicio.md) Correcciones: [[MI SOLUCIÓN](./Retos/Reto%20%2342%20-%20PUNTO%20DE%20ENCUENTRO%20%5BDifícil%5D/python/mouredev.py)] [[COMUNIDAD](./Retos/Reto%20%2342%20-%20PUNTO%20DE%20ENCUENTRO%20%5BDifícil%5D/)] * **#43** - 30/10/23 | Fácil | [`SIMULADOR DE CLIMA`](./Retos/Reto%20%2343%20-%20SIMULADOR%20DE%20CLIMA%20%5BFácil%5D/ejercicio.md) | Correcciones: [[MI SOLUCIÓN](./Retos/Reto%20%2343%20-%20SIMULADOR%20DE%20CLIMA%20%5BFácil%5D/python/mouredev.py)] [[COMUNIDAD](./Retos/Reto%20%2343%20-%20SIMULADOR%20DE%20CLIMA%20%5BFácil%5D/)] -* **#44** - 13/10/23 | Media | [`ADIVINANZAS MATEMÁTICAS`](./Retos/Reto%20%2344%20-%20ADIVINANZAS%20MATEMÁTICAS%20%5BMedia%5D/ejercicio.md) | Último reto publicado +* **#44** - 13/11/23 | Media | [`ADIVINANZAS MATEMÁTICAS`](./Retos/Reto%20%2344%20-%20ADIVINANZAS%20MATEMÁTICAS%20%5BMedia%5D/ejercicio.md) | Correcciones: [[MI SOLUCIÓN](./Retos/Reto%20%2344%20-%20ADIVINANZAS%20MATEMÁTICAS%20%5BMedia%5D/python/mouredev.py)] [[COMUNIDAD](./Retos/Reto%20%2344%20-%20ADIVINANZAS%20MATEMÁTICAS%20%5BMedia%5D/)] +* **#45** - 20/11/23 | Fácil | [`EL CALENDARIO DE ADEVIENTO 2023`](./Retos/Reto%20%2345%20-%20EL%20CALENDARIO%20DE%20ADEVIENTO%202023%20%5BFácil%5D/ejercicio.md) | Correcciones: [[MI SOLUCIÓN](./Retos/Reto%20%2345%20-%20EL%20CALENDARIO%20DE%20ADEVIENTO%202023%20%5BFácil%5D/python/mouredev.py)] [[COMUNIDAD](./Retos/Reto%20%2345%20-%20EL%20CALENDARIO%20DE%20ADEVIENTO%202023%20%5BFácil%5D/)] +* **#46** - 27/11/23 | Media | [`LA CARRERA DE COCHES`](./Retos/Reto%20%2346%20-%20LA%20CARRERA%20DE%20COCHES%20%5BMedia%5D/ejercicio.md) | Último reto publicado -> **Corrección y Publicación próximo reto - 20/11/23 | [🗓️ Horario evento corrección en directo](https://discord.gg/mouredev?event=1173570988865232968) en [Twitch](https://twitch.tv/mouredev)** +> **Corrección y Publicación próximo reto - 04/12/23 | [🗓️ Horario evento corrección en directo](https://discord.gg/aNQNqZcB?event=1178638296092524544) en [Twitch](https://twitch.tv/mouredev)** *Puedes ejecutar el archivo [language_stats.py](./Retos/language_stats.py) para visualizar las estadísticas de uso de cada lenguaje.* diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/BRivasTorres.js" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/BRivasTorres.js" new file mode 100644 index 0000000000..fc64ef607e --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/BRivasTorres.js" @@ -0,0 +1,13 @@ +const fizzBuzz = () => { + for (let i = 0; i <= 100; i++) { + if (i % 3 === 0 && i % 5 === 0) { + console.log("fizzBuzz"); + } else if (i % 3 === 0) { + console.log("fizz"); + } else if (i % 5 === 0) { + console.log("buzz"); + } + } +}; + +console.log(fizzBuzz()); diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/ifritzler.js" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/ifritzler.js" new file mode 100644 index 0000000000..b40e1b177a --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/ifritzler.js" @@ -0,0 +1,16 @@ +const MIN = 1 +const MAX = 100 + +function isMultiplo(number, targets = []) { + if(number == null) return false + if(!Array.isArray(targets)) targets = [targets] + + return targets.every(target => number % target === 0) +} + +for(let i = MIN; i <= MAX; i++) { + if(isMultiplo(i, [3, 5])) console.log('fizzbuzz') + else if(isMultiplo(i, 3)) console.log('fizz') + else if(isMultiplo(i, 5)) console.log('buzz') + else console.log(i) +} \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/rodrigosambadesaa.js" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/rodrigosambadesaa.js" new file mode 100644 index 0000000000..5ed6d7794c --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/rodrigosambadesaa.js" @@ -0,0 +1,31 @@ +const fizzbuzz = numVal => { + if (typeof numVal !== 'number') { + throw new Error(`"${numVal}" is not a number`) + } + + if (numVal === 0) { + return numVal + } + + if (numVal % 3 === 0 && numVal % 5 === 0) { + return 'fizzbuzz' + } + + if (numVal % 3 === 0) { + return 'fizz' + } + + if (numVal % 5 === 0) { + return 'buzz' + } + + return numVal + } + +const printFizzbuzz = number => { + for (let i = 1; i <= number; i++) { + console.log(`${fizzbuzz(i)}`) + } + } + +printFizzbuzz(100) \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/JuanPaperez.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/JuanPaperez.py" new file mode 100644 index 0000000000..bf9e35ef1c --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/JuanPaperez.py" @@ -0,0 +1,9 @@ +for i in range(1,101): + if i%3 == 0 and i%5 == 0: + print("fizz buzz") + elif i%3 == 0: + print("fizz") + elif i%5 == 0: + print("buzz") + else: + print(i) \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/iTzBigPerrito.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/iTzBigPerrito.py" index c12fd666d5..d770a5969a 100644 --- "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/iTzBigPerrito.py" +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/iTzBigPerrito.py" @@ -6,15 +6,15 @@ def main(): multiplo3 = x % 3 multiplo5 = x % 5 - if(multiplo3 == 0): + if(multiplo3 == 0 and multiplo5 == 0): + print('fizzbuzz') + continue + elif(multiplo3 == 0): print('fizz') continue elif(multiplo5 == 0): print('buzz') continue - elif(multiplo3 == 0 and multiplo5 == 0): - print('fizzbuzz') - continue else: print(x) diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/mariovelascodev.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/mariovelascodev.py" new file mode 100644 index 0000000000..89c2520e64 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/mariovelascodev.py" @@ -0,0 +1,12 @@ +def fizz_buzz(): + for number in range(1,101): + if number % 3 == 0 and number % 5 == 0: + print("fizzbuzz") + elif number % 3 == 0: + print("fizz") + elif number % 5 == 0: + print("buzz") + else: + print(number) + +fizz_buzz() \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/n4nd1k4nde.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/n4nd1k4nde.py" new file mode 100644 index 0000000000..6d4274bcd4 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/n4nd1k4nde.py" @@ -0,0 +1,20 @@ +''' +/* + * 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 i in range(1, 101): + if i % 3 and i % 5 == 0: + print("fizzbuzz") + elif i % 5 == 0: + print("buzz") + elif i % 3 == 0: + print("fizz") + else: + print(i) diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/typescript/andeveling.ts" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/typescript/andeveling.ts" new file mode 100644 index 0000000000..f6ac0ed54c --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/typescript/andeveling.ts" @@ -0,0 +1,11 @@ +const fizzBuzz = (limit: number): void => { + const numbers = Array.from({ length: limit }, (_, index) => index + 1) + for (const number of numbers) { + if (number % 3 === 0) console.log("fizz") + if (number % 5 === 0) console.log("buzz") + if (number % 3 === 0 && number % 5 === 0) console.log("fizzbuzz") + else console.log(number) + } +} + +fizzBuzz(100) diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/BRivasTorres.js" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/BRivasTorres.js" new file mode 100644 index 0000000000..3ea8aba8d9 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/BRivasTorres.js" @@ -0,0 +1,50 @@ +const leetAlphabet = { + a: "4", + b: "13", + 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", + 1: "L", + 2: "R", + 3: "E", + 4: "A", + 5: "S", + 6: "b", + 7: "T", + 8: "B", + 9: "g", + 0: "o", +}; + +const lenguajeHacker = (s) => { + let r = ""; + for (let char of s.toLowerCase()) { + let isChar = leetAlphabet[char]; + isChar ? (r += isChar) : (r += char); + } + return r; +}; + +console.log(lenguajeHacker("Reto mouredev #4")); +console.log(lenguajeHacker("Hola Mundo")); diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/aran-tm.js" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/aran-tm.js" new file mode 100644 index 0000000000..66ab2c2824 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/aran-tm.js" @@ -0,0 +1,64 @@ + +const LOWER_CASE_LETTERS = + ['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']; + +const UPPER_CASE_LETTERS = + ['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']; + +const LEET_SPEAK_ALPHABET = + ['4', 'I3', '[', ')', '3', '|=', '&', '#', '1', ',_|', '>|', '1', 'IVI', + '^/', '0', '|*', '(_,)', 'I2', '5', '7', '(_)', '\/', '\/\/', '><', 'j', '2'] + +const LEET_NUMBERS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; +const NUMBERS_TO_LEET = ['()', 'L', 'R', 'E', 'A', 'S', 'b', 'T', 'B', 'g']; + +function convert_to_leet_alphabet(){ + + // get the string + let stringFromUser = prompt("Please enter an entry"); + let string_hacked = []; + + // convert to an array + let arrayFromString = stringFromUser.split(""); + + // using a foreach to compare each character with each array element + arrayFromString.forEach(element => { + + let indexOfLetters; + let indexOfNumbers; + + // to check if it's a lower case letter + if (LOWER_CASE_LETTERS.includes(element)) { + + indexOfLetters = LOWER_CASE_LETTERS.indexOf(element); + string_hacked.push(LEET_SPEAK_ALPHABET[indexOfLetters]); + } + + // to check if it's a upper case letter + else if (UPPER_CASE_LETTERS.includes(element)) { + + indexOfLetters = UPPER_CASE_LETTERS.indexOf(element); + string_hacked.push(LEET_SPEAK_ALPHABET[indexOfLetters]); + } + + // To check if it's a number + else if (LEET_NUMBERS.includes(Number(element))) { + + indexOfNumbers = LEET_NUMBERS.indexOf(Number(element)); + string_hacked.push(NUMBERS_TO_LEET[indexOfNumbers]); + } + + // to identify if there is a space + else if (element == "") { + + string_hacked.push(" "); + } + }); + + console.log(string_hacked); +} + +// calling the function +convert_to_leet_alphabet(); \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/php/julianpk19961.php" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/php/julianpk19961.php" new file mode 100644 index 0000000000..485c15ed02 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/php/julianpk19961.php" @@ -0,0 +1,89 @@ + "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", + "0" => "o", + "1" => "L", + "2" => "R", + "3" => "E", + "4" => "A", + "5" => "S", + "6" => "b", + "7" => "T", + "8" => "B", + "9" => "g", +]; + +$exceptionsChar = [" ", ".", ",", "'"]; + +function sentencesToLeet($sentence = 'Sentence is void') +{ + + global $transform, $exceptionsChar; + + if (gettype($sentence) === 'object') { + $sentence = "I Can't work with a object, sorry"; + } + + if (gettype($sentence) === 'array') { + $sentence = implode($sentence); + } + + $leetSentences = str_split(strtolower($sentence)); + + foreach ($leetSentences as $character) { + $key = str_replace($exceptionsChar, "", $character); + if ($key) { + echo $transform[$key]; + } else { + echo $character; + } + }; + echo "\n"; +} + + +sentencesToLeet(new stdClass); +sentencesToLeet(["this", "an", "array"]); +sentencesToLeet(25660); +sentencesToLeet(25, 5); +sentencesToLeet(25.5); +sentencesToLeet("Hello"); \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/DanniRodrJ.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/DanniRodrJ.py" new file mode 100644 index 0000000000..79fbf88b3f --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/DanniRodrJ.py" @@ -0,0 +1,30 @@ +''' +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") +''' +def translator(text): + leet_speak = {'a': 4, 'b': 8, 'c': '<', 'd': '>', 'e': '&', 'f': 'v', 'g': 9, 'h': '#', + 'i': 1, 'j': ';', 'k': '1<', 'l': '£', 'm': '^^', 'n': 'И', 'o': 0, 'p': 9, + 'q': 2, 'r': 'Я', 's': 5, 't': 7, 'u': 'µ', 'v': '\/', 'w': 'Ш', 'x': 'ecks', + 'y': '¥', 'z': 's'} + list_ls = [] + + for letter in text: + if letter in leet_speak.keys(): + list_ls.append(leet_speak[letter]) + else: + list_ls.append(letter) + + end_text = ''.join(map(str, list_ls)) + return end_text + + +test = 'Leet speak o leet es un tipo de escritura compuesta de caracteres alfanuméricos' +print(translator(test)) + +user = input('Texto a traducir: ').lower() +print(translator(user)) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/adra-dev.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/adra-dev.py" new file mode 100644 index 0000000000..32df34bbc9 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/adra-dev.py" @@ -0,0 +1,35 @@ +""" +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") + +""" + +def to_leet(text): + + leet = {"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", + } + + leet_text="" + + for word in text: + if word.upper() in leet.keys(): + leet_text += leet[word.upper()] + else: + leet_text += word + + return leet_text + + +print(to_leet("Leet")) +print(to_leet("Aquí está un texto de prueba para ver si funciona el reto!")) +print(to_leet(input("Texto a traducir: "))) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/mariovelascodev.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/mariovelascodev.py" new file mode 100644 index 0000000000..b4fe6c0eaf --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/mariovelascodev.py" @@ -0,0 +1,26 @@ +def leet (text): + #Convertir el texto en una lista y en minúsculas + text_list = list(text.lower()) + + """ + Creamos una variable donde almacenar la conversion a lenguaje hacker + y un diccionario con el lenguaje hacker + """ + leet="" + my_dictionary_leet = {"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", " ":" "} + + #Comprobar cada valor de la lista y convertirlo a lenguaje hacker + for character in text_list: + for value_dictionary in my_dictionary_leet: + if character == value_dictionary: + leet +=my_dictionary_leet[value_dictionary] + + return leet + +print(leet("Leet")) +print(leet("El Lenguaje hacker")) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/treber.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/treber.py" new file mode 100644 index 0000000000..cc7c679fec --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/treber.py" @@ -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") + + """ + +leetAlphabet = {'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'} + +leetNumber = {"0":"o", "1":"L", "2":"R", "3":"E", "4":"A", "5":"S", "6":"b", "7":"T", "8":"B", "9":"g"} + + +def inputTxt(): + + text = input("Escribe su texto aquí (solo alfanumerico): ").lower() + if text.isalnum(): + return text + else: + return inputTxt() + + +def hackerTxt(text): + + txtTransform = "" + + for caracter in text: + if caracter in leetAlphabet.keys(): + txtTransform+= leetAlphabet[caracter] + else: + txtTransform+= leetNumber[caracter] + + return txtTransform + + +text = inputTxt() +newTxt = hackerTxt(text) +print(newTxt) diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/typescript/Andeveling.ts" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/typescript/Andeveling.ts" new file mode 100644 index 0000000000..95a7096809 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/typescript/Andeveling.ts" @@ -0,0 +1,53 @@ +const leetTable: Record = { + 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: "`/", + Z: "2", + 1: "L", + 2: "R", + 3: "E", + 4: "A", + 5: "S", + 6: "b", + 7: "T", + 8: "B", + 9: "g", + 0: "o", +} + +/** + * Translates a given text by replacing characters according to a provided leet table. + * + * @param {string} text - The text to be translated. + * @param {Record} leetTable - The leet table containing character mappings. + * @return {string} The translated text. + */ +const translateLeet = (text: string = "", leetTable: Record): string => + text + .split("") + .map((char) => leetTable[char.toUpperCase()] || char) + .join("") + +console.log(translateLeet("Hello World", leetTable)) diff --git a/Retos/Reto #10 - LA API [Media]/javascript/marvnramos.js b/Retos/Reto #10 - LA API [Media]/javascript/marvnramos.js new file mode 100644 index 0000000000..e37d40eb78 --- /dev/null +++ b/Retos/Reto #10 - LA API [Media]/javascript/marvnramos.js @@ -0,0 +1,16 @@ +const URL_BASE = "https://pokeapi.co/api/v2/pokemon/"; + +async function getPokemon(pokemon) { + await fetch(URL_BASE + pokemon) + .then(res => res.json()) + .then(pokeRes => { + console.log({ + id: pokeRes.id, + name: pokeRes.name, + height: pokeRes.height, + weight: pokeRes.weight + }); + }); +} + +getPokemon("pikachu"); // by Name output: { id: 25, name: 'pikachu', height: 4, weight: 60 } \ No newline at end of file diff --git a/Retos/Reto #10 - LA API [Media]/python/rokmanhaman.py b/Retos/Reto #10 - LA API [Media]/python/rokmanhaman.py new file mode 100644 index 0000000000..43779a6efc --- /dev/null +++ b/Retos/Reto #10 - LA API [Media]/python/rokmanhaman.py @@ -0,0 +1,23 @@ +""" +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 + */ + """ + +import requests + +url = "https://www.fruityvice.com/api/fruit/all" + + +response = requests.get(url) + + +for fruit in response.json(): + print(f"{fruit['name']} --- {fruit['family']}") diff --git "a/Retos/Reto #11 - URL PARAMS [F\303\241cil]/javascript/marvnramos.js" "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/javascript/marvnramos.js" new file mode 100644 index 0000000000..f4277cd3aa --- /dev/null +++ "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/javascript/marvnramos.js" @@ -0,0 +1,31 @@ +const url = 'https://retosdeprogramacion.com?year=2023&challenge=0'; + +/** + * Get the parameters from a url and print them in the console + * @param {*} url - The url to get the parameters from + */ +const getParameters = (url) => { + let index = url.indexOf('?'); + let values = []; + + for(let i = index + 1; i < url.length; i++) { + let endIndex = url.indexOf('&', i); + + if(endIndex === -1) { + endIndex = url.length; + } + + let startIndex = url.lastIndexOf('=', endIndex); + if(startIndex === -1) { + startIndex = i; + } + + values.push(url.slice(startIndex + 1, endIndex)); + + // Update the index to skip the current parameter value + i = endIndex; + } + console.log(values); +} + +getParameters(url); \ No newline at end of file diff --git "a/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/rokmanhaman.py" "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/rokmanhaman.py" new file mode 100644 index 0000000000..13dea600eb --- /dev/null +++ "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/rokmanhaman.py" @@ -0,0 +1,24 @@ +""" +Reto #11: URL PARAMS +FÁCIL | Publicación: 13/03/23 | Resolución: 20/03/23 +/* + * 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"] + */ +""" + +def split_url(url): + url_p0 = url.split("?")[0] + url_p1 = url.split("?")[1] + parametrs = url_p1.split("&") + my_dict = {param.split("=")[0]: param.split("=")[1] for param in parametrs} + + return my_dict.values() + + +url = "https://retosdeprogramacion.com?year=2023&challenge=0&activo=true&visible=false&pag=42&q=consulta" +s = split_url(url) +print(s) diff --git "a/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/treber.py" "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/treber.py" new file mode 100644 index 0000000000..996ea280bc --- /dev/null +++ "b/Retos/Reto #11 - URL PARAMS [F\303\241cil]/python/treber.py" @@ -0,0 +1,30 @@ +# Reto #11: URL params +#### Dificultad: Fácil | Publicación: 13/03/23 | Corrección: 20/03/23 + +## Enunciado + +""" +/* + * 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"] + */ +""" + +url = input("Pegue su url con parámetros: ") + + +def findParams(): + params = [] + x = url.split("?") + lista = x[1].split("&") # ['year=2023', 'challenge=0'] + for y in lista: + z = y.split("=") # ['year', '2023'] + params.append(z[1]) + + return params + +params_url = findParams() +print(f"los parámetros de la url son: {params_url}") diff --git "a/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/python/rokmanhaman.py" "b/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/python/rokmanhaman.py" new file mode 100644 index 0000000000..fbf0eda7e9 --- /dev/null +++ "b/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/python/rokmanhaman.py" @@ -0,0 +1,23 @@ +""" +Reto #12: VIERNES 13 +FÁCIL | Publicación: 20/03/23 | Resolución: 27/03/23 +/* + * Crea una función que sea capaz de detectar si existe un viernes 13 + * en el mes y el año indicados. + * - La función recibirá el mes y el año y retornará verdadero o falso. + */ +""" +from datetime import datetime + +def det_v13(year, month): + fecha_especifica = datetime(year, month, 13) + dia_de_la_semana = fecha_especifica.weekday() + + + + return True if fecha_especifica.weekday() == 4 else False + +#2023 month 1 ==> True +#2023 month 10 ==> True +indicado = det_v13(2023, 11) +print(indicado) \ No newline at end of file diff --git a/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/python/DCRael.py b/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/python/DCRael.py new file mode 100644 index 0000000000..d8bc06001f --- /dev/null +++ b/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/python/DCRael.py @@ -0,0 +1,91 @@ +from random import choice, randint, sample +from os import * + +longitud_palabra = "" + +def inicio(): + system("cls") + words = ['LAPTOP', 'CELULAR', 'JIRAFA', 'PYTHON', 'GATO', 'MESSI', 'GOAT'] + global longitud_palabra + print('ADIVINA LA PALABRA') + palabra_seleccionada = choice(words) + longitud_palabra = len(palabra_seleccionada) + palabra_adivinanza = list("_" * longitud_palabra) + + # Se delimita las letras mostradas y selecciona indices que se mostraran + num_letras_mostradas = randint(2, longitud_palabra//2) + posiciones_mostradas = sample(range(longitud_palabra), num_letras_mostradas) + + # Reemplazar los guiones bajos en las posiciones seleccionadas con las letras correspondientes + for i in posiciones_mostradas: + palabra_adivinanza[i] = palabra_seleccionada[i] + + juego(palabra_seleccionada, palabra_adivinanza) + + +def juego(palabra_seleccionada, palabra_adivinanza): + intentos = 6 + + while True: + + espacios = 0 + print("INTENTOS DISPONIBLES: ", intentos) + print(" ".join(palabra_adivinanza)) + dibujo(intentos) + + for i in range(longitud_palabra): + if palabra_adivinanza[i] == '_': + espacios += 1 + + if espacios == 0 and intentos != 0: + print('has ganado bien jugado') + system("pause") + inicio() + + elif intentos == 0: + print('Haz perdido') + system("pause") + inicio() + + texto = input('Escribe una letra o la palabra: ').upper() + + + if len(texto) == 1: + + if texto in palabra_seleccionada: + i = palabra_seleccionada.find(texto) + palabra_adivinanza[i] = palabra_seleccionada[i] + else: + intentos -= 1 + + elif len(texto) == longitud_palabra: + + if texto == palabra_seleccionada: + palabra_adivinanza = palabra_seleccionada + else: + intentos -= 1 + + else: + intentos -= 1 + + + +def dibujo(intentos): + + if intentos == 6: + print("\n _______\n | |\n |\n |\n |\n |\n |\n ----------") + elif intentos == 5: + print("\n _______\n | |\n | 0\n |\n |\n |\n |\n ----------") + elif intentos == 4: + print("\n _______\n | |\n | 0\n | |\n |\n |\n |\n ----------") + elif intentos == 3: + print("\n _______\n | |\n | 0\n | /|\n |\n |\n |\n ----------") + elif intentos == 2: + print("\n _______\n | |\n | 0\n | /|\ \n |\n |\n |\n ----------") + elif intentos == 1: + print("\n _______\n | |\n | 0\n | /|\ \n | /\n |\n |\n ----------") + elif intentos == 0: + print("\n _______\n | |\n | 0\n | /|\ \n | / \ \n |\n |\n ----------") + + +inicio() \ No newline at end of file diff --git a/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/python/rokmanhaman.py b/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/python/rokmanhaman.py new file mode 100644 index 0000000000..70751a8cfa --- /dev/null +++ b/Retos/Reto #13 - ADIVINA LA PALABRA [Media]/python/rokmanhaman.py @@ -0,0 +1,89 @@ +""" +Reto #13: ADIVINA LA PALABRA +FÁCIL | Publicación: 27/03/23 | Resolución: 03/04/23 +/* + * Crea un pequeño juego que consista en adivinar palabras en un número máximo de intentos: + * - El juego comienza proponiendo una palabra aleatoria incompleta + * - Por ejemplo "m_ur_d_v", y el número de intentos que le quedan + * - El usuario puede introducir únicamente una letra o una palabra (de la misma longitud que + * la palabra a adivinar) + * - Si escribe una letra y acierta, se muestra esa letra en la palabra. Si falla, se resta + * uno al número de intentos + * - Si escribe una resolución y acierta, finaliza el juego, en caso contrario, se resta uno + * al número de intentos + * - Si el contador de intentos llega a 0, el jugador pierde + * - La palabra debe ocultar de forma aleatoria letras, y nunca puede comenzar + * ocultando más del 60% + * - Puedes utilizar las palabras que quieras y el número de intentos que consideres + */ + """ +import math +import random + +class Word(): + + def __init__(self, word, attemps): + self.word = word + self.attemps = attemps + + + def initial_sample(self): + max_zeros = 0.6 + hidden_word = "" + word_list = self.word.split() + + for word in word_list: + for i, letter in enumerate(word): + if random.random() < max_zeros: + hidden_word += word[i] + else: + hidden_word += '_' + + hidden_word = hidden_word + " " + + return hidden_word[:-1] + + def guess_word(self): + + + dict_hidden = {index: character for index, character in enumerate(self.initial_sample())} + dict_word = {index: character for index, character in enumerate(self.word)} + + att = self.attemps + + a = ''.join(dict_hidden.values()) + b = ''.join(dict_word.values()) + + while att > 0: + + if list(dict_hidden.values()).count("_") == 0: + out = "WiNNer!!!" + break + + else: + print(f"la palabra a adivinar es: {''.join(dict_hidden.values())}") + letter = input("Ingrese una letra: ") + + if letter not in dict_word.values(): + att = att - 1 + print(f"la letra: {letter} no se encuentra en la frase. Le quedan {att} intentos") + + """ + elif dict_hidden == dict_word: + out = "WiNNer!!!" + break + """ + else: + indexs = [key for key, value in dict_word.items() if value == letter] + + for index in indexs: + dict_hidden[index] = letter + + if att == 0: + out = "GaMe OvEr!!!" + + return print(out) + +word = Word("hola manola campeon", 5) +#print(word.initial_sample()) +word.guess_word() \ No newline at end of file diff --git "a/Retos/Reto #14 - OCTAL Y HEXADECIMAL [F\303\241cil]/python/rokmanhaman.py" "b/Retos/Reto #14 - OCTAL Y HEXADECIMAL [F\303\241cil]/python/rokmanhaman.py" new file mode 100644 index 0000000000..086165784c --- /dev/null +++ "b/Retos/Reto #14 - OCTAL Y HEXADECIMAL [F\303\241cil]/python/rokmanhaman.py" @@ -0,0 +1,61 @@ +""" +Reto #14: OCTAL Y HEXADECIMAL +FÁCIL | Publicación: 03/04/23 | Resolución: 10/04/23 +/* + * Crea una función que reciba un número decimal y lo trasforme a Octal + * y Hexadecimal. + * - No está permitido usar funciones propias del lenguaje de programación que + * realicen esas operaciones directamente. + */ +""" + +class Number(): + + def __init__(self, number): + self.number = number + + def dec_to_oct(self): + + cociente_list = [self.number // 8] + resto_list = [self.number % 8] + i = 0 + while cociente_list[i] >= 8: + cociente_list.append(cociente_list[i] // 8) + resto_list.append(cociente_list[i] % 8) + i = i + 1 + + + largo = len(resto_list) + last_cociente = cociente_list[i] + invert_resto = [resto_list[x] for x in range(largo-1,-1,-1)] + + resultado_text = str(last_cociente)+ "".join(map(str, invert_resto)) + + return print(f" el num decimal: {self.number} se corresponde con el num octal: {resultado_text}") + + def dec_to_hex(self): + cociente_list = [self.number // 16] + resto_list = [self.number % 16] + i = 0 + while cociente_list[i] >= 16: + cociente_list.append(cociente_list[i] // 16) + resto_list.append(cociente_list[i] % 16) + i = i + 1 + + + last_cociente = cociente_list[i] + invert_resto = resto_list[::-1] + hex_values = "0123456789ABCDEF" + last_cociente_hex = hex_values[last_cociente] + invert_resto_hex = [hex_values[y] for y in invert_resto] + + resultado_text = str(last_cociente_hex)+ "".join(map(str, invert_resto_hex)) + + return print(f" el num decimal: {self.number} se corresponde con el num hexa: {resultado_text}") + + +num_dec = Number(255) + +num_dec.dec_to_oct() +num_dec.dec_to_hex() + diff --git a/Retos/Reto #16 - LA ESCALERA [Media]/javascript/giovanyosorio.js b/Retos/Reto #16 - LA ESCALERA [Media]/javascript/giovanyosorio.js new file mode 100644 index 0000000000..8bf92d560e --- /dev/null +++ b/Retos/Reto #16 - LA ESCALERA [Media]/javascript/giovanyosorio.js @@ -0,0 +1,48 @@ +/* + * Crea una función que dibuje una escalera según su número de escalones. + * - Si el número es positivo, será ascendente de izquiera a derecha. + * - Si el número es negativo, será descendente de izquiera a derecha. + * - Si el número es cero, se dibujarán dos guiones bajos (__). + * + * Ejemplo: 4 + * _ + * _| + * _| + * _| + * _| + * + +*/ + + +function escalera(num){ + let space=" " + if(num>0) + { + for (let index = 0; index < num; index++) + { + console.log(space.repeat(num-index) + '_|'); + } + } + + if(num<0) + { + let newnum=Math.abs(num) + for (let index = 0; index < newnum; index++) + { + console.log(space.repeat(index) + '_|'); + } + console.log("menos 0") + } + + if(num==0){ + return '__'; + } + + + +} +escalera(-2) +escalera(4) + +escalera(0) \ No newline at end of file diff --git "a/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/javascript/giovanyosorio.js" "b/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/javascript/giovanyosorio.js" new file mode 100644 index 0000000000..bed906771e --- /dev/null +++ "b/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/javascript/giovanyosorio.js" @@ -0,0 +1,34 @@ +/* + * Crea un programa que analice texto y obtenga: + * - Número total de palabras. + * - Longitud media de las palabras. + * - Número de oraciones del texto (cada vez que aparecen un punto). + * - Encuentre la palabra más larga. + * + * Todo esto utilizando un único bucle. + */ + +function analizar(texto){ + const palabras=texto.split(" ") + let sentences=texto.split(".") + let mayor=palabras[0] + + for(let i=0;imayor.length){ + mayor=palabras[i] + } + } + //console.log(palabras) + //console.log(palabras.join("").length) + //console.log(palabras.length) + let average=palabras.join("").length/palabras.length + console.log("Longitud media de palabras: "+average) + console.log("Numero total de palabras: "+texto.split(" ").length) + console.log("letra mayor: "+mayor) + console.log("numero de oraciones del texto: "+sentences.length) + } + + analizar("Crea un programa que analice texto y obtenga: Número total de palabras. Longitud media de las palabras. Número de oraciones del texto(cada vez que aparecen un punto). Encuentre la palabra más larga (Supercalifragilisticoespialidoso). Todo esto utilizando un único bucle.") + + \ No newline at end of file diff --git "a/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/python/rokmanhaman.py" "b/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/python/rokmanhaman.py" new file mode 100644 index 0000000000..92ea686724 --- /dev/null +++ "b/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/python/rokmanhaman.py" @@ -0,0 +1,43 @@ +""" +Reto #19: ANÁLISIS DE TEXTO +MEDIA | Publicación: 11/05/23 | Resolución: 15/05/23 +/* + * Crea un programa que analice texto y obtenga: + * - Número total de palabras. + * - Longitud media de las palabras. + * - Número de oraciones del texto (cada vez que aparecen un punto). + * - Encuentre la palabra más larga. + * + * Todo esto utilizando un único bucle. + */ +""" + + +def analice_text(text): + + num_sentences = text.count(".") + list = text.split() + num_word = len(list) + + my_dict = { word : len(word) for word in list} + ave_length = round(sum(my_dict.values()) / len(my_dict.values()), 2) + + key_max_len = max(my_dict, key=my_dict.get) + print(my_dict) + + + + + return num_sentences, num_word, ave_length, key_max_len + + + + + +text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam volutpat, velit a aliquam cursus, justo turpis viverra libero, ac fringilla lectus justo nec turpis. Sed non ligula nec elit hendrerit laoreet. Suspendisses nec rhoncus libero. Maecenas a neque quis ipsum commodo vestibulum. Fusce consectetur urna at est ultrices, a posuere orci commodo. Vestibulum vel justo a justo tristique accumsan. Proin efficitur nisi quis metus luctus, in hendrerit lectus fermentum. Nullam sagittis, nisl vel tincidunt tristique, eros lacus tincidunt elit, vel consequat justo sapien vel eros. In hac habitasse platea dictumst. Vivamus fringilla metus ac ante varius, vel lacinia mi tincidunt. Curabitur accumsan, ex ut hendrerit semper, orci tortor volutpat ligula, sit amet blandit metus urna at tellus. Curabitur in vehicula enim. Nullam sit amet lacinia odio." + +a, b, c, d = analice_text(text) +print(f"\nLa cantidad de oraciones es: {a}") +print(f"\nEl numero de palabras es: {b}") +print(f"\nLa longitud media de las palabras es: {c}") +print(f"\nLa palabra mas larga es : {d}") \ No newline at end of file diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/BRivasTorres.js b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/BRivasTorres.js new file mode 100644 index 0000000000..6f2494c8a8 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/BRivasTorres.js @@ -0,0 +1,51 @@ +const points = { + 0: "Love", + 1: 15, + 2: 30, + 3: 40, +}; + +const showGame = (arr) => { + let results = ""; + let [currPointsP1, currPointsP2] = [0, 0]; + + for (let i = 0; i < arr.length; i++) { + let currPoint = arr[i]; + + switch (currPoint) { + case "P1": + currPointsP1++; + break; + case "P2": + currPointsP2++; + break; + default: + break; + } + + if (currPointsP1 >= 4 && currPointsP1 - currPointsP2 >= 2) { + results += "Ha ganado P1\n"; + break; + } else if (currPointsP2 >= 4 && currPointsP2 - currPointsP1 >= 2) { + results += "Ha ganado P2\n"; + break; + } + + if (currPointsP1 >= 3 && currPointsP2 >= 3) { + if (currPointsP1 === currPointsP2) { + results += "Deuce\n"; + } else if (currPointsP1 - currPointsP2 === 1) { + results += "Ventaja P1\n"; + } else if (currPointsP2 - currPointsP1 === 1) { + results += "Ventaja P2\n"; + } + } else { + results += `${points[currPointsP1] || currPointsP1} - ${ + points[currPointsP2] || currPointsP2 + }\n`; + } + } + return results; +}; + +console.log(showGame(["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"])); diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/daldev14.js b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/daldev14.js new file mode 100644 index 0000000000..6a71543939 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/daldev14.js @@ -0,0 +1,62 @@ +/* + * 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. + */ + +function jugarTenis(secuencia) { + let puntuacionP1 = 0 + let puntuacionP2 = 0 + + const puntuaciones = ["Love", 15, 30, 40] + + for (let punto of secuencia) { + if (punto === "P1") { + puntuacionP1++ + } else if (punto === "P2") { + puntuacionP2++ + } + + // Mostrar puntuación actual + if (puntuacionP1 >= 3 && puntuacionP2 >= 3) { + if (puntuacionP1 === puntuacionP2) { + console.log("Deuce") + } else if (puntuacionP1 > puntuacionP2) { + console.log("Ventaja P1") + } else { + console.log("Ventaja P2") + } + } else { + console.log( + `${puntuaciones[puntuacionP1]} - ${puntuaciones[puntuacionP2]}` + ) + } + + // Verificar si hay un ganador + if (puntuacionP1 >= 4 && puntuacionP1 - puntuacionP2 >= 2) { + console.log("Ha ganado el P1") + return + } else if (puntuacionP2 >= 4 && puntuacionP2 - puntuacionP1 >= 2) { + console.log("Ha ganado el P2") + return + } + } +} + +// Ejemplo de uso +const secuenciaJuego = ["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"] +jugarTenis(secuenciaJuego) + diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/marvnramos.js b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/marvnramos.js new file mode 100644 index 0000000000..7012d14f5a --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/marvnramos.js @@ -0,0 +1,55 @@ +// P1 (player 1) +// P2 (player 2) + +const show_score = (plays) =>{ + // initializing player's score + let P1 = 0; + let P2 = 0; + + // Iterate over each play in array plays + for(let play in plays){ + if(plays[play] === "P1"){ + P1++; + } + else{ + P2++; + } + + // logic to determinate the game status + let game_status = determinate_game_status(P1, P2); + console.log(game_status); + + if(game_status === "Ganador"){ + break; + } + } +} + +const determinate_game_status = (P1, P2) =>{ + if(P1 == 1 && P2 == 0){ + return "15 - Love"; + } + else if(P1 == 2 && P2 == 0){ + return "30 - Love"; + } + else if(P1 == 2 && P2 == 1){ + return "30 - 15"; + } + else if(P1 == 2 && P2 == 2){ + return "30 - 30"; + } + else if(P1 == 3 && P2 == 2){ + return "40 - 30"; + } + else if(P1 == P2){ + return "Deuce"; + }else if (P1 == 4) { + return "Ventaja P1"; + }else if (P1 > 4) { + return "Ha ganado el P1"; + } +} + + +let sequence_of_actions = ["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"]; +show_score(sequence_of_actions); diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/MarcosDigu.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/MarcosDigu.py new file mode 100644 index 0000000000..735cee17c6 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/MarcosDigu.py @@ -0,0 +1,41 @@ +import os + +os.system('cls') + +puntaje = ["0", "15", "30", "40", "Ad"] + +P1 = puntaje[0] +P2 = puntaje[0] + +game_finished = False + +while not game_finished: + print(f"Score P1: {P1}") + print(f"Score P2: {P2}") + print(" ") + + winner = input("Type P1 or P2: ") + + if P1 == "Ad" and P2 == "40" and winner == "P1": + game_finished = True + elif P2 == "Ad" and P1 == "40" and winner == "P2": + game_finished = True + else: + index_P1 = puntaje.index(P1) + index_P2 = puntaje.index(P2) + + if winner == "P1": + P1 = puntaje[index_P1 + 1] + if P1 == "Ad" and P2 in ["0", "15", "30"]: + game_finished = True + else: + P2 = puntaje[index_P2 + 1] + if P2 == "Ad" and P1 in ["0", "15", "30"]: + game_finished = True + + os.system('cls') + +if P1 == "Ad": + print("Player 1 won") +else: + print("Player 2 won") diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/ajloinformatico.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/ajloinformatico.py new file mode 100644 index 0000000000..2102911405 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/ajloinformatico.py @@ -0,0 +1,135 @@ +from random import randint +from os import system + +""" +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. +""" + +APP_NAME = """ +####################################### + TENNIS MATCH + + by infolojo + https:://infolojo.es + Antonio José Lojo Ojeda +####################################### +""" +DEUCE = "DEUCE" +ADVENTAGE = "ADVENTAGE" + +class Match: + def __init__(self, playerOne: str = "", playerTwo: str = ""): + self.playerOne: str = playerOne + self.playerTwo: str = playerTwo + self.service: int = 0 + self.playerOnePoint: int = 0 + self.playerTwoPoint: int = 0 + self.pointsList = ["Love", "15", "30", "40", "GAME"] + + def add_players(self): + if self.playerOne == "": + self.playerOne = input("Please enter P1 name:\n>> ") + if self.playerTwo == "": + self.playerTwo = input("Please enter P2 name:\n>> ") + + return f"\nPlayers {self.playerOne} and {self.playerTwo} are ready" + + def launch_round(self, mockk: bool = False): + if mockk == True: + self.playerOnePoint += 1 + self.playerTwoPoint += 1 + + else: + playerWinner: str = [self.playerOne, self.playerTwo][randint(0, 1)] + if playerWinner == self.playerOne: + self.playerOnePoint += 1 + elif playerWinner == self.playerTwo: + self.playerTwoPoint += 1 + + + actualPoints: str + if self.playerOnePoint >= 3 and self.playerTwoPoint >= 3: + # deuce + if self.playerOnePoint == self.playerTwoPoint: + actualPoints = f"\n{self.playerOne} - {DEUCE} | {self.playerTwo} - {DEUCE}" + + # player one wins + elif self.playerOnePoint - self.playerTwoPoint == 2: + actualPoints = f"\n{self.playerOne} - GAME | {self.playerTwo} - 40" + + # player one wins + elif self.playerTwoPoint - self.playerOnePoint == 2: + actualPoints = f"\n{self.playerOne} - 40 | {self.playerTwo} - GAME" + + # player one ADVENTAGE + elif self.playerOnePoint > self.playerTwoPoint: + actualPoints = f"\n{self.playerOne} - {ADVENTAGE} | {self.playerTwo} - 40" + + elif self.playerTwoPoint > self.playerOnePoint: + actualPoints = f"\n{self.playerOne} - 40 | {self.playerTwo} - {ADVENTAGE}" + + else: + actualPoints = f"\n{self.playerOne} - {self.pointsList[self.playerOnePoint]} | {self.playerTwo} - {self.pointsList[self.playerTwoPoint]}" + + print(actualPoints) + + def clear_screen(self): + # uncomment by checking your or + # clear windows screen + # system('CLS') + # clear linux screen + system('clear') + + def check_winner(self): + winner: str = "" + if self.playerOnePoint >= 3 and self.playerTwoPoint >= 3: + if self.playerOnePoint > 3 and (self.playerOnePoint - self.playerTwoPoint == 2): + winner = f"\nCongratulations {self.playerOne.upper()} YOU WINS\n" + elif self.playerTwoPoint > 3 and (self.playerTwoPoint - self.playerOnePoint == 2): + winner = f"\nCongratulations {self.playerTwo.upper()} YOU WINS\n" + + elif self.playerOnePoint == 4: + winner = f"\nCongratulations {self.playerOne.upper()} YOU WINS\n" + elif self.playerTwoPoint == 4: + winner = f"\nCongratulations {self.playerTwo.upper()} YOU WINS\n" + + if winner != "": + print(winner) + return True + return False + + def run(self): + self.clear_screen() + print(APP_NAME) + print(self.add_players()) + + while(True): + # check to finish game + if self.check_winner(): + return + + # upgrade service number + self.service += 1 + print(f"\nService number {self.service}:") + + + # launch rounf game + self.launch_round() + +if __name__ == "__main__": + Match().run() \ No newline at end of file diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/danielzx9.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/danielzx9.py new file mode 100644 index 0000000000..1430548648 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/danielzx9.py @@ -0,0 +1,59 @@ +"""``` +/* + * 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. + */ +```""" + +def puntaje(puntos_p1, puntos_p2): + puntajes = ["Love", "15", "30", "40"] + if puntos_p1 == puntos_p2: + if puntos_p1 < 3: + return f"{puntajes[puntos_p1]} - {puntajes[puntos_p2]}" + elif puntos_p1 == 3: + return "Deuce" + else: + return "Ventaja" + elif puntos_p1 >= 4 or puntos_p2 >= 4: + diferencia = abs(puntos_p1 - puntos_p2) + if diferencia == 1: + return f"Ventaja {'P1' if puntos_p1 > puntos_p2 else 'P2'}" + else: + return f"Ha ganado el {'P1' if puntos_p1 > puntos_p2 else 'P2'}" + else: + return f"{puntajes[puntos_p1]} - {puntajes[puntos_p2]}" + +def game(partido): + p1 = 0 + p2 = 0 + + for punto in partido: + if punto == "P1": + p1 += 1 + elif punto == "P2": + p2 += 1 + else: + print("Entrada no válida") + + resultado = puntaje(p1, p2) + print(resultado) + + if "Ha ganado" in resultado: + break + +secuenciaJuego = ["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"] +game(secuenciaJuego) diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/mariovelascodev.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/mariovelascodev.py new file mode 100644 index 0000000000..731a399d5a --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/mariovelascodev.py @@ -0,0 +1,47 @@ +def match_tennis(points: list): + #Declaración de variables + result = "" + player1 = 0 + player2 = 0 + game_sequence = {0:"Love", 1:"15", 2:"30", 3:"40", 4:"Ventaja", 5:"Ganador"} + + + #Controlamos que se introduce un valor iterable + try: + #Recorremos la lista introducida por parámetros y convertimos los valores en mayúsculas + for game in points: + if game.upper() == "P1": + player1 += 1 + elif game.upper() == "P2": + player2 += 1 + else: + print("La lista solo puede contener valores P1 y P2") + break + + #Si ambos jugadores empatan a 40 se muestra Deuce + if game_sequence[player1] == "40" and game_sequence[player2] == "40": + result += "Deuce\n" + #Si ambos jugadores llegan a Ventaja se muestra Deuce y + #se les reduce un punto a cada jugador + elif game_sequence[player1] == "Ventaja" and game_sequence[player2] == "Ventaja": + result += "Deuce\n" + player1 -= 1 + player2 -= 1 + #Si un jugador tiene ventaja se muestra el jugador que tiene ventaja + elif game_sequence[player1] == "Ventaja" or game_sequence[player2] == "Ventaja": + result += "Ventaja {player}\n".format(player = game) + #Se muestra el jugador que ha ganado el partido + elif game_sequence[player1] == "Ganador" or game_sequence[player2] == "Ganador": + result += "Ha ganador el {player}\n".format(player = game) + break + #Muestra el resto del marcador del partido + else: + result += game_sequence[player1] +" - "+ game_sequence[player2] +"\n" + + return result + except TypeError: + print("Introduce una lista") + + +print(match_tennis(["P1", "P1", "P2", "P2", "P1", "P2", "P1", "P1"])) +print(match_tennis(["p1", "p1", "p2", "p2", "p1", "p2", "p2", "p1","p2","p2"])) \ No newline at end of file diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/typescript/Andeveling.ts b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/typescript/Andeveling.ts new file mode 100644 index 0000000000..9c874aff0c --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/typescript/Andeveling.ts @@ -0,0 +1,91 @@ +const P1 = "P1" +const P2 = "P2" +const sequence = [P1, P1, P2, P2, P1, P2, P1, P1] + +enum Scores { + Love = 0, + Fifteen = 1, + Thirty = 2, + Forty = 3, + Deuce = 4, + Advantage = 5, + Winner = 6, +} + +const scores = { + 0: "Love", + 1: 15, + 2: 30, + 3: 40, + 4: "Deuce", + 5: "Advantage", + 6: "Winner", +} + +class Player { + name: string + score: Scores = Scores.Love + + constructor(name: string) { + this.name = name + } + makePoint() { + this.score++ + } + + getScore() { + return this.score + } +} + +class Game { + player1: Player = new Player(P1) + player2: Player = new Player(P2) + scorePlayer1: Scores = Scores.Love + scorePlayer2: Scores = Scores.Love + isDeuce: boolean = false + + start(sequence: string[]) { + for (const iterator of sequence) { + if (iterator === P1) { + this.player1.score++ + } + if (iterator === P2) { + this.player2.score++ + } + if (this.changeDeuce()) { + this.player1.score++ + this.player2.score++ + console.log("Deuce") + this.isDeuce = true + } else { + const player1Score = this.player1.getScore() + const player2Score = this.player2.getScore() + if (this.isDeuce && player1Score === Scores.Advantage) { + console.log(`${scores[this.player1.score]} ${this.player1.name}`) + } else if (this.isDeuce && player2Score === Scores.Advantage) { + console.log(`${scores[this.player2.score]} ${this.player2.name}`) + } else { + if (player1Score === Scores.Winner) { + console.log(`The winner is ${this.player1.name}`) + break + } + if (player2Score === Scores.Winner) { + console.log(`The winner is ${this.player2.name}`) + break + } + console.log(this.getScoreGame()) + } + } + } + } + changeDeuce() { + return this.player1.score === Scores.Forty && this.player2.score === Scores.Forty + } + + getScoreGame() { + return scores[this.player1.score] + " - " + scores[this.player2.score] + } +} + +new Game().start(sequence) diff --git a/Retos/Reto #20 - LA TRIFUERZA [Media]/javascript/Pancratzia.js b/Retos/Reto #20 - LA TRIFUERZA [Media]/javascript/Pancratzia.js new file mode 100644 index 0000000000..b86d02243c --- /dev/null +++ b/Retos/Reto #20 - LA TRIFUERZA [Media]/javascript/Pancratzia.js @@ -0,0 +1,46 @@ +/* + * ¡El nuevo "The Legend of Zelda: Tears of the Kingdom" ya está disponible! + * + * Crea un programa que dibuje una Trifuerza de "Zelda" + * formada por asteriscos. + * - Debes indicarle el número de filas de los triángulos con un entero positivo (n). + * - Cada triángulo calculará su fila mayor utilizando la fórmula 2n-1. + * + * Ejemplo: Trifuerza 2 + * + * * + * *** + * * * + * *** *** + * + */ + + function dibujarTriFuerza(n = 1) { + + baseTriangulo = 2*n - 1; + let trifuerza = ""; + + for (let i = 0; i < n; i++) { + trifuerza += " ".repeat(baseTriangulo - i) + "*".repeat(2 * i + 1) + "\n"; + } + + + let espaciosDer = n-1; + let espaciosIzq = 2*n - 1; + + //Dibujo los dos triangulos inferiores + for (let i = 0; i < n; i++) { + + trifuerza += " ".repeat(espaciosDer) + "*".repeat(2 * i + 1) + " ".repeat(espaciosIzq) + "*".repeat(2 * i + 1) + "\n"; + + espaciosDer--; + espaciosIzq-=2; + } + + console.log(trifuerza); + } + + dibujarTriFuerza(2); + dibujarTriFuerza(3); + dibujarTriFuerza(10); + \ No newline at end of file diff --git a/Retos/Reto #20 - LA TRIFUERZA [Media]/python/sublian.py b/Retos/Reto #20 - LA TRIFUERZA [Media]/python/sublian.py new file mode 100644 index 0000000000..cdbb7a2a14 --- /dev/null +++ b/Retos/Reto #20 - LA TRIFUERZA [Media]/python/sublian.py @@ -0,0 +1,35 @@ +# Reto #20: La Trifuerza +#### Dificultad: Media | Publicación: 15/05/23 | Corrección: 22/05/23 | Mi Solución : 20/11/23 +## Enunciado +""" + ¡El nuevo "The Legend of Zelda: Tears of the Kingdom" ya está disponible! + + Crea un programa que dibuje una Trifuerza de "Zelda" + formada por asteriscos. + - Debes indicarle el número de filas de los triángulos con un entero positivo (n). + - Cada triángulo calculará su fila mayor utilizando la fórmula 2n-1. + + Ejemplo: Trifuerza 2 + + * + *** + * * + *** *** +""" + +def trifuerza(n: int) -> None: + longitud = 2 * n + + for i in range(1, n + 1): + text = "*" * (2 * i - 1) + text = text.center(longitud * 2) + print(text) + + for i in range(1, n + 1): + text = "*" * (2 * i - 1) + text = text.center(longitud)*2 + print(text) + + +if __name__ == "__main__": + trifuerza(abs(int(input("Indica tu fuerza: ")))) \ No newline at end of file diff --git "a/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/javascript/Cesarpinagon.js" "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/javascript/Cesarpinagon.js" new file mode 100644 index 0000000000..b5ebf85be8 --- /dev/null +++ "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/javascript/Cesarpinagon.js" @@ -0,0 +1,17 @@ +function isPrime(num) { + for(let i = 2, sqrt = Math.sqrt(num); i <= sqrt; i++) + if(num % i === 0) return false; + return num > 1; +} + +function findTwinPrimes(n) { + let twinPrimes = []; + for(let i = 2; i <= n - 2; i++) { + if(isPrime(i) && isPrime(i + 2)) { + twinPrimes.push([i, i + 2]); + } + } + return twinPrimes; +} + +console.log(findTwinPrimes(14)); \ No newline at end of file diff --git "a/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/javascript/Pancratzia.js" "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/javascript/Pancratzia.js" new file mode 100644 index 0000000000..b650f3d8d8 --- /dev/null +++ "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/javascript/Pancratzia.js" @@ -0,0 +1,34 @@ +/* + * Crea un programa que encuentre y muestre todos los pares de números primos + * gemelos en un rango concreto. + * El programa recibirá el rango máximo como número entero positivo. + * + * - Un par de números primos se considera gemelo si la diferencia entre + * ellos es exactamente 2. Por ejemplo (3, 5), (11, 13) + * + * - Ejemplo: Rango 14 + * (3, 5), (5, 7), (11, 13) + */ +function esPrimo(numero){ + if (numero == 0 || numero == 1 || numero == 4) return false; + for (let x = 2; x < numero / 2; x++) { + if (numero % x == 0) return false; + } + return true; +} + +function primosGemelos(rango = 10){ + let primosGemelos=""; + + for(let i=1; i<=rango; i++){ + if(esPrimo(i) && esPrimo(i+2)){ + primosGemelos += "("+i+", "+(i+2)+") "; + } + } + + console.log(primosGemelos); + +} + +primosGemelos(10); +primosGemelos(30); \ No newline at end of file diff --git "a/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/python/sublian.py" "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/python/sublian.py" new file mode 100644 index 0000000000..1a11e73ccd --- /dev/null +++ "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/python/sublian.py" @@ -0,0 +1,42 @@ +# Reto #21: Números primos gemelos +#### Dificultad: Media | Publicación: 22/05/23 | Corrección: 29/05/23 | Mi solución: 24/11/2023 + +## Enunciado +# Crea un programa que encuentre y muestre todos los pares de números primos +# gemelos en un rango concreto. +# El programa recibirá el rango máximo como número entero positivo. +# - Un par de números primos se considera gemelo si la diferencia entre +# ellos es exactamente 2. Por ejemplo (3, 5), (11, 13) +# - Ejemplo: Rango 14 +# (3, 5), (5, 7), (11, 13) + +#creacion de funcion que revisa si es primo o no +def is_prime(number: int)->bool: + #definamos caso base + if number < 2: + return False + + #revisamos si es un numero primo + for index in range(2, number): + if number%index ==0: + return False + return True + +#mostramos los primos gemelos +def find_prime_twins(range_number: int): + if range_number >2: + print(f"Valores gemelos primos para <{range_number}>") + for index in range(2, range_number): + #revisa si el valor no excede el rango y valida si cada elemento es primo + if index +2 <=range_number and is_prime(index) and is_prime(index+2): + print(f"({index}, {index+2})") + else: + print(f"No hay numeros primos gemelos para <{range_number}>") + +if __name__ == "__main__": + + find_prime_twins(42) + find_prime_twins(2) + find_prime_twins(-100) + find_prime_twins(int(input("Ingresa un valor para evaluar la existencia de # primos gemelos: "))) + \ No newline at end of file diff --git "a/Retos/Reto #24 - CIFRADO C\303\211SAR [F\303\241cil]/javascript/giovanyosorio.js" "b/Retos/Reto #24 - CIFRADO C\303\211SAR [F\303\241cil]/javascript/giovanyosorio.js" new file mode 100644 index 0000000000..7b8458bf5e --- /dev/null +++ "b/Retos/Reto #24 - CIFRADO C\303\211SAR [F\303\241cil]/javascript/giovanyosorio.js" @@ -0,0 +1,50 @@ +function cifrar(palabra, clave){ + let letra,respuesta="" + let alfabeto = 'abcdefghijklmnopqrstuvwxyz'; + let cifrado=alfabeto.slice(-clave) + console.log(cifrado) + cifrado+=alfabeto.slice(0,alfabeto.length-clave) + console.log("cifrado "+ cifrado) + console.log(palabra.length) + + for(let i=0;i ", characters) + return characters +} diff --git "a/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/rokmanhaman.py" "b/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/rokmanhaman.py" new file mode 100644 index 0000000000..287f3bb1bf --- /dev/null +++ "b/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/rokmanhaman.py" @@ -0,0 +1,36 @@ +""" +Reto #29: EL CARÁCTER INFILTRADO +FÁCIL | Publicación: 17/07/23 | Resolución: 24/07/23 +/* + * 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"] + */ +""" + +def text_compare(text1, text2): + + lista = [text2[i] for i,j in enumerate(text2) if text1[i]!=text2[i]] + + + return lista + + + + +#a = "Me llamo.Brais Moure" +a = "Me llamo mouredev" +#b = "Me llamo brais moure" +b = "Me llemo mouredov" + +diff = text_compare(a,b) + +print(diff) \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/BRivasTorres.js" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/BRivasTorres.js" new file mode 100644 index 0000000000..c2bf0ddc0d --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/BRivasTorres.js" @@ -0,0 +1,37 @@ +//*Se crea un array que contiene los números, letras minusculas y mayusculas, y simbolos. +const mixedArray = [ + ...Array(10).keys(), + ...Array(26) + .fill() + .map((_, i) => String.fromCharCode(97 + i)), + ...Array(26) + .fill() + .map((_, i) => String.fromCharCode(65 + i)), + ...["!", "@", "#", "$", "%", "^", "&", "*"], +]; + +const generatePassword = () => { + let res = ""; + + //*Se crean las variables para crear un valor aletorio, + //* lengthOfPassword === la longitud aleatoria de cada contraseña + //* arrLength === longitud del array previamente creado. + //*Por medio de un bucle for recoremos hasta que se llegue a longitud actual, en cada iteración j crea un numero aleatorio + //* >= 0 y <= arrLength(que seria 70), luego solamente se le asigna ese valor al Caracter actual. + + let lengthOfPassword = Math.floor(Math.random() * (16 - 8) + 8); + let arrLength = mixedArray.length; + let j = 0; + + for (let i = 0; i <= lengthOfPassword; i++) { + j = Math.floor(Math.random() * arrLength); + res += `${mixedArray[j]}`; + } + + return res; +}; + +console.log(generatePassword()); +console.log(generatePassword()); +console.log(generatePassword()); +console.log(generatePassword()); diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/daldev14.js" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/daldev14.js" new file mode 100644 index 0000000000..8c89785183 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/daldev14.js" @@ -0,0 +1,60 @@ +/* + * 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 generatePassword({ + hasUppercase, + hasNumbers, + hasSymbols, + length = 8, +} = {}) { + // Lowercase letters (a-z) + let characters = Array.from({ length: 26 }, (_, i) => + String.fromCodePoint(97 + i) + ); + + if (hasUppercase) { + // Uppercase letters (A-Z) + const uppercaseLetters = Array.from({ length: 26 }, (_, i) => + String.fromCodePoint(65 + i) + ); + + characters.push(...uppercaseLetters); + } + + if (hasNumbers) { + // Numbers (0-9) + const numbers = Array.from({ length: 10 }, (_, i) => + String.fromCodePoint(48 + i) + ); + + characters.push(...numbers); + } + + if (hasSymbols) { + // Symbols + const symbols = Array.from("!@#$%^&*()-_=+[]{}|;:'\",.<>?/"); + characters.push(...symbols); + } + + let password = ""; + + for (let i = 0; i < length; i++) { + password += characters[Math.floor(Math.random() * characters.length)]; + } + + return password; +} + +generatePassword({ + hasUppercase: true, + hasNumbers: true, + hasSymbols: true, + length: 10, +}); diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/marvnramos.js" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/marvnramos.js" new file mode 100644 index 0000000000..b7309ee8ff --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/marvnramos.js" @@ -0,0 +1,175 @@ +/* + * RETO #3: GENERADOR DE CONTRASEÑAS + * 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) + */ + + + +// const alphabet = ['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']; +// const numbers = [0,1,2,3,4,5,6,7,8,9]; +// const symbols = ['!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '-', '=', '[', ']', '{', '}', ';', ':', ',', '.', '<', '>', '/', '?', '|'] + +const parameters = { + alphabet: [ + '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' + ], + symbols: [ + '!', '@', '#', '$', '%', + '^', '&', '*', '(', ')', + '_', '+', '-', '=', '[', + ']', '{', '}', ';', ':', + ',', '.', '<', '>', '/', + '?', '|' + ], + numbers: [0,1,2,3,4,5,6,7,8,9] +} + +const getIndex = (num) => { + if(!num){ + return 'Parámetro requerido.'; + } + + const randomNumber = Math.floor(Math.random()*num); + + return randomNumber; +}; + +const getParameter = (obj) => { + if (!obj) { + return 'Parámetro requerido.'; + } + + const key = Object.keys(obj); + if(key === 0){ + return 'Objeto vacío.'; + } + + const randomKey = getIndex(key.length) + const randomObjectMember = obj[key[randomKey]]; + return randomObjectMember; + +}; + +const getPassword = (passwordLength, upperCase, withNumbers, withSymbols) =>{ + let password = ''; + + const regexWithUpperCase = /^(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=\[\]{};:,.<>\/?|]).*$/; + const regexWithLowerCase = /^(?=.*[a-z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=\[\]{};:,.<>\/?|]).*$/; + + + + if(upperCase && withNumbers && withSymbols){ + for(let i = 0; i < passwordLength; i++){ + const parameter = getParameter(parameters); + const index = getIndex(parameter.length); + + password += parameter[index]; + } + password = password.toUpperCase(); + + return regexWithUpperCase.test(password) ? password : getPassword(upperCase, withNumbers, withSymbols); + } + else if(!upperCase && !withNumbers && !withSymbols){ + for(let i = 0; i < passwordLength; i++){ + const parameter = parameters.alphabet; + const index = getIndex(parameter.length); + + password += parameter[index]; + } + return password; + } + else if(!upperCase && withNumbers && withSymbols){ + for(let i = 0; i < passwordLength; i++){ + const parameter = getParameter(parameters); + const index = getIndex(parameter.length); + + password += parameter[index]; + } + + return regexWithLowerCase.test(password) ? password : getPassword(upperCase, withNumbers, withSymbols); + } + else if(!upperCase && !withNumbers && withSymbols){ + for(let i = 0; i < passwordLength; i++){ + let parameter = ''; + let flag = true; + + while(flag){ + parameter = getParameter(parameters); + + if(parameter !== parameters.numbers){ + flag = false; + } + }; + + const index = getIndex(parameter.length); + + password += parameter[index]; + } + return password; + } + else if (upperCase && withNumbers && !withSymbols) { + for(let i = 0; i < passwordLength; i++){ + const parametersWithNoSymbols = { alphabet : [...parameters.alphabet], numbers: [...parameters.numbers]}; + + const parameter = getParameter(parametersWithNoSymbols); + const index = getIndex(parameter.length); + + password += parameter[index]; + + } + + return password; + } + + else if(upperCase && !withNumbers && !withSymbols){ + for(let i = 0; i < passwordLength; i++){ + const parameter = parameters.alphabet; + const index = getIndex(parameter.length); + + password += parameter[index]; + } + return password.toUpperCase(); + } +} + + +const passwordGenerator = (passwordLength, upperCase, withNumbers, withSymbols) =>{ + const password = getPassword(passwordLength, upperCase, withNumbers, withSymbols); + + const validPasswordLength = passwordLength >= 8 && passwordLength <= 16; + + if(!validPasswordLength){ + return 'La longitud de la contraseña debe estar entre 8 y 16'; + } + + return password; +}; + + +const newPassword1 = passwordGenerator(12, true, true, true); // capital letters, numbers and symbols +const newPassword2 = passwordGenerator(10, false, true, true); // lowercase letters, numbers and symbols +const newPassword3 = passwordGenerator(10, false, false, false); // lowercase letters only +const newPassword4 = passwordGenerator(10,false, false, true); // lowercase letters and symbols +const newPassword5 = passwordGenerator(10, true, true, false); // capital letters and numbers +const newPassword6 = passwordGenerator(10, true, false, false); // capital letters only + + +//---------------------- + +console.log(newPassword1); // primera condicion con upper +console.log(newPassword2); // segunda condicion con lower +console.log(newPassword3); // just lower cases +console.log(newPassword4); // no capital letters or numbers +console.log(newPassword5) // no symbols +console.log(newPassword6) // just upper cases \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/rodrigosambadesaa.js" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/rodrigosambadesaa.js" new file mode 100644 index 0000000000..64ee06896c --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/rodrigosambadesaa.js" @@ -0,0 +1,37 @@ +function generatePassword(length, includeUppercase, includeNumbers, includeSymbols) { + if (length < 8 || length > 16) { + throw new Error('Invalid password length ' + length); + } + + const lowercaseChars = 'abcdefghijklmnopqrstuvwxyz'; + const uppercaseChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; + const numberChars = '0123456789'; + const symbolChars = '!@#$%^&*()_+[]{}|;:,.<>?'; + + let validChars = lowercaseChars; + + if (includeUppercase) { + validChars += uppercaseChars; + } + + if (includeNumbers) { + validChars += numberChars; + } + + if (includeSymbols) { + validChars += symbolChars; + } + + let password = ''; + + for (let i = 0; i < length; i++) { + const randomIndex = Math.floor(Math.random() * validChars.length); + password += validChars[randomIndex]; + } + + return password; + } + + const newPassword = generatePassword(16, true, true, true); + console.log(newPassword); + \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/MarcosDigu.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/MarcosDigu.py" new file mode 100644 index 0000000000..c1c65abd58 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/MarcosDigu.py" @@ -0,0 +1,43 @@ +""" + * 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) +""" +import string +import random +import os + +os.system('cls') + +def generate_password(length, use_uppercase, use_numbers, use_symbols): + characters = "" + + if use_uppercase: + characters += string.ascii_uppercase + if use_numbers: + characters += string.digits + if use_symbols: + characters += "!@#$%^&*()_-+=<>?/[]{}|" + + if not any([use_uppercase, use_numbers, use_symbols]): + # If no character type is selected, default to lowercase letters + characters = string.ascii_lowercase + + password = ''.join(random.choice(characters) for _ in range(length)) + return password + +char = int(input("Number of characters (8-16): ")) +uplo = input("U: Include uppercase - L: Lowercase only: ") +num = input("Include numbers (y/n): ") +sym = input("Include symbols (y/n): ") + +# Validate input for the number of characters +char = max(8, min(char, 16)) + +password = generate_password(char, uplo == "U", num == "y", sym == "y") + +print(f"Your password is: {password}") diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/danielzx9.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/danielzx9.py" new file mode 100644 index 0000000000..d014ee77e6 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/danielzx9.py" @@ -0,0 +1,44 @@ + +'''``` +/* + * 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) + */ +``` +''' + +import string +import random + +def contra(longitudContra, mayus, numeros, simbol): + caracteres = string.ascii_lowercase + if mayus: + caracteres += string.ascii_uppercase + if numeros: + caracteres += string.digits + if simbol: + caracteres += string.punctuation + + contrasena = ''.join(random.choice(caracteres) for _ in range(longitudContra)) + return contrasena + +def main(): + longitudContra = int(input("Ingrese la longitud que desea para la contraseña (entre 8 y 16): ")) + if not (8 <= longitudContra <= 16): + print("Longitud no válida. Debe estar entre 8 y 16 caracteres.") + return + + mayus = input("Incluir letras mayúsculas (si/no): ").lower() == 'si' + numeros = input("Incluir números (si/no): ").lower() == 'si' + simbol = input("Incluir símbolos (si/no): ").lower() == 'si' + + contrasena = contra(longitudContra, mayus, numeros, simbol) + print(f"\nContraseña generada: {contrasena}") + +if __name__ == "__main__": + main() diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/patotal.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/patotal.py" new file mode 100644 index 0000000000..a941582fb6 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/patotal.py" @@ -0,0 +1,32 @@ +import random, string + +base = list(string.ascii_lowercase) + +while True: + longitud = int(input("Indique longitud de contraseña a generar entre 8 y 16 caracteres: ")) + if longitud < 8 or longitud > 16: + print ("Número fuera de rango, vuelva a intentarlo") + else: + break + +pregunta_mayusculas = input("¿Puede contener mayúsculas? y/n: ") +pregunta_nro = input("¿Puede contener números? y/n: ") +pregunta_especiales = input("¿Puede contener caracteres especiales? y/n: ") + +if pregunta_mayusculas == "y": + for i in string.ascii_uppercase: + base.append(i) + +if pregunta_nro == "y": + for i in string.digits: + base.append(i) + +if pregunta_especiales == "y": + for i in string.punctuation: + base.append(i) + +passw = "" +for i in range(longitud): + passw += random.choice(base) + +print (f"Su contraseña es: {passw}") \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/rokmanhaman.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/rokmanhaman.py" new file mode 100644 index 0000000000..74210c6898 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/rokmanhaman.py" @@ -0,0 +1,67 @@ +import random +import string + + + +class password(): + + possible_characters = [] + + + def __init__(self, long, upper_case=False, numeric=False, symbolyc=False): + self.long = long + self.final_lenght = 8 if long < 8 else 16 if long > 16 else long + self.upper_case = upper_case + self.numeric = numeric + self.symbolyc = symbolyc + + + def config(self): + + ### + if self.upper_case == 0: + l_lower_case = list(string.ascii_lowercase) + for l in l_lower_case: + self.possible_characters.append(l) + elif self.upper_case == 1: + l_letters = list(string.ascii_letters) + for l in l_letters: + self.possible_characters.append(l) + else: + print("error Elija 0 o 1") + ### + if self.numeric == 0: + pass + elif self.numeric == 1: + l_digits = list(string.digits) + for l in l_digits: + self.possible_characters.append(l) + ### + if self.symbolyc == 0: + pass + elif self.symbolyc ==1: + l_punctuation = list(string.punctuation) + for l in l_punctuation: + self.possible_characters.append(l) + + return ' los caracteres posibles son: ' +'\n'+ '{}'.format(self.possible_characters) #+ '{} {} {} {}'.format(self.long, self.upper_case, self.numeric, self.symbolyc) + + + def generattor(self): + pass_out = [] + for i in range(self.final_lenght): + + pass_out.append(random.choice(self.possible_characters)) + + return 'la contraseña es: {}'.format(''.join(pass_out)) + + + +pwd1 = password(20,True, True, True) + + +pwd1.config() + +print(pwd1.generattor()) + + diff --git a/Retos/Reto #30 - EL TECLADO T9 [Media]/python/rokmanhaman.py b/Retos/Reto #30 - EL TECLADO T9 [Media]/python/rokmanhaman.py new file mode 100644 index 0000000000..15524febba --- /dev/null +++ b/Retos/Reto #30 - EL TECLADO T9 [Media]/python/rokmanhaman.py @@ -0,0 +1,62 @@ +""" +Reto #30: EL TECLADO T9 +MEDIA | Publicación: 24/07/23 | Resolución: 31/07/23 +/* + * Los primeros dispositivos móviles tenían un teclado llamado T9 + * con el que se podía escribir texto utilizando únicamente su + * teclado numérico (del 0 al 9). + * + * Crea una función que transforme las pulsaciones del T9 a su + * representación con letras. + * - Debes buscar cuál era su correspondencia original. + * - Cada bloque de pulsaciones va separado por un guión. + * - Si un bloque tiene más de un número, debe ser siempre el mismo. + * - Ejemplo: + * Entrada: 6-666-88-777-33-3-33-888 + * Salida: MOUREDEV + */ +""" + +def t9_code(number): + dict_code = { + "2" : "A", + "22" : "B", + "222" : "C", + "3" : "D", + "33" : "E", + "333" : "F", + "4" : "G", + "44" : "H", + "444" : "I", + "5" : "J", + "55" : "K", + "555" : "L", + "6" : "M", + "66" : "N", + "666" : "O", + "7" : "P", + "77" : "Q", + "777" : "R", + "7777" : "S", + "8" : "T", + "88" : "U", + "888" : "V", + "9" : "W", + "99" :"X", + "999" : "Y", + "9999" : "Z" + } + + out = "" + nlist= number.split("-") + for n in nlist: + out += dict_code[n] + + + return out + + + +num = "2-6-666-88-777-33-3-33-888" +output = t9_code(num) +print(output) \ No newline at end of file diff --git "a/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/python/rokmanhaman.py" "b/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/python/rokmanhaman.py" new file mode 100644 index 0000000000..1573bda5df --- /dev/null +++ "b/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/python/rokmanhaman.py" @@ -0,0 +1,41 @@ +""" +Reto #31: EL ÁBACO +FÁCIL | Publicación: 31/07/23 | Resolución: 07/08/23 +/* + * 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 + */ +""" + + + +def abaco(array): + + num = "" + for n in array: + num += str(len(n.split("-")[0])) + + return num + + +n = ["O---0OOOOOOO", "OOO---OOOOOO", "---OOOOOOOOO", "OO---OOOOOOO","OOOOOOO---OO","OOOOOOOOO---","---OOOOOOOOO"] + +numero = abaco(n) + +print(numero) diff --git a/Retos/Reto #32 - LA COLUMNA DE EXCEL [Media]/python/rokmanhaman.py b/Retos/Reto #32 - LA COLUMNA DE EXCEL [Media]/python/rokmanhaman.py new file mode 100644 index 0000000000..8931d91d0d --- /dev/null +++ b/Retos/Reto #32 - LA COLUMNA DE EXCEL [Media]/python/rokmanhaman.py @@ -0,0 +1,26 @@ +""" +Reto #32: LA COLUMNA DE EXCEL +MEDIA | Publicación: 07/08/23 | Resolución: 14/08/23 +/* + * Crea una función que calcule el número de la columna de una hoja de Excel + * teniendo en cuenta su nombre. + * - Las columnas se designan por letras de la "A" a la "Z" de forma infinita. + * - Ejemplos: A = 1, Z = 26, AA = 27, CA = 79. + */ +""" + +def ExcelColumn(column): + letters = ['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'] + for i,j in enumerate(letters[:26]): + for x, y in enumerate(letters[:26]): + letters.append(j + y) + + return letters.index(column) +1 + + + +col = 'CA' +out = ExcelColumn(col) +print(f"\n\nEl número de la columna {col} es el: {out}\n\n") + diff --git a/Retos/Reto #36 - PERMUTACIONES [Media]/python/rokmanhaman.py b/Retos/Reto #36 - PERMUTACIONES [Media]/python/rokmanhaman.py new file mode 100644 index 0000000000..f59c201223 --- /dev/null +++ b/Retos/Reto #36 - PERMUTACIONES [Media]/python/rokmanhaman.py @@ -0,0 +1,25 @@ +""" +Reto #36: PERMUTACIONES +MEDIA | Publicación: 04/09/23 | Resolución: 18/09/23 +/* + * Crea un programa que sea capaz de generar e imprimir todas las + * permutaciones disponibles formadas por las letras de una palabra. + * - Las palabras generadas no tienen por qué existir. + * - Deben usarse todas las letras en cada permutación. + * - Ejemplo: sol, slo, ols, osl, los, lso + */ + """ +from itertools import permutations + +def generar_permutaciones(word): + + todas_permutaciones = permutations(word) + + + for permutacion in todas_permutaciones: + print(''.join(permutacion)) + + +w = 'hola' +generar_permutaciones(w) + diff --git a/Retos/Reto #37 - COLORES HEX Y RGB [Media]/python/rokmanhaman.py b/Retos/Reto #37 - COLORES HEX Y RGB [Media]/python/rokmanhaman.py new file mode 100644 index 0000000000..0d2599c36b --- /dev/null +++ b/Retos/Reto #37 - COLORES HEX Y RGB [Media]/python/rokmanhaman.py @@ -0,0 +1,71 @@ +""" +Reto #37: COLORES HEX Y RGB +MEDIA | Publicación: 18/09/23 | Resolución: 25/09/23 +/* + * Crea las funciones capaces de transformar colores HEX + * a RGB y viceversa. + * Ejemplos: + * RGB a HEX: r: 0, g: 0, b: 0 -> #000000 + * HEX a RGB: hex: #000000 -> (r: 0, g: 0, b: 0) + */ +""" + +def dec_to_hex(number): + cociente_list = [number // 16] + resto_list = [number % 16] + i = 0 + while cociente_list[i] >= 16: + cociente_list.append(cociente_list[i] // 16) + resto_list.append(cociente_list[i] % 16) + i = i + 1 + + last_cociente = cociente_list[i] + invert_resto = resto_list[::-1] + hex_values = "0123456789ABCDEF" + last_cociente_hex = hex_values[last_cociente] + invert_resto_hex = [hex_values[y] for y in invert_resto] + + resultado_text = str(last_cociente_hex)+ "".join(map(str, invert_resto_hex)) + + return resultado_text + +def hex_to_dec(number): + acc = 0 + hex_values = "0123456789ABCDEF" + + for i, j in enumerate(number[::-1]): + + acc += hex_values.index(j) * 16**i + + return acc + + +def hex_to_rgb(hex): + + r = hex_to_dec(hex[0:2]) + g = hex_to_dec(hex[2:4]) + b = hex_to_dec(hex[4:6]) + + return print(f"\n\nEl color HEX {hex} corresponde al color RGB: ({r},{g},{b})\n\n") + + + +def rgb_to_hex(r,g,b): + + if r >= 0 and r <=255 and g >= 0 and g<=255 and b >= 0 and b <=255: + rhex = dec_to_hex(r) + ghex = dec_to_hex(g) + bhex = dec_to_hex(b) + else: + print( "ingrese valores entre 0 y 255") + + return print(f"\n\nEl color RGB {r}-{g}-{b} corresponde al color hex: #{rhex}{ghex}{bhex}\n\n") + + +rgb_to_hex(255,210,194) + + +hex_to_rgb('FFD2C2') + + + diff --git a/Retos/Reto #38 - LAS SUMAS [Media]/javascript/npminit-dev.js b/Retos/Reto #38 - LAS SUMAS [Media]/javascript/npminit-dev.js index 8ab574c347..2dcd62428e 100644 --- a/Retos/Reto #38 - LAS SUMAS [Media]/javascript/npminit-dev.js +++ b/Retos/Reto #38 - LAS SUMAS [Media]/javascript/npminit-dev.js @@ -15,15 +15,14 @@ function getSumsLists(list, target) { let sList = list.filter(num => num <= target).sort() let result = [] - function backTracking(sub, start) { - let sum = sub?.reduce((acc, curr) => acc += curr, 0) || 0 + function backTracking(sub, start, sum) { if(sum === target) result.push(sub) for(let i = start; i < sList.length; i++) - if(sum + list[i] <= target) backTracking([...sub, list[i]], i + 1) + if(sum + list[i] <= target) backTracking([...sub, list[i]], i + 1, sum + list[i]) } for(let i = 0; i < sList.length - 1; i++) - backTracking([list[i]], i + 1) + backTracking([list[i]], i + 1, list[i]) return result } @@ -35,6 +34,6 @@ console.log(getSumsLists([3, 2, 1, 6, 8, 4, 3, 10], 12)) console.log(getSumsLists([3, 6, 9, 12, 15], 30)) /* result = [[ 3, 6, 9, 12 ], [ 3, 12, 15 ], [ 6, 9, 15 ]] */ console.log(getSumsLists([15, 10, 5, 2, 8, 10], 50)) -/* result = [[ 3, 6, 9, 12 ], [ 3, 12, 15 ], [ 6, 9, 15 ]] */ +/* result = [[15, 10, 5, 2, 8, 10]] */ console.log(getSumsLists([1, 2, 3, 2, 1], 3)) -/* result = [[ 3, 6, 9, 12 ], [ 3, 12, 15 ], [ 6, 9, 15 ]] */ +/* result = [[ 1, 2 ], [ 1, 2 ], [ 2, 1 ], [ 3 ], [ 2, 1 ]] */ diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/marvnramos.js b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/marvnramos.js new file mode 100644 index 0000000000..782e808743 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/marvnramos.js @@ -0,0 +1,95 @@ +/* + si un numero es par su reciduo de división modular es 0, + sino es impar. + + para determinar un número fibonacci se puede usar la formula + test de la raiz cuadrada de 5° o el criterio de la suma + de cuadrados. + + Un número n es número fibonacci si y solo si uno de los + siguientes es verdadero: + 5n^2 + 4 ó 5n^2 - 4 +*/ + + + +/** + * Comprueba si un número es par. + * @param {number} num - El número a evaluar. + * @returns {boolean} - Devuelve true si el número es par, false si es impar. + */ +function isPar(num){ + return num % 2 === 0; +} +/** + * Comprueba si un número es primo. + * @param {number} num - El número a evaluar. + * @returns {boolean} - Devuelve true si el número es primo, false si no lo es. + */ +function isPrime(num){ + let sqrt = Math.floor(Math.sqrt(num)); + + if(num <= 1){ + return false; // uno no es ni primo ni par + } + + for(let i = 2; i <= sqrt; i++){ + if(num % i === 0){ + return false; + } + } + + return true; +} +/** + * Comprueba si un numero pertenece a la secuencia de Fibonacci + * @param {number} num - El número a evaluar + * @returns {boolean} - Devuelve true si el numero cumple una de las dos condiciones, sino devuelve false + */ +function isFibonacci(num){ + // Calcula dos posibles resultados de la fórmula que indica la pertenencia a la secuencia de Fibonacci. + const firstResult = 5 * num**2 + 4; + const secondResult = 5 * num**2 - 4; + + // Calcula las raíces cuadradas de los resultados y verifica si son números enteros. + const firstSqrt = Math.sqrt(firstResult); + const secondSqrt = Math.sqrt(secondResult); + + // Devuelve true si al menos uno de los resultados es un número entero. + return Number.isInteger(firstSqrt) || Number.isInteger(secondSqrt); +} + + +/** + * Analiza un número e imprime mensajes que indican si es primo, pertenece a la secuencia de Fibonacci y si es par o impar. + * @param {number} num - El número a analizar. + */ +const numberIs = (num) =>{ + let result = ""; + + if(isPrime(num)){ + result += `${num} es primo, `; + }else{ + result += `${num} no es primo, `; + } + + if(isFibonacci(num)){ + result += "fibonacci, "; + } + else{ + result += "no es fibonacci, " + } + + if(isPar(num)){ + result += "y es par"; + } + else{ + result += "y es impar"; + } + + console.log(result); + +} + +const num = 2; +numberIs(num); \ No newline at end of file diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/meidencore.js b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/meidencore.js new file mode 100644 index 0000000000..a307d912e1 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/meidencore.js @@ -0,0 +1,52 @@ +/* + * 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" + */ + +const isEven = (number) => { + if (number % 2 === 0) { + return "Es par" + } else { + return "Es impar" + } +} + +const isFibonacci = (number) => { + let previusNumber = 0; + let nextNumber = 1; + while (previusNumber < number) { + const temp = previusNumber; + previusNumber = nextNumber; + nextNumber = temp + nextNumber; + } + if (previusNumber === number) { + return "es fibonacci" + } else { + return "no es fibonacci" + } +} + +const isPrime = (number) => { + // los numeros menores que 1 no son primos + if (number <= 1) { + return "no es primo" + } + // comprueba que es divisible por un numero desde 2 hasta la raiz cuadrada del numero + for (let i = 2; i <= Math.sqrt(number); i++) { + if (number % i === 0) { + return 'no es primo' + } + } + return "es primo" +} + +// genera valores enteros aleatorios entre 0 y 1000 +const number = Math.floor(Math.random() * 1000) + +console.log(`El numero ==> ${number} ${isEven(number)}, ${isFibonacci(number)} y ${isPrime(number)}.`) + + + + diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/MarcosDigu.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/MarcosDigu.py new file mode 100644 index 0000000000..24ae697340 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/MarcosDigu.py @@ -0,0 +1,31 @@ +def es_primo(num): + """Verifica si un número es primo.""" + if num < 2: + return False + for i in range(2, int(num**0.5) + 1): + if num % i == 0: + return False + return True + +def es_numero_fibonacci(num): + """Verifica si un número es un número de Fibonacci.""" + def es_cuadrado_perfecto(n): + """Verifica si un número es un cuadrado perfecto.""" + raiz = int(n**0.5) + return n == raiz**2 + + return es_cuadrado_perfecto(5 * num**2 + 4) or es_cuadrado_perfecto(5 * num**2 - 4) + +def es_par(num): + """Verifica si un número es par.""" + return num % 2 == 0 + +def checker(num): + """Imprime información sobre si un número es primo, de Fibonacci y par.""" + primo = "primo" if es_primo(num) else "compuesto" + fibo = "fibonacci" if es_numero_fibonacci(num) else "no fibonacci" + par = "par" if es_par(num) else "impar" + + print(f"El número {num} es {primo}, {fibo} y {par}.") + +checker(10) diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/danielzx9.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/danielzx9.py new file mode 100644 index 0000000000..d99e423d66 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/danielzx9.py @@ -0,0 +1,46 @@ +''' * 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 par(num): + return num % 2 == 0 + +def primo(num): + if num < 2: + return False + for i in range(2, int(num**0.5) + 1): + if num % i == 0: + return False + return True + +def fibo(num): + a, b = 0, 1 + while a < num: + a, b = b, a + b + return a == num + +def veri(): + try: + num = int(input("Ingrese un número: ")) + if primo(num) and fibo(num) and par(num): + print(f"{num} es primo, fibonacci y es par") + elif primo(num) and fibo(num) and not par(num): + print(f"{num} es primo, fibonacci y es impar") + elif primo(num) and not fibo(num) and par(num): + print(f"{num} es primo, no es fibonacci y es par") + elif primo(num) and not fibo(num) and not par(num): + print(f"{num} es primo, no es fibonacci y es impar") + elif not primo(num) and fibo(num) and par(num): + print(f"{num} no es primo, es fibonacci y es par") + elif not primo(num) and fibo(num) and not par(num): + print(f"{num} no es primo, es fibonacci y es impar") + elif not primo(num) and not fibo(num) and par(num): + print(f"{num} no es primo, no es fibonacci y es par") + elif not primo(num) and not fibo(num) and not par(num): + print(f"{num} no es primo, no es fibonacci y es impar") + except ValueError: + print("Por favor, ingrese un número válido.") + + +veri() diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/patoal.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/patoal.py new file mode 100644 index 0000000000..a6df45ec9f --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/patoal.py @@ -0,0 +1,41 @@ + +def primo(n1): + contador = 0 + for i in range(1, n1 + 1): + if n1 % i == 0: + contador += 1 + if contador == 2: + return "es primo" + else: + return "no es primo" + +def fibonacci(n3): + fibo = [0] + n1 = 0 + n2 = 1 + for i in range(n3): + agrega = n1 + n2 + fibo.append(agrega) + n1 = n2 + n2 = agrega + if n2 > n3: + break + if n3 in fibo: + return "es fibonacci" + else: + return "no es fibonacci" + +def impar(n4): + if n4 % 2 == 0: + return "es par" + else: + return "no es par" + +while True: + try: + ingreso = int(input("Ingrese el Número: ")) + break + except ValueError: + print("\n Sólo se admite un valor numérico, vuelva a intentarlo.\n") + +print (f"{ingreso} {primo(ingreso)}, {fibonacci(ingreso)} y {impar(ingreso)}") \ No newline at end of file diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/rokmanhamman.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/rokmanhamman.py new file mode 100644 index 0000000000..3cf7724b85 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/rokmanhamman.py @@ -0,0 +1,69 @@ +### RETO 4 + +"""/* + * 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" + */""" + +class Number(): + def __init__(self, num): + self.value = num + + def check_even(self): #chequeo si es par + if self.value % 2 == 0: + paridad = "es par" + else: + paridad = "es impar" + return paridad + + def check_fibonacci(self): #chequeo si pertenece a un numero de fibonacci + fibo_list = [0, 1] + while self.value > fibo_list[-1]: + fibo_list.append(fibo_list[-2] + fibo_list[-1]) + + if self.value in fibo_list: + fibo = "es fibonacci" + else: + fibo = "no es fibonacci" + + return fibo + + def check_primo(self): + if self.value < 2: + primitud = "indefinido" + else: + list_resto=[] + for w in range(1,self.value+1): + resto = self.value % w + list_resto.append(resto) + + if list_resto.count(0) == 2: + primitud = "es primo" + else: + primitud = "no es primo" + + return primitud + + + +n= Number(17) + +print(f"{n.value} {n.check_primo()}, {n.check_fibonacci()} y {n.check_even()}") + + + + +"""for x in range(50): + print("------------------------------------------------") + n= Number(x) + print(f"{n.value} {n.check_primo()}, {n.check_fibonacci()} y {n.check_even()}") +""" + + + + + + \ No newline at end of file diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/javascript/Cesarpinagon.js" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/javascript/Cesarpinagon.js" new file mode 100644 index 0000000000..a97780e628 --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/javascript/Cesarpinagon.js" @@ -0,0 +1,5 @@ +var numero = 5; //cambiar el numero para ver la tabla de multiplicar de otro numero + +for (var i = 1; i <= 10; i++) { + console.log(numero + " x " + i + " = " + (numero * i)) +} \ No newline at end of file diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/javascript/giovanyosorio.js" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/javascript/giovanyosorio.js" new file mode 100644 index 0000000000..e836440dd1 --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/javascript/giovanyosorio.js" @@ -0,0 +1,20 @@ +/* + * 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 + * ... + */ + +function tablaDeMultiplicar(num){ + for (let index = 1; index <= 10; index++) { + + + const element = index; + console.log(element+" * "+ num + " = " + num*element) + + } +} +tablaDeMultiplicar(12) \ No newline at end of file diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/manuelmslv.py" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/manuelmslv.py" new file mode 100644 index 0000000000..7ba9d4553b --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/manuelmslv.py" @@ -0,0 +1,9 @@ +def mult(number:int): + for n in range (1,11): + result = number * n + print (f"{number} x {n} = {result}") + + +response = input('Ingrese numero: ') +response = int(response) +mult (response) diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/marcoatrs.py" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/marcoatrs.py" new file mode 100644 index 0000000000..7c8026afbb --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/marcoatrs.py" @@ -0,0 +1,5 @@ +def tabla_multiplicar(numero): + for i in range(1, 11): + print(f"{numero} x {i} = {numero * i}") + +tabla_multiplicar(12) diff --git "a/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/javierfiestasbotella.py" "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/javierfiestasbotella.py" new file mode 100644 index 0000000000..52dd6605dd --- /dev/null +++ "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/javierfiestasbotella.py" @@ -0,0 +1,132 @@ +import tkinter as tk +import random +from tkinter import simpledialog, messagebox + +'''entry = "🚪" +exit = "🍭" +room = "⬜" +ghost = "👻" +player = "🐍"''' + + +# Define las casillas +CASILLA_PUERTA = '🚪' +CASILLA_HABITACION_OCULTA = '⬜' +CASILLA_HABITACION_DULCES = '🍭' +CASILLA_ILUMINADA = '💡' + +# Enigmas y respuestas +ENIGMAS_RESPUESTAS = { + "¿Qué tiene ojos pero no puede ver?": "plátano", + "¿Qué tiene llaves pero no abre puertas?": "piano", + "¿Qué es lo que tiene dientes pero no puede morder?": "peine", + # Agrega más enigmas y respuestas aquí +} + +# Preguntas de los fantasmas y respuestas +PREGUNTAS_FANTASMAS_RESPUESTAS = { + "Pregunta de fantasma 1": "R1", + "Pregunta de fantasma 2": "R2", + # Agrega más preguntas de fantasmas y respuestas aquí +} + +class JuegoHalloween: + def __init__(self, ventana): + self.ventana = ventana + self.ventana.title("Juego de Halloween") + self.jugador = simpledialog.askstring("Bienvenido", "Ingresa tu nombre:") + self.ruta = [(0, 0)] + self.intentos_restantes = 4 + self.instrucciones = "Instrucciones:\n\n1. Debes avanzar en la mansión 4x4 hasta encontrar la habitación de los dulces.\n\n2. Cada vez que avanzas hacia una casilla oculta, debes responder a un enigma o preguntas de fantasmas.\n\n3. Tienes 4 intentos para avanzar en la dirección que elijas (arriba, abajo, izquierda o derecha).\n\n4. Si respondes correctamente a un enigma o pregunta de fantasma, la casilla se iluminará.\n\n5. Si encuentras la habitación de los dulces, ¡has ganado, {}! ¡Diviértete!".format(self.jugador) + self.crear_mansion() + self.crear_interfaz() + self.mostrar_instrucciones() + + def crear_mansion(self): + # Crea la mansión como una matriz 4x4 con casillas ocultas + self.mansion = [[CASILLA_HABITACION_OCULTA] * 4 for _ in range(4)] + self.mansion[0][0] = CASILLA_PUERTA + + # Coloca la casilla de los dulces de manera aleatoria + dulces_fila = random.randint(0, 3) + dulces_columna = random.randint(0, 3) + self.mansion[dulces_fila][dulces_columna] = CASILLA_HABITACION_DULCES + + def crear_interfaz(self): + # Crea la interfaz gráfica con botones para cada habitación + for fila, habitaciones_fila in enumerate(self.mansion): + for columna, tipo_habitacion in enumerate(habitaciones_fila): + boton = tk.Button(self.ventana, text=" ", font=("Arial", 16), command=lambda row=fila, col=columna: self.hacer_movimiento(row, col)) + boton.grid(row=fila, column=columna) + + def mostrar_instrucciones(self): + respuesta_instrucciones = simpledialog.askstring("Instrucciones", "¿Quieres ver las instrucciones? (Sí/No)") + if respuesta_instrucciones and respuesta_instrucciones.lower() == "si": + messagebox.showinfo("Instrucciones", self.instrucciones) + else: + messagebox.showinfo("¡Comencemos!", "¡Que comience el juego!") + + def hacer_movimiento(self, fila, columna): + if self.intentos_restantes == 0: + return + + if fila < self.ruta[-1][0]: + direccion = "arriba" + elif fila > self.ruta[-1][0]: + direccion = "abajo" + elif columna < self.ruta[-1][1]: + direccion = "izquierda" + elif columna > self.ruta[-1][1]: + direccion = "derecha" + else: + return + + self.intentos_restantes -= 1 + self.ruta.append((fila, columna)) + self.actualizar_interfaz() + + if direccion: + if self.mansion[fila][columna] == CASILLA_HABITACION_DULCES: + messagebox.showinfo("¡Felicidades!", "¡Has encontrado la habitación de los dulces, {}! ¡Has ganado!".format(self.jugador)) + self.ventana.quit() + elif self.mansion[fila][columna] == CASILLA_HABITACION_OCULTA: + if random.random() < 0.1: + # Aparece un fantasma + pregunta_fantasma = random.choice(list(PREGUNTAS_FANTASMAS_RESPUESTAS.keys())) + respuesta_correcta_fantasma = PREGUNTAS_FANTASMAS_RESPUESTAS[pregunta_fantasma] + respuesta_usuario = simpledialog.askstring("Fantasma", pregunta_fantasma) + if respuesta_usuario and respuesta_usuario.lower() == respuesta_correcta_fantasma.lower(): + self.mansion[fila][columna] = CASILLA_ILUMINADA + self.actualizar_interfaz() + messagebox.showinfo("¡Escapaste del fantasma!", "Respuesta correcta. Puedes continuar.") + else: + messagebox.showerror("¡Fantasma te ha atrapado!", "Respuesta incorrecta. El fantasma te atrapó.") + self.ventana.quit() + else: + # Pregunta de enigma + pregunta_enigma = random.choice(list(ENIGMAS_RESPUESTAS.keys())) + respuesta_correcta_enigma = ENIGMAS_RESPUESTAS[pregunta_enigma] + respuesta_usuario = simpledialog.askstring("Enigma", pregunta_enigma) + if respuesta_usuario and respuesta_usuario.lower() == respuesta_correcta_enigma.lower(): + self.mansion[fila][columna] = CASILLA_ILUMINADA + self.actualizar_interfaz() + else: + messagebox.showerror("Respuesta Incorrecta", "La respuesta es incorrecta. Inténtalo de nuevo en otra habitación.") + + self.intentos_restantes = 4 + + def actualizar_interfaz(self): + for fila, habitaciones_fila in enumerate(self.mansion): + for columna, tipo_habitacion in enumerate(habitaciones_fila): + if tipo_habitacion == CASILLA_ILUMINADA: + self.ventana.grid_slaves(row=fila, column=columna)[0].config(text=tipo_habitacion) + elif self.ruta[-1] == (fila, columna): + self.ventana.grid_slaves(row=fila, column=columna)[0].config(text="👣") + else: + self.ventana.grid_slaves(row=fila, column=columna)[0].config(text=" ") + +if __name__ == "__main__": + ventana = tk.Tk() + juego = JuegoHalloween(ventana) + ventana.mainloop() + diff --git "a/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/marcoatrs.py" "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/marcoatrs.py" new file mode 100644 index 0000000000..412dca6645 --- /dev/null +++ "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/marcoatrs.py" @@ -0,0 +1,94 @@ +import random + + +def generate_pos(a: int, b: int) -> tuple[int, int]: + return (random.randint(a, b), random.randint(a, b)) + +def generate_house() -> list[list[str]]: + house = [["⬜️" for _ in range(4)] for _ in range(4)] + house[0][0] = "🚪" + occup_roms = [(0, 0)] + exit_pos = (0, 0) + while exit_pos in occup_roms: + exit_pos = generate_pos(1, 3) + occup_roms.append(exit_pos) + house[exit_pos[0]][exit_pos[1]] = "🍭" + return house + + +def draw_house(house: list): + for row in house: + print(f'{"".join(row)}') + + +def get_valid_pos(pos: list[int, int]) -> list[str]: + valid_pos = [] + if pos[0] > 0: + valid_pos.append("norte") + if pos[0] < 3: + valid_pos.append("sur") + if pos[1] < 3: + valid_pos.append("este") + if pos[1] > 0: + valid_pos.append("oeste") + return valid_pos + + +def play_game(): + house = generate_house() + print("Sal de la mansión pero cuidado con las fantasmas") + pos = [0, 0] + win = False + draw_house(house) + while not win: + print(f"Estas en {pos}\n") + valid_pos = get_valid_pos(pos) + move = input(f"¿A donde te quieres mover? ({'/'.join(valid_pos)}) ").lower() + if move not in valid_pos: + continue + if move == "norte": + pos[0] = max(0, pos[0] - 1) + elif move == "sur": + pos[0] = min(3, pos[0] + 1) + elif move == "este": + pos[1] = min(3, pos[1] + 1) + else: + pos[1] = max(0, pos[1] - 1) + if house[pos[0]][pos[1]] == "🍭": + print("Encontraste los dulces 🍭🍭🍭, ganaste :)") + win = True + continue + questions = 1 + if random.random() <= 0.1: + print("Encontraste un fantasma, contesta 2 preguntas para pasar 👻") + house[pos[0]][pos[1]] = "👻" + draw_house(house) + questions += 1 + while questions > 0: + question = generate_question() + answer = input(f"{question[0]}: ").lower() + if answer == question[1]: + print("Correcto") + questions -= 1 + else: + print("Fallaste, intenta de nuevo 👻") + + +def generate_question() -> str: + questions = [ + ("¿Cuantas patas tiene una araña?", "8"), + ("¿Que lenguage de programacion tiene nombre de serpiente?", "python"), + ("¿Cuantos lados tiene un rombo", "4"), + ("¿Cual es el planeta rojo", "marte"), + ("¿Como esta compuesta es agua?", "h2o"), + ("¿Cual es el planeta mas cercano al Sol?", "mercurio"), + ("¿En qué disciplina deportiva juega Leo Messi?", "futbol"), + ("¿En qué país vivieron los samuráis?", "japon"), + ("El sol es una estrella. ¿Verdadero o falso?", "verdadero"), + ("¿Cuantas vocales tiene el abcedario?", "5") + ] + return random.choice(questions) + + +if __name__ == "__main__": + play_game() diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/PushoDev.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/PushoDev.py" new file mode 100644 index 0000000000..d4ba90cccd --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/PushoDev.py" @@ -0,0 +1,123 @@ +# Reto No.42 - Punto de Encuentro +# Dificultad: Difícil | Publicación: 23/10/23 | Corrección: 30/10/23 +#----------------------------------------------------------------- +# ENUNCIADO +# Crea una función que calcule el punto de encuentro de dos objetos en movimiento +# en dos dimensiones. +# - Cada objeto está compuesto por una coordenada xy y una velocidad de desplazamiento +# (vector de desplazamiento) por unidad de tiempo (también en formato xy). +# - La función recibirá las coordenadas de inicio de ambos objetos y sus velocidades. +# - La función calculará y mostrará el punto en el que se encuentran y el tiempo que tardarn en lograrlo. +# - La función debe tener en cuenta que los objetos pueden no llegar a encontrarse. +# ... +#----------------------------------------------------------------- + +from typing import NamedTuple, Protocol, TypeAlias +import math + +print ("Pushodev") +print ("https://github.com/PushoDev") + +Number: TypeAlias = float | int + + +class Coordinates(NamedTuple): + x: Number + y: Number + + +class Velocity(Coordinates): + pass + + +class Object(NamedTuple): + start_point: Coordinates + velocity: Velocity + + +class Objects(NamedTuple): + object1: Object + object2: Object + + +def calculate_diff_coordinates( + obj1_coords: Coordinates, obj2_coords: Coordinates +) -> Coordinates: + diff_x = obj2_coords.x - obj1_coords.x + diff_y = obj2_coords.y - obj1_coords.y + + return Coordinates(x=diff_x, y=diff_y) + + +def calculate_diff_velocity(obj1_vel: Velocity, obj2_vel: Velocity) -> Velocity: + diff_vel_x = obj2_vel.x - obj1_vel.x + diff_vel_y = obj2_vel.y - obj1_vel.y + + return Velocity(x=diff_vel_x, y=diff_vel_y) + + +def calculate_time_to_intersection( + diff_coordinates: Coordinates, diff_velocity: Velocity +) -> float: + time_to_intersection = math.sqrt( + diff_coordinates.x**2 + diff_coordinates.y**2 + ) / math.sqrt(diff_velocity.x**2 + diff_velocity.y**2) + + return time_to_intersection + + +def calculate_intersection_point( + object1: Object, time_to_intersection: float +) -> Coordinates: + intersection_x = object1.start_point.x + object1.velocity.x * time_to_intersection + intersection_y = object1.start_point.y + object1.velocity.y * time_to_intersection + + return Coordinates(x=intersection_x, y=intersection_y) + + +def is_same_direction(diff_velocity: Velocity) -> bool: + return diff_velocity.x == 0 and diff_velocity.y == 0 + + +def calculate_intersection_point_in_motion(objects: Objects) -> None: + diff_coordinates: Coordinates = calculate_diff_coordinates( + objects.object1.start_point, objects.object2.start_point + ) + diff_velocity: Velocity = calculate_diff_velocity( + objects.object1.velocity, objects.object2.velocity + ) + + if is_same_direction(diff_velocity): + print("Los objetos o puntos de encuentro son paralelos y nunca se encuentran.") + return + + time_to_intersection = calculate_time_to_intersection( + diff_coordinates, diff_velocity + ) + intersection_point = calculate_intersection_point( + objects.object1, time_to_intersection + ) + intersection_x = intersection_point.x + intersection_y = intersection_point.y + + print(f"El punto de encuentro es ({intersection_x}, {intersection_y})") + print(f"El tiempo que les tomará encontrarse es {time_to_intersection}") + + +class MotionCalculatorFn(Protocol): + def __call__(self, objects: Objects) -> None: + ... + + +def execute(motion_calculator: MotionCalculatorFn, objects: Objects) -> None: + motion_calculator(objects=objects) + + +if __name__ == "__main__": + object1 = Object(start_point=Coordinates(x=2, y=2), velocity=Velocity(x=2, y=2)) + object2 = Object(start_point=Coordinates(x=2, y=2), velocity=Velocity(x=2, y=2)) + objects = Objects(object1=object1, object2=object2) + + execute(motion_calculator=calculate_intersection_point_in_motion, objects=objects) + +print ("Los puntos nunca se encuentran ... :(") \ No newline at end of file diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/java/asjordi.java" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/java/asjordi.java" new file mode 100644 index 0000000000..5197fcb3c5 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/java/asjordi.java" @@ -0,0 +1,45 @@ +package facil.reto43; + +public class WeatherSimulator { + + public static void main(String[] args) { + simulate(7, 25, 0.2); + } + + public static void simulate(int days, double initialTemp, double initialRainProbability){ + double temperature = initialTemp; + double chanceOfRain = initialRainProbability; + double tempMax = temperature; + double tempMin = temperature; + int rainDays = 0; + + for (int i = 1; i <= days ; i++) { + // simulate change of temperature + if (Math.random() < 0.1){ + temperature += Math.random() < 0.5 ? 2 : -2; + } + + // update rain probability + if (temperature > 25) chanceOfRain += 0.2; + else if (temperature < 5) chanceOfRain -= 0.2; + + // set limite to rain probability + chanceOfRain = Math.min(1, Math.max(0, chanceOfRain)); + + // simulate rain + if (Math.random() < chanceOfRain){ + temperature -= 1; + rainDays++; + } + + // update math and min temperature + tempMax = Math.max(tempMax, temperature); + tempMin = Math.min(tempMin, temperature); + } + + String data = String.format("Max temperature %s °C%nMin temperature %s °C%nRaining days %s", tempMax, tempMin, rainDays); + + System.out.println(data); + } + +} diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/javascript/RodriJOk.js" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/javascript/RodriJOk.js" new file mode 100644 index 0000000000..c7ae0bb2c1 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/javascript/RodriJOk.js" @@ -0,0 +1,57 @@ +/* + * Crea una función que simule las condiciones climáticas (temperatura y probabilidad de lluvia) + * de un lugar ficticio al pasar un número concreto de días según estas reglas: + * - La temperatura inicial y el % de probabilidad de lluvia lo define el usuario. + * - Cada día que pasa: + * - 10% de posibilidades de que la temperatura aumente o disminuya 2 grados. + * - Si la temperatura supera los 25 grados, la probabilidad de lluvia al día siguiente aumenta en un 20%. + * - Si la temperatura baja de 5 grados, la probabilidad de lluvia al día siguiente disminuya en un 20%. + * - Si llueve (100%), la temperatura del día siguiente disminuye en 1 grado. + * - La función recibe el número de días de la predicción y muestra la temperatura y si llueve durante todos esos días. + * - También mostrará la temperatura máxima y mínima de ese periodo y cuántos días va a llover. + */ + +function weather_simulator(dias, temperatura_inicial, probabilidad_lluvia){ + if(dias < 1) return "El número de días debe ser mayor que 0"; + let temperatura_max = temperatura_inicial; + let temperatura_min = temperatura_inicial; + let llueve = false; + + for(let i=0; i 25){ + probabilidad_lluvia += 20; + }else if(temperatura_inicial < 5){ + probabilidad_lluvia -= 20; + } + if(probabilidad_lluvia > 100){ + probabilidad_lluvia = 100; + }else if(probabilidad_lluvia < 0){ + probabilidad_lluvia = 0; + } + if(probabilidad <= probabilidad_lluvia){ + temperatura_inicial -= 1; + llueve = true; + } + if(temperatura_inicial > temperatura_max){ + temperatura_max = temperatura_inicial; + }else if(temperatura_inicial < temperatura_min){ + temperatura_min = temperatura_inicial; + } + } + if(llueve){ + return `La temperatura máxima es ${temperatura_max}°C, la mínima es ${temperatura_min}°C y va a llover ${dias} días`; + } + + return `La temperatura máxima es ${temperatura_max}°C, la mínima es ${temperatura_min}°C y no va a llover`; +} + +console.log(weather_simulator(7, 20, 50)); \ No newline at end of file diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/javascript/klyone.js" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/javascript/klyone.js" new file mode 100644 index 0000000000..1dcd3fcfa5 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/javascript/klyone.js" @@ -0,0 +1,81 @@ + +function simulateWeather(initialTemperature, rainLikehood, days) { + result = {} + simulation = [] + simulation.push({temperature: initialTemperature, + rain: rainLikehood, rained: (rainLikehood == 100) ? true : false}) + + let temperature = initialTemperature + let rain = rainLikehood + + for (i = 0 ; i < days ; i++) { + let d = passNextDay({temperature: temperature, rain: rain}) + simulation.push(d) + temperature = d.temperature + rain = d.rain + } + + result.simulation = simulation + + let maxTemp = result.simulation[0].temperature + let minTemp = result.simulation[0].temperature + let rainedDays = 0 + + result.simulation.forEach((d) => { + if (d.temperature > maxTemp) + maxTemp = d.temperature + if (d.temperature < minTemp) + minTemp = d.temperature + if (d.rained) + rainedDays++ + }) + + result.metrics = {maxTemperature: maxTemp, minTemperature: minTemp, rainedDays: rainedDays} + + return result +} + +function passNextDay({temperature, rain}) +{ + let newTemperature = temperature + let newRain = rain + let rained = false + const getRandom = () => Math.floor(Math.random() * 101) + + if (rain == 100) { + newTemperature -= 1 + newRain = 0 + rained = true + } + else { + let tempIncrease = getRandom() < 10 + if (tempIncrease) { + newTemperature += 2 + } + else { + let tempDecrease = getRandom() < 10 + if (tempDecrease) { + newTemperature -= 2 + } + } + } + + if (temperature > 25) { + newRain += 20 + if (newRain > 100) + newRain = 100 + } else { + if (temperature < 5) { + newRain -= 20; + if (newRain < 0) + newRain = 0 + } + } + + return {temperature: newTemperature, rain: newRain, rained: rained} +} + +console.log(simulateWeather(15, 10, 7)) +console.log(simulateWeather(25, 30, 10)) +console.log(simulateWeather(5, 25, 3)) +console.log(simulateWeather(30, 50, 9)) diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/Hugovrc.py" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/Hugovrc.py" new file mode 100644 index 0000000000..48938bd477 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/Hugovrc.py" @@ -0,0 +1,50 @@ +import random + +def simulador_clima(dias: int): + temp_ini = int(input("Digita la temperatura inicial: ")) + prob_lluv = int(input("Digita el % de probabilidad de lluvia: ")) + dias_luvia = 0 + temp_min = 100 + temp_max = 0 + lluvia = "No" + + for dia in range(0, dias): + prob_tem = random.randint(0,10) == 1 + aum_o_dis = random.randint(1,2) + + if prob_tem: + if aum_o_dis == 1: + temp_ini += 2 + else: + temp_ini -= 2 + if temp_ini > 25: + if prob_lluv >= 100: + prob_lluv = 100 + elif prob_lluv < 100: + restante = 100 - prob_lluv + prob_lluv += restante + else: + prob_lluv += 20 + if prob_lluv == 100: + temp_ini -= 1 + lluvia = "Si" + if temp_ini < 5: + if prob_lluv <= 0: + prob_lluv = 0 + else: + prob_lluv -= 20 + if temp_ini > temp_max: + temp_max = temp_ini + if temp_ini < temp_min: + temp_min = temp_ini + if prob_lluv < 100: + lluvia = "No" + if lluvia == "Si": + dias_luvia += 1 + print(f"Dia: {dia} , Temperatura: {temp_ini} ,probabilidad de Lluvia: {lluvia, prob_lluv}") + print(f"Temperatura max: {temp_max}") + print(f"Temperatura min: {temp_min}") + print(f"Dias de Luvia: {dias_luvia}") + + +simulador_clima(10) \ No newline at end of file diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/PushoDev.py" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/PushoDev.py" new file mode 100644 index 0000000000..0f77ba605e --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/PushoDev.py" @@ -0,0 +1,85 @@ +# +# Reto #43: Simulador de clima +# Dificultad: Fácil | Publicación: 30/10/23 | Corrección: 13/11/23 +#----------------------------------------------------------------- +# ENUNCIADO DEL EJERCICIO +#----------------------------------------------------------------- +# /* +# * Crea una función que simule las condiciones climáticas (temperatura y probabilidad de lluvia) +# * de un lugar ficticio al pasar un número concreto de días según estas reglas: +# * - La temperatura inicial y el % de probabilidad de lluvia lo define el usuario. +# * - Cada día que pasa: +# * - 10% de posibilidades de que la temperatura aumente o disminuya 2 grados. +# * - Si la temperatura supera los 25 grados, la probabilidad de lluvia al día +# * siguiente aumenta en un 20%. +# * - Si la temperatura baja de 5 grados, la probabilidad de lluvia al día +# * siguiente disminuye en un 20%. +# * - Si llueve (100%), la temperatura del día siguiente disminuye en 1 grado. +# * - La función recibe el número de días de la predicción y muestra la temperatura +# * y si llueve durante todos esos días. +# * - También mostrará la temperatura máxima y mínima de ese periodo y cuántos días va a llover. +# */ +#----------------------------------------------------------------- + +import random + + +print ("Pushodev") +print ("https://github.com/PushoDev") + +def simular_clima_interactivo(): + # Solicitar entrada del usuario + dias = int(input("Ingrese el número de días para la predicción: ")) + temp_inicial = float(input("Ingrese la temperatura inicial: ")) + prob_lluvia_inicial = float(input("Ingrese la probabilidad inicial de lluvia (0-1): ")) + + # Inicializar variables + temperatura = temp_inicial + prob_lluvia = prob_lluvia_inicial + llueve = False + dias_lluvia = 0 + temperaturas = [] + + # Simular condiciones climáticas + for _ in range(dias): + # 10% de posibilidades de cambio de temperatura + if random.random() < 0.1: + cambio_temperatura = random.choice([-2, 2]) + temperatura += cambio_temperatura + + # Ajustar probabilidad de lluvia según la temperatura + if temperatura > 25: + prob_lluvia += 0.2 + elif temperatura < 5: + prob_lluvia -= 0.2 + + # Verificar si llueve + llueve = random.random() < prob_lluvia + + # Ajustar temperatura si llueve + if llueve: + temperatura -= 1 + + # Registrar datos del día + temperaturas.append(temperatura) + + # Contar días de lluvia + if llueve: + dias_lluvia += 1 + + # Mostrar resultados + temp_maxima = max(temperaturas) + temp_minima = min(temperaturas) + + print(f"\nPredicción para los próximos {dias} días:") + print(f"Temperatura máxima: {temp_maxima}°C") + print(f"Temperatura mínima: {temp_minima}°C") + print(f"Días de lluvia: {dias_lluvia}") + print("Detalles por día:") + for i, temp in enumerate(temperaturas, start=1): + print(f"Día {i}: {temp}°C {'(lluvia)' if llueve else ''}") + +# Ejecutar la simulación interactiva +simular_clima_interactivo() + +print("Gracias por participar ...") diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/ShinMugenNoKabe.py" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/ShinMugenNoKabe.py" new file mode 100644 index 0000000000..51d76222f4 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/ShinMugenNoKabe.py" @@ -0,0 +1,69 @@ +# Crea una función que simule las condiciones climáticas (temperatura y probabilidad de lluvia) +# de un lugar ficticio al pasar un número concreto de días según estas reglas: +# - La temperatura inicial y el % de probabilidad de lluvia lo define el usuario. +# - Cada día que pasa: +# - 10% de posibilidades de que la temperatura aumente o disminuya 2 grados. +# - Si la temperatura supera los 25 grados, la probabilidad de lluvia al día +# siguiente aumenta en un 20%. +# - Si la temperatura baja de 5 grados, la probabilidad de lluvia al día +# siguiente disminuye en un 20%. +# - Si llueve (100%), la temperatura del día siguiente disminuye en 1 grado. +# - La función recibe el número de días de la predicción y muestra la temperatura +# y si llueve durante todos esos días. +# - También mostrará la temperatura máxima y mínima de ese periodo y cuántos días va a llover. + +from random import randint, getrandbits + + +def climate_change(initial_days: int, initial_temperature: float, inititial_risk_of_rain: float): + days: int = initial_days + next_temperature: float = initial_temperature + next_risk_of_rain: float = inititial_risk_of_rain + + min_temperature: float = initial_temperature + max_temperature: float = initial_temperature + + for day in range(days): + temperature: float = next_temperature + risk_of_rain: float = next_risk_of_rain + + print(f"Day {day + 1}, temperature: {temperature}, is raining: {risk_of_rain == 100} ") + + if risk_of_rain == 100: + next_temperature -= 1 + + if temperature < min_temperature: + min_temperature = temperature + + if temperature > max_temperature: + max_temperature = temperature + + increase_decrease_temperature_prob: int = randint(1, 100) + + if increase_decrease_temperature_prob >= 1 and increase_decrease_temperature_prob <= 10: + increase_temperature: bool = bool(getrandbits(1)) + + if increase_temperature: + next_temperature += 2 + else: + next_temperature -= 2 + + if next_temperature > 25: + next_risk_of_rain += 20 + elif next_temperature < 5: + next_risk_of_rain -= 20 + + if next_risk_of_rain < 0: + next_risk_of_rain = 0 + elif next_risk_of_rain > 100: + next_risk_of_rain = 100 + + print(f"Min temperature: {min_temperature}º, max temperature: {max_temperature}º") + + +if __name__ == "__main__": + days: int = int(input("Number of days: ")) + temperature: float = float(input("Initial number of temperature: ")) + risk_of_rain: float = float(input("Initial risk of rain: ")) + + climate_change(days, temperature, risk_of_rain) \ No newline at end of file diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/pyramsd.py" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/pyramsd.py" new file mode 100644 index 0000000000..6d49922268 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/pyramsd.py" @@ -0,0 +1,44 @@ +import random + + +def weather_simulator(temperature: int, rain: int, days: int): + + rainy_days = 0 + min_temp = temperature + max_temp = temperature + + for day in range(1, days + 1): + + print(f"Día {day}: {temperature} grados y {rain}% de probabilidad de lluvia") + + if rain == 100: + rainy_days += 1 + + if temperature < min_temp: + min_temp = temperature + + if temperature > max_temp: + max_temp = temperature + + if random.randint(1, 10) == 1: + temperature += 2 if random.randint(1, 2) == 1 else -2 + + if temperature > 25: + rain += 20 + if rain > 100: + rain = 100 + + elif temperature < 5: + rain -= 20 + if rain < 0: + rain = 0 + + if rain == 100: + temperature -= 1 + + print(f"Días lluviosos: {rainy_days}") + print(f"Temperatura mínima: {min_temp}") + print(f"Temperatura máxima: {max_temp}") + + +weather_simulator(24, 100, 365) \ No newline at end of file diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/raulG91.py" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/raulG91.py" new file mode 100644 index 0000000000..9fdb6305c1 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/python/raulG91.py" @@ -0,0 +1,59 @@ +from random import randrange + +def sim_weather(ini_temp,ini_rain_percentage,num_days=7): + min_temp = ini_temp + max_temp = ini_temp + rain_percentage = ini_rain_percentage + rain_days = 0 + temperature_today = ini_temp + temperature_previos_day = temperature_today + temperature_next_day = temperature_today + + for day in range(1,num_days + 1): + is_raining = False + temperature_previos_day = temperature_today + temperature_today = temperature_next_day + + print("Temparature on day " + str(day) + " is " + str(temperature_today)) + #Adjust min and max temperature + if temperature_today < min_temp: + min_temp = temperature_today + elif temperature_today > max_temp: + max_temp = temperature_today + #Generate a random number to check if it will rain + random = randrange(0,100) + if random <= rain_percentage: + #It will rain + is_raining = True + rain_days +=1 + print("it will rain") + else: + print("it won't rain") + if temperature_today > 25: + #Temparature is bigger than 25 so we increase rain percentage 20% + rain_percentage += 20 + if temperature_previos_day - temperature_today == 5: + #Temperature decrease 5 degrees + rain_percentage -= 20 + + if is_raining : + #if it's raining 100% temperature will decrease 1 degree + temperature_next_day = temperature_today - 1 + else: + # there is a 10% of changing temparature + random = randrange(0,100) + if random <= 10: + #Temperature will change and new random will be generated to know if it will + # increase or decrease + random = randrange(0,1) + if random == 0: + temperature_next_day = temperature_today + 2 + else: + temperature_next_day = temperature_today - 2 + print("Number days with rain " + str(rain_days)) + print("Max temperature expected " + str(max_temp) + " , min temperature expected " + str(min_temp)) + +ini_temp = int(input("Set initial temperature ")) +ini_rain_percentage = int(input("Set initial rain probability ")) + +sim_weather(ini_temp=ini_temp, ini_rain_percentage= ini_rain_percentage) \ No newline at end of file diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c#/deathwing696.cs" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c#/deathwing696.cs" new file mode 100644 index 0000000000..c0cb564565 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c#/deathwing696.cs" @@ -0,0 +1,114 @@ +/* + * Crea un juego interactivo por terminal en el que tendrs que adivinar + * el resultado de diferentes + * operaciones matemticas aleatorias (suma, resta, multiplicacin + * o divisin de dos nmeros enteros). + * - Tendrs 3 segundos para responder correctamente. + * - El juego finaliza si no se logra responder en ese tiempo. + * - Al finalizar el juego debes mostrar cuntos clculos has acertado. + * - Cada 5 aciertos debes aumentar en uno el posible nmero de cifras + * de la operacin (cada vez en un operando): + * - Preguntas 1 a 5: X (entre 0 y 9) operacin Y (entre 0 y 9) + * - Preguntas 6 a 10: XX (entre 0 y 99) operacin Y (entre 0 y 9) + * - Preguntas 11 a 15: XX operacin YY + * - Preguntas 16 a 20: XXX (entre 0 y 999) operacin YY + * ... + */ + +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace reto44 +{ + public class Reto44 + { + static void Main(string[] args) + { + int num_respuestas = 0, respuesta, resultado = 0; + CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); + CancellationToken cancellationToken = cancellationTokenSource.Token; + Task readInputTask; + + do + { + readInputTask = Task.Run(() => Lanza_operacion(num_respuestas, out resultado), cancellationToken); + respuesta = Task.WaitAny(new Task[] { readInputTask }, TimeSpan.FromSeconds(2)); + + if (Task.WaitAny(new Task[] { readInputTask }, TimeSpan.FromSeconds(3)) != -1) + { + if (readInputTask.Result == resultado) + { + num_respuestas++; + } + else + { + Console.WriteLine($"El resultado {readInputTask.Result} no es correcto, el valor esperado era {resultado}"); + respuesta = -2; + } + } + else + { + respuesta = -1; + break; + } + + } while (respuesta != -1 && respuesta != -2); + + cancellationTokenSource.Cancel(); + + if (respuesta == -1) + { + Console.WriteLine(); + Console.WriteLine($"Has tardado ms de 3 segundos en responder, lo siento, has perdido pero has respondido bien a {num_respuestas} respuestas"); + } + + Console.ReadKey(); + } + + public static int Lanza_operacion(int num_respuestas, out int resultado) + { + Random random = new Random(); + int operacion, respuesta; + string num1 = "", num2 = "", operador = ""; + + for (int i = 0; i < Math.Floor(num_respuestas / 5.0) + 1; i++) + num1 += random.Next(0, 10).ToString(); + + for (int i = 0; i < Math.Floor(num_respuestas / 5.0) + 1; i++) + num2 += random.Next(0, 10).ToString(); + + operacion = random.Next(0, 4); + + switch (operacion) + { + case 0: + operador = "+"; + resultado = Int32.Parse(num1) + Int32.Parse(num2); + break; + case 1: + operador = "-"; + resultado = Int32.Parse(num1) - Int32.Parse(num2); + break; + case 2: + operador = "x"; + resultado = Int32.Parse(num1) * Int32.Parse(num2); + break; + case 3: + operador = "/"; + resultado = Int32.Parse(num1) / Int32.Parse(num2); + break; + default: + resultado = 0; + break; + } + + Console.Write($"Resuelve: {num1} {operador} {num2} = "); + + if (Int32.TryParse(Console.ReadLine(), out respuesta)) + return respuesta; + else + return 0; + } + } +} \ No newline at end of file diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c#/miquelcie.cs" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c#/miquelcie.cs" new file mode 100644 index 0000000000..ea3279b616 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c#/miquelcie.cs" @@ -0,0 +1,174 @@ +namespace Reto44; + +/* + * Crea un juego interactivo por terminal en el que tendrs que adivinar + * el resultado de diferentes + * operaciones matemticas aleatorias (suma, resta, multiplicacin + * o divisin de dos nmeros enteros). + * - Tendrs 3 segundos para responder correctamente. + * - El juego finaliza si no se logra responder en ese tiempo. + * - Al finalizar el juego debes mostrar cuntos clculos has acertado. + * - Cada 5 aciertos debes aumentar en uno el posible nmero de cifras + * de la operacin (cada vez en un operando): + * - Preguntas 1 a 5: X (entre 0 y 9) operacin Y (entre 0 y 9) + * - Preguntas 6 a 10: XX (entre 0 y 99) operacin Y (entre 0 y 9) + * - Preguntas 11 a 15: XX operacin YY + * - Preguntas 16 a 20: XXX (entre 0 y 999) operacin YY + * ... + + Para ejecutar + + using Reto44; + Adivinanza adivinanza= new Adivinanza(); + adivinanza.Init(); + + */ + +public class Adivinanza +{ + private int Score { get; set; } + private Operator Operator { get; set; } + + private DateTime InitTime; + private DateTime EndTime; + private int IntervalCountNumber1 = 5; + private int IntervalCountNumber2 = 10; + private int powCounterNumber1 = 1; + private int powCounterNumber2 = 1; + private static Random random = new Random(); + + + private string ShowOperation(int number1, int number2, Operator operation) + { + InitTime = DateTime.Now; + Operator = operation; + string operationShow = ""; + switch (operation) + { + case Operator.Plus: + operationShow = $"{number1} + {number2} = "; + break; + case Operator.Minus: + operationShow = $"{number1} - {number2} = "; + break; + case Operator.Multiplication: + operationShow = $"{number1} * {number2} = "; + break; + case Operator.Division: + + operationShow = $"{number1} / {number2} = "; + break; + } + + return operationShow; + } + + private void CalculateOperation(int number1, int number2, int result) + { + EndTime = DateTime.Now; + int resultado = 0; + switch (Operator) + { + case Operator.Plus: + resultado = number1 + number2; + break; + case Operator.Minus: + resultado = number1 - number2; + break; + case Operator.Multiplication: + resultado = number1 * number2; + break; + case Operator.Division: + + resultado = number1 / number2; + break; + } + + if (resultado == result) + Score++; + + } + + private string ShowScoreEndGame() + { + return $"Haz acertado {Score} operaciones"; + } + + private bool IsInTime() + { + TimeSpan diference = EndTime - InitTime; + return diference.TotalSeconds <= 3; + } + + private int GetNumber1() + { + if (Score <= 5) + { + return random.Next(1, 10); + } + + if (Score > IntervalCountNumber1) + { + powCounterNumber1++; + IntervalCountNumber1 += 10; + } + + return random.Next(1, (int)Math.Pow(10, powCounterNumber1)); + + } + + private int GetNumber2() + { + if (Score <= 5) + { + return random.Next(1, 10); + } + + if (Score > IntervalCountNumber2) + { + powCounterNumber2++; + IntervalCountNumber2 += 10; + } + + return random.Next(1, (int)Math.Pow(10, powCounterNumber2)); + } + private Operator GetRandomOperation() + { + return (Operator)random.Next(4); + } + + public void Init() + { + + while (this.IsInTime()) + { + var number1 = this.GetNumber1(); + var number2 = this.GetNumber2(); + var operation = this.GetRandomOperation(); + + string operationText = this.ShowOperation(number1, number2, operation); + Console.Write(operationText); + string result = Console.ReadLine(); + int resultInt; + if (int.TryParse(result, out resultInt)) + this.CalculateOperation(number1, number2, resultInt); + + } + + Console.WriteLine(ShowScoreEndGame()); + Console.WriteLine("Presione enter para salir"); + Console.ReadLine(); + + + } + + +} + +public enum Operator +{ + Plus, + Minus, + Multiplication, + Division +} \ No newline at end of file diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c++/exanderguitar.cpp" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c++/exanderguitar.cpp" new file mode 100644 index 0000000000..e594c42370 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/c++/exanderguitar.cpp" @@ -0,0 +1,168 @@ +#include +#include +#include +#include + +enum MathOperator { + ADD, + SUBSTRACT, + MULTIPLY, + DIVIDE +}; + +void getTime (std::chrono::steady_clock::time_point& timePoint); +double calculateInterval (std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end); +bool game (int& level, int& prevLevel, double timeLimit, int& digitLeft, int& digitRight); +int prepareQuestion (int rightAnswers, int prevLevel, int& digitLeft, int& digitRight); +int randomNumber (int digits); +void randomOperator (MathOperator& quizOperator); + +int main() { + + bool finish {false}; + int currentLevel {1}; + int previousLevel {1}; + double timeLimit {20.0}; + int leftDigit {1}; + int rightDigit {1}; + + while(!finish) { + finish = game(currentLevel, previousLevel, timeLimit, leftDigit, rightDigit); + } + + std::cout << '\n'; + std::cout << "Has tenido " << currentLevel - 1<< " aciertos.\n"; + + return 0; +} + +void getTime (std::chrono::steady_clock::time_point& timePoint) { + + timePoint = std::chrono::steady_clock::now(); + +} + +double calculateInterval (std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end) { + + std::chrono::duration timeInterval = std::chrono::duration_cast>(end - start); + + return timeInterval.count(); +} + +bool game(int& level, int& prevLevel, double timeLimit, int& digitLeft, int& digitRight) { + + std::chrono::steady_clock::time_point startTime {}; + std::chrono::steady_clock::time_point endTime {}; + + std::cout << "¡Ponte a prueba con adivinanzas matematicas!\n\n"; + std::cout << "Nivel " << level << "\n\n"; + + int result {prepareQuestion (level, prevLevel, digitLeft, digitRight)}; + + getTime (startTime); + + int userAnswer {}; + std::cin >> userAnswer; + + std::cout << '\n'; + + getTime (endTime); + double interval {calculateInterval (startTime, endTime)}; + + if(result == userAnswer) { + std::cout << "¡Correcto!\n"; + level++; + } + else { + std::cout << "¡Incorrecto! El resultado era: " << result << '\n'; + prevLevel = level; + } + + if(interval > timeLimit) { + std::cout << "Lo siento, pero has tardado demasiado en responder.\n"; + return true; + } + + return false; +} + +int prepareQuestion (int rightAnswers, int prevLevel, int& digitLeft, int& digitRight) { + + MathOperator quizOperator {}; + randomOperator (quizOperator); + + if(rightAnswers % 5 == 0 && prevLevel != rightAnswers) { + if(digitLeft == digitRight) { + digitLeft++; + } + else { + digitRight++; + } + } + + int leftOperand {randomNumber(digitLeft)}; + int rightOperand {randomNumber(digitRight)}; + int result {}; + + switch(quizOperator) { + case ADD: + std::cout << leftOperand << " + " << rightOperand << " = "; + result = leftOperand + rightOperand; + break; + case SUBSTRACT: + std::cout << leftOperand << " - " << rightOperand << " = "; + result = leftOperand - rightOperand; + break; + case MULTIPLY: + std::cout << leftOperand << " * " << rightOperand << " = "; + result = leftOperand * rightOperand; + break; + case DIVIDE: + if(rightOperand == 0) { + rightOperand++; + } + std::cout << leftOperand << " / " << rightOperand << " = "; + result = leftOperand / rightOperand; + break; + default: + std::cout << "Error in prepareQuestion switch\n"; + break; + } + + return result; +} + +int randomNumber (int digits) { + + int upperLimit {static_cast(std::pow(10, digits) - 1)}; + + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution numberDis(0, upperLimit); + + return numberDis(gen); +} + +void randomOperator (MathOperator& quizOperator) { + + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution numberDis(0,3); + + switch(numberDis(gen)) { + case 0: + quizOperator = ADD; + break; + case 1: + quizOperator = SUBSTRACT; + break; + case 2: + quizOperator = MULTIPLY; + break; + case 3: + quizOperator = DIVIDE; + break; + default: + std::cout << "Error in switch operator\n"; + } +} diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/go/blackriper.go" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/go/blackriper.go" new file mode 100644 index 0000000000..3e49dd3172 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/go/blackriper.go" @@ -0,0 +1,89 @@ +package main + +import ( + "fmt" + "math/rand" + "time" +) + +/* definir metodos de trabajo*/ +type MathematicalRiddles interface { + PlayRiddles() +} + +// implementar metodos de interface +type RiddlesGame struct { + Sucess int +} + +func (r *RiddlesGame) PlayRiddles() { + var ( + res int + answer int + question int = 1 + ) + + for { + fmt.Println("***** MathematicalRiddles *****") + x, signal, y := GeneratorRiddles(question) + GetResultRiddle(x, y, &res, signal) + fmt.Printf("Write the correct answer to the following operation %v %v %v = ", x, signal, y) + fmt.Scanf("%d", &answer) + time.Sleep(3 * time.Second) + if answer != res { + fmt.Println("you lost game !!") + fmt.Printf("you solved %v operations correctly ", r.Sucess) + break + } else if answer == res { + question++ + r.Sucess++ + } + + } + +} + +/* funciones auxiliares*/ +func GeneratorRiddles(question int) (x int, signal string, y int) { + + signals := []string{"+", "-", "*", "/"} + + switch { + case question >= 1 && question <= 5: + x = rand.Intn(9) + y = rand.Intn(9) + + case question >= 6 && question <= 10: + x = rand.Intn(99) + y = rand.Intn(9) + + case question >= 11 && question <= 15: + x = rand.Intn(99) + y = rand.Intn(99) + + case question >= 16 && question <= 20: + x = rand.Intn(999) + y = rand.Intn(99) + } + signal = signals[rand.Intn(len(signals))] + + return x, signal, y +} + +func GetResultRiddle(x, y int, res *int, signal string) { + switch signal { + case "+": + *res = x + y + case "-": + *res = x - y + case "*": + *res = x * y + case "/": + *res = x / y + } +} + +func main() { + var game MathematicalRiddles = &RiddlesGame{} + game.PlayRiddles() +} diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/haskell/sfmolina.hs" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/haskell/sfmolina.hs" new file mode 100644 index 0000000000..4936e52840 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/haskell/sfmolina.hs" @@ -0,0 +1,136 @@ +module Main where + +import Data.Time.Clock.POSIX ( getPOSIXTime ) +import System.Timeout ( timeout ) +import Control.Concurrent +import Text.Read (readMaybe) +import Data.Maybe +import System.IO + + +---- + + +main :: IO () +main = do + + hSetBuffering stdout NoBuffering -- Corrige errores de salida a terminal al compilar con ghc + hSetBuffering stdin LineBuffering -- Corrige errores de entrada al ejecutar con ghci + + putStrLn "--------------------------------------" + putStrLn "¡Bienvenido a Adivinanzas matemáticas!" + putStrLn "--------------------------------------" + putStrLn $ + "Tendrás 3 segundos para responder correctamente el resultado de una operación matemática." ++ + "\n" ++ + "- Si lo consigues, se te presentará una nueva cuestión. Cada 5 aciertos aumentará en uno" ++ + " el posible número de cifras de un operando." ++ + "\n" ++ + "- Si no lo consigues, acabará el juego y se mostrará tu puntuación final." + + iniciar + + +---- + + +iniciar :: IO () +iniciar = do + putStrLn "---" + putStr "Cuando estés listo escribe 'y': " + respuesta <- getLine + if respuesta == "y" + then comenzarJuego (1, 1) 0 + else do + putStrLn "No hay prisa, ya sabes..." + iniciar + + +---- + + +comenzarJuego :: (Int, Int) -> Int -> IO () +comenzarJuego longitud puntuacion = do + + semilla1 <- obtenerSemilla + semilla2 <- obtenerSemilla + semilla3 <- obtenerSemilla + + let opStr = operacionAleatoria semilla1 + op = strToOp opStr + x = numeroAleatorio (semilla2 + 564851568) (fst longitud) + y = if opStr /= "/" then numeroAleatorio (semilla3 + 3219781323) (snd longitud) else (numeroAleatorio (semilla3 + 98202238) (snd longitud)) + 1 + -- Controla la división entre 0 + + putStr "\n" + putStrLn "--------------------------------------" + putStrLn $ "Pregunta " ++ show (puntuacion + 1) + putStr "\n" + putStr $ ">>> " ++ show x ++ opStr ++ show y ++ " = " + + maybeRespuesta <- timeout (3 * 10^6) getLine -- Máximo 3 segundos para responder + let solucion = x `op` y + + case maybeRespuesta of + Nothing -> incorrecto solucion -- El jugador no responde + Just respuestaStr -> case readMaybe respuestaStr of -- El jugador responde + Nothing -> incorrecto solucion -- El jugador da una respuesta no válida + Just respuestaInt -> -- La respuesta es válida + if respuestaInt == solucion + then correcto longitud puntuacion -- El jugador acierta + else incorrecto solucion -- El jugador falla + + where + incorrecto :: Int -> IO () + incorrecto s = do + putStr "\n" + putStrLn "--------------------------------------" + putStrLn "¡Has fallado!" + putStrLn $ "La respuesta correcta era: " ++ show s + putStrLn $ "Tu puntuación final: " ++ show puntuacion + putStrLn "--------------------------------------" + + correcto :: (Int, Int) -> Int -> IO () + correcto l p + | (p `mod` 5) /= 0 || p == 0 = comenzarJuego longitud (puntuacion + 1) + | otherwise = comenzarJuego (actualizar longitud) (puntuacion + 1) + + actualizar :: (Int, Int) -> (Int, Int) + actualizar (l1, l2) + | l1 == l2 = (l1 + 1, l2) + | otherwise = (l1, l2 + 1) + + obtenerSemilla :: IO Int + obtenerSemilla = round <$> getPOSIXTime + + +---- + + +operaciones :: [String] +operaciones = ["+", "-", "*", "/"] + + +operacionAleatoria :: Int -> String +operacionAleatoria semilla = operaciones !! (semilla `mod` length operaciones) + + +strToOp :: String -> (Int -> Int -> Int) +strToOp "+" = (+) +strToOp "-" = (-) +strToOp "*" = (*) +strToOp "/" = div +strToOp _ = error "ERROR: Operador no reconocido" + + +---- + + +numeroAleatorio :: Int -> Int -> Int +numeroAleatorio semilla longitud + | longitud <= 0 = error "ERROR: La longitud de un número debe ser mayor que 0" + | otherwise = semilla `mod` (limiteSuperior - limiteInferior + 1) + limiteInferior + where + limiteSuperior = 10 ^ longitud - 1 + limiteInferior = 0 + diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/Franpelirrojo.java" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/Franpelirrojo.java" new file mode 100644 index 0000000000..bb4971ebbc --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/Franpelirrojo.java" @@ -0,0 +1,120 @@ +import java.util.Scanner; + +/* + * https://github.com/franpelirrojo + */ + +public class Franpelirrojo { + private static int resultado; + private static double vuelta = 0; + private static int nX = 1; + private static int nY = 1; + + private enum Estado {SIN_TIMEPO, INCORRECTO}; + private static Estado estado; + + public static void main(String[] args) throws InterruptedException { + Thread main = Thread.currentThread(); + + System.out.println("¡Responde rápido!"); + while (true){ + Thread crono = new Thread(() -> { //bucle del tiempo de juego + try { + while (true){ + Thread.sleep(3000); + if (!Thread.interrupted()){ + estado = Estado.SIN_TIMEPO; + main.interrupt(); + break; + } + } + } catch (InterruptedException e) { + System.out.println("¡3 segundos!"); + } + }); + + Thread juego = new Thread(() ->{ //bucle de juego + Scanner usuario = new Scanner(System.in); + generarOperacion(); + + int respuesta = usuario.nextInt(); + if (respuesta != resultado){ + estado = Estado.INCORRECTO; + main.interrupt(); + }else { + crono.interrupt(); + } + + vuelta ++; + comprobarVueltas(); + }); + juego.setDaemon(true); + + juego.start(); + crono.start(); + try { + juego.join(); + } catch (InterruptedException e) { + break; + } + } + + if (estado.equals(Estado.INCORRECTO)){ //Diferenciamos fin de juego + System.out.println("¡FIN DEL JUEGO!"); + System.out.println("Acertaste " + (vuelta!=0 ? (int)(vuelta - 1) : vuelta) + " operaciones."); + System.out.println("La respuesta correcta era: " + resultado); + } else if (estado.equals(Estado.SIN_TIMEPO)) { + System.out.println("¡FIN DEL JUEGO!"); + System.out.println("Te quedaste sin tiempo"); + System.out.println("Acertaste " + (vuelta!=0 ? (int)(vuelta - 1) : vuelta) + " operaciones."); + } + } + + /* + * Generamos aleatoriamente una de las cuatro cuentas posibles. + * La longitud de los operandos depende del exponente de 10. + * */ + private static void generarOperacion(){ + int operandoX; + int operandoY; + int operador = (int) (Math.random() * 3.9); + do { + operandoX = (int) (Math.random() * Math.pow(10, nX)); + operandoY = (int) (Math.random() * Math.pow(10, nY)); + } while (operador == 2 && operandoY == 0 || operandoX { //suma + System.out.println(operandoX + " + " + operandoY); + resultado = operandoX + operandoY; + } + case 1 -> { //multiplicación + System.out.println(operandoX + " * " + operandoY); + resultado = operandoX * operandoY; + } + case 2 -> { //división + System.out.println(operandoX + " / " + operandoY); + resultado = operandoX / operandoY; + } + case 3 -> { //resta + System.out.println(operandoX + " - " + operandoY); + resultado = operandoX - operandoY; + } + } + } + + /* + * Aumenta los operadores dependiendo de en qué momento de juego estamos. + * Si el numero de vueltas que hemos dado al bucle de juego es divisible entre 5 + * aumenta el operador X. En cambio si también lo es entre 2 aumenta el operador Y. + * */ + private static void comprobarVueltas(){ + if (vuelta%5 == 0 ){ + if (vuelta%2 == 0){ + nY++; + }else { + nX++; + } + } + } +} diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/asjordi.java" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/asjordi.java" new file mode 100644 index 0000000000..06f1f76dfb --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/java/asjordi.java" @@ -0,0 +1,80 @@ +import java.util.Random; +import java.util.Scanner; +import java.util.Timer; +import java.util.TimerTask; + +public class MathRiddle { + + static boolean gameOn = true; + static int correctAnswers = 0; + static int num1Digits = 1; + static int num2Digits = 1; + static Random random = new Random(); + + public static void main(String[] args) { + while (gameOn) { + int num1 = randomInt(num1Digits); + int num2 = randomInt(num2Digits); + char operation = randomOperation(); + + int result; + if (operation == '+') result = num1 + num2; + else if (operation == '-') result = num1 - num2; + else if (operation == '*') result = num1 * num2; + else { + while (num2 == 0) num2 = randomInt(num2Digits); + result = num1 / num2; + } + + String answer = inputWithTimeout(num1, num2, operation); + + if (!gameOn) break; + else if (answer.equals(Integer.toString(result))) { + System.out.println("Respuesta correcta!"); + correctAnswers++; + + if (correctAnswers % 5 == 0) { + if (correctAnswers % 2 == 0) num2Digits++; + else num1Digits++; + } + + } else { + System.out.println("Respuesta incorrecta!"); + gameOn = false; + } + } + + System.out.println("Juego finalizado. Has acertado " + correctAnswers + " cálculos."); + } + + private static int randomInt(int digits) { + return random.nextInt((int) Math.pow(10, digits)); + } + + private static char randomOperation() { + char[] operations = {'+', '-', '*', '/'}; + return operations[random.nextInt(operations.length)]; + } + + private static String inputWithTimeout(int num1, int num2, char operation) { + Timer timer = new Timer(); + timer.schedule(new TimerTask() { + @Override + public void run() { + System.out.println("\n¡El tiempo ha finalizado! Pulsa enter."); + gameOn = false; + } + }, 3000); + + String answer; + try { + System.out.print("¿Cuál es el resultado de " + num1 + " " + operation + " " + num2 + "? "); + answer = new Scanner(System.in).nextLine(); + } finally { + timer.cancel(); + } + + return answer; + } + +} diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/klyone.js" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/klyone.js" new file mode 100644 index 0000000000..0ba901dd1a --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/klyone.js" @@ -0,0 +1,92 @@ + +const readline = require('node:readline/promises'); + +const SUM = 0; +const SUB = 1; +const MUL = 2; +const DIV = 3; +const TIMEOUTMS = 3000; + +function getOperation() { + return Math.floor(Math.random() * 4); +} + +function getRandom(digits) { + return Math.floor(Math.random() * (10**digits)); +} + +async function playGame() { + let aDigits = 1; + let bDigits = 1; + let endGame = false; + let answeredQuestions = 0; + let aToBeUpdated = true; + + const prompt = readline.createInterface({ input: process.stdin, output: process.stdout }) + + while (!endGame) { + let a = getRandom(aDigits); + let b = getRandom(bDigits); + let op = getOperation(); + let opStr = ""; + let res = 0; + + switch (op) { + case SUM: + res = parseInt(Math.floor(a + b)); + opStr = "+"; + break; + case SUB: + res = parseInt(Math.floor(a - b)); + opStr = "-"; + break; + case MUL: + res = parseInt(Math.floor(a * b)); + opStr = "*"; + break; + case DIV: + if (b == 0) { + b++; + } + res = parseInt(Math.floor(a / b)); + opStr = "/"; + break; + default: + throw new Error("Unexpected operation"); + break; + } + + console.log(`${a} ${opStr} ${b} = ?`); + + try { + const answer = parseInt(await prompt.question("Result: ", { signal: AbortSignal.timeout(TIMEOUTMS)})); + + if (res !== answer) { + console.log(`Wrong answer, correct is ${res}`); + endGame = true; + } + else { + answeredQuestions++; + + if (answeredQuestions % 5 == 0) { + if (aToBeUpdated) { + aDigits++; + aToBeUpdated = false; + } else { + bDigits++; + aToBeUpdated = true; + } + } + } + } catch(error) { + endGame = true; + } + + } + + prompt.close(); + + console.log(`You have answered ${answeredQuestions}`); +} + +playGame(); diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/marcode24.js" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/marcode24.js" new file mode 100644 index 0000000000..09d32b16b8 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/marcode24.js" @@ -0,0 +1,95 @@ +/* + * 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 + * ... + */ + +const readline = require('readline'); + +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout, +}); + +let score = 0; +let digitCount = 1; +const MAX_SECONDS = 3000; + +function getRandomNumber(max) { + return Math.floor(Math.random() * (max + 1)); +} + +function generateRandomOperation() { + const operators = ['+', '-', '*', '/']; + const operator = operators[getRandomNumber(operators.length - 1)]; + let operand1; + let operand2; + + switch (digitCount) { + case 1: + operand1 = getRandomNumber(9); + operand2 = getRandomNumber(9); + break; + case 2: + operand1 = getRandomNumber(99); + operand2 = getRandomNumber(9); + break; + case 3: + operand1 = getRandomNumber(99); + operand2 = getRandomNumber(99); + break; + default: + operand1 = getRandomNumber(999); + operand2 = getRandomNumber(99); + } + + return `${operand1} ${operator} ${operand2}`; +} + +function playRound() { + const operation = generateRandomOperation(); + console.log(`\nPregunta ${score + 1}: ${operation}`); + + const startTime = Date.now(); + rl.question('Tu respuesta: ', (answer) => { + const endTime = Date.now(); + const elapsedTime = endTime - startTime; + + // eslint-disable-next-line no-eval + if (parseInt(answer, 10) === eval(operation) && elapsedTime < MAX_SECONDS) { + console.log('\n¡Correcto!'); + score++; + } else { + console.log('\nRespuesta incorrecta o fuera de tiempo. Fin del juego.'); + console.log(`Preguntas acertadas: ${score}`); + rl.close(); + return; + } + + if (score % 5 === 0) { + digitCount++; + } + + playRound(); + }); +} + +function startGame() { + console.log('¡Bienvenido al juego matemático!'); + console.log('Tienes 3 segundos para responder cada pregunta.'); + playRound(); +} + +startGame(); + +// Visita mi repo en GitHub para ver y correr los tests de este código --> https://github.com/marcode24/weekly-challenges diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/npminit-dev.js" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/npminit-dev.js" new file mode 100644 index 0000000000..c965774ec6 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/npminit-dev.js" @@ -0,0 +1,79 @@ +const readline = require('readline') + +let questCount = 1 +let correct = 0 +const ops = ['+', '-', '*', '/'] + +const createIF = (readline) => readline.createInterface({ + input: process.stdin, + output: process.stdout +}) + +const getOperation = (ops, quesCount) => { + const op = ops[Math.round(Math.random() * (ops.length - 1))] + let left + let right + if(quesCount <= 5) { + left = Math.round(Math.random() * 9) + right = Math.round(Math.random() * 9) + } else if(quesCount > 5 && quesCount <= 10) { + left = Math.round(Math.random() * 90) + right = Math.round(Math.random() * 9) + } else if(quesCount > 10 && quesCount <= 15) { + left = Math.round(Math.random() * 99) + right = Math.round(Math.random() * 99) + } else { + left = Math.round(Math.random() * 999) + right = Math.round(Math.random() * 99) + } + return [ + `${left}${op}${right}`, + eval(`Math.trunc(${left}${op}${right})`) + ] +} + +console.clear() +console.log( +` <--- MATH OPS GAME ---> +All results must be rounded to the nearest integer +3 seconds contdown per question...`) + +const question =() => { + return new Promise((res, rej) => { + let rl = createIF(readline) + let [opstring, expect] = getOperation(ops, questCount) + rl.question( + `- Question ${questCount}: + Which is the result of ${opstring}?\n`, (result) => { + if(parseInt(result) === expect) correct++ + rl.close() + console.clear() + res('') + }) + setTimeout(() => { + rl.close() + rej('') + }, 3000) + }) +} + +setTimeout(async () => { + console.clear() + while(questCount <= 20) { + try { await question() } + catch(_) { break } + questCount ++ + } + console.clear() + console.log(` + GAME END!!! + Correct answers: ${correct}/20 + ${correct <= 10 ? + 'Meh... better luck next time' : + correct > 10 && correct <= 15 ? + 'Not bad, but you can improve' : + correct > 15 && correct <= 19 ? + 'Great work!' : 'Perfect!!!' + }`) + process.exit(0) +}, 4000) diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/othamae.js" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/othamae.js" new file mode 100644 index 0000000000..7d0d2e9948 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/othamae.js" @@ -0,0 +1,115 @@ +/* + * 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 + * ... + */ + +const readline = require('readline') +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout +}) + +playGame() + +function playGame(){ + console.log('Welcome to the math game!') + console.log('You have 3 seconds to answer...') + console.log('Good luck!!') + game(0) + +} + +function game(points){ + const [number1,operation, number2] = getQuestion(points) + const question = `${number1} ${operation} ${number2}` + const result =getResult(number1, operation, number2) + + const timer = setTimeout(() => { + console.log('\nTime is up! Game over :('); + console.log(`You answered ${points} questions correctly`); + rl.close(); + }, 3000) + + rl.question(`What is the result of the operation: ${question} = `, (answer) => { + console.log(result) + clearTimeout(timer); + if (parseInt(answer) === result){ + console.log('Correct answer') + points++ + console.log(`You have ${points} points`) + game(points) + } + else { + console.log('Game over :(') + console.log(`You answered ${points} questions correctly`) + rl.close() + } + }) + +} + +// helper functions +function getOperator(){ + const operations = ['+','-','*','/']; + return operations[Math.floor(Math.random()*operations.length)]; +} + +function getOneDigitNumber(){ + return Math.floor(Math.random()*10); +} + +function getTwoDigitNumber(){ + return Math.floor(Math.random()*100); +} + +function getThreeDigitNumber(){ + return Math.floor(Math.random()*1000); +} + +function getQuestion(points){ + let number1 + let number2 + if (points< 5 ){ + number1 = getOneDigitNumber() + number2 = getOneDigitNumber() + } else if (points< 10){ + number1 = getTwoDigitNumber() + number2 = getOneDigitNumber() + } else if (points< 15){ + number1 = getTwoDigitNumber() + number2 = getTwoDigitNumber() + } else if (points< 20){ + number1 = getThreeDigitNumber() + number2 = getTwoDigitNumber() + } else if (points< 25){ + number1 = getThreeDigitNumber() + number2 = getThreeDigitNumber() + } + const operation = getOperator() + return [number1, operation, number2] +} + +function getResult(number1, operator, number2){ + if (operator === '+'){ + return number1 + number2 + } else if (operator === '-'){ + return number1 - number2 + } else if (operator === '*'){ + return number1 * number2 + } else if (operator === '/'){ + return Math.round(number1 / number2) + } +} + diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/pepegonzale.js" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/pepegonzale.js" new file mode 100644 index 0000000000..9e08b9e5dc --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/javascript/pepegonzale.js" @@ -0,0 +1,89 @@ +/* + * 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 + * ... + */ +let correct = 0; +let questions = 0; +let digits_number = 0; +let x = 9; +let y = 9; +let myTimeout; +const rl = require("readline").createInterface({ + input: process.stdin, + output: process.stdout, +}); +const generateOperator = () => { + let operators = ["+", "-", "/", "*"]; + let operator = Math.floor(operators.length * Math.random()); + return operators[operator]; +}; +generateOperator(); +const generateRandomNumbers = () => { + if (correct % 5 === 0 && correct != 0) { + digits_number++; + if (!(digits_number % 2 === 0)) { + x = parseInt(x + "9"); + } else { + y = parseInt(y + "9"); + } + } + + let first = Math.floor(Math.random() * x); + let second = Math.floor(Math.random() * y); + return { + first, + second, + }; +}; +const adivinanzas_matematicas = () => { + let { first, second } = generateRandomNumbers(correct); + let operator = generateOperator(); + myTimeout = timeout(); + rl.question( + `What is the result of this ${first} ${operator} ${second} => `, + (user_result) => { + questions++; + console.log(`Question number ${questions}`); + let result = eval(`${first} ${operator} ${second}`); + console.log( + `The correct result is: ${result}, and your result is ${user_result}` + ); + if ( + result === parseInt(user_result) || + result === parseFloat(user_result) + ) { + correct++; + console.log(`Correct answer!`); + clearTimeout(myTimeout); + adivinanzas_matematicas(); + } else { + console.log( + `You solved ${correct} questions, try again to beat your record!` + ); + rl.close(); + } + } + ); +}; +const timeout = () => { + return setTimeout(() => { + console.log( + `You solved ${correct} questions, try again to beat your record!` + ); + rl.close(); + }, 3000); +}; + +adivinanzas_matematicas(); diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/kotlin/pisanowp.kt" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/kotlin/pisanowp.kt" new file mode 100644 index 0000000000..5f7e6ab473 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/kotlin/pisanowp.kt" @@ -0,0 +1,156 @@ +import java.time.Duration +import java.time.LocalDateTime + +fun main() { + + /* + * Reto #44 13/11/2023 ADIVINANZAS MATEMÁTICAS + * + * 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 + * ... + */ + + adivinanzasMatematicas() + +} + +fun adivinanzasMatematicas(tiempoParaResponder:Long = 3){ + + var ronda = 0 + var finJuego = false + + while (!finJuego){ + ronda++ + val operacion = dameOperacion() + var num1 = 0 + var num2 = 0 + var limiteInferior = 0 + + if (operacion == '/') { + limiteInferior = 1 + } + + if (ronda in (1..5)) { + num1 = dameNumero(0, 9) + num2 = dameNumero(limiteInferior, 9) + + } else if (ronda in (6..10) ) { + num1 = dameNumero(0, 99) + num2 = dameNumero(limiteInferior, 9) + + } else if (ronda in (11..15) ) { + num1 = dameNumero(0, 99) + num2 = dameNumero(limiteInferior, 99) + + } else if (ronda in (16..20) ) { + num1 = dameNumero(0, 999) + num2 = dameNumero(limiteInferior, 99) + + } else if (ronda in (11..25) ) { + num1 = dameNumero(0, 999) + num2 = dameNumero(limiteInferior, 999) + + } + + + print("Ronda nº$ronda. ") + val resultado = dameResultado(num1, num2, operacion) + + + val resultadoUsuario = pideResultado("$num1 ${operacion} $num2", tiempoParaResponder) + if (resultadoUsuario==-1) { + println("Has tardado más de $tiempoParaResponder segundos en responder :(") + finJuego = true + + } else if (resultadoUsuario!=resultado) { + println("Error, el resutaldo era $resultado :(") + finJuego = true + } else { + println("¡¡¡ Enhorabuena !!! :D, vamos a por otra ...") + } + + } + +} + + +fun dameNumero( limiteInferior : Int = 0, limiteSuperior : Int = 9) : Int { + return (limiteInferior..limiteSuperior).random() +} + +fun dameOperacion() : Char { + val operaciones = listOf('+', '-', '*', '/') + return operaciones.random() +} + +fun dameResultado(num1:Int, num2:Int, operacion:Char): Int{ + val resultado : Int + when (operacion) { + '+' -> { + resultado = num1 + num2 + } + '-' -> { + resultado = num1 - num2 + } + '*' -> { + resultado = num1 * num2 + } + '/' -> { + resultado = num1 / num2 + } + else -> { + resultado = 0 + } + } + return resultado + +} + +fun pideResultado( etiqueta : String, tiempoParaResponder: Long = 3): Int { + var numero: Int? = null + var valido = false + + + val tiempoInicial = LocalDateTime.now() + + while (!valido) { + print("Introduce $etiqueta = ") + val input = readLine() + + try { + numero = input?.toInt() + if (numero != null) { + valido = true + } else { + println("Entrada inválida. Debes ingresar un número entero positivo.") + } + + } catch (e: NumberFormatException) { + println("Entrada inválida. Debes ingresar un número entero positivo.") + } + } + + val tiempoFinal = LocalDateTime.now() + val duracion: Duration = Duration.between(tiempoInicial, tiempoFinal) + + // Obtener la diferencia en segundos + val segundos = duracion.seconds + if (segundos> tiempoParaResponder){ + numero=-1 + } + + return numero!! + +} \ No newline at end of file diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/KevinED11.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/KevinED11.py" new file mode 100644 index 0000000000..3119e00e9a --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/KevinED11.py" @@ -0,0 +1,127 @@ +from typing import Protocol, Iterable +import time +import functools +import random +import dataclasses + + +type Number = float | int + + +def pause_game(seconds: Number = 3) -> None: + time.sleep(seconds) + + +pause_game_by_3_seconds = functools.partial(pause_game, seconds=3) + + +class MathOperationFn(Protocol[Number]): + def __call__[T: Number](self, a: T, b: T) -> T: + ... + + +def add[T: Number](a: T, b: T) -> T: + return a + b + + +def subtract[T: Number](a: T, b: T) -> T: + return a - b + + +def multiply[T: Number](a: T, b: T) -> T: + return a * b + + +def divide[T: Number](a: T, b: T) -> T: + try: + return a / b + except ZeroDivisionError as err: + print(f"No se puede dividir por cero: {err}") + + +@functools.lru_cache +def math_operations() -> list[MathOperationFn]: + return [add, subtract, multiply, divide] + + +class MathOPerationSelectorStrategyFn(Protocol): + def __call__(self, operations: Iterable[MathOperationFn]) -> MathOperationFn: + ... + + +def math_operation_random_selector( + operations: Iterable[MathOperationFn], +) -> MathOperationFn: + return random.choice(operations) + + +class IGame(Protocol): + def play(self) -> None: + ... + + +class GameNotRunningExeption(Exception): + pass + + +class GameAlreadyRunningExeption(Exception): + pass + + +class MathRiddleGame: + def __init__(self, selector_strategy: MathOPerationSelectorStrategyFn) -> None: + self.selector_strategy = selector_strategy + self.__runnning = False + self.__score = 0 + + def __request_answer(self) -> str: + user_input = input("Ingrese la respuesta: ") + + def __pause_game(self) -> str | None: + while True: + user_input = input("Presione enter para continuar") + if user_input == "": + break + + def __choice_operation(self) -> MathOperationFn: + return self.selector_strategy() + + def __stop_game(self) -> None: + if not self.__runnning: + raise GameNotRunningExeption("El juego no está corriendo") + + self.__runnning = False + print("El juego ha finalizado") + + def __show_score(self) -> None: + print(f"Tu puntuación es: {self.__score} aciertos") + + def __prepare_game(self) -> None: + while True: + operation = self.__choice_operation() + user_input = self.__request_question() + self.__stop_game() + self.__show_score() + + self.__show_score() + self.__stop_game() + + def play(self) -> None: + if self.__runnning: + raise GameAlreadyRunningError("El juego ya está corriendo") + + self.__runnning = True + self.__prepare_game() + + +def main(game: IGame) -> None: + try: + game.play() + except (GameAlreadyRunningError, GameNotRunningExeption) as err: + print(err) + + +if __name__ == "__main__": + selector_strategy = math_operation_random_selector + game = MathRiddleGame(selector_strategy=selector_strategy) + main(game=game) diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/drifterDev.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/drifterDev.py" new file mode 100644 index 0000000000..a3ad309e07 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/drifterDev.py" @@ -0,0 +1,57 @@ +import time +import random + +def nums(level): + if level % 2 == 0: + return [random.randint(0, 10**(level//2 +1) - 1), random.randint(0, 10**(level//2) - 1)] + else: + potencia = 10**((level+1)//2) - 1 + return [random.randint(0, potencia), random.randint(0, potencia)] + +def operacion(num1, num2, op, res): + try: + res = int(res) + if res == num1+num2 and op == "+": + return True + elif res == num1-num2 and op == "-": + return True + elif res == num1*num2 and op == "*": + return True + elif res == num1//num2 and op == "/": + return True + else: + print("\nRespuesta incorrecta") + except: + print("\nEntrada no valida") + return False + +def main(): + ops = ["+", "-", "*", "/"] + level = 1 + aciertos = 0 + print("Bienvenido a la prueba de matematicas") + print("Las operaciones se resolveran en menos de 3 segundos y las divisiones seran enteras\n") + print("Nivel de dificultad:",(level),"\n") + while True: + num1, num2 = nums(level) + op = random.choice(ops) + if op == "/" and num2 == 0: + num2 = 1 + tiempo = time.time() + res = input(str(num1)+" "+op+" "+str(num2)+" = ") + if time.time() - tiempo > 3: + print("Se acabó el tiempo") + break + if operacion(num1, num2, op, res): + aciertos += 1 + else: + break + if aciertos % 5 == 0: + level += 1 + print("\nNivel de dificultad:",(level),"\n") + + + print("Aciertos:",aciertos) + +if __name__ == "__main__": + main() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/evilpotato04.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/evilpotato04.py" new file mode 100644 index 0000000000..2856122f5c --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/evilpotato04.py" @@ -0,0 +1,141 @@ +# 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 +# ... + +import random +from multiprocessing import TimeoutError +from multiprocessing.pool import ThreadPool + +def timeout(seconds): + def decorator(function): + def wrapper(*args, **kwargs): + pool = ThreadPool(processes=1) + result = pool.apply_async(function, args=args, kwds=kwargs) + try: + return result.get(timeout=seconds) + except TimeoutError as e: + return e + return wrapper + return decorator + +def seleccionar_operacion_matematica(): + rand = random.randint(1, 4) + operacion = "" + if rand == 1: + operacion = "+" + elif rand == 2: + operacion = "-" + elif rand == 3: + operacion = "*" + elif rand == 4: + operacion = "/" + else: + operacion = "" + return operacion + +def generar_calculo_aleatorio(nivel_de_dificultad): + valor1 = 0 + valor2 = 0 + + if nivel_de_dificultad == 1: + valor1 = int(random.randint(0,9)) + valor2 = int(random.randint(0,9)) + elif nivel_de_dificultad == 2: + valor1 = int(random.randint(0,99)) + valor2 = int(random.randint(0,9)) + elif nivel_de_dificultad == 3: + valor1 = int(random.randint(0,99)) + valor2 = int(random.randint(0,99)) + elif nivel_de_dificultad == 4: + valor1 = int(random.randint(0,999)) + valor2 = int(random.randint(0,99)) + elif nivel_de_dificultad == 5: + valor1 = int(random.randint(0,999)) + valor2 = int(random.randint(0,999)) + elif nivel_de_dificultad == 6: + valor1 = int(random.randint(0,9999)) + valor2 = int(random.randint(0,999)) + elif nivel_de_dificultad == 7: + valor1 = int(random.randint(0,9999)) + valor2 = int(random.randint(0,9999)) + elif nivel_de_dificultad == 8: + valor1 = int(random.randint(0,99999)) + valor2 = int(random.randint(0,9999)) + elif nivel_de_dificultad == 9: + valor1 = int(random.randint(0,99999)) + valor2 = int(random.randint(0,99999)) + elif nivel_de_dificultad == 10: + valor1 = int(random.randint(0,999999)) + valor2 = int(random.randint(0,99999)) + else: + print("Eres un genio de las matemáticas!\nMejor estudia algo de literatura!") + valor1 = -1 + valor2 = -1 + + operacion = seleccionar_operacion_matematica() + + if operacion == "/" and valor2 == 0: + valor2 = 1 + + return [valor1, operacion, valor2] + +def calcular_respuesta_correcta(valor1, operacion, valor2): + resultado = 0 + if operacion == "+": + resultado = valor1 + valor2 + elif operacion == "-": + resultado = valor1 - valor2 + elif operacion == "*": + resultado = valor1 * valor2 + elif operacion == "/": + resultado = valor1 / valor2 + else: + print("Operación invalida") + return resultado + +@timeout(3) +def leer_respuesta_del_jugador(calculo): + return float(input(str(calculo[0]) + " " + calculo[1] + " " + str(calculo[2]) + " = ")) + +def empiezar_juego_nuevo(): + fin_del_juego = False + respuestas_correctas = 49 + nivel_de_dificultad = 10 + + while fin_del_juego == False: + calculo = generar_calculo_aleatorio(nivel_de_dificultad) + + if calculo[0] < 0: + print("Fin del juego! :D\nTu puntuación: " + str(respuestas_correctas) + " respuestas correctas") + break + + respuesta_del_jugador = leer_respuesta_del_jugador(calculo) + + if isinstance(respuesta_del_jugador, TimeoutError): + fin_del_juego = True + print("\nFin del juego! :(\nTu puntuación: " + str(respuestas_correctas) + " respuestas correctas") + break + + respuesta_correcta = calcular_respuesta_correcta(calculo[0], calculo[1], calculo[2]) + + if respuesta_del_jugador == respuesta_correcta: + respuestas_correctas += 1 + if respuestas_correctas >= (nivel_de_dificultad * 5): + nivel_de_dificultad += 1 + else: + fin_del_juego = True + print("Fin del juego! :(\nTu puntuación: " + str(respuestas_correctas) + " respuestas correctas") + +empiezar_juego_nuevo() + diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/inkhemi.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/inkhemi.py" new file mode 100644 index 0000000000..31fd26f6c7 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/inkhemi.py" @@ -0,0 +1,77 @@ +import random +import threading +import queue +import os + +operations = { + 1: "+", + 2: "-", + 3: "*", + 4: "/" +} + + +def get_input(input_queue): + input_queue.put(float(input("Respuesta: "))) + + +input_queue = queue.Queue() + + +def operations_game(): + ''' + Juego de resolución de operaciones matemáticas básicas con limite de tiempo de 3 segundos. + ''' + + digits_1 = 1 + digits_2 = 1 + questions = 0 + cont = 0 + + while True: + op = random.randint(1, 4) + number_1 = random.randint(0, int("9" * digits_1)) + number_2 = random.randint(0, int("9" * digits_2)) + + if op == 1: + result = number_1 + number_2 + elif op == 2: + result = number_1 - number_2 + elif op == 3: + result = number_1 * number_2 + else: + if number_2 == 0: # Si el divisor es 0, se cambia por 1 para evitar errores + number_2 += 1 + result = number_1 / number_2 + + print(f"{number_1} {operations[op]} {number_2} = ?") + input_thread = threading.Thread(target=get_input, args=(input_queue,)) + input_thread.start() + input_thread.join(timeout=3) + + if input_thread.is_alive(): + print("\nTiempo agotado!") + break + + answer = input_queue.get() + + if answer == result: + print("Correcto!\n") + else: + break + + questions += 1 + cont += 1 + if cont == 5: + if digits_1 == digits_2: + digits_1 += 1 + else: + digits_2 += 1 + cont = 0 + + print(f"Fin del juego \nRespuestas correctas: {questions}") + # Se usa os._exit(0) para terminar el programa cuando se acaba el tiempo + os._exit(0) + + +operations_game() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/jamerrq.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/jamerrq.py" new file mode 100644 index 0000000000..925f02e70c --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/jamerrq.py" @@ -0,0 +1,150 @@ +import random as rd +import sys +from pytimedinput import timedInput + + +class Game: + + def __init__(self, lang='en') -> None: + self.xlevel = 0 + self.ylevel = 0 + self.score = 0 + # User correct hits + self.uhits = 0 + # Limit time to answer (in seconds) + self.limit_time = 5 + self.timed_out = False + self.lang = lang + self.level = 0 + self.prev = 0 + + def generate_random_question(self): + operations = ['+', '-', '*', '/'] + operation = rd.choice(operations) + a = rd.randint(10 ** self.xlevel, 10 ** (self.xlevel + 1)) + b = rd.randint(10 ** self.ylevel, 10 ** (self.ylevel + 1)) + c = 0 + if operation == '+': + c = a + b + elif operation == '-': + c = a - b + elif operation == '*': + c = a * b + elif operation == '/': + c = a // b + + return a, b, c, operation + + def show_game_status(self, current_operation, result_symbol, result_color): + clear() + sys.stdout.write( + f"\033[1;32m🎯 Score {self.score} | ❓ {current_operation} | ⏲️ {self.limit_time}s | 🧮 Level {self.level}\n") + # sys.stdout.write(f"{result_color}{result_symbol}\033[0m ") + # sys.stdout.write("→ ") + + def show_stats(self): + if self.lang == 'es': + print(f'🎯 Tu puntaje: {self.score}') + print(f'🔥 Dificultad: {self.xlevel + self.ylevel + 1}') + print(f'🏆 Respuestas correctas: {self.uhits}') + else: + print(f'\n🎯 Your score: {self.score}') + print(f'🔥 Difficulty: {self.xlevel + self.ylevel + 1}') + print(f'🏆 Correct hits: {self.uhits}') + + def play(self): + while True: + a, b, c, operation = self.generate_random_question() + self.prev = c + + # Show initial game status + self.show_game_status(f"{a} {operation} {b}", "", "") + + x, timedOut = timedInput("→ ", timeout=self.limit_time) + if timedOut: + self.timed_out = True + break + + if x == 'exit': + break + + try: + x = int(x) + + if x == c: + self.uhits += 1 + self.score += self.xlevel + self.ylevel + 1 + else: + break + + except ValueError: + break + + self.show_game_status("", "", "") + # time.sleep(0.5) + + if self.uhits != 0: + # Each 4 levels, give more time to answer + if self.uhits % 4 == 0: + self.limit_time += 1 + if self.uhits % 5 == 0: + self.level += 1 + if self.xlevel > self.ylevel: + self.ylevel += 1 + else: + self.xlevel += 1 + + clear() + if self.timed_out: + if self.lang == 'es': + print('⌛ Se acabó el tiempo 😭') + else: + print('⌛ You ran out of time 😭') + else: + if self.lang == 'es': + print('💀 Respondiste mal 💀') + else: + print('💀 You answered wrong 💀') + + print() + final_message = f'🦃 Respuesta correcta: {self.prev}' if self.lang == 'es' else f'🦃 Correct answer: {self.prev}' + print(final_message) + self.show_stats() + + +def clear(): + sys.stdout.write("\033c") + + +def show_welcome_message(lang='en'): + es_welcome_message = ''' + 🧮 Bienvenido al juego de preguntas matemáticas! 🧮 + + 🤓 Tienes que responder tantas preguntas como puedas. + 🧠 Cada 5 respuestas correctas, la dificultad aumentará. + ❌ Si respondes mal, el juego terminará. + ⏰ Ten cuidado, tienes tiempo limitado para responder cada pregunta! + ➗ Para la división, solo escribe el cociente (parte entera). + ''' + en_welcome_message = ''' + 🧮 Welcome to the math quiz game! 🧮 + + 🤓 You have to answer as many questions as you can. + 🧠 Every 5 correct answers, the difficulty will increase. + ❌ If you answer wrong, the game will end. + ⏰ Be careful, you have limited time to answer each question! + ➗ For division, just write the quotient (integer part). + ''' + + if lang == 'es': + print(es_welcome_message) + input('Presiona cualquier tecla para comenzar 🎮\n') + else: + print(en_welcome_message) + input('Press any key to start 🎮\n') + +if __name__ == '__main__': + clear() + show_welcome_message() + game = Game() + game.play() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/javierfiestasbotella.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/javierfiestasbotella.py" new file mode 100644 index 0000000000..a47aafb39c --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/javierfiestasbotella.py" @@ -0,0 +1,68 @@ +''' + 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''' + +import random +import time + +aciertos = 0 +numero_pregunta = 1 + +while True: + + signo = random.choice(['+', '-', '*', '/']) + + + if numero_pregunta <= 5: + a = random.randint(0, 9) + b = random.randint(0, 9) + elif numero_pregunta > 5 and numero_pregunta <= 10: + a = random.randint(0, 99) + b = random.randint(0, 9) + elif numero_pregunta > 10 and numero_pregunta <= 15: + a = random.randint(10, 99) + b = random.randint(10, 99) + elif numero_pregunta > 15 and numero_pregunta <= 20: + a = random.randint(0, 999) + b = random.randint(0, 99) + + + pregunta = f'{a} {signo} {b} ' + print(pregunta) + inicio_tiempo = time.time() + + try: + + respuesta_usuario = input("Respuesta: ") + resultado = eval(pregunta) + respuesta_usuario = int(respuesta_usuario) + + if respuesta_usuario == resultado: + aciertos += 1 + print("¡Correcto!\n") + else: + print(f"Incorrecto. La respuesta correcta es: {resultado}\n") + break + + except ValueError: + print("Debes ingresar un número válido.\n") + + + tiempo_transcurrido = time.time() - inicio_tiempo + + if tiempo_transcurrido > 3: + print("¡Lo siento, fuera de tiempo... han pasado sus 3 segundos!\n") + break + +print(f"¡Has conseguido {aciertos} aciertos! ¡Suerte la próxima vez!\n") diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/jcdm60.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/jcdm60.py" new file mode 100644 index 0000000000..4eac963a39 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/jcdm60.py" @@ -0,0 +1,95 @@ +# Reto #44: Adivinanzas matemáticas +#### Dificultad: Media | Publicación: 13/11/23 | Corrección: 20/11/23 + +## Enunciado + +# +# 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 +# + +import random +import time + +class GuessingGame: + def __init__(self): + self.level = 1 + self.correct_guesses = 0 + self.time_limit = 3 + + def set_time_limit(self): + try: + self.time_limit = float(input("Ingrese el limite de tiempo de espera para las respuesta (en segundos): ")) + except ValueError: + print("Límite invalido, usaré el límite por defecto de 3 segundos") + + def generate_operation(self): + if self.level <= 5: + x = random.randint(0, 9) + y = random.randint(1, 9) + elif self.level <= 10: + x = random.randint(0, 99) + y = random.randint(1, 9) + elif self.level <= 15: + x = random.randint(0, 99) + y = random.randint(1, 99) + else: + x = random.randint(0, 999) + y = random.randint(1, 99) + + operators = ['+', '-', '*', '/'] + operator = random.choice(operators) + + operation = f"{x} {operator} {y}" + result = eval(operation) if operator != '/' or y != 0 else x + + return operation, result + + def play(self): + self.set_time_limit() + + while self.level <= 20: + print(f"\nPregunta {self.level}:") + operation, correct_result = self.generate_operation() + print(f"Cuál es el resultado de: {operation}?") + + start_time = time.time() + user_answer = input("Respuesta: ") + + if time.time() - start_time > self.time_limit: + print("Tiempo agotado!") + break + + try: + user_answer = eval(user_answer) + except (ValueError, ZeroDivisionError): + print("Respuesta no válida") + continue + + if round(user_answer, 2) == round(correct_result, 2): + print("Correcto!") + self.correct_guesses += 1 + else: + print(f"Incorrecto. La respuesta correcta era: {correct_result}.") + + if self.correct_guesses % 5 == 0: + print(f"\nUsted obtuvo {self.correct_guesses} respuestas correctas! Vamos a aumentar el número de dígitos!") + + self.level += 1 + + print(f"\nFin del juego. Total de respuestas correctas: {self.correct_guesses}") + +if __name__ == "__main__": + game = GuessingGame() + game.play() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/juanppdev.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/juanppdev.py" new file mode 100644 index 0000000000..59598a2653 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/juanppdev.py" @@ -0,0 +1,41 @@ +import random +import time + +def generar_operacion(num_digitos): + num1 = random.randint(0, 10 ** num_digitos - 1) + num2 = random.randint(0, 9) + operadores = ['+', '-', '*', '/'] + operador = random.choice(operadores) + operacion = f"{num1} {operador} {num2}" + return operacion + +def jugar(): + aciertos = 0 + num_digitos = 1 + + while True: + operacion = generar_operacion(num_digitos) + print(f"Calcula: {operacion}") + + start_time = time.time() + respuesta = input("Respuesta: ") + + if time.time() - start_time > 3: + print("¡Tiempo agotado! Fin del juego.") + break + + resultado_correcto = eval(operacion) + + if float(respuesta) == resultado_correcto: + aciertos += 1 + print("¡Correcto!\n") + else: + print(f"Incorrecto. La respuesta correcta era {resultado_correcto}.\n") + + if aciertos % 5 == 0: + num_digitos += 1 + + print(f"Juego finalizado. Aciertos totales: {aciertos}") + +if __name__ == "__main__": + jugar() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/keltoi-dev.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/keltoi-dev.py" new file mode 100644 index 0000000000..aa095eddd0 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/keltoi-dev.py" @@ -0,0 +1,97 @@ +""" +* 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 + """ + +import random +import time + +nivel = 1 + +def establece_nivel(): + global nivel + if nivel <= 5: + x = 9 + y = 9 + elif nivel >5 and nivel <= 10: + x = 99 + y = 9 + elif nivel > 10 and nivel <= 15: + x = 99 + y = 99 + elif nivel > 15: + x = 999 + y = 99 + + return x, y + +def sortea_operacion(): + operacion = random.choice(["+", "-", "*", "/"]) + + return operacion + +def sortea_numeros(x, y, operacion): + operador_1 = random.randint(0, x) + operador_2 = random.randint(0, y) + if operacion == "/" and operador_2 == 0: + operador_2 = random.randint(1, y) + elif operacion == "/" and operador_2 > operador_1: + operador_2 = random.randint(1, operador_1) + pregunta = str(operador_1) + operacion + str(operador_2) + + return pregunta + +def prepara_tablero(): + + x, y = establece_nivel() + + operacion = sortea_operacion() + + pregunta = sortea_numeros(x, y, operacion) + + return pregunta + +def a_jugar(pregunta, tiempo): + global nivel + calculo = eval(pregunta) + ini_tiempo = time.time() + resultado = int(input(f"Cual es el resultado de {pregunta} = ")) + fin_tiempo = time.time() + + if fin_tiempo - ini_tiempo > tiempo: + print("\nHas perdido") + print("Expiro el tiempo") + return False + elif resultado == round(calculo, 0): + nivel += 1 + print(f"La respuesta es correcta, has pasado al nivel {nivel}\n") + return True + else: + print("La respuesta es incorrecta, vuelve a intentarlo\n") + return True + +condicion = True +tiempo = 10 +print("Vamos a jugar!!!") +print(f"Tienes {tiempo} segundos para responder cada operacion matematica.\n") +print(f"Estas en el nivel {nivel}") +print("*" * 25) + +while condicion: + pregunta = prepara_tablero() + condicion = a_jugar(pregunta, tiempo) + +print("*" * 25) +print("El juego se termino!!!") +print(f"Respondiste correctamente {nivel - 1} operaciones\n") diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/mouredev.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/mouredev.py" new file mode 100644 index 0000000000..3689dcf93c --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/mouredev.py" @@ -0,0 +1,69 @@ +import random +import threading + + +def random_int(digits) -> int: + return random.randint(0, 10**digits - 1) + + +def input_with_timeout(): + + def on_timeout(): + print("\n¡El tiempo ha finalizado! Pulsa enter.") + global game_on + game_on = False + + timer = threading.Timer(3, on_timeout) + timer.start() + + try: + answer = input(f"¿Cuál es el resultado de {num1} {operation} {num2}? ") + finally: + timer.cancel() + return answer + + +operations = ["+", "-", "*", "/"] +correct_answers = 0 +num1_digits = 1 +num2_digits = 1 + +game_on = True + +while game_on: + + num1 = random_int(num1_digits) + num2 = random_int(num2_digits) + operation = random.choice(operations) + + if operation == "+": + result = num1 + num2 + elif operation == "-": + result = num1 - num2 + elif operation == "*": + result = num1 * num2 + elif operation == "/": + while num2 == 0: + num2 = random_int(num2_digits) + result = num1 / num2 + result = round(result, 1) + + answer = input_with_timeout() + + if not game_on: + break + elif answer == str(result): + print("Respuesta correcta!") + correct_answers += 1 + + if correct_answers % 5 == 0: + if correct_answers % 2 == 0: + num2_digits += 1 + else: + num1_digits += 1 + + else: + print("Respuesta incorrecta!") + game_on = False + +print(f"Juego finalizado. Has acertado {correct_answers} cálculos.") diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/raulG91.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/raulG91.py" new file mode 100644 index 0000000000..da53240144 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/raulG91.py" @@ -0,0 +1,63 @@ +from random import randint +from threading import Timer +from os import _exit + +def end_game(i): + print(" /\nTiempo!! ") + print("Nº respuestas correctas: " + str(i)) + _exit(0) + +def get_number(num_digits): + #Create a random number with num_digits digits + max_number = (10** num_digits) - 1 + return randint(1,max_number) + + +def game(): + lv_end = False + number_digit1 = 1 + number_digit2 = 1 + num_correct = 0 + + while not(lv_end): + #Get numbers + a = get_number(number_digit1) + b = get_number(number_digit2) + #Calculate operation + random = randint(0,3) + result = 0 + + if random == 0: + result = a + b + print("Operacion: " + str(a) + " + " + str(b)) + elif random == 1: + result = a-b + print("Operacion: " + str(a) + " - " + str(b)) + elif random == 2: + result = a*b + print("Operacion: " + str(a) + " * " + str(b)) + elif random == 3: + result = a//b + print("Operacion: " + str(a) + " / " + str(b)) + #Set a 3 seconds timer + t = Timer(3.0,end_game,[num_correct]) + t.start() + user_input = int(input("Resultado: ")) + t.cancel() + + if result != user_input: + #Incorrect answer --> cancel execution + lv_end = True + else: + num_correct += 1 + + if num_correct % 5 == 0: + #5 questions have been answered correctly + if number_digit1 == number_digit2: + number_digit1 += 1 + elif number_digit2 < number_digit1: + number_digit2 += 1 + print("Nº respuestas correctas: " + str(num_correct)) + + +game() \ No newline at end of file diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/sirnas1983.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/sirnas1983.py" new file mode 100644 index 0000000000..3b3a204d84 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/sirnas1983.py" @@ -0,0 +1,65 @@ +import random +import time + +def operacion_aleatoria(tupla): + a,b = tupla + op = random.randint(1,4) + if op == 1: + res = a + b + signo = '+' + elif op == 2: + res = a - b + signo = '-' + elif op == 3: + res = a * b + signo = 'x' + else: + if b == 0: + b = 1 + res = a // b + signo = '//' + return res, f"{a} {signo} {b} = " + +def operandos_aleatorios(nivel): + exp = nivel//2 + 1 + a = random.randint(1,10**exp) - 1 + if nivel%2==0: + b = random.randint(1,10**(exp -1)) - 1 + else: + b = random.randint(1,10**exp) - 1 + return a, b + +def juego_matematicas(): + jugar = input("¿Quieres jugar? s/n: ").lower() == "s" + tiempo = 5 + nivel = 1 + correctas = 0 + while jugar: + if correctas == 0: + print("¿Preparado?") + print("Nota: En las divisiones ingresar la parte entera unicamente") + time.sleep(0.7) + resp, texto = operacion_aleatoria(operandos_aleatorios(nivel)) + print(texto) + cronom_on = time.time() + guess = float(input("respuesta: ")) + cronom_off = time.time() + vuelta = cronom_off - cronom_on + if vuelta > tiempo: + print(f"Tiempo agotado, tienes {tiempo} seg. para contestar correctamente") + jugar = False + elif guess == resp: + print("¡Respuesta correcta!") + correctas += 1 + if correctas % 5 == 0 and correctas < 16: + nivel += 1 + print(f"¡¡Felicidades, pasaste al nivel {nivel}!!") + else: + print("Respuesta incorrecta") + print(f"La respuesta correcta era {resp}") + jugar = False + if not jugar: + print("Gracias por participar") + print(f"Usted logro {correctas} respuestas correctas") + +juego_matematicas() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/valevil27.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/valevil27.py" new file mode 100644 index 0000000000..9311ffb7c6 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/valevil27.py" @@ -0,0 +1,97 @@ +import os +import random +import sys +import select +from time import sleep +from typing import Callable + +operations: list[tuple[str, Callable[[int, int], int]]] = [ + ("+", lambda x, y: x + y), + ("-", lambda x, y: x - y), + ("⨉", lambda x, y: x * y), + ("÷", lambda x, y: x // y), +] + + +def timed_input(prompt: str, timeout: float = 3.0): + print(prompt, end="", flush=True) + + rlist, _, _ = select.select([sys.stdin], [], [], timeout) + if not rlist: + return None + return sys.stdin.readline().rstrip("\n") + + +def generate_question(x_digits: int, y_digits: int) -> tuple[str, int]: + op_sign, op_func = random.choice(operations) + x = random.randint(0, int("9" * x_digits)) + y = random.randint(0, int("9" * y_digits)) + + if op_sign == "÷" and y == 0: + while y == 0: + y = random.randint(0, int("9" * y_digits)) + + if x < y and x != 0: + x, y = y, x + + return f"[?] {x} {op_sign} {y} = ", op_func(x, y) + + +def handle_player_loses(points): + print(f"[*] You scored {points}!") + + +def handle_difficulty(points: int = 0, x_digits: int = 0, y_digits: int = 0): + if points == 0: + return x_digits, y_digits + if points % 5 == 0: + if points % 2 == 0: + return x_digits, y_digits + 1 + else: + return x_digits + 1, y_digits + return x_digits, y_digits + + +def main(): + print("➕🟰 Welcome to the Ultimate Math Quest! ➖➗") + for i in range(3,0,-1): + print(f"[!] Starting in {i}...") + sleep(1) + print ("\033[A \033[A") + points, x_digits , y_digits = 0, 1, 1 + while True: + # handle digits + x_digits, y_digits = handle_difficulty(points, x_digits, y_digits) + + # question and answer + question, result = generate_question(x_digits, y_digits) + user_input = timed_input(question, 3) + + # if timeout + if not user_input: + print("\n[!] Too Slow! You have been disqualified!") + handle_player_loses(points) + return + + # getting the answer + try: + answer = int(user_input.strip()) + except: + print("[!] Incorret format! You have been disqualified!") + handle_player_loses(points) + return + + # * wrong answer + if answer != result: + print("[!] Game over! Incorrect answer!") + print(f"{question}{result}") + handle_player_loses(points) + return + + # * correct answer + points += 1 + + +if __name__ == "__main__": + os.system("clear") + main() diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/vandresca.py" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/vandresca.py" new file mode 100644 index 0000000000..7afec42446 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/python/vandresca.py" @@ -0,0 +1,91 @@ +""" +/* + * 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 + * ... + */ +""" +from enum import Enum +import random +from inputimeout import inputimeout, TimeoutOccurred + +class Operator(Enum): + ADD = 1 + SUBSTRACT = 2 + MULTIPLY = 3 + DIVIDE = 4 + +class ResultOperation(Enum): + OK = 1 + ERROR_DIV_0 = 2 + +def get_operator(): + rand_operator =random.randint(1,4) + return(Operator(rand_operator)) + +def get_number(digits): + number = 0 + for d in range(digits): + if d == 0: + rand_digit = random.randint(0,9) + else: + rand_digit = random.randint(1,9) + number += 10**d * rand_digit + return number + +def do_operation(digit_op1, digit_op2): + operand_one = get_number(digit_op1) + operand_two = get_number(digit_op2) + operator = get_operator() + match operator: + case Operator.ADD: + print(f"{operand_one} + {operand_two} = ", end="") + return (operand_one + operand_two), ResultOperation.OK + case Operator.SUBSTRACT: + print(f"{operand_one} - {operand_two} = ", end="") + return (operand_one - operand_two), ResultOperation.OK + case Operator.MULTIPLY: + print(f"{operand_one} * {operand_two} = ", end="") + return (operand_one * operand_two), ResultOperation.OK + case Operator.DIVIDE: + if operand_two == 0: + return 0, ResultOperation.ERROR_DIV_0 + print(f"{operand_one} / {operand_two} = ", end="") + return (operand_one / operand_two), ResultOperation.OK + +correct_answers = 0 +digit_op1 = 1 +digit_op2 = 1 + +while True: + guess, isOK = do_operation(digit_op1, digit_op2) + if isOK == ResultOperation.ERROR_DIV_0: + continue + try: + result = inputimeout(prompt='', timeout=10) + except TimeoutOccurred: + print("Perdiste") + break + if round(float(result),2) == round(float(guess),2): + correct_answers += 1 + pack_5answer_count = int(correct_answers / 5) + if correct_answers % 5 == 0 and not pack_5answer_count == 0: + print("Has subido de nivel. Nivel: "+str(pack_5answer_count)) + if pack_5answer_count % 2 == 0: + digit_op2 += 1 + else: + digit_op1 += 1 + else: + print("Perdiste") + break diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/rust/hdescobarh.rs" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/rust/hdescobarh.rs" new file mode 100644 index 0000000000..54e744be88 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/rust/hdescobarh.rs" @@ -0,0 +1,234 @@ +// author: Hans D. Escobar H. (hdescobarh) + +/* +Solución con el mínimo número de bibliotecas externas. + +rand es necesario porque en la biblioteca estándar de Rust no hay herramientas +para generar números aleatorios. + */ + +use std::fmt::Display; +use std::io::{stdout, Write}; +use std::num::ParseIntError; +use std::sync::mpsc::{channel, Receiver, TryRecvError}; +use std::thread; +use std::time::Duration; + +// Biblioteca para la generación de valores aleatorios +use rand::distributions::{Distribution, Standard}; +use rand::rngs::StdRng; +use rand::{Rng, SeedableRng}; + +/// Indica cuanto tiempo (en ms) dura cada tick del juego +pub const TICK_LENGTH: u64 = 1000; +/// Indica los conteos máximos por pregunta. Multiplicado por TICK_LENGTH resulta en el tiempo en ms por pregunta. +pub const MAX_TICKS_PER_QUESTION: usize = 3; + +fn main() { + let mut game = Game::default(); + + // initial question + game.make_question(); + let mut stdout = stdout(); + + // Canal para capturar desde otro hilo el input. + let stdin_rx = stdin_channel(); + let mut ticks: usize = 0; + let clean_line = " ".repeat(20); + + // Ciclo principal del juego + loop { + ticks += 1; + // refresca el stdout + let _ = stdout.write_fmt(format_args!("{clean_line}\r")); + let _ = stdout.write_fmt(format_args!("{game}\ttime: {ticks}s:\t")); + let _ = stdout.flush(); + thread::sleep(Duration::from_millis(TICK_LENGTH)); + + let game_over: bool = if ticks >= MAX_TICKS_PER_QUESTION { + true + } else { + match stdin_rx.try_recv() { + Ok(Ok(answer)) => !game.check_answer(answer), + Ok(Err(_)) => true, + Err(TryRecvError::Empty) => continue, + Err(TryRecvError::Disconnected) => break, + } + }; + + if game_over { + println!("\nGame Over\nScore: {}", game.get_score()); + std::process::exit(0); + } + + game.make_question(); + ticks = 0; + } +} + +fn stdin_channel() -> Receiver> { + let (tx, rx) = channel(); + thread::spawn(move || loop { + let mut input_buffer = String::new(); + std::io::stdin() + .read_line(&mut input_buffer) + .expect("Unexpected error while reading input."); + tx.send(input_buffer.trim().parse::()).unwrap(); + }); + rx +} + +/// Operadores validos a emplear en el juego +pub enum Operator { + Addition, + Subtraction, + Division, + Multiplication, +} + +/// Distribución de probabilidad para generar operadores de forma aleatoria +impl Distribution for Standard { + fn sample(&self, rng: &mut R) -> Operator { + let n: u8 = rng.gen_range(0..=4); + match n { + 0 => Operator::Addition, + 1 => Operator::Subtraction, + 2 => Operator::Division, + _ => Operator::Multiplication, + } + } +} + +/// Implementa el juego y sus normas +pub struct Game { + /// Marcador de puntos. Otorga un punto por cada respuesta correcta. Cada 5 puntos incrementa la dificultad en uno. + score: usize, + /// Indica la dificultad del juego. El número de dígitos totales de cada pregunta es la dificultad + 1. + difficulty_level: usize, + /// Contiene el primer y segundo operando y el operador. + question: (isize, isize, Operator), + /// Contiene el resultado correcto de la operación. + answer: isize, +} + +impl Default for Game { + fn default() -> Self { + Self { + score: 0, + difficulty_level: 1, + question: (0, 0, Operator::Addition), + answer: 0, + } + } +} + +impl Game { + /// Genera una operación valida y su respuesta correcta. + pub fn make_question(&mut self) { + // llama generate_numbers para obtener el par de operando + // = U+003D Equals Sign + let (first_digits, second_digits) = self.generate_operands_digits(); + let first_operand = Self::sample_operand(first_digits); + let second_operand = Self::sample_operand(second_digits); + + let operator = Self::sample_operator(); + let answer: isize = match operator { + Operator::Addition => first_operand + second_operand, + Operator::Subtraction => first_operand - second_operand, + Operator::Division => first_operand / second_operand, + Operator::Multiplication => first_operand * second_operand, + }; + self.answer = answer; + self.question = (first_operand, second_operand, operator); + } + + // Determina los dígitos del primer y segunda operando + fn generate_operands_digits(&self) -> (usize, usize) { + let total_digits: usize = self.difficulty_level + 1; + let second_operand: usize = total_digits / 2; + let first_operand: usize = total_digits - second_operand; + (first_operand, second_operand) + } + + // Obtiene un valor de operador aleatorio entre en el intervalo [0, 9*D], + // donde D es un numero de la forma 1111... conteniendo digit_number dígitos. + fn sample_operand(digit_number: usize) -> isize { + let upper_bound = "9".repeat(digit_number).parse().unwrap(); + // para permitir el cero es necesario agregar un control cuando el divisor es 0. + StdRng::from_entropy().gen_range(1..=upper_bound) + } + + // Escoge aleatoriamente la operación a realizar + fn sample_operator() -> Operator { + StdRng::from_entropy().sample(Standard) + } + + /// Verifica si la respuesta ingresada es correcta. Retorna true sí es correcta. + /// + /// # Argumentos: + /// * `answer` - respuesta ingresada + pub fn check_answer(&mut self, answer: isize) -> bool { + if self.answer == answer { + self.score += 1; + self.update(); + return true; + } + false + } + + // Actualiza los contadores internos + fn update(&mut self) { + if self.score % 5 == 0 { + self.difficulty_level += 1; + } + } + + /// Presenta la tabla de puntuación + pub fn get_score(&self) -> &usize { + &self.score + } +} + +// Implementación de la vista para Game +impl Display for Game { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let operator_str = match self.question.2 { + // U+002B Plus Sign + Operator::Addition => "+", + // U+2212 Minus Sign + Operator::Subtraction => "−", + // U+00F7 Division Sign + Operator::Division => "÷", + // U+00D7 Multiplication Sign + Operator::Multiplication => "×", + }; + + write!( + f, + "{} {} {}", + self.question.0, operator_str, self.question.1 + ) + } +} + +#[cfg(test)] +mod test { + use super::*; + #[test] + fn operand_digits_works() { + let mut game = Game::default(); + assert_eq!((1, 1), game.generate_operands_digits()); + game.difficulty_level = 2; + assert_eq!((2, 1), game.generate_operands_digits()); + game.difficulty_level = 3; + assert_eq!((2, 2), game.generate_operands_digits()); + game.difficulty_level = 4; + assert_eq!((3, 2), game.generate_operands_digits()); + game.difficulty_level = 12; + assert_eq!((7, 6), game.generate_operands_digits()); + game.difficulty_level = 13; + assert_eq!((7, 7), game.generate_operands_digits()); + game.difficulty_level = 81; + assert_eq!((41, 41), game.generate_operands_digits()); + } +} diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/swift/alemohamad.swift" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/swift/alemohamad.swift" new file mode 100644 index 0000000000..5b54b93c19 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/swift/alemohamad.swift" @@ -0,0 +1,81 @@ +import Foundation + +// Este reto solo funciona en línea de comando. +// Se debe llamar usando `swift reto44.swift` para probarlo. +// Es por esta razón que no funciona en Swift Playgrounds. + +func generateOperation(level: Int) -> (String, Int) { + let operations = ["+", "-", "*", "/"] + let selectedOperation = operations.randomElement()! + var operand1: Int + var operand2: Int + + if selectedOperation == "/" { + repeat { + operand1 = Int.random(in: 1...maxByLevel(level)) + operand2 = Int.random(in: 1...maxByLevel(level)) + } while operand1 % operand2 != 0 + } else { + operand1 = Int.random(in: 0...maxByLevel(level)) + operand2 = Int.random(in: 0...maxByLevel(level)) + } + + let question = "\(operand1) \(selectedOperation) \(operand2)" + let answer = evaluateOperation(operand1, operand2, selectedOperation) + + return (question, answer) +} + +func maxByLevel(_ level: Int) -> Int { + switch level { + case 1: return 9 + case 2: return 99 + case 3: return 999 + default: return 9 + } +} + +func evaluateOperation(_ operand1: Int, _ operand2: Int, _ operation: String) -> Int { + switch operation { + case "+": return operand1 + operand2 + case "-": return operand1 - operand2 + case "*": return operand1 * operand2 + case "/": return operand2 != 0 ? operand1 / operand2 : 0 + default: return 0 + } +} + +func startQuestion(question: String, correctAnswer: Int) -> Bool { + print(question) + print("Your answer: ", terminator: "") + let startTime = Date() + + guard let input = readLine() else { + print("No answer was provided.") + return false + } + + guard let userAnswer = Int(input) else { + print("Please enter a valid number.") + return false + } + + let timeElapsed = Date().timeIntervalSince(startTime) + return timeElapsed <= 3 && userAnswer == correctAnswer +} + +var hits = 0 +var level = 1 + +while true { + let (question, correctAnswer) = generateOperation(level: level) + let isCorrect = startQuestion(question: question, correctAnswer: correctAnswer) + + if !isCorrect { + print("Game over. You got \(hits) right.") + break + } else { + hits += 1 + if hits % 5 == 0 { level += 1 } + } +} diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/swift/didacdev.swift" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/swift/didacdev.swift" new file mode 100644 index 0000000000..7553e936a3 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/swift/didacdev.swift" @@ -0,0 +1,119 @@ +import Foundation + +enum Operations { + case sum + case sub + case mul + case div +} + +var rightAnswers = 0 +var finish: Bool = false + +enum MyError: Error { + case runtimeError(String) +} + +func randomOperation() -> Operations { + let random = Int.random(in: 0...3) + switch random { + case 0: + return .sum + case 1: + return .sub + case 2: + return .mul + default: + return .div + } +} + +func operation() -> (String, Int) { + var numberOne = 0 + var numberTwo = 0 + var result = 0 + + do { + numberOne = try getNumber(digits: getDigitsX()) + numberTwo = try getNumber(digits: getDigitsY()) + } catch { + print(error) + } + + let sign = randomOperation() + + switch sign { + case Operations.sum: + result = numberOne + numberTwo + return ("\(numberOne) + \(numberTwo)", result) + case Operations.sub: + result = numberOne - numberTwo + return ("\(numberOne) - \(numberTwo)", result) + case Operations.mul: + result = numberOne * numberTwo + return ("\(numberOne) * \(numberTwo)", result) + case Operations.div: + result = numberOne / numberTwo + return ("\(numberOne) / \(numberTwo)", result) + } + +} + +func getNumber(digits: Int) throws -> Int { + var numberString = "" + + for _ in 1...digits { + let randomNumber = String(Int.random(in:0...9)) + numberString += randomNumber + } + + if let number = Int(numberString) { + return number + } else { + throw MyError.runtimeError("No se ha podido convertir el String en Int") + } +} + +func getDigitsX() -> Int { + + return (((rightAnswers - 1) + 5) / 10 + 1) +} + +func getDigitsY() -> Int { + + return ((rightAnswers - 1) / 10 + 1) +} + +func askQuestion() { + let question = operation() + + print() + print(question.0) + + let semaphore = DispatchSemaphore(value: 0) + + var answer: String? + + DispatchQueue.global().async { + answer = readLine() + semaphore.signal() + } + + if semaphore.wait(timeout: .now() + 3) == .timedOut { + print("Te quedaste sin tiempo 💀") + finish = true + } else if let answer = answer { + if answer == String(question.1) { + rightAnswers += 1 + print("✅ ¡¡Respuesta correcta!!") + print("Llevas \(rightAnswers) puntos") + } else { + print("❌ Error") + finish = true + } + } +} + +while !finish { + askQuestion() +} diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/typescript/johanrestrepo19.ts" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/typescript/johanrestrepo19.ts" new file mode 100644 index 0000000000..1021ff2572 --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/typescript/johanrestrepo19.ts" @@ -0,0 +1,162 @@ +//@ts-ignore +import { stdin as input, stdout as output } from "node:process"; +//@ts-ignore +import { createInterface } from "node:readline/promises"; + +const readLine = createInterface({ input, output }); + +enum Operations { + ADD = "add", + SUBTRAC = "subtrac", + MULTIPLY = "multiply", + DIVIDE = "divide", +} + +type Question = { + x: number; + y: number; + operation: Operations; + operationSign?: string; + result: number; +}; + +const getRandomEnumKey = (someEnum: T): T[keyof T] => { + const enumKeys = Object.values(someEnum); + const randomIndex = Math.floor(Math.random() * enumKeys.length); + return enumKeys[randomIndex]; +}; + +class Game { + private _answeredQuestionAmm: number; + private _currentQuestion?: Question; + private _nextIncrement: "x" | "y"; + private _digitsX: number; + private _digitsY: number; + + constructor() { + this._answeredQuestionAmm = 0; + this._digitsX = this._digitsY = 10; + this._nextIncrement = "x"; + } + + get currentQuestion() { + return this._currentQuestion; + } + + get answeredQuestionAmm() { + return this._answeredQuestionAmm; + } + + private calculateDigists() { + if (this._answeredQuestionAmm > 0 && this._answeredQuestionAmm % 5 === 0) { + if (this._nextIncrement === "x") { + this._digitsX = this._digitsX * 10; + this._nextIncrement = "y"; + } else if (this._nextIncrement === "y") { + this._digitsY = this._digitsY * 10; + this._nextIncrement = "x"; + } + } + } + + generateQuestion(): void { + this.calculateDigists(); + + const x = Math.floor(Math.random() * this._digitsX); + const y = Math.floor(Math.random() * this._digitsY); + const operation = getRandomEnumKey(Operations); + let operationSign = ""; + let result = 0; + + switch (operation) { + case Operations["ADD"]: + result = x + y; + operationSign = "+"; + break; + case Operations["SUBTRAC"]: + result = x - y; + operationSign = "-"; + break; + case Operations["MULTIPLY"]: + result = x * y; + operationSign = "*"; + break; + case Operations["DIVIDE"]: + result = x / y; + result = Number(result.toFixed(2)); + operationSign = "/"; + break; + } + + this._currentQuestion = { x, y, operation, result, operationSign }; + } + + validateAnswer(answer: number): boolean { + if (this.currentQuestion?.result === answer) { + this._answeredQuestionAmm++; + return true; + } + return false; + } +} + +const showQuestion = (question: Question): void => { + console.log( + `Resultado de la siguiente operación: ${question.x} ${question.operationSign} ${question.y}?`, + ); +}; + +const waitAnswerForAmmTime = ( + timeToWait = 3000, +): Promise<{ value: number; hasAnswered: boolean }> => { + const ac = new AbortController(); + + return new Promise(async (resolve) => { + const timeOutId = setTimeout(() => ac.abort(), timeToWait); + + try { + const userAnswer = Number( + await readLine.question("Ingrese su respuesta: ", { + signal: ac.signal, + }), + ); + clearTimeout(timeOutId); + if (isNaN(userAnswer)) throw Error; + resolve({ value: userAnswer, hasAnswered: true }); + } catch { + resolve({ value: NaN, hasAnswered: false }); + } + }); +}; + +const showGameOver = (answeredQuestions: number) => { + console.log(); + console.log("No has respondido correctamente "); + console.log( + `Lograste responder correctamente ${answeredQuestions} preguntas`, + ); +}; + +const main = async () => { + console.clear(); + const game = new Game(); + + while (true) { + game.generateQuestion(); + if (game.currentQuestion) showQuestion(game.currentQuestion); + + try { + const userAnswer = await waitAnswerForAmmTime(); + if (!userAnswer.hasAnswered) break; + const isValidAnswer = game.validateAnswer(userAnswer.value); + if (!isValidAnswer) break; + } catch (error) { + console.error(error); + } + console.log(); + } + + showGameOver(game.answeredQuestionAmm); +}; + +main(); diff --git "a/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/typescript/luishendrix92.ts" "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/typescript/luishendrix92.ts" new file mode 100644 index 0000000000..72b7f467cc --- /dev/null +++ "b/Retos/Reto #44 - ADIVINANZAS MATEM\303\201TICAS [Media]/typescript/luishendrix92.ts" @@ -0,0 +1,154 @@ +// Run it yourself +// ========================================================= +// https://replit.com/@luishendrix92/Reto44MoureDev#index.ts + +import * as readline from "readline"; +import { exit } from "process"; + +const STATISTICS_MSG = (correct: number, total: number) => + `You answered ${correct}/${total} questions correctly!`; +const WRONG_ANSWER_MSG = "❌ Your answer is wrong; better luck next time."; +const RIGHT_ANSWER_MSG = "✅ Congratulations! your answer was correct."; +const TIMEOUT_MSG = "⌛ Sorry, you took more than 3 seconds to answer."; +const TIME_BETWEEN_QUESTIONS = 1_500; +const MAX_TIME = 3_000; + +type BinaryOp = (a: number, b: number) => number; +type Operator = "+" | "-" | "*" | "/"; + +interface Question { + operator: Operator; + argA: number; + argB: number; +} + +const operations: Record = { + "+": (a, b) => a + b, + "-": (a, b) => a - b, + "/": (a, b) => a / b, + "*": (a, b) => a * b, +}; + +const sleep = (time: number) => + new Promise((resolve) => setTimeout(resolve, time)); + +const choice = (items: T[]): T => { + const randomIndex = Math.floor(Math.random() * items.length); + + return items[randomIndex]; +}; + +const randInt = (digits: number) => + Math.floor(Math.random() * Math.pow(10, digits)); + +const digitsPair = (rightAnswersCount: number) => { + const digCount = Math.floor(rightAnswersCount / 5) + 1; + const turn = digCount % 2 === 0; + + /** + * Every 5 right answers, digCount will grow by 1, and whether digit A + * or B grow by 1 depends on if digCount is odd or pair. And since + * we're working with 2 values, we divide by 2. */ + return [ + (digCount + Number(turn) + 1) / 2, + (digCount + Number(!turn)) / 2 + ]; +}; + +function* questionGenerator(): Generator { + let rightAnswerCount = 0; + + while (true) { + const [argA, argB] = digitsPair(rightAnswerCount).map(randInt); + const operator = choice(Object.keys(operations)) as Operator; + + rightAnswerCount = yield { argA, operator, argB }; + } +} + +const formatQuestion = ({ argA, operator, argB }: Question) => { + const prompt = `How much is ${argA} ${operator} ${argB}?`; + + return ` + .${"_".repeat(prompt.length)}. +{ ${prompt} } + \\${"-".repeat(prompt.length)}/ + \\ + \\ \\_\\_ _/_/ + \\ \\__/ + (oo)\\_______ + (__)\\ )\\/\\ + ||----w | + || || + +Your answer: `; +}; + +function askQuestion({ argA, operator, argB }: Question): Promise { + const rightAnswer = Math.floor(operations[operator](argA, argB)); + const promptMsg = formatQuestion({ operator, argA, argB }); + + /** + * NOTE: Readline and cancellation mechanism sources + * ================================================= + * https://stackoverflow.com/questions/66318202/how-to-abort-a-readline-interface-question + * https://nodejs.org/api/readline.html#rlquestionquery-options-callback + */ + const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout + }); + + return new Promise((resolve, reject) => { + const ac = new AbortController(); + const signal = ac.signal; + const timeout = setTimeout(() => ac.abort(), MAX_TIME); + + signal.addEventListener('abort', () => { + rl.close(); + reject(new Error(TIMEOUT_MSG)); + }); + + rl.question(promptMsg, { signal }, (answer: string) => { + clearTimeout(timeout); + rl.close(); + resolve(Number(answer) === rightAnswer); + }); + }); +} + +// NOTE: Bear in mind emojis use variable charater spaces. +const fmtMsg = (msg: string) => ` +┌─${"─".repeat(msg.length)}──┐ +│ ${msg} │ +└─${"─".repeat(msg.length)}──┘ +`; + +async function main() { + let [questionCount, rightAnswerCount] = [0, 0]; + const questions = questionGenerator(); + + while (true) { + console.clear(); + + try { + const isRightAnswer = await askQuestion( + questions.next(rightAnswerCount).value + ); + + questionCount++; + console.log(fmtMsg(isRightAnswer ? RIGHT_ANSWER_MSG : WRONG_ANSWER_MSG)); + isRightAnswer && rightAnswerCount++; + + await sleep(TIME_BETWEEN_QUESTIONS); + } catch (error) { + // HACK: Typescript needs the IF in order to access .message + if (error instanceof Error) console.log(fmtMsg(error.message)); + + console.log(STATISTICS_MSG(rightAnswerCount, questionCount)); + exit(0); + } + } +} + +main(); diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/DrDavidRenes.cs" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/DrDavidRenes.cs" new file mode 100644 index 0000000000..209f4b40b1 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/DrDavidRenes.cs" @@ -0,0 +1,123 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DrDavidRenes +{ + class Program + { + static List participantes = new List(); + static Random random = new Random(); + + static void Main(string[] args) + { + + while (true) + { + MostrarMenu(); + string opcion = Console.ReadLine().ToLower(); + + switch (opcion) + { + case "1": + AñadirParticipante(); + break; + case "2": + MostrarParticipantes(); + break; + case "3": + EliminarParticipante(); + break; + case "4": + RealizarSorteo(); + break; + case "5": + Console.WriteLine("¡Hasta luego!"); + return; + default: + Console.WriteLine("Opción no válida. Por favor, selecciona una opción válida."); + break; + } + } + } + + static void MostrarMenu() + { + Console.WriteLine("===== Menú ====="); + Console.WriteLine("1. Añadir participante"); + Console.WriteLine("2. Mostrar participantes"); + Console.WriteLine("3. Eliminar participante"); + Console.WriteLine("4. Realizar sorteo"); + Console.WriteLine("5. Salir"); + Console.Write("Selecciona una opción: "); + } + + static void AñadirParticipante() + { + Console.Write("Introduce el nombre del participante: "); + string nombre = Console.ReadLine(); + + if (participantes.Contains(nombre)) + { + Console.WriteLine("¡Error! Este participante ya existe."); + } + else + { + participantes.Add(nombre); + Console.WriteLine($"¡{nombre} ha sido añadido correctamente!"); + } + } + + static void MostrarParticipantes() + { + Console.WriteLine("===== Participantes ====="); + if (participantes.Count == 0) + { + Console.WriteLine("No hay participantes registrados."); + } + else + { + foreach (var participante in participantes) + { + Console.WriteLine(participante); + } + } + } + + static void EliminarParticipante() + { + Console.Write("Introduce el nombre del participante a eliminar: "); + string nombre = Console.ReadLine(); + + if (participantes.Contains(nombre)) + { + participantes.Remove(nombre); + Console.WriteLine($"¡{nombre} ha sido eliminado correctamente!"); + } + else + { + Console.WriteLine("¡Error! Este participante no existe."); + } + } + + static void RealizarSorteo() + { + if (participantes.Count == 0) + { + Console.WriteLine("¡Error! No hay participantes para realizar el sorteo."); + } + else + { + int indiceGanador = random.Next(participantes.Count); + string ganador = participantes[indiceGanador]; + + Console.WriteLine($"¡El ganador del sorteo es: {ganador}!"); + participantes.RemoveAt(indiceGanador); + } + } + } +} + + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/bielsesa.cs" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/bielsesa.cs" new file mode 100644 index 0000000000..86592d494f --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/bielsesa.cs" @@ -0,0 +1,161 @@ +namespace RetosProgramacion +{ + internal class Program + { + public static void Main(string[] args) + { + new Adeviento().GestionaSorteo(); + } + } + + internal class Adeviento + { + private List participantes = new(); + + public void GestionaSorteo() + { + Console.WriteLine("#¡Buenas! Bienvenide al programa de selección de ganadores para el calendario de aDEViento 2023.#"); + string? seleccion; + do + { + Console.WriteLine(""" + =============================================================================================== + Selecciona una opción: + 1 - Mostrar participantes + 2 - Añadir participante + 3 - Eliminar participante + 4 - Realizar sorteo + 0 - Salir + =============================================================================================== + """); + seleccion = Console.ReadLine(); + + switch (seleccion) + { + case "1": + MostrarParticipantes(true); + break; + case "2": + AñadirParticipante(); + break; + case "3": + EliminarParticipante(); + break; + case "4": + RealizarSorteo(); + break; + default: + continue; + } + + } + while (seleccion != null && !seleccion.Equals("0")); + + Console.WriteLine("#¡Que tengas un buen día!#"); + Console.WriteLine("Presiona ENTER para salir ..."); + Console.ReadLine(); + } + + private void MostrarParticipantes(bool clearConsoleOnEnter) + { + if (clearConsoleOnEnter) Console.Clear(); + if (!participantes.Any()) + { + Console.WriteLine("No hay participantes actualmente."); + } + else + { + Console.WriteLine("Participantes:"); + participantes.ForEach(Console.WriteLine); + } + ContinueAndClearConsole(); + } + + private void AñadirParticipante() + { + Console.Clear(); + Console.WriteLine("Escribe el nombre del participante a añadir."); + string? participante; + + do + { + participante = Console.ReadLine(); + } + while (string.IsNullOrWhiteSpace(participante)); + + if (participantes.Contains(participante)) + { + Console.WriteLine("Este participante ya existe."); + ContinueAndClearConsole(); + return; + } + + participantes.Add(participante); + Console.WriteLine($"Se ha añadido correctamente a {participante}."); + MostrarParticipantes(false); + } + + private void EliminarParticipante() + { + Console.Clear(); + + if (!participantes.Any()) + { + Console.WriteLine("No hay ningún participante, así que no se puede eliminar ninguno."); + ContinueAndClearConsole(); + } + else + { + Console.WriteLine("¿Qué participante quieres eliminar?"); + Console.WriteLine("(Si quieres ver la lista de participantes antes, escribe 0 a continuación)"); + var participante = Console.ReadLine(); + + if (participante.Equals("0")) + { + participantes.ForEach(Console.WriteLine); + Console.WriteLine(""" + ------------------------------------ + Escribe el participante a eliminar:" + ------------------------------------ + """); + participante = Console.ReadLine(); + } + + if (string.IsNullOrWhiteSpace(participante) || !participantes.Contains(participante)) + { + Console.WriteLine("Este participante no se encuentra en la lista."); + ContinueAndClearConsole(); + return; + } + + participantes.Remove(participante); + Console.WriteLine($"Se ha eliminado correctamente a {participante}"); + + MostrarParticipantes(false); + } + } + + private void RealizarSorteo() + { + Console.Clear(); + if (!participantes.Any() || participantes.Count == 1) + { + Console.WriteLine($"No se puede realizar el sorteo con {participantes.Count} participante{(participantes.Count == 1 ? string.Empty : "s")}."); + } + else + { + var ganador = participantes[new Random().Next(0, participantes.Count)]; + Console.WriteLine($"The winner is {ganador}!"); + participantes.Remove(ganador); + } + ContinueAndClearConsole(); + } + + private static void ContinueAndClearConsole() + { + Console.WriteLine("Presiona ENTER para continuar."); + Console.ReadLine(); + Console.Clear(); + } + } +} diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/deathwing696.cs" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/deathwing696.cs" new file mode 100644 index 0000000000..80f8667986 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/deathwing696.cs" @@ -0,0 +1,165 @@ +/* + * Conoces el calendario de aDEViento de la comunidad (https://adviento.dev)? + * 24 das, 24 regalos sorpresa relacionados con desarrollo de software. + * Desde el 1 al 24 de diciembre. + * + * Crea un programa que simule el mecanismo de participacin: + * - Mediante la terminal, el programa te preguntar si quieres aadir y borrar + * participantes, mostrarlos, lanzar el sorteo o salir. + * - Si seleccionas aadir un participante, podrs escribir su nombre y pulsar enter. + * - Si seleccionas aadir un participante, y este ya existe, avisars de ello. + * (Y no lo duplicars) + * - Si seleccionas mostrar los participantes, se listarn todos. + * - Si seleccionas eliminar un participante, podrs escribir su nombre y pulsar enter. + * (Avisando de si lo has eliminado o el nombre no existe) + * - Si seleccionas realizar el sorteo, elegirs una persona al azar + * y se eliminar del listado. + * - Si seleccionas salir, el programa finalizar. + */ + +using System; +using System.Collections.Generic; +using System.ComponentModel.Design; +using System.Text.RegularExpressions; +using System.Threading; + +namespace reto45 +{ + public class Reto45 + { + static void Main(string[] args) + { + int opcion; + List participantes = new List(); + + do + { + opcion = Menu(); + + switch (opcion) + { + case 0: + break; + + case 1: + Append_participante(participantes); + break; + + case 2: + Delete_participante(participantes); + break; + + case 3: + Console.WriteLine("Lista de participantes:"); + + foreach (var participante in participantes) + { + Console.WriteLine(participante.ToString()); + } + + break; + + case 4: + Realizar_sorteo(participantes); + break; + + default: + Console.WriteLine("Opcin invlida, por favor introduzca una opcin vlida (Del 0 al 4)"); + opcion = 5; + break; + + } + } while (opcion != 0); + + Console.WriteLine("Adioooooos!"); + Console.ReadKey(); + } + + private static int Menu() + { + string cadena; + + Console.WriteLine("*************************************************************"); + Console.WriteLine("** Bienvenido al calendario de aDEViento Qu desea hacer? **"); + Console.WriteLine("** 1. Aadir participante **"); + Console.WriteLine("** 2. Borrar participante **"); + Console.WriteLine("** 3. Mostrar lista de participantes **"); + Console.WriteLine("** 4. Lanzar el sorteo **"); + Console.WriteLine("** 0. Salir **"); + Console.WriteLine("*************************************************************"); + + cadena = Console.ReadLine(); + + if (Int32.TryParse(cadena, out int opcion)) + { + return opcion; + } + else + { + Console.WriteLine("Opcin invlida, por favor introduzca una opcin vlida (Del 0 al 4)"); + return Menu(); + } + } + + private static void Append_participante(List participantes) + { + string participante, pattern = "^[a-zA-Z--0-9_.]+$"; + Regex regex = new Regex(pattern); + + Console.Write("Introduce el nombre del nuevo participante:"); + participante = Console.ReadLine(); + + if (regex.IsMatch(participante)) + { + if (participantes.Contains(participante)) + { + Console.WriteLine("El participante ya existe en la lista"); + } + else + { + participantes.Add(participante); + Console.WriteLine("Participante aadido"); + } + } + else + { + Console.WriteLine("Por favor, introduzca un nombre de usuario vlido compuesto por letras, nmeros o los caracteres \"_\" o \".\""); + } + } + + private static void Delete_participante(List participantes) + { + string participante; + + Console.WriteLine("Introduce el nombre del participante a eliminar"); + participante = Console.ReadLine(); + + if (participantes.Remove(participante)) + { + Console.WriteLine($"Participante {participante} eliminado con xito"); + } + else + { + Console.WriteLine($"El participante {participante} no existe en la lista y no ha podido ser eliminado"); + } + } + + private static void Realizar_sorteo(List participantes) + { + Random random = new Random(); + int ganador; + + if (participantes.Count > 0) + { + Console.Write("Se va a proceder a realizar el sorteo...el ganador es..."); + ganador = random.Next(0, participantes.Count-1); + Thread.Sleep(3000); + Console.WriteLine($"{participantes[ganador]}"); + } + else + { + Console.WriteLine("No se puede lanzar el sorteo, la lista est vaca, por favor, introduce, al menos, un participante"); + } + } + } +} \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/miquelcie.cs" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/miquelcie.cs" new file mode 100644 index 0000000000..dcd819d50c --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c#/miquelcie.cs" @@ -0,0 +1,171 @@ +/* + * ¿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á. + */ +using System; +using static System.Runtime.InteropServices.JavaScript.JSType; + +namespace reto45 +{ + public class Reto45 + { + static void Main(string[] args) + { + Concurso concurso = new Concurso(); + Concurso.Option option = Concurso.Option.Inicio; + + + while (option != Concurso.Option.Salir) + { + option = concurso.ShowMenu(); + switch (option) + { + case Concurso.Option.Mostrar: + concurso.Mostrar(); + break; + case Concurso.Option.Anadir: + concurso.Anadir(); + break; + case Concurso.Option.Borrar: + concurso.Borrar(); + break; + case Concurso.Option.Lanzar: + concurso.Lanzar(); + break; + default: + break; + } + + } + } + + public class Concurso + { + private List participantes; + + public Concurso() + { + participantes = new List(); + } + + public void Lanzar() + { + Console.WriteLine("\n********* Sorteo ****************"); + Random random = new Random(); + int indiceAleatorio = random.Next(0, participantes.Count); + string nombreParticipante = participantes[indiceAleatorio]; + Console.WriteLine($"¡¡El ganador es {nombreParticipante}!!"); + + participantes.Remove(nombreParticipante); + + Console.WriteLine("*********************************\n"); + + Continuar(); + } + + private static void Continuar() + { + Console.WriteLine("Pulse una tecla para continuar"); + Console.ReadLine(); + } + + public void Borrar() + { + Console.WriteLine("\n********* Borrar participante ****************"); + Console.Write("Introduzca su nombre: "); + string nombreParticipante = Console.ReadLine(); + if (!string.IsNullOrWhiteSpace(nombreParticipante) && participantes.Contains(nombreParticipante)) + { + participantes.Remove(nombreParticipante); + Console.WriteLine($"El participante {nombreParticipante} se ha borrado"); + } + else + { + Console.WriteLine("¡¡El participante no existe!!"); + } + Console.WriteLine("*************************************************\n"); + + Continuar(); + } + + public void Anadir() + { + Console.WriteLine("\n********* Añadir participante ****************"); + Console.Write("Introduzca su nombre: "); + string nombre = Console.ReadLine(); + if (!participantes.Contains(nombre)) + { + participantes.Add(nombre); + } + else + { + Console.WriteLine("¡¡Participante ya existe!!"); + } + Console.WriteLine("*************************************************\n"); + + Continuar(); + } + + public void Mostrar() + { + + Console.WriteLine("\n********* Lista de participantes ****************"); + foreach (string participante in participantes) + { + Console.WriteLine(participante); + } + + Console.WriteLine("*************************************************\n"); + + Continuar(); + } + + public Option ShowMenu() + { + Console.Clear(); + + Console.WriteLine("\n*************************"); + Console.WriteLine("0. Salir"); + Console.WriteLine("1. Mostrar participantes"); + Console.WriteLine("2. Añadir participante"); + Console.WriteLine("3. Borrar participante"); + Console.WriteLine("4. Lanzar sorteo"); + Console.WriteLine("*************************\n"); + Console.Write("Elija una opción: "); + Option option = (Option)Enum.Parse(typeof(Option), Console.ReadLine()); + if (!Enum.IsDefined(typeof(Option), option)) + { + Console.WriteLine("¡¡Opcion no permitida!!"); + } + + return option; + + } + + public enum Option + { + Inicio = -1, + Salir = 0, + Mostrar = 1, + Anadir = 2, + Borrar = 3, + Lanzar = 4 + } + } + } + +} \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c++/exanderguitar.cpp" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c++/exanderguitar.cpp" new file mode 100644 index 0000000000..7780e90ee3 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/c++/exanderguitar.cpp" @@ -0,0 +1,137 @@ +#include +#include +#include + +int main() { + std::vector contestants {}; + + bool exitFlag {false}; + + while(!exitFlag) { + std::cout << "Sorteo Calendario de Adviento\n"; + std::cout << "=============================\n"; + std::cout << '\n'; + std::cout << "Selecciona una opcion.\n"; + std::cout << " 1. Nuevo participante.\n"; + std::cout << " 2. Borrar participante.\n"; + std::cout << " 3. Mostrar lista de participantes.\n"; + std::cout << " 4. Realizar sorteo.\n"; + std::cout << " 5. Salir.\n"; + std::cout << "\n >> "; + + int selection {}; + std::cin >> selection; + + std::cout << '\n'; + + switch(selection) { + case 1: + { + std::cout << "Cual es el nombre del participante?\n"; + std::cout << ">> "; + + std::string userName {}; + std::cin >> userName; + + bool userExists {false}; + + for(size_t i = 0; i < contestants.size(); i++) { + if(userName == contestants[i]) { + userExists = true; + } + } + + if(userExists) { + std::cout << "Este usuario ya existe.\n"; + } + else { + contestants.push_back(userName); + } + } + + std::cout << '\n'; + + break; + + case 2: + { + std::cout << "Que participante quieres borrar?\n"; + std::cout << ">> "; + + std::string userName {}; + std::cin >> userName; + + bool userExists {false}; + + for(size_t i = 0; i < contestants.size(); i++) { + if(userName == contestants[i]) { + contestants.erase(contestants.begin() + i); + userExists = true; + } + } + + std::cout << '\n'; + + userExists ? + std::cout << "El nombre ha sido borrado.\n" : + std::cout << "Este participante no existe.\n"; + + std::cout << '\n'; + } + break; + + case 3: + std::cout << "Esta es la lista de participantes.\n"; + std::cout << "==================================\n"; + + if(contestants.empty()) { + std::cout << "Aun no hay participantes.\n"; + } + else { + for(size_t i = 0; i < contestants.size(); i++) { + std::cout << contestants[i] << '\n'; + } + } + + std::cout << '\n'; + + break; + + case 4: + { + if(!contestants.empty()) { + std::cout << "Empieza el sorteo.\n"; + std::cout << '\n'; + std::cout << "El ganador es: "; + + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution numGenerator(0, contestants.size()); + int randomNumber = numGenerator(gen); + + std::cout << contestants[randomNumber] << '\n'; + + contestants.erase(contestants.begin() + randomNumber); + } + else { + std::cout << "No hay participantes para el sorteo.\n"; + } + + std::cout << '\n'; + } + break; + + case 5: + std::cout << "Hasta pronto"; + exitFlag = true; + break; + + default: + std::cout << "No te entinedo.\n"; + break; + } + + } + + return 0; +} diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/ejercicio.md" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/ejercicio.md" new file mode 100644 index 0000000000..92de45c51b --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/ejercicio.md" @@ -0,0 +1,30 @@ +# Reto #45: El calendario de aDEViento 2023 +#### Dificultad: Fácil | Publicación: 20/11/23 | Corrección: 27/11/23 + +## Enunciado + +``` +/* + * ¿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á. + */ +``` +#### 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)**. \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/go/blackriper.go" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/go/blackriper.go" new file mode 100644 index 0000000000..d15f768886 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/go/blackriper.go" @@ -0,0 +1,129 @@ +package main + +import ( + "fmt" + "math/rand" +) + +/*interfaces de trabajo*/ +type Adev interface { + ShowMenuOptions() +} + +type ParticipanCrud interface { + AddParticipan(name string) + ShowParticipans() + DeleteParticipan(name string) + HoldaDraw() +} + +/*Implementar interface para acciones de los participantes*/ + +type Hold struct { + Participans []string +} + +func (h *Hold) AddParticipan(name string) { + if exists := ExistParticipan(h.Participans, name); exists == false { + h.Participans = append(h.Participans, name) + fmt.Printf("participant %v successfully added\n", name) + } else { + fmt.Printf("participan %v already exists\n", name) + } +} + +func (h *Hold) ShowParticipans() { + fmt.Println("+++Register participans aDEViento+++") + for _, participan := range h.Participans { + fmt.Println(participan) + } +} +func (h *Hold) DeleteParticipan(name string) { + if exists := ExistParticipan(h.Participans, name); exists == true { + indx := GetIndex(h.Participans, name) + h.Participans = append(h.Participans[:indx], h.Participans[indx+1:]...) + fmt.Printf("participan %v delete successfully\n", name) + } else { + fmt.Printf("participan %v not exists \n", name) + } +} + +func (h *Hold) HoldaDraw() { + random := rand.Intn(len(h.Participans)) + winner := h.Participans[random] + h.Participans = append(h.Participans[:random], h.Participans[random+1:]...) + fmt.Printf("Congratulations %v you winner a prieze\n", winner) +} + +/*funciones auxilares*/ +func GetIndex(participans []string, name string) int { + indx := 0 + for ind, parparticipan := range participans { + if parparticipan == name { + indx = ind + } + } + return indx +} + +func ExistParticipan(participans []string, name string) bool { + for _, part := range participans { + if name == part { + return true + } + } + return false +} + +/* implementar metodos para mostrar menu de opciones*/ +type ADEViento struct { + Adev ParticipanCrud +} + +func (ad *ADEViento) ShowMenuOptions() { + var ( + option int + name string + ) +adviento: + for { + fmt.Println("************************") + fmt.Println("Welcome hold ADEViento") + fmt.Println("**************************") + fmt.Println("1.-Add participan") + fmt.Println("2.-Show participans") + fmt.Println("3.-Delete participan") + fmt.Println("4.-Hold a Draw") + fmt.Println("5.-Exit to program") + + fmt.Println("Enter a number to perform an action: ") + fmt.Scanf("%d", &option) + + switch option { + + case 1: + fmt.Println("What is name for a new participian?") + fmt.Scanf("%s", &name) + ad.Adev.AddParticipan(name) + case 2: + ad.Adev.ShowParticipans() + case 3: + fmt.Println("What is name for delete participan?") + fmt.Scanf("%s", &name) + ad.Adev.DeleteParticipan(name) + case 4: + ad.Adev.HoldaDraw() + case 5: + break adviento + } + + } + +} + +func main() { + var crudpart ParticipanCrud = &Hold{} + var adev Adev = &ADEViento{Adev: crudpart} + adev.ShowMenuOptions() + +} diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/java/nilcasane.java" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/java/nilcasane.java" new file mode 100644 index 0000000000..64fe89ca93 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/java/nilcasane.java" @@ -0,0 +1,96 @@ +package challenge_45; + +import java.util.Random; +import java.util.Scanner; + +public class Challenge_45 { + + public static void main (String[]args) { + + Scanner read = new Scanner(System.in); + Random alea = new Random(); + + int id; + String participantes[]; + String accion, nombre; + boolean cerrar = false; + + participantes = new String [0]; + + while (!cerrar) { + System.out.print("Indica la acción que deseas realizar: "); + accion = read.nextLine(); + System.out.println(); + switch (accion) { + case "añadir": + System.out.print("\tIntroduce el nombre del participante que deseas añadir: "); + nombre = read.nextLine(); + System.out.println(); + id = buscarParticipante(participantes,nombre); + if(id<0) { + participantes = añadirParticipante(participantes, nombre); + System.out.println("\t\tParticipante añadido"); + } else { + System.out.println("\t\tEl participante ya existe!"); + } + break; + case "borrar": + System.out.print("\tIntroduce el nombre del participante que deseas borrar: "); + nombre = read.nextLine(); + System.out.println(); + id = buscarParticipante(participantes,nombre); + if(id<0) { + System.out.println("\t\tEl participante no existe!"); + } else { + participantes = borrarParticipante(participantes,id); + System.out.println("\t\tParticipante borrado"); + } + break; + case "mostrar": + System.out.println("\tEste es el listado de participantes: \n"); + for(id = 0; id { + console.log('\nSelecciona una opción:'); + console.log('1. Añadir participante'); + console.log('2. Mostrar participantes'); + console.log('3. Eliminar participante'); + console.log('4. Realizar sorteo'); + console.log('5. Salir'); + + // eslint-disable-next-line no-use-before-define + askOption(); +}; + +const addParticipant = () => { + rl.question('\nIntroduce el nombre del participante: ', (name) => { + if (participants.includes(name)) { + console.log('Este participante ya existe.'); + } else { + participants.push(name); + console.log('Participante añadido con éxito.'); + } + showMenu(); + }); +}; + +const showParticipants = () => { + console.log('\nLista de participantes:'); + participants.forEach((participant, index) => { + console.log(`${index + 1}. ${participant}`); + }); + showMenu(); +}; + +const removeParticipant = () => { + rl.question('\nIntroduce el nombre del participante a eliminar: ', (name) => { + const index = participants.indexOf(name); + if (index !== -1) { + participants.splice(index, 1); + console.log('Participante eliminado con éxito.'); + } else { + console.log('Este participante no existe.'); + } + showMenu(); + }); +}; + +const drawWinner = () => { + if (participants.length === 0) { + console.log('\nNo hay participantes para realizar el sorteo.'); + } else { + const winnerIndex = Math.floor(Math.random() * participants.length); + const winner = participants[winnerIndex]; + console.log(`\n¡El ganador es: ${winner}!`); + participants.splice(winnerIndex, 1); + } + showMenu(); +}; + +const askOption = () => { + const menuOptions = { + 1: addParticipant, + 2: showParticipants, + 3: removeParticipant, + 4: drawWinner, + 5: () => rl.close(), + }; + + rl.question('Opción: ', (option) => (menuOptions[option] || (() => { + console.log('\nOpción no válida. Inténtalo de nuevo.'); + showMenu(); + }))()); +}; + +showMenu(); + +// Visita mi repo en GitHub para ver y correr los tests de este código --> https://github.com/marcode24/weekly-challenges diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/javascript/othamae.js" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/javascript/othamae.js" new file mode 100644 index 0000000000..ca61322cc3 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/javascript/othamae.js" @@ -0,0 +1,82 @@ +/* + * ¿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('readline') +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout +}) + +function aDEViento(){ + console.log("Welcome to aDEViento!!") + console.log("Please, select an action from the list:") + console.log("a - Add a participant") + console.log("r - Remove a participant") + console.log("s - Show the list of participants") + console.log("d - Draw the lottery") + console.log("e - Exit") + const listOfParticipants = [] + game() + function game(){ + rl.question("What do you want to do? ", (answer) => { + if (answer.toLowerCase() === 'a'){ + rl.question("Please, write the name of the participant: ", (answer) => { + if (listOfParticipants.includes(answer.toLowerCase())){ + console.log("This participant is already in the list") + } else { + listOfParticipants.push(answer.toLowerCase()) + console.log("Participant added successfully") + } + game() + }) + } else if (answer.toLowerCase() === 'r'){ + rl.question("Please, write the name of the participant to be removed: ", (answer) => { + if (!listOfParticipants.includes(answer.toLowerCase())){ + console.log("This participant is not in the list") + } else { + const index = listOfParticipants.indexOf(answer.toLowerCase()) + listOfParticipants.splice(index, 1) + console.log("This participant has been removed from the list") + } + game() + }) + } else if (answer.toLowerCase() === 's'){ + console.log("Here is the list of participants:") + console.log(listOfParticipants) + game() + } else if (answer.toLowerCase() === 'd'){ + const randomNumber = Math.floor(Math.random() * listOfParticipants.length) + const winner = listOfParticipants[randomNumber] + console.log({randomNumber, winner}) + console.log(`The winner is ${winner}`) + listOfParticipants.splice(randomNumber, 1) + game() + } else if (answer.toLowerCase() === 'e'){ + console.log("See you later!!") + rl.close() + } else { + console.log("Please, select a valid option") + game() + } + }) + } + +} + +aDEViento() \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/kotlin/Mariopolonia0.kt" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/kotlin/Mariopolonia0.kt" new file mode 100644 index 0000000000..eb9a119341 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/kotlin/Mariopolonia0.kt" @@ -0,0 +1,108 @@ +package EjercicioKotlin.Mouredev + +class Reto45_ElCalendarioDeAdeviento { + + var listaParticipantes: MutableList = mutableListOf("mario", "eskerni", "jaziel", "polonia") + + init { + var stop = false + + while (stop == false) { + when (menu()) { + 1 -> { + agregarParticipante() + } + + 2 -> { + borrarParticipante() + } + + 3 -> { + listarParticipante() + } + + 4 -> { + realizarSorteo() + } + + 5 -> { + stop = true + } + + else -> { + println("Opcion no existe") + } + + } + } + } + + private fun agregarParticipante() { + println("\n\n") + println("---------Agrega Participante---------") + print("Digite el nombre:") + + val nombre = readln() + + //el contains busca si hay un nombre igual en la lista + if (listaParticipantes.contains(nombre)) { + println("Participante ya esta en la lista") + } else { + listaParticipantes.add(nombre) + println("Participante agregado") + } + } + + private fun realizarSorteo() { + println("\n\nEl ganador es :${listaParticipantes.random()}") + listaParticipantes = mutableListOf() + println("\n\nSe limpio la lista") + } + + private fun borrarParticipante() { + println("\n\n") + println("---------Borrar Participante---------") + print("Digite el nombre:") + + val nombre = readln() + + //el contains busca si hay un nombre igual en la lista + if (listaParticipantes.contains(nombre)) { + listaParticipantes.remove(nombre) + println("Participante borrado de la lista") + } else { + println("Participante no esta en la lista") + } + } + + private fun listarParticipante() { + var item = 1 + + println("\n\n----Lista de participante----") + + listaParticipantes.map { + println("${item}.${it}") + item++ + } + } + + private fun menu(): Int { + var select = 0 + + println("\n\n") + println("---------Menu---------") + println("1.Agregar participante") + println("2.Borrar participante") + println("3.Mostrar") + println("4.Realizar Sorteo") + println("5.Salir") + print("Seleccione una opcion:") + select = readLine()!!.toInt() + + return select + } +} + +fun main() { + Reto45_ElCalendarioDeAdeviento() +} diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/kotlin/pisanowp.kt" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/kotlin/pisanowp.kt" new file mode 100644 index 0000000000..7aae09ce26 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/kotlin/pisanowp.kt" @@ -0,0 +1,153 @@ +package retos2023 + +fun main() { + + /* + * Reto #45 20/11/2023 EL CALENDARIO DE ADEVIENTO 2023 + * + * ¿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: + * - [X] Mediante la terminal, el programa te preguntará si quieres añadir y borrar + * participantes, mostrarlos, lanzar el sorteo o salir. + * - [X] Si seleccionas añadir un participante, podrás escribir su nombre y pulsar enter. + * - [X] Si seleccionas añadir un participante, y este ya existe, avisarás de ello. + * (Y no lo duplicarás) + * - [X] Si seleccionas mostrar los participantes, se listarán todos. + * - [X] Si seleccionas eliminar un participante, podrás escribir su nombre y pulsar enter. + * (Avisando de si lo has eliminado o el nombre no existe) + * - [X] Si seleccionas realizar el sorteo, elegirás una persona al azar + * y se eliminará del listado. + * - [X] Si seleccionas salir, el programa finalizará. + * + */ + + val cal = CalendarioADeviento() + cal.menu() + + +} + +class CalendarioADeviento() { + + private val participantes: MutableList = mutableListOf() + + fun menu() { + + var opcion = 0 + while (opcion != 5) { + println() + println("1 - Añadir participante") + println("2 - Borrar participante") + println("3 - Listar participantes") + println("4 - Realizar sorteo") + println("5 - Salir") + opcion = pideNumeroPositivo("Elige una opción") + + when (opcion) { + 1 -> addParticipante() + 2 -> borrarParticipante() + 3 -> listarParticipantes() + 4 -> realizarSorteo() + 5 -> println("Fin") + else -> println("Opción no válida") + } + + } + + } + + fun realizarSorteo() { + if (participantes.isEmpty()) { + println("Aún no hay participantes en la lista. Añade alguno antes de realizar el sorteo") + + } else { + println("El ganador es ${participantes.random()} ¡¡ENHORABUENA!!") + } + + } + + fun listarParticipantes() { + if (participantes.isEmpty()) { + println("Aún no hay participantes en la lista.") + + } else { + println("Lista de participantes") + participantes.forEach() { + println(it) + + } + + } + } + + fun borrarParticipante() { + val participante = pedirNombreParticipante("Introduce el participante a añadir") + if (participantes.contains(participante)) { + participantes.remove(participante) + println("$participante eliminado a la lista de participantes.") + + } else { + println("$participante NO ESTA en la lista de participantes.") + + } + + + } + + fun addParticipante() { + val participante = pedirNombreParticipante("Introduce el participante a añadir") + if (participantes.contains(participante)) { + println("$participante YA ESTA en la lista de participantes.") + } else { + participantes.add(participante) + println("$participante añadido a la lista de participantes.") + } + } + + + fun pedirNombreParticipante(pregunta: String): String { + + var valido = false + var input: String? = null + + while (!valido) { + print("$pregunta >") + input = readLine() + if (input != null) { + valido = true + } + } + + return input!! + + } + + fun pideNumeroPositivo( etiqueta : String): Int { + var numero: Int? = null + var valido = false + + while (!valido) { + print("Introduce $etiqueta >") + val input = readLine() + + try { + numero = input?.toInt() + if (numero != null) { + if (numero > 0){ + valido = true + } else { + println("Entrada inválida. Debes ingresar un número entero positivo.") + } + } + + } catch (e: NumberFormatException) { + println("Entrada inválida. Debes ingresar un número entero positivo.") + } + } + return numero!! + } + +} \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Engleonardorm7.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Engleonardorm7.py" new file mode 100644 index 0000000000..b3dc33ffff --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Engleonardorm7.py" @@ -0,0 +1,56 @@ +# /* +# * ¿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á. +# */ +import random +option=0 +participantes=[] +while option!="5": + option=input(""" + 1. Añadir + 2. Mostrar + 3. Borrar + 4. Lanzar sorteo + 5. Salir + + """) + + + if option == "1": + newparticipant=input("Escribe el nombre del participante") + if newparticipant in participantes: + print("El participante ya esta registrado") + else: + participantes.append(newparticipant) + + + elif option == "2": + print("Estos son los participantes: ") + for each in participantes: + print(each) + elif option == "3": + participant=input("Escribe el nombre del participante a eliminar") + if participant in participantes: + participantes.remove(participant) + print("Participante eliminado") + else: + print("El participante no esta registrado") + elif option=="4": + winer= random.choice(participantes) + print(f"El ganador es: {winer}") + participantes.remove(winer) + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Hool45.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Hool45.py" new file mode 100644 index 0000000000..3a2a8458eb --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Hool45.py" @@ -0,0 +1,98 @@ +""" +¿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á. + */ +""" + + + + + + + +import random +listaparticipantes = list() + +def adeviento(): + + what_you_wanna_do = input("que quieres hacer ") + + if what_you_wanna_do == "add": + Añadido = input("nombre del añadido: ") + if len(listaparticipantes) == 0: + listaparticipantes.append(Añadido) + print(listaparticipantes) + else: + for i in range(0, len(listaparticipantes)): + print(i) + print(len(listaparticipantes)) + name = listaparticipantes[i] + if Añadido == name: + print("ese nombre ya esta añadido") + adeviento() + + + listaparticipantes.append(Añadido) + print(listaparticipantes) + + adeviento() + + elif what_you_wanna_do == "eliminate": + elim = input("nombre del eliminado: ") + if len(listaparticipantes) == 0: + print("no hay nadie participando") + else: + for i in range(0, len(listaparticipantes)): + print(i) + name = listaparticipantes[i] + print(name) + if elim == name: + listaparticipantes.remove(listaparticipantes[i]) + adeviento() + + print("ese nombre no existe") + + adeviento() + + elif what_you_wanna_do == "sort": + if len(listaparticipantes) == 1: + print("no hay suficientes participantes, añadelos") + else: + sorteo = random.randint(0,len(listaparticipantes) - 1) + print(sorteo) + ganador = listaparticipantes[sorteo] + print(f"EL GANADOR DEL SORTEO {ganador}") + listaparticipantes.remove(listaparticipantes[sorteo]) + + adeviento() + elif what_you_wanna_do == "close": + print("OK closing up") + iniciador() + else: + print("ese no es un comando") + adeviento() + +def iniciador(): + Abrir = input("quieres abrir el programa' Y/N ") + if Abrir == "Y": + adeviento() + elif Abrir == "N": + print( ":(") + + + +iniciador() \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/KevinED11.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/KevinED11.py" new file mode 100644 index 0000000000..deccf3d807 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/KevinED11.py" @@ -0,0 +1,132 @@ +from dataclasses import dataclass, field +from typing import Protocol +from random import randint +import time +from abc import abstractmethod, abstractproperty + + +class ParticipationMecanism(Protocol): + participants: list[str] = [] + running: bool = False + + @abstractmethod + def add(self, participant: str) -> None: + ... + + @abstractmethod + def delete(self, participant: str) -> None: + ... + + @abstractmethod + def show(self) -> None: + ... + + @abstractmethod + def run_giveaway(self) -> str: + ... + + @abstractmethod + def run(self) -> None: + ... + + +def user_input(prompt: str) -> str: + return input(prompt).lower() + + +@dataclass +class AdevientoParticipationMecanism(ParticipationMecanism): + participants: list[str] = field(default_factory=list) + running: bool = field(default=False) + + def add(self, participant: str) -> None: + if participant in self.participants: + print(f"El participante '{participant}' ya existe en la lista.") + return + + self.participants += [participant] + print(f"El participante '{participant}' ha sido añadido con éxito.") + + def delete(self, participant: str) -> None: + if participant not in self.participants: + print(f"El participante '{participant}' no existe en la lista.") + return + + print(f"El participante '{participant}' ha sido eliminado con éxito.") + self.participants.remove(participant) + + def show(self) -> None: + if not self.participants: + print("No hay participantes registrados.") + return + + print("Lista de participantes:") + for participant in self.participants: + print(participant) + + def run_giveaway(self) -> str: + if not self.participants: + print("No hay participantes para realizar el sorteo.") + return + + time.sleep(3) + giveaway_winner = self.participants[randint(0, len(self.participants) - 1)] + + self.delete(giveaway_winner) + print(f"El ganador del sorteo es: {giveaway_winner}") + return giveaway_winner + + def get_options(self) -> dict[str, callable]: + add_option = lambda: self.add( + user_input("Introduce el nombre del participante a añadir: ") + ) + delete_option = lambda: self.delete( + user_input("Introduce el nombre del participante a eliminar: ") + ) + return { + "1": add_option, + "2": delete_option, + "3": self.show, + "4": self.run_giveaway, + "5": self.exit, + } + + def run(self) -> None: + self.running = True + options = self.get_options() + while self.running: + print( + "1. Añadir participante, 2. Eliminar participante, 3. Mostrar participantes, 4. Realizar sorteo, 5. Salir" + ) + option = user_input("Opcion: ") + if option not in options: + print("Opcion no valida") + continue + + result = options[option]() + if isinstance(result, bool) and result: + self.running = False + break + + def exit(self) -> bool: + self.running = False + print("¡Que tengas un buen dia, hasta luego!") + return True + + +@dataclass +class Program: + participation_mechanism: ParticipationMecanism + + def run(self) -> None: + self.participation_mechanism.run() + + +def main(participation_mechanism: ParticipationMecanism) -> None: + program = Program(participation_mechanism=participation_mechanism) + program.run() + + +if __name__ == "__main__": + participation_mechanism = AdevientoParticipationMecanism() + main(participation_mechanism=participation_mechanism) diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Miguelmdv.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Miguelmdv.py" new file mode 100644 index 0000000000..18d9025658 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Miguelmdv.py" @@ -0,0 +1,67 @@ + +# * ¿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á. + +import random as rd + + +def calendario(df: set, eliminados: set): + salir = True + while salir: + respuesta = input( + "1 -> Añadir participante, 2 -> mostrar participantes, 3 -> Eliminar participante, 4 -> Realizar sorteo, 5 -> Salir\ + \n> " + ) + + match respuesta: + case "1": + dato = input("Nombre participante: ") + if dato not in df: + df.add(dato) + else: + print("Este participante ya existe") + + case "2": + if len(df): + for i, name in enumerate(df): + print(f"{i+1}.{name}") + else: + print("No hay participantes") + + case "3": + dato = input("Nombre participante: ") + if dato in df: + df.remove(dato) + eliminados.add(dato) + print(dato, "se ha eliminado correctamente") + elif dato in eliminados: + print("Este participante ya ha sido eliminado") + else: + print("Este participante no existe") + + case "4": + eliminado = rd.choice(list(df)) + eliminados.add(eliminado) + df.remove(eliminado) + print(eliminado, "ha ganado! Y por lo tanto ha sido eliminado") + + case "5": + salir = False + print("Adios") + + case _: + print("Dato no valido") + + +df = set() +eliminados = set() + +calendario(df, eliminados) diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/PandorasActor0.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/PandorasActor0.py" new file mode 100644 index 0000000000..b849f5685a --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/PandorasActor0.py" @@ -0,0 +1,85 @@ +# Reto #45: El calendario de aDEViento 2023 +#### Dificultad: Fácil | Publicación: 20/11/23 | Corrección: 27/11/23 + +## Enunciado + +# +# ¿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á. +# + +import random + +class Opciones: + def __init__(self): + self.Participantes = [] + + def addparticipante(self,Nombre): + if Nombre in self.Participantes: + print("El participante ya esta concursando") + else: + self.Participantes.append(Nombre) + print("Se agrego correctamente el participante {0}".format(Nombre)) + + def eliminarParticipante(self,Nombre): + if Nombre in self.Participantes: + print("El participante {0} se elimino".format(Nombre)) + self.Participantes.remove(Nombre) + else: + print("El participante {0} No se encuentra registrado".format(Nombre)) + + def mostrarParticipantes(self): + if self.Participantes: + print(self.Participantes) + else: + print("No tienes participantes registrados") + + def sorteo(self): + if self.Participantes: + ganador = random.choice(self.Participantes) + print("El ganador es: {0}".format(ganador)) + self.Participantes.remove(ganador) + else: + print("No tiene participantes") + +if __name__ == '__main__': + opciones = Opciones() + + while True: + print("\nmenu:") + print("1. Agregar participante") + print("2. Eliminar Participante") + print("3. Mostrar Participantes") + print("4. Realziar sorteo") + print("5. Salir") + + opcion = input("Seleciona una opcion (1-5) : ") + + menu = { + "1": lambda : opciones.addparticipante(input("Ingrese el Nombre del participante ")), + "2": lambda : opciones.eliminarParticipante(input("Ingrese el Nombre del participante ")), + "3": opciones.mostrarParticipantes, + "4": opciones.sorteo, + "5": lambda: print("¡Hasta Luego!") or exit(), + } + + + accion = menu.get(opcion, lambda: print("Opcion no valida.")) + + accion() + + input("Presione Enter para continuar...") \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/PushoDev.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/PushoDev.py" new file mode 100644 index 0000000000..bd028212a2 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/PushoDev.py" @@ -0,0 +1,98 @@ +# Reto #45: El calendario de aDEViento 2023 +# Dificultad: Fácil | Publicación: 20/11/23 | Corrección: 27/11/23 +#----------------------------------------------------------------- +# ENUNCIADO DEL EJERCICIO +#----------------------------------------------------------------- +# /* +# * ¿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á. +#----------------------------------------------------------------- + +import random + + +print ("Pushodev") +print ("https://github.com/PushoDev") + +class CalendarioAdvento: + def __init__(self): + self.participantes = [] + + def agregar_participante(self, nombre): + if nombre in self.participantes: + print(f"{nombre} ya está en la lista de participantes.") + else: + self.participantes.append(nombre) + print(f"{nombre} ha sido añadido a la lista.") + + def mostrar_participantes(self): + if not self.participantes: + print("No hay participantes en la lista.") + else: + print("Lista de participantes:") + for participante in self.participantes: + print(participante) + + def eliminar_participante(self, nombre): + if nombre in self.participantes: + self.participantes.remove(nombre) + print(f"{nombre} ha sido eliminado de la lista.") + else: + print(f"{nombre} no existe en la lista de participantes.") + + def realizar_sorteo(self): + if not self.participantes: + print("No hay participantes para realizar el sorteo.") + else: + participante_ganador = random.choice(self.participantes) + print(f"¡El ganador del sorteo es: {participante_ganador}!") + self.participantes.remove(participante_ganador) + +# Función principal +def calendario_advento(): + calendario = CalendarioAdvento() + + while True: + print("\n--- Calendario de aDEViento 2023 ---") + print("1. Añadir participante") + print("2. Mostrar participantes") + print("3. Eliminar participante") + print("4. Realizar sorteo") + print("5. Salir") + + opcion = input("Seleccione una opción (1-5): ") + + if opcion == "1": + nombre_participante = input("Ingrese el nombre del participante: ") + calendario.agregar_participante(nombre_participante) + elif opcion == "2": + calendario.mostrar_participantes() + elif opcion == "3": + nombre_participante = input("Ingrese el nombre del participante a eliminar: ") + calendario.eliminar_participante(nombre_participante) + elif opcion == "4": + calendario.realizar_sorteo() + elif opcion == "5": + print("Saliendo del programa. ¡Hasta luego!") + break + else: + print("Opción no válida. Por favor, seleccione una opción del 1 al 5.") + +# Ejecutar el programa +calendario_advento() + +print("Gracias por Participar......") \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Rusian69.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Rusian69.py" new file mode 100644 index 0000000000..deff53fbee --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/Rusian69.py" @@ -0,0 +1,91 @@ +""" + * ¿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á. +""" +import random +def aDEVinteo(): + name_list = [] + name = "" + print("Bienvenidos a sistema de participacion aDEViemto\naqui tenemos las opciones de ingresar [y/o] eliminar participantes-[1], ver la lista de los mismos-[2] o lazar el sorteo-[3]\ncualquier otra opcion cerrara el programa.") + orden = (input("ingrese su opcion basado en los numero: ")) + + if orden == "1": + participants_text = open("participants.text", "r+") + work_line = participants_text.readlines() + print(f"estos son los participantes actuales: {work_line}") + + print("vas a ingresar un nuevo participante[I] o vas a eliminar[D] un participante.") + respont = input(":") + + if respont == "i": + print("ingrese los nombre a ingresar en la lista separados una coma [,]: ") + insertion = input(":") + for index in insertion: + if index != ",": + name += index + else: + name_list.append(name) + name = "" + name_list.append(name) + name = "" + + elif respont == "d": + name_list = work_line + print("escriba el nombres a retirar separados por un espacio: ") + insertion = input() + for index in insertion: + if index != " ": + name += index + else: + name_list.remove(name+"\n") + name = "" + name_list.remove(name+"\n") + name = "" + else: + print("Obcion no valida, el programa se reiniciara para eviar errores") + aDEVinteo() + complete_list = work_line.extend(index for index in name_list if index not in work_line) + print(f"la lista de participante actual es: {complete_list}") + + participants_text = open("participants.text", "w") + for name in complete_list: + participants_text.write(name + "\n") + participants_text.close() + + elif orden == "2": + participants_text = open("participants.text") + name_list = participants_text.readlines() + name_list_temp=[] + for index in name_list: + name_list_temp.append(index.replace("\n", "")) + print(f"la lista de participante es: {name_list_temp}") + participants_text.close() + + elif orden == "3": + participants_text = open("participants.text", "r+") + work_line = participants_text.readlines() + result = random.choice(work_line) + print(f"EL GANADOR EN EL SORTEO aDEViento es: {result}\nEste se eliminara del listado para las siguientes rifas") + work_line.remove(result) + participants_text = open("participants.text", "w") + + for index in work_line: + participants_text.write(index) + participants_text.close() + else: + exit() +aDEVinteo() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/ajloinformatico.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/ajloinformatico.py" new file mode 100644 index 0000000000..991f483502 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/ajloinformatico.py" @@ -0,0 +1,229 @@ +import os +import random + +""" +/* + * ¿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á. + */ +""" + +APP_NAME = """ +####################################### + Lottery + + by infolojo + https:://infolojo.es + Antonio José Lojo Ojeda +####################################### +""" + +class Competitor: + def __init__(self, id: int, name: str): + self.id = id + self.name = name + +class ErrorMessages: + def __init__(self): + self.no_competitors: str = "There are not registered competitors yet" + self.id_type_error: str = "Error: I think that was not an id" + self.not_found: str = "Competitor not found" + self.empty_name: str = "Competitor name can not be empty" + self.duplicated: str = "We have a competitor registered with this name" + +class Lottery: + def __init__(self, competitors: list = list(), lastId = 0): + self.commands: str = """ +Please select a command (id or name): + 0. commands + 1. add + 2. remove + 3. list + 4. Play + 5. exit + """ + self.currentLottery: int = 0 + self.lastId: int = lastId + self.app_name: str = APP_NAME + self.error_manager: ErrorMessages = ErrorMessages() + self.competitors: list = competitors + + # region main class methods + def start(self): + self.start + + def clear(self): + # uncomment by checking your or + # clear windows screen + os.system('CLS') + # clear linux screen + # os.system('clear') + + def add(self, competitor: Competitor): + self.competitors.append(competitor) + + def remove(self, idOrName: str): + id: int = -1 + name: str = "" + + try: + id = int(idOrName) + except: + name = idOrName.lower().capitalize() + + for competitor in self.competitors: + if competitor.id == id or name == competitor.name: + print(competitor.name + " has been removed") + self.competitors.remove(competitor) + return + + print(self.error_manager.not_found) + + def are_competitors_empty(self): + if (len(self.competitors) == 0): + print(self.error_manager.no_competitors) + return True + return False + + def check_if_exists(self, name: str): + for competitor in self.competitors: + if competitor.name == name: + print(self.error_manager.duplicated) + return True + return False + # endregion main class methods + + # region menu actions + def print_commands(self): + print(self.commands) + + def print_competitors(self): + if self.are_competitors_empty(): + return + + print("Registered competitors:\n") + for competitor in self.competitors: + print(str(competitor.id) + "-" + competitor.name) + + def create_new_user(self, id: int): + name: str = input(">>> Input new competitor name: ").lower().capitalize() + if name == "": + print(self.error_manager.empty_name) + return + if self.check_if_exists(name): + return + + new_competitor = Competitor(id, name) + self.add(new_competitor) + print(f"\n {name} has been added") + + def remove_competitor(self): + if self.are_competitors_empty(): + return + + print(f">>> Input id or name competitor that you want to remove:\n") + self.print_competitors() + competitorToRemove: str = input("\n>>> ") + self.remove(competitorToRemove) + + def play(self): + if self.are_competitors_empty(): + return + winner = random.choice(self.competitors) + print(f"The winner of {self.currentLottery} is {winner.name}") + self.currentLottery += 1 + + def exit(self): + print("\n Thanks for using and See you soon \n") + exit(-1) + + # endregion menu actions + + # region main loop + def start(self): + self.clear() + print(APP_NAME) + self.print_commands() + while (True): + userInput: str = input("\n>>> Select one option ") + + if userInput == "0" or userInput == "commands": + self.clear() + self.print_commands() + + elif userInput == "1" or userInput == "add": + self.clear() + self.lastId += 1 + self.create_new_user(self.lastId) + + elif userInput == "2" or userInput == "remove": + self.clear() + self.remove_competitor() + + elif userInput == "3" or userInput == "list": + self.clear() + self.print_competitors() + + elif userInput == "4" or userInput == "play": + self.clear() + self.play() + + elif userInput == "5" or userInput == "exit": + self.clear() + self.exit() + + else: + self.clear() + print("not a valid input") + + print("\n-Remmember 0 to print commands-") + # endregion main loop + + +def seeder(): + return Lottery( + [ + Competitor( + 1, + "Juan" + ), + Competitor( + 2, + "Maria" + ), + Competitor( + 3, + "Alicia" + ), + Competitor( + 4, + "Toni" + ), + Competitor( + 5, + "Euge" + ) + ], + 5 + ) + + +if __name__ == "__main__": + # If you want to use mock uncomment this and comment next app = Lottery() + # app = seeder() + app = Lottery() + app.start() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/alexg1t.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/alexg1t.py" new file mode 100644 index 0000000000..020aeef05a --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/alexg1t.py" @@ -0,0 +1,106 @@ +# """ +# * ¿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á. +# """ + +import sqlite3 +import random + +#CREAR BASE DE DATOS +# Conectar a base de datos o crear si no existe +conn = sqlite3.connect('participantes.db') +# Crear un cursor +cursor = conn.cursor() +# Crear una tabla +cursor.execute('''CREATE TABLE IF NOT EXISTS participantes (nombre VARCHAR(50))''') + + +#FUNCIONES READ/UPDATE/DELETE +# Insertar participante +def a_participante(nombre): + # Comprobar si el participante ya existe + cursor.execute("SELECT * FROM participantes WHERE nombre=?", (nombre,)) + if cursor.fetchone() is not None: + print("Ya existe el participante") + # Si no existe, añadirlo + else: + cursor.execute("INSERT INTO participantes VALUES (?)", (nombre,)) + print("Participante añadido") +# Eliminar participante +def rm_participante(nombre): + # Comprobar si el participante existe + cursor.execute("SELECT * FROM participantes WHERE nombre=?", (nombre,)) + if cursor.fetchone() is not None: + cursor.execute("DELETE FROM participantes WHERE nombre=?", (nombre,)) + print("Participante eliminado") + # Si no existe, mostrar mensaje + else: + print("No existe el participante") +# Mostrar participantes +def m_participante(): + # Comprobar si hay participantes + cursor.execute("SELECT * FROM participantes") + participants = cursor.fetchall() + if participants: + print("Participantes:") + for participant in participants: + print(participant[0]) + else: + print("No hay participantes") +# Elegir participante ganador +def get_ganador(): + cursor.execute("SELECT * FROM participantes") + participantes = cursor.fetchall() + # Si hay participantes, elegir uno al azar y eliminarlo + if participantes: + winner = random.choice(participantes) + cursor.execute("DELETE FROM participantes WHERE nombre=?", (winner[0],)) + print("El ganador:", winner[0]) + # Si no hay participantes, mostrar mensaje + else: + print("No hay participantes") + +while True: + print("\n--- Menú ---") + print("1. Agregar participante") + print("2. Remover participante") + print("3. Mostrar participantes") + print("4. Elegir ganador") + print("5. Salir") + print("------------") + el = input("Elige opción (1-5): ") + + if el == "1": + nombre = input("Ingresa nombre del participante a añadir: ") + a_participante(nombre) + elif el == "2": + nombre = input("Ingresa nombre del participante a eliminar: ") + rm_participante(nombre) + elif el == "3": + m_participante() + elif el == "4": + get_ganador() + elif el == "5": + break + else: + print("Elije una opción válida") + +# Cerrar conexión +conn.commit() +conn.close() + + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/angiedylexx.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/angiedylexx.py" new file mode 100644 index 0000000000..1b47dd4b24 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/angiedylexx.py" @@ -0,0 +1,59 @@ +import random + +class calendarioAdvento: + def __init__(self): + self.participantes = [] + def mostrar_menu(self): + print("1. Añadir participante") + print("2. Mostrar participantes") + print("3. Eliminar participante") + print("4. Realizar sorteo") + print("5. SALIR") + + def añadirParticipante(self, nombre): + nombre = nombre.lower() + if nombre not in self.participantes: + self.participantes.append(nombre) + print (f"Participante {nombre} añadido") + else : + print ("El participante ya existe") + + def mostrarParticipantes(self): + print("Participantes:") + print("\n".join(self.participantes)) #Join(), concatena los nobres con una salto de linea + + def eliminarParticipante(self, nombre): + if nombre in self.participantes: + self.participantes.remove(nombre) + print (f"Participante {nombre} eliminado") + else : + print ("El participante no encontrado") + + def realizarSorteo(self): + if not self.participantes: + print("No hay participantes para realizar el sorteo") + else: + random.shuffle(self.participantes) + ganador = self.participantes.pop() + print(f"¡El participante ganador es: {ganador}!") + +calendario = calendarioAdvento() + +while True: #puesto solo se sale , al oprimir salir + + calendario.mostrar_menu() + seleccion = input("Selecciona una opción (1-5):") + + if seleccion == "1": + calendario.añadirParticipante(input("Introduce el nombre del participante: ")) + elif seleccion == "2": + calendario.mostrarParticipantes() + elif seleccion == "3": + calendario.eliminarParticipante(input("Introduce el nombre del participante a eliminar: ")) + elif seleccion == "4": + calendario.realizarSorteo() + elif seleccion == "5": + print("¡Hasta luego!") + break + else: + print("Opción no válida. Intentalo de nuevo") \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/danivendetta.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/danivendetta.py" new file mode 100644 index 0000000000..e916d077cd --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/danivendetta.py" @@ -0,0 +1,74 @@ +from random import randint +from pprint import pprint + +participantes = [] +def menu(): + print("Opciones:") + print("1: Añadir participante") + print("2: Eliminar participante") + print("3: Listar participantes") + print("4: Realizar sorteo") + print("5: Salir") + + op = input("Selecciona una opción: ") + while op not in ["1", "2", "3", "4", "5"]: + print(f'{op} no es una opción válida, vuelve a intentarlo!') + op = input("Selecciona una opción: ") + + return op + +def add_participante(participante: str): + if participante in participantes: + print(f'{participante} ya está en la lista de participantes') + else: + participantes.append(participante) + print(f'{participante} añadido a la lista de participantes') + +def del_participante(participante: str): + if participante not in participantes: + print(f'{participante} no está en la lista de participantes') + else: + participantes.remove(participante) + print(f'{participante} eliminado de la lista de participantes') + +def list_participantes(): + pprint(participantes) + +def realizar_sorteo(): + if len(participantes) == 0: + print("Primero debes añadir usuarios a la lista de participantes") + else: + ganador = participantes[randint(0, len(participantes)-1)] + print(f'El participante ganador ha sido: {ganador}') + del_participante(ganador) + +if __name__ == "__main__": + op = menu() + while op != "5": + if op == "1": + print("1: Añadir participante") + participante = input("Participante: ") + add_participante(participante) + op = menu() + elif op == "2": + print("2: Eliminar participante") + participante = input("Participante: ") + del_participante(participante) + op = menu() + elif op == "3": + print("3: Listar participantes") + list_participantes() + op = menu() + elif op == "4": + print("4: Realizar sorteo") + realizar_sorteo() + op = menu() + else: + print("5: Salir") + + print("Exit!!") + + + + + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/drifterDev.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/drifterDev.py" new file mode 100644 index 0000000000..6301d920e3 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/drifterDev.py" @@ -0,0 +1,82 @@ +import random + +class App: + def __init__(self): + self.persons = [] + + def add(self, person): + if person not in self.persons: + self.persons.append(person) + return True + else: + return False + + def delete(self, person): + if person in self.persons: + self.persons.remove(person) + return True + else: + return False + + def lottery(self): + if len(self.persons) == 0: + return None + choice = random.choice(self.persons) + self.persons.remove(choice) + return choice + + def show(self): + if len(self.persons) == 0: + print("No hay participantes") + return + print("Participantes:") + for p in self.persons: + print(p) + +def main(): + app = App() + menu = """ + Selecciona una opcion: + 1. Anadir participante + 2. Eliminar participante + 3. Mostrar participantes + 4. Realizar sorteo + 5. Salir + """ + while True: + print(menu) + try: + option = int(input("Opcion: ")) + if option == 1: + name = input("Participante: ") + result = app.add(name) + if result: + print("Anadido") + else: + print("Paricipante ya existe") + elif option == 2: + name = input("Participante: ") + result = app.delete(name) + if result: + print("Eliminado") + else: + print("Participante no existe") + elif option == 3: + app.show() + elif option == 4: + result = app.lottery() + if result == None: + print("No hay participantes") + else: + print("El ganador del sorteo es:", result) + elif option == 5: + print("Adios") + break + else: + print("Opcion invalida") + except: + print("Opcion invalida") + + +if __name__ == "__main__": + main() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/egid10p.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/egid10p.py" new file mode 100644 index 0000000000..3781341f6c --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/egid10p.py" @@ -0,0 +1,76 @@ +# Reto #45: El calendario de aDEViento 2023 +#### Dificultad: Fácil | Publicación: 20/11/23 | Corrección: 27/11/23 + +## Enunciado + +# +# ¿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á. +# +import random + +participantes = ["egidio", "giorgia", "maria", "luiz", "kiki", "pame"] + +print("Hola bienvenido o bienvenida a Calendario de aDEViento 2023\n") + +print("1.Añadir participante\n2.Borrar participante\n3.Mostrar participantes\n4.Lanzar sorteo\n5.Salir") + + +while True: + opcion = input("Introduce un numero del 1 al 5: ") + if opcion == "1": + username = input("\nIntroduce el nombre de usuario del participante que quieres agregar: ") + if len(username) > 0: + username.lower() + el_nombre_de_usuario_ya_existe = False + for i in participantes: + if username == i: + print(f"Error: {username} ya estaba previamente en la lista") + el_nombre_de_usuario_ya_existe = True + break + if not el_nombre_de_usuario_ya_existe: + participantes.append(username) + print(f"El nombre de usuario {username} se a añadido sin errores") + else: + print("No introduciste un nombre de usuario, porfavor intente de nuevo") + elif opcion == "2": + username = input("\nIntroduce el nombre de usuario que deseas eliminar: ") + username.lower() + if len(username) > 0: + if username in participantes: + participantes.remove(username) + print(f"Se ha eliminado {username} de la lista.") + else: + print(f"El usuario {username} no esta en la lista") + else: + print("No introduciste un nombre de usuario, porfavor intente de nuevo") + elif opcion == "3": + print("") + for i in participantes: + print(i) + elif opcion == "4": + if participantes: + ganador = random.choice(participantes) + print(f"¡¡El ganador es {ganador}!!") + else: + print("No hay participantes en el sorteo") + elif opcion == "5": + break + else: + print("Opcion invalida") + +print("Has salido sin problemas") \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/hernandezpalo83.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/hernandezpalo83.py" new file mode 100644 index 0000000000..9c017dc6ca --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/hernandezpalo83.py" @@ -0,0 +1,94 @@ +# Reto #45: El calendario de aDEViento 2023 +#### Dificultad: Fácil | Publicación: 20/11/23 | Corrección: 27/11/23 + +## Enunciado + +# +# ¿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á. +# + +import random + +class CalendarioAdvento: + def __init__(self): + self.participantes = [] + + def agregar_participante(self, nombre): + if nombre in self.participantes: + print(f"{nombre} ya está en la lista.") + else: + self.participantes.append(nombre) + print(f"{nombre} ha sido añadido.") + + def mostrar_participantes(self): + print("Lista de participantes:") + for participante in self.participantes: + print(participante) + + def eliminar_participante(self, nombre): + if nombre in self.participantes: + self.participantes.remove(nombre) + print(f"{nombre} ha sido eliminado.") + else: + print(f"{nombre} no se encuentra en la lista.") + + def realizar_sorteo(self): + if not self.participantes: + print("No hay participantes para realizar el sorteo.") + else: + ganador = random.choice(self.participantes) + print(f"¡El ganador es: {ganador}!") + self.participantes.remove(ganador) + +if __name__ == "__main__": + calendario = CalendarioAdvento() + + while True: + print("\n--- Calendario de aDEViento ---") + print("1. Añadir participante") + print("2. Mostrar participantes") + print("3. Eliminar participante") + print("4. Realizar sorteo") + print("5. Salir") + + try: + opcion = int(input("Selecciona una opción (1-5): ")) + except ValueError: + print("Por favor, ingresa un número válido.") + continue + + if opcion == 1: + nombre_participante = input("Introduce el nombre del participante: ") + calendario.agregar_participante(nombre_participante) + + elif opcion == 2: + calendario.mostrar_participantes() + + elif opcion == 3: + nombre_participante = input("Introduce el nombre del participante a eliminar: ") + calendario.eliminar_participante(nombre_participante) + + elif opcion == 4: + calendario.realizar_sorteo() + + elif opcion == 5: + print("¡Hasta luego!") + break + + else: + print("Opción no válida. Inténtalo de nuevo.") diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/hornico.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/hornico.py" new file mode 100644 index 0000000000..acc505f819 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/hornico.py" @@ -0,0 +1,51 @@ +import random +participante:list = [] + +nombre:str +apellido:str + +while True: + print("Presione las siguientes teclas según corresponda: ") + print("A - para agregar participante") + print("E - para eliminar participante") + print("L - para listar todos los participantes") + print("C - comenzar sorteo") + print("S - para salir") + print() + opcion = input("A - E - L - C - S").upper() + if opcion == "S": + break + if opcion == "A": + nombre = input("Cual es tu nombre? ").upper() + apellido = input("Cual es tu apellido? ").upper() + if [nombre,apellido] in participante: + print() + print("Ya estas participando!!!") + print() + else: + participante.append([nombre,apellido]) + print() + print(nombre,apellido,"has sido incorporado satisfactoriamente, Muchas suerte!!!") + print() + if opcion == "E": + nombre = input("Cual es tu nombre? ").upper() + apellido = input("Cual es tu apellido? ").upper() + if [nombre,apellido] in participante: + participante.remove([nombre,apellido]) + print() + print(nombre,apellido," ha sido eliminado de la lista") + print() + + else: + print() + print(nombre,apellido," no esta en la lista") + print() + + if opcion == "C": + ganador =random.choice(participante) + participante.remove([ganador[0], ganador[1]]) + print("El ganador es ",ganador[0], ganador[1]) + if opcion == "L": + print() + print(participante) + print() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/inkhemi.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/inkhemi.py" new file mode 100644 index 0000000000..d4b3371c0b --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/inkhemi.py" @@ -0,0 +1,46 @@ +import random + +participants = [] + +while True: + print("\nSeleccione una opción:") + print("1. Añadir participante") + print("2. Eliminar participante") + print("3. Mostrar participantes") + print("4. Realizar sorteo") + print("5. Salir") + + option = input("Ingrese el número de la opción: ") + + if option == "5": + break + elif option == "1": + name = input("Ingrese el nombre del participante: ") + if name in participants: + print("Este participante ya existe.") + else: + participants.append(name) + print(f"{name} ha sido añadido.") + elif option == "2": + name = input("Ingrese el nombre del participante: ") + if name not in participants: + print("El participante no existe.") + else: + participants.remove(name) + print(f"{name} ha sido eliminado.") + elif option == "3": + if not participants: + print("No hay participantes.") + else: + print("Participantes:") + for index, name in enumerate(participants): + print(f"{index + 1}. {name}") + elif option == "4": + if not participants: + print("No hay participantes para realizar el sorteo.") + else: + winner = random.choice(participants) + print(f"El ganador es {winner}") + participants.remove(winner) + else: + print("Opción inválida. Por favor, seleccione una opción válida.") diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/jamerrq.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/jamerrq.py" new file mode 100644 index 0000000000..bccffc4e86 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/jamerrq.py" @@ -0,0 +1,171 @@ +import random as rd +import sys +from time import sleep + +def clear(): + sys.stdout.write("\033c") + +""" +stackoverflow.com/questions/287871/how-do-i-print-colored-text-to-the-terminal +""" +class bcolors: + HEADER = '\033[95m' + OKBLUE = '\033[94m' + OKCYAN = '\033[96m' + OKGREEN = '\033[92m' + WARNING = '\033[93m' + FAIL = '\033[91m' + ENDC = '\033[0m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + +class Participation: + + def __init__(self): + + self.participants = set([]) + self.cursor = f'{bcolors.BOLD}{bcolors.HEADER}→' + self.prompt = f'{bcolors.OKBLUE}Inserta el nombre' + \ + f' del participante\n{self.cursor} ' + self.index = 0 + self.heading = f"{bcolors.OKGREEN}🎄 CALENDARIO DE ADEVIENTO 🎁" + + def ask_prompt(self): + + name = input(self.prompt) + return name + + def add_participant(self): + + name = self.ask_prompt() + + if name in self.participants: + + print(f'{bcolors.FAIL}🛑 Error: este participante ya se encuentra' + \ + ' registrado!\n') + # sleep(1) + + else: + + self.participants.add(name) + print(f'{bcolors.OKCYAN}El participante ha sido agregado' + \ + ' correctamente!\n') + + def delete_participant(self): + + name = self.ask_prompt() + + if name in self.participants: + + self.participants.remove(name) + print(f'{bcolors.OKCYAN}El participante ha sido borrado exitosamente!\n') + + else: + + print(f'{bcolors.FAIL}🛑 Error: no ha sido encontrado un participante' +\ + f' con nombre ⚠️ {name} ⚠️\n') + + def show_participants(self): + + print(f'{bcolors.OKGREEN}********** Lista de participantes **********') + + for (index, participant) in enumerate(self.participants): + + color = bcolors.FAIL if index % 2 == 0 else bcolors.OKGREEN + print(f'{color}{index + 1} {participant}') + + plural = 's' if len(self.participants) != 1 else '' + color = bcolors.FAIL if len(self.participants) % 2 == 0 else bcolors.OKGREEN + print(f'{color}' + \ + f'Hay un total de {len(self.participants)} ' + \ + f'participante{plural} registrado{plural}!\n') + + def giveaway(self): + + if not len(self.participants): + + print(f'{bcolors.FAIL}Error: no hay participantes registrados todavía!\n') + + else: + + winner = rd.choice(list(self.participants)) + + print(f'{bcolors.OKCYAN}Resultado: El ganador es 🎉 {winner} 🥳\n') + self.participants.remove(winner) + + + def show_menu(self): + + print(self.heading) + print(f'{bcolors.FAIL}1. Añadir participante.') + print(f'{bcolors.OKGREEN}2. Remover participante.') + print(f'{bcolors.FAIL}3. Listar participantes.') + print(f'{bcolors.OKGREEN}4. Realizar sorteo') + print(f'{bcolors.FAIL}5. Salir') + + while True: + + option = input(self.cursor + ' ') + + try: + + option = int(option) + + if 0 >= option or option > 5: + print(f'{bcolors.FAIL}Error. Opción fuera de rango') + print(option, type(option), 0 <= option or option > 5) + continue + + except ValueError: + + print(f'{bcolors.FAIL}Error: Opción inválida') + continue + + return option + + def welcome_message(self): + + clear() + print(f'{bcolors.OKGREEN}Bienvenido al calendario de aDEViento') + print(f'{bcolors.FAIL}24 días, 24 regalos sorpresa relacionados' + \ + ' con desarrollo de software') + print(f'{bcolors.OKGREEN}Desde el 1 al 24 de diciembre.') + print(f'{bcolors.FAIL}¿Estás listo para participar?') + + print(f'{bcolors.OKCYAN}\nPresiona enter para continuar') + + input(f'{self.cursor} ') + clear() + + def start(self): + + self.welcome_message() + + while True: + + + option = self.show_menu() + clear() + + if option == 1: + self.add_participant() + + if option == 2: + self.delete_participant() + + if option == 3: + self.show_participants() + + if option == 4: + self.giveaway() + + if option == 5: + print(f'{bcolors.OKCYAN}Saliendo 🕺...') + sleep(1) + clear() + break + + +if __name__ == '__main__': + calendar = Participation() + calendar.start() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/javierfiestasbotella.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/javierfiestasbotella.py" new file mode 100644 index 0000000000..dae0b8b7ea --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/javierfiestasbotella.py" @@ -0,0 +1,78 @@ +''' + * ¿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á.''' +from random import choice +class Sorteo: + def __init__(self): + self.participantes=[] + self.participantes_premiados=[] + self.premios=[] + def menu(self): + return ''' + 1- Añadir participate + 2- Mostrar los participantes + 3- Eliminar + 4- Relalizar Sorteo + 5- Salir + ''' + def incluir(self): + self.name=input('Introduce el nombre del participante: ') + if self.name in self.participantes: + return f'{self.name} ya está incluido en la lista de participantes' + else: + self.participantes.append(self.name) + def mostrar(self): + for i in self.participantes: + print(i) + def eliminar(self): + self.name=input('Introduce el nombre del participante a eliminar: ') + if self.name in self.participantes: + self.participantes.remove(self.name) + return f'{self.name} ha sido eliminado de la lista de participantes' + else: + return f'{self.name} no se encuentra en la lista de participantes.' + def sorteo(self): + premiado=choice(self.participantes) + if premiado in self.participantes_premiados: + self.sorteo() + else: + self.participantes_premiados.append(premiado) + return f' El participante premiado ha sido {premiado}' + + + +s=Sorteo() + +if __name__ == "__main__": + while True: + print(s.menu()) + opc=int(input('Introduce un opción: ')) + if opc == 1: + print(s.incluir()) + elif opc == 2: + s.mostrar() + elif opc ==3: + print(s.eliminar()) + elif opc == 4: + print(s.sorteo()) + elif opc == 5: + break + else: + print('Ha intruducido un valor erróneo.') + + + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/jcdm60.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/jcdm60.py" new file mode 100644 index 0000000000..f828af4b53 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/jcdm60.py" @@ -0,0 +1,91 @@ +# Reto #45: El calendario de aDEViento 2023 +#### Dificultad: Fácil | Publicación: 20/11/23 | Corrección: 27/11/23 + +## Enunciado + +# +# ¿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á. +# + +import random + +class ParticipantManager: + def __init__(self): + self.participants = {} + + def add_participant(self, name): + if name in self.participants: + print(f"El participante '{name}' ya existe.") + else: + self.participants[name] = True + print(f"El participante '{name}' ha sido añadido.") + + def show_participants(self): + if self.participants: + print("Lista de participantes:") + for participant in self.participants: + print(participant) + else: + print("No hay participantes registrados.") + + def remove_participant(self, name): + if name in self.participants: + del self.participants[name] + print(f"El participante '{name}' ha sido eliminado.") + else: + print(f"El participante '{name}' no existe en la lista.") + + def draw(self): + if self.participants: + selected_participant = random.choice(list(self.participants.keys())) + print(f"El participante sorteado es: {selected_participant}") + del self.participants[selected_participant] + else: + print("No hay participantes para realizar el sorteo.") + +def main(): + manager = ParticipantManager() + + while True: + print("\nQué acción deseas realizar?") + print("1. Añadir participante") + print("2. Mostrar participantes") + print("3. Eliminar participante") + print("4. Realizar sorteo") + print("5. Salir") + + option = input("Ingresa tu selección ") + + if option == '1': + name = input("Ingresa el nombre del participante: ") + manager.add_participant(name) + elif option == '2': + manager.show_participants() + elif option == '3': + name = input("Ingresa el nombre del participante a eliminar: ") + manager.remove_participant(name) + elif option == '4': + manager.draw() + elif option == '5': + break + else: + print("Opción no válida. Por favor, elige una opción del 1 al 5.") + +if __name__ == "__main__": + main() + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/juanppdev.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/juanppdev.py" new file mode 100644 index 0000000000..9459bce8fb --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/juanppdev.py" @@ -0,0 +1,60 @@ +import random + +participantes = [] + +def mostrar_participantes(): + print("Lista de participantes:") + for participante in participantes: + print(participante) + print() + +def agregar_participante(): + nombre = input("Introduce el nombre del participante: ") + if nombre in participantes: + print("Este participante ya existe.") + else: + participantes.append(nombre) + print(f"{nombre} ha sido añadido correctamente.") + +def eliminar_participante(): + nombre = input("Introduce el nombre del participante que deseas eliminar: ") + if nombre in participantes: + participantes.remove(nombre) + print(f"{nombre} ha sido eliminado correctamente.") + else: + print("Este participante no existe en la lista.") + +def realizar_sorteo(): + if participantes: + ganador = random.choice(participantes) + print(f"¡El ganador del sorteo es: {ganador}!") + participantes.remove(ganador) + else: + print("No hay participantes para realizar el sorteo.") + +def main(): + while True: + print("1. Añadir participante") + print("2. Mostrar participantes") + print("3. Eliminar participante") + print("4. Realizar sorteo") + print("5. Salir") + + opcion = input("Selecciona una opción (1-5): ") + + if opcion == "1": + agregar_participante() + elif opcion == "2": + mostrar_participantes() + elif opcion == "3": + eliminar_participante() + elif opcion == "4": + realizar_sorteo() + elif opcion == "5": + print("Saliendo del programa. ¡Hasta luego!") + break + else: + print("Opción no válida. Por favor, selecciona una opción válida.") + +if __name__ == "__main__": + main() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/keltoi-dev.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/keltoi-dev.py" new file mode 100644 index 0000000000..b3b0a93947 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/keltoi-dev.py" @@ -0,0 +1,103 @@ +""" +* ¿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á. +""" + +import random +import os + +condicion = "" +particpantes = [] + +def menu(): + if os.name == "nt": + os.system("cls") + else: + os.system("clear") + + opciones = "1234" + print("*** MENU ***") + print("1.- Añadir un participante") + print("2.- Eliminar un participante") + print("3.- Listar los participantes") + print("4.- Sortear premio") + print("0.- Salir de la aplicacion") + seleccion = input("\nSelecciones una opcion: ") + global condicion + if seleccion in opciones: + condicion = True + else: + condicion = False + + return seleccion + +def alta(): + global particpantes + ingresante = input("Ingrese un participante: ") + if ingresante != "": + if ingresante.capitalize() in particpantes: + print("El dato ingresado ya existe.") + alta() + else: + particpantes.append(ingresante.capitalize()) + + continuar = input("Desea ingresar otro participante? (s/n) ") + if continuar.lower() == "s": + alta() + +def baja(): + ingresante = input("Ingrese el participante a eliminar: ") + if ingresante != "": + if ingresante.capitalize() in particpantes: + particpantes.remove(ingresante.capitalize()) + else: + print("El participante no existe:") + baja() + + continuar = input("Desea eliminar otro participante? (s/n) ") + if continuar.lower() == "s": + baja() + +def mostrar(): + print("Listado de participantes") + for i in particpantes: + print(i) + continuar = input("Presione una tecla para continuar") + + +def sorteo(): + print("Sorteo de premio") + if not particpantes: + print("No hay perticipantes para realizar el sorteo") + else: + ganador = random.choice(particpantes) + print(f"El ganador es {ganador}") + particpantes.remove(ganador) + continuar = input("Presione una tecla para continuar") + +print("Bienvenido!!!") +seleccion = menu() +while condicion: + if seleccion == "1": + alta() + elif seleccion == "2": + baja() + elif seleccion == "3": + mostrar() + else: + sorteo() + seleccion = menu() \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/mouredev.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/mouredev.py" new file mode 100644 index 0000000000..ffc923471e --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/mouredev.py" @@ -0,0 +1,54 @@ +import random + +participants = [] + +print("Calendario de aDEViento 2023") + +while True: + + print("\n1. Añadir | 2. Eliminar | 3. Listar | 4. Sortear | 5. Salir") + + option = input("Selecciona una opción: ") + + if option == "1": + + name = input( + "Introduce el nombre del participante que quieres añadir: ").lower() + if name in participants: + print(f"El participante \"{name}\" ya existe.") + else: + participants.append(name) + print(f"Participante \"{name}\" añadido correctamente.") + + elif option == "2": + + name = input( + "Introduce el nombre del participante que quieres eliminar: ").lower() + if name in participants: + participants.remove(name) + print(f"Participante \"{name}\" eliminado correctamente.") + else: + print(f"El participante \"{name}\" no existe.") + + elif option == "3": + + print("Listado de participantes:") + for participant in participants: + print(participant) + + elif option == "4": + + if participants: + name = random.choice(participants) + print(f"El ganador del sorteo es \"{name}\".") + participants.remove(name) + else: + print("No hay participantes para realizar el sorteo.") + + elif option == "5": + + print("Sorteo finalizado.") + break + + else: + print("Opción no válida. Selecciona otra opción.") diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/raulG91.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/raulG91.py" new file mode 100644 index 0000000000..c2a87da049 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/raulG91.py" @@ -0,0 +1,37 @@ +from random import choice +users = [] + +while True: + print("¿Que desea hacer?") + print("Pulsa A: Añadir nuevo usuario \nPulsa B: para eliminar un participante \nPulsa L: Para listar los participantes \nPulsa S: Para realizar el sorteo \nPulsa E: Para salir del programa" ) + user_choice = input() + user_choice = user_choice.upper() + + match user_choice: + case "A": + name = input("Intorduce el nombre del participante ") + if users.count(name) > 0: + print("El usuario ya existe en el sistema ") + else: + users.append(name) + case "B": + name = input("Introduzca el usuario a borrar ") + if users.count(name) > 0: + users.remove(name) + print("Usuario "+ name +" eliminado del sistema") + else: + print("El usuario no existe en el sistema") + case "L": + for user in users: + print(user) + case "S": + if len(users) > 0: + user_winner = choice(users) + print("El ganador del sorteo es: " + user_winner) + users.remove(user_winner) + else: + print("No hay usuarios en el sistema") + + case "E": + break + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/robertbarac.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/robertbarac.py" new file mode 100644 index 0000000000..b5a2d11518 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/robertbarac.py" @@ -0,0 +1,94 @@ +import os +from time import sleep +from random import choice + +lista_regalos = [i for i in range(1,25)] +lista_participantes = [] + +def menu(): + mensaje_input = """ + Programa navideño aDEViento + Seleccione una de las opciones: + 1. Añadir participante + 2. Eliminar participante + 3. Mostrar participantes + 4. Lanzar el sorteo + 5. Salir + """ + print(mensaje_input) + opcion = int(input()) + while True: + if opcion == 1: + os.system("cls") + agregar_participante() + elif opcion == 2: + eliminar_participante() + elif opcion == 3: + os.system("cls") + mostrar_participante() + elif opcion == 4: + os.system("cls") + lanzar_sorteo() + elif opcion == 5: + os.system("cls") + salir() + else: + print("Opción errada") + + +def agregar_participante(): + nombre = input("Ingresa el nombre del participante: ") + nombre = nombre.title() + if nombre in lista_participantes: + print("Este participante está agregado previamente") + sleep(1) + os.system("cls") + menu() + else: + lista_participantes.append(nombre) + print("Participante agregado...") + sleep(1) + os.system("cls") + menu() + +def eliminar_participante(): + nombre = input("Escriba el nombre del participante a eliminar: ").title() + if nombre in lista_participantes: + indice = lista_participantes.index(nombre) + print(f"Eliminando a {nombre}...") + sleep(1) + lista_participantes.remove(nombre) + print(f"Ha sido eliminado {nombre}") + sleep(1) + os.system("cls") + menu() + else: + print(f"{nombre} no está en los participantes") + sleep(1) + os.system("cls") + menu() + +def mostrar_participante(): + print("Éstos son los participantes:") + for i in range(len(lista_participantes)): + print(lista_participantes[i]) + sleep(1) + os.system("cls") + menu() + +def lanzar_sorteo(): + nombre = choice(lista_participantes) + regalo = choice(lista_regalos) + print(f"Hoy ganó {nombre} el regalo {regalo}") + sleep(2) + lista_participantes.remove(nombre) + os.system("cls") + menu() + +def salir(): + print("Saliendo de aplicación") + print("Adiós") + exit() + +if __name__ == "__main__": + menu() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/sirnas1983.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/sirnas1983.py" new file mode 100644 index 0000000000..8ecc94670b --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/sirnas1983.py" @@ -0,0 +1,48 @@ +import random + +lista_participantes =[] +cont = True +print("-"*21) +print("Bienvenido a ADVIENTO") +while cont: + print("-"*21) + print("1. Añadir participante") + print("2. Remover participante") + print("3. Mostrar participantes") + print("4. Lanzar Sorteo") + print("0. Salir") + print("-"*21) + opcion = input("Seleccione una opcion: ") + if opcion == "0": + cont = False + break + if opcion == "1": + nombre = input("Ingrese nombre: ") + if nombre in lista_participantes: + print("Nombre ya esta registrado") + else: + lista_participantes.append(nombre) + print(f'{nombre} agregado correctamente') + if opcion == "2": + if len(lista_participantes) != 0: + nombre = input("Ingrese nombre: ") + if not nombre in lista_participantes: + print("Nombre no esta registrado") + else: + lista_participantes.remove(nombre) + print(f'{nombre} removido correctamente') + else: + print("No hay participantes cargados") + if opcion == "3": + if len(lista_participantes) != 0: + for participante in lista_participantes: + print(participante) + else: + print("Lista de participantes vacia") + if opcion == "4": + if len(lista_participantes) != 0: + ganador = lista_participantes[random.randint(0, len(lista_participantes)-1)] + print(f"¡¡El ganador es {ganador}!!\n¡¡Felicitaciones!!") + lista_participantes.remove(ganador) + else: + print("No hay participantes") diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/troleomotor10.py" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/troleomotor10.py" new file mode 100644 index 0000000000..3321e0d768 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/python/troleomotor10.py" @@ -0,0 +1,132 @@ +# /* +# * ¿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á. +# */ +import os +import random +import time + +participantes = [] + +def empty_list(): + if len(participantes) <= 0: + return True + +def add_user(): + os.system("cls") + print("=== AÑADIR USUARIOS ===") + while True: + try: + cantidad = int(input("Cuantos participante te gustaría añadir: ")) + for x in range(cantidad): + encontrado = False + user = input("Nombre del participantes a agregar: ") + if empty_list(): + participantes.append(user.capitalize()) + else: + for z in participantes: + if z.lower() == user.lower(): + print("El participante ya existe!") + encontrado = True + break + if not encontrado: + participantes.append(user.capitalize()) + break + except: + print("El valor introducido no es correcto!") + input("Pulsa una tecla para continuar...") + menu() + +def remove_user(): + os.system("cls") + print("=== QUITAR USUARIOS ===") + if empty_list(): + print("No existen usuarios dentro de la lista.") + input("Pulsa una tecla para continuar...") + menu() + else: + user = input("Que usuario te gustaría eliminar: ") + encontrado = False + for x in participantes: + if user.capitalize() == x.capitalize(): + encontrado = True + if encontrado: + participantes.remove(user.capitalize()) + print("El usuario ha sido eliminado!") + else: + print("El usuario no se ha encontrado!") + input("Pulsa una tecla para continuar...") + menu() + +def list_users(): + os.system("cls") + print("=== LISTA DE PARTICIPANTES ===") + for i in participantes: + print(i) + print("Hay {} participantes en la lista".format(len(participantes))) + input("Pulsa una tecla para continuar...") + menu() + +def start_giveway(): + os.system("cls") + print("=== SORTEO ===") + if empty_list(): + print("¡No hay participantes! ¡El sorteo no se puede realizar!") + input("Pulsa una tecla para salir....") + menu() + else: + print("El ganador es....") + for x in range(3,0, -1): + print(x) + time.sleep(1) + winner = random.choice(participantes) + print("¡{} se lleva el premio! ¡Muchas felicidades!".format(winner)) + participantes.remove(winner) + input("Pulsa una tecla para salir....") + menu() + +def showapp(option): + if option == 1: + add_user() + elif option == 2: + remove_user() + elif option == 3: + list_users() + elif option == 4: + start_giveway() + elif option == 5: + print("¡Que tengas un buen dia!") + exit() + +def menu(): + option = 0 + try: + while(int(option) not in {1, 2, 3, 4, 5}): + os.system("cls") + print("=== MENU CALENDARIO ADVIENTO 2023 ===") + print("[1] Añadir participante") + print("[2] Borrar participante") + print("[3] Listar participante") + print("[4] Comenzar sorteo") + print("[5] Salir") + option = int(input("Introduce tu opción: ")) + except: + print("¡El valor introducido no es correcto!") + menu() + showapp(int(option)) + +menu() \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/rust/hdescobarh.rs" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/rust/hdescobarh.rs" new file mode 100644 index 0000000000..2a40b6d416 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/rust/hdescobarh.rs" @@ -0,0 +1,282 @@ +// author: Hans D. Escobar H. (hdescobarh) + +/* +Solución con el mínimo de bibliotecas externas. Solo emplea rand para generar números aleatorios. + +Esta organizada en tres módulos: +- giveaway_data: contiene las entidades encargadas del acceso a los medios de persistencia. +- giveaway: se encarga de la logica de negocio +- giveaway_cli: interfaz de linea de comandos + +Cargo manifest: +[package] +name = "giveaway" +version = "0.1.0" +edition = "2021" +[dependencies] +rand = "0.8.5" +*/ + +use giveaway::Giveaway; +use giveaway_cli::Cli; +use giveaway_data::MockRepository; + +fn main() { + // inicializa la interfaz de linea de comandos + let mut cli = Cli::default(); + // inicializa el controlador y el repositorio, uno falso para el ejercicio. + let mut giveaway = Giveaway::new(MockRepository::default()); + loop { + let state = cli.run(&mut giveaway); + println!("{}", state); + } +} + +// command line interface module +pub mod giveaway_cli { + use crate::giveaway::{Giveaway, Request}; + + const PROMPT_OPTION: &str = "\n\ + Ingrese el número de la acción que desea realizar: + 1 Agregar participante. + 2 Mostrar todos los participantes. + 3 Eliminar a un participante. + 4 Realizar el sorteo. + 5 Salir."; + const PROMPT_USERNAME: &str = "Por favor ingrese el nombre de usuario del participante."; + const MSG_INVALID_OPTION: &str = "La opción ingresada no es valida."; + const MSG_EXIT: &str = "Cerrando el programa. Hasta pronto."; + + #[derive(Default)] + pub struct Cli { + buffer: String, + } + + impl Cli { + pub fn run(&mut self, giveaway: &mut Giveaway) -> String { + self.buffer.clear(); + println!("{}", PROMPT_OPTION); + + std::io::stdin().read_line(&mut self.buffer).unwrap(); + + let choice = match self.buffer.trim().parse::() { + Ok(number) => { + if (1..=5).contains(&number) { + number + } else { + return MSG_INVALID_OPTION.to_string(); + } + } + Err(_) => return MSG_INVALID_OPTION.to_string(), + }; + + match choice { + 1 => giveaway.request(Request::AddParticipant, Some(self.ask_username())), + 2 => giveaway.request(Request::ListParticipants, None), + 3 => giveaway.request(Request::RemoveParticipant, Some(self.ask_username())), + 4 => giveaway.request(Request::Draw, None), + 5 => { + println!("{}", MSG_EXIT); + std::process::exit(0) + } + _ => panic!("Unexpected error: allowed choice out of bounds."), + } + } + + fn ask_username(&mut self) -> &str { + self.buffer.clear(); + println!("{}", PROMPT_USERNAME); + std::io::stdin().read_line(&mut self.buffer).unwrap(); + self.buffer.trim() + } + } +} + +pub mod giveaway { + use crate::giveaway_data::{ErrorKind, Participant, Repository}; + use rand::seq::SliceRandom; + use std::fmt::Display; + + const MSG_ERR_NOT_FOUND: &str = "El participante no existe."; + const MSG_ERR_ALREADY_EXIST: &str = "El participante ya se encuentra en el sorteo."; + const MSG_ERR_EMPTY_DATA: &str = "No hay participantes en el sorteo."; + const MSG_SUCCESS_ADDING: &str = "Se ha agregado un al participante."; + const MSG_SUCCESS_DELETING: &str = "El participante ha sido removido."; + const MSG_WARNING_MISSING: &str = "Faltó el nombre de usaurio."; + const MSG_WINNER: &str = "El ganador es el usuario"; + + pub struct Giveaway { + repository: Box, + } + + impl Giveaway { + pub fn new(repository: impl Repository + 'static) -> Self { + Self { + repository: Box::new(repository), + } + } + + pub fn request(&mut self, kind: Request, username: Option<&str>) -> String { + match kind { + Request::AddParticipant => match username { + Some(username) => self.add_participant(username), + None => MSG_WARNING_MISSING.to_string(), + }, + Request::ListParticipants => self.get_all_participants(), + Request::RemoveParticipant => match username { + Some(username) => self.remove_participant(username), + None => MSG_WARNING_MISSING.to_string(), + }, + Request::Draw => self.draw(), + } + } + + // Agrega un nuevo participante + fn add_participant(&mut self, username: &str) -> String { + match self.repository.create(Participant { + username: username.to_owned(), + }) { + Ok(_) => MSG_SUCCESS_ADDING.to_string(), + Err(e) => format!("{e}"), + } + } + + // Lista todos los participantes + fn get_all_participants(&self) -> String { + match self.repository.read_all() { + Ok(l) => String::from_iter( + l.into_iter() + .map(|participant| format!("- {}\n", participant.username)), + ), + Err(e) => format!("{e}"), + } + } + + // Remueve por nombre de usuario a un participante + fn remove_participant(&mut self, username: &str) -> String { + match self.repository.delete(username) { + Ok(_) => MSG_SUCCESS_DELETING.to_string(), + Err(e) => format!("{e}"), + } + } + + // Obtiene un ganador y lo remueve de la lista de participantes + fn draw(&mut self) -> String { + let mut rng = rand::thread_rng(); + let participants = match self.repository.read_all() { + Ok(l) => l, + Err(e) => return format!("{e}"), + }; + + let winner = match participants.choose(&mut rng) { + Some(participant) => participant.username.to_owned(), + None => return format!("{}", ErrorKind::Empty), + }; + match self.repository.delete(&winner) { + Ok(_) => format!("{} {}.", MSG_WINNER, winner), + Err(e) => format!("{e}"), + } + } + } + + pub enum Request { + AddParticipant, + ListParticipants, + RemoveParticipant, + Draw, + } + + impl Display for ErrorKind { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let msg = match self { + ErrorKind::NotFound => MSG_ERR_NOT_FOUND, + ErrorKind::AlreadyExist => MSG_ERR_ALREADY_EXIST, + ErrorKind::Empty => MSG_ERR_EMPTY_DATA, + }; + write!(f, "{msg}") + } + } +} + +pub mod giveaway_data { + + // Las nombres de usuario de Twitter son únicos, por lo que pueden usarse como identificadores únicos del participante + #[derive(PartialEq, Clone)] + pub struct Participant { + pub username: String, + } + + pub trait Repository { + fn create(&mut self, participant: Participant) -> Result<(), ErrorKind>; + fn read_all(&self) -> Result, ErrorKind>; + fn delete(&mut self, username: &str) -> Result<(), ErrorKind>; + } + + #[non_exhaustive] + pub enum ErrorKind { + NotFound, + AlreadyExist, + Empty, + } + + // Para el ejercicio la "conexión" será falseada por una simple colección + pub struct MockRepository { + connection: Vec, + } + + impl MockRepository { + fn get_username_index(&self, username: &str) -> Result { + for (index, entry) in self.connection.iter().enumerate() { + if entry.username == username { + return Ok(index); + } + } + Err(ErrorKind::NotFound) + } + } + + impl Default for MockRepository { + fn default() -> Self { + Self { + connection: Vec::from( + [ + "QuantumFracture", + "mouredev", + "midudev", + "sama", + "neiltyson", + "HiromuArakawa", + ] + .map(|i| Participant { + username: i.to_string(), + }), + ), + } + } + } + + impl Repository for MockRepository { + fn create(&mut self, participant: Participant) -> Result<(), ErrorKind> { + if self.connection.contains(&participant) { + return Err(ErrorKind::AlreadyExist); + } + + self.connection.push(participant); + Ok(()) + } + + fn read_all(&self) -> Result, ErrorKind> { + if self.connection.is_empty() { + Err(ErrorKind::Empty) + } else { + Ok(Vec::from_iter(self.connection.iter().cloned())) + } + } + + fn delete(&mut self, username: &str) -> Result<(), ErrorKind> { + let index = self.get_username_index(username)?; + self.connection.swap_remove(index); + Ok(()) + } + } +} diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/shell/luishendrix92.sh" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/shell/luishendrix92.sh" new file mode 100644 index 0000000000..8280b278d8 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/shell/luishendrix92.sh" @@ -0,0 +1,108 @@ +#f/bin/bash + +participants=() + +participant_exists() { + local already_entered=false + + for entry in "${participants[@]}"; do + if [[ "$entry" == "$1" ]]; then + already_entered=true + break + fi + done + + echo "$already_entered" +} + +add_entry() { + if [[ "$(participant_exists $1)" == false ]]; then + participants+=("$1") + echo "Successfully added $1 to the list!" + else + echo "The name $1 was already registered..." + fi +} + +remove_entry() { + if [[ "$(participant_exists $1)" == true ]]; then + for i in "${!participants[@]}"; do + if [[ ${participants[i]} = $1 ]]; then + unset 'participants[i]' + fi + done + + for i in "${!participants[@]}"; do + participants_copy+=("${participants[i]}") + done + + participants=("${participants_copy[@]}") + unset participants_copy + echo "The name $1 was successfully removed!" + else + echo "There was no $1 to remove..." + fi +} + +list_entries() { + for entry in "${participants[@]}"; do + echo "$entry" + done +} + +pick_winner() { + if [ ${#participants[@]} -eq 0 ]; then + echo "The list of participants is empty." + else + winner="${participants[ $RANDOM % ${#participants[@]} ]}" + + echo "And the winner is: $winner! 🎉" + fi +} + +while true; do + clear + + echo "What do you want to do?" + echo "-----------------------" + echo "1- List all participants." + echo "2- Add a new participant." + echo "3- Remove a participant." + echo "4- Choose a lucky winner!" + echo "5- EXIT" + + read -p "Choose an option: " user_option + clear + + case $user_option in + 1) + echo "Entry list" + echo "----------" + list_entries + ;; + + 2) + read -p "Enter the name you wish to add: " new_name + add_entry "$new_name" + ;; + + 3) + read -p "Enter the name you wish to remove: " to_remove + remove_entry "$to_remove" + ;; + + 4) + pick_winner + ;; + + 5) + exit 0 + ;; + + *) + echo "Unknown option [$user_option]." + ;; + esac + + read -p $'\n'"Press to continue..." +done diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/swift/allbertoMD.swift" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/swift/allbertoMD.swift" new file mode 100644 index 0000000000..a6b693cab1 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/swift/allbertoMD.swift" @@ -0,0 +1,82 @@ +import Foundation + +var participants: [String] = [] + +showMenu() + +print("Introduce una opcion y pulsa Enter") + +var validInput = true + +while validInput { + if let input: String = readLine(), let option = Int(input) { + switch option { + case 1: + print("Añadir participante") + addParticipant() + case 2: + print("Eliminar participante") + deleteParticipant() + case 3: + print("Mostrar participantes") + showParticipants() + case 4: + print("Lanzar sorteo") + toHoldRaffle() + validInput = false + case 5: + print("Salir") + validInput = false + default: + print("Enter a valid option") + } + } +} + +func showMenu() { + print("\n") + print("[1]-Añadir participante") + print("[2]-Borrar participante") + print("[3]-Mostrar participantes") + print("[4]-Lanzar sorteo") + print("[5]-Salir") +} + +func addParticipant() { + print("Introduce el numbre del participante") + + if let input = readLine() { + participants.append(input) + } + print("Participante añadido") + + showMenu() +} + +func deleteParticipant() { + print("Introduce el nombre del participante que quieres eliminar") + + if let input = readLine() { + if let index = participants.firstIndex(of: input) { + participants.remove(at: index) + } + } + print("Participante eliminado") + + showMenu() +} + +func showParticipants() { + print("Todos los participantes:") + + for participant in participants { + print(participant) + } + showMenu() +} + +func toHoldRaffle() { + if let winner = participants.randomElement() { + print("El ganador de concurso es: \(winner)") + } +} diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/swift/didacdev.swift" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/swift/didacdev.swift" new file mode 100644 index 0000000000..d3c078e29d --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/swift/didacdev.swift" @@ -0,0 +1,117 @@ +import Foundation + +class DataBase { + var participants: [String] = [] + + func addParticipant(name: String) { + if !exists(name: name) { + participants.append(name) + print("Participante añadido!") + } else { + print("El participante ya existe") + } + } + + func exists(name: String) -> Bool { + for participant in participants { + if participant == name { + return true + } + } + + return false + } + + func getParticipants() -> [String]{ + return participants + } + + func deleteParticipant(name: String) { + if let index = participants.firstIndex(of: name) { + participants.remove(at: index) + print("Participante eliminado") + } else { + print("El participante no existe") + } + } + + func getRandomParticipant() -> String { + let randomNumber = Int.random(in: 0.. Bool { + return exit + } +} + +var app = App() + +while !app.getExit() { + app.chooseOption() +} + + diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/ChemaAlfonso.ts" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/ChemaAlfonso.ts" new file mode 100644 index 0000000000..4992aa7a93 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/ChemaAlfonso.ts" @@ -0,0 +1,168 @@ +import { createInterface } from 'node:readline' +import { stdin as input, stdout as output } from 'node:process' + +type UserCommunicator = { + makeQuestion: (questionToMake: string) => Promise + tellSomething: (somethingToTell: string) => void + forgetTold: () => void + endCommunication: () => void +} + +export class AdevientoCalendar { + private participants: string[] = [] + private running = true + private output = '' + private outputColor = '' + private colors = { + ok: '\x1b[92m', + ko: '\x1b[91m' + } + + constructor(private readonly userCommunicator: UserCommunicator) {} + + async run() { + const menu = Object.values(this.getMenuOptions()) + .map((option, idx) => `${idx + 1}. ${option.optionName}`) + .join('\n') + + while (this.running) { + // Select action + this.userCommunicator.forgetTold() + this.userCommunicator.tellSomething(this.title()) + this.userCommunicator.tellSomething(menu) + + if (this.output) this.userCommunicator.tellSomething(`\n${this.outputColor}${this.output}\x1b[00m`) + + const selectedOption = await this.userCommunicator.makeQuestion('\n\x1b[93m¿Qué quieres hacer?\x1b[00m') + + // Handle selected action + this.userCommunicator.forgetTold() + this.outputColor = this.colors.ok + this.userCommunicator.tellSomething(this.title()) + + const handler = this.getMenuOptions()[+selectedOption - 1]?.handler + if (!handler) { + this.outputColor = this.colors.ko + this.output = 'Selecciona una opción válida...' + continue + } + + await handler() + } + } + + private async addParticipant() { + const name = await this.userCommunicator.makeQuestion('Dime el nombre del participante:') + + if (this.participantAlreadyExists(name)) { + this.outputColor = this.colors.ko + this.output = 'El participante ya existe' + return + } + + this.participants.push(name) + this.output = `Se ha añadido a '${name}' a los participantes` + } + + private async removeParticipant() { + const removingName = await this.userCommunicator.makeQuestion('Dime el nombre del participante:') + + if (!this.participantAlreadyExists(removingName)) { + this.outputColor = this.colors.ko + this.output = 'El participante no existe' + return + } + + this.participants = this.participants.filter(name => name !== removingName) + this.output = `Se ha eliminado a '${removingName}' de los participantes` + } + + private listParticipants() { + if (!this.participants.length) { + this.outputColor = this.colors.ko + this.output = 'No hay ningún participante' + return + } + + const participantsList = this.participants.map(option => `- ${option}`).join('\n') + const total = `${this.participants.length} participantes en total.` + this.output = `${participantsList}\n\n${total}` + } + + private sortout() { + if (!this.participants.length) { + this.outputColor = this.colors.ko + this.output = 'No hay ningún participante' + return + } + + const winnerIdx = Math.floor(Math.random() * this.participants.length) + const winner = this.participants[winnerIdx] + this.output = `El ganador es '${winner}'! 🥳 🎊 🎉` + + this.participants.splice(winnerIdx, 1) + } + + private exit() { + this.userCommunicator.tellSomething('Hasta otra 👋!') + this.userCommunicator.endCommunication() + this.running = false + } + + private participantAlreadyExists(name: string) { + return this.participants.includes(name) + } + + private title() { + return `\x1b[95m + ███████ ██████ ███████ ██ ██ ██ ███████ ███ ██ ████████ ██████ + ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ + ███████ ██ ██ █████ ██ ██ ██ █████ ██ ██ ██ ██ ██ ██ + ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ + ██ ██ ██████ ███████ ████ ██ ███████ ██ ████ ██ ██████ Calendar. + \x1b[00m` + } + + private getMenuOptions() { + return [ + { + optionName: 'Añadir participante', + handler: this.addParticipant.bind(this) + }, + { + optionName: 'Eliminar participante', + handler: this.removeParticipant.bind(this) + }, + { + optionName: 'Listar participantes', + handler: this.listParticipants.bind(this) + }, + { + optionName: 'Sortear', + handler: this.sortout.bind(this) + }, + { + optionName: 'Salir', + handler: this.exit.bind(this) + } + ] + } +} + +// Create communicator +const inputInterface = createInterface({ input, output }) +const communicator: UserCommunicator = { + makeQuestion: (questionToMake: string): Promise => { + return new Promise(resolve => { + inputInterface.question(`${questionToMake}\n`, (answer: string) => { + resolve(answer) + }) + }) + }, + tellSomething: somethingToTell => console.log(somethingToTell), + forgetTold: () => console.clear(), + endCommunication: inputInterface.close.bind(inputInterface) +} + +// Start +new AdevientoCalendar(communicator).run() diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/albertovf.ts" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/albertovf.ts" new file mode 100644 index 0000000000..6122520f22 --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/albertovf.ts" @@ -0,0 +1,56 @@ +let participantes: String[] = ["Anonimo", "1", "2", "3", "4"] + +const add = (participante: String) => { + if (participantes.indexOf(participante) != -1) { + participantes.push(participante) + } else { + console.log(`El participante ${participante} ya existe`); + } +} + +const del = (participante: String) => { + let l = participantes.findIndex(i => i == participante) + if (l == -1) { + console.log(`El participante ${participante} no existe`); + } else { + participantes.splice(l, 1); + } +} + +const mostrar = () => { + console.log(participantes); +} + +const sortear = () => { + let numero = Math.floor(Math.random() * participantes.length) + console.log(`El ganador es Nº${numero} ${participantes[numero]}`); + participantes.splice(numero, 1) +} + +const reto = () => { + + while (true) { + const accion = prompt('Selecciona una opcion [A]ñadir, [S]ortear, [B]orrar, [M]ostrar, [E]xit') + + switch (accion) { + case 'A': + add(prompt('Introduce el nombre que quieres agregar:') || "") + break; + case 'S': + sortear() + break; + case 'B': + del(prompt('Introduce el nombre que quieres borrar: ') || "") + break; + case 'M': + mostrar(); + break; + case 'E': + return false; + default: + mostrar() + break; + } + } +} +reto() \ No newline at end of file diff --git "a/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/restolsurf.ts" "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/restolsurf.ts" new file mode 100644 index 0000000000..9785f4f29d --- /dev/null +++ "b/Retos/Reto #45 - EL CALENDARIO DE ADEVIENTO 2023 [F\303\241cil]/typescript/restolsurf.ts" @@ -0,0 +1,129 @@ + +// readline es un módulo en Node.js que proporciona una interfaz para leer datos desde un flujo de entrada + +import * as readline from 'readline'; + +// Creamos la interfaz para realizar operaciones de entrada/salida +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout, +}); + +// Preguntamos si queremos mostrar el menú de nuevo +const menuPrompt = () => { + drawLine(); + console.log("(Introduce '0' si quieres volver a mostrar el menú.)"); + handleUserChoice(); +}; + +const drawLine = () => console.log("------------------------"); + +// creamos una clase para gestionar los participantes +class ParticipantesSorteoaDEViento { + participants: string[]; + + constructor() { + this.participants = []; + } + + // métodos para gestionar la clase + addParticipant(participantName: string): void { + if (this.participants.includes(participantName)) + console.log("El Participante ya existe"); + else { + this.participants.push(participantName); + console.log(`Felicidades! ${participantName} ha sido añadido.`); + } + } + + removeParticipant(participantName: string): void { + if (this.participants.includes(participantName)) { + const index = this.participants.indexOf(participantName); + this.participants.splice(index, 1); + console.log(`${participantName} ha sido eliminado del sorteo.`); + } else console.log("El Participante no existe"); + } + + showParticpants(): void { + this.participants.length === 0 + ? console.log("No hay ningún participante") + : this.participants.forEach((e) => console.log(e)); + } + + theWinnerIs(): void { + if (this.participants.length === 0) + console.log("No hay ningún participante todavía"); + else { + const indexWinner = Math.floor(Math.random() * this.participants.length); + const winnerName = this.participants[indexWinner]; + + console.log(`Muchas Felicidades! El ganador es ${winnerName}`); + this.removeParticipant(winnerName); + } + } +} + +// creamos los participantes e inicializamos mostrando el menú +const participants = new ParticipantesSorteoaDEViento(); +showMenu(); + +// Mostamos el menú de opciones en la terminal +function showMenu(): void { + console.log(`Menú: + 1. Añade un nuevo participante. + 2. Borra un participante. + 3. Muestra todos los participantes. + 4. Elije un ganador. + 5. Salir.`); + drawLine(); + handleUserChoice(); +} + +// configuramos rl para leer desde la consola y escribir en la consola. +function handleUserChoice(): void { + rl.question("Selecciona una opción: ", (respuesta) => { + drawLine(); + // respuesta recibe una string=> la convertimos a number + switch (Number(respuesta)) { + case 0: + showMenu(); + break; + case 1: + rl.question("Introduce un participante: ", (respuesta) => { + participants.addParticipant(respuesta); + menuPrompt(); + }); + break; + case 2: + rl.question("Introduce el participante a eliminar: ", (respuesta) => { + participants.removeParticipant(respuesta); + menuPrompt(); + }); + + break; + case 3: + participants.showParticpants(); + menuPrompt(); + break; + case 4: + participants.theWinnerIs(); + menuPrompt(); + break; + case 5: + rl.close(); + break; + default: + console.log( + "Esta opción no es valida. Selecciona una opción del menú." + ); + drawLine(); + showMenu(); + } + }); +} + +// Cerrar la interfaz readline al finalizar +rl.on("close", () => { + console.log("¡Hasta luego!"); + process.exit(0); +}); diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/ejercicio.md b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/ejercicio.md new file mode 100644 index 0000000000..6efb393b45 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/ejercicio.md @@ -0,0 +1,32 @@ +# Reto #46: La carrera de coches +#### Dificultad: Media | Publicación: 27/11/23 | Corrección: 04/12/23 + +## Enunciado + +``` +/* + * 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. + * + */ +``` +#### 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)**. \ No newline at end of file diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/go/blackriper.go b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/go/blackriper.go new file mode 100644 index 0000000000..53e476433c --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/go/blackriper.go @@ -0,0 +1,171 @@ +package main + +import ( + "fmt" + "math/rand" + "strings" + "time" +) + +// elementos para pintar la pista durante el juego +const ( + GOAL = " 🏁 " + TREE = "🌲" + PLAYER1 = " 🚙 " + PLAYER2 = " 🚗 " + SHOCK = " 💥 " +) + +/*definir metodos para el juego*/ +type CarRace interface { + ConfigParams() + StartRace() bool +} + +type Race struct { + NumTracks int + PosTree1 []int + PosTree2 []int +} + +// configurar el largo de la pista y generar los obstaculos +func (r *Race) ConfigParams() { + fmt.Println("How long should the race track be?") + fmt.Scanf("%d", &r.NumTracks) + r.PosTree1 = FactoryTree(r.NumTracks) + r.PosTree2 = FactoryTree(r.NumTracks) +} + +// empezar la carrera +func (r *Race) StartRace() bool { + var ( + posP1 int = r.NumTracks - 1 + posP2 int = r.NumTracks - 1 + numRace int = 1 + numShock int + endGame bool + ) + + fmt.Println("Inicial Race") + fmt.Println(PaintingCar(r.NumTracks, posP1, PLAYER1, r.PosTree1, false)) + fmt.Println(PaintingCar(r.NumTracks, posP2, PLAYER2, r.PosTree2, false)) + + for { + shock1 := MoveCar(&posP1, &numShock, r.PosTree1) + shock2 := MoveCar(&posP2, &numShock, r.PosTree2) + + time.Sleep(5 * time.Second) + + fmt.Printf("Race number %v \n", numRace) + fmt.Println(PaintingCar(r.NumTracks, posP1, PLAYER1, r.PosTree1, shock1)) + fmt.Println(PaintingCar(r.NumTracks, posP2, PLAYER2, r.PosTree2, shock2)) + numRace++ + + if posP1 == 0 { + fmt.Printf("The winner is %v \n", PLAYER1) + endGame = true + break + } + + if posP2 == 0 { + fmt.Printf("The winner is %v \n", PLAYER2) + endGame = true + break + } + + if posP1 == 0 && posP2 == 0 { + fmt.Println("Not winner race end tie!!") + endGame = true + break + } + + } + return endGame +} + +/* funciones auxilares*/ + +// pintar jugadores en la pista +func PaintingCar(numTracks, positionCar int, emojiCar string, positionTree []int, shock bool) string { + var car string + + for t := 0; t < numTracks; t++ { + + switch { + case t == 0: + car += GOAL + case t == positionCar: + if shock { + car += SHOCK + } else { + car += emojiCar + } + default: + if tree := IsTree(t, positionTree); tree == true { + car += TREE + } else { + car += "_" + } + + } + + } + return car +} + +// saber si hay que pintar un arbol en la posicion actual +func IsTree(numTrack int, positionTree []int) (tree bool) { + for _, pos := range positionTree { + if pos == numTrack { + tree = true + } + } + return tree +} + +// generar el numero de arboles y la posicion del mismo +func FactoryTree(numTracks int) []int { + var posTree []int + numTrees := rand.Intn(4-1) + 1 + max := numTracks - 1 + + for t := 0; t < numTrees; t++ { + posTree = append(posTree, rand.Intn(max-1)+1) + } + return posTree +} + +// mover el auto del jugador y comprobar si ha chocado con algun obstaculo +func MoveCar(positionCar, numShock *int, positionTree []int) (colision bool) { + + if shock := IsTree(*positionCar, positionTree); shock == true && *numShock == 0 { + colision = true + *numShock++ + } else { + if *positionCar < 0 { + *positionCar = 0 + } else { + *positionCar -= rand.Intn(4-1) + 1 + } + } + return colision +} + +// controlar el modo de juego +func RaceGame() { + var option string = "y" + var f1 CarRace = &Race{} + for option != "n" { + f1.ConfigParams() + endGame := f1.StartRace() + if endGame { + fmt.Println("You can play a new race Y/N") + fmt.Scanf("%s", &option) + option = strings.ToLower(option) + } + } +} + +func main() { + RaceGame() +} diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/java/lcozatl.java b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/java/lcozatl.java new file mode 100644 index 0000000000..aba9dac816 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/java/lcozatl.java @@ -0,0 +1,158 @@ +package lcozatl; + +import java.util.HashMap; +import java.util.List; +import java.util.ArrayList; +import java.util.Random; +import java.util.concurrent.TimeUnit; + +public class lcozatl { + + private static final char OBSTACLE_SYMBOL = '|'; + private static final char AUTO_SYMBOL = '<'; + private static final char CRASH_SYMBOL = '*'; + private static final char WIN_SYMBOL = '$'; + + private static final int SHIFT_DELAY_SECONDS = 1; + private static final int MIN_MOVE = 1; + private static final int MAX_MOVE = 3; + private static final int NUMBER_OF_CARS = 2; + private static final int POSITIONS = 10; + private static final int MIN_GAP_BETWEEN_TREES = 3; + + public static void main(String[] args) { + race(); + } + + public static void race(){ + HashMap circuits = new HashMap<>(); + if (NUMBER_OF_CARS <= 0) { + System.out.println("Imposible ejecutar sin autos"); + } + + lcozatl mainClass = new lcozatl(); + + System.out.println("/* /* /* /* Circuito inicial"); + for (int i = 0; i < NUMBER_OF_CARS; i++) { + circuits.put(i, mainClass.new Track()); + System.out.println(circuits.get(i).getTrack() + " - > Auto " + (i+1)); + } + + boolean noCarWon = true; + int shift = 0; + List winners = new ArrayList(); + while(noCarWon){ + try { + TimeUnit.SECONDS.sleep(SHIFT_DELAY_SECONDS); + } catch (InterruptedException e) { + } + shift++; + System.out.println("/* /* /* /* Turno: " + shift); + for (int car : circuits.keySet()) { + Track currentTrack = circuits.get(car); + int positions = howManyAdvance(); + String advance = ""; + if (!currentTrack.moveCar(positions)) { + advance = " No avanzó debido al choque con un obstaculo"; + }else{ + advance = " avanzo: " + positions + " posiciones"; + } + System.out.println(currentTrack.getTrack() + " - > El auto " + (car+1) + advance); + if (currentTrack.carWon) { + winners.add(car+1); + noCarWon = false; + } + } + } + if (winners.size()>1) { + System.out.println("Carrera terminada, empate de los autos: " + winners.toString()); + }else{ + System.out.println("Carrera terminada, gana el auto: " + winners.get(0)); + } + } + + public static int howManyAdvance() { + Random random = new Random(); + + int randomNumber = random.nextInt(MAX_MOVE) + MIN_MOVE; + + return randomNumber; + } + + public class Track{ + private int positions = POSITIONS; + private int carPosition = POSITIONS + 1; + private boolean carLocked; + private StringBuilder track = new StringBuilder(); + private boolean carWon = false; + + public Track(){ + generateTrack(); + addRandomTrees(); + } + + private void generateTrack(){ + + this.track.append("#"); + for (int i = 0; i <= positions; i++) { + this.track.append("_"); + } + + } + + private void addRandomTrees() { + Random random = new Random(); + + int maxTrees = POSITIONS / 2; + int numbOfTrees = random.nextInt(maxTrees) + 1; + + if (numbOfTrees <= 0) { + return; + } + + int length = this.track.length() -1; + + for (int i = 1; i < POSITIONS && numbOfTrees > 0; i++) { + boolean placeTree = false; + placeTree = (random.nextInt(length)+1) % 2 != 0; + if (placeTree) { + this.track.setCharAt(i, OBSTACLE_SYMBOL); + i += MIN_GAP_BETWEEN_TREES; + } + + } + + } + + public boolean moveCar(int positions){ + if (carLocked) { + return carLocked = false; + } + + this.carPosition = this.carPosition - positions; + + if (carPosition >= 0 && this.track.charAt(carPosition) == OBSTACLE_SYMBOL) { + carLocked = true; + } + + return true; + } + + public String getTrack(){ + StringBuilder tempTrack = new StringBuilder(this.track); + char carSymbol = AUTO_SYMBOL; + if (carLocked) { + carSymbol = CRASH_SYMBOL; + } + if (this.carPosition <= 0) { + carSymbol = WIN_SYMBOL; + carWon = true; + this.carPosition = 0; + } + tempTrack.setCharAt(this.carPosition, carSymbol); + return tempTrack.toString(); + } + + } + +} \ No newline at end of file diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/REstolSurf.js b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/REstolSurf.js new file mode 100644 index 0000000000..ee70a3d318 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/REstolSurf.js @@ -0,0 +1,132 @@ + +const prompt = require("prompt-sync")(); + +const emojis = { car1: "🚙", car2: "🚗", tree: "🌲", end: "🏁", crash: "💥" }; +let raceDistance = 5; +let userBet = "azul"; +let track1 = [emojis.end], + track2 = [emojis.end]; + +//preguntar la distancia de la carrera +function userSelection() { + raceDistance = prompt( + "Que distancia quieres que tenga la pista (min.5 - max.30)? : " + ); + + while (raceDistance > 30 || raceDistance < 5 || isNaN(raceDistance)) { + raceDistance = prompt( + "La distancia tiene que ser entre min. 5 - max.30)? : " + ); + } + + //preguntar por que coche quiere apostar + userBet = prompt("A que coche quieres apostar el 'azul' o el 'rojo'? : "); + userBet = userBet.toLowerCase(); + + while (userBet !== "azul" && userBet !== "rojo") { + userBet = prompt("Sólo puedes seleccionar coche 'azul' o coche 'rojo'? : "); + userBet = userBet.toLowerCase(); + } + generateTrack(); +} +//generar pistas con de 1 a 3 arboles aleatorios +function generateTrack() { + const numberOfTrees = getRandomInt(4, 1); + + for (let i = 0; i < raceDistance; i++) { + track1.push("_"); + track2.push("_"); + } + + for (i = 0; i < numberOfTrees; i++) { + let randomPos1 = getRandomInt(raceDistance, 1); + let randomPos2 = getRandomInt(raceDistance, 1); + + while (track1[randomPos1] === emojis.tree) + randomPos1 = getRandomInt(raceDistance, 1); + while (track2[randomPos2] === emojis.tree) + randomPos2 = getRandomInt(raceDistance, 1); + + track1[randomPos1] = emojis.tree; + track2[randomPos2] = emojis.tree; + } + + track1.push(emojis.car1); + track2.push(emojis.car2); + showRace(); + countdown(); +} +//mostrar arranque de la carrera +function countdown() { + let c = 3; + let countdownIdInterval = setInterval(() => { + if (c == 0) { + console.log("START"); + clearInterval(countdownIdInterval); + raceStart(); + } else console.log(c); + c--; + }, 1000); +} + +//generar turnos y movimientos aleatorio +function raceStart() { + let randomMov1 = 1; + let randomMov2 = 1; + let ind1 = 0; + let ind2 = 0; + showRace(); + raceIdInt = setInterval(() => { + randomMov1 = getRandomInt(4, 1); + randomMov2 = getRandomInt(4, 1); + + if (randomMov1 > track1.length) randomMov1 = track1.length; + + ind1 = track1.length - (randomMov1 + 1); + + if ( randomMov2 > track2.length) randomMov2 = track2.length; + + ind2 = track2.length - (randomMov2 + 1); + + + (track1[ind1] === emojis.tree) + ? track1.splice(ind1, randomMov1, emojis.crash) + : track1.splice(ind1, randomMov1); + + + (track2[ind2] === emojis.tree) + ? track2.splice(ind2, randomMov2, emojis.crash) + : track2.splice(ind2, randomMov2); + + showRace(); + + if (track1.length <= 1 || track2.length <= 1) { + showResult(); + clearInterval(raceIdInt); + } + }, 1000); +} + +//gestionar choque + +//mostrar ganador y resultado de la apuesta +function showResult() { + //gestionar empate + const winner = + track1.length === 1 ? (track2.length === 1 ? "both" : "azul") : "rojo"; + const betResult = winner === userBet || winner === "both" ? "win" : "lost"; + console.log(`FINISH! ${winner.toUpperCase()} WINS!! `); + console.log(`You ${betResult} your bet`); +} + +function showRace() { + console.clear(); + console.log(track1.join("")); + console.log(track2.join("")); +} + +function getRandomInt(max, min) { + return Math.floor(Math.random() * (max - min) + min); // The maximum is exclusive and the minimum is inclusive +} + +userSelection(); diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/klyone.js b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/klyone.js new file mode 100644 index 0000000000..5f71db696c --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/klyone.js @@ -0,0 +1,111 @@ +const MAX_TREES = 3; +const TREE_LIKEHOOD = 0.3; +const MAX_MOVE = 3; +const SIMULATION_STEP_MS = 1000; +const TARGET = "🏁"; +const CAR1 = "🚙"; +const CAR2 = "🚗"; +const TREE = "🌲"; +const CRASH = "💥"; +const ROAD = "_"; + +function waitNextStep() { + return new Promise(resolve => setTimeout(resolve, + SIMULATION_STEP_MS)); +} + +function showRaceStatus(header, road1, road2) { + console.log(header); + console.log(road1.join("")); + console.log(road2.join("")); +} + +function generateRoad(car, roadSize) { + let road = []; + let numTrees = 0; + + road.push(TARGET); + + for(let i = 0 ; i < roadSize ; i++) { + if (numTrees < MAX_TREES) { + let p = Math.random(); + if (p < TREE_LIKEHOOD) { + road.push(TREE); + numTrees++; + } + else { + road.push(ROAD); + } + continue; + } + + road.push(ROAD); + } + + road.push(car); + + return road; +} + +async function runSimulation(road1, road2) { + let raceFinish = false; + let car1Crash = false; + let car2Crash = false; + + while (!raceFinish) { + await waitNextStep(); + + let car1Move = Math.floor(1 + Math.random() * (MAX_MOVE - 1)); + let car2Move = Math.floor(1 + Math.random() * (MAX_MOVE - 1)); + let car1Index = road1.indexOf(CAR1); + if (car1Index == -1) + car1Index = road1.indexOf(CRASH); + let car2Index = road2.indexOf(CAR2); + if (car2Index == -1) + car2Index = road2.indexOf(CRASH); + let newCar1Index = ((car1Index - car1Move) < 0) ? 0 : (car1Index - car1Move); + let newCar2Index = ((car2Index - car2Move) < 0) ? 0 : (car2Index - car2Move); + + if (!car1Crash) { + car1Crash = (road1[newCar1Index] == TREE); + road1[car1Index] = ROAD; + road1[newCar1Index] = (car1Crash ? CRASH : CAR1); + } else { + car1Crash = false; + newCar1Index = car1Index; + } + + if (!car2Crash) { + car2Crash = (road2[newCar2Index] == TREE); + road2[car2Index] = ROAD; + road2[newCar2Index] = (car2Crash ? CRASH : CAR2); + } else { + car2Crash = false; + newCar2Index = car2Index; + } + + showRaceStatus("Current", road1, road2); + + if ((!car1Crash && newCar1Index == 0) || (!car2Crash && newCar2Index == 0)) + raceFinish = true; + } + + showRaceStatus("Final", road1, road2); + + if (road1[0] == CAR1 && road2[0] == CAR2) { + console.log("Race: Draw"); + } else { + if (road1[0] == CAR1) { + console.log("Race: Car1 wins"); + } else { + console.log("Race: Car2 wins"); + } + } +} + +const roadSize = 10; +let road1 = generateRoad(CAR1, roadSize); +let road2 = generateRoad(CAR2, roadSize); + +showRaceStatus("Initial state", road1, road2); +runSimulation(road1, road2); diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/othamae.js b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/othamae.js new file mode 100644 index 0000000000..b8f3f2c90a --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/javascript/othamae.js @@ -0,0 +1,110 @@ +/* + * 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. + * + */ + +const car1 = "🚙" +const car2 = "🚗" +const meta = "🏁" +const tree = "🌲" +const crash = "💥" +function raceCart(trace){ + let [trace1, trace2] =createRacetrace(trace) + console.log(trace1) + console.log(trace2) + let carToMove = car1 + const interval = setInterval(() => { + if (carToMove === car1) { + trace1 = move(trace1, carToMove); + carToMove = car2 + } else { + trace2= move(trace2, carToMove); + carToMove = car1 + } + console.log('##################') + console.log(trace1) + console.log(trace2) + anyWinner(trace1, trace2) && clearInterval(interval) + + }, 1000); +} + + +// Helper functions + +function createRacetrace(trace){ + let trace1 = meta+ "_".repeat(trace)+ car1 + let trace2 = meta+"_".repeat(trace)+ car2 + trace1 = addTrees(trace1) + trace2 = addTrees(trace2) + return [trace1, trace2] +} + +function addTrees(trace){ + const traceArray = [...trace] + const trees = Math.floor(Math.random()*3) +1 + for (let i=1; i<=trees; i++){ + let treePosition + do { + treePosition = Math.floor(Math.random()*(traceArray.length -4))+2 + + } while (traceArray[treePosition] === tree) + traceArray[treePosition] = tree + } + return traceArray.join("") +} + +function move(trace, car){ + const steps= Math.floor(Math.random()*3) +1 + const traceArray = [...trace] + const crashPosition = traceArray.indexOf(crash) + if (crashPosition !== -1) { + traceArray[crashPosition] = car + return traceArray.join("") + } + const carPosition = traceArray.indexOf(car) + const newCarPosition = carPosition - steps + if (newCarPosition < 0){ + traceArray[0] = car + } else if (traceArray[newCarPosition] === tree){ + traceArray[newCarPosition] = crash + } else { + traceArray[newCarPosition] = car + } + traceArray[carPosition] = '_' + return traceArray.join("") +} + +function hasWin(currentTrace){ + return (!currentTrace.includes(meta) && !currentTrace.includes(crash)) +} + +function anyWinner(trace1, trace2){ + if (hasWin(trace1)){ + console.log(`🎉 Winner: Car ${car1} 🎉`) + return true + } + if (hasWin(trace2)){ + console.log(`🎉 Winner: Car ${car2} 🎉`) + return true + } + return false +} + +raceCart(12) \ No newline at end of file diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/inkhemi.py b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/inkhemi.py new file mode 100644 index 0000000000..f3c1981df9 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/inkhemi.py @@ -0,0 +1,132 @@ +import random + +floor = ["_", "🌲", "🏁", "💥"] +cars = ["🚗", "🚙"] + + +def race(large: int): + + # Se crea una pista aleatoria para cada auto + def create_path(large: int, player: int) -> list: + + # Se le añade la meta como primer elemento + path = [floor[2]] + trees = 0 + + for i in range(1, large-1): + if trees < 3: + if random.randint(1, 8) == 2: + path.append(floor[1]) + trees += 1 + continue + path.append(floor[0]) + + if trees == 0: + path[random.randint(1, large-1)] = floor[1] + + # Agregar un auto (player 0: auto rojo, player 1: auto verde) + path.append(cars[player]) + + return path + + # Obtener una lista de la carrera + path1 = create_path(large, 0) + path2 = create_path(large, 1) + + # Variables útiles + position1 = large - 1 + position2 = large - 1 + last_piece1 = floor[0] + last_piece2 = floor[0] + count1 = 0 + count2 = 0 + turn1 = True + turn2 = True + + # Convertir la lista en un string para mostrar en pantalla + show_path1 = "".join(x for x in path1) + show_path2 = "".join(x for x in path2) + + # Mostrar el inicio de la carrera + print(show_path1) + print(show_path2) + + # Iniciar la carrera + while path1[0] != cars[0] and path2[0] != cars[1]: + # Si ningún auto esta en la meta se mantiene el ciclo + + # Movimiento + if count1 != 0: + count1 -= 1 + move1 = 0 + path1[position1] = floor[1] + turn1 = False + else: + move1 = random.randint(1, 3) + + if count2 != 0: + count2 -= 1 + move2 = 0 + path2[position2] = floor[1] + turn2 = False + else: + move2 = random.randint(1, 3) + + # Reemplazar la pieza anterior + path1[position1] = last_piece1 + path2[position2] = last_piece2 + + # Reemplazar la pieza actual + position1 -= move1 + position2 -= move2 + if position1 < 0: + position1 = 0 + if position2 < 0: + position2 = 0 + + last_piece1 = path1[position1] + last_piece2 = path2[position2] + + # Revisar si ocurrió algún choque + if last_piece1 == floor[1] and last_piece2 == floor[1] and turn1 == True and turn2 == True: + path1[position1] = floor[3] + path2[position2] = floor[3] + count1 = 1 + count2 = 1 + turn1 = True + turn2 = True + + elif last_piece1 == floor[1] and turn1 == True: + path1[position1] = floor[3] + path2[position2] = cars[1] + count1 = 1 + turn1 = True + + elif last_piece2 == floor[1] and turn2 == True: + path1[position1] = cars[0] + path2[position2] = floor[3] + count2 = 1 + turn2 = True + + else: + path1[position1] = cars[0] + path2[position2] = cars[1] + turn1 = True + turn2 = True + + # Actualizar la carrera + show_path1 = "".join(x for x in path1) + show_path2 = "".join(x for x in path2) + + print(show_path1) + print(show_path2) + + if path1[0] == cars[0] and path2[0] == cars[1]: + print("Empate") + elif path1[0] == cars[0]: + print("Gana el auto 1") + else: + print("Gana el auto 2") + + +race(30) diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/jcdm60.py b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/jcdm60.py new file mode 100644 index 0000000000..fd1ae14dd6 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/jcdm60.py @@ -0,0 +1,123 @@ +# Reto #46: La carrera de coches +#### Dificultad: Media | Publicación: 27/11/23 | Corrección: 04/12/23 + +## Enunciado + +# +# 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. +# + +import random +import time + +class CarRace: + EMOJI_TREE = '🌲' + EMOJI_EXPLOSION = '💥' + EMOJI_CAR1 = '🚙' + EMOJI_CAR2 = '🚗' + EMOJI_FINISH = '🏁' + MAX_ADVANCEMENT = 3 + + def __init__(self, track_length=20): + self.track_length = track_length + self.finish_line = 0 + self.track_trees1 = self.generate_trees() + self.track_trees2 = self.generate_trees() + self.car1_position = self.track_length - 1 + self.car2_position = self.track_length - 1 + self.race_finished = False + + def generate_trees(self): + return random.sample(range(1, self.track_length - 1), random.randint(1, min(3, self.track_length - 2))) + + def display_track(self): + track1 = [self.EMOJI_TREE if i in self.track_trees1 else '_' for i in range(self.track_length)] + track2 = [self.EMOJI_TREE if i in self.track_trees2 else '_' for i in range(self.track_length)] + + # Modificar el icono en la posición de la meta según el coche que llegue primero + if self.finish_line == self.car1_position: + track1[self.finish_line] = self.EMOJI_CAR1 + track2[self.finish_line] = self.EMOJI_FINISH + elif self.finish_line == self.car2_position: + track2[self.finish_line] = self.EMOJI_CAR2 + track1[self.finish_line] = self.EMOJI_FINISH + else: + track1[self.finish_line] = self.EMOJI_FINISH + track2[self.finish_line] = self.EMOJI_FINISH + + # Mostrar los árboles y las posiciones de los coches + track1[self.car1_position] = self.EMOJI_EXPLOSION if self.car1_position in self.track_trees1 else self.EMOJI_CAR1 + track2[self.car2_position] = self.EMOJI_EXPLOSION if self.car2_position in self.track_trees2 else self.EMOJI_CAR2 + + print(''.join(track1)) + print(''.join(track2)) + print() + + + def cars_turn(self): + car1_advance = random.randint(1, self.MAX_ADVANCEMENT) + car2_advance = random.randint(1, self.MAX_ADVANCEMENT) + + new_car1_position = max(self.car1_position - car1_advance, 0) + if new_car1_position in self.track_trees1: + car1_advance = 0 + + new_car2_position = max(self.car2_position - car2_advance, 0) + if new_car2_position in self.track_trees2: + car2_advance = 0 + + self.car1_position = new_car1_position + self.car2_position = new_car2_position + + self.display_track() + time.sleep(1) + + if self.car1_position <= self.finish_line or self.car2_position <= self.finish_line: + self.race_finished = True + + return self.race_finished + + def start_race(self): + print(f"Posición inicial de los coches (Longitud de la Pista: {self.track_length}):") + self.display_track() + + while not self.race_finished: + self.race_finished = self.cars_turn() + + if self.car1_position <= self.finish_line and self.car2_position <= self.finish_line: + print("Es un empate!") + self.finish_line = min(self.car1_position, self.car2_position) + elif self.car1_position <= self.finish_line: + self.finish_line = self.car1_position + else: + self.finish_line = self.car2_position + + self.display_track() + if self.finish_line == self.car1_position and self.finish_line == self.car2_position: + print("Es un empate!") + elif self.finish_line == self.car1_position: + print("El Coche 🚙 ha ganado la carrera!") + else: + print("El Coche 🚗 ha ganado la carrera!") + +if __name__ == "__main__": + track_length = int(input("Ingrese la longitud de la pista: ")) + + race = CarRace(track_length) + race.start_race() diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/sirnas1983.py b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/sirnas1983.py new file mode 100644 index 0000000000..cb01839ac4 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/sirnas1983.py @@ -0,0 +1,100 @@ +# 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. + + +import random +import time + + +def pista_base(long): + pista = ["_" for i in range(0,long)] + return pista + +def pista_con_arbol_aleatorio(pista): + cantidad = random.randint(1,3) + for i in range(1, cantidad + 1): + pos = random.randint(0, len(pista)-1) + pista[pos] = "🌲" + return pista + +class auto: + + def __init__(self, icono, pista : list): + self.icono = icono + self.puede_mover = True + self.ganador = False + self.pista = pista + self.pista.insert(0,'🏁') + self.pista.append(icono) + self.mostrar_pista() + + def mostrar_pista(self): + print(''.join(self.pista)) + + def mover(self): + cas = random.randint(2,4) + indice = - cas + try: + if self.puede_mover and self.pista[indice] == "🌲": + self.puede_mover = False + self.pista[indice] = '💥' + self.pista = self.pista[:indice + 1] + elif self.puede_mover: + if self.pista[indice] == '🏁': + self.pista[indice] = self.icono + self.pista = self.pista[:indice + 1] + self.ganador = True + else: + self.pista[indice] = self.icono + self.pista = self.pista[:indice + 1] + else: + self.puede_mover = True + self.mostrar_pista() + except: + self.ganador = True + self.pista = [self.icono] + self.mostrar_pista() + + + + +def jugar(): + try: + longitud_pista = int(input("Ingrese la longitud de pista deseada: ")) + print("¡En sus marcas!") + time.sleep(1) + print("¿¿¿¡Listos!???") + auto1 = auto('🚙',pista_con_arbol_aleatorio(pista_base(longitud_pista))) + auto2 = auto('🚗',pista_con_arbol_aleatorio(pista_base(longitud_pista))) + time.sleep(1) + print("¡¡¡YAAAAAAA!!!") + while not auto1.ganador and not auto2.ganador: + auto1.mover() + auto2.mover() + time.sleep(1) + + if auto1.ganador == auto2.ganador: + print("Empate") + elif auto1.ganador: + print("¡¡VERDE GANADOR!!") + else: + print("¡¡ROJO GANADOR!!") + except: + print("Debe ingresar un entero") +jugar() + diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/EdGonzz.cs" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/EdGonzz.cs" new file mode 100644 index 0000000000..dbabd12b1f --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/EdGonzz.cs" @@ -0,0 +1,9 @@ +using System; + +public class HolaMundo +{ + public static void Main() + { + Console.WriteLine("Hola Mundo"); + } +} \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/marvnramos.cs" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/marvnramos.cs" new file mode 100644 index 0000000000..ff168f9c1e --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/marvnramos.cs" @@ -0,0 +1,9 @@ +using System; + +public class Program +{ + public static void Main() + { + Console.WriteLine("Hello, World!"); + } +} diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/go/EdGonzz.go" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/go/EdGonzz.go" new file mode 100644 index 0000000000..2892e4847f --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/go/EdGonzz.go" @@ -0,0 +1,7 @@ +package main + +import "ftm" + +func main() { + ftm.println("Hola Mundo!") +} \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/java/mtirador.java" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/java/mtirador.java" new file mode 100644 index 0000000000..c9de7c0923 --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/java/mtirador.java" @@ -0,0 +1,6 @@ +public class mtirador{ + public static void main(String []args){ + System.out.println("hello world"); + + } +} \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/EdGonzz.js" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/EdGonzz.js" new file mode 100644 index 0000000000..1ba44c718f --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/EdGonzz.js" @@ -0,0 +1,11 @@ +// ``` +// /* +// * 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]/javascript/iTzBigPerrito.js" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/iTzBigPerrito.js" new file mode 100644 index 0000000000..00b254cb13 --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/iTzBigPerrito.js" @@ -0,0 +1 @@ +console.log('Hola Mundo!'); \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/marvnramos.js" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/marvnramos.js" new file mode 100644 index 0000000000..06f320c59b --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/javascript/marvnramos.js" @@ -0,0 +1 @@ +console.log("Hello, world!"); \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/EdGonzz.py" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/EdGonzz.py" new file mode 100644 index 0000000000..865c819b61 --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/EdGonzz.py" @@ -0,0 +1 @@ +print("Hola Mundo!") \ No newline at end of file diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/marvnramos.py" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/marvnramos.py" new file mode 100644 index 0000000000..7b6a0e7e4a --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/marvnramos.py" @@ -0,0 +1 @@ +print("hello, world!") \ No newline at end of file diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/marvnramos.js b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/marvnramos.js new file mode 100644 index 0000000000..774a382fab --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/marvnramos.js @@ -0,0 +1,92 @@ +/* +player 1 +player 2 +tie +*/ + +/* +===== Lógica del juego ===== + 🖖 rompe ✂️ [✅] + 🖖 vaporiza 🗿 [✅] + + ✂️ decapita 🦎 [✅] + ✂️ corta 📄 [✅] + + 📄 desautoriza 🖖 [✅] + 📄 envuelve 🗿 [✅] + + 🗿 aplasta ✂️ [✅] + 🗿 aplasta 🦎 [✅] + + 🦎 envenena 🖖 [✅] + 🦎 devora 📄 [✅] +*/ + +const input = [ + ["🗿","✂️"], // 0 + ["✂️","🗿"], // 1 + ["📄","✂️"] // 2 +]; + + +/** + * Calcula e imprime qué jugador gana más partidas + * @param {Array} input - Arreglo de arreglos con las jugadas de cada jugador + */ +function firstPlace(input){ + let player1 = 0; + let player2 = 0; + let tie = 0; + + for(let i = 0; i < input.length; i++){ + if(input[i][0] === input[i][1]){ + tie++; + } + else if(input[i][0] === "🖖" && input[i][1] === "✂️"){ + player1++; + + } + else if(input[i][0] === "🖖" && input[i][1] === "🗿"){ + player1++; + } + else if(input[i][0] === "✂️" && input[i][1] === "🦎"){ + player1++; + } + else if(input[i][0] === "✂️" && input[i][1] === "📄"){ + player1++; + } + else if(input[i][0] === "📄" && input[i][1] === "🖖"){ + player1++; + } + else if(input[i][0] === "📄" && input[i][1] === "🗿"){ + player1++; + } + else if(input[i][0] === "🗿" && input[i][1] === "✂️"){ + player1++; + } + else if(input[i][0] === "🗿" && input[i][1] === "🦎"){ + player1++; + } + else if(input[i][0] === "🦎" && input[i][1] === "🖖"){ + player1++; + } + else if(input[i][0] === "🦎" && input[i][1] === "📄"){ + player1++; + } + else{ + player2++; + } + } + + if(tie > player1 && tie > player2){ + console.log("tie"); + } + else if(player1 > player2){ + console.log(`Player 1: ${player1} wins`); + } + else{ + console.log(`Player 2: ${player2} wins`); + } +} + +firstPlace(input); diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/wapastorv.js b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/wapastorv.js new file mode 100644 index 0000000000..296a2bb92c --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/javascript/wapastorv.js @@ -0,0 +1,53 @@ +const opcionesJuego = ['🪨', '📄', '✂️', '🦎', '🖖']; + +function calcularGanador(jugador1, jugador2){ + + const indexPlayer1 = opcionesJuego.indexOf(jugador1) + const indexPlayer2 = opcionesJuego.indexOf(jugador2) + + + const opcionesGanar = [ + [2, 1], // ✂️ corta 📄 + [1, 0], // 📄 cubre 🪨 + [0, 3], // 🪨 aplasta 🦎 + [3, 4], // 🦎 envenena 🖖 + [4, 2], // 🖖 rompe ✂️ + [2, 3], // ✂️ decapita 🦎 + [3, 1], // 🦎 come 📄 + [1, 4], // 📄 desautoriza 🖖 + [4, 0], // 🖖 vaporiza 🪨 + [0, 2], // 🪨 aplasta ✂️ + ] + + if (indexPlayer1 === indexPlayer2){ + return 'Tie' + } + + if(opcionesGanar.some(par => par[0] === indexPlayer1 && par[1] === indexPlayer2)){ + return 'Jugador 1 gana' + }else { + return 'Jugador 2 Gana' + } +} + +function jugarPartidas(jugadas){ + + for( const jugada of jugadas){ + + const resultado = calcularGanador(jugada[0],jugada[1]) + + console.log(`Resultado de la partia: ${resultado}`) + } + +} + +const jugadas=[ + ['🪨','✂️'], + ['✂️','🪨'], + ['📄','✂️'], + ['🪨', '✂️'], + ['🦎', '🖖'], + ['📄', '🦎'], + ['✂️', '🪨'] + ] +jugarPartidas(jugadas) diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/iTzBigPerrito.py b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/iTzBigPerrito.py new file mode 100644 index 0000000000..b0c7792e9e --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/iTzBigPerrito.py @@ -0,0 +1,65 @@ +def main(): + print('PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK') + rockWin = ['lagarto', 'tijera'] + paperWin = ['piedra', 'spock'] + scissorsWin = ['papel', 'lagarto'] + lizzardWin = ['spock', 'papel'] + spockWin = ['piedra','tijera'] + playLog = [] + for x in range(1,4): + print(f'RONDA {x}') + fPlayerInput = str(input('Player 1 plays: ')).lower + sPlayerInput = str(input('Player 2 plays: ')).lower + result = 0 + fPlayerScore = 0 + sPlayerScore = 0 + + if(fPlayerInput == sPlayerInput): + result = 'Tie' + # Piedra if + elif(fPlayerInput == 'piedra'): + if(sPlayerInput in rockWin): + result = 1 + else: + result = 2 + # Papel if + elif(fPlayerInput == 'papel'): + if(sPlayerInput in paperWin): + result = 1 + else: + result = 2 + # Tijera if + elif(fPlayerInput == 'tijera'): + if(sPlayerInput in scissorsWin): + result = 1 + else: + result = 2 + # Lagarto if + elif(fPlayerInput == 'lagarto'): + if(sPlayerInput in lizzardWin): + result = 1 + else: + result = 2 + # Spock if + elif(fPlayerInput == 'spock'): + if(sPlayerInput in spockWin): + result = 1 + else: + result = 2 + # First Player Score + if(result == 1): + fPlayerScore += 1 + # Second Player Score + if(result == 2): + sPlayerScore += 1 + playLog.append(result) + if(fPlayerScore == sPlayerScore): + winner = 'Tie' + elif(fPlayerScore > sPlayerScore): + winner = 'Player 1' + else: + winner = 'Player 2' + print(f'Resultado: {winner}') + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/rokmanhaman.py b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/rokmanhaman.py new file mode 100644 index 0000000000..37db3d7f2f --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/rokmanhaman.py @@ -0,0 +1,46 @@ + +"""Reto #6: PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK +/* + * 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 who_win(games): + + rules_win = { + "ROCK" : ["SCISSORS", "LIZARD"], + "PAPER" : ["ROCK", "SPOCK"], + "SCISSORS" : ["PAPER", "LIZARD"], + "SPOCK" : ["ROCK", "SCISSORS"], + "LIZARD" : ["PAPER", "SPOCK"] + } + + pp1 = 0 # puntos player 1 + pp2 = 0 # puntos player 2 + for game in games: + if game[0] != game[1]: + if game[1] in rules_win[game[0]]: + pp1 +=1 + else: + pp2 +=1 + print(f"{pp1} a {pp2}") + + + + return "Tie" if pp1 == pp2 else "Player 1" if pp1 > pp2 else "Player 2" + + +print(who_win([("SCISSORS", "LIZARD"), ("PAPER", "LIZARD"), ("ROCK", "SCISSORS"), ("ROCK", "SCISSORS"), ("ROCK", "SCISSORS")])) + + + + + + diff --git a/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/marvnramos.js b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/marvnramos.js new file mode 100644 index 0000000000..b93766e3af --- /dev/null +++ b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/javascript/marvnramos.js @@ -0,0 +1,74 @@ +/* + * 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'); + +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout +}); + +/** + * + * @param {*} question - Pregunta a realizar + * @param {*} options - Array de opciones + * @returns - Promise que se resuelve con la opción seleccionada + */ +function askQuestion(question, options) { + return new Promise((resolve, reject) => { + const formattedOptions = options.map((option, index) => `${index + 1}. ${option}`); + rl.question(`${question}\n${formattedOptions.join('\n')}\n`, (answer) => { + const selectedOption = parseInt(answer); + if (isNaN(selectedOption) || selectedOption < 1 || selectedOption > options.length) { + console.log('Respuesta no válida. Por favor, elige una opción válida.'); + reject(); + } else { + resolve(selectedOption); + } + }); + }); +} + + +async function startSortingHat() { + console.log('¡Bienvenido al Sombrero Seleccionador de Hogwarts!'); + + const answers = []; + + // Preguntas + answers.push(await askQuestion('¿Qué cualidad valoras más?', ['Valentía', 'Ambición', 'Lealtad', 'Intelecto'])); + answers.push(await askQuestion('¿Cómo te enfrentas a los desafíos?', ['Con coraje', 'Con astucia', 'Con paciencia', 'Con sabiduría'])); + answers.push(await askQuestion('¿Cuál es tu animal favorito?', ['León', 'Serpiente', 'Tejón', 'Águila'])); + answers.push(await askQuestion('¿Qué color te gusta más?', ['Rojo', 'Verde', 'Amarillo', 'Azul'])); + answers.push(await askQuestion('¿Qué actividad disfrutas más?', ['Deportes', 'Planificación estratégica', 'Cuidar de otros', 'Estudio'])); + + // Algoritmo de selección de casa + const totalGryffindor = answers[0] + answers[1]; + const totalSlytherin = answers[1] + answers[3]; + const totalHufflepuff = answers[2] + answers[4]; + const totalRavenclaw = answers[4] + answers[3]; + + const maxTotal = Math.max(totalGryffindor, totalSlytherin, totalHufflepuff, totalRavenclaw); + + if (maxTotal === totalGryffindor) { + console.log('¡Eres de Gryffindor!'); + } else if (maxTotal === totalSlytherin) { + console.log('¡Eres de Slytherin!'); + } else if (maxTotal === totalHufflepuff) { + console.log('¡Eres de Hufflepuff!'); + } else { + console.log('¡Eres de Ravenclaw!'); + } + + rl.close(); +} + +startSortingHat(); diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/marvnramos.js b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/marvnramos.js new file mode 100644 index 0000000000..f786827ebc --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/javascript/marvnramos.js @@ -0,0 +1,26 @@ +/** + * Generates a random number between min and max (inclusive). + * @param {number} min - The minimum number in the range. + * @param {number} max - The maximum number in the range. + * @returns {number} - A random number between min and max. + */ +const getRandomNumber = (min, max) =>{ + + // Get the last 3 digits of the current timestamp + const lastThreeDigits = Date.now().toString().slice(-3); + + // Convert the last three digits to a number and divide by 10, rounding it + let randomNumber = Math.round(Number(lastThreeDigits) / 10); + + + // Ensure the random number is within the specified range + if (randomNumber < min) { + randomNumber = min; + } else if (randomNumber > max) { + randomNumber = max; + } + + return randomNumber; +} + +console.log(getRandomNumber(0, 100)); \ No newline at end of file diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/feltoxXx.py b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/feltoxXx.py new file mode 100644 index 0000000000..abc1960b5a --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/feltoxXx.py @@ -0,0 +1,23 @@ +# 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... +# + +import time + +def rand_val(x): + + random=int(time.time()*1000) + + random %= (x + 1) + + return random + + +for x in range(100): + print(rand_val(x)) diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/javascript/marvnramos.js" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/javascript/marvnramos.js" new file mode 100644 index 0000000000..6311e6a853 --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/javascript/marvnramos.js" @@ -0,0 +1,73 @@ +/** + * A function that tests if a string is a heterogram + * @param {*} string - a string to be tested + * @returns - true if the string is a heterogram, false otherwise + */ +const isHeterogram = function(string){ + for(let i = 0; i < string.length; i++){ + let character = string[i]; + + if(string.indexOf(character) !== string.lastIndexOf(character)){ + return false; // the character is repeated + }; + }; + + return true; +}; + +/** + * Validates if a string is an isogram + * @param {*} string - a string to be tested + * @returns - true if the string is an isogram, false otherwise + */ +const isIsogram = function(string){ + const containsNumbers = /[0-9]/; + + if(containsNumbers.test(string)){ + return false; // the string contains numbers so it is not an isogram + } + + for(let i = 0; i < string.length; i++){ + let character = string[i]; + + if(string.indexOf(character) !== string.lastIndexOf(character)){ + return false; // the character is repeated + }; + }; + + return true; +}; + +/** + * Validates if a string is a pangram + * @param {*} string - a string to be tested + * @returns - true if the string is a pangram, false otherwise + */ +const isPangram = function(string){ + const containsNumbers = /[0-9]/; + const containsSpecialCharacters = /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/; + + if(containsNumbers.test(string) || containsSpecialCharacters.test(string)){ + return false; // the string contains numbers or special characteres so it is not an pangram + } + + const regex = /[a-z]/g; + let lowerCaseString = string.toLowerCase(); + let letters = new Set(lowerCaseString.match(regex)); + + return letters.size === 26; // the string contains all the letters of the alphabet +}; + + +let string_heterogram = "Hi, het3rog4m"; +console.log(isHeterogram(string_heterogram)); + + +let string_isogram = "H3y, 1s0gr4ms 4r3 c00l!"; +let string_isogram2 = "Hey isogram"; +console.log(isIsogram(string_isogram)); +console.log(isIsogram(string_isogram2)); + +let string_pangram = "The quick brown fox jumps over a lazy dog"; +console.log(isPangram(string_pangram)); + diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/feltoxXx.py" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/feltoxXx.py" new file mode 100644 index 0000000000..fc5d35ef54 --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/feltoxXx.py" @@ -0,0 +1,34 @@ +# Reto #9: Heterograma, isograma y pangrama + +# +# 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. +# + +def es_heterograma(texto): + texto = texto.replace(" ", "").lower() + return len(texto) == len(set(texto)) + + +def es_isograma(texto): + texto = texto.replace(" ", "").lower() + return len(texto) == len(set(texto)) + + +def es_pangrama(texto): + alfabeto = set("abcdefghijklmnopqrstuvwxyz") + texto = texto.lower() + return set(texto) >= alfabeto + + +texto_heterograma = "hiperblanduzcos" +texto_isograma = "anna" +texto_pangrama = "Benjamín pidió una bebida de kiwi y fresa. Noé, sin vergüenza, la más exquisita champaña del menú" + +resultado_heterograma = es_heterograma(texto_heterograma) +print(f'"{texto_heterograma}" es un heterograma: {resultado_heterograma}') +resultado_isograma = es_isograma(texto_isograma) +print(f'"{texto_isograma}" es un isograma: {resultado_isograma}') +resultado_pangrama = es_pangrama(texto_pangrama) +print(f'"{texto_pangrama}" es un pangrama: {resultado_pangrama}') + diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/rokmanhaman.py" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/rokmanhaman.py" new file mode 100644 index 0000000000..7c35182215 --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/rokmanhaman.py" @@ -0,0 +1,74 @@ +"""Reto #9: HETEROGRAMA, ISOGRAMA Y PANGRAMA +FÁCIL | Publicación: 27/02/23 | Resolución: 06/03/23 +/* + * 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. + */""" + +# HETEROGRAMA: palabra o frase que no contiene ninguna letra repetida. +# ISOGRAMA: palabra o frase en la que cada letra aparece el mismo número de veces +# PANGRAMA: es un texto que usa todas las letras posibles del alfabeto de un idioma + +import string + +class MyText(): + + def __init__(self, text): + self.text = text + + def is_heterograma(self): + text_without_spaces = self.text.replace(" ", "") + text_without_duplicated = set(text_without_spaces) + + ocurrencias = { + text_without_duplicated: + self.text.count(text_without_duplicated) + for text_without_duplicated in text_without_duplicated} + + max_occ = max(ocurrencias.values()) + + return "es HETEROGRAMA" if max_occ == 1 else "no es HETEROGRAMA" + + def is_isograma(self): + text_without_spaces = self.text.replace(" ", "") + text_without_duplicated = set(text_without_spaces) + + ocurrencias = { + text_without_duplicated: + self.text.count(text_without_duplicated) + for text_without_duplicated in text_without_duplicated} + + lista = list(ocurrencias.values()) + check = True + for index, val in enumerate(lista): + check = lista[index] == lista[0] and check + + return "es ISOGRAMA" if check == True else "no es ISOGRAMA" + + def is_pangrama(self): + text_without_spaces = self.text.replace(" ", "") + text_without_duplicated = set(text_without_spaces) + lpos = string.ascii_lowercase + + check = True + for l in lpos: + if l in text_without_duplicated: + check = True and check + else: + check = False + + + + return "es PANGRAMA" if check == True else "no es PANGRAMA" + + +#frase = "murciélago" +#frase = "mama" +frase = "El veloz murciélago hindú comía feliz cardillo y kiwi. La cigüeña tocaba el saxofón detrás del palenque de paja" + +f = MyText(frase) +print(f.is_heterograma()) +print(f.is_isograma()) +print(f.is_pangrama()) + diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/treber.py" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/treber.py" new file mode 100644 index 0000000000..c136322cae --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/treber.py" @@ -0,0 +1,80 @@ +# 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. + */ +""" +""" +* Heterograma: +Un heterograma (del griego héteros, 'diferente' y gramma, 'letra') +es una palabra o frase que no contiene ninguna letra repetida. + +* Isograma: +Un isograma (del griego isos, 'igual' y gramma, 'letra') +es una palabra o frase en la que cada letra aparece el mismo número de veces + +* Pangrama: +Un pangrama (del griego pan, 'todo' y gramma, 'letra') +es una frase en la que aparecen todas las letras del abecedario. +Si cada letra aparece sólo una vez, formando por tanto un heterograma, se le llama pangrama perfecto + +""" +import string + +def pangrama(txt): # + + txt = txt.lower() + for i in string.ascii_lowercase: + if i not in txt: + return False + + return True + +def heterograma(txt): + + for i in range(len(txt)): + start = i+1 + if start < len(txt): + if txt[i] in txt[start:len(txt)]: + return False + + return True + +def isograma(txt): + + for i in range(len(txt)): + start = i+1 + if start < len(txt): + if txt[i] in txt[start:len(txt)]: + return True + + return False + + +def inputTexto(): + + txt_input = input("Escriba una palabra o frase: ") + + if pangrama(txt_input): + print("El texto es un pangrama.") + elif heterograma(txt_input): + print("El texto es un heterograma.") + elif isograma(txt_input): + print("El texto es un isograma.") + else: + print("El texto no es un heterograma, isograma ni pangrama.") + + +inputTexto() + +""" +Probar los siguientes textos: +1. Benjamín pidió una bebida de kiwi y fresa. Noé, sin vergüenza, la más exquisita champaña del menú +2. yuxtaponer +3. escritura +""" \ No newline at end of file