diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/c++/acoidaan.cpp" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/c++/acoidaan.cpp" new file mode 100644 index 0000000000..2794af82ba --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/c++/acoidaan.cpp" @@ -0,0 +1,19 @@ +#include +int main() { + int n{1}; + while (n <= 100) { + if (n % 3 == 0 && n % 5 == 0) { + std::cout << "fizzbuzz" << std::endl; + } + if (n % 3 == 0) { + std::cout << "fizz" << std::endl; + } + if (n % 5 == 0) { + std::cout << "buzz" << std::endl; + } else { + std::cout << n << std::endl; + } + n++; + } + return 0; +} \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/dart/thegera.dart" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/dart/thegera4.dart" similarity index 100% rename from "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/dart/thegera.dart" rename to "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/dart/thegera4.dart" diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Sebastian09173.java" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Sebastian1973.java" similarity index 100% rename from "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Sebastian09173.java" rename to "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Sebastian1973.java" diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/vitrivix.js" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/vitrivix.js" new file mode 100644 index 0000000000..ef60c9a25c --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/vitrivix.js" @@ -0,0 +1,18 @@ +/* + * Escribe un programa que muestre por consola (con un print) los + * números de 1 a 100 (ambos incluidos y con un salto de línea entre + * cada impresión), sustituyendo los siguientes: + * - Múltiplos de 3 por la palabra "fizz". + * - Múltiplos de 5 por la palabra "buzz". + * - Múltiplos de 3 y de 5 a la vez por la palabra "fizzbuzz". + */ + +function fizzbuzz(){ + for (let i = 1; i <= 100; i++) { + if(i % 3 === 0 && i % 5 === 0) console.log('fizzbuzz'); + else if (i % 3 === 0) console.log('fizz'); + else if (i % 5 === 0) console.log('buzz'); + else console.log(i); + } +} +fizzbuzz() \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/TheAsintota.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/The-Asintota.py" similarity index 100% rename from "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/TheAsintota.py" rename to "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/The-Asintota.py" diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/luiveldel.py" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/luiveldel.py" new file mode 100644 index 0000000000..03f718e6f0 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/python/luiveldel.py" @@ -0,0 +1,19 @@ +# Create by luiveldel +# 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". + +num_1_100 = range(1, 101) + +for n in num_1_100: + if n % 3 == 0: + print("fizz",'\n') + elif n % 5 == 0: + print("buzz",'\n') + elif n % 3 == 0 and n % 5 == 0: + print("fizzbuzz",'\n') + else: + print(n,'\n') \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/rust/regalk.rs" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/rust/regalk13.rs" similarity index 100% rename from "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/rust/regalk.rs" rename to "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/rust/regalk13.rs" diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/c++/acoidaan.cpp" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/c++/acoidaan.cpp" new file mode 100644 index 0000000000..2ae2703c3d --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/c++/acoidaan.cpp" @@ -0,0 +1,60 @@ +#include +#include +#include +#include +std::string toLower(const std::string& text) { + std::string result; + for (char c : text) { + result += std::tolower(c); + } + return result; +} + +int main() { + const std::map leet_alphabet = { + {'a', "4",}, + {'b', "I3",}, + {'c', "[",}, + {'e', "3",}, + {'d', ")",}, + {'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"}, + {' ', " "} + }; + std::string input_text; + std::cout << "Write some text to be translated to hacker language" << std::endl; + std::getline(std::cin, input_text); + std::string lower_text = toLower(input_text); + for (char i : lower_text) { + std::cout << leet_alphabet.at(i); + } +} \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/Oskitar_Ale.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/Oskitar-Ale.py" similarity index 95% rename from "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/Oskitar_Ale.py" rename to "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/Oskitar-Ale.py" index e97b0e9159..66d26acbcc 100644 --- "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/Oskitar_Ale.py" +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/Oskitar-Ale.py" @@ -1,60 +1,60 @@ - -# 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") - -leet = { - 'a': '4', - 'b': '8', - 'c': '<', - 'd': '|)', - 'e': '3', - 'f': '|=', - 'g': '9', - 'h': '#', - 'i': '1', - 'j': '_|', - 'k': '|<', - 'l': '1', - 'm': '|\/|', - 'n': '|\|', - 'o': '0', - 'p': '|>', - 'q': '(_,)', - 'r': '|2', - 's': '5', - 't': '7', - 'u': '|_|', - 'v': '\/', - 'w': '\/\/', - 'x': '><', - 'y': '¥', - 'z': '2', - '1': 'L', - '2': 'Z', - '3': 'E', - '4': 'A', - '5': 'S', - '6': 'b', - '7': 'T', - '8': 'B', - '9': 'g', - '0': 'O' -} - -def text_to_leet(text): - result = '' - for char in text.lower(): - if char in leet: - result += leet[char] - else: - result += char - return result - -texto_original = input("Ingrese un texto: ") -texto_en_leet = text_to_leet(texto_original) -print("Texto transformado en leet:") -print(texto_en_leet) + +# 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") + +leet = { + 'a': '4', + 'b': '8', + 'c': '<', + 'd': '|)', + 'e': '3', + 'f': '|=', + 'g': '9', + 'h': '#', + 'i': '1', + 'j': '_|', + 'k': '|<', + 'l': '1', + 'm': '|\/|', + 'n': '|\|', + 'o': '0', + 'p': '|>', + 'q': '(_,)', + 'r': '|2', + 's': '5', + 't': '7', + 'u': '|_|', + 'v': '\/', + 'w': '\/\/', + 'x': '><', + 'y': '¥', + 'z': '2', + '1': 'L', + '2': 'Z', + '3': 'E', + '4': 'A', + '5': 'S', + '6': 'b', + '7': 'T', + '8': 'B', + '9': 'g', + '0': 'O' +} + +def text_to_leet(text): + result = '' + for char in text.lower(): + if char in leet: + result += leet[char] + else: + result += char + return result + +texto_original = input("Ingrese un texto: ") +texto_en_leet = text_to_leet(texto_original) +print("Texto transformado en leet:") +print(texto_en_leet) diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jorgea_hn.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jorgea-hn.py" similarity index 100% rename from "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jorgea_hn.py" rename to "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jorgea-hn.py" diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/luiveldel.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/luiveldel.py" new file mode 100644 index 0000000000..4ff9903c26 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/luiveldel.py" @@ -0,0 +1,26 @@ +# Created by luiveldel +# 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") + + +# First, create a dictionary for the hacker language +hacker_dict = {'a': '4', + 'e': '3', + 'i': '1', + 'o': '0', + 'A': '4', + 'E': '3', + 'I': '1', + 'O': '0'} + +word = "hacker" + +for k, v in hacker_dict.items(): + word = word.replace(k, v) + + +print(word) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/opibl1.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/opibl.py" similarity index 96% rename from "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/opibl1.py" rename to "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/opibl.py" index a5dc5b511e..6353f16161 100644 --- "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/opibl1.py" +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/opibl.py" @@ -1,68 +1,68 @@ - -def cambiar_texto(texto): - i = 0 - nuevo_texto = list(texto) - while i < len(texto): - if nuevo_texto[i] == 'A': - nuevo_texto[i] = '4' - if nuevo_texto[i] == 'B': - nuevo_texto[i] = 'I3' - if nuevo_texto[i] == 'C': - nuevo_texto[i] = '[' - if nuevo_texto[i] == 'D': - nuevo_texto[i] = ')' - if nuevo_texto[i] == 'E': - nuevo_texto[i] = '3' - if nuevo_texto[i] == 'F': - nuevo_texto[i] = '|=' - if nuevo_texto[i] == 'G': - nuevo_texto[i] = '&' - if nuevo_texto[i] == 'H': - nuevo_texto[i] = '#' - if nuevo_texto[i] == 'I': - nuevo_texto[i] = '1' - if nuevo_texto[i] == 'J': - nuevo_texto[i] = ',_|' - if nuevo_texto[i] == 'K': - nuevo_texto[i] = '>|' - if nuevo_texto[i] == 'L': - nuevo_texto[i] = '1' - if nuevo_texto[i] == 'M': - nuevo_texto[i] = '[V]' - if nuevo_texto[i] == 'N': - nuevo_texto[i] = '^/' - if nuevo_texto[i] == "O": - nuevo_texto[i] = '0' - if nuevo_texto[i] == 'P': - nuevo_texto[i] = '|*' - if nuevo_texto[i] == 'Q': - nuevo_texto[i] = '(_,)' - if nuevo_texto[i] == 'R': - nuevo_texto[i] = 'I2' - if nuevo_texto[i] == 'S': - nuevo_texto[i] = '5' - if nuevo_texto[i] == 'T': - nuevo_texto[i] = '7' - if nuevo_texto[i] == 'U': - nuevo_texto[i] = '(_)' - if nuevo_texto[i] == 'V': - nuevo_texto[i] = '\/' - if nuevo_texto[i] == 'W': - nuevo_texto[i] = '\/\/' - if nuevo_texto[i] == 'X': - nuevo_texto[i] = '><' - if nuevo_texto[i] == 'Y': - nuevo_texto[i] = 'j' - if nuevo_texto[i] == 'Z': - nuevo_texto[i] = '2' - - - i = i + 1 - - texto = "".join(nuevo_texto) - print("TEXTO TRANSFORMADO",texto) - - -texto = input('Escribe un texto\n') -texto = texto.upper() + +def cambiar_texto(texto): + i = 0 + nuevo_texto = list(texto) + while i < len(texto): + if nuevo_texto[i] == 'A': + nuevo_texto[i] = '4' + if nuevo_texto[i] == 'B': + nuevo_texto[i] = 'I3' + if nuevo_texto[i] == 'C': + nuevo_texto[i] = '[' + if nuevo_texto[i] == 'D': + nuevo_texto[i] = ')' + if nuevo_texto[i] == 'E': + nuevo_texto[i] = '3' + if nuevo_texto[i] == 'F': + nuevo_texto[i] = '|=' + if nuevo_texto[i] == 'G': + nuevo_texto[i] = '&' + if nuevo_texto[i] == 'H': + nuevo_texto[i] = '#' + if nuevo_texto[i] == 'I': + nuevo_texto[i] = '1' + if nuevo_texto[i] == 'J': + nuevo_texto[i] = ',_|' + if nuevo_texto[i] == 'K': + nuevo_texto[i] = '>|' + if nuevo_texto[i] == 'L': + nuevo_texto[i] = '1' + if nuevo_texto[i] == 'M': + nuevo_texto[i] = '[V]' + if nuevo_texto[i] == 'N': + nuevo_texto[i] = '^/' + if nuevo_texto[i] == "O": + nuevo_texto[i] = '0' + if nuevo_texto[i] == 'P': + nuevo_texto[i] = '|*' + if nuevo_texto[i] == 'Q': + nuevo_texto[i] = '(_,)' + if nuevo_texto[i] == 'R': + nuevo_texto[i] = 'I2' + if nuevo_texto[i] == 'S': + nuevo_texto[i] = '5' + if nuevo_texto[i] == 'T': + nuevo_texto[i] = '7' + if nuevo_texto[i] == 'U': + nuevo_texto[i] = '(_)' + if nuevo_texto[i] == 'V': + nuevo_texto[i] = '\/' + if nuevo_texto[i] == 'W': + nuevo_texto[i] = '\/\/' + if nuevo_texto[i] == 'X': + nuevo_texto[i] = '><' + if nuevo_texto[i] == 'Y': + nuevo_texto[i] = 'j' + if nuevo_texto[i] == 'Z': + nuevo_texto[i] = '2' + + + i = i + 1 + + texto = "".join(nuevo_texto) + print("TEXTO TRANSFORMADO",texto) + + +texto = input('Escribe un texto\n') +texto = texto.upper() cambiar_texto(texto) \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/rust/regalk.rs" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/rust/regalk13.rs" similarity index 100% rename from "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/rust/regalk.rs" rename to "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/rust/regalk13.rs" diff --git "a/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/c#/deathiwng696.cs" "b/Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/c#/deathwing696.cs" similarity index 100% rename from "Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/c#/deathiwng696.cs" rename to "Retos/Reto #19 - AN\303\201LISIS DE TEXTO [Media]/c#/deathwing696.cs" diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/dart/titoworldev.dart b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/dart/titoworlddev.dart similarity index 100% rename from Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/dart/titoworldev.dart rename to Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/dart/titoworlddev.dart diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/CarlosRivera4726.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/CarlosRivera4726.py new file mode 100644 index 0000000000..06145fc082 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/CarlosRivera4726.py @@ -0,0 +1,74 @@ +''' + * 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. + */ + ''' + + + +#6 puntuaciones -> 0,1,2,3,4,5 +PUNTUACIONES = ("Love", "15", "30", "30", "Deuce", "Ventaja") + + + + +def imprimirPuntuaciones(puntuaciones1, puntuaciones2): + limite = 4 + if puntuaciones1 == limite and puntuaciones2 == limite: + print("Deuce") + + elif puntuaciones1 >= limite or puntuaciones2 >= limite: + puntos = puntuaciones1 - puntuaciones2 + if puntos == 0: + print("Deuce") + elif puntos == 1: + print("Ventaja P1") + elif puntos == -1: + print("Ventaja P2") + elif puntos >= 2: + print("Ha ganado el P1") + return + else: + print("Ha ganado el P2") + return + + + else: + print(f"{PUNTUACIONES[puntuaciones1]} - {PUNTUACIONES[puntuaciones2]}") + + + +puntuacionP1 = 0 +puntuacionP2 = 0 +def anotador(equipo): + global puntuacionP1, puntuacionP2 + if(equipo == 'P1'): + puntuacionP1 += 1 + elif equipo == 'P2': + puntuacionP2 += 1 + + imprimirPuntuaciones(puntuacionP1, puntuacionP2) + + +def main(): + lista_secuencia = ['P1', 'P1', 'P2', 'P2', 'P1', 'P2', 'P1', 'P1'] + for secuencia in lista_secuencia: + anotador(secuencia) + + +if __name__ == '__main__': + main() diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/breakngpitt.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/breakingpitt.py similarity index 100% rename from Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/breakngpitt.py rename to Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/breakingpitt.py diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgea_hn.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgea-hn.py similarity index 100% rename from Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgea_hn.py rename to Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgea-hn.py diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgearmasc.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgearmas.py similarity index 100% rename from Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgearmasc.py rename to Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jorgearmas.py diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/luiveldel.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/luiveldel.py new file mode 100644 index 0000000000..888e91cec3 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/luiveldel.py @@ -0,0 +1,56 @@ +# Created by luiveldel + +# 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. + + +from enum import Enum + +class Player(Enum): + P1 = 1 + P2 = 2 + +def game_results(player_win: list): + game = ['0', '15', '30', '40'] + score_p1 = 0 + score_p2 = 0 + game_finished = False + + for player in player_win: + if player == Player.P1: + score_p1 += 1 + else: + score_p2 += 1 + + if score_p1 >= 4 or score_p2 >= 4: + if abs(score_p1 - score_p2) >= 2: + game_finished = True + elif score_p1 == score_p2: + print("Deuce") + elif score_p1 > score_p2: + print("Advantage P1") + else: + print("Advantage P2") + else: + print(f'{game[score_p1]} - {game[score_p2]}') + + if score_p1 > score_p2: + print("Ha ganado el P1") + else: + print("Ha ganado el P2") + +game_results([Player.P1, Player.P1, Player.P2, Player.P1, Player.P2, Player.P2, Player.P2, Player.P1, Player.P1]) \ No newline at end of file diff --git "a/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/python/federcoronado.py" "b/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/python/federcoronado.py" deleted file mode 100644 index 34c4613633..0000000000 --- "a/Retos/Reto #21 - N\303\232MEROS PRIMOS GEMELOS [Media]/python/federcoronado.py" +++ /dev/null @@ -1,31 +0,0 @@ -''' -* 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) -''' - -rango = 1000 - -primo_1 = 1 -gemelos = [] -for i in range(1, rango): - #determino si es primo - primo = True - for j in range(2,i): - if i%j == 0: - primo = False - # si es primo lo comparo con le anterior, si la dif es 2 guardo el par - if primo: - primo_2 = i - if primo_2 - primo_1 == 2: - par = (primo_1, primo_2) - gemelos.append(par) - else: - primo_1 = primo_2 -print(gemelos) diff --git a/Retos/Reto #22 - LA ESPIRAL [Media]/javascript/marcode.js b/Retos/Reto #22 - LA ESPIRAL [Media]/javascript/marcode24.js similarity index 100% rename from Retos/Reto #22 - LA ESPIRAL [Media]/javascript/marcode.js rename to Retos/Reto #22 - LA ESPIRAL [Media]/javascript/marcode24.js diff --git "a/Retos/Reto #24 - CIFRADO C\303\211SAR [F\303\241cil]/python/EspinoLeandro.py" "b/Retos/Reto #24 - CIFRADO C\303\211SAR [F\303\241cil]/python/EspinoLeandroo.py" similarity index 100% rename from "Retos/Reto #24 - CIFRADO C\303\211SAR [F\303\241cil]/python/EspinoLeandro.py" rename to "Retos/Reto #24 - CIFRADO C\303\211SAR [F\303\241cil]/python/EspinoLeandroo.py" diff --git "a/Retos/Reto #25 - EL C\303\223DIGO KONAMI [Media]/java/Ivanrm.java" "b/Retos/Reto #25 - EL C\303\223DIGO KONAMI [Media]/java/Ivan-rm.java" similarity index 100% rename from "Retos/Reto #25 - EL C\303\223DIGO KONAMI [Media]/java/Ivanrm.java" rename to "Retos/Reto #25 - EL C\303\223DIGO KONAMI [Media]/java/Ivan-rm.java" diff --git "a/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/go/pepegonzalez.go" "b/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/go/pepegonzale.go" similarity index 100% rename from "Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/go/pepegonzalez.go" rename to "Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/go/pepegonzale.go" diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/dart/titoworldev.dart" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/dart/titoworlddev.dart" similarity index 100% rename from "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/dart/titoworldev.dart" rename to "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/dart/titoworlddev.dart" diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/Akhiro93.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/Akihiro93.py" similarity index 100% rename from "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/Akhiro93.py" rename to "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/Akihiro93.py" diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/CarlosRivera4726.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/CarlosRivera4726.py" new file mode 100644 index 0000000000..b1d760e52e --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/CarlosRivera4726.py" @@ -0,0 +1,53 @@ +'''* +/* + * 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 secrets + +def parameters(upperCase=True, numbers=True, symbols=True): + alphabet = "" + # si upperCase es verdadero + if upperCase: + # traemos todo el alfabeto en minusculas y mayusculas + alphabet = string.ascii_letters + else: + alphabet += string.ascii_lowercase + + if numbers: + alphabet += string.digits + + if symbols: + alphabet += string.punctuation + + #print(f"alphabet: {alphabet}") + + return alphabet + + + + +if __name__ == "__main__": + # menu + upperCase = input("Quieres que tu clave lleve Mayusculas?: (s) or (n): ") + numbers = input("Quieres que tu clave lleve Números?: (s) or (n): ") + symbols = input("Quieres que tu clave lleve Símbolos?: (s) or (n): ") + longitud = int(input("De que tamaño quieres tu contraseña?: (min: 8, max: 16): ")) + if (longitud >= 8) and (longitud <= 16): + upperCase = True if upperCase.lower() == 's' else False + numbers = True if numbers.lower() == 's' else False + symbols = True if symbols.lower() == 's' else False + + alphabet = parameters(upperCase=upperCase, numbers=numbers, symbols=symbols) + password = ''.join(secrets.choice(alphabet) for i in range(longitud)) + print(f"Tu contraseña: {password}") + else: + print("No se pudo completar la contraseña por la longitud!") \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/adra-dev.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/adra-dev.py" new file mode 100644 index 0000000000..94019fa92a --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/adra-dev.py" @@ -0,0 +1,46 @@ +""" +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 random +import string + +def password_gen(length=8, upper=False, digits=False, symbols=False): + """ Using https://www.ascii-code.com """ + + characters = list(range(97, 123)) + + if upper: + characters += list(range(65, 91)) + + if digits: + characters += list(range(48, 58)) + + if symbols: + characters += list(range(33, 48)) +\ + list(range(58, 65)) + list(range(91, 97)) + + password="" + + final_length = 8 if length < 8 else 16 if length > 16 else length + + while len(password) < final_length: + password += chr(random.choice(characters)) + + return password + + +print(password_gen()) +print(password_gen(length=16)) +print(password_gen(length=1)) +print(password_gen(length=22)) +print(password_gen(length=12, upper=True)) +print(password_gen(length=12, upper=True, digits=True)) +print(password_gen(length=12, upper=True, digits=True, symbols=True)) +print(password_gen(length=12, upper=True, symbols=True)) \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/ajlinformatico.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/ajloinformatico.py" similarity index 100% rename from "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/ajlinformatico.py" rename to "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/ajloinformatico.py" diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/luiveldel.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/luiveldel.py" new file mode 100644 index 0000000000..389fd1acaf --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/luiveldel.py" @@ -0,0 +1,19 @@ +# Created by luiveldel + +# 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 random # generate random numbers +import string # provide a set of characters to choose + +password_lengh: int = random.randint(8, 17) +characters: str = string.ascii_letters + string.digits + string.punctuation + +password: str = "".join(random.choice(characters) for i in range(password_lengh)) + +print(password) \ No newline at end of file diff --git "a/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/javascript/patriciotrujillo.js" "b/Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/javascript/patriciotrujilllo.js" similarity index 100% rename from "Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/javascript/patriciotrujillo.js" rename to "Retos/Reto #31 - EL \303\201BACO [F\303\241cil]/javascript/patriciotrujilllo.js" diff --git a/Retos/Reto #34 - EL TXT [Media]/python/JoseAntonioRuizGarica.py b/Retos/Reto #34 - EL TXT [Media]/python/JoseAntonioRuizGarcia.py similarity index 100% rename from Retos/Reto #34 - EL TXT [Media]/python/JoseAntonioRuizGarica.py rename to Retos/Reto #34 - EL TXT [Media]/python/JoseAntonioRuizGarcia.py diff --git a/Retos/Reto #36 - PERMUTACIONES [Media]/python/nicolauroca_v1.py b/Retos/Reto #36 - PERMUTACIONES [Media]/python/nicolauroca.py similarity index 100% rename from Retos/Reto #36 - PERMUTACIONES [Media]/python/nicolauroca_v1.py rename to Retos/Reto #36 - PERMUTACIONES [Media]/python/nicolauroca.py diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/c++/Mardowen.cpp b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/c++/Mardowen.cpp new file mode 100644 index 0000000000..23cbcc3ad6 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/c++/Mardowen.cpp @@ -0,0 +1,92 @@ +#include +using namespace std; + +/* + * Escribe un programa que, dado un nmero, compruebe y muestre si es primo, fibonacci y par. + * Ejemplos: + * - Con el nmero 2, nos dir: "2 es primo, fibonacci y es par" + * - Con el nmero 7, nos dir: "7 es primo, no es fibonacci y es impar" + */ + +void fibonacci(int); +void primo(int); +void par(int); + + + +int main(){ + int numero; + + cout<<"Coloca un numero: "; cin>>numero; + + fibonacci(numero); + primo(numero); + par(numero); + + + + + + return 0; +} + +void fibonacci(int n){ + int a=0, b=1,c=0; + + do{ + c= a+b; + b=a; + a=c; + + }while(c!=n and c <= n); + + if(c == n){ + cout<<"Es fibonacci, "; + } + + else{ + cout<<"No es fibonacci, "; + } +} + +void primo(int n){ + + int div=0; + + if(n < 2){ + + } + + else{ + + for(int i=2; i 1: + for index in range(2, number): + if number % index == 0: + result += "no es primo, " + break + else: + result += "es primo, " + + else: + result += "no es primo, " + + # Fibonacci + result += "es fibonacci " if number > 0 and (is_perfect_square(5 * number * number + 4) or is_perfect_square( + 5 * number * number - 4)) else "no es fibonacci " + + # Par + result += "y es par" if number % 2 == 0 else "y es impar" + + print(result) + + +def is_perfect_square(number): + sqrt = int(math.sqrt(number)) + return sqrt * sqrt == number + + + +prime_fibonacci_even(2) +prime_fibonacci_even(7) +prime_fibonacci_even(0) +prime_fibonacci_even(13) +prime_fibonacci_even(-2) \ 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/rokmanhaman.py similarity index 100% rename from Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/rokmanhamman.py rename to Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/rokmanhaman.py diff --git "a/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/kotlin/isaacus98.kt" "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/kotlin/isaacus98.kt" new file mode 100644 index 0000000000..d5b5f49e27 --- /dev/null +++ "b/Retos/Reto #43 - SIMULADOR DE CLIMA [F\303\241cil]/kotlin/isaacus98.kt" @@ -0,0 +1,83 @@ +import java.util.* + +/* + * 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. + */ + +fun main(args: Array) { + println("Inserte el numero de dias de la predicción: ") + val dia: String = readln() + simularClima(dia.toInt()) +} + +fun simularClima(dia: Int){ + println("Inserte la temperatura inicial: ") + var temperatura: Int = readln().toInt() + println("Inserte la probabilidad de lluvia: ") + var probabilidadLluvia: Int = readln().toInt() + var contadorDiasLluvia: Int = 0 + var aumentarDisminuirTemperatura: Int + val listaTiempo: MutableList = mutableListOf() + val rnd: Random = Random() + + for (i in 1..dia){ + aumentarDisminuirTemperatura = rnd.nextInt(11) + 1 + + if (aumentarDisminuirTemperatura == 1){ + temperatura += 2 + } + + if (aumentarDisminuirTemperatura == 2){ + temperatura -= 2 + } + + if (temperatura > 25){ + if ((probabilidadLluvia + 20) > 100) + probabilidadLluvia = 100 + else + probabilidadLluvia += 20 + } + + if (temperatura < 5){ + if ((probabilidadLluvia - 20) < 0) + probabilidadLluvia = 0 + else + probabilidadLluvia -= 20 + } + + listaTiempo.add(Tiempo(temperatura, probabilidadLluvia)) + + if (probabilidadLluvia == 100){ + temperatura -= 1 + contadorDiasLluvia += 1 + } + } + + //Mostrar datos por consola + for (tiempo in listaTiempo){ + println(tiempo.toString()) + } + + listaTiempo.sortBy { it.temperatura } + println("Temperatura mínima: ${listaTiempo[0].temperatura}") + println("Temperatura máxima: ${listaTiempo[listaTiempo.lastIndex].temperatura}") + println("Número de dias que ha llovido: " + contadorDiasLluvia) +} + +data class Tiempo(val temperatura: Int, val probabilidadLluvia: Int){ + override fun toString(): String { + return "Temperatura: " + temperatura.toString() + ", ProbabilidadLluvia: " + probabilidadLluvia.toString() + } +} \ No newline at end of file diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/c#/isaacus98.cs b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/c#/isaacus98.cs new file mode 100644 index 0000000000..dbdbc2f5bc --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/c#/isaacus98.cs @@ -0,0 +1,177 @@ +using System.IO; + +namespace RetosProgramacion +{ + /* + * 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. + */ + + internal class Program + { + static string[] iconoCoche = { "1", "2" }; + + static void Main(string[] args) + { + /* + * M = Meta + * A = Arbol + * E = Choque con arbol + * 1 = Coche 1 + * 2 = Coche 2 + */ + + Console.WriteLine("Introduzca la longitud del circuito: "); + int longitud = int.Parse(Console.ReadLine()); + int posmover; + int[] posicionesCoches = { longitud - 1, longitud - 1 }; + bool[] saltarTurno = { false, false }; + string[,] circuito = GenerarCircuito(longitud); + + ImprimirCircuito(circuito); + + Thread.Sleep(5000); + + Random rnd = new Random(); + while (!CarreraFinalizada(posicionesCoches)) + { + for (int i = 0; i < circuito.GetLength(0); i++) + { + if (!saltarTurno[i]) + { + if (posicionesCoches[i] != 0) + { + posmover = rnd.Next(1, 4); + + if ((posicionesCoches[i] - posmover) <= 0) + { + // Meta + if (circuito[i, posicionesCoches[i]] == "E") + circuito[i, posicionesCoches[i]] = "A"; + else + circuito[i, posicionesCoches[i]] = "_"; + + if ((posicionesCoches[i] - posmover) == 0) + { + posicionesCoches[i] -= posmover; + circuito[i, posicionesCoches[i]] = iconoCoche[i]; + } + else + { + posicionesCoches[i] -= posicionesCoches[i]; + circuito[i, posicionesCoches[i]] = iconoCoche[i]; + } + + } + else if (circuito[i, posicionesCoches[i] - posmover] == "A") + { + // Choque arbol + saltarTurno[i] = true; + if (circuito[i, posicionesCoches[i]] == "E") + circuito[i, posicionesCoches[i]] = "A"; + else + circuito[i, posicionesCoches[i]] = "_"; + + posicionesCoches[i] -= posmover; + circuito[i, posicionesCoches[i]] = "E"; + } + else if (circuito[i, posicionesCoches[i] - posmover] == "_") + { + // Avance coche + if (circuito[i, posicionesCoches[i]] == "E") + circuito[i, posicionesCoches[i]] = "A"; + else + circuito[i, posicionesCoches[i]] = "_"; + + posicionesCoches[i] -= posmover; + circuito[i, posicionesCoches[i]] = iconoCoche[i]; + } + } + } + else + { + saltarTurno[i] = false; + } + } + + ImprimirCircuito(circuito); + + if (posicionesCoches[0] == 0 && posicionesCoches[1] == 0) + Console.WriteLine("Empate!!!"); + + if (posicionesCoches[0] == 0) + Console.WriteLine("Ganador coche 1"); + + if (posicionesCoches[1] == 0) + Console.WriteLine("Ganador coche 2"); + + Thread.Sleep(1000); + } + + } + + static string[,] GenerarCircuito(int longitud) + { + Random rnd = new Random(); + string[,] circuito = new string[2, longitud]; + int probabilidadArbol = 20; + + for (int i = 0; i < circuito.GetLength(0); i++) + { + for (int j = 0; j < circuito.GetLength(1); j++) + { + if (j == 0) + { + circuito[i, j] = "M"; + } + else + { + int probalidad = rnd.Next(0, 101); + if (probalidad >= 0 && probalidad <= probabilidadArbol) + circuito[i, j] = "A"; + else + circuito[i, j] = "_"; + } + } + + circuito[i, circuito.GetUpperBound(1)] = iconoCoche[i]; + } + + return circuito; + } + + static void ImprimirCircuito(string[,] circuito) + { + for(int i = 0;i < circuito.GetLength(0); i++) + { + Console.WriteLine("Pista del jugador " + (i+1)); + for(int j = 0;j < circuito.GetLength(1); j++) + { + Console.Write(circuito[i,j]); + } + Console.WriteLine(); + Console.WriteLine(); + } + } + + static bool CarreraFinalizada(int[] posicionesCoche) + { + return posicionesCoche[0] == 0 || posicionesCoche[1] == 0; + } + } +} \ No newline at end of file diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/java/JaviEstacio.java b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/java/JaviEstacio.java new file mode 100644 index 0000000000..263fdeacb4 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/java/JaviEstacio.java @@ -0,0 +1,154 @@ +import java.awt.Font; +import java.awt.GridLayout; +import java.util.Random; + +import javax.swing.JFrame; +import javax.swing.JLabel; +import javax.swing.SwingUtilities; + +public class JaviEstacio { + final static String COCHE_VERDE = "🚙"; + final static String COCHE_ROJO = "🚗"; + final static String META = "🏁"; + final static String ARBOL = "🌲"; + final static String CRASH = "💥"; + static JLabel jlabRojo, jlabVerde, jlabGanador; + static Pista pistaRojo, pistaVerde; + + public JaviEstacio() { + + + JFrame jfrm = new JFrame("Reto #46 de 2023"); + jfrm.setLayout(new GridLayout(3, 1)); + jfrm.setSize(800, 300); + jfrm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + jlabRojo = new JLabel(""); + jlabRojo.setFont(new Font("Ubuntu", Font.PLAIN, 48)); + jlabVerde = new JLabel(""); + jlabVerde.setFont(new Font("Ubuntu", Font.PLAIN, 48)); + jlabGanador = new JLabel(""); + jlabGanador.setFont(new Font("Ubuntu", Font.PLAIN, 48)); + actualizarPistas(); + jfrm.add(jlabRojo); + jfrm.add(jlabVerde); + jfrm.add(jlabGanador); + jfrm.setVisible(true); + + } + + public static void main(String[] args) { + pistaRojo = new Pista(JaviEstacio.COCHE_ROJO, 10); + pistaVerde = new Pista(JaviEstacio.COCHE_VERDE, 10); + SwingUtilities.invokeLater(new Runnable() { + public void run() { + new JaviEstacio(); + } + }); + + while (pistaRojo.posicionCoche >= 0 && pistaVerde.posicionCoche >= 0) { + try { + Thread.sleep(1000); + avanzarCoches(); + actualizarPistas(); + System.out.println(); + } catch (InterruptedException e) { + System.out.println("Main thread interrupted."); + } + } + validarGanador(pistaRojo, pistaVerde); + } + + static void actualizarPistas() { + jlabRojo.setText(vistaPista(pistaRojo)); + jlabVerde.setText(vistaPista(pistaVerde)); + } + + static String vistaPista(Pista pista) { + StringBuilder sb = new StringBuilder(JaviEstacio.META); + for (String s : pista.pista) + sb.append(s); + return sb.toString(); + } + + static void avanzarCoches() { + pistaRojo.avanzarCoche(); + pistaVerde.avanzarCoche(); + } + + static void validarGanador(Pista p1, Pista p2) { + if (p1.posicionCoche < 0 && p2.posicionCoche < 0) + jlabGanador.setText("EMPATE"); + else if (p1.posicionCoche < 0) + jlabGanador.setText(p1.coche + " GANA\n"); + else + jlabGanador.setText(p2.coche + " GANA\n"); + } + + static class Pista { + public String coche; + public int posicionCoche; + public String[] pista; + final int LONGITUD_DEFECTO = 10; + final String ARBOL = "🌲"; + final String CRASH = "💥"; + Random rand = new Random(); + + Pista(String coche, int longitud) { + this.coche = coche; + + int arboles = rand.nextInt(3) + 1; + + this.pista = crearPista(longitud, arboles); + this.posicionCoche = this.pista.length - 1; + this.pista[posicionCoche] = this.coche; + } + + private String[] crearPista(int longitud, int arboles) { + String[] pista; + + if (longitud < (arboles)) + longitud = this.LONGITUD_DEFECTO; + + pista = new String[longitud]; + + // Crear pista vacía + for (int i = 0; i < longitud - 1; i++) { + // pista[longitud-1] se reserva para la posición inicial del coche + pista[i] = "_"; + } + + // Colocar árboles + do { + int posicionArbol = rand.nextInt(longitud - 2); + if (pista[posicionArbol] != JaviEstacio.ARBOL) { + pista[posicionArbol] = JaviEstacio.ARBOL; + arboles--; + } + } while (arboles > 0); + + return pista; + } + + public void avanzarCoche() { + if (pista[posicionCoche].compareTo(JaviEstacio.CRASH) == 0) + pista[posicionCoche] = coche; + else { + int avance = rand.nextInt(3) + 1; + posicionCoche = posicionCoche - avance; + if (posicionCoche >= 0) { + if (pista[posicionCoche].compareTo(JaviEstacio.ARBOL) == 0) { + pista[posicionCoche] = JaviEstacio.CRASH; + } else { + pista[posicionCoche] = coche; + } + for (int i = posicionCoche + 1; i < pista.length; i++) + pista[i] = ""; + } + else { + for (int i = 0; i < pista.length; i++) + pista[i] = ""; + } + } + } + } +} diff --git a/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/ajloinformatico.py b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/ajloinformatico.py new file mode 100644 index 0000000000..413be41795 --- /dev/null +++ b/Retos/Reto #46 - LA CARRERA DE COCHES [Media]/python/ajloinformatico.py @@ -0,0 +1,257 @@ +from os import system +import random +from time import sleep + +""" +/* + * 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. + * + */ +""" + + + + +APP_NAME = """ +####################################### + Race Car + + by infolojo + https:://infolojo.es + Antonio José Lojo Ojeda +####################################### +""" + + + + +class Car: + def __init__(self, player: str, car_image: str, pista: int, type: int): + self.player: str = player + self.car_image: str = car_image, + self.pista: int = pista + self.position: int = pista + 1 + self.crashed: bool = False, + self.type: int = type + + def get_car_image(self): + return self.car_image[0] + + def update_position(self, new_position: int): + self.position = new_position + + +class Race: + def __init__(self, player_one: Car, player_two: Car): + self.current: int + self.example: str + self.crash: str = "💥" + self.tree: str = "🌲" + self.final: str = "🏁" + self.cars = (player_one, player_two) + self.pista_car_one = "" + self.pista_car_two = "" + self.initi_config() + + def initi_config(self): + """Prepare pista with trees and crashes + + Keyword arguments: + argument -- description + Return: return_description + """ + + + def clear_screen(self): + # uncomment by checking your or + # clear windows screen + # os.system('CLS') + # clear linux screen + system('clear') + + def get_random_tree_positions(self, size_pista: int): + """Get random trees 1 or 3 and random position of each trees + + Keyword arguments: + argument -- description + Return: array of trees + """ + number_of_trees = random.randint(1, 3) + index: int = 0 + trees: list = [] + + while (index < number_of_trees): + index += 1 + trees.append(random.randint(1, size_pista -1)) + + return trees + + + def build_pist(self, car: Car, pista: str, trees: list): + i = 0 + while (True): + if i == 0: + pista += "🏁" + + elif i in trees: + trees.remove(i) + pista += self.tree + + elif car.position == i: + pista += car.get_car_image() + return pista + else: + pista += "_" + i += 1 + + + def prepare_pista(self): + car_one_pista: str = self.build_pist( + car = self.cars[0], + pista = self.pista_car_one, + trees = self.get_random_tree_positions( + size_pista = self.cars[0].position + ) + + ) + + car_two_pista: str = self.build_pist( + car = self.cars[1], + pista = self.pista_car_two, + trees = self.get_random_tree_positions( + size_pista = self.cars[1].position + ) + ) + + self.pista_car_one = car_one_pista + self.pista_car_two = car_two_pista + + # TODO SAVE PISTAS ? + print(f"{self.cars[0].player} - {car_one_pista}") + print(f"{self.cars[1].player} - {car_two_pista}") + + + def check_winners(self): + winner_found: bool = False + car_one = self.cars[0] + car_two = self.cars[1] + if car_one.position == 1 and car_two.position == 1: + print(f"{car_one.player} and {car_two.player} are the WINNERS !!") + winner_found = True + + elif car_one.position == 1: + print(f"{car_one.player} WINS !!") + winner_found = True + + elif car_two.position == 1: + print(f"{car_two.player} WINS !!") + winner_found = True + + return winner_found + + + def update_positions(self, type): + if type == 1: + self.cars[0].position -= 1 + elif type == 2: + self.cars[1].position -= 1 + + def update_pista(self, type: int, pista: str): + if type == 1: + self.pista_car_one = pista + elif type == 2: + self.pista_car_two = pista + + + def update_crashes(self, type, value: bool): + if type == 1: + self.cars[0].crashed = value + elif type == 2: + self.cars[1].crashed = value + + + def launch_single_round(self, car: Car, pista: str): + # Prepare data + pista_list = list(pista) + next_position = car.position -1 + + # Check to skip single round + if car.crashed == True: + self.update_crashes(type = car.type, value=False) + + # print pista + self.build_and_print_pista(car = car, pista_list = pista_list) + return + + + # update pista + if (pista_list[next_position] == self.tree): + pista_list[next_position] = self.crash + self.update_crashes(type = car.type, value = True) + + else: + pista_list[next_position] = car.get_car_image() + + # remove last position + pista_list.pop(car.position) + + + # update cars positions + self.update_positions(type = car.type) + + # print pista + self.build_and_print_pista(car = car, pista_list = pista_list) + + + def build_and_print_pista(self, car: Car, pista_list: list): + # build pista + pista_builded: str = "".join(pista_list) + + # print pista + print(f"{car.player} - {pista_builded}") + + # update pista + self.update_pista(type = car.type, pista = pista_builded) + + + def launch_rounds(self): + while (True): + self.clear_screen() + print(APP_NAME) + if self.check_winners() == True: + # finish + return + else: + # print round on pista and check if crash + self.launch_single_round(self.cars[0], self.pista_car_one) + self.launch_single_round(self.cars[1], self.pista_car_two) + sleep(.5) + + + def start_race(self): + self.clear_screen() + print(APP_NAME) + self.prepare_pista() + self.launch_rounds() + + +if __name__ == "__main__": + car_one = Car(player = "Crisitian", car_image = "🚙", pista = 10, type = 1) + car_two = Car(player = "Joaquin", car_image = "🚗", pista = 10, type = 2) + Race(player_one = car_one, player_two = car_two).start_race() diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/CarlosRivera4726.java" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/CarlosRivera4726.java" new file mode 100644 index 0000000000..f9676f97b9 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/CarlosRivera4726.java" @@ -0,0 +1,64 @@ +package com.exercises; + +import java.util.Dictionary; +import java.util.Hashtable; +import java.util.Scanner; + +public class Main { + public static void main(String[] args) { + Mapeo(); + do{ + Scanner input = new Scanner(System.in); + System.out.println("Ingrese una palabra: "); + String palabra = input.next(); + int puntos = PuntosPalabra(palabra.toLowerCase()); + System.out.println("Sus puntos son: " + puntos); + if(puntos >= 100) + { + input.close(); + return; + } + + } while(true); + } + + /* + * La última semana de 2021 comenzamos la actividad de retos de programación, + * con la intención de resolver un ejercicio cada semana para mejorar + * nuestra lógica... ¡Hemos llegado al EJERCICIO 100! Gracias 🙌 + * + * Crea un programa que calcule los puntos de una palabra. + * - Cada letra tiene un valor asignado. Por ejemplo, en el abecedario + * español de 27 letras, la A vale 1 y la Z 27. + * - El programa muestra el valor de los puntos de cada palabra introducida. + * - El programa finaliza si logras introducir una palabra de 100 puntos. + * - Puedes usar la terminal para interactuar con el usuario y solicitarle + * cada palabra. + */ + public static char[] LowerCaseAlphabet = {'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'}; + public static Dictionary values = new Hashtable<>(); + + private static void Mapeo() + { + for(int i = 0; i < LowerCaseAlphabet.length; i++) + { + values.put(LowerCaseAlphabet[i], i+1); + } + } + + public static int PuntosPalabra(String palabra) + { + char[] letras = palabra.toCharArray(); + int suma = 0; + for(char letra : letras) + { + try{ + suma += values.get(letra); + } catch(Exception ex) + { + return 0; + } + } + return suma; + } +} diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/JaviEstacio.java" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/JaviEstacio.java" new file mode 100644 index 0000000000..dd4d716875 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/JaviEstacio.java" @@ -0,0 +1,63 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.text.Normalizer; + +public class JaviEstacio { + public static void main(String[] args) { + int puntos; + char[] palabra; + + System.out.println("LA PALABRA DE LOS 100 PUNTOS"); + System.out.println("============================"); + System.out.println(); + System.out.println("El programa finaliza si se introduce una palabra de 100 puntos."); + System.out.println("Ejemplo: Zoología"); + System.out.println("Z\to\to\tl\to\tg\tí\ta"); + System.out.println("26\t15\t15\t12\t15\t7\t9\t1 = 100 puntos."); + System.out.println(); + + try { + do { + System.out.println("Inserta la palabra: "); + BufferedReader br = new BufferedReader(new InputStreamReader(System.in, System.console().charset())); + + palabra = limpiarPalabra(br.readLine()).toCharArray(); + puntos = calcularPuntos(palabra); + System.out.println("Valor: " + puntos + " puntos.\n"); + } while (puntos != 100); + } catch (IOException e) { + System.out.println("\nEXCEPCIÓN leyendo la palabra. Fin de aplicación\n\n"); + } + } + + private static String limpiarPalabra(String palabra) { + palabra = palabra.trim().toLowerCase(); + palabra = Normalizer.normalize(palabra, Normalizer.Form.NFD); + return palabra; + } + + private static int calcularPuntos(char[] palabra) { + int puntos = 0; + boolean finPalabra = false; + int minVal = 'a'; + int maxVal = 'z'; + Character[] separadores = { ' ', '\t', '\n' }; + + for (char letra : palabra) { + for (char separador : separadores) { + if (letra == separador) { + finPalabra = true; // Si se detecta un separador, se asume que la primera palabra ha finalizado y + // deja de sumar puntos + break; + } else if (letra >= minVal && letra <= maxVal) { + puntos += (letra - (minVal - 1)); + break; + } + } + if (finPalabra) + break; + } + return puntos; + } +} diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/moguism.java" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/moguism.java" new file mode 100644 index 0000000000..7a5efa6242 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/java/moguism.java" @@ -0,0 +1,66 @@ +import java.util.Scanner; + +public class moguism { + + public static void main(String[] args){ + + Scanner leer = new Scanner(System.in); + + int puntos = 0; + + String palabra = ""; + + while (puntos != 100) { + + System.out.print("Introduce una palabra: "); + palabra = leer.next(); + + String copiaPalabra = palabra.toUpperCase(); + + for(int i = 0; i < copiaPalabra.length(); i++){ + + int puntosLetra = 0; + + for(int j = 65; j <= 90; j++){ // Empieza en la A y termina en la Z (en ASCII) + + puntosLetra++; + + if(j == 78){ // Cuando llega a la Ñ + + puntosLetra++; + + } + + if(copiaPalabra.charAt(i) == j){ + + puntos = puntos + puntosLetra; + break; + + } else if(copiaPalabra.charAt(i) == 'Ñ'){ + + puntos = puntos + 15; + break; + + } + + } + + } + + System.out.println("La palabra "+palabra+" vale "+puntos+" puntos"); + + if(puntos != 100){ + + puntos = 0; + + } + + + } + + System.out.println("¡ENHORABUENA!"); + + leer.close(); + + } +} diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/Jacobosilvar.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/Jacobosilvar.py" new file mode 100644 index 0000000000..afbd375502 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/Jacobosilvar.py" @@ -0,0 +1,62 @@ +""" + * Crea un programa que calcule los puntos de una palabra. + * - Cada letra tiene un valor asignado. Por ejemplo, en el abecedario + * español de 27 letras, la A vale 1 y la Z 27. + * - El programa muestra el valor de los puntos de cada palabra introducida. + * - El programa finaliza si logras introducir una palabra de 100 puntos. + * - Puedes usar la terminal para interactuar con el usuario y solicitarle + * cada palabra. + */ +""" + +def calcular_puntos(palabra: str) -> int: + """ Calcula el valor de un string pasado como la suma del valor de cada letra a=1 z=26 + + Params: + palabra str: string cuyo valor hay que calcular + + result: + puntos int: suma de el valor de cada letra de la palabraa + + ej: + 'abc' = 1 + 2 + 3 = 6 + + + """ + letras = {'a':1, 'á':1, 'b':2, 'c':3, 'd':4, 'e':5, 'é':5, 'f':6, 'g':7, 'h':8, 'i':9, 'í':9, 'j':10, + 'k':11, 'l':12, 'm':13, 'n':14, 'ñ':15, 'o':16, 'ó':16, 'p':17, 'q':18, 'r':19, 's':20, + 't':21,'u':22, 'ú':22, 'ü':22, 'v':23, 'w':24, 'x':25, 'y':26, 'z':27 } + + try: + resultado = sum([letras[x] for x in palabra]) + except KeyError as e: + print(f' El caracter {e} no pertenece as abecedario español...') + resultado = 0 + + return resultado + + + +if __name__ == '__main__': + + puntuacion = 0 + + while True: + + palabra = input(""" + Teclee la palabra +(presione ENTER para salir) + +---> """) + + if palabra == '': break + if not palabra.isalpha(): + print(" Sólo se permiten letras de la 'a' a la 'z', vuelva a intentar...") + else: + puntuacion = calcular_puntos(palabra.lower()) + + if puntuacion == 100: + print('Enhorabuena, ha ganado!!!') + break + else: + print(f'La puntuacion {puntuacion} de su palabra no es 100, vuelva a intentar') diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/aalfonzo1984.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/aalfonzo1984.py" new file mode 100644 index 0000000000..1e2e92aadc --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/aalfonzo1984.py" @@ -0,0 +1,37 @@ +""" + Programa en el cual introduces una palabra, dependiendo las letras que contenga + sumara una puntuación, si hace 100 puntos gana +""" + +abecedario = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12, 'M': 13, + 'N': 14, 'Ñ': 15, 'O': 16, 'P': 17, 'Q': 18, 'R': 19, 'S': 20, 'T': 21, 'U': 22, 'V': 23, 'W': 24, 'X': 25, 'Y': 26, 'Z': 27} + + +def jugar(): + print('******Hola bienvenido al juego de la palabra de los 100 puntos******') + puntos: int = 0 + while puntos != 100: + palabra: str = input('Introduce una palabra: ').upper() + if palabra.isalpha(): + puntos = calcula_puntaje(palabra, puntos) + else: + print('Solamente se admiten letras') + + +def calcula_puntaje(palabra:str, puntos:int): + for letra in palabra: + for key, val in abecedario.items(): + if key == letra: + puntos = puntos + val + if puntos == 100: + print(f'Perfecto lo lograste la palabra { + palabra} tiene {puntos} de puntaje') + else: + print(f'Tu palabra "{palabra}" tiene { + puntos} de puntaje, vamos intentalo de nuevo con otra palabra') + puntos = 0 + return puntos + + +if __name__ == '__main__': + jugar() diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/anegrin86.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/anegrin86.py" new file mode 100644 index 0000000000..c53d50d126 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/anegrin86.py" @@ -0,0 +1,20 @@ +# Almaceno las letras del abecedario en la variable "letras": +letras = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ" + +# Se crea un ciclo que termina si se alcanzan los 100 puntos: +while True: + puntos = 0 + palabra = input("Escriba una palabra que llegue a 100 puntos: ") + palabra = palabra.upper() + for letra in palabra: + puntos += letras.index(letra) + 1 + if puntos == 100: + break + print(f"Su palabra tiene un valor de {puntos} puntos") +print("ENHORABUENA, SU PALABRA INTRODUCIDA ALCANZÓ LOS 100 PUNTOS") + + + + + + diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/evilpotato04.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/evilpotato04.py" new file mode 100644 index 0000000000..71d38f28ab --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/evilpotato04.py" @@ -0,0 +1,37 @@ +# +# La última semana de 2021 comenzamos la actividad de retos de programación, +# con la intención de resolver un ejercicio cada semana para mejorar +# nuestra lógica... ¡Hemos llegado al EJERCICIO 100! Gracias 🙌 +# +# Crea un programa que calcule los puntos de una palabra. +# - Cada letra tiene un valor asignado. Por ejemplo, en el abecedario +# español de 27 letras, la A vale 1 y la Z 27. +# - El programa muestra el valor de los puntos de cada palabra introducida. +# - El programa finaliza si logras introducir una palabra de 100 puntos. +# - Puedes usar la terminal para interactuar con el usuario y solicitarle +# cada palabra. +# + +def calcular_puntos(palabra): + puntos = 0 + dicionario_letras = { + "A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6, "G": 7, "H": 8, "I": 9, "J": 10, + "K": 11, "L": 12, "M": 13, "N": 14, "Ñ": 15, "O": 16, "P": 17, "Q": 18, "R": 19, + "S": 20, "T": 21, "U": 22, "V": 23, "W": 24, "X": 25, "Y": 26, "Z": 27 + } + + for l in palabra.upper(): + puntos += dicionario_letras[l] + + return puntos + +def juegar(): + puntos = 0 + + while puntos != 100: + puntos = calcular_puntos(input("Escribe una palabra:\n")) + print("Tu palabra vale {0} puntos".format(puntos)) + + print("Fin de Juego!") + +juegar() diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/javierfiestasbotella.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/javierfiestasbotella.py" new file mode 100644 index 0000000000..004755cc8a --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/javierfiestasbotella.py" @@ -0,0 +1,29 @@ +''' +Crea un programa que calcule los puntos de una palabra. + * - Cada letra tiene un valor asignado. Por ejemplo, en el abecedario + * español de 27 letras, la A vale 1 y la Z 27. + * - El programa muestra el valor de los puntos de cada palabra introducida. + * - El programa finaliza si logras introducir una palabra de 100 puntos. + * - Puedes usar la terminal para interactuar con el usuario y solicitarle + * cada palabra.''' + +abc='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' +abc=abc.split(',') +abc_valores=dict() +valor=[n for n in range(1,28)] +for i in range(27): + abc_valores[abc[i]]=valor[i] + +acierto=0 +while True: + question=input('Introduce una palabra con valor 100: ') + for i in question: + acierto+=abc_valores[i] + if acierto<100: + print(f'La palabra {question} tiene un valor de {acierto}. te has quedado corto, inténtalo de nuevo.') + elif acierto > 100: + print(f'La palabra {question} tiene un valor de {acierto}, te has pasado, inténtalo de nuevo') + elif acierto==100: + break + acierto=0 +print(f'¡¡¡Enhorabuena la palabra {question} tiene un valor de 100!!!') \ No newline at end of file diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/lilberick.py" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/lilberick.py" new file mode 100644 index 0000000000..8d7c452d13 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/python/lilberick.py" @@ -0,0 +1,29 @@ +def valorCaracter(c): + t='abcdefghijklmnñopqrstuvwxyz' + if(c.isalpha()): return t.find(c)+1 + return -1; +def valorPalabra(s): + if(s.isalpha()): + suma=0 + for i in s: suma+=valorCaracter(i) + return suma + return -1 +def leer_datos(): + indicaciones="Ingresa una palabra o palabras cuyos caracteres pertenezan al abecedario español:\n" + entrada = input(indicaciones).split() + return entrada + +def juego(): + finaliza=False + while not finaliza: + entrada = leer_datos() + for i in entrada: + print(i,end=": ") + valor=valorPalabra(i) + if(valor==-1): print("palabra incorrecta, solo usa letras del abecedario español.") + else: + if(valor==100): print(valor,"Puntos. Felicidades palabra de 100 puntos. Finalizamos el programa") + else: print(valor,"Puntos. Si hay una palabra de 100 puntos finaliza el programa.") + if(valor==100): finaliza=True + print() +juego() diff --git "a/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/typescript/ChemaAlfonso.ts" "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/typescript/ChemaAlfonso.ts" new file mode 100644 index 0000000000..91b4558020 --- /dev/null +++ "b/Retos/Reto #47 - LA PALABRA DE 100 PUNTOS [F\303\241cil]/typescript/ChemaAlfonso.ts" @@ -0,0 +1,104 @@ +import { createInterface } from 'readline/promises' + +// =================================== +// Evaluator +// =================================== +type EvaluatorMap = { [char: string]: number } + +const wordEvaluator = (lang: 'es' | 'en') => { + const alphabet = { + es: Array(26) + .fill(0) + .map((_, i) => String.fromCharCode(65 + i)) + .toSpliced(14, 0, 'Ñ'), + en: Array(26) + .fill(0) + .map((_, i) => String.fromCharCode(65 + i)) + } + + const evaluatorMap = alphabet[lang].reduce((map, char, i) => { + map[char] = i + 1 + return map + }, {} as EvaluatorMap) + + return (word: string) => { + const normalizedWord = word + .normalize('NFD') + .replace(/[\u0300-\u036f]/g, '') + .toUpperCase() + + return [...normalizedWord].reduce((punctuation, char) => punctuation + (evaluatorMap?.[char] || 0), 0) + } +} + +// =================================== +// Game +// =================================== +;(async () => { + const communicator = createInterface({ + input: process.stdin, + output: process.stdout + }) + + console.clear() + console.log('Bienvenido al juego de las palabras!') + console.log('El objetivo es conseguir el valor deseado con la suma de las letras de la palabra introducida.') + + let lang = '' + let punctuationToWin = 0 + let lastTry = { punctuation: 0, word: '' } + + while (lang !== 'es' && lang !== 'en') { + lang = await communicator.question('\nEn que idioma vas a introducir las palabras? (es/en): ') + } + + while (punctuationToWin < 1 || Number.isNaN(punctuationToWin)) { + punctuationToWin = Number(await communicator.question('\nQue valor quieres conseguir? (1-100): ')) + } + + const evaluator = wordEvaluator(lang) + + while (punctuationToWin !== lastTry.punctuation) { + console.clear() + console.log(`🏁 Valor esperado: ${punctuationToWin} 🏁 \n`) + + if (lastTry.word) + console.log( + `Ups... el valor de la palabra '${lastTry.word}' es ${lastTry.punctuation}, sigue intentándolo!\n` + ) + const word = await communicator.question('Introduce una palabra: ') + const punctuation = evaluator(word) + + lastTry = { punctuation, word } + } + + console.clear() + console.log(`🥳 Enhorabuena! has conseguido un valor de ${punctuationToWin} con '${lastTry.word}'!`) + + communicator.close() +})() + +// =================================== +// Manual testing +// =================================== +// const runTests = () => { +// const expectEqual = (a: any, b: any) => { +// console.log(a === b ? `${a} OK` : `${a} KO, recived ${a} but expected ${b}`) +// } + +// // Esp +// const espEvaluator = wordEvaluator('es') +// expectEqual(espEvaluator('HOLA'), 37) // H + O + L + A = 8 + 16 + 12 + 1 = 37 +// expectEqual(espEvaluator('MUNDO'), 69) // M + U + N + D + O = 13 + 22 + 14 + 4 + 16 = 69 +// expectEqual(espEvaluator('PROGRAMACIÓN'), 135) // P + R + O + G + R + A + M + A + C + I + Ó + N = 17 + 19 + 16 + 7 + 19 + 1 + 13 + 1 + 3 + 9 + 16 + 14 = 135 +// expectEqual(espEvaluator('MoUreDev'), 107) // M + O + U + R + E + D + E + V = 13 + 16 + 22 + 19 + 5 + 4 + 5 + 23 = 107 + +// // Eng +// const engEvaluator = wordEvaluator('en') +// expectEqual(engEvaluator('HELLO'), 52) // H + E + L + L + O = 8 + 5 + 12 + 12 + 15 = 52 +// expectEqual(engEvaluator('WORLD'), 72) // W + O + R + L + D = 23 + 15 + 18 + 12 + 4 = 72 +// expectEqual(engEvaluator('PROGRAMMING'), 131) // P + R + O + G + R + A + M + M + I + N + G = 16 + 18 + 15 + 7 + 18 + 1 + 13 + 13 + 9 + 14 + 7 = 131 +// expectEqual(engEvaluator('MoUreDev'), 103) // M + O + U + R + E + D + E + V = 13 + 15 + 21 + 18 + 5 + 4 + 5 + 22 = 103 +// } + +// runTests() diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/rafael.ramirez150.cs" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/rafaelramirez150.cs" similarity index 100% rename from "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/rafael.ramirez150.cs" rename to "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/c#/rafaelramirez150.cs" diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/go/rafael.ramirez150.go" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/go/rafaelramirez150.go" similarity index 100% rename from "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/go/rafael.ramirez150.go" rename to "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/go/rafaelramirez150.go" diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/html/odravirdev.html" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/html/odracirdev.html" similarity index 100% rename from "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/html/odravirdev.html" rename to "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/html/odracirdev.html" diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/php/rafaelramirez.php" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/php/rafaelramirez150.php" similarity index 100% rename from "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/php/rafaelramirez.php" rename to "Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/php/rafaelramirez150.php" diff --git "a/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/adra-dev.py" "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/adra-dev.py" new file mode 100644 index 0000000000..388d50cb9a --- /dev/null +++ "b/Retos/Reto #5 - HOLA MUNDO [F\303\241cil]/python/adra-dev.py" @@ -0,0 +1,8 @@ +""" +Escribe un !Hola Mundo! en todos los lenguajes de programación que puedas. +Seguro que hay algún lenguaje que te llama la atención y nunca has utilizado, +o quizás quieres dar tus primeros pasos... ¡Pues este es el momento! +A ver quién se atreve con uno de esos lenguajes que no solemos ver por ahí... +""" + +print("Hola Mundo!") \ No newline at end of file diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/c#/vicgallego.cs b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/c#/vicgallego.cs new file mode 100644 index 0000000000..9f408796ad --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/c#/vicgallego.cs @@ -0,0 +1,104 @@ +/* + * 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. + */ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Reto__6 +{ + internal class Program + { + + static void Main(string[] args) + { + string jugador1 = "jugador1"; + string jugador2 = "jugador2"; + + + int victoriasJugador1 = 0; + int victoriasJugador2 = 0; + + // Bucle para jugar múltiples rondas + while (true) + { + Console.WriteLine("\nNueva ronda:"); + + // Solicitar jugadas de los jugadores + Console.Write("Jugador 1 elige: Piedra, Papel, Tijera, Lagarto o Spock: "); + string jugadaJugador1 = Console.ReadLine().ToUpper(); + + Console.Write("Jugador 2 elige: Piedra, Papel, Tijera, Lagarto o Spock: "); + string jugadaJugador2 = Console.ReadLine().ToUpper(); + + // Validar las jugadas y determinar el ganador + string resultado = DeterminarGanador(jugadaJugador1, jugadaJugador2); + + // Mostrar el resultado de la ronda + Console.WriteLine($"Resultado: {resultado}"); + + // Actualizar el contador de victorias + if (resultado == jugador1) + victoriasJugador1++; + else if (resultado == jugador2) + victoriasJugador2++; + + // Preguntar si los jugadores quieren jugar otra ronda + Console.Write("\n¿Quieren jugar otra ronda? (Sí/No): "); + string respuesta = Console.ReadLine().ToUpper(); + + if (respuesta != "SI") + break; // Salir del bucle si la respuesta no es "Sí" + } + + // Mostrar el resultado final + Console.WriteLine($"\nResultados finales:"); + Console.WriteLine($"Jugador 1: {victoriasJugador1} victorias"); + Console.WriteLine($"Jugador 2: {victoriasJugador2} victorias"); + + if (victoriasJugador1 > victoriasJugador2) + Console.WriteLine("Jugador 1 es el ganador!"); + else if (victoriasJugador2 > victoriasJugador1) + Console.WriteLine("Jugador 2 es el ganador!"); + else + Console.WriteLine("¡Empate!"); + + // Esperar a que el usuario presione una tecla antes de salir + Console.ReadKey(); + } + + // Función para determinar el ganador de una ronda + static string DeterminarGanador(string jugada1, string jugada2) + { + if ((jugada1 == "PIEDRA" && (jugada2 == "LAGARTO" || jugada2 == "TIJERA")) || + (jugada1 == "PAPEL" && (jugada2 == "PIEDRA" || jugada2 == "SPOCK")) || + (jugada1 == "TIJERA" && (jugada2 == "PAPEL" || jugada2 == "LAGARTO")) || + (jugada1 == "LAGARTO" && (jugada2 == "PAPEL" || jugada2 == "SPOCK")) || + (jugada1 == "SPOCK" && (jugada2 == "PIEDRA" || jugada2 == "TIJERA"))) + { + return "jugador1"; + } else if ((jugada2 == "PIEDRA" && (jugada1 == "LAGARTO" || jugada1 == "TIJERA")) || + (jugada2 == "PAPEL" && (jugada1 == "PIEDRA" || jugada1 == "SPOCK")) || + (jugada2 == "TIJERA" && (jugada1 == "PAPEL" || jugada1 == "LAGARTO")) || + (jugada2 == "LAGARTO" && (jugada1 == "PAPEL" || jugada1 == "SPOCK")) || + (jugada2 == "SPOCK" && (jugada1 == "PIEDRA" || jugada1 == "TIJERA"))) + + { + return "jugador2"; + } else { + return "Empate"; + } + } + } + +} \ No newline at end of file diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/mariovelascodev.py b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/mariovelascodev.py new file mode 100644 index 0000000000..a6ebdf922e --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/mariovelascodev.py @@ -0,0 +1,35 @@ +def rock_paper_scissors_lizard_spock(games): + #Variables + player_1 = 0 + player_2 = 0 + rules = {"🗿":["✂️","🦎"], + "✂️":["📄","🦎"], + "📄":["🗿","🖖"], + "🦎":["🖖","📄"], + "🖖":["✂️","🗿"]} + + #Recorremos la lista de juegos + for game in games: + #Si los valores no son iguales, miramos si lo jugado por el jugador 2 esta en el valor de la llave de lo jugado por el jugador 1 + if game[0] != game[1]: + #Si la llave del diccionario (lo jugado por el jugador 1) contiene lo jugado por el jugador 2, gana jugador 1, si no gana jugador 2 + if game[1] in rules[game[0]]: + player_1 += 1 + else: + player_2 += 1 + #En caso de que ambos saquen el mismo valor no suman ningún punto + else: + player_1 += 0 + player_2 += 0 + + #Comparamos cúal de los dos jugadores tiene más puntos o si han empatado + if player_1 > player_2: + return "Player 1" + elif player_1 < player_2: + return "Player 2" + else: + return "Tie" + +print(rock_paper_scissors_lizard_spock([("🗿","✂️"), ("✂️","🗿"), ("📄","✂️")])) +print(rock_paper_scissors_lizard_spock([("🗿","✂️"), ("✂️","🗿"), ("📄","✂️"), ("🦎","🖖")])) +print(rock_paper_scissors_lizard_spock([("🖖","✂️"), ("📄","🗿"), ("🦎","✂️"), ("🦎","🦎"), ("🦎","🖖")])) \ No newline at end of file diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/JoseAntonioRuizGarcia.py b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/JoseAntonioRuizGarcia.py new file mode 100644 index 0000000000..0049a91ba9 --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/JoseAntonioRuizGarcia.py @@ -0,0 +1,15 @@ +import numpy as np +import time + +def randomNumber() -> None: + # Extrae los últimos 3 números de la hora de ejecución del código + seconds = time.time() + number = int(str(seconds)[-3:]) + + if number > 100: + number = int(np.round(number / 10, 0)) + + print(number) + +if __name__=='__main__': + randomNumber() diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/JoseAntonioRuizGarcia.py" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/JoseAntonioRuizGarcia.py" new file mode 100644 index 0000000000..7e8476a0f9 --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/JoseAntonioRuizGarcia.py" @@ -0,0 +1,65 @@ +import re + +def cleanText(text: str) -> str: + # Elimina caracteres especiales + pattern = r'[^a-zA-ZñÑáéíóúÁÉÍÓÚüÜ]' + text_clear = re.sub(pattern, '', text) + list_text = [str.lower(ch) for ch in text_clear] + + # Conversión de vocales con tildes + map_ch = { + 'á': 'a', 'é': 'e', 'í': 'i', 'ó': 'o', 'ú': 'u', 'ü': 'u' + } + list_ = [] + for ch in list_text: + if ch in map_ch.keys(): + list_.append(map_ch.get(ch)) + else: + list_.append(ch) + + return list_ + +def isHeterograma(text: str) -> None: + # Palabra que no repite ninguna letra + clean_text = cleanText(text) + len_original = len(clean_text) + + if len_original == len(set(clean_text)): + print('La palabra o frase es un Heterograma') + else: + print('La palabra o frase NO es un Heterograma') + +def isIsograma(text: str) -> None: + # Palabra en la que cada letra aparece el mismo número de veces + clean_text = cleanText(text) + + counter = [] + for ch in clean_text: + counter.append(clean_text.count(ch)) + + if (len(set(counter)) == 1) & (counter[0] > 1): + print('La palabra o frase es un Isograma') + else: + print('La palabra o frase NO es un Isograma') + + +def isPangrama(text: str) -> None: + # Texto que usa todas las letras posibles del alfabeto + clean_text = cleanText(text) + n_ch = len(set(clean_text)) + + if n_ch == 27: + print('La palabra o frase es un Pangrama') + else: + print('La palabra o frase NO es un Pangrama') + +def isHIP(text: str) -> None: + isHeterograma(text) + isIsograma(text) + isPangrama(text) + +if __name__=='__main__': + isHeterograma('Sujeto') + isIsograma('Mama') + isPangrama('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.') + isHIP('murciélago')