diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Adrian01cst.java" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Adrian01cst.java" new file mode 100644 index 0000000000..5d6ccd3699 --- /dev/null +++ "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/java/Adrian01cst.java" @@ -0,0 +1,25 @@ +/* + * 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". + */ + +public class Adrian01cst { + public static void main(String[] args) { + + for(int i = 1; i <= 100; i++) { + if(i % 3 == 0 && i % 5 ==0) { + System.out.println("fizzbuzz"); + } else if(i % 3 == 0) { + System.out.println("fizz"); + } else if(i % 5 == 0) { + System.out.println("buzz"); + } else { + System.out.println(i); + } + } + } +} \ No newline at end of file diff --git "a/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/rogmovi.js" "b/Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/r0j0Code.js" similarity index 100% rename from "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/rogmovi.js" rename to "Retos/Reto #0 - EL FAMOSO FIZZ BUZZ [F\303\241cil]/javascript/r0j0Code.js" diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/rogmovi.js" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/r0j0Code.js" similarity index 100% rename from "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/rogmovi.js" rename to "Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/javascript/r0j0Code.js" diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/kotlin/vicadev.kt" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/kotlin/vicadev.kt" new file mode 100644 index 0000000000..7f60f24040 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/kotlin/vicadev.kt" @@ -0,0 +1,38 @@ +fun main() { + print("Introduce un texto: ") + val text = readln().lowercase() + + val leetMap = mapOf( + 'a' to "4", + 'b' to "|3", + 'c' to "[", + 'd' to ")", + 'e' to "3", + 'f' to "|=", + 'g' to "&", + 'h' to "#", + 'i' to "1", + 'j' to ",_|", + 'k' to ">|", + 'l' to "1", + 'm' to "/\\/\\", + 'n' to "^/", + 'o' to "0", + 'p' to "|*", + 'q' to "(_,)", + 'r' to "|2", + 's' to "5", + 't' to "7", + 'u' to "(_)", + 'v' to "\\/", + 'w' to "\\/\\/", + 'x' to "><", + 'y' to "j", + 'z' to "2", + ' ' to " " + ) + + var textHacker = "" + text.forEach { note -> textHacker += leetMap[note] } + println(textHacker) +} \ No newline at end of file diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/ccaicedo09.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/ccaicedo09.py" new file mode 100644 index 0000000000..8b9bbbf163 --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/ccaicedo09.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 hacker_language(): + + text = input("Ingresa la oración que quieres traducir a lenguaje hacker ---> ").upper() + + 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_string = "" + + for char in text: + if char in leet.keys(): + leet_string += leet[char] + else: + leet_string += char + + return leet_string + + +print(f"\nTexto traducido ---> {hacker_language()}") diff --git "a/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jarkillo.py" "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jarkillo.py" new file mode 100644 index 0000000000..0bac182ffc --- /dev/null +++ "b/Retos/Reto #1 - EL LENGUAJE HACKER [F\303\241cil]/python/jarkillo.py" @@ -0,0 +1,69 @@ +# -*- coding: utf-8 -*- +""" +Created on Wed Oct 25 17:23:05 2023 + +@author: Jarkillo +""" +''' + * 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_lang = { + + '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': 'Z', + '3': 'E', + '4': 'A', + '5': 'S', + '6': 'b', + '7': 'T', + '8': 'B', + '9': 'g', + '0': 'o' +} + + +def leet(text): + text = text.lower() + for letra in text: + if letra in leet_lang: + text = text.replace(letra, leet_lang[letra]) + return text + + +print(leet('Hola, me llamo Jarkillo y soy un hacker')) +texto = input(leet('Introduce un texto para transformarlo: ')) + +texto = leet(texto) +print(texto) diff --git "a/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/python/ccaicedo09.py" "b/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/python/ccaicedo09.py" new file mode 100644 index 0000000000..c380645bd6 --- /dev/null +++ "b/Retos/Reto #12 - VIERNES 13 [F\303\241cil]/python/ccaicedo09.py" @@ -0,0 +1,14 @@ +""" + * 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 Friday_13th(month: int, year: int): + date = datetime(year, month, 13) + + return True if date.isoweekday() == 5 else False #.isoweekday() no toma lunes como 0; más cómodo + +print(Friday_13th(9, 2023)) +print(Friday_13th(10, 2023)) diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/rogmovi.js b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/r0j0Code.js similarity index 100% rename from Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/rogmovi.js rename to Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/javascript/r0j0Code.js diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/kotlin/vicadev.kt b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/kotlin/vicadev.kt new file mode 100644 index 0000000000..173c0e3152 --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/kotlin/vicadev.kt @@ -0,0 +1,40 @@ +fun main() { + println("-------Partido de Tenis------- \n") + play() +} + +fun points(point: Int): String { + return when(point) { + 1 -> "15" + 2 -> "30" + 3 -> "40" + else -> "Love" + } +} + +fun random(start: Int, end: Int): Int { + require(start <= end) {"No válido"} + return (start..end).random() +} + +fun play() { + var playerOne = 0 + var playerTwo= 0 + + while (playerTwo < 3 && playerOne < 3) { + if (random(1, 2) == 1) playerOne++ + else playerTwo++ + + println("Player 1: ${points(playerOne)} -- Player 2: ${points(playerTwo)}") + + Thread.sleep(1000) + } + + if (playerOne == playerTwo) { + println("Empate") + return + } + if (playerOne > playerTwo) println("\n-----¡¡Ganador Player 1!!-----") + else println("\n-----¡¡Ganador Player 2!!-----") +} + diff --git a/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jarkillo.py b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jarkillo.py new file mode 100644 index 0000000000..334dff9dfb --- /dev/null +++ b/Retos/Reto #2 - EL PARTIDO DE TENIS [Media]/python/jarkillo.py @@ -0,0 +1,81 @@ +''' +/* + * 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. + */ + ''' + + +import os +import random + + +def tenis(secuencia): + + puntuacion = { + '0': 'Love', + '1': '15', + '2': '30', + '3': '40' + } + + p1 = 0 + p2 = 0 + + for punto in secuencia: + + if punto == 'P1': + p1 += 1 + elif punto == 'P2': + p2 += 1 + else: + print('Error en la secuencia') + return + + if p1 == 4 and p2 == 4: + print('Deuce') + empate = True + + if p1 == 4 or p2 == 4: + if empate == False: + print('Ha ganado el P1' if p1 == 4 else 'Ha ganado el P2') + return + else: + print('Ventaja P1' if p1 == 4 else 'Ventaja P2') + p1 -= 1 + p2 -= 1 + return + + else: + print(puntuacion[str(p1)] + ' - ' + puntuacion[str(p2)]) + empate = False + if p1 < 4 and p2 < 4: + print('Fin del tiempo') + print('Ha ganado el P1' if p1 > p2 else 'Ha ganado el P2') + return + +# Metemos secuencias Random + + +secuencia = [] +for i in range(15): + secuencia.append(random.choice(['P1', 'P2'])) + +os.system('PAUSE') +print(secuencia) +os.system('PAUSE') +tenis(secuencia) diff --git "a/Retos/Reto #28 - EXPRESI\303\223N MATEM\303\201TICA [Media]/javascript/patriciotrujilllo.js" "b/Retos/Reto #28 - EXPRESI\303\223N MATEM\303\201TICA [Media]/javascript/patriciotrujilllo.js" new file mode 100644 index 0000000000..fb57075512 --- /dev/null +++ "b/Retos/Reto #28 - EXPRESI\303\223N MATEM\303\201TICA [Media]/javascript/patriciotrujilllo.js" @@ -0,0 +1,44 @@ +/* + * Crea una función que reciba una expresión matemática (String) + * y compruebe si es correcta. Retornará true o false. + * - Para que una expresión matemática sea correcta debe poseer + * un número, una operación y otro número separados por espacios. + * Tantos números y operaciones como queramos. + * - Números positivos, negativos, enteros o decimales. + * - Operaciones soportadas: + - * / % + * + * Ejemplos: + * "5 + 6 / 7 - 4" -> true + * "5 a 6" -> false + */ + +const tuplaOperaciones = ['+','-','*','/','%'] + +const expresionMatematica = (expresion) =>{ + const ToArray = expresion.split(' ') + + for(let i=0;i<=ToArray.length-3;i+=2){ + + if(ToArray.length<3) return false + + if(isNaN(Number(ToArray[i]))){ + return false + } + if(!tuplaOperaciones.includes(ToArray[i+1])){ + return false + } + if(isNaN(Number(ToArray[i+2]))){ + return false + } + return true + } +} + +console.log(expresionMatematica("5 + 6 / 7 - 4"))//---->true +console.log(expresionMatematica("5 * 6 / 7 + 4"))//---->true +console.log(expresionMatematica("5 * 6 / -7 + 4 % 3"))//---->true +console.log(expresionMatematica("-5 * 6 / 7 + 4 % 3"))//---->true +console.log(expresionMatematica("5 a 6")) //---->false +console.log(expresionMatematica("a * 6")) //---->false +console.log(expresionMatematica("5 x 6")) //---->false +console.log(expresionMatematica("5 * b")) //---->false \ No newline at end of file diff --git "a/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/PushoDev.py" "b/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/PushoDev.py" new file mode 100644 index 0000000000..ba095b56a5 --- /dev/null +++ "b/Retos/Reto #29 - EL CAR\303\201CTER INFILTRADO [F\303\241cil]/python/PushoDev.py" @@ -0,0 +1,20 @@ +def encontrar_caracter_infiltrado(cad1, cad2): + infiltrados = [] + if len(cad1) != len(cad2): + return infiltrados # Retorna una lista vacía si las cadenas no tienen la misma longitud + for i in range(len(cad1)): + if cad1[i] != cad2[i]: + infiltrados.append(cad1[i]) + return infiltrados + +print("Pusho.Dev") +print("https://puschoft.blogspot.com") + +# Solicitar al usuario ingresar textos para identificar +cad1 = input("Ingrese la primera cadena: ") +cad2 = input("Ingrese la segunda cadena: ") + +# Mostrar los Resultados de este ejercicio +resp = encontrar_caracter_infiltrado(cad1, cad2) +print("Los caracteres infiltrados son:", resp) +print("Muchas Gracias por participar ...") \ No newline at end of file diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/rogmovi.js" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/r0j0Code.js" similarity index 100% rename from "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/rogmovi.js" rename to "Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/javascript/r0j0Code.js" diff --git "a/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/jarkillo.py" "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/jarkillo.py" new file mode 100644 index 0000000000..83cff2ba40 --- /dev/null +++ "b/Retos/Reto #3 - EL GENERADOR DE CONTRASE\303\221AS [Media]/python/jarkillo.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 random + + +def generar_contrasena(N): + mayusculas = ['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'] + minusculas = ['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'] + simbolos = ['!', '#', '$', '&', '/', + '(', ')', '=', '?', '¿', '¡', '}', '{', '[', ']', '*', '+', '-', '_', '.'] + numeros = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'] + + caracteres = mayusculas + minusculas + simbolos + numeros + + contrasena = [] + + for i in range(N): + caracter_random = random.choice(caracteres) + contrasena.append(caracter_random) + + contrasena = ''.join(contrasena) + return contrasena + + +print('Bienvenido al generador de contraseñas') +N = input('¿De cuantos caracteres quieres la contraseña? (Recomendado entre 8 y 16)') +try: + N = int(N) + generar_contrasena = generar_contrasena(N) + print('\nTu nueva contraseña es: ' + generar_contrasena) + +except: + print('Debes introducir un número') + exit() diff --git a/Retos/Reto #34 - EL TXT [Media]/python/jduque1989.py b/Retos/Reto #34 - EL TXT [Media]/python/jduque1989.py new file mode 100644 index 0000000000..943f53d486 --- /dev/null +++ b/Retos/Reto #34 - EL TXT [Media]/python/jduque1989.py @@ -0,0 +1,46 @@ +import os + + +def write_file(filename): + + with open(filename, "a") as file: + while True: + line = input("Enter a line of text: ") + if line == "": + break + file.write(line + "\n") + + +def erase_file(filename): + with open(filename, "w") as file: + file.write("") + + +# get files in directory + +files_in_directory = os.listdir() + +# Filter the list to only show .txt files +text_files = [file for file in files_in_directory if file.endswith(".txt")] + +if text_files: + print("The following .txt files are in the current directory:") + for idx, file in enumerate(text_files, 1): + print(f"{idx}. {file}") + choise = int(input("Enter the number of the file you want to edit: ")) + filename = text_files[choise - 1] + action = input("Write (w) or erase (e)?: ").lower() + if action == "w": + write_file(filename) + elif action == "e": + erase_file(filename) + print(f"Content of {filename} has been cleared!") + write_file(filename) +else: + print("No .txt files found in the current directory.") + print("We're going to create one for you.") + filename = input("What do you want to name the file? ") + filename = filename + ".txt" + with open(filename, "w") as f: + pass + write_file(filename) diff --git "a/Retos/Reto #35 - PRIMEROS PASOS [F\303\241cil]/python/marcoatrs.py" "b/Retos/Reto #35 - PRIMEROS PASOS [F\303\241cil]/python/marcoatrs.py" new file mode 100644 index 0000000000..85422b61bb --- /dev/null +++ "b/Retos/Reto #35 - PRIMEROS PASOS [F\303\241cil]/python/marcoatrs.py" @@ -0,0 +1,69 @@ +# Hola mundo +print("Hola, mundo!") + +# Variables +variable_string = "Variable de tipo str" +variable_entero = 4 +variable_flotante = 8.34 +variable_booleana = True + +# Constante +CONSTANTE = "Sigue siendo variable pero las mayusculas se usan como constantes" + +# if | else if | else +if variable_booleana: + print("Su valor es true") +elif variable_flotante > 10: + print("Su valor es mayor a 10") +else: + print("Ningunas de las condiciones anteriores se cumplieron") + +# Estructuras +lista: list = [0, 1, 2, "tres"] +tupla: tuple = (0, 1, 2, "dos + 1") +conjunto: set = {0, 1, 2, "tres"} +diccionario: dict = {"clave_1": "valor_1", "clave_2": "valor_2"} + +# for | foreach | while +for i in range(5): + print(i) + +for elemento in lista: + print(elemento) + +i = 0 +while i < 5: + print(i) + i += 1 + +# Funciones +def funcion_con_parametros(parametro_1: str, parametro_2: float): + print(f"Pasaste: {parametro_1} y {parametro_2}") + +def funcion_sin_parametros(): + print("Solo necesitas llamar esta funcion") + +def funcion_con_retorno(valor: int) -> int: + return valor + 1 + +funcion_con_parametros("Hola", 3.3) +funcion_sin_parametros() +print(funcion_con_retorno(3)) + +# Clases +class MiClase: + def __init__(self, id: str): + self.id = id + + def show_id(self): + print(self.id) + +print(MiClase("Marco").show_id()) + +# Control de excepciones +try: + print(3 / 0) +except ZeroDivisionError: + print("No se puede dividir entre 0") +finally: + print("Esta parte se ejecuta con o sin error") diff --git a/Retos/Reto #36 - PERMUTACIONES [Media]/python/marcoatrs.py b/Retos/Reto #36 - PERMUTACIONES [Media]/python/marcoatrs.py new file mode 100644 index 0000000000..cfe468e190 --- /dev/null +++ b/Retos/Reto #36 - PERMUTACIONES [Media]/python/marcoatrs.py @@ -0,0 +1,21 @@ +import itertools +from typing import List + + +def permutaciones(word: str) -> List[str]: + words = list() + if len(word) <= 1: + return [word] + for i, letter in enumerate(word): + for per in permutaciones(f"{word[:i]}{word[i+1:]}"): + words.append(f"{letter}{per}") + return words + + +word = "sol" + +# Opcion 1 +print(permutaciones("sol")) + +# Opcion 2 +print(["".join(per) for per in itertools.permutations(word)]) diff --git a/Retos/Reto #36 - PERMUTACIONES [Media]/python/ycanas.py b/Retos/Reto #36 - PERMUTACIONES [Media]/python/ycanas.py new file mode 100644 index 0000000000..03791c5d6d --- /dev/null +++ b/Retos/Reto #36 - PERMUTACIONES [Media]/python/ycanas.py @@ -0,0 +1,22 @@ +def permute(word): + if len(word) == 1: + return word + + permutations = [] + + for i in range(len(word)): + current = word[i] + rest = word[:i] + word[i + 1:] + + _permutations = permute(rest) + + for permut in _permutations: + permutations.append(current + permut) + + return permutations + + +permutations = permute("sol") + +for permut in permutations: + print(permut) diff --git a/Retos/Reto #38 - LAS SUMAS [Media]/python/matiaschamu.py b/Retos/Reto #38 - LAS SUMAS [Media]/python/matiaschamu.py new file mode 100644 index 0000000000..8666d9c433 --- /dev/null +++ b/Retos/Reto #38 - LAS SUMAS [Media]/python/matiaschamu.py @@ -0,0 +1,16 @@ +def BuscarObjetivo(list, objetivo): + combinaciones = pow(2,len(list)) + suma = 0 + for k in range (1,combinaciones): + b= bin(k)[2:].zfill(len(list)) + ret=[] + for i, bit in enumerate(b): + if bit == '1': + suma += list[i] + ret.append(list[i]) + if suma==objetivo: + print(ret) + suma=0 + ret=[] + return () +BuscarObjetivo([1,5,3,2],6) \ No newline at end of file diff --git a/Retos/Reto #38 - LAS SUMAS [Media]/python/ycanas.py b/Retos/Reto #38 - LAS SUMAS [Media]/python/ycanas.py new file mode 100644 index 0000000000..9b107e8b2c --- /dev/null +++ b/Retos/Reto #38 - LAS SUMAS [Media]/python/ycanas.py @@ -0,0 +1,25 @@ +def findsums(numbers, target): + def findsum(start, target, combination): + if target == 0: + result.append(combination.copy()) + return + + if target < 0 or start == len(numbers): + return + + for i in range(start, len(numbers)): + if i > start and numbers[i] == numbers[i - 1]: + continue + + combination.append(numbers[i]) + findsum(i + 1, target - numbers[i], combination) + combination.pop() + + numbers.sort() + result = [] + findsum(0, target, []) + + return result + + +print(findsums([1, 1, 1, 1, 1, 1, 1, 2, 2], 7)) diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/r0j0Code.js b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/r0j0Code.js new file mode 100644 index 0000000000..fb29d68646 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/javascript/r0j0Code.js @@ -0,0 +1,106 @@ +const readline = require("readline"); +const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout, +}); + +let userInput = 0; +rl.question("Ingresa un número: ", (answer) => { + userInput = Number(answer); + + console.log( + `El número ${userInput} ${isPrime(userInput).msg},` + + ` ${isFibonacci(userInput).msg} y ` + + ` ${esPar(userInput).msg}` + ); + + rl.close(); +}); + +/** + * Check if a number is a Pair or not + * @param {Number} num number to check if its pair or not + * @returns {Object} the result object {is, msg} + */ +function esPar(num) { + if (num % 2 == 0) { + return { + is: true, + msg: "es Par", + }; + } else { + return { + is: false, + msg: "es Impar", + }; + } +} + +/** + * Regresa si es un número primo. Los números primos son aquellos que solo tienen 2 factores: 1 y ellos mismos. + * @param {*} num + * @returns {Object} the result object {is, msg} + */ +function isPrime(num) { + let output = {}; + const isPrimeOrNot = () => { + if (num <= 1) { + return false; + } + if (num <= 3) { + return true; + } + if (num % 2 === 0 || num % 3 === 0) { + return false; + } + + for (let i = 5; i * i <= num; i += 6) { + if (num % i === 0 || num % (i + 2) === 0) { + return false; + } + } + + return true; + }; + + output["is"] = isPrimeOrNot(); + output["msg"] = isPrimeOrNot() == true ? "es primo" : "no es Primo"; + return output; +} + +function fibonacci(n) { + // The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones. It starts with 0 and 1. + + if (n <= 1) { + return n; + } else { + return fibonacci(n - 1) + fibonacci(n - 2); + } +} + +/** + * Check if a number is part of the fibonacci sequence + * @param {Number} n Number that if going to be screen to check if its a fibonacci or not + * @returns {Object} the result object {is, msg} + */ +function isFibonacci(n) { + let fibonacciSeq = []; + + for (let num = 0; num <= n + 1; num++) { + fibonacciSeq.push(fibonacci(num)); + } + + let output = {}; + output.seq = fibonacciSeq; + output.number = n; + + if (fibonacciSeq.includes(n)) { + output["is"] = true; + output["msg"] = "fibonacci"; + } else { + output["is"] = false; + output["msg"] = "no es fibonacci"; + } + + return output; +} diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/ccaicedo09.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/ccaicedo09.py new file mode 100644 index 0000000000..520cc3967e --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/ccaicedo09.py @@ -0,0 +1,51 @@ +""" +/* + * 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 is_prime(num: int): + + if num <= 1: + return False + + for i in range(2,num): + if num%i == 0: + return False + + return True + + +def is_fibonacci(num: int): + numOne = 1 + numTwo = 1 + while numTwo < num: + [numOne, numTwo] = [numTwo, numOne + numTwo] + + return numTwo == num or num == 1 + + +def is_even(num: int): + + if num%2 == 0: + return True + else: + return False + + +def main(num): + + result = f"El número {num}" + result += f" es primo," if is_prime(num) else " no es primo," + result += f" fibonacci " if is_fibonacci(num) else " no es fibonacci " + result += f"y es par" if is_even(num) else "y es impar" + + return result + + +print(main(2)) +print(main(7)) diff --git a/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/jarkillo.py b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/jarkillo.py new file mode 100644 index 0000000000..7b3b407aa9 --- /dev/null +++ b/Retos/Reto #4 - PRIMO, FIBONACCI Y PAR [Media]/python/jarkillo.py @@ -0,0 +1,39 @@ +'''/* + * 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 primo_fibonacci_par(numero): + # Comprobamos si es primo + if numero > 1: + for i in range(2, numero): + if numero % i == 0: + print(f'{numero} no es primo') + break + else: + print(f'{numero} es primo') + else: + print(f'{numero} no es primo') + + # Comprobamos si es fibonacci + a = 0 + b = 1 + while b < numero: + a, b = b, a + b # a = b, b = a + b + if b == numero: + print(f'{numero} es fibonacci') + else: + print(f'{numero} no es fibonacci') + + # Comprobamos si es par + if numero % 2 == 0: + print(f'{numero} es par') + else: + print(f'{numero} es impar') + + +numero = int(input('Introduce un número: ')) +primo_fibonacci_par(numero) diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/dart/JosephPaiz.dart" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/dart/JosephPaiz.dart" new file mode 100644 index 0000000000..023bde6131 --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/dart/JosephPaiz.dart" @@ -0,0 +1,26 @@ +import 'dart:io'; + +void main(List args) { + stdout.writeln("Ingrese la tabla de multiplicar: "); + FindOut(); +} + +void FindOut() { + String? table = stdin.readLineSync(); + + if (table == null || table.isEmpty || int.tryParse(table) == null) { + print("¡¡¡Ingrese un valor correcto!!!"); + FindOut(); + } else { + Calculetion(table); + } +} + +void Calculetion(String table) { + print('Estas seria las tablas de multiplicar de $table'); + final numTable = int.tryParse(table)!; + + for (int i = 1; i <= 10; i++) { + print("$table x $i = ${numTable * i}"); + } +} diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/PushoDev.py" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/PushoDev.py" new file mode 100644 index 0000000000..1b576531b5 --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/PushoDev.py" @@ -0,0 +1,24 @@ +# Reto No.40 -Tabla de multiplicar +# Dificultad: Fácil | Publicación: 09/10/23 | Corrección: 16/10/23 +#----------------------------------------------------------------- +#Enunciado +# 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 +# ... +#----------------------------------------------------------------- + +print ("Pushodev") +print ("https://github.com/PushoDev") + +numero = int(input("Ingresa un número: ")) + +for i in range(1, 11): + resultado = numero * i + print(f"{numero} x {i} = {resultado}") + +print ("Muchas Gracias por participar") +print ("Su número ingresado fué: ", numero) \ No newline at end of file diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/ccaicedo09.py" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/ccaicedo09.py" new file mode 100644 index 0000000000..5b7601b573 --- /dev/null +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/ccaicedo09.py" @@ -0,0 +1,16 @@ +""" + * 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 + * ... +""" + +def main(): + number = int(input("Ingresa el número del que deseas saber su tabla de multiplicar ---> ")) + for i in range(1,11): + print(f"{number} x {i} = {number*i}") + +main() diff --git "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/ycanas.py" "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/ycanas.py" index 3fb3e7aac6..897356ff1f 100644 --- "a/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/ycanas.py" +++ "b/Retos/Reto #40 - TABLA DE MULTIPLICAR [F\303\241cil]/python/ycanas.py" @@ -3,5 +3,12 @@ def tabla(n): for i in range(1, 11): print(f"{n} x {str(i):>2s} = {str(n * i):>{max}s}") -n = int(input("Ingrese un número: ")) -tabla(n) + +while True: + try: + n = int(input("Ingrese un número entero: ")) + tabla(n) + break + + except: + print("[Error] Ingrese un número entero.") diff --git "a/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/c#/deathwing696.cs" "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/c#/deathwing696.cs" new file mode 100644 index 0000000000..d7bad081a4 --- /dev/null +++ "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/c#/deathwing696.cs" @@ -0,0 +1,207 @@ +/* + * Este es un reto especial por Halloween. + * Te encuentras explorando una mansión abandonada llena de habitaciones. + * En cada habitación tendrás que resolver un acertijo para poder avanzar a la siguiente. + * Tu misión es encontrar la habitación de los dulces. + * + * Se trata de implementar un juego interactivo de preguntas y respuestas por terminal. + * (Tienes total libertad para ser creativo con los textos) + * + * - 🏰 Casa: La mansión se corresponde con una estructura cuadrada 4 x 4 + * que deberás modelar. Las habitaciones de puerta y dulces no tienen enigma. + * (16 habitaciones, siendo una de entrada y otra donde están los dulces) + * Esta podría ser una representación: + * 🚪⬜️⬜️⬜️ + * ⬜️👻⬜️⬜️ + * ⬜️⬜️⬜️👻 + * ⬜️⬜️🍭⬜️ + * - ❓ Enigmas: Cada habitación propone un enigma aleatorio que deberás responder con texto. + * Si no lo aciertas no podrás desplazarte. + * - 🧭 Movimiento: Si resuelves el enigma se te preguntará a donde quieres desplazarte. + * (Ejemplo: norte/sur/este/oeste. Sólo deben proporcionarse las opciones posibles) + * - 🍭 Salida: Sales de la casa si encuentras la habitación de los dulces. + * - 👻 (Bonus) Fantasmas: Existe un 10% de que en una habitación aparezca un fantasma y + * tengas que responder dos preguntas para salir de ella. + */ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; + +namespace reto41 +{ + public class Reto41 + { + private static Dictionary _enigmas = new Dictionary(); + private static Dictionary _preguntas = new Dictionary(); + + static void Main(string[] args) + { + Inicializa_enigmas(); + Inicializa_preguntas(); + + string[,] mansion = { + {"🚪", "⬜", "⬜", "⬜"}, + {"⬜", "👻", "⬜", "⬜"}, + {"⬜", "⬜", "⬜", "👻"}, + {"⬜", "⬜", "🍭", "⬜"} + }; + + int fila_actual = 0; + int columna_actual = 0; + + Console.WriteLine("¡Bienvenido a la mansión abandonada! Conseguirás hallar la habitación de los dulces?"); + + while (true) + { + string habitacion_actual = mansion[fila_actual, columna_actual]; + + Imprime_tablero(mansion, fila_actual, columna_actual); + + if (habitacion_actual == "🍭") + { + Console.WriteLine("¡Enhorabuena! ¡Has encontrado la habitación de los dulces!"); + break; + } + + if (habitacion_actual == "👻") + { + Console.WriteLine("¡Oh no! Un fantasma te ha atrapado. Debes responder dos preguntas para salir."); + + if (!ResponderPregunta() || !ResponderPregunta()) + { + Console.WriteLine("El fantasma no está satisfecho. Has perdido."); + break; + } + } + else + { + Console.WriteLine($"Estás en una habitación. Resuelve el enigma para avanzar."); + if (!ResolverEnigma()) + { + Console.WriteLine("Respuesta incorrecta. No puedes avanzar."); + continue; + } + } + + Console.Write("¿Hacia dónde quieres desplazarte? (norte/sur/este/oeste): "); + string direccion = Console.ReadLine().ToLower(); + + // Mover según la dirección + switch (direccion) + { + case "norte": + if (fila_actual > 0) fila_actual--; + break; + case "sur": + if (fila_actual < mansion.GetLength(0) - 1) fila_actual++; + break; + case "este": + if (columna_actual < mansion.GetLength(1) - 1) columna_actual++; + break; + case "oeste": + if (columna_actual > 0) columna_actual--; + break; + default: + Console.WriteLine("Dirección no válida. Las direcciones que puedes usar son: norte, sur, este u oeste"); + break; + } + } + + Console.ReadKey(); + } + + static void Imprime_tablero(string[,] tablero, int fila_actual, int columna_actual) + { + string simbolo = tablero[fila_actual, columna_actual]; + + tablero[fila_actual, columna_actual] = "👤"; + + for (int i = 0; i < tablero.GetLength(0); i++) + { + for (int j = 0; j < tablero.GetLength(1); j++) + { + Console.Write($"{tablero[i, j]} "); + } + + Console.WriteLine(); + } + + tablero[fila_actual, columna_actual] = simbolo; + } + + static void Inicializa_enigmas() + { + _enigmas.Add("aguja", "Enigma: ¿Qué tiene ojos y no puede ver?"); + _enigmas.Add("vela", "Enigma: Soy alto cuando joven y corto cuando viejo. ¿Qué soy?"); + _enigmas.Add("secreto", "Enigma: Todos me quieren, todos me buscan. Cuando me tienen, me quieren compartir. ¿Qué soy?"); + _enigmas.Add("oscuridad", "Enigma: Cuanto más lo miras, menos lo ves. ¿Qué es?"); + _enigmas.Add("agua", "Enigma: Siempre estoy corriendo, pero nunca me canso. ¿Qué soy?"); + _enigmas.Add("corazón", "Enigma: Si me rompes, no dejas de llorar. Si me tocas, algo moriría. ¿Qué soy?"); + _enigmas.Add("nube", "Enigma: Sin alas, voy a lugares altos. Sin piernas, me muevo rápido. ¿Qué soy?"); + _enigmas.Add("pizza", "Soy redonda como una pelota, pero todo el mundo me quiere llevar a casa. ¿Qué soy?"); + _enigmas.Add("viento", "Enigma: Puedo estar en todas partes, pero nunca puedes verme. ¿Qué soy?"); + _enigmas.Add("teclado", "Enigma: Tengo llaves pero no abro cerraduras. Tengo espacio pero no tengo habitación. ¿Qué soy?"); + _enigmas.Add("espejo", "Enigma: Aunque siempre hablo la verdad, nunca digo una palabra. ¿Qué soy?"); + _enigmas.Add("aliento", "Enigma: Puedo ser tan ligero como una pluma, pero incluso el hombre más fuerte no puede sostenerme durante mucho tiempo. ¿Qué soy?"); + _enigmas.Add("libro", "Enigma: Puedo ser leído, pero no por todos. Todos tienen uno, pero algunos prefieren usar el de otros. ¿Qué soy?"); + _enigmas.Add("futuro", "Enigma: Siempre estoy delante de ti, pero nunca puedes verme. ¿Qué soy?"); + _enigmas.Add("reloj", "Enigma: Tengo agujas pero no coso. Tengo números pero no cuento. ¿Qué soy?"); + _enigmas.Add("cebolla", "Enigma: Aunque no tengo ojos, lloro cuando cortas. ¿Qué soy?"); + _enigmas.Add("sombra", "Enigma: Puedes verme en el agua, pero nunca me mojaré. ¿Qué soy?"); + } + + static void Inicializa_preguntas() + { + _preguntas.Add("mapa", "Pregunta: Tengo ciudades, pero no casas. Tengo montañas, pero no árboles. Tengo agua, pero no peces. ¿Qué soy?"); + _preguntas.Add("café", "Pregunta: Soy tomado de la vaca, pero no soy leche. Tengo cuernos y me bebes caliente. ¿Qué soy?"); + _preguntas.Add("agujero", "Pregunta: Cuando más lo quitas, más grande se vuelve. ¿Qué es?"); + _preguntas.Add("nube", "Pregunta: Puedo volar sin tener alas. Puedo llorar sin tener ojos. ¿Qué soy?"); + _preguntas.Add("Incorrectamente", "Pregunta: ¿Qué palabra siempre está escrita incorrectamente?"); + _preguntas.Add("toalla", "Pregunta: Cuanto más seca, más mojada se vuelve. ¿Qué es?"); + _preguntas.Add("teléfono", "Pregunta: Hablo sin boca y oigo sin oídos. No tengo cuerpo, pero vengo de un cerdo. ¿Qué soy?"); + _preguntas.Add("copo de nieve", "Pregunta: Entra uno, el sol lo toca, y ya no está. ¿Qué es?"); + } + + static bool ResolverEnigma() + { + Extrae_de_diccionario(false, out string pregunta, out string solucion); + + Console.WriteLine(pregunta); + string respuesta = Console.ReadLine().ToLower(); + + return respuesta == solucion; + } + + static bool ResponderPregunta() + { + Extrae_de_diccionario(true, out string pregunta, out string solucion); + + Console.WriteLine(pregunta); + string respuesta = Console.ReadLine().ToLower(); + + return respuesta == solucion; + } + + static void Extrae_de_diccionario(bool es_pregunta, out string pregunta, out string solucion) + { + Random random = new Random(); + + if (es_pregunta) + { + int numero_aleatorio = random.Next(0, _preguntas.Count); + + solucion = _preguntas.Keys.ElementAt(numero_aleatorio); + pregunta = _preguntas[solucion]; + } + else + { + int numero_aleatorio = random.Next(0, _enigmas.Count); + + solucion = _enigmas.Keys.ElementAt(numero_aleatorio); + pregunta = _enigmas[solucion]; + } + } + } +} \ No newline at end of file diff --git "a/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/java/Qv1ko.java" "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/java/Qv1ko.java" new file mode 100644 index 0000000000..9986e68f19 --- /dev/null +++ "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/java/Qv1ko.java" @@ -0,0 +1,181 @@ +import java.util.Random; +import java.util.Scanner; + +public class Qv1ko { + + public static void main(String[] args) { + + char[][] house = createHouse(); + int[] door = findDoor(house); + + int[] position = door; + System.out.println("Starting position: [" + position[0] + ", " + position[1] + "]\n"); + + System.out.println("If you want to find the candy in the haunted house you will have to search through its rooms."); + System.out.println("But remember, you won't be able to move if you don't answer their riddle correctly first.\n"); + + Scanner scanner = new Scanner(System.in); + + while (true) { + + position = move(position, house); + System.out.println("Position: [" + position[0] + ", " + position[1] + "]\n"); + + char houseRoom = house[position[0]][position[1]]; + + if (houseRoom == 'R') { + + System.out.println("Answer this question correctly."); + riddle(); + + boolean ghost = new Random().nextInt(10) == 1; + + if (ghost) { + System.out.println("Boo! To get out of this room you will have to answer one more question."); + riddle(); + } + + } else if (houseRoom == 'C') { + System.out.println("You have found the candy and escaped from the haunted house."); + break; + } + + } + + scanner.close(); + + } + + private static char[][] createHouse() { + + char[][] house = new char[4][4]; + + for (int i = 0; i < 4; i++) { + for (int j = 0; j < 4; j++) { + house[i][j] = 'R'; + } + } + + boolean isColumn = new Random().nextBoolean(); + int[] door; + + if (isColumn) { + door = new int[] { new Random().nextInt(4), new Random().nextInt(2) * 3 }; + } else { + door = new int[] { new Random().nextInt(2) * 3, new Random().nextInt(4) }; + } + + house[door[0]][door[1]] = 'D'; + + int[] candy = generateCandy(door); + house[candy[0]][candy[1]] = 'C'; + + for (int i = 0; i < 4; i++) { + System.out.println(new String(house[i])); + } + + return house; + + } + + private static int[] generateCandy(int[] door) { + + int[] candy; + + do { + candy = new int[] { new Random().nextInt(4), new Random().nextInt(4) }; + } while (candy[0] == door[0] && candy[1] == door[1]); + + return candy; + + } + + private static int[] findDoor(char[][] house) { + + for (int i = 0; i < 4; i++) { + for (int j = 0; j < 4; j++) { + if (house[i][j] == 'D') { + return new int[] { i, j }; + } + } + } + + return new int[] { -1, -1 }; + + } + + private static int[] move(int[] position, char[][] house) { + + int row = position[0]; + int column = position[1]; + + String movements = "N S E W "; + + if (row == 0) { + movements = movements.replace("N ", ""); + } + if (row == 3) { + movements = movements.replace("S ", ""); + } + if (column == 0) { + movements = movements.replace("W ", ""); + } + if (column == 3) { + movements = movements.replace("E ", ""); + } + + try (Scanner scanner = new Scanner(System.in)) { + + String movement; + + do { + System.out.print("Where do you want to move [ " + movements + "]?: "); + movement = scanner.next().toUpperCase(); + } while (!movements.contains(movement)); + + if (movement.equals("N")) { + position = new int[] { row - 1, column }; + } else if (movement.equals("S")) { + position = new int[] { row + 1, column }; + } else if (movement.equals("E")) { + position = new int[] { row, column + 1 }; + } else if (movement.equals("W")) { + position = new int[] { row, column - 1 }; + } + + } + + return position; + + } + + private static void riddle() { + + int randomNumber1 = (int) (Math.random() * 51); + int randomNumber2 = (int) (Math.random() * 51); + + String[][] riddles = { + { Integer.toString(randomNumber1) + " + " + Integer.toString(randomNumber2), Integer.toString(randomNumber1 + randomNumber2) }, + { Integer.toString(randomNumber1) + " - " + Integer.toString(randomNumber2), Integer.toString(randomNumber1 - randomNumber2) }, + { Integer.toString(randomNumber1) + " * " + Integer.toString(randomNumber2), Integer.toString(randomNumber1 * randomNumber2) }, + }; + + String[] riddle = riddles[new Random().nextInt(riddles.length)]; + + try (Scanner scanner = new Scanner(System.in)) { + + System.out.print(riddle[0] + ": "); + + String answer = scanner.nextLine(); + + if (answer.equalsIgnoreCase(riddle[1])) { + System.out.println("Correct answer!\n"); + } else { + System.out.println("Incorrect answer!\n"); + } + + } + + } + +} diff --git "a/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/Hugovrc.py" "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/Hugovrc.py" new file mode 100644 index 0000000000..79c11142fe --- /dev/null +++ "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/Hugovrc.py" @@ -0,0 +1,79 @@ +import random + +def casa_encantada(): + preguntas = (("cuando se celebra el halloween?", "31 de octubre"), + ("Qué bebida es popular en las fiestas de Halloween?","sangre de vampiro"), + ("Qué película de terror es un clásico para ver en Halloween?","el resplandor"), + ("Que actividad hacen los niños el dia de Halloween?","pedir dulces"), + ("Por que se tallan calabazas en forma de caras espeluznantes?","para alejar a los espiritus malignos"), + ("De dónde proviene la celebración de Halloween?", "de una festividad celta llamada Samhain")) + + habitaciones = [["🚪","⬜","⬜","⬜"], + ["⬜","👻","⬜","⬜"], + ["⬜","⬜","⬜","👻"], + ["⬜","⬜","⬜","🍭"]] + + #for row in habitaciones: + # print("".join(map(str,row))) + + posicion = encontrar_elemento(habitaciones, "🚪") + posicion_fila = posicion[0] + posicion_columna = posicion[1] + pos = [] + + while True: + num = len(preguntas) + num_preg = random.randint(0,num-1) + num_preg2 = random.randint(0, num-1) + + primera_pregunta, primera_resp = preguntas[num_preg] + if num_preg2 != num_preg: + segunda_pregunta, segunda_resp = preguntas[num_preg2] + + pos = habitaciones[posicion_fila][posicion_columna] + if pos == "⬜": + print("---Deberas responder esta pregunta para poder avanzar---") + respuesta = input(f"{primera_pregunta}: ") + while respuesta != primera_resp: + print("respuesta incorrecta!!") + respuesta = input(f"{primera_pregunta}: ") + + elif pos == "👻": + print("---Deberas responder dos preguntas para poder avanzar---") + respuesta1 = input(f"{primera_pregunta}: ") + respuesta2 = input(f"{segunda_pregunta}: ") + while respuesta1 != primera_resp or respuesta2 != segunda_resp: + print("--- respuesta incorrecta!!") + respuesta1 = input(f"{primera_pregunta}: ") + respuesta2 = input(f"{segunda_pregunta}: ") + elif pos == "🍭": + print("--- Felicidades haz encontrado la salida ---") + break + + movimiento = input("-- Hacia donde deseas desplazarte(norte/sur/este/oeste): ") + + if movimiento == "norte" and posicion_fila > 0: + posicion_fila -= 1 + elif movimiento == "sur" and posicion_fila < 3: + posicion_fila += 1 + elif movimiento == "oeste" and posicion_columna > 0: + posicion_columna -= 1 + elif movimiento == "este" and posicion_columna < 3: + posicion_columna += 1 + else: + print(f"no se puede desplazar hacia el {movimiento}") + +def encontrar_elemento(habitaciones, elemento): + posicion = [] + + for fila in range(4): + for columna in range(4): + if habitaciones[fila][columna] == elemento: + posicion = [fila, columna] + break + return posicion + + + + +casa_encantada() diff --git "a/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/mstrnilsson.py" "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/mstrnilsson.py" new file mode 100755 index 0000000000..f765984fe8 --- /dev/null +++ "b/Retos/Reto #41 - LA CASA ENCANTADA [Dif\303\255cil]/python/mstrnilsson.py" @@ -0,0 +1,259 @@ +import random, time, os + +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' + +def intro(): + os.system('clear') + txt1 = '👻 LA CASA ENCANTADA 👻' + u = txt1.center(69, '#') + print(f'\n\n\r{bcolors.HEADER}{bcolors.BOLD}{u}{bcolors.ENDC}\n\n', end='') + time.sleep(1) + txt2 = ' Te encuentas explorando las habitaciones de una 🏚️ mansión abandonada' + v = txt2.center(69, '#') + print(f'\r{bcolors.HEADER}{bcolors.BOLD}{v}{bcolors.ENDC}', end='') + time.sleep(3) + txt3 = ' Elige la dirección con las teclas N_orte 🔼 S_ur 🔽 E_ste ▶️ O_este ◀️ ' + w = txt3.center(69, '#') + print(f'\r{bcolors.HEADER}{bcolors.BOLD}{w}{bcolors.ENDC}', end='') + time.sleep(3) + txt4 = ' Para entrar en cada habitación tendrás que resolver una pregunta ' + x = txt4.center(70, '#') + print(f'\r{bcolors.HEADER}{bcolors.BOLD}{x}{bcolors.ENDC}', end='') + time.sleep(3) + txt5 = '¡¡¡¡ SUERTE !!!!' + z = txt5.center(69, '#') + print(f'\r{bcolors.HEADER}{bcolors.BOLD}{z}{bcolors.ENDC}\n', end='') + os.system('clear') + print('\r\r\r') + time.sleep(1) + + +def random_targets(): + for i in range(1): + random_row = random.randrange(0,4) + random_column = random.randrange(0,4) + return random_row, random_column + +def targets(row, column): + + door_coor=[] + lolli_coor=[] + ghost_coor1 = [] + ghost_coor2 = [] + + door_coor.extend([row, column]) + row, column = random_targets() + while [row, column] == door_coor: + row, column = random_targets() + lolli_coor.extend([row, column]) + row, column = random_targets() + while [row, column] == lolli_coor or [row, column] == door_coor: + row, column = random_targets() + ghost_coor1.extend([row, column]) + row, column = random_targets() + while [row, column] == ghost_coor1 or [row, column] == lolli_coor or [row, column] == door_coor: + row, column = random_targets() + ghost_coor2.extend([row, column]) + + return door_coor, lolli_coor, ghost_coor1, ghost_coor2 + + +def paint_matrix(door_coor, now_coor, matrix): + time.sleep(1) + print('\r\r\r') + for i in range(4): + matrix.append([]) + for j in range(4): + if [i, j] == door_coor: + matrix[i].append('🚪') + now_coor = door_coor.copy() + else: + matrix[i].append('🔳') + for row in range(4): + for column in range(4): + print(matrix[row][column], end = '') + print() + return now_coor, matrix + +def course(now_coor): + + key = input('\nHacia que habitación quieres moverte?\n').lower() + arrows = ['n', 's', 'e', 'o'] + + if key == 'n': + print('🔼') + if key == 's': + print('🔽') + if key == 'e': + print('▶️') + if key == 'o': + print('◀️') + + if key in arrows: + if forbidden(key, now_coor) == key: + return key + else: + return None + else: + return None + +def forbidden(key, now_coor): + + if (now_coor[0] == 0 and key == 'n'): + print(f'{bcolors.WARNING}\n ❌ No puedes moverte en esa dirección{bcolors.ENDC}') + return None + elif (now_coor[1] == 0 and key == 'o'): + print(f'{bcolors.WARNING}\n ❌ No puedes moverte en esa dirección{bcolors.ENDC}') + return None + elif (now_coor[0] == 3 and key == 's'): + print(f'{bcolors.WARNING}\n ❌ No puedes moverte en esa dirección{bcolors.ENDC}') + return None + elif (now_coor[1] == 3 and key == 'e'): + print(f'{bcolors.WARNING}\n ❌ No puedes moverte en esa dirección{bcolors.ENDC}') + return None + else: + return key + +def next(key, now_coor): + + next_coor = now_coor.copy() + + if key == 'n': + next_coor[0] -= 1 + if key == 's': + next_coor[0] += 1 + if key == 'e': + next_coor[1] += 1 + if key == 'o': + next_coor[1] -= 1 + return next_coor + + +def wich_target(matrix, finish, next_coor, lolli_coor, ghost_coor1, ghost_coor2): + + if next_coor == ghost_coor1: + print(f'\n{bcolors.WARNING}BUUUU !!! 👻 El fantasmico te retiene y debes superar 2 preguntas para entrar 👻{bcolors.ENDC}\n') + time.sleep(1) + enigma(2) + print(f'\n{bcolors.OKGREEN}🔑 Puedes entrar en la habitación{bcolors.ENDC}\n') + time.sleep(1) + os.system('clear') + matrix[ghost_coor1[0]][ghost_coor1[1]] = '👻' + now_coor = next_coor.copy() + return now_coor, finish + + elif next_coor == ghost_coor2: + print(f'\n{bcolors.WARNING}BUUUU !!! 👻 El fantasmico te retiene y debes superar 2 preguntas para entrar 👻{bcolors.ENDC}\n') + time.sleep(1) + enigma(2) + print(f'\n{bcolors.OKGREEN}🔑 Puedes entrar en la habitación{bcolors.ENDC}\n') + time.sleep(1) + os.system('clear') + matrix[ghost_coor2[0]][ghost_coor2[1]] = '👻' + now_coor = next_coor.copy() + return now_coor, finish + + + elif next_coor == lolli_coor: + enigma(1) + foo = '#' + print(f'{bcolors.OKGREEN}\n{foo*9:68}{foo*9}{bcolors.ENDC}') + print(f'{bcolors.OKGREEN}{foo*9:68}{foo*9}{bcolors.ENDC}') + print(f'{bcolors.OKGREEN}{foo*9} 🍭 Genial!! Has encontrado la habitación de los dulces 🍭 {foo*9}{bcolors.ENDC}') + print(f'{bcolors.OKGREEN}{foo*9:68}{foo*9}{bcolors.ENDC}') + print(f'{bcolors.OKGREEN}{foo*9:68}{foo*9}\n{bcolors.ENDC}') + time.sleep(1) + matrix[lolli_coor[0]][lolli_coor[1]] = '🍭' + now_coor = next_coor.copy() + finish = 'lollipop' + return now_coor, finish + + else: + enigma(1) + print(f'\n{bcolors.OKGREEN}🔑 Puedes entrar en la habitación{bcolors.ENDC}\n') + time.sleep(1) + os.system('clear') + matrix[next_coor[0]][next_coor[1]] = '✅' + now_coor = next_coor.copy() + return now_coor, finish + +def enigma(i:int): + while i != 0: + n1 = random.randrange(3,10) + n2 = random.randrange(3,10) + + answer_input = input(f'\n{bcolors.OKBLUE}¿Cuánto es {n1} x {n2}? = {bcolors.ENDC}') + answer = (n1*n2) + + if answer_input.isnumeric() and int(answer_input) == answer: + print(f'\n{bcolors.OKGREEN}Correcto!!{bcolors.ENDC}') + else: + print(f'\n{bcolors.FAIL} ❌ Lo siento respuesta incorrecta, es {bcolors.WARNING}{answer}{bcolors.ENDC}{bcolors.FAIL}, prueba otra vez{bcolors.ENDC}') + enigma(1) + i -= 1 + +def main(): + row=0 + column=0 + matrix = [] + next_coor = [] + now_coor = [] + key = '' + finish = '' + try: + time.sleep(1) + row, column = random_targets() + door_coor, lolli_coor, ghost_coor1, ghost_coor2 = targets(row, column) + now_coor, matrix = paint_matrix(door_coor, now_coor, matrix) + while finish == '': + key = course(now_coor) + while key == None: + key = course(now_coor) + next_coor = next(key, now_coor) + forbidden(key, now_coor) + now_coor, finish = wich_target(matrix, finish, next_coor, lolli_coor, ghost_coor1, ghost_coor2) + paint_matrix(door_coor, now_coor, matrix) + menu() + except KeyboardInterrupt: + print('\nbye!!\n') + SystemExit + + +if __name__ == "__main__": + + def menu(): + + try: + chosen_element = input(f"\n{bcolors.BOLD}{bcolors.OKBLUE}BIENVENIDO AL JUEGO, ELIGE UNA OPCIÓN: J_ugar C_ontinuar S_alir{bcolors.ENDC} \n") + os.system('clear') + if chosen_element.upper() == "J": + intro() + main() + elif chosen_element.upper() == "C": + main() + elif chosen_element.upper() == "S": + print('\nbye!!\n') + time.sleep(1) + SystemExit + else: + print("\nOpción no válida, vuelve a intentarlo") + menu() + except KeyboardInterrupt: + print('\nbye!!\n') + SystemExit + menu() + + + + + + \ No newline at end of file diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/c#/deathwing696.cs" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/c#/deathwing696.cs" new file mode 100644 index 0000000000..10d3142600 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/c#/deathwing696.cs" @@ -0,0 +1,97 @@ +/* + * Crea una funcin 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 (tambin en formato xy). + * - La funcin recibir las coordenadas de inicio de ambos objetos y sus velocidades. + * - La funcin calcular y mostrar el punto en el que se encuentran y el tiempo que tardarn en lograrlo. + * - La funcin debe tener en cuenta que los objetos pueden no llegar a encontrarse. + */ + +using System; + +namespace reto42 +{ + public class Reto42 + { + static void Main(string[] args) + { + //Ejemplo cruce 1 salida = (2.5, 2.5) 2.5 + //Punto obj1 = new Punto(0, 0); + //Vector vel1 = new Vector(1, 1); + + //Punto obj2 = new Punto(5, 0); + //Vector vel2 = new Vector(-1, 1); + + //Ejemplo cruce 2 salida = (1.5,1.5) 1.5 + //Punto obj1 = new Punto(0, 0); + //Vector vel1 = new Vector(1, 1); + + //Punto obj2 = new Punto(3, 0); + //Vector vel2 = new Vector(-1, 1); + + //Ejemplo cruce 3 salida = (2, 2) 2 + //Punto obj1 = new Punto(0, 0); + //Vector vel1 = new Vector(1, 1); + + //Punto obj2 = new Punto(4, 0); + //Vector vel2 = new Vector(-1, 1); + + //Ejemplo ya se han cruzado + Punto obj1 = new Punto(0, 0); + Vector vel1 = new Vector(1, 0); + + Punto obj2 = new Punto(0, 2); + Vector vel2 = new Vector(0, 1); + + Calcula_encuentro(obj1, vel1, obj2, vel2); + + Console.ReadKey(); + } + + static void Calcula_encuentro(Punto obj1, Vector vel1, Punto obj2, Vector vel2) + { + double deltaX = obj2.X - obj1.X; + double deltaY = obj2.Y - obj1.Y; + double deltaVX = vel2.X - vel1.X; + double deltaVY = vel2.Y - vel1.Y; + + double tiempo_encuentro = -(deltaX * deltaVX + deltaY * deltaVY) / (Math.Pow(deltaVX, 2) + Math.Pow(deltaVY, 2)); + + if (double.IsNaN(tiempo_encuentro) || tiempo_encuentro < 0) + { + Console.WriteLine("Los objetos se estn alejando o ya se han encontrado"); + return; + } + + double punto_encuentro_x = obj1.X + vel1.X * tiempo_encuentro; + double punto_encuentro_y = obj1.Y + vel1.Y * tiempo_encuentro; + + Console.WriteLine($"El punto de encuentro es el ({punto_encuentro_x.ToString().Replace(',', '.')},{punto_encuentro_y.ToString().Replace(',', '.')}) y se encontrarn pasadas {tiempo_encuentro} unidades de tiempo"); + } + + public class Punto + { + public double X { get;} + public double Y { get; } + + public Punto(double x, double y) + { + X = x; + Y = y; + } + } + + public class Vector + { + public double X { get; } + public double Y { get; } + + public Vector(double x, double y) + { + X = x; + Y = y; + } + } + } +} \ No newline at end of file diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/c#/mrf1989.cs" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/c#/mrf1989.cs" new file mode 100644 index 0000000000..12e9ab7707 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/c#/mrf1989.cs" @@ -0,0 +1,69 @@ +// Test cases + +MovingObject obj1A = new(new(2, 2), new(1, 2)); +MovingObject obj1B = new(new(5, 5), new(-2, -1)); + +MovingObject obj2A = new(new(0, 0), new(2, 1)); +MovingObject obj2B = new(new(0, 6), new(2, -2)); + +MovingObject obj3A = new(new(5, 0), new(0, 3)); +MovingObject obj3B = new(new(14, 15), new(-3, -2)); + +MovingObject obj4A = new(new(5, 0), new(0, 3)); +MovingObject obj4B = new(new(14, 15), new(3, 2)); + +CalculateMeetingPoint(obj1A, obj1B); +CalculateMeetingPoint(obj2A, obj2B); +CalculateMeetingPoint(obj3A, obj3B); +CalculateMeetingPoint(obj4A, obj4B); + +void CalculateMeetingPoint(MovingObject objA, MovingObject objB) +{ + + var dx = objB.Position.X - objA.Position.X; + var dy = objB.Position.Y - objA.Position.Y; + var dsx = objB.SpeedVector.X - objA.SpeedVector.X; + var dsy = objB.SpeedVector.Y - objA.SpeedVector.Y; + + var t = - (dx * dsx + dy * dsy) / (Math.Pow(dsx, 2) + Math.Pow(dsy, 2)); + + if (t < 0 || Convert.ToDecimal(t) % 1 != 0) + { + Console.WriteLine("Objects do not intersect at any point in the plane"); + } + else + { + Coord CutPoint = new(objA.Position.X + Convert.ToInt32(t) * objA.SpeedVector.X, + objA.Position.Y + Convert.ToInt32(t) * objA.SpeedVector.Y); + Console.WriteLine($"The objects have been found at point {CutPoint} after {t} seconds"); + } +} + +class MovingObject +{ + public Coord Position { get; set; } + public Coord SpeedVector { get; set; } + + public MovingObject(Coord position, Coord speedVector) + { + Position = position; + SpeedVector = speedVector; + } +} + +class Coord +{ + public int X { get; set; } + public int Y { get; set; } + + public Coord(int x, int y) + { + X = x; + Y = y; + } + + public override string ToString() + { + return $"({X}, {Y})"; + } +} \ No newline at end of file diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/java/Qv1ko.java" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/java/Qv1ko.java" new file mode 100644 index 0000000000..804656260e --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/java/Qv1ko.java" @@ -0,0 +1,41 @@ +class Qv1ko { + + public static void main(String[] args) { + meetingPoint(new int[]{randomNumber(5), randomNumber(5)}, new int[]{randomNumber(5), randomNumber(5)}, new int[]{randomVector(2), randomVector(2)}, new int[]{randomVector(2), randomVector(2)}); + } + + private static void meetingPoint(int[] obj1, int[] obj2, int[] vectorObj1, int[] vectorObj2) { + + int time = 0; + + if (!parallel(vectorObj1, vectorObj2)) { + + while((obj1[0] != obj2[0] || obj1[1] != obj2[1]) && time < 180) { + obj1[0] += vectorObj1[0]; + obj1[1] += vectorObj1[1]; + obj2[0] += vectorObj2[0]; + obj2[1] += vectorObj2[1]; + time++; + } + + System.out.println((time == 180)? "Will not be found" : "Meets at " + obj1[0]+ "," + obj1[1] + " after " + time + " seconds"); + + } else { + System.out.println("Will not be found"); + } + + } + + private static boolean parallel(int[] vectorObj1, int[] vectorObj2) { + return (vectorObj1[0] * vectorObj2[1] == vectorObj1[1] * vectorObj2[0]); + } + + private static int randomNumber(int index) { + return (int)(Math.random() * (index + 1)); + } + + private static int randomVector(int index) { + return (int)(Math.random() * index) + 1; + } + +} diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/javascript/othamae.js" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/javascript/othamae.js" new file mode 100644 index 0000000000..69e007c4ab --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/javascript/othamae.js" @@ -0,0 +1,98 @@ +/* + * 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. + */ + + +function meetingPoint(object1, object2){ + const dx = object2.x - object1.x + const vx = object1.vx - object2.vx + const dy = object2.y - object1.y + const vy = object1.vy - object2.vy + + const t = (dx * vx + dy * vy) / (vx * vx + vy * vy) + + if (t > 0){ + const x = object1.x + object1.vx * t + const y = object1.y + object1.vy * t + const relativeX = object2.x + object2.vx * t + const relativeY = object2.y + object2.vy * t + + const distance = Math.sqrt((x - relativeX) ** 2 + (y - relativeY) ** 2) + + if (distance < 0.00001) { + return `Time to meet: ${t}, Coordinates: (${x}, ${y})` + } + } + return ("They will never meet") +} + + +// Test: + +const object1={ + x:0, + y:0, + vx:1, + vy:1 +} + +const object2={ + x: 4, + y:0, + vx:0, + vy:1 +} + +const object3={ + x:0, + y:0, + vx:1, + vy:1 +} + +const object4={ + x: 2, + y:0, + vx:1, + vy:2 +} + +const object5={ + x:6, + y:6, + vx:-1, + vy:-1 +} + +const object6={ + x: 2, + y:0, + vx:1, + vy:2 +} + +const object7={ + x:6, + y:6, + vx:-1, + vy:-1 +} + +const object8={ + x: 2, + y:0, + vx:2, + vy:1 +} + + +console.log(meetingPoint(object1, object2)) // Time to meet: 4, Coordinates: (4, 4) +console.log(meetingPoint(object3, object4)) // They will never meet +console.log(meetingPoint(object5, object6)) // Time to meet: 2, Coordinates: (4, 4) +console.log(meetingPoint(object7, object8)) // They will never meet diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/javascript/pedrogf.js" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/javascript/pedrogf.js" new file mode 100644 index 0000000000..4dde9714f1 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/javascript/pedrogf.js" @@ -0,0 +1,83 @@ +/* + * 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. + */ + +function objectMetting (obj1, obj2) { + //Calcula la distancia entre los objetos en la posición inicial (previous) y en la t+1(actual). + let previousDistance = Math.sqrt((obj2.x - obj1.x)**2 + (obj2.y - obj1.y)**2) + let actualDistance = Math.sqrt(((obj2.x + obj2.vx) - (obj1.x + obj1.vx))**2 + (((obj2.y + obj2.vy) - (obj1.y + obj1.vy))**2)) + let t=1 + let newPositionObj1x, newPositionObj1y, newPositionObj2x, newPositionObj2y + + while (true) { + t++ + // Calcula la posición de los objetos en función del tiempo. + newPositionObj1x = obj1.x + obj1.vx * t + newPositionObj1y = obj1.y + obj1.vy * t + newPositionObj2x = obj2.x + obj2.vx * t + newPositionObj2y = obj2.y + obj2.vy * t + + if(actualDistance >= previousDistance) { // Si la distancia entre los objetos aumenta o es igual nunca se encontrarán. + return 'Los vectores nunca se encontraán' + } else if (newPositionObj1x === newPositionObj2x && newPositionObj1y === newPositionObj2y) { // avanzamos la posición multiplicando por el tiempo + // Si la posición de ambos objetos es la misma, se han encontraron. + return`Los vectores se han encontrado en la posición [${newPositionObj1x}, ${newPositionObj1y}] en un tiempo de ${t} unidades` + }else{ + //recalculamos las nuevas posiciones de los objetos. + previousDistance = actualDistance + actualDistance = Math.sqrt((newPositionObj2x - newPositionObj1x)**2 + ((newPositionObj2y - newPositionObj1y)**2)) + } + } +} + +// Objetos que se encuentran. +let objeto1 = { + x: 0, + y: 0, + vx: 1, + vy: 1, +} +let objeto2 = { + x: 5, + y: 0, + vx: 0, + vy: 1, +} +console.log(objectMetting(objeto1, objeto2)) + +// Objetos con vectores paralelos que nunca se encuentran. +let objeto3 = { + x: 2, + y: 0, + vx: 0, + vy: 1, +} +let objeto4 = { + x: 4, + y: 0, + vx: 0, + vy: 1, +} +console.log(objectMetting(objeto3, objeto4)) + +// Objetos que se cruzan pero no en el mismo instante +let objeto5 = { + x: 2, + y: 2, + vx: 1, + vy: 1, +} +let objeto6 = { + x: 4, + y: 0, + vx: 0, + vy: 1, +} +console.log(objectMetting(objeto5, objeto6)) + diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/JorgeCM2004.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/JorgeCM2004.py" new file mode 100644 index 0000000000..169572e7d8 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/JorgeCM2004.py" @@ -0,0 +1,68 @@ +from typing import NamedTuple +class Object(NamedTuple): + position: tuple + speed: tuple + +def ask_position(obj: str) -> tuple: + coorx = int(input(f"Coordenada x del objeto {obj}: ")) + coory = int(input(f"Coordenada y del objeto {obj}: ")) + return (coorx, coory) + +def ask_speed(obj: str) -> tuple: + speedx = int(input(f"Velocidad en el eje x del objeto {obj}: ")) + speedy = int(input(f"Velocidad en el eje y del objeto {obj}: ")) + return (speedx, speedy) + +def will_intersect(obj1: Object, obj2: Object) -> bool: + # Debemos calular las pendientes y ver si son iguales o no, li lo son las proyecciones son paralelas y nunca colisionarán. + return obj1.speed[1] / obj1.speed[0] != obj2.speed[1] / obj2.speed[0] + +def same_position(obj1: Object, obj2: Object) -> bool: + return obj1.position == obj2.position + +def calculate_intersection(obj1: Object, obj2: Object) -> tuple: + m1 = obj1.speed[1] / obj1.speed[0] + m2 = obj2.speed[1] / obj2.speed[0] + # Procedimiento seguido (Os lo dejo en codigo, si lo quereis ver Quitad las comillas) + ''' + eq1 = f"y = {m1} * (x - {obj1.position[0]}) + {obj1.position[1]}" + eq2 = f"y = {m2} * (x - {obj2.position[0]}) + {obj2.position[1]}" + resol1 = f"{m1} * (x - {obj1.position[0]}) + {obj1.position[1]} = {m2} * (x - {obj2.position[0]}) + {obj2.position[1]}" + resol2 = f"{m1} * x - {m1} * {obj1.position[0]} + {obj1.position[1]} = {m2} * x - {m2} * {obj2.position[0]} + {obj2.position[1]}" + resol3 = f"{m1} * x - {m2} * x = - {m2} * {obj2.position[0]} + {obj2.position[1]} + {m1} * {obj1.position[0]} - {obj1.position[1]}" + resol4 = f"x * ({m1} - {m2}) = - {m2} * {obj2.position[0]} + {obj2.position[1]} + {m1} * {obj1.position[0]} - {obj1.position[1]}" + resol4 = f"x = (- {m2} * {obj2.position[0]} + {obj2.position[1]} + {m1} * {obj1.position[0]} - {obj1.position[1]}) / ({m1} - {m2})" + print("Estas rectas son las que describen el movimiento tanto para lo que hará como para lo que deberia hacer en tiempos negativos (avanzando en el tiempo tanto hacia delante como hacia detras)") + print(f"Ecuacion del objeto B: {eq1}\nEcuacion del objeto B: {eq2}\nProcedimiento:\nPaso 1: {resol1}\nPaso 2: {resol2}\nPaso 3: {resol3}\nPaso 4: {resol4}") + ''' + coor_x = (-m2 * obj2.position[0] + obj2.position[1] + m1 * obj1.position[0] -obj1.position[1]) / (m1 - m2) + coor_y = m1 * coor_x - obj1.position[0] + obj1.position[1] + return (coor_x, coor_y) + +def main() -> None: + objectA = Object(position = ask_position("A"), speed = ask_speed("A")) + objectB = Object(position = ask_position("B"), speed = ask_speed("B")) + if will_intersect(objectA, objectB): + intersection = calculate_intersection(objectA, objectB) + if (intersection[0] - objectA.position[0]) % objectA.speed[0] == 0: + t1 = (intersection[0] - objectA.position[0]) / objectA.speed[0] + t2 = (intersection[0] - objectB.position[0]) / objectB.speed[0] + if same_position(objectA, objectB): + print(f"Aunque los objetos tengan distinta velocidad comienzan en el mismo punto de partida por lo que colisionarán en el punto {objectA.position} en el instante t = 0.") + else: + if t1 == t2: + print(f"Los objetos colisionarán en el punto {intersection} tras {t1} unidades de tiempo.") + else: + print(f"Aunque ambos objetos pasan por el mismo punto, necesitan distintos tiempos para alcanzar el punto {intersection}, El Objeto A necesita {t1} unidades de tiempo mientras que el Objeto B necesita {t2} unidades.") + else: + print("Los objetos A y B no colisionarán nunca dado que siguiendo sus proyecciones colisionaron en un momento anterior.") + elif same_position(objectA, objectB): + if objectA.speed == objectB.speed: + print("Los objetos A y B tienen tanto la misma direccion como la misma velocidad por lo que colisionaran en todos los puntos por los que pasen.") + else: + print(f"Los objetos A y B parten desde el mismo punto y siguen la misma trayectoria, sin embargo, tienen velocidades distintas por lo que solo tendrán una colisión en {objectA.position} en el intsante t = 0.") + else: + print(f"Los objetos A y B nunca colisionarán al tener la misma pendiente en sus proyecciones y empezar en puntos distintos.") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/KevinED11.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/KevinED11.py" new file mode 100644 index 0000000000..f1a847a7fb --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/KevinED11.py" @@ -0,0 +1,142 @@ +from typing import NamedTuple, Protocol +import math +import functools + + +type Number = 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 + + +class Result(NamedTuple): + time_to_intersection: float + intersection_point: Coordinates + + +def calculate_intersection_point_in_motion(objects: Objects) -> Result: + default_result = Result( + time_to_intersection=0, intersection_point=Coordinates(x=0, y=0) + ) + + 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=diff_velocity): + return default_result + + time_to_intersection: float = calculate_time_to_intersection( + diff_coordinates, diff_velocity + ) + intersection_point: Coordinates = calculate_intersection_point( + objects.object1, time_to_intersection + ) + + return Result( + time_to_intersection=time_to_intersection, intersection_point=intersection_point + ) + + +class MotionCalculatorFn(Protocol): + def __call__(self, objects: Objects) -> Result: + ... + + +def execute(motion_calculator: MotionCalculatorFn, objects: Objects) -> Result: + return motion_calculator(objects=objects) + + +def print_motion_calculator_results(result: Result) -> None: + if result.time_to_intersection == 0: + print("Los objetos o puntos de encuentro son paralelos y nunca se encuentran.") + return + + print( + f"El punto de encuentro es ({result.intersection_point.x}, {result.intersection_point.y})" + ) + print( + f"El tiempo que les tomará encontrarse es {result.time_to_intersection} segundos." + ) + + +def main() -> None: + 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_calculate_intersection_point_in_motion = functools.partial( + execute, motion_calculator=calculate_intersection_point_in_motion + ) + + result1 = execute_calculate_intersection_point_in_motion(objects=objects) + print_motion_calculator_results(result=result1) + + object3 = Object(start_point=Coordinates(x=4, y=3), velocity=Velocity(x=5, y=4)) + object4 = Object(start_point=Coordinates(x=4, y=1), velocity=Velocity(x=3, y=4)) + objects2 = Objects(object1=object3, object2=object4) + + result2 = execute_calculate_intersection_point_in_motion(objects=objects2) + print_motion_calculator_results(result=result2) + + +if __name__ == "__main__": + main() diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/eldalai.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/eldalai.py" new file mode 100644 index 0000000000..4b3267c164 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/eldalai.py" @@ -0,0 +1,102 @@ +import unittest + +# m = (y2 - y1) - (x2 - y1) +# y = m x + b + +def calc_m(x, y, dx, dy): + x1 = x + x2 = x + dx + y1 = y + y2 = y + dy + return (y2 - y1) / (x2 - x1) + +def calc_b(x, y, m): + # y = m x + b + # b = y - m x + return y - (m * x) + +def join(x1, y1, dx1, dy1, x2, y2, dx2, dy2): + m1 = calc_m(x1, y1, dx1, dy1) + m2 = calc_m(x2, y2, dx2, dy2) + if m1 == m2: + raise Exception('Son paralelas') + b1 = calc_b(x1, y1, m1) + b2 = calc_b(x2, y2, m2) + x = (b2 - b1) / (m1 - m2) + y = m1 * x + b1 + return x, y + +class TestPuntoEncuentro(unittest.TestCase): + def test_calc_m(self): + x = 3 + y = 2 + dx = 1 + dy = 2 + m = calc_m(x, y, dx, dy) + self.assertEqual(m, 2.0) + + def test_calc_b(self): + x = 3 + y = 2 + dx = 1 + dy = 2 + m = calc_m(x, y, dx, dy) + b = calc_b(x, y, m) + self.assertEqual(b, -4.0) + + def test_join_ok(self): + x1 = 3 + y1 = 2 + dx1 = 2 + dy1 = 1 + x2 = 4 + y2 = 1 + dx2 = 1 + dy2 = 2 + resultx, resulty = join(x1, y1, dx1, dy1, x2, y2, dx2, dy2) + self.assertEqual(resultx, 5.0) + self.assertEqual(resulty, 3.0) + + def test_join(self): + x1 = 3 + y1 = 7 + dx1 = 1 + dy1 = -1 + x2 = 4 + y2 = 1 + dx2 = 1 + dy2 = 1 + resultx, resulty = join(x1, y1, dx1, dy1, x2, y2, dx2, dy2) + self.assertEqual(resultx, 6.5) + self.assertEqual(resulty, 3.5) + + def test_join_error(self): + x1 = 1 + y1 = 1 + dx1 = 1 + dy1 = 1 + x2 = 4 + y2 = 1 + dx2 = 1 + dy2 = 1 + with self.assertRaises(Exception): + join(x1, y1, dx1, dy1, x2, y2, dx2, dy2) + +def main(): + x1 = int(input("Coordenada x1: ")) + y1 = int(input("Coordenada y1: ")) + dx1 = int(input("Incremento x1: ")) + dy1 = int(input("Incremento y1: ")) + x2 = int(input("Coordenada x2: ")) + y2 = int(input("Coordenada y2: ")) + dx2 = int(input("Incremento x2: ")) + dy2 = int(input("Incremento y2: ")) + try: + resultx, resulty = join(x1, y1, dx1, dy1, x2, y2, dx2, dy2) + print(f"las rectas se unen en {resultx}, {resulty}") + except Exception as e: + print(str(e)) + + +if __name__ == '__main__': + main() diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/gladoncio.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/gladoncio.py" new file mode 100644 index 0000000000..23316f6b9c --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/gladoncio.py" @@ -0,0 +1,37 @@ +def validate(objeto_1, objeto_2): + x1, y1, vx1, vx2 = objeto_1 + x2, y2, vy1, vy2 = objeto_2 + + dx = x2 - x1 + dy = y2 - y1 + dvx = vx2 - vx1 + dvy = vy2 - vy1 + + if dvx == 0 and dvy == 0: + return "Los objetos son paralelos y nunca se cruzan." + + #calculamos el producto escalar (nos dice si el objeto se aleja y a que ritmo lo hacen) + pd = (-dx * dvx - dy * dvy) + #Calculamos la velocidad relativa + vr = (dvx ** 2 + dvy**2 ) + + t = pd/vr + + if t < 0: + return "Los objetos jamas se tocan" + + x_encuentro = x1 + vx1 * t + y_encuentro = y1 + vy1 * t + + return [x_encuentro, y_encuentro, t] + +objeto_1 = [0, 0, 5, 1] +objeto_2 = [3, 1, 2, 2] + +resultado = validate(objeto_1, objeto_2) + +if isinstance(resultado, str): + print(resultado) +else: + print(f"Los objetos se encuentran en ({resultado[0]}, {resultado[1]}) después de {resultado[2]} unidades de tiempo.") + diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/icedrek.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/icedrek.py" new file mode 100644 index 0000000000..1f2fc54458 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/icedrek.py" @@ -0,0 +1,67 @@ +""" + * 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. + """ + + +class Object: + def __init__(self, position, move_vector) -> None: + self.initial_position = position + self.move_vector = move_vector + + def position_in_time(self, t): + movement = [(t * _) for _ in self.move_vector] + return [(v1 + v2) for v1, v2 in zip(self.initial_position, movement)] + + +def calculate_colision(ob1: Object, ob2: Object): + (x1, y1) = ob1.initial_position + (xv1, yv1) = ob1.move_vector + + (x2, y2) = ob2.initial_position + (xv2, yv2) = ob2.move_vector + + tx = division(x1 - x2, xv2 - xv1) + ty = division(y1 - y2, yv2 - yv1) + + colision = None + t = None + + if tx == ty: + t = tx + colision = ob1.position_in_time(t) + elif tx == None and ty != None: + if ob1.position_in_time(ty) == ob2.position_in_time(ty): + t = ty + colision = ob1.position_in_time(t) + elif tx != None and ty == None: + if ob1.position_in_time(tx) == ob2.position_in_time(tx): + t = tx + colision = ob1.position_in_time(t) + + if colision == None: + print("NO HAY COLISION") + else: + print(f"Colision en t={t} en posicion {colision}") + + +def division(x, y): + try: + result = x / y + + except ZeroDivisionError: + result = None + + return result + + +if __name__ == "__main__": + ob1 = Object((0, 0), (1, 1)) # posicion_inicial, vector_de_movimiento + ob2 = Object((0, 3), (1, -1)) + + calculate_colision(ob1, ob2) diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/jcdm60.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/jcdm60.py" new file mode 100644 index 0000000000..34d237711f --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/jcdm60.py" @@ -0,0 +1,65 @@ +# Reto #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. +# + + +class MovingObject: + def __init__(self, x, y, vx, vy): + self.x = x + self.y = y + self.vx = vx + self.vy = vy + + def position_at_time(self, t): + new_x = self.x + self.vx * t + new_y = self.y + self.vy * t + return new_x, new_y + + @staticmethod + def find_intersection(obj1, obj2): + x1, y1, vx1, vy1 = obj1.x, obj1.y, obj1.vx, obj1.vy + x2, y2, vx2, vy2 = obj2.x, obj2.y, obj2.vx, obj2.vy + + delta_x = x2 - x1 + delta_y = y2 - y1 + delta_vx = vx2 - vx1 + delta_vy = vy2 - vy1 + + if delta_vx * vy1 == delta_vy * vx1: + return None # Los objetos viajan en la misma dirección o a la misma velocidad, no se cruzan + + t = (delta_x * delta_vy - delta_y * delta_vx) / ( + vx1 * delta_vy - vy1 * delta_vx + ) + + if t < 0: + return None + + x_intersection, y_intersection = obj1.position_at_time(t) + + return x_intersection, y_intersection, t + + +if __name__ == "__main__": + object1 = MovingObject(0, 0, 2, 1) + object2 = MovingObject(4, 2, 1, 1) + result = MovingObject.find_intersection(object1, object2) + + if result is not None: + x_intersection, y_intersection, time = result + print( + f"Los objetos se encuentran en ({x_intersection}, {y_intersection}) después de {time} unidades de tiempo." + ) + else: + print("Los objetos no se encuentran.") diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/juanppdev.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/juanppdev.py" new file mode 100644 index 0000000000..e0a273005c --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/juanppdev.py" @@ -0,0 +1,30 @@ +def punto_encuentro(coord_objeto1, velocidad_objeto1, coord_objeto2, velocidad_objeto2): + # Calcula las diferencias entre las coordenadas iniciales de los objetos. + diff_x = coord_objeto2[0] - coord_objeto1[0] + diff_y = coord_objeto2[1] - coord_objeto1[1] + + # Calcula la diferencia de velocidad entre los dos objetos. + diff_vel_x = velocidad_objeto2[0] - velocidad_objeto1[0] + diff_vel_y = velocidad_objeto2[1] - velocidad_objeto1[1] + + # Comprueba si los objetos son paralelos (no se encuentran). + if diff_vel_x == 0 and diff_vel_y == 0: + return "Los objetos no se encuentran." + + # Calcula el tiempo en el que se encontrarán. + tiempo_encuentro = (diff_x / diff_vel_x) if diff_vel_x != 0 else (diff_y / diff_vel_y) + + # Calcula las coordenadas del punto de encuentro. + punto_x = coord_objeto1[0] + velocidad_objeto1[0] * tiempo_encuentro + punto_y = coord_objeto1[1] + velocidad_objeto1[1] * tiempo_encuentro + + return f"Los objetos se encuentran en ({punto_x}, {punto_y}) en {tiempo_encuentro} unidades de tiempo." + +# Ejemplo de uso: +coord_objeto1 = (0, 0) +velocidad_objeto1 = (1, 2) +coord_objeto2 = (3, 1) +velocidad_objeto2 = (1, 1) + +resultado = punto_encuentro(coord_objeto1, velocidad_objeto1, coord_objeto2, velocidad_objeto2) +print(resultado) diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/keltoi-dev.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/keltoi-dev.py" new file mode 100644 index 0000000000..818618f511 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/keltoi-dev.py" @@ -0,0 +1,65 @@ +"""/* + * 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. + */""" + +import random + +def funciones_lineales(x1, y1, veloc1, x2, y2, veloc2): + + # m1*x1 + n1*y1 = result1 + # m2*x2 + n2*y2 = result2 + # Se estipulan en forma aleatorias las pendientes de las rectas de accion + m1 = random.randint(-10,10) + n1 = random.randint(-10,10) + m2 = random.randint(-10,10) + n2 = random.randint(-10,10) + + # Obtencion de los datos faltantes para aplicar la regla de Cramer (determinantes) + result1 = (m1 * x1) + (n1 * y1) + result2 = (m2 * x2) + (n2 * y2) + + determinante = (m1 * n2) - (n1 * m2) + if determinante == 0: + print("Las rectas son paralelas, no se seguir calculando.") + exit() + else: + # Calculo coordenadas de cruce + x_intersect = (((result1 * n2) - (n1 * result2)) / determinante) + x_intersect = round(x_intersect, 2) + y_intersect = (((m1 * result2) - (result1 * m2)) / determinante) + y_intersect = round(y_intersect, 2) + + # Calculo de distancias desde origen a punto de cruce con el Teorema de Pitagoras + dist1 = (((x_intersect - x1) ** 2) + ((y_intersect - y1) ** 2)) ** .5 + dist1 = round(dist1, 2) + dist2 = (((x_intersect - x2) ** 2) + ((y_intersect - y2) ** 2)) ** .5 + dist2 = round(dist2, 2) + + # Calculo de tiempo hasta el cruce + tiempo1 = round((dist1 / veloc1), 2) + tiempo2 = round((dist2 / veloc2), 2) + + print("\nLOS RESULTADOS SON:") + print(f"Ambas rectas se cruzan en el punto ({x_intersect}, {y_intersect})") + print(f"La distancia recorrida por el primer vector es {dist1} y le tomo {tiempo1} de tiempo." ) + print(f"La distancia recorrida por el segundo vector es {dist2} y le tomo {tiempo2} de tiempo." ) + +x1 = int(input("Ingrese la coordenada en x del primer punto: ")) +y1 = int(input("Ingrese la coordenada en y del primer punto: ")) +veloc1 = int(input("Ingrese la velocidad del primer punto: ")) +print("\n") +x2 = int(input("Ingrese la coordenada en x del segundo punto: ")) +y2 = int(input("Ingrese la coordenada en y del segundo punto: ")) +veloc2 = int(input("Ingrese la velocidad del segundo punto: ")) + +if x1 != x2 and y1 != y2: + funciones_lineales(x1, y1, veloc1, x2, y2, veloc2) +else: + print("Ambas coordenadas son identicas. Se cruzan antes de iniciar el movimiento.") + \ No newline at end of file diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/klyone.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/klyone.py" new file mode 100644 index 0000000000..0c32290656 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/klyone.py" @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 + +class World: + def __init__(self, max_x, max_y, max_time): + self.max_x = max_x + self.max_y = max_y + self.max_time = max_time + self.particles = [] + self.meeting_point = None + + def reset(self): + self.particles = [] + self.meeting_point = None + + def attach_particle(self, p): + self.particles.append(p) + + def check_particles_pos_limits(self): + ok = True + for p in self.particles: + pos = p.get_pos() + + if pos[0] > self.max_x or pos[1] > self.max_y: + ok = False + break + return ok + + def check_particles_meeting_point(self): + found = True + + point = self.particles[0].get_pos() + + for p in self.particles: + if point != p.get_pos(): + found = False + break + + return found + + def update_particles(self): + for p in self.particles: + p.update() + + def run(self): + self.meeting_points = None + + if len(self.particles) <= 1: + return + + if not self.check_particles_pos_limits(): + return + + if self.check_particles_meeting_point(): + self.meeting_point = [0, self.particles[0].get_pos()] + return + + for t in range(1, self.max_time): + self.update_particles() + + if not self.check_particles_pos_limits(): + break + + if self.check_particles_meeting_point(): + self.meeting_point = [t, self.particles[0].get_pos()] + break + + def get_meeting_point(self): + return self.meeting_point + +class Particle: + def __init__(self, pos, speed): + self.pos = pos + self.speed = speed + def update_pos(self, t): + self.pos[0] += self.speed[0] * t + self.pos[1] += self.speed[1] * t + def update(self): + self.update_pos(1) + def get_pos(self): + return self.pos + +if __name__ == "__main__": + p1 = Particle([0,0], [1,1]) + p2 = Particle([0,10], [1,0]) + w = World(100,100,100) + w.attach_particle(p1) + w.attach_particle(p2) + w.run() + print(w.get_meeting_point()) + + p1 = Particle([0,0], [1,2]) + p2 = Particle([0,0], [-1,-1]) + w.reset() + w.attach_particle(p1) + w.attach_particle(p2) + w.run() + print(w.get_meeting_point()) + + p1 = Particle([0,0], [1,2]) + p2 = Particle([10,0], [10,22]) + w.reset() + w.attach_particle(p1) + w.attach_particle(p2) + w.run() + print(w.get_meeting_point()) diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/qf-jonathan.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/qf-jonathan.py" new file mode 100644 index 0000000000..44b5387877 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/qf-jonathan.py" @@ -0,0 +1,119 @@ +import unittest + + +class Object: + def __init__(self, init_pos: tuple[float, float], move_vec: tuple[float, float]) -> None: + self.init_pos = init_pos + self.move_vec = move_vec + + def pos_at_time(self, time: float) -> tuple[float, float]: + return (pos + vec * time for pos, vec in zip(self.init_pos, self.move_vec)) + + def __str__(self) -> str: + return f"Object(position{self.init_pos}, vector{self.move_vec})" + + +def meeting_point( + obj_a: Object, obj_b: Object, epsilon: float = 1e-7 +) -> tuple[tuple[float, float], float]: + (ax, ay), (vax, vay) = obj_a.init_pos, obj_a.move_vec + (bx, by), (vbx, vby) = obj_b.init_pos, obj_b.move_vec + (dx, dy), (dvx, dvy) = (bx - ax, by - ay), (vax - vbx, vay - vby) + + if abs(dvx) > epsilon and (tx := dx / dvx) >= 0: + x, y = obj_a.pos_at_time(tx) + _, yb = obj_b.pos_at_time(tx) + if abs(y - yb) < epsilon: + return (x, y), tx + + if abs(dvy) > epsilon and (ty := dy / dvy) >= 0: + x, y = obj_a.pos_at_time(ty) + xb, _ = obj_b.pos_at_time(ty) + if abs(x - xb) < epsilon: + return (x, y), ty + + return (None, None), float("inf") + + +class TestMeetingPoint(unittest.TestCase): + def assertMeetAt( + self, + result: tuple[tuple[float, float], float], + expected: tuple[tuple[float, float], float], + msg: str, + ): + (x, y), time = result + (expected_x, expected_y), expected_time = expected + self.assertAlmostEqual(x, expected_x, msg=msg) + self.assertAlmostEqual(y, expected_y, msg=msg) + self.assertAlmostEqual(time, expected_time, msg=msg) + + def assertNotMeet(self, result: tuple[tuple[float, float], float], msg: str): + (x, y), time = result + self.assertIsNone(x, msg=msg) + self.assertIsNone(y, msg=msg) + self.assertEqual(time, float("inf"), msg=msg) + + def test_objects_meet(self): + cases = { + (((0, 0), (2, 2)), ((1, 1), (-2, -2))): ((0.5, 0.5), 0.25), + (((0, 0), (1, 1)), ((5, 0), (-1, 1))): ((2.5, 2.5), 2.5), + (((0, 0), (1, 1)), ((0, 5), (1, -1))): ((2.5, 2.5), 2.5), + (((2.001, 1.001), (1, 1)), ((2.001, 1.001), (-1, -1))): ((2.001, 1.001), 0), + (((0, 0), (1.01, 1.01)), ((1, 1), (1, 1))): ((101, 101), 100), + (((5, 5), (0.0001, -10000)), ((6, 5), (-0.0001, -10000))): ((5.5, -49999995), 5000), + (((5, 5), (1, 1)), ((9, 1), (0, 2))): ((9, 9), 4), + (((46101.5, -57159.4), (-456, 567)), ((-23487.5, -44635.4), (233, 443))): ( + (45.5, 107.6), + 101, + ), + (((750.26, 689.29), (-12.5, -11.6)), ((-3661.99, 1932.49), (67, -34))): ( + (56.51, 45.49), + 55.5, + ), + (((-1921509, -1343381), (334, 233)), ((-645897, -1912235), (112, 332))): ( + (-2345, -4563), + 5746, + ), + (((123, 726), (6, 9)), ((100023, 667547), (-4, -57.74884884885))): ( + (60063, 90636), + 9990, + ), + (((-1000000, 1000000), (100, -1)), ((1000000, -1000000), (-1, 100))): ( + (980198.019802, 980198.019802), + 19801.980198, + ), + (((794816856, -262218141), (1, 2)), ((216304461, -455055606), (4, 3))): ( + (987654321, 123456789), + 192837465, + ), + (((-0.01825, 0.198), (0.05, 0.08)), ((-0.04975, 0.0315), (0.12, 0.45))): ( + (0.00425, 0.234), + 0.45, + ), + } + + for (obj_a_params, obj_b_params), expected in cases.items(): + obj_a = Object(*obj_a_params) + obj_b = Object(*obj_b_params) + result = meeting_point(obj_a, obj_b) + self.assertMeetAt(result, expected, msg=f"{obj_a} does not meet {obj_b} at {result}") + + def test_object_not_meet(self): + cases = [ + (((0, 0), (1, 1)), ((5, 5), (1, 1))), + (((0, 0), (0.99, 0.99)), ((1, 1), (1, 1))), + (((0, 1), (0, 1)), ((0, 0), (0, -1))), + (((123, 726), (6, 9)), ((100023, 667547), (-4, -57.75))), + (((1, 2), (3, 4)), ((5, 6), (7, 8))), + ] + + for obj_a_params, obj_b_params in cases: + obj_a = Object(*obj_a_params) + obj_b = Object(*obj_b_params) + result = meeting_point(obj_a, obj_b) + self.assertNotMeet(result, msg=f"{obj_a} should not not meet {obj_b}") + + +if __name__ == "__main__": + unittest.main() diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/santi55.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/santi55.py" new file mode 100644 index 0000000000..8fb934a10b --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/santi55.py" @@ -0,0 +1,48 @@ +""" + +/* + * 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. + */ + + """ + + +class Vehiculo: + # Constructor + def __init__(self, x, y, vx, vy): + self.x = x + self.y = y + self.vx = vx + self.vy = vy + + # Métodos + def mover(self): + self.x += self.vx + self.y += self.vy + + +def puntoEncuentro(vehiculo1 : Vehiculo, vehiculo2 : Vehiculo) -> str: + tiempo = 0 ##se entrará en un bucle y en cada iteración se aumentará 1 + + while(vehiculo1.x != vehiculo2.x or vehiculo1.y != vehiculo2.y) and tiempo != 100: + vehiculo1.mover() + vehiculo2.mover() + tiempo += 1 + + + if(vehiculo1.x == vehiculo2.x and vehiculo1.y == vehiculo2.y): + return f"Se encuentran en {vehiculo1.x,vehiculo1.y} en {tiempo} unidades de tiempo" + else: + return "No se han encontrado" + + +veh1 = Vehiculo(1,4,1,0) +veh2 = Vehiculo(4,0,0,1) + +print(puntoEncuentro(veh1,veh2)) \ No newline at end of file diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/sirnas1983.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/sirnas1983.py" new file mode 100644 index 0000000000..26c42fe283 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/sirnas1983.py" @@ -0,0 +1,108 @@ +import math +from matplotlib import pyplot as plt +import numpy + +def detectar_colision(coor1, coor2, vel1, vel2, plot_graph=False): + ''' + Determina si dos objetos colisionarán en el plano y muestra un gráfico si se especifica. + + Parámetros: + coor1 (tuple): Coordenadas iniciales del objeto 1 (x1, y1). + coor2 (tuple): Coordenadas iniciales del objeto 2 (x2, y2). + vel1 (tuple): Velocidades del objeto 1 en (vx1, vy1). + vel2 (tuple): Velocidades del objeto 2 en (vx2, vy2). + plot_graph (bool, opcional): True si se debe mostrar un gráfico, False por defecto. + + Retorna: + bool: True si los objetos colisionan, False si no. + ''' + colision = False + try: + # Asigno el valor de las tuplas a variables individuales + vx1, vy1 = vel1 + vx2, vy2 = vel2 + + x1, y1 = coor1 + x2, y2 = coor2 + + # Verifico la condición de que no parten del mismo punto + if (x1 == x2) and (y1 == y2): + print("Ambos objetos están colisionados antes de iniciar su movimiento.") + x = x1 + y = y1 + alpha = 0 + colision = True + else: + # Verifico que ambas trayectorias no sean coplanares + if (vx1 * vy2 - vy1 * vx2) != 0: + # Calculo alpha y beta de sus ecuaciones vectoriales + beta = (vx1 * (y1 - y2) + vy1 * (x2 - x1)) / (vx1 * vy2 - vy1 * vx2) + if vy1 != 0: + alpha = (y2 - y1 + beta * vy2) / vy1 + elif vx1 != 0: + alpha = (x2 - x1 + beta * vx2) / vx1 + + x = x2 + beta * vx2 + y = y2 + beta * vy2 + + # Si alpha y beta son iguales (tiempo) hay colisión, sino solamente intersección de trayectorias + if alpha == beta and alpha > 0: + print(f"Los objetos colisionan en ({x:.2f}, {y:.2f}) transcurridos {alpha:.2f} segundos.") + colision = True + else: + print(f"Si bien las trayectorias se intersectan en ({x:.2f}, {y:.2f}), no hay colisión entre objetos.") + else: + # Hago el análisis puntual de trayectorias coplanares + vect1 = complex(vx1, vy1) + vect12 = complex(x2-x1, y2-y1) + vect21 = complex(x1-x2, y1-y2) + + ang_vect1 = numpy.angle(vect1) + ang_vect12 = numpy.angle(vect12) + ang_vect21 = numpy.angle(vect21) + + # Determino la colinealidad mediante compara el vector entre P1 y P2 y una de las velocidades + if ang_vect1 == ang_vect12 or ang_vect1 == ang_vect21: + alpha = -math.inf + beta = -math.inf + # Para ello calculo la constante del vector + if vx1 - vx2 != 0: + alpha = (x2 - x1) / (vx1 - vx2) + if vy1 - vy2 != 0: + beta = (y2 - y1) / (vy1 - vy2) + # Si la velocidad en ambos ejes son igualesquiere decir que van a la misma velocidad + if alpha == -math.inf and beta == -math.inf: + print("Los objetos van a la misma velocidad, no habrá colisión.") + elif (alpha == -math.inf and beta > 0) or (beta == -math.inf and alpha > 0) or (beta == alpha > 0): + if alpha <= 0: + alpha = beta + x = x1 + alpha * vx1 + y = y1 + alpha * vy1 + print(f"Los objetos colisionan en ({x:.2f}, {y:.2f}) transcurridos {alpha:.2f} segundos.") + colision = True + else: + print("Los objetos son colineales pero van separándose, no habrá colisión.") + + else: + print("Las trayectorias son paralelas, no habrá colisión.") + + if colision and plot_graph: + plt.axhline(0, color='black', linewidth=0.65) + plt.axvline(0, color='black', linewidth=0.65) + plt.scatter(x, y, color='red', linewidths=10, label=f'COLISIÓN\nx: {x:.2f} - y: {y:.2f} - t: {alpha:.2f}') + plt.scatter(x1, y1, color='blue', linewidths=5, label=f'Salida objeto 1\nVx: {vx1} Vy: {vy1}') + plt.scatter(x2, y2, color='green', linewidths=5, label=f'Salida objeto 2\nVx: {vx2} Vy: {vy2}') + plt.plot([x1, x], [y1, y], color='blue', ls="-.") + plt.plot([x2, x], [y2, y], color='green', ls="-.") + plt.legend() + plt.xlabel('Eje X') + plt.ylabel('Eje Y') + plt.title('Punto de Colisión') + plt.grid(True) + plt.show() + + return colision + + except Exception as e: + print(f"Error: {e}") + return colision diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/valevil27.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/valevil27.py" new file mode 100644 index 0000000000..150ad6ac9d --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/valevil27.py" @@ -0,0 +1,71 @@ +def collision( + r: tuple[float, float], + s: tuple[float, float], + vr: tuple[float, float], + vs: tuple[float, float], +): + '''The function `collision` calculates the collision point and time between two moving objects, given + their initial positions and velocities, and prints them to the user. + + Parameters + ---------- + The parameters `r` and `s` represent the initial position of objects R and S, given as a tuple of two floats (x,y). + + The parameters `vr` and `vs` represent the velocity of objects R and A, where `vr[0]` is the velocity in the x-direction and `vr[1]` is the velocity in the y-direction. + ''' + + try: # What if some coord velocities are equal or none + t_0 = (s[0] - r[0]) / (vr[0] - vs[0]) + if t_0 < 0: # If they would collide in the past then we don't care + print(f"Objects won't collide.") + return + except: + if s[0] != r[0]: # distance between them will be constant in time + print(f"Objects won't collide.") + return + t_0 = "any" # If they are in the same coord time doesn't matter + + try: + t_1 = (s[1] - r[1]) / (vr[1] - vs[1]) + if t_1 < 0: + print(f"Objects won't collide.") + return + except: + if s[1] != r[1]: + print(f"Objects won't collide.") + return + else: t_1 = t_0 + + if t_0 == t_1 or t_0 == "any": + if (t := t_1) == "any": # This would mean they both have the same IC + print("The objects share their movement.") + return + c = (s[0] + vs[0] * t, s[1] + vs[1] * t) + print(f"Collision at x = {c[0]}, y = {c[1]} at t = {t}.") + else: + print(f"Objects won't collide.") + + +def get_input(var: str): + while True: + try: + x = float(input(f"\t- {var}: ").strip()) + return x + except ValueError as e: + print(f"Please, enter a number.") + + +def get_coord(): + x = get_input("x") + y = get_input("y") + vx = get_input("vx") + vy = get_input("vy") + return (x, y), (vx, vy) + + +if __name__ == "__main__": + print("Write the initial conditions of the first object.") + r, vr = get_coord() + print("Write the initial conditions of the second object.") + s, vs = get_coord() + collision(r, s, vr, vs) diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/vandresca.py" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/vandresca.py" new file mode 100644 index 0000000000..4f2deddfda --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/python/vandresca.py" @@ -0,0 +1,75 @@ +""" +/* + * 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. + */ +""" + + +import numpy as np +import copy + +class Point: + x = None + y = None + + # Métodos de la clase + def __init__(self, x, y): + self.x = y + self.y = x + + +def printTable(): + for row in range(SIDE_TABLE): + print() + for col in range(SIDE_TABLE): + print(str(table[row, col])+" ", end="") + +def setValues(point1, point2): + table[point1.x][point1.y] = "(x)" + table[point2.x][point2.y] = "(x)" + +def isOutTable(point1, point2): + limit = SIDE_TABLE - 1 + if (point1.x > limit or point2.x > limit + or point1.y > limit or point2.y > limit + or point1.x == -1 or point2.x == -1 + or point1.y == -1 or point2.y == -1): + return True + return False + + +point1 = Point(5, 5) +point2 = Point(9, 1) + +vectorSpeed1 = Point(1, 1) +vectorSpeed2 = Point(0, 2) + +SIDE_TABLE = 15 +modelTable = np.array([[" o "]*SIDE_TABLE]* SIDE_TABLE) +table = copy.copy(modelTable) +setValues(point1, point2) +while(True): + print() + print() + printTable() + table = copy.copy(modelTable) + if(point1.x == point2.x and point1.y == point2.y): + print(f"Los dos puntos se encuentran en ({point1.x}, {point1.y})") + break + else: + print("Los dos puntos no se encuentran") + point1.x += vectorSpeed1.x + point1.y += vectorSpeed1.y + point2.x += vectorSpeed2.x + point2.y += vectorSpeed2.y + if isOutTable(point1, point2): + break + setValues(point1, point2) + + diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/rust/hdescobarh.rs" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/rust/hdescobarh.rs" new file mode 100644 index 0000000000..46b6d86b40 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/rust/hdescobarh.rs" @@ -0,0 +1,357 @@ +// author: Hans D. Escobar H. (hdescobarh) + +//! La lógica de la solución es la siguiente. Sí los dos objetos se encuentran, necesariamente +//! existe un tiempo 𝘵 ≥ 0 tal que la distancia euclídea entre las posiciones de los dos objetos es cero. +//! Primero calcula ese tiempo 𝘵, y luego lo usa como parámetro para obtener la posición. +//! +//! # Ejemplo: +//! ``` +//! use punto_de_encuentro::*; +//! let object_1 = Object2D::new(&[6.0, 7.0], &[-1.8, -0.6]); +//! let object_2 = Object2D::new(&[2.0, 2.0], &[-1.0, 0.4]); +//! let (collision_point, collision_time) = object_1.ulm_collision(&object_2).unwrap(); +//! assert!((collision_time - 5.0).abs() < TOLERANCE); +//! assert!((collision_point.x - -3.0).abs() < TOLERANCE); +//! assert!((collision_point.y - 4.0).abs() < TOLERANCE); +//! ``` + +#![crate_name = "punto_de_encuentro"] +#![crate_type = "cdylib"] +use std::ops::{Add, Mul, Sub}; + +/// Parámetro introducido para controlar el impacto de errores de redondeo en valores cercanos al cero [^note]. +/// +/// [^note]: Para mis información: [Catastrophic cancellation](https://en.wikipedia.org/wiki/Catastrophic_cancellation). +pub const TOLERANCE: f64 = 1E-10_f64; + +/// Representa una entidad arbitraria en un espacio vectorial ℝ². +pub struct Object2D { + /// Vector posición 𝗽. + location: Vector2D, + /// Vector velocidad 𝐯. Es decir, desplazamiento (𝗽(𝘵+𝑖) - 𝗽(𝘵)) por unidad de tiempo 𝑖. + velocity: Vector2D, +} + +impl Object2D { + /// Retorna una entidad en un espacio vectorial ℝ². + /// + /// # Argumentos: + /// + /// * `location` - La posición actual del objeto (x,y). + /// * `velocity` - La velocidad (x,y) con la que se mueve el objeto. + pub fn new(location: &[f64; 2], velocity: &[f64; 2]) -> Self { + Self { + location: Vector2D::from(location), + velocity: Vector2D::from(velocity), + } + } +} + +impl UniformLinearMotion for Object2D { + /// Retorna el tiempo dentro del cual el objeto va a colisionar con otro objeto. + /// Retorna None sí nunca se encuentran. + /// + /// # Argumentos: + /// + /// * `other` - El segundo objeto con el que se evaluara la colisión. + /// + /// # Ejemplo: + /// + /// ``` + /// use punto_de_encuentro::*; + /// let object_1 = Object2D::new(&[6.0, 7.0], &[-1.8, -0.6]); + /// let object_2 = Object2D::new(&[2.0, 2.0], &[-1.0, 0.4]); + /// let time: f64 = object_1.ulm_collision_time(&object_2).unwrap(); + /// assert!((5.0-time).abs() < TOLERANCE); + /// ``` + /// + /// # Explicación de la física: + /// + /// Sí los dos objetos se encuentran, necesariamente existe un tiempo 𝘵, + /// tal que la distancia euclídea 𝓓(a,b) = ‖a-b‖ entre las posiciones 𝗽 y 𝗽' + /// del primer y segundo objeto, respectivamente, es cero; es decir: + /// + /// * (1) ∃𝘵‖𝗽(𝘵)-𝗽'(𝘵)‖ = ‖Δ𝗽(𝘵)‖ = 0 + /// + /// En movimiento linear uniforme, la velocidad 𝐯 es constante para todo tiempo 𝘵; por lo tanto: + /// * (2) 𝗽(𝘵) = 𝗽₀ + 𝘵𝐯 + /// + /// Por (1) y (2), y por propiedades del producto punto ⟨·,·⟩: + /// * (3) ⟨Δ𝗽(𝘵), Δ𝗽(𝘵)⟩ = 𝘵² ⟨Δ𝐯,Δ𝐯⟩ + 𝘵 2⟨Δ𝐯,Δ𝗽₀⟩ + ⟨Δ𝗽₀,Δ𝗽₀⟩ = 0 + /// + fn ulm_collision_time(&self, other: &Self) -> Option { + // obtenemos Δ𝗽₀ y Δ𝐯 + let delta_initial_position: Vector2D = self.location - other.location; + let delta_velocity: Vector2D = self.velocity - other.velocity; + // Es un polinomio de la forma ax² + bx + c, donde a=⟨Δ𝐯,Δ𝐯⟩, b=2⟨Δ𝐯,Δ𝗽₀⟩, c=⟨Δ𝗽₀,Δ𝗽₀⟩ + let a: f64 = delta_velocity * delta_velocity; + let b: f64 = delta_velocity * delta_initial_position * 2.0; + let c: f64 = delta_initial_position * delta_initial_position; + // sí ambos objetos llevan la misma velocidad, a=0 y b=0. El problema es lineal 0x + c = 0 + if a.abs() < TOLERANCE { + // sí parten de la misma posición, c=0. Hay infinitas soluciones: ∀x(0x = 0) + if c.abs() < TOLERANCE { + return Some(0.0); + // sí por el contrario, c≠0. No hay solución: ∄x(0x = c) + } else { + return None; + } + } + // Cuando a≠0 es un problema cuadrático y aplicamos + // la formula cuadrática: ( -b +- sqrt(b² - 4 ac) ) / (2a), + + let mut discriminant = (b * b) - (4.0 * a * c); + // Sí v satisface que -TOLERANCE < v < TOLERANCE, entonces es un cero efectivo + if discriminant.abs() < TOLERANCE { + discriminant = 0.0; + } + // sí tiene solución en los reales, necesariamente b² - 4ac ≧ 0 + if discriminant < 0.0_f64 { + return None; + } + let sqrt_discriminant = discriminant.sqrt(); + let solution_1 = (-b - sqrt_discriminant) / (2.0 * a); + let solution_2 = (-b + sqrt_discriminant) / (2.0 * a); + // es movimiento rectilíneo uniforme en un espacio euclídeo; por lo tanto, + // a lo sumo existe solo una solución valida (t>=0) + if solution_1 >= 0.0_f64 { + Some(solution_1) + } else if solution_2 > 0.0_f64 { + Some(solution_2) + } else { + None + } + } + + /// Calcula la posición del objeto tomando como punto de partida (𝗽₀ = 𝗽(0)) la + /// ubicación actual del objeto (location). 𝗽(𝘵) = 𝗽₀ + 𝘵𝐯 + /// + /// # Argumentos: + /// + /// * `time` - tiempo 𝘵 transcurrido. + /// + /// # Ejemplo: + /// + /// ``` + /// use punto_de_encuentro::*; + /// let object_1 = Object2D::new(&[11.0, 17.0], &[1.64383561643, 3.69863013698]); + /// let position: Vector2D = object_1.ulm_position_delta_time(&7.3); + /// assert!((position.x - 23.0).abs() < TOLERANCE + /// && (position.y - 44.0).abs() < TOLERANCE); + /// ``` + fn ulm_position_delta_time(&self, time: &f64) -> Vector2D { + // 𝗽(𝘵) = 𝗽₀ + 𝘵𝐯 + let delta_position: Vector2D = self.location + (self.velocity * *time); + delta_position + } +} + +pub trait UniformLinearMotion { + fn ulm_collision_time(&self, other: &Self) -> Option; + fn ulm_position_delta_time(&self, time: &f64) -> T; + fn ulm_collision(&self, other: &Self) -> Option<(T, f64)> { + self.ulm_collision_time(other) + .map(|time| (self.ulm_position_delta_time(&time), time)) + } +} + +/// Representa un elemento de un espacio vectorial en ℝ² en coordenadas cartesianas. +/// Tiene definidas las operaciones de suma y resta vectorial, producto punto, y producto escalar. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Vector2D { + pub x: f64, + pub y: f64, +} + +/// Construye un Vector desde un Array [f64; 2] +impl From<&[f64; 2]> for Vector2D { + fn from(value: &[f64; 2]) -> Self { + Self { + x: value[0], + y: value[1], + } + } +} + +/// Producto punto con otro vector. self * other = ⟨self,other⟩ +impl Mul for Vector2D { + type Output = f64; + fn mul(self, rhs: Vector2D) -> Self::Output { + (self.x * rhs.x) + (self.y * rhs.y) + } +} + +/// Producto escalar. self * scalar +impl Mul for Vector2D { + type Output = Vector2D; + fn mul(self, rhs: f64) -> Self::Output { + Self { + x: self.x * rhs, + y: self.y * rhs, + } + } +} + +/// Diferencia con otro vector. self - other +impl Sub for Vector2D { + type Output = Vector2D; + + fn sub(self, rhs: Self) -> Self::Output { + Vector2D { + x: self.x - rhs.x, + y: self.y - rhs.y, + } + } +} + +/// Suma vectorial. self + other +impl Add for Vector2D { + type Output = Vector2D; + + fn add(self, rhs: Self) -> Self::Output { + Vector2D { + x: self.x + rhs.x, + y: self.y + rhs.y, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn ulm_collision_time_by_axis() { + let test_cases = [ + // same origin and velocity + ( + [[9.0, 0.0], [60.0, 0.0], [9.0, 0.0], [60.0, 0.0]], + Some(0.0), + ), + // same origin, different velocity + ( + [[15.8, 0.0], [80.3, 0.0], [15.8, 0.0], [-50.0, 0.0]], + Some(0.0), + ), // different origin, same velocity + ([[17.0, 0.0], [123.5, 0.0], [1.8, 0.0], [123.5, 0.0]], None), + // from here, different origin and velocity + ([[98.0, 0.0], [30.0, 0.0], [15.0, 0.0], [-42.0, 0.0]], None), + ([[0.0, 0.0], [0.5, 0.0], [6.0, 0.0], [0.0, 0.0]], Some(12.0)), + ( + [[-2.5, 0.0], [2.406, 0.0], [4.5, 0.0], [2.1, 0.0]], + Some(22.8758169934), + ), + ( + [[12.0, 0.0], [2.7, 0.0], [179.0, 0.0], [-3.1, 0.0]], + Some(28.7931031275), + ), + ( + [[-10.0, 0.0], [34.0, 0.0], [200.0, 0.0], [-36.0, 0.0]], + Some(3.0), + ), + ]; + + // check axis X + for ([loc1, vel1, loc2, vel2], expected) in &test_cases { + let object_1 = Object2D::new(loc1, vel1); + let object_2 = Object2D::new(loc2, vel2); + let solution = object_1.ulm_collision_time(&object_2); + if expected.is_some() && solution.is_some() { + assert!( + (expected.unwrap() - solution.unwrap()).abs() < TOLERANCE, + "Axis X. Expected {:?}, obtained {:?}", + expected, + solution + ) + } else { + assert_eq!(*expected, solution) + }; + } + + // now check axis Y + for ([loc1, vel1, loc2, vel2], expected) in &test_cases { + let object_1 = Object2D::new(&[loc1[1], loc1[0]], &[vel1[1], vel1[0]]); + let object_2 = Object2D::new(&[loc2[1], loc2[0]], &[vel2[1], vel2[0]]); + let solution = object_1.ulm_collision_time(&object_2); + if expected.is_some() && solution.is_some() { + assert!( + (expected.unwrap() - solution.unwrap()).abs() < TOLERANCE, + "Axis Y. Expected {:?}, obtained {:?}", + expected, + solution + ) + } else { + assert_eq!(*expected, solution) + }; + } + } + + #[test] + fn ulm_collision_time_bidimensional() { + let test_cases = [ + // meet + ( + [[6.0, 7.0], [-9.0, -3.0], [2.0, 2.0], [-5.0, 2.0]], + Some(1.0), + ), + ( + [[6.0, 7.0], [-1.8, -0.6], [2.0, 2.0], [-1.0, 0.4]], + Some(5.0), + ), + // never meet + ([[6.0, 7.0], [-1.8, -0.6], [2.0, 2.0], [1.0, 0.4]], None), + ]; + + for ([loc1, vel1, loc2, vel2], expected) in &test_cases { + let object_1 = Object2D::new(loc1, vel1); + let object_2 = Object2D::new(loc2, vel2); + let solution = object_1.ulm_collision_time(&object_2); + if expected.is_some() && solution.is_some() { + assert!( + (expected.unwrap() - solution.unwrap()).abs() < TOLERANCE, + "Expected {:?}, obtained {:?}", + expected, + solution + ) + } else { + assert_eq!(*expected, solution) + }; + } + } + + #[test] + fn ulm_collision_point_bidimensional() { + let test_cases = [ + // meet + ( + [[6.0, 7.0], [-1.8, -0.6], [2.0, 2.0], [-1.0, 0.4]], + Some((Vector2D::from(&[-3.0, 4.0]), 5.0)), + ), + // never meet + ([[6.0, 7.0], [-1.8, -0.6], [2.0, 2.0], [1.0, 0.4]], None), + ]; + + for ([loc1, vel1, loc2, vel2], expected) in &test_cases { + let object_1 = Object2D::new(loc1, vel1); + let object_2 = Object2D::new(loc2, vel2); + let solution = object_1.ulm_collision(&object_2); + if expected.is_some() && solution.is_some() { + let (expected_position, expected_time) = expected.unwrap(); + let (solution_position, solution_time) = solution.unwrap(); + let diff_position = expected_position - solution_position; + let diff_time = expected_time - solution_time; + assert!( + diff_position.x.abs() < TOLERANCE + && diff_position.y.abs() < TOLERANCE + && diff_time < TOLERANCE, + "Expected {:?}, obtained {:?}", + expected, + solution + ) + } else { + assert_eq!(*expected, solution) + }; + } + } +} + diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/swift/didacdev.swift" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/swift/didacdev.swift" new file mode 100644 index 0000000000..c381f0a439 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/swift/didacdev.swift" @@ -0,0 +1,69 @@ +import Foundation + +class Object { + + let position: (Double, Double) + let speed: (Double, Double) + + init(position: (Double, Double), speed: (Double, Double)) { + + self.position = position + self.speed = speed + } +} + +enum MyCustomError: Error { + case DivisionByZero +} + +func substract(vectorA: (Double, Double), vectorB: (Double, Double)) -> (Double, Double) { + + let i = vectorA.0 - vectorB.0 + let j = vectorA.1 - vectorB.1 + + return (i, j) +} + +func add(vectorA: (Double, Double), vectorB: (Double, Double)) -> (Double, Double) { + + let i = vectorA.0 + vectorB.0 + let j = vectorA.1 + vectorB.1 + + return (i, j) +} + +func multiply(vector: (Double, Double), time: Double) -> (Double, Double) { + return (vector.0*time, vector.1*time) +} + +func vectorMagnitude(vector: (Double, Double)) -> Double { + return sqrt(pow(vector.0, 2) + pow(vector.1, 2)) +} + +func getMeeting(objectA: Object, objectB: Object) { + var time: Double = 0.0 + + do { + time = vectorMagnitude(vector: substract(vectorA: objectA.position, vectorB: objectB.position)) / vectorMagnitude(vector: substract(vectorA: objectB.speed, vectorB: objectA.speed)) + } catch { + print("Los vectores no se pueden encontrar") + return + } + + + let positionA = add(vectorA: objectA.position, vectorB: multiply(vector: objectA.speed, time: time)) + let positionB = add(vectorA: objectB.position, vectorB: multiply(vector: objectB.speed, time: time)) + + if abs(positionA.0 - positionB.0) < 0.0001 && abs(positionA.1 - positionB.1) < 0.0001 { + + print("Los objetos se encuentran en el punto \(positionA) pasados \(time) segundos") + + } + +} + + +let objectA = Object(position: (2, 2), speed: (2, -1)) +let objectB = Object(position: (4, 2), speed: (1, -1)) +getMeeting(objectA: objectA, objectB: objectB) + diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/albertovf.ts" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/albertovf.ts" new file mode 100644 index 0000000000..97fd5d0dbf --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/albertovf.ts" @@ -0,0 +1,69 @@ +class Point { + x: number; y: number; + + constructor(x, y) { + this.x = x; + this.y = y; + } + + distance = (z: Point) => { + return Math.sqrt( + (z.x - this.x) ** 2 + + (z.y - this.y) ** 2 + ) + } +} + +class Vector { + x: number; + y: number; + vx: number; + vy: number; + + constructor(o: Point, v: Point) { + this.x = o.x; + this.y = o.y; + this.vx = v.x; + this.vy = v.y; + } + + origin() { + return new Point(this.x, this.y); + } + + desplazamiento(t: number) { + return new Point(this.x + this.vx * t, this.y + this.vy * t); + } +} + +const colision = (A: Vector, B: Vector) => { + let t = 1; + let previousDistance = A.origin().distance(B.origin()); + let actualDistance = A.desplazamiento(t).distance(B.desplazamiento(t)); + + while (true) { + t++ + let Ax2 = A.desplazamiento(t).x; + let Ay2 = A.desplazamiento(t).y; + let Bx2 = B.desplazamiento(t).x; + let By2 = B.desplazamiento(t).y; + if (actualDistance >= previousDistance) { + return 'Los puntos no se encuentran'; + } + else if (Ax2 === Bx2 && Ay2 === By2) { + return `Se han encontrado en (${Ax2}, ${Ay2}) en t=${t}`; + } + else { + previousDistance = actualDistance; + actualDistance = A.desplazamiento(t).distance(B.desplazamiento(t)); + } + } +} + +const reto = (v1: Vector, v2: Vector) => { + console.log(colision(v1, v2)); +} + +reto(new Vector(new Point(0, 0), new Point(1, 1)), new Vector(new Point(5, 0), new Point(0, 1)));// Se cruzan +reto(new Vector(new Point(2, 0), new Point(0, 1)), new Vector(new Point(4, 0), new Point(0, 1)));// Objetos con vectores paralelos que nunca se encuentran. +reto(new Vector(new Point(2, 2), new Point(1, 1)), new Vector(new Point(4, 0), new Point(0, 1)));// Objetos que se cruzan pero no en el mismo instante diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/csantosr.ts" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/csantosr.ts" new file mode 100644 index 0000000000..70f1be2b5c --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/csantosr.ts" @@ -0,0 +1,94 @@ +/* + * 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. + */ + +type PointLocation = { + x: number; + y: number; +} + +type Velocity = PointLocation; + +interface Point { + loc: PointLocation, + vel: Velocity, +} + +const meetingPoint = (pointA: Point, pointB: Point): number | null => { + // Resolviendo la ecuación para el eje x + const tX = (pointB.loc.x - pointA.loc.x) / (pointA.vel.x - pointB.vel.x); + + // Resolviendo la ecuación para el eje y + const tY = (pointB.loc.y - pointA.loc.y) / (pointA.vel.y - pointB.vel.y); + + // Si tX y tY son iguales, entonces se encontrarán en ese momento t + if (tX === tY) { + return tX; + } + return null; +} + +const meetingPointWrapper = (pointA: Point, pointB: Point) => { + const response = meetingPoint(pointA, pointB); + + if (response === null) { + console.log('Los puntos no se encontrarán! 😢'); + } else { + console.log(`Los puntos se encontrarán en ${response} segundos!!! 🎉`); + } +} + +// Ejemplos +// NO SE ENCUENTRAN + +const pointA1: Point = { + loc: { x: 0, y: 0 }, + vel: { x: 1, y: 0 }, +}; + +const pointB1: Point = { + loc: { x: 0, y: 1 }, + vel: { x: 1, y: 0 }, +}; +meetingPointWrapper(pointA1, pointB1); + + +const pointA2: Point = { + loc: { x: 0, y: 0 }, + vel: { x: 1, y: 0 }, +}; + +const pointB2: Point = { + loc: { x: 1, y: 0 }, + vel: { x: -1, y: 0 }, +}; +meetingPointWrapper(pointA2, pointB2); + +const pointA3: Point = { + loc: { x: 0, y: 0 }, + vel: { x: 0, y: 1 }, +}; + +const pointB3: Point = { + loc: { x: 2, y: 0 }, + vel: { x: 1, y: 0 }, +}; +meetingPointWrapper(pointA3, pointB3); + +// SE ENCUENTRAN! +const pointA4: Point = { + loc: { x: 0, y: 0 }, + vel: { x: 1, y: 1 } +}; + +const pointB4: Point = { + loc: { x: 2, y: 2 }, + vel: { x: 0, y: 0 } +}; +meetingPointWrapper(pointA4, pointB4); diff --git "a/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/johanrestrepo19.ts" "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/johanrestrepo19.ts" new file mode 100644 index 0000000000..1184d4f0e0 --- /dev/null +++ "b/Retos/Reto #42 - PUNTO DE ENCUENTRO [Dif\303\255cil]/typescript/johanrestrepo19.ts" @@ -0,0 +1,62 @@ +type Vector = { x: number; y: number }; +type Particle = { + position: Vector; + speed: Vector; +}; +type LinearCoefficients = [number, number]; +type Path = { x: LinearCoefficients; y: LinearCoefficients }; + +const findTimeToMeet = ( + equationCoefficients1: LinearCoefficients, + equationCoefficients2: LinearCoefficients, +): number => { + const ec2Inverted = equationCoefficients2.map( + (coefficient) => coefficient * -1, + ); + const coefficientSum: LinearCoefficients = [ + equationCoefficients1[0] + ec2Inverted[0], + equationCoefficients1[1] + ec2Inverted[1], + ]; + + return Math.abs(coefficientSum[1] / coefficientSum[0]); +}; + +const evaluatePath = (path: Path, time: number): Vector => { + const x = path.x[0] * time + path.x[1]; + const y = path.y[0] * time + path.y[1]; + return { x, y }; +}; + +const findMeetingPoint = (p1: Particle, p2: Particle): string => { + const pathCoefficients1: Path = { + x: [p1.speed.x, p1.position.x], + y: [p1.speed.y, p1.position.y], + }; + + const pathCoefficients2: Path = { + x: [p2.speed.x, p2.position.x], + y: [p2.speed.y, p2.position.y], + }; + + const timeToMeetX = findTimeToMeet(pathCoefficients1.x, pathCoefficients2.x); + const timeToMeetY = findTimeToMeet(pathCoefficients1.y, pathCoefficients2.y); + + if (timeToMeetX !== timeToMeetY) return "The particles will not meet"; + + const meetingPoint = evaluatePath(pathCoefficients1, timeToMeetX); + return `The particles will meet at x: ${meetingPoint.x} and y: ${meetingPoint.y} in ${timeToMeetX} seconds`; +}; + +console.log( + findMeetingPoint( + { position: { x: -8, y: 2 }, speed: { x: 3, y: -1 } }, + { position: { x: -2, y: -7 }, speed: { x: 1, y: 2 } }, + ), +); + +console.log( + findMeetingPoint( + { position: { x: 6, y: 4 }, speed: { x: -2, y: -2 } }, + { position: { x: 3, y: -4 }, speed: { x: -1, y: 2 } }, + ), +); diff --git a/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/jarkillo.py b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/jarkillo.py new file mode 100644 index 0000000000..14a808e89f --- /dev/null +++ b/Retos/Reto #6 - PIEDRA, PAPEL, TIJERA, LAGARTO, SPOCK [Media]/python/jarkillo.py @@ -0,0 +1,84 @@ +'''/* + * 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. + */''' + + +import random + +jugador1_puntuacion = 0 +jugador2_puntuacion = 0 + + +def piedra_papel_tijera_lagarto_spock(jugada1, jugada2, jugador1_puntuacion, jugador2_puntuacion): + ganador = '' + + for n in range(len(jugada1)): + if jugada1[n] == jugada2[n]: + ganador = 'Tie' + elif jugada1[n] == '🗿': + + if jugada2[n] == '✂️' or jugada1[n] == '🦎': + ganador = 'Player 1' + jugador1_puntuacion += 1 + else: + ganador = 'Player 2' + jugador2_puntuacion += 1 + + elif jugada1[n] == '📄': + + if jugada2[n] == '🗿' or jugada2[n] == '🖖': + ganador = 'Player 1' + jugador1_puntuacion += 1 + else: + ganador = 'Player 2' + jugador2_puntuacion += 1 + + elif jugada1[n] == '✂️': + + if jugada2[n] == '📄' or jugada2[n] == '🦎': + ganador = 'Player 1' + jugador1_puntuacion += 1 + else: + ganador = 'Player 2' + jugador2_puntuacion += 1 + + elif jugada1[n] == '🦎': + + if jugada2[n] == '📄' or jugada2[n] == '🖖': + ganador = 'Player 1' + jugador1_puntuacion += 1 + else: + ganador = 'Player 2' + jugador2_puntuacion += 1 + + elif jugada1[n] == '🖖': + + if jugada2[n] == '🗿' or jugada2[n] == '✂️': + ganador = 'Player 1' + jugador1_puntuacion += 1 + else: + ganador = 'Player 2' + jugador2_puntuacion += 1 + + print(f'El ganador es: {ganador}') + return jugador1_puntuacion, jugador2_puntuacion + + +jugada1 = [] +jugada2 = [] +for i in range(5): + jugada1.append(random.choice(['🗿', '📄', '✂️', '🦎', '🖖'])) + jugada2.append(random.choice(['🗿', '📄', '✂️', '🦎', '🖖'])) + +print(jugada1, jugada2) +jugador1_puntuacion, jugador2_puntuacion = piedra_papel_tijera_lagarto_spock( + jugada1, jugada2, jugador1_puntuacion, jugador2_puntuacion) +print(f'El ganador es el Player 1 con {jugador1_puntuacion} puntos') if jugador1_puntuacion > jugador2_puntuacion else print( + f'El ganador es el Player 2 con {jugador2_puntuacion} puntos') diff --git a/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jarkillo.py b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jarkillo.py new file mode 100644 index 0000000000..8277f9c876 --- /dev/null +++ b/Retos/Reto #7 - EL SOMBRERO SELECCIONADOR [Media]/python/jarkillo.py @@ -0,0 +1,169 @@ +'''/* + * 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. + */''' + + +def sombrero(): + + recuento = [0, 0, 0, 0] + respuesta = "" + print('Bienvenido al sombrero seleccionador de Hogwarts') + print('Responde a las siguientes preguntas para saber a que casa perteneces') + print('') + print('Pregunta 1: ¿Que te gustaría ser?') + print('1. Rico') # Slitherin + print('2. Sabio') # Ravenclaw + print('3. Fuerte') # Griffindor + print('4. Feliz') # Hufflepuf + + while respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + respuesta = input('Elige una opción: ') + + if respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + print('Respuesta no válida') + + if respuesta == '1': + recuento[0] += 1 + + elif respuesta == '2': + recuento[3] += 1 + + elif respuesta == '3': + recuento[1] += 1 + + elif respuesta == '4': + recuento[2] += 1 + + else: + print('Respuesta no válida') + + print('Pregunta 2: ¿Qué cualidad te parece más valiosa?: ') + print('1. Ambición') # Slitherin + print('2. Inteligencia') # Ravenclaw + print('3. Lealtad') # Hufflepuff + print('4. Valentía') # Griffindor + respuesta = "" + + while respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + respuesta = input('Elige una opción: ') + if respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + print('Respuesta no válida') + + if respuesta == '1': + recuento[0] += 1 + + elif respuesta == '2': + recuento[3] += 1 + + elif respuesta == '3': + recuento[2] += 1 + + elif respuesta == '4': + recuento[1] += 1 + + else: + print('Respuesta no válida') + + print('Pregunta 3: ¿Cuál de las siguientes opciones odiarías más que la gente te llamara?: ') + print('1. Ignorante') # Ravenclaw + print('2. Cobarde') # Griffindor + print('3. Egoísta') # Hufflepuff + print('4. Ordinario') # Slitherin + respuesta = "" + + while respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + respuesta = input('Elige una opción: ') + if respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + print('Respuesta no válida') + + if respuesta == '1': + recuento[3] += 1 + + elif respuesta == '2': + recuento[1] += 1 + + elif respuesta == '3': + recuento[2] += 1 + + elif respuesta == '4': + recuento[0] += 1 + + else: + print('Respuesta no válida') + + print('Pregunta 4: ¿Después de su muerte ¿qué es lo que más te gustaría que hiciera la gente cuando escuche tu nombre?: ') + print('1. Leer') # Ravenclaw + print('2. Hacer deporte') # Griffindor + print('3. Estar con tus amigos') # Hufflepuff + print('4. Estar solo') # Slitherin + + respuesta = "" + while respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + respuesta = input('Elige una opción: ') + if respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + print('Respuesta no válida') + + if respuesta == '1': + recuento[3] += 1 + + elif respuesta == '2': + recuento[1] += 1 + + elif respuesta == '3': + recuento[2] += 1 + + elif respuesta == '4': + recuento[0] += 1 + + else: + print('Respuesta no válida') + + +# Slitherin, Gryffindor, Hufflepuff, Ravenclaw + print('Pregunta 5: Preferirías inventar una poción que garantizara: ') + print('1. Amor') # Hufflepuff + print('2. Gloria') # Gryffindor + print('3. Sabiduría') # Ravenclaw + print('4. Poder') # Slitherin + respuesta = "" + + while respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + respuesta = input('Elige una opción: ') + if respuesta != '1' and respuesta != '2' and respuesta != '3' and respuesta != '4': + print('Respuesta no válida') + + if respuesta == '1': # Hufflepuff + recuento[3] += 1 + + elif respuesta == '2': # Gryffindor + recuento[1] += 1 + + elif respuesta == '3': # Ravenclaw + recuento[2] += 1 + + elif respuesta == '4': # Slitherin + recuento[0] += 1 + + else: + print('Respuesta no válida') + + if max(recuento) == recuento[0]: + print('Tu casa es Slitherin') + elif max(recuento) == recuento[1]: + print('Tu casa es Gryffindor') + elif max(recuento) == recuento[2]: + print('Tu casa es Hufflepuff') + elif max(recuento) == recuento[3]: + print('Tu casa es Ravenclaw') + else: + print('Error') + + +sombrero() diff --git a/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jarkillo.py b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jarkillo.py new file mode 100644 index 0000000000..b1055da161 --- /dev/null +++ b/Retos/Reto #8 - EL GENERADOR PSEUDOALEATORIO [Media]/python/jarkillo.py @@ -0,0 +1,51 @@ +'''/* + * 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... + */''' + +from time import sleep +import datetime +import math + + +def pseudoaleatorio(digitos=2, contador=1, velocidad=0.2): + '''Genera {contador} números pseudoaleatorios de {digitos} dígitos . + Params: digitos: Número de dígitos del número pseudoaleatorio. + contador: Número de números pseudoaleatorios a generar.''' + + for n in range(contador): + current_time = datetime.datetime.now().timestamp() + seconds = datetime.datetime.now().second + minute = datetime.datetime.now().minute + hour = datetime.datetime.now().hour + day = datetime.datetime.now().day + month = datetime.datetime.now().month + year = datetime.datetime.now().year + microsecond = datetime.datetime.now().microsecond + + op1 = current_time * minute / 100 * hour / \ + 15 * day / 30 * month / 12 * year / 100 - seconds + + op2 = op1 + datetime.datetime.now().second * 100000 / 1000 * minute / 100 * \ + day / 1000 * month * microsecond / 100 * year / \ + 1000 / datetime.datetime.now().microsecond + + for n in range(datetime.datetime.now().second): + op1 = op1 + n - op2 + datetime.datetime.now().microsecond * 100 + op3 = op1 + op2 - datetime.datetime.now().microsecond * 100 + op4 = op3 * 123478912 / \ + datetime.datetime.now().microsecond * math.pi + op4 = int(op4*10*digitos) + + print(int(str(op4)[-digitos:])) + sleep(velocidad) + + +contador = input('¿Cuantos números pseudoaleatorios quieres generar? ') +digitos = input('¿De cuantos dígitos quieres que sean? ') +velocidad = input( + '¿A que velocidad quieres que se generen? (Recomendado: 0.5 - 1) ') + +pseudoaleatorio(int(digitos), int(contador), float(velocidad)) diff --git "a/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/jarkillo.py" "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/jarkillo.py" new file mode 100644 index 0000000000..92c1c5cce6 --- /dev/null +++ "b/Retos/Reto #9 - HETEROGRAMA, ISOGRAMA Y PANGRAMA [F\303\241cil]/python/jarkillo.py" @@ -0,0 +1,49 @@ +'''/* + * 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 que no tiene ninguna letra repetida. + # Isograma: palabra o frase en la que cada letra aparece el mismo número de veces + # Pangrama: Palabra que contiene todas las letras del alfabeto. + # Pangrama perfecto: Pangrama y además no tiene ninguna letra repetida. + + */''' + + +def heterograma(cadena): + '''Devuelve True si la cadena es un heterograma.''' + for letra in cadena: + if cadena.count(letra) > 1: + return False + return True + + +def isograma(cadena): + '''Devuelve True si la cadena es un isograma.''' + for letra in cadena: + if cadena.count(letra) != cadena.count(letra.lower()) + cadena.count(letra.upper()): + return False + return True + + +def pangrama(cadena): + '''Devuelve True si la cadena es un pangrama.''' + for letra in 'abcdefghijklmnñopqrstuvwxyz': + if letra not in cadena.lower(): + return False + return True + + +def pangrama_perfecto(cadena): + '''Devuelve True si la cadena es un pangrama perfecto.''' + if heterograma(cadena) == True and pangrama(cadena) == True: + return True + return False + + +cadena = input('Introduce una cadena de texto: ') +print('Heterograma: ', heterograma(cadena)) +print('Isograma: ', isograma(cadena)) +print('Pangrama: ', pangrama(cadena)) +print('Pangrama perfecto: ', pangrama_perfecto(cadena))