Algoritmo de Caminata Aleatoria en Python: Clase Borracho

¿Cómo funciona la caminata aleatoria y cómo se implementa su algoritmo?

¡Bienvenidos a un fascinante viaje al mundo de los caminos aleatorios! Este concepto, conocido también como la "caminata del borracho", es un problema sencillo pero intrigante en el cual un objeto puede desplazarse en múltiples direcciones con igual probabilidad. Vamos a repasar cómo nosotros podemos implementar este modelo con clases en Python para simular estos movimientos aleatorios y representar el comportamiento en un plano cartesiano.

¿Qué es un camino aleatorio?

Un camino aleatorio comienza en un punto de origen y puede moverse en varias direcciones: arriba, abajo, izquierda, o derecha, con una probabilidad igual del 25% para cada dirección. Este proceso se repite en cada paso, llevando a infinitas posibilidades de recorrer diferentes trayectorias. Algunos aspectos interesantes de un camino aleatorio incluyen:

• Puede ser extendido a múltiples dimensiones, no solo en 2D, sino también en 3D, 5D, etc.
• Se pueden asignar probabilidades diferentes para cada movimiento.
• La distancia recorrida se calcula fácilmente mediante el teorema de Pitágoras.

¿Cómo podemos representar un borracho?

En el contexto del camino de borrachos, un borracho es una entidad que se mueve al azar en un plano. Implementamos la clase Borracho para abstraer el comportamiento de esta entidad.

class Borracho:
    def __init__(self, nombre):
        self.nombre = nombre

De esta manera, al extender Borracho, podemos crear subclases que modelen diferentes tipos de trayectorias y comportamientos. Un ejemplo de subclase es el BorrachoTradicional, quien se mueve aleatoriamente entre cuatro opciones: arriba, abajo, izquierda y derecha.

¿Cómo defino los movimientos del borracho?

Usamos la clase BorrachoTradicional para implementar esta lógica con la ayuda de la librería random de Python.

import random

class BorrachoTradicional(Borracho):
    def __init__(self, nombre):
        super().__init__(nombre)

    def camina(self):
        return random.choice([(0, 1), (0, -1), (1, 0), (-1, 0)])

Aquí random.choice se utiliza para seleccionar aleatoriamente una de las direcciones posibles, reflejando nuestro modelo de movimientos equiprobables.

¿Cómo manejamos las coordenadas y calculamos distancias?

Para gestionar la posición en el plano, creamos la clase Coordenada. Esta clase se encarga de las posiciones y desplazamientos del borracho.

import math

class Coordenada:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def mover(self, delta_x, delta_y):
        return Coordenada(self.x + delta_x, self.y + delta_y)

    def distancia(self, otra_coordenada):
        delta_x = self.x - otra_coordenada.x
        delta_y = self.y - otra_coordenada.y
        return math.sqrt(delta_x**2 + delta_y**2)

Aquí, utilizamos el teorema de Pitágoras para calcular la distancia entre dos puntos.

¿Cómo se representa el campo?

El campo es el espacio que contiene a los borrachos. Implementamos esto a través de la clase Campo, la cual permitirá añadir, mover, y consultar las coordenadas de nuestros "borrachos".

class Campo:
    def __init__(self):
        self.coordenadas_de_borrachos = {}

    def añadir_borracho(self, borracho, coordenada):
        self.coordenadas_de_borrachos[borracho] = coordenada

    def mover_borracho(self, borracho):
        delta_x, delta_y = borracho.camina()
        coordenada_actual = self.coordenadas_de_borrachos[borracho]
        nueva_coordenada = coordenada_actual.mover(delta_x, delta_y)
        self.coordenadas_de_borrachos[borracho] = nueva_coordenada

    def obtener_coordenada(self, borracho):
        return self.coordenadas_de_borrachos[borracho]

Con esto, ahora tenemos el framework necesario para implementar simulaciones complejas de caminos aleatorios. Estas clases nos ofrecen la flexibilidad para modelar diferentes escenarios de simulación.

¡Construye y observa tu simulación!

Con las bases listas, podemos avanzar hacia integrar todo en un solo programa. Esto te permitirá realizar experimentos con diferentes escenarios y parámetros, y observar cómo varía la distancia al origen a medida que aumenta el número de pasos. Este ejercicio no solo es útil para aprender sobre programación orientada a objetos, sino también sobre probabilidad y estadísticas. ¡Sigue experimentando y expandiendo tus conocimientos!