Problemas de codificación intermedios en Python

Python, al ser un lenguaje de programación muy dinámico y versátil, se utiliza en casi todos los campos. Desde el desarrollo de software hasta el aprendizaje automático, los cubre todos. Este artículo se centrará en algunos problemas de codificación interesantes que se pueden usar para mejorar un poco más nuestras habilidades y, al mismo tiempo, divertirnos resolviendo esta lista de problemas especialmente seleccionados. Aunque este artículo se centrará en resolver estos problemas usando Python, uno puede sentirse libre de usar cualquier otro lenguaje de su elección. ¡Así que vamos directamente a eso!

Teorema del mono infinito

El teorema establece que un mono que golpea las teclas al azar en el teclado de una máquina de escribir durante una cantidad infinita de tiempo seguramente escribirá un texto determinado, como las obras completas de William Shakespeare. Bueno, supongamos que reemplazamos un mono con una función de Python. ¿Cuánto tiempo le tomaría a una función de Python generar solo una oración? La frase que elegiremos es: “un portal de informática para geeks”. 
La forma en que simularemos esto es escribir una función que genere una string de 35 caracteres de largo eligiendo letras al azar de las 26 letras del alfabeto más espacio. Escribiremos otra función que puntuará cada string generada comparando la string generada aleatoriamente con el objetivo. Una tercera función llamará repetidamente a generar y puntuar, luego, si el 100% de las letras son correctas, hemos terminado. Si las letras no son correctas, generaremos una string completamente nueva. Para que sea más fácil de seguir, nuestro programa debe realizar un seguimiento de la mejor string generada hasta el momento.

Ejemplo: 

import random
   
   
# function to generate 
# a random string 
def generateOne(strlen): 
       
    # string with all the alphabets
    # and a space
    alphabet = "abcdefghijklmnopqrstuvwxyz "
    res =""
       
    for i in range(strlen):
        res+= alphabet[random.randrange(27)]
           
    return res
   
# function to determine the 
# score of the generated string
def score(goal, testString): 
    numSame = 0
       
    for i in range(len(goal)):
        if goal[i] == testString[i]:
            numSame+= 1
               
    return numSame / len(goal)
   
# main function to call the previous
# two functions until the goal is achieved
def main(): 
    goalString = "a computer science portal for geeks"
    newString = generateOne(35)
    best = 0
    newScore = score(goalString, newString)
       
    while newScore<1:
        if newScore>best:
            print(newString)
            best = newScore
        newString = generateOne(35)
        newScore = score(goalString, newString)
   
# Driver code
main()

Producción:

pxwvkdfwpbzneycy rifcrnczxqtsfowgjm
wfgytnakffjty ggfy trylljfhurazyxow
docujzolvswarzqszridmejyluhwviujlkj
 qbtvqanrbwsximmnlhjgkaacufhskiooxm
w jnlhvvinzrlimtesllsroqqqf wwteela
mjcevludro yoigewqudxjsad bxrl qnlv
f pomksbzrjizegcjwyoqftjz wwx   ges

Aquí, escribimos tres funciones. Uno generará una string aleatoria usando los 26 caracteres del alfabeto y el espacio. La segunda función luego calificará la string generada comparando cada letra con la string de meta. La tercera función llamará repetidamente a las dos primeras funciones hasta que se complete la tarea. También tomará nota de la mejor string generada hasta el momento comparando sus puntajes. El que tenga la puntuación más alta será el mejor. Finalmente, ejecutamos este programa en nuestro IDE y lo vemos funcionar. 

El dilema de las substrings

Este es un programa realmente interesante ya que genera algunos resultados realmente divertidos. También es un problema de práctica saludable para los principiantes que quieren entender más claramente el tipo de «cuerda». Analicemos el problema.
Dada una string, busque una substring según las siguientes condiciones: 

• La substring debe ser la más larga de todas las posibles substrings en la string dada. 
• No debe haber ningún carácter repetido en la substring. 
• Si hay más de una substring que cumple las dos condiciones anteriores, imprima la substring que aparece primero. 
• Si no hay una substring que satisfaga todas las condiciones antes mencionadas, imprima -1. 

Aunque puede haber muchos métodos para abordar este problema, veremos el más básico.

Ejemplo: 

def test_1(string =""):
       
    # initializing the substring
    substring = "" 
    testList = []
    initial = 0
       
    for char in string:
           
        for i in range(initial, len(string)):
            substring+= string[i]
               
            # checking conditions
            if substring.count(string[i])>1:
                testList.append(substring[:-1])
                initial+= 1
                substring = ""
                break
    maxi =""
       
    for word in testList:
           
        if len(word)>len(maxi):
            maxi = word
               
    if len(maxi)<3:
        return "-1"
    else:
        return maxi
       
# Driver code
print(test_1("character"))
print(test_1("standfan"))
print(test_1("class"))

Aquí, escribimos una sola función que llevará a cabo toda la tarea. Primero, inicializará variables llamadas substring y testList para almacenar la substring y una lista de posibles salidas, respectivamente. Luego, recorrerá toda la string proporcionada y se interrumpirá cada vez que encuentre una repetición y agregue esa palabra a testList. Finalmente, se devuelve la palabra más larga de las posibles salidas.

Producción: 

racte
standf
clas 

Cerebro

Una implementación de bajo nivel del clásico juego «Mastermind». Necesitamos escribir un programa que genere un código aleatorio de cuatro dígitos y el usuario debe adivinar el código en 10 intentos o menos. Si algún dígito del código de cuatro dígitos adivinado es incorrecto, la computadora debe imprimir «B». Si el dígito es correcto pero está en el lugar equivocado, la computadora debe imprimir «Y». Si tanto el dígito como la posición son correctos, la computadora debe imprimir “R”. Ejemplo:

Ejemplo: 

import random
   
   
# generates a four-digit code
def gen_code(): 
    set_code = []
       
    for i in range(4):
        val = random.randint(0, 9)
        set_code.append(val)
           
    return set_code
       
# asks for input from the user
def input_code(): 
    code = input("Enter your four digit guess code: ")
    return code
   
   
# plays the game
def mastermind(): 
       
    genCode = gen_code()
    i = 0
       
    while i < 10:
        result = ""
        inputCode = [int(c) for c in input_code()]
           
        if len(inputCode) != 4:
            print("Enter only 4 digit number")
            continue
           
        if inputCode == genCode:
             print("You guessed it !", genCode)
             break
               
        for element in inputCode:
               
            if element in genCode:
                   
                if inputCode.index(element) == genCode.index(element):
                    result+="R"
                else:
                    result+="Y"
            else:
                result+="B"
        print(result)
           
        i += 1
    else:    
        print("You ran out of trys !", genCode)    
           
           
# Driver Code
mastermind()

Primero, escribimos una función para generar un código aleatorio de cuatro dígitos utilizando el módulo aleatorio de Python. A continuación, definimos una función que solicita la entrada del usuario. Finalmente, escribimos una función que compara el código generado con el código adivinado y da resultados apropiados. 

Catástrofe de dirección

Un problema muy simple con muchas soluciones diferentes, pero el objetivo principal es resolverlo de la manera más eficiente. A un hombre se le dieron instrucciones para ir del punto A al punto B. Las direcciones eran: «SUR», «NORTE», «OESTE», «ESTE». Claramente, «NORTE» y «SUR» son opuestos, «OESTE» y «ESTE» también. Ir en una dirección y regresar en la dirección opuesta es una pérdida de tiempo y energía. Entonces, necesitamos ayudar al hombre escribiendo un programa que elimine los pasos inútiles y contenga solo las instrucciones necesarias. 
Por ejemplo: Las direcciones [“NORTE”, “SUR”, “SUR”, “ESTE”, “OESTE”, “NORTE”, “OESTE”] deben reducirse a [“OESTE”]. Esto se debe a que ir al “NORTE” y luego inmediatamente al “SUR” significa volver al mismo lugar. Así que los cancelamos y tenemos [“SUR”, “ESTE”, “OESTE”, “NORTE”, “OESTE”]. A continuación, vamos al “SUR”, tomamos el “ESTE” y luego tomamos inmediatamente el “OESTE”, lo que nuevamente significa volver al mismo punto. Por lo tanto, cancelamos «ESTE» y «OESTE» para darnos [«SUR», «NORTE», «OESTE»]. Está claro que «SUR» y «NORTE» son opuestos, por lo que se cancelan y finalmente nos queda [«OESTE»].

Ejemplo: 

opposite = {'NORTH': 'SOUTH', 
            'EAST': 'WEST', 
            'SOUTH': 'NORTH', 
            'WEST': 'EAST'}
   
   
# Function to find the reduced
# direction
def dirReduc(givenDirections):
    finalDirections = []
       
    for d in range(0, len(givenDirections)):
           
        if finalDirections:
           
            if finalDirections[-1] == opposite[givenDirections[d]]:
                finalDirections.pop()
            else:
                finalDirections.append(givenDirections[d])
                   
        else:
            finalDirections.append(givenDirections[d])
               
    return finalDirections
   
# Driver Code
print(dirReduc(["NORTH", "SOUTH", "SOUTH", "EAST", "WEST", "NORTH", "WEST"]))

En la solución anterior, creamos un diccionario de opuestos para ayudarnos a determinar si una dirección determinada es opuesta a la otra. A continuación, inicializamos una variable llamada finalDirections que será nuestra salida. Si la dirección que está en las direcciones dadas es opuesta al último elemento en las direcciones finales, lo sacamos de las direcciones finales; de lo contrario, lo agregamos a las direcciones finales. 

Producción:

['WEST'] 

Comparando arreglos

Este problema ayuda a comprender los conceptos clave de una array (lista) en Python. Se dice que dos arreglos son iguales si contienen los mismos elementos y en el mismo orden. Sin embargo, en este problema, compararemos dos arreglos para ver si son iguales, pero con un ligero cambio. Aquí, dos arreglos son iguales si los elementos de un arreglo son cuadrados de elementos de otros arreglos y sin importar el orden. Considere dos arreglos a y b .

a = [121, 144, 19, 161, 19, 144, 19, 11] 
b = [121, 14641, 20736, 361, 25921, 361, 20736, 361]

Aquí b se puede escribir como: 

b = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19]

que es un cuadrado de cada elemento de a . Por lo tanto, son iguales. Si a o b son Ninguno, nuestro programa debería escribir Falso

Ejemplo: 

# function to compare the arrays
def comp(array1, array2):
       
    # checking if any array is None
    if array1 is None or array2 is None: 
        return False
       
    # checking if any of the array 
    # is a square of the other
    if (sorted(array1) == sorted([i ** 2 for i in array2])) or (sorted(array2) == sorted([i ** 2 for i in array1])): 
        return True
       
    return False
   
# Driver Code
comp([1,2,3,4], [1,4,9,16])

Producción:

True