├── Arrays ├── Contiene_Duplicados-.py ├── Eliminar_duplicados.py ├── Girar_Matriz.py ├── Interseccion_Matrices.py ├── Mas_Uno.py ├── Mejor_Momento.py ├── Mover_Zeros.py ├── Sudoku.py └── Un_Solo_Numero.py ├── Linear ├── ejercicio1.py ├── ejercicio2.py ├── ejercicio3.py ├── ejercicio4.py ├── ejercicio5.py ├── ejercicio6.py ├── ejercicio7.py ├── ejercicio8.py └── ejercicio9.py ├── README.md ├── String ├── Anagrama.py ├── Cadena_A_Entero.py ├── Caracter_Unico.py ├── Devolver_Indice.py ├── Entero_inverso.py ├── Es_Palindromo.py ├── Palabra_Invertida.py └── Prefijo_Común_Más_Largo.py └── variado ├── adivina_numero.py ├── aprender_a_sumar.py ├── cara_o_cruz.py ├── contar_recusividad.py ├── cuenta_lineas.py ├── diferencia_maxima.py ├── factorial.py ├── fibonacci.py ├── numero_primo.py ├── palabras_en_frase.py └── tabla_multiplicar.py /Arrays/Contiene_Duplicados-.py: -------------------------------------------------------------------------------- 1 | """Dada una matriz de números enteros nums, devuelve truesi algún valor aparece al menos dos veces en la matriz y devuelve falsesi cada elemento es distinto. 2 | 3 | Ejemplo 1: 4 | Entrada: números = [1,2,3,1] 5 | Salida: verdadero""" 6 | 7 | # Resultado 8 | 9 | class Solution(object): 10 | def containsDuplicate(self, nums): 11 | # Creamos un conjunto (set) para almacenar los elementos únicos que hemos encontrado 12 | seen = set() 13 | 14 | # Iteramos sobre la lista de números 15 | for num in nums: 16 | # Verificamos si el elemento ya está en el conjunto (ya ha sido encontrado antes) 17 | if num in seen: 18 | # Si encontramos un duplicado, devolvemos True 19 | return True 20 | 21 | # Agregamos el elemento al conjunto (ya que es la primera vez que lo encontramos) 22 | seen.add(num) 23 | 24 | # Si llegamos hasta aquí, no hemos encontrado duplicados, devolvemos False 25 | return False -------------------------------------------------------------------------------- /Arrays/Eliminar_duplicados.py: -------------------------------------------------------------------------------- 1 | """Dada una matriz de enteros numsordenada en orden no decreciente , elimine los duplicados en el lugar de modo que cada elemento único aparezca solo una vez . El orden relativo de los elementos debe mantenerse igual . Luego devuelve el número de elementos únicos ennums . 2 | Considere la cantidad de elementos únicos de numsto be k. Para ser aceptado, debe hacer lo siguiente: 3 | 4 | Cambie la matriz numsde modo que los primeros kelementos numscontengan los elementos únicos en el orden en que estaban presentes numsinicialmente. Los elementos restantes de numsno son importantes al igual que el tamaño de nums. 5 | Devolver k. 6 | 7 | Entrada: nums = [1,1,2] 8 | Salida: 2, nums = [1,2,_] 9 | Explicación: Su función debería devolver k = 2, siendo los dos primeros elementos de nums 1 y 2 respectivamente. 10 | No importa lo que dejes más allá de la k devuelta (de ahí que sean guiones bajos). 11 | """ 12 | 13 | class Solution(object): 14 | def removeDuplicates(self, nums): 15 | if not nums: 16 | return 0 17 | 18 | # Inicializa el índice para los elementos únicos 19 | indice_unico = 0 20 | 21 | # Itera a través del arreglo empezando desde el segundo elemento 22 | for i in range(1, len(nums)): 23 | # Verifica si el elemento actual es diferente al anterior 24 | if nums[i] != nums[indice_unico]: 25 | # Incrementa el índice único 26 | indice_unico += 1 27 | # Mueve el elemento único a su posición correcta 28 | nums[indice_unico] = nums[i] 29 | 30 | # La cantidad de elementos únicos es (indice_unico + 1) 31 | return indice_unico + 1 32 | 33 | # Ejemplo de uso 34 | sol = Solution() 35 | nums = [1, 1, 2, 2, 2, 3, 4, 4, 5] 36 | expectedNums = [1, 2, 3, 4, 5] 37 | 38 | k = sol.removeDuplicates(nums) 39 | 40 | # Verifica si el arreglo modificado coincide con la respuesta esperada 41 | assert k == len(expectedNums) 42 | for i in range(k): 43 | assert nums[i] == expectedNums[i] 44 | -------------------------------------------------------------------------------- /Arrays/Girar_Matriz.py: -------------------------------------------------------------------------------- 1 | """Dada una matriz de números enteros nums, gire la matriz hacia la derecha en kpasos, donde kno es negativo. 2 | 3 | Ejemplo 1: 4 | 5 | Entrada: números = [1,2,3,4,5,6,7], k = 3 6 | Salida: [5,6,7,1,2,3,4] 7 | Explicación: 8 | rotar 1 paso a la derecha: [7,1,2,3,4,5,6] 9 | rotar 2 pasos a la derecha: [6,7,1,2,3,4,5] 10 | rotar 3 pasos a la derecha: [5,6,7,1,2,3,4] 11 | """ 12 | 13 | #RESULTADO 14 | class Solution(object): 15 | def rotate(self, nums, k): 16 | # Si k es mayor que la longitud de la matriz, toma el módulo 17 | k = k % len(nums) 18 | 19 | # Gira la matriz hacia la derecha utilizando la técnica de slicing 20 | nums[:] = nums[-k:] + nums[:-k] 21 | # Ejemplo de uso 22 | numbers = [1, 2, 3, 4, 5, 6, 7] 23 | k = 3 24 | rotate(numbers, k) 25 | print(numbers) # Salida esperada: [5, 6, 7, 1, 2, 3, 4] -------------------------------------------------------------------------------- /Arrays/Interseccion_Matrices.py: -------------------------------------------------------------------------------- 1 | """Dadas dos matrices de enteros nums1y nums2, devuelve una matriz de su intersección . Cada elemento del resultado debe aparecer tantas veces como se muestra en ambas matrices y puede devolver el resultado en cualquier orden . 2 | 3 | Ejemplo 1: 4 | Entrada: números1 = [1,2,2,1], números2 = [2,2] 5 | Salida: [2,2] 6 | """ 7 | 8 | #Solucion 9 | 10 | from collections import Counter 11 | 12 | class Solution(object): 13 | def intersect(self, nums1, nums2): 14 | # Contar las frecuencias de los elementos en ambas matrices 15 | count_nums1 = Counter(nums1) 16 | count_nums2 = Counter(nums2) 17 | 18 | # Inicializar una lista para almacenar la intersección 19 | intersection = [] 20 | 21 | # Iterar sobre los elementos comunes a ambas matrices 22 | for num in count_nums1 & count_nums2: 23 | # Agregar el elemento repetido según la frecuencia común mínima 24 | intersection.extend([num] * min(count_nums1[num], count_nums2[num])) 25 | 26 | return intersection 27 | 28 | sol = Solution() 29 | nums1 = [1, 2, 2, 1] 30 | nums2 = [2, 2] 31 | result = sol.intersect(nums1, nums2) 32 | print(result) # Salida esperada: [2, 2] -------------------------------------------------------------------------------- /Arrays/Mas_Uno.py: -------------------------------------------------------------------------------- 1 | """Se le proporciona un número entero grande representado como una matriz de números enteros digits, donde cada uno digits[i]es el dígito del número entero. Los dígitos están ordenados del más significativo al menos significativo de izquierda a derecha. El número entero grande no contiene ningún inicial .ith0 2 | Incrementa el número entero grande en uno y devuelve la matriz de dígitos resultante . 3 | 4 | Ejemplo 1: 5 | Entrada: dígitos = [1,2,3] 6 | Salida: [1,2,4] 7 | Explicación: La matriz representa el número entero 123. 8 | Incrementar en uno da 123 + 1 = 124. 9 | Por tanto, el resultado debería ser [1,2,4]. 10 | """ 11 | 12 | #RESULTADO 13 | 14 | class Solution(object): 15 | def plusOne(self, digits): 16 | # Inicializar el acarreo como 1 (para incrementar en uno) 17 | carry = 1 18 | 19 | # Iterar sobre los dígitos de derecha a izquierda 20 | for i in range(len(digits) - 1, -1, -1): 21 | # Sumar el dígito actual y el acarreo 22 | total = digits[i] + carry 23 | 24 | # Calcular el nuevo dígito y actualizar el acarreo 25 | digits[i] = total % 10 26 | carry = total // 10 27 | 28 | # Si queda un acarreo al final, agregarlo como un nuevo dígito 29 | if carry > 0: 30 | digits.insert(0, carry) 31 | 32 | return digits 33 | sol = Solution() 34 | digits = [1, 2, 3] 35 | result = sol.plusOne(digits) 36 | print(result) # Salida esperada: [1, 2, 4] -------------------------------------------------------------------------------- /Arrays/Mejor_Momento.py: -------------------------------------------------------------------------------- 1 | """Se le proporciona una matriz de números enteros pricesdonde prices[i]está el precio de una acción determinada en el 2 | día.ith Cada día, usted puede decidir comprar y/o vender las acciones. Sólo puede poseer como máximo una acción a la 3 | vez. Sin embargo, puedes comprarlo y venderlo inmediatamente el mismo día . 4 | Encuentre y devuelva el máximo beneficio que pueda lograr . 5 | 6 | Entrada: precios = [7,1,5,3,6,4] 7 | Salida: 7 8 | Explicación: Compre el día 2 (precio = 1) y venda el día 3 (precio = 5), ganancia = 5-1 = 4. 9 | Luego compre el día 4 (precio = 3) y venda el día 5 (precio = 6), ganancia = 6-3 = 3. 10 | La ganancia total es 4 + 3 = 7.""" 11 | 12 | #RESULTADO 13 | 14 | class Solution(object): 15 | def maxProfit(self, prices): 16 | if not prices or len(prices) == 1: 17 | return 0 18 | 19 | # Inicializar una lista para almacenar los beneficios hasta el día i 20 | profits = [0] * len(prices) 21 | 22 | # Iterar desde el segundo día hasta el final 23 | for i in range(1, len(prices)): 24 | # Calcular el beneficio si vendemos en el día i 25 | sell_today = prices[i] - prices[i-1] + profits[i-1] 26 | 27 | # Calcular el beneficio si no hacemos ninguna transacción en el día i 28 | no_transaction_today = max(profits[i-1], 0) 29 | 30 | # Actualizar el beneficio máximo hasta el día i 31 | profits[i] = max(sell_today, no_transaction_today) 32 | 33 | # El beneficio máximo estará en profits[-1] 34 | return profits[-1] 35 | # Ejemplo de uso 36 | prices = [7, 1, 5, 3, 6, 4] 37 | result = maxProfit(prices) 38 | print(result) # Salida esperada: 7 -------------------------------------------------------------------------------- /Arrays/Mover_Zeros.py: -------------------------------------------------------------------------------- 1 | """Dada una matriz de números enteros nums, mueva todos 0al final manteniendo el orden relativo de los elementos distintos de cero. 2 | Tenga en cuenta que debe hacer esto in situ sin hacer una copia de la matriz. 3 | 4 | Ejemplo 1: 5 | Entrada: números = [0,1,0,3,12] 6 | Salida: [1,3,12,0,0] 7 | """ 8 | 9 | #RESULTADO 10 | 11 | class Solution(object): 12 | def moveZeroes(self, nums): 13 | # Inicializar el puntero para la posición de los elementos no nulos 14 | non_zero_index = 0 15 | 16 | # Mover los elementos no nulos hacia la posición adecuada 17 | for i in range(len(nums)): 18 | if nums[i] != 0: 19 | # Si el elemento no es cero, muévelo a la posición adecuada 20 | nums[non_zero_index] = nums[i] 21 | non_zero_index += 1 22 | 23 | # Llenar el resto de la matriz con ceros 24 | for i in range(non_zero_index, len(nums)): 25 | nums[i] = 0 26 | 27 | sol = Solution() 28 | nums = [0, 1, 0, 3, 12] 29 | sol.moveZeroes(nums) 30 | 31 | # Imprimir el resultado 32 | print(nums) # Salida esperada: [1, 3, 12, 0, 0] -------------------------------------------------------------------------------- /Arrays/Sudoku.py: -------------------------------------------------------------------------------- 1 | """Determinar si un 9 x 9tablero de Sudoku es válido. Sólo es necesario validar las celdas completadas de acuerdo con las siguientes reglas : 2 | 3 | Cada fila debe contener los dígitos 1-9sin repetición. 4 | Cada columna debe contener los dígitos 1-9 sin repetición. 5 | Cada uno de los nueve 3 x 3subcuadros de la grilla debe contener los dígitos 1-9 sin repetición. 6 | Nota: 7 | 8 | Un tablero de Sudoku (parcialmente lleno) podría ser válido pero no necesariamente tiene solución. 9 | Sólo es necesario validar las celdas completadas de acuerdo con las reglas mencionadas. 10 | 11 | 12 | Ejemplo 1: 13 | 14 | 15 | Entrada: tablero = 16 | [["5","3",".",".","7",".",".",".","."] 17 | ,["6",".",".","1","9","5",".",".","."] 18 | ,[".","9","8",".",".",".",".","6","."] 19 | ,["8",".",".",".","6",".",".",".","3"] 20 | ,["4",".",".","8",".","3",".",".","1"] 21 | ,["7",".",".",".","2",".",".",".","6"] 22 | ,[".","6",".",".",".",".","2","8","."] 23 | ,[".",".",".","4","1","9",".",".","5"] 24 | ,[".",".",".",".","8",".",".","7","9"]] 25 | Salida: verdadero 26 | """ 27 | 28 | #RESULTADO 29 | 30 | class Solution(object): 31 | def isValidSudoku(self, board): 32 | # Función para verificar si una lista de números tiene duplicados 33 | def hasDuplicates(nums): 34 | seen = set() 35 | for num in nums: 36 | if num != '.': 37 | if num in seen: 38 | return True 39 | seen.add(num) 40 | return False 41 | 42 | # Verificar filas y columnas 43 | for i in range(9): 44 | # Verificar fila 45 | if hasDuplicates(board[i]): 46 | return False 47 | 48 | # Verificar columna 49 | if hasDuplicates([board[j][i] for j in range(9)]): 50 | return False 51 | 52 | # Verificar subcuadros 3x3 53 | for i in range(0, 9, 3): 54 | for j in range(0, 9, 3): 55 | subgrid = [board[x][y] for x in range(i, i + 3) for y in range(j, j + 3)] 56 | if hasDuplicates(subgrid): 57 | return False 58 | 59 | return True 60 | 61 | # Ejemplo de uso 62 | sol = Solution() 63 | sudoku_board = [ 64 | ["5", "3", ".", ".", "7", ".", ".", ".", "."], 65 | ["6", ".", ".", "1", "9", "5", ".", ".", "."], 66 | [".", "9", "8", ".", ".", ".", ".", "6", "."], 67 | ["8", ".", ".", ".", "6", ".", ".", ".", "3"], 68 | ["4", ".", ".", "8", ".", "3", ".", ".", "1"], 69 | ["7", ".", ".", ".", "2", ".", ".", ".", "6"], 70 | [".", "6", ".", ".", ".", ".", "2", "8", "."], 71 | [".", ".", ".", "4", "1", "9", ".", ".", "5"], 72 | [".", ".", ".", ".", "8", ".", ".", "7", "9"] 73 | ] 74 | result = sol.isValidSudoku(sudoku_board) 75 | print(result) # Salida esperada: True 76 | -------------------------------------------------------------------------------- /Arrays/Un_Solo_Numero.py: -------------------------------------------------------------------------------- 1 | """Dada una matriz de números enteros no vacíanums , cada elemento aparece dos veces excepto uno. Encuentra ese único. 2 | 3 | Debe implementar una solución con una complejidad de tiempo de ejecución lineal y utilizar solo espacio adicional constante. 4 | Entrada: números = [2,2,1] 5 | Salida: 1 """ 6 | 7 | # Resultado 8 | 9 | class Solution(object): 10 | def singleNumber(self, nums): 11 | resultado = 0 12 | 13 | for num in nums: 14 | resultado ^= num 15 | 16 | return resultado 17 | -------------------------------------------------------------------------------- /Linear/ejercicio1.py: -------------------------------------------------------------------------------- 1 | # A partir del radio de la órbita del planeta y su velocidad orbital, calcule el número de días por año en este planeta. 2 | 3 | from math import pi 4 | 5 | r = input("Ingrese el radio de la órbita del planeta en km: ") 6 | v = input("Ingrese la velocidad orbital del planeta en km/h: ") 7 | r = float(r) 8 | v = float(v) 9 | 10 | # Calculamos el perímetro de la órbita 11 | r = r * 1000000 12 | 13 | year = 2 * pi * r / v 14 | 15 | year = year / (60 * 60 * 24) 16 | 17 | print("El número de días por año en este planeta es: ", round(year)) -------------------------------------------------------------------------------- /Linear/ejercicio2.py: -------------------------------------------------------------------------------- 1 | # Escribir un programa que genere un número aleatorio de tres dígitos y calcule la suma de sus dígitos 2 | 3 | from random import randint 4 | 5 | num = randint(100, 999) 6 | print("Número aleatorio de tres dígitos: ", num) 7 | 8 | a = num // 100 9 | b = num // 10 % 10 10 | c = num % 10 11 | 12 | suma = a + b + c 13 | 14 | print("La suma de los dígitos del número es: ", suma) 15 | -------------------------------------------------------------------------------- /Linear/ejercicio3.py: -------------------------------------------------------------------------------- 1 | # Las longitudes de dos catetos de un triángulo anular se ingresan desde el teclado. calcular su área y perímetro 2 | 3 | import math 4 | 5 | AB = input("Ingrese la longitud del cateto AB: ") 6 | AC = input("Ingrese la longitud del cateto AC: ") 7 | 8 | AB = float(AB) 9 | AC = float(AC) 10 | 11 | BC = math.sqrt(AB**2 + AC**2) 12 | 13 | superficie = (AB * AC) / 2 14 | perimetro = AB + AC + BC 15 | 16 | print("El área del triángulo es: ", superficie) 17 | print("El perímetro del triángulo es: ", perimetro) -------------------------------------------------------------------------------- /Linear/ejercicio4.py: -------------------------------------------------------------------------------- 1 | # Se ingresan la altura del cilindro y el radio de su base. calcular la superficie total del cilindro 2 | 3 | from math import pi 4 | 5 | height = float(input("Ingrese la altura del cilindro en cm: ")) 6 | radio = float(input("Ingrese el radio de la base del cilindro en cm: ")) 7 | 8 | circle = pi * radio**2 9 | side = 2 * pi * radio * height 10 | total_area = 2 * circle + side 11 | 12 | print("La superficie total del cilindro es: ", total_area, "cm^2") 13 | -------------------------------------------------------------------------------- /Linear/ejercicio5.py: -------------------------------------------------------------------------------- 1 | # Introduce el radio. Encuentra la circunferencia y el área correspondientes del círculo. 2 | 3 | import math 4 | 5 | radio = float(input("Introduce el radio del círculo en cm: ")) 6 | 7 | circunferencia = 2 * math.pi * radio 8 | area = math.pi * radio**2 9 | 10 | print("La circunferencia del círculo es: ", circunferencia, "cm") 11 | print("El área del círculo es: ", area, "cm^2") 12 | -------------------------------------------------------------------------------- /Linear/ejercicio6.py: -------------------------------------------------------------------------------- 1 | # Se introducen las coordenadas de dos puntos. mostrar la ecuación de la recta que pasa por estos dos puntos 2 | 3 | print("Introduzca las coordenadas de dos puntos:") 4 | x1 = float(input("x1: ")) 5 | y1 = float(input("y1: ")) 6 | 7 | print("Introduzca las coordenadas del segundo punto:") 8 | x2 = float(input("x2: ")) 9 | y2 = float(input("y2: ")) 10 | 11 | print("La ecuación de la recta que pasa por los puntos ({}, {}) y ({}, {}) es:".format( 12 | x1, y1, x2, y2)) 13 | k = (y2 - y1) / (x2 - x1) 14 | b = y1 - k * x1 15 | print("y = {}x + {}".format(k, b)) 16 | -------------------------------------------------------------------------------- /Linear/ejercicio7.py: -------------------------------------------------------------------------------- 1 | # Se da una pequeña letra en inglés. determinar su número ordinal en el alfabeto 2 | 3 | letra = input("Introduce una letra en minúscula: ") 4 | number = ord(letra) - ord("a") + 1 5 | 6 | print("El número ordinal de la letra {} es: {}".format(letra, number)) 7 | -------------------------------------------------------------------------------- /Linear/ejercicio8.py: -------------------------------------------------------------------------------- 1 | # Se dan los límites de los rangos. producir números aleatorios dentro de los límites especificados. 2 | 3 | from random import randint, random 4 | 5 | print("Generar números aleatorios dentro de los límites especificados") 6 | print("---------------------------------------------------------------") 7 | imin = int(input("Introduce el límite inferior: ")) 8 | imax = int(input("Introduce el límite superior: ")) 9 | 10 | print("Número aleatorio entre {} y {}: {}".format(imin, imax, randint(imin, imax))) 11 | 12 | fmin = float(input("Introduce el límite inferior: ")) 13 | fmax = float(input("Introduce el límite superior: ")) 14 | 15 | print("Número aleatorio entre {} y {}: {}".format(fmin, fmax, random() * (fmax - fmin) + fmin)) 16 | -------------------------------------------------------------------------------- /Linear/ejercicio9.py: -------------------------------------------------------------------------------- 1 | # Se ingresa un par de números binarios. realice operaciones bit a bit "AND" "OR" "EXCLUSIVE OR" en ellos. mostrar el resultado en la pantalla. 2 | 3 | bin1 = input("Introduce el primer número binario: ") 4 | bin2 = input("Introduce el segundo número binario: ") 5 | 6 | num1 = int(bin1, 2) 7 | num2 = int(bin2, 2) 8 | 9 | print("Operaciones bit a bit en {} y {}".format(bin1, bin2)) 10 | print("-------------------------------------------------") 11 | print("AND: {}".format(bin(num1 & num2)[2:])) 12 | print("OR: {}".format(bin(num1 | num2)[2:])) 13 | print("EXCLUSIVE OR: {}".format(bin(num1 ^ num2)[2:])) 14 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 🚀 Pruebas Técnicas en Python 2 | 3 | ¡Bienvenido al repositorio de **Pruebas Técnicas en Python**! Aquí encontrarás una colección de ejercicios técnicos resueltos en Python, organizados en diferentes categorías. Este repositorio es perfecto para mejorar tus habilidades de programación y prepararte para entrevistas técnicas. 4 | 5 | ## 📂 Estructura del Proyecto 6 | 7 | El proyecto está organizado en las siguientes carpetas: 8 | 9 | - **📊 Arrays**: Ejercicios relacionados con arreglos y matrices. 10 | - **📐 Linear**: Problemas lineales y geométricos. 11 | - **🔤 String**: Manipulación y procesamiento de cadenas de texto. 12 | - **🔀 Variado**: Una mezcla de problemas diversos. 13 | 14 | ## 📜 Ejercicios Destacados 15 | 16 | ### 📊 Arrays 17 | 18 | - **🔍 Contiene Duplicados**: Verifica si una matriz contiene elementos duplicados. 19 | - **🗑️ Eliminar Duplicados**: Elimina duplicados de una matriz ordenada. 20 | - **🔄 Girar Matriz**: Rota una matriz hacia la derecha en `k` pasos. 21 | - **✔️ Sudoku**: Valida si un tablero de Sudoku es válido. 22 | 23 | ### 📐 Linear 24 | 25 | - **🌍 Ejercicio 1**: Calcula el número de días por año en un planeta dado su radio orbital y velocidad. 26 | - **📏 Ejercicio 3**: Calcula el área y perímetro de un triángulo dados sus catetos. 27 | 28 | ### 🔤 String 29 | 30 | - **🔠 Anagrama**: Verifica si dos cadenas son anagramas. 31 | - **🔁 Es Palíndromo**: Determina si una cadena es un palíndromo. 32 | - **🔍 Devolver Índice**: Encuentra el índice de la primera aparición de una subcadena. 33 | 34 | ### 🔀 Variado 35 | 36 | - **🎲 Adivina Número**: Simula el juego de adivinar un número. 37 | - **🪙 Cara o Cruz**: Simula el juego de cara o cruz. 38 | - **🔢 Fibonacci**: Calcula el número de Fibonacci en una posición `n`. 39 | 40 | ## 🚀 Cómo Empezar 41 | 42 | 1. **Clona el repositorio**: 43 | ```sh 44 | git clone https://github.com/miguelASL/Pruebas_Tecnicas_Python.git 45 | ``` 46 | 47 | 2. **Navega a la carpeta del proyecto**: 48 | ```sh 49 | cd Pruebas_Tecnicas_Python 50 | ``` 51 | 52 | 3. **Ejecuta los scripts**: 53 | ```sh 54 | python Arrays/Contiene_Duplicados-.py 55 | ``` 56 | 57 | ## 🤝 Contribuciones 58 | 59 | ¡Las contribuciones son bienvenidas! Si tienes una solución mejor o un nuevo ejercicio, no dudes en hacer un fork del repositorio y enviar un pull request. 60 | 61 | ## 📄 Licencia 62 | 63 | Este proyecto está bajo la Licencia MIT. Consulta el archivo LICENSE para más detalles. 64 | 65 | --- 66 | 67 | ¡Gracias por visitar este repositorio! Si te ha sido útil, no olvides darle una estrella ⭐ en GitHub. 68 | -------------------------------------------------------------------------------- /String/Anagrama.py: -------------------------------------------------------------------------------- 1 | """Dadas dos cadenas sy t, devuelve true si t es un anagrama de s, y false en caso contrario . 2 | Un anagrama es una palabra o frase formada reorganizando las letras de una palabra o frase diferente, normalmente usando todas las letras originales exactamente una vez. 3 | 4 | Ejemplo 1: 5 | Entrada: s = "anagrama", t = "nagaram" 6 | Salida: verdadero 7 | """ 8 | 9 | #Solucion 10 | class Solution(object): 11 | def isAnagram(self, s, t): 12 | return sorted(s) == sorted(t) 13 | 14 | # Ejemplo de uso 15 | sol = Solution() 16 | s = "anagram" 17 | t = "nagaram" 18 | result = sol.isAnagram(s, t) 19 | print(result) # Expected output: True -------------------------------------------------------------------------------- /String/Cadena_A_Entero.py: -------------------------------------------------------------------------------- 1 | """Implemente la myAtoi(string s)función, que convierte una cadena en un entero con signo de 32 bits (similar a la atoifunción de C/C++). 2 | 3 | El algoritmo para myAtoi(string s)es el siguiente: 4 | 5 | Lea e ignore cualquier espacio en blanco inicial. 6 | Compruebe si el siguiente carácter (si no está al final de la cadena) es '-'o '+'. Lea este personaje si lo es. Esto determina si el resultado final es negativo o positivo respectivamente. Suponga que el resultado es positivo si ninguno de los dos está presente. 7 | Lea a continuación los caracteres hasta llegar al siguiente carácter que no sea un dígito o al final de la entrada. El resto de la cadena se ignora. 8 | Convierta estos dígitos en un número entero (es decir "123" -> 123, "0032" -> 32). Si no se leyeron dígitos, entonces el número entero es 0. Cambie el letrero según sea necesario (desde el paso 2). 9 | Si el número entero está fuera del rango de enteros con signo de 32 bits , entonces fije el número entero para que permanezca en el rango. Específicamente, los números enteros menores que se deben fijar a , y los enteros mayores que se deben fijar a .[-231, 231 - 1]-231-231231 - 1231 - 1 10 | Devuelve el número entero como resultado final. 11 | Nota: 12 | 13 | Sólo el carácter de espacio ' 'se considera un carácter de espacio en blanco. 14 | No ignore ningún carácter que no sea el espacio en blanco inicial o el resto de la cadena después de los dígitos. 15 | 16 | 17 | Ejemplo 1: 18 | 19 | Entrada: s = "42" 20 | Salida: 42 21 | Explicación: Los caracteres subrayados son lo que se lee, el cursor es la posición actual del lector. 22 | Paso 1: "42" (no se leen caracteres porque no hay espacios en blanco al principio) 23 | ^ 24 | Paso 2: "42" (no se leen caracteres porque no hay '-' ni '+') 25 | ^ 26 | Paso 3: " 42 " (" Se lee 42") 27 | ^ 28 | El número entero analizado es 42. 29 | Dado que 42 está en el rango [-2 31 , 2 31 - 1], el resultado final es 42.""" 30 | 31 | # Respuesta 32 | 33 | class Solution(object): 34 | def myAtoi(self, s): 35 | # Elimina los espacios en blanco al principio y al final de la cadena 36 | s = s.strip() 37 | 38 | # Si la cadena está vacía, devuelve 0 39 | if not s: 40 | return 0 41 | 42 | # Asume que el número es positivo 43 | sign = 1 44 | 45 | # Si el primer carácter es un signo negativo, actualiza el signo y elimina el signo de la cadena 46 | if s[0] == '-': 47 | sign = -1 48 | s = s[1:] 49 | # Si el primer carácter es un signo positivo, simplemente elimina el signo de la cadena 50 | elif s[0] == '+': 51 | s = s[1:] 52 | 53 | # Inicializa el resultado como 0 54 | res = 0 55 | 56 | # Itera sobre los caracteres de la cadena 57 | for c in s: 58 | # Si el carácter es un dígito, lo añade al resultado 59 | if c.isdigit(): 60 | res = res * 10 + int(c) 61 | # Si el carácter no es un dígito, termina el bucle 62 | else: 63 | break 64 | 65 | # Aplica el signo al resultado 66 | res = sign * res 67 | 68 | # Si el resultado es mayor que el máximo entero de 32 bits, devuelve el máximo entero de 32 bits 69 | if res > 2 ** 31 - 1: 70 | return 2 ** 31 - 1 71 | # Si el resultado es menor que el mínimo entero de 32 bits, devuelve el mínimo entero de 32 bits 72 | elif res < -2 ** 31: 73 | return -2 ** 31 74 | # Si no, devuelve el resultado 75 | else: 76 | return res 77 | 78 | sol = Solution() 79 | print(sol.myAtoi("-123")) # Debería imprimir -123 80 | print(sol.myAtoi("4193 with words")) # Debería imprimir 4193 81 | print(sol.myAtoi("words and 987")) # Debería imprimir 0 82 | print(sol.myAtoi("-91283472332")) # Debería imprimir -2147483648 porque es menor que el mínimo entero de 32 bits -------------------------------------------------------------------------------- /String/Caracter_Unico.py: -------------------------------------------------------------------------------- 1 | """Dada una cadena s, busque el primer carácter no repetido que contenga y devuelva su índice . Si no existe, regresa -1. 2 | 3 | Entrada: s = "aabb" 4 | Salida: -1 5 | """ 6 | 7 | # Respuesta 8 | 9 | class Solution(object): 10 | def firstUniqChar(self, s): 11 | # Recorremos la cadena 's' utilizando índices 12 | for i in range(len(s)): 13 | # Verificamos si el carácter actual 's[i]' aparece solo una vez en la cadena 14 | if s.count(s[i]) == 1: 15 | # Si es así, devolvemos el índice actual como la primera posición única 16 | return i 17 | # Si no se encuentra ningún carácter único, devolvemos -1 18 | return -1 19 | 20 | # Ejemplo de prueba 21 | # Creamos una instancia de la clase Solution 22 | sol = Solution() 23 | 24 | # Probamos la función con una cadena de ejemplo 25 | input_str = "leetcode" 26 | result = sol.firstUniqChar(input_str) 27 | 28 | # Imprimimos el resultado 29 | print(f"La primera posición única en '{input_str}' es: {result}") -------------------------------------------------------------------------------- /String/Devolver_Indice.py: -------------------------------------------------------------------------------- 1 | """Dadas dos cadenas needley haystack, devuelve el índice de la primera aparición de needleen haystack, o -1 si needleno forma parte de haystack. 2 | 3 | Ejemplo 1: 4 | 5 | Entrada: haystack = "sadbutsad", needle = "sad" 6 | Salida: 0 7 | Explicación: "sad" ocurre en los índices 0 y 6. 8 | La primera aparición está en el índice 0, por lo que devolvemos 0. 9 | """ 10 | 11 | # Respuesta 12 | 13 | class Solution(object): 14 | def strStr(self, haystack, needle): 15 | # Si needle es una cadena vacía, devuelve 0 16 | if not needle: 17 | return 0 18 | 19 | # Si needle no está en el haystack, devuelve -1 20 | if needle not in haystack: 21 | return -1 22 | 23 | # Devuelve el índice de la primera aparición de la needle en el haystack 24 | return haystack.index(needle) 25 | 26 | 27 | sol = Solution() 28 | print(sol.strStr("sadbutsad", "sad")) # Debería imprimir 0 29 | print(sol.strStr("hello", "ll")) # Debería imprimir 2 30 | print(sol.strStr("aaaaa", "bba")) # Debería imprimir -1 31 | print(sol.strStr("", "")) # Debería imprimir 0 -------------------------------------------------------------------------------- /String/Entero_inverso.py: -------------------------------------------------------------------------------- 1 | """Dado un entero de 32 bits con signo x, regresa xcon sus dígitos invertidos . Si la inversión xhace que el valor salga del rango de enteros de 32 bits con signo , entonces devuelva .[-231, 231 - 1]0 2 | 3 | Suponga que el entorno no le permite almacenar enteros de 64 bits (con o sin signo) 4 | """ 5 | 6 | # Solucion 7 | 8 | class Solution(object): 9 | def reverse(self, x): 10 | INT_MAX = 2**31 - 1 11 | INT_MIN = -2**31 12 | 13 | # Manejar el signo del número 14 | sign = 1 if x >= 0 else -1 15 | x *= sign 16 | 17 | # Invertir los dígitos 18 | reversed_x = 0 19 | while x != 0: 20 | digit = x % 10 21 | x //= 10 22 | 23 | # Verificar desbordamiento antes de multiplicar por 10 24 | if reversed_x > (INT_MAX - digit) // 10: 25 | return 0 26 | 27 | reversed_x = reversed_x * 10 + digit 28 | 29 | return reversed_x * sign 30 | 31 | # Ejemplo de uso: 32 | sol = Solution() 33 | num = 123 34 | result = sol.reverse(num) 35 | print(result) -------------------------------------------------------------------------------- /String/Es_Palindromo.py: -------------------------------------------------------------------------------- 1 | """Una frase es un palíndromo si, después de convertir todas las letras mayúsculas en minúsculas y eliminar todos los caracteres no alfanuméricos, se lee igual hacia adelante y hacia atrás. Los caracteres alfanuméricos incluyen letras y números. 2 | Dada una cadena s, devuelve truesi es un palíndromo , o falseen caso contrario . 3 | 4 | Ejemplo 1: 5 | Entrada: s = "Un hombre, un plan, un canal: Panamá" 6 | Salida: verdadero 7 | Explicación: "amanaplanacanalpanama" es un palíndromo. 8 | 9 | Ejemplo 2: 10 | Entrada: s = "carrera de autos" 11 | Salida: falso 12 | Explicación: "carrera de autos" no es un palíndromo. 13 | 14 | Ejemplo 3: 15 | Entrada: s = " " 16 | Salida: verdadero 17 | Explicación: s es una cadena vacía "" después de eliminar caracteres no alfanuméricos. 18 | Dado que una cadena vacía se lee igual hacia adelante y hacia atrás, es un palíndromo. 19 | 20 | Restricciones: 21 | 1 <= s.length <= 2 * 105 22 | sconsta únicamente de caracteres ASCII imprimibles.""" 23 | 24 | #RESULTADO 25 | 26 | class Solution(object): 27 | def isPalindrome(self, s): 28 | s = ''.join(c.lower() for c in s if c.isalnum()) 29 | return s==s[::-1] -------------------------------------------------------------------------------- /String/Palabra_Invertida.py: -------------------------------------------------------------------------------- 1 | """Escribe una función que invierta una cadena. La cadena de entrada se proporciona como una matriz de caracteres s. 2 | Debe hacer esto modificando la matriz de entrada in situ con O(1)memoria adicional. 3 | 4 | Ejemplo 1: 5 | Entrada: s = ["h","e","l","l","o"] 6 | Salida: ["o","l","l","e","h"] 7 | """ 8 | 9 | #RESULTADO 10 | 11 | class Solution(object): 12 | def reverseString(self, s): 13 | return s.reverse() 14 | 15 | # Uso de ejemplo: 16 | cadena_original = ["h", "e", "l", "l", "o"] 17 | sol = Solution() 18 | sol.reverseString(cadena_original) 19 | print(cadena_original) -------------------------------------------------------------------------------- /String/Prefijo_Común_Más_Largo.py: -------------------------------------------------------------------------------- 1 | """Escriba una función para encontrar la cadena de prefijo común más larga entre una matriz de cadenas. 2 | Si no hay un prefijo común, devuelve una cadena vacía "". 3 | 4 | Ejemplo 1: 5 | Entrada: strs = ["flor","flujo","vuelo"] 6 | Salida: "fl 7 | """ 8 | 9 | # Respuesta 10 | 11 | class Solution(object): 12 | def longestCommonPrefix(self, strs): 13 | # Si no hay cadenas en la lista, devuelve una cadena vacía 14 | if not strs: 15 | return "" 16 | 17 | # Ordena la lista de cadenas 18 | strs.sort() 19 | 20 | # La cadena más corta en la lista es el primer elemento 21 | # La cadena más larga en la lista es el último elemento 22 | # Estos dos elementos son los que más difieren 23 | first = strs[0] 24 | last = strs[-1] 25 | 26 | # Encuentra el prefijo común más largo entre la primera y la última cadena 27 | prefix = "" 28 | for i in range(len(first)): 29 | if first[i] == last[i]: 30 | prefix += first[i] 31 | else: 32 | break 33 | 34 | # Devuelve el prefijo común más largo 35 | return prefix 36 | 37 | sol = Solution() 38 | 39 | # Ejemplo 1: ["flower","flow","flight"] 40 | # El prefijo común más largo es "fl" 41 | print(sol.longestCommonPrefix(["flower","flow","flight"])) # Debería imprimir "fl" 42 | 43 | # Ejemplo 2: ["dog","racecar","car"] 44 | # No hay un prefijo común, por lo que se devuelve una cadena vacía 45 | print(sol.longestCommonPrefix(["dog","racecar","car"])) # Debería imprimir "" 46 | 47 | # Ejemplo 3: ["interspecies","interstellar","interstate"] 48 | # El prefijo común más largo es "inters" 49 | print(sol.longestCommonPrefix(["interspecies","interstellar","interstate"])) # Debería imprimir "inters" -------------------------------------------------------------------------------- /variado/adivina_numero.py: -------------------------------------------------------------------------------- 1 | """ 2 | Simula el juego de adivinar un número 3 | """ 4 | 5 | import random 6 | 7 | ordenador = random.randint(1, 100) 8 | intentos = 0 9 | 10 | while True: 11 | usuario = int(input("Introduce un número: ")) 12 | intentos += 1 13 | if usuario < ordenador: 14 | print("El número es mayor") 15 | elif usuario > ordenador: 16 | print("El número es menor") 17 | else: 18 | print("¡Has acertado!") 19 | print(f"Has necesitado {intentos} intentos") 20 | break 21 | -------------------------------------------------------------------------------- /variado/aprender_a_sumar.py: -------------------------------------------------------------------------------- 1 | """ 2 | Haz un programa para aprender a sunmar en poco tiempo 3 | """ 4 | 5 | import time 6 | import random 7 | 8 | acierto = 0 9 | 10 | tiempo_inicio = time.time() 11 | 12 | for i in range(5): 13 | numero_1 = random.randint(1, 10) 14 | numero_2 = random.randint(1, 10) 15 | correcto = numero_1 + numero_2 16 | 17 | respuesta = int(input(f"cuánto es {numero_1} + {numero_2}? ")) 18 | if respuesta == correcto: 19 | print("Correcto!") 20 | acierto += 1 21 | else: 22 | print(f"Incorrecto. La respuesta es {correcto}") 23 | 24 | tiempo_final = time.time() 25 | print(f" has tardado {tiempo_final - tiempo_inicio} segundos") 26 | print(f"Has acertado {acierto} veces") -------------------------------------------------------------------------------- /variado/cara_o_cruz.py: -------------------------------------------------------------------------------- 1 | """ 2 | Simula erl juego de cara o cruz 3 | """ 4 | import random 5 | opciones = ["cara", "cruz"] 6 | usuario = input("Elige cara o cruz: ").lower() 7 | 8 | if usuario not in opciones: 9 | print("Opción no válida") 10 | quit() 11 | else: 12 | maquina = random.choice(opciones) 13 | print(f"La máquina ha elegido {maquina}") 14 | 15 | if usuario == maquina: 16 | print("Has ganado!") 17 | else: 18 | print("Has perdido") -------------------------------------------------------------------------------- /variado/contar_recusividad.py: -------------------------------------------------------------------------------- 1 | """ 2 | Haz una función que sume los primeros 'n' números utilizados recursividad 3 | """ 4 | 5 | def sumar_recusiva(n): 6 | if n == 0: 7 | return 0 8 | else: 9 | return n + sumar_recusiva(n - 1) -------------------------------------------------------------------------------- /variado/cuenta_lineas.py: -------------------------------------------------------------------------------- 1 | """ 2 | Haz una funcion que cuente las palabras de un archivo de texto 3 | """ 4 | 5 | def cuenta_lineas(archivo): 6 | with open(archivo, 'r') as f: 7 | data = f.read() 8 | return len(data.split()) 9 | -------------------------------------------------------------------------------- /variado/diferencia_maxima.py: -------------------------------------------------------------------------------- 1 | """ 2 | Haz una funcion que devuelva la diferencia máxima entre dos números de una lista 3 | """ 4 | 5 | def diferencia_maxima(lista): 6 | if len(lista) == 0: 7 | return 0 8 | lista.sort() 9 | min = lista[0] 10 | max = lista[-1] 11 | return max - min -------------------------------------------------------------------------------- /variado/factorial.py: -------------------------------------------------------------------------------- 1 | """ 2 | Haz una funcion que devuelva el factorial de un número 3 | """ 4 | 5 | def factorial(n): 6 | if n == 1: 7 | return 1 8 | return n * factorial(n-1) 9 | 10 | print(factorial(5)) 11 | -------------------------------------------------------------------------------- /variado/fibonacci.py: -------------------------------------------------------------------------------- 1 | """ 2 | Funcion que devuelva el numero de la sucecion de fibonacci en la posicion n 3 | """ 4 | 5 | def fibonacci(n): 6 | if n == 0: 7 | return 0 8 | if n == 1: 9 | return 1 10 | fibo = [0, 1] 11 | for i in range(2, n): 12 | fibo.append(fibo[-1] + fibo[-2]) 13 | return fibo[-1] 14 | 15 | print(fibonacci(10)) -------------------------------------------------------------------------------- /variado/numero_primo.py: -------------------------------------------------------------------------------- 1 | """ 2 | Haz una funcion que devuleva si un numero es primo o no 3 | """ 4 | def primo(n): 5 | for i in range(2, n): 6 | if n % i == 0: 7 | return False 8 | return True 9 | 10 | print(primo(7)) 11 | print(primo(10)) -------------------------------------------------------------------------------- /variado/palabras_en_frase.py: -------------------------------------------------------------------------------- 1 | """ 2 | Haz una funcion que pida una frase y cuente cuantas palabras tiene 3 | """ 4 | 5 | def contar(): 6 | frase = input("Escribe una frase: ") 7 | palabras = frase.split() 8 | return len(palabras) 9 | 10 | print(contar()) -------------------------------------------------------------------------------- /variado/tabla_multiplicar.py: -------------------------------------------------------------------------------- 1 | """ 2 | Imprime la tabla de un numero n 3 | """ 4 | 5 | n = int(input) 6 | for i in range(1, 11): 7 | print(f"{n} x {i} = {n * i}") --------------------------------------------------------------------------------