Ejercicios

Estos son algunos ejercicios que pueden realizarse para practicar lo aprendido en el tema de Minería de Datos, sobre el uso de las bibliotecas NumPy, Pandas, Matplotlib y Seaborn desde Python.

1. Crea una matriz NumPy de 100 * 3 con coordenadas (x, y, z) generadas aleatoriamente para 100 enemigos en el rango [-50, 50] en X y Z, y Y=0. Aplica una transformación vectorizada sin bucles para calcular la distancia euclídea de cada enemigo al origen (0,0,0) y filtra los índices de los enemigos que están a un radio menor de 15 unidades.
2. Dado un array NumPy de 5 * 4 que representa 5 personajes con 4 atributos reales (Vida [100-500], Ataque [10-50], Defensa [5-30], Velocidad [1-10]), aplica Escalado Min-Max mediante difusión (broadcasting) para normalizar todas las características al rango [0, 1] sin usar bucles for.
3. Genera un vector 2D normalizado que represente la dirección hacia la que mira un jugador (ej. [0, 1]) y una matriz de 50 * 2 con las direcciones hacia 50 PNJs en el mapa. Utiliza el producto escalar vectorizado (np.dot ó @) para calcular el coseno del ángulo entre el jugador y cada PNJ, determinando cuáles están dentro de un cono de visión de 90º (su coseno es mayor o igual que el coseno de 45º).
4. Crea una rejilla (grid) de 10 * 10 que represente el mapa de calor del daño de una explosión. Asigna valores aleatorios de daño. Define una zona central de 4 * 4 usando corte (slicing) e incrementa su daño en un +50%. Finalmente, reemplaza con 0 cualquier celda de la rejilla donde el daño final sea inferior a un umbral de 10 puntos mediante una máscara booleana.
5. Crea un DataFrame de Pandas ficticio con 20 ítems de un RPG (columnas: nombre, tipo [arma/armadura/pocion], rareza [comun/raro/legendario], precio_oro, nivel_minimo). Filtra y muestra solo las armas de rareza ‘legendario’ que requieran un nivel mínimo menor o igual a 15 y tengan un coste superior a 500 monedas.
6. Genera un DataFrame simulando los registros (logs) de red de 30 partidas con las columnas: player_id, ping_ms, y loss_percentage. Introduce intencionadamente valores nulos (np.nan) y filas duplicadas. Realiza la limpieza correspondiente: elimina duplicados, imputa los valores nulos del ping con la mediana global y convierte la columna ping_ms a tipo entero (int64).
7. Crea un DataFrame de una sesión de shooter táctico con las columnas bajas, muertes, asistencias y dano_total para 15 jugadores. Crea dos columnas calculadas: la tasa de bajas, muertes y asistencias (Kills, Deaths, Assists (KDA) Ratio) que se calcula así: (bajas + asistencias) / max(1, muertes) y el daño medio por baja: (dano_total / max(1, bajas)).
8. Genera un DataFrame ficticio de telemetría de juego con 1000 filas (datos de FPS, uso de GPU y memoria RAM). Guárdalo en un archivo CSV local, vuelve a leerlo seleccionando únicamente las columnas de rendimiento técnico e imprime un resumen estadístico global utilizando describe.
9. Define una función matemática para la experiencia requerida por nivel (XP = 100 * nivel^1.5) para niveles del 1 al 50. Utiliza plt.plot para representar la curva de progresión, añade líneas discontinuas para marcar los niveles «hito» (10, 25 y 50) y personaliza títulos, etiquetas de ejes y leyenda.
10. Simula una lista de 500 duraciones de partida en minutos siguiendo una distribución normal (media 20 min., desviación 5 min.). En una misma figura con dos subplots (plt.subplots(1, 2)), dibuja un histograma de frecuencias a la izquierda y un diagrama de caja (boxplot) a la derecha para detectar posibles partidas atípicamente largas o cortas, es decir, valores atípicos (outliers).
11. Crea un gráfico de barras horizontal que compare la tasa de victorias (Win Rate) media de 5 arquetipos de personaje (Tanque, Asesino, Mago, Soporte, Tirador). Pinta en verde las barras que superen el 50% y en rojo o gris las que estén por debajo, añadiendo el valor exacto como texto sobre cada barra.
12. Dado un DataFrame con datos de 200 partidas (columnas: modo_juego [Solo, Duo, Squad], duracion_seg, puntuacion, victoria), utiliza groupby(‘modo_juego’) junto con agg para calcular -en una sola llamada- el tiempo medio de partida, la puntuación máxima y el porcentaje global de victorias por cada modo.
13. Dado un DataFrame con las horas jugadas y el gasto en microtransacciones (en euros) de 50 usuarios, escribe una función personalizada y aplícala con apply para categorizar a los jugadores en cuatro perfiles: ‘Free-to-Play’, ‘Casual Payer’, ‘Whale’ (las ballenas son jugadores de alto gasto) o ‘Hardcore F2P’.
14. Genera un registro ficticio de 100 partidas 1v1 con las columnas personaje_A, personaje_B y resultado (1 si gana A, 0 si gana B). Construye una tabla dinámica como las de las hojas de cálculo de Google (en Pandas, pd.pivot_table) que muestre en filas el personaje A, en columnas el personaje B y en el contenido la tasa de victorias (Win Rate) promedio de A contra B.
15. Dado un DataFrame con marcas de tiempo (timestamp) de inicio de sesión de jugadores durante un mes, convierte la columna a datetime. Extrae el día de la semana y la hora del día usando el accesor .dt, y agrupa los datos para determinar cuáles son los días y franjas horarias con mayor afluencia de usuarios en el juego.
16. Toma la tabla dinámica de enfrentamientos del ejercicio 14 (o genera una matriz de 5 * 5 de tasa de victoria) y represéntala mediante un mapa de calor (sns.heatmap). Configura la paleta de colores divergente (coolwarm), fuerza el centro del mapa de calor en 0.5 (balance perfecto) y muestra los porcentajes exactos dentro de cada celda (annot=True).
17. Genera un DataFrame con métricas de comportamiento de 100 jugadores (kda, oro_minuto, vision_score, puntos_liga). Calcula la matriz de correlación de Pearson y represéntala visualmente. Adicionalmente, utiliza una matriz de gráficos de dispersión coloreada por categoría (scatter plot matrix, o en Seaborn sns.pairplot) asignando como tono/color (hue) si el jugador es de rango ‘Alto’ o ‘Bajo’.
18. Simula datos de tiempo de juego diario para usuarios en tres plataformas (PC, Console, Mobile). Utiliza un gráfico de violín (sns.violinplot) o un gráfico de caja (sns.boxplot) con o sin bigotes con ajuste de tono (hue) por tipo de usuario (Nuevo vs Veterano) para comparar gráficamente cómo se distribuye el compromiso del jugador según la plataforma.
19. Descarga o lee mediante URL el famoso conjunto de datos de ventas de videojuegos de Kaggle/GitHub Video Game Sales (fichero CSV disponible en GitHub). Carga el conjunto de datos en Pandas, filtra las publicaciones desde el año 2000 en adelante, agrupa por Genre y Platform, y calcula las ventas globales totales (Global_Sales). Muestra un gráfico de barras (sns.barplot en Seaborne) con los 5 géneros más vendidos históricamente en las plataformas de Nintendo vs. PlayStation.
20. Utiliza el conjunto de datos público de las primeras partidas de 10 minutos de League of Legends en rango Diamante llamado League of Legends Diamond Ranked Games (10 min). Carga los datos e investiga qué características de los primeros 10 minutos (diferencia de oro blueGoldDiff, primera sangre blueFirstBlood, dragones blueDragons) tienen mayor correlación con la victoria final del equipo azul (blueWins). Representa la relación entre la diferencia de oro a min. 10 y la probabilidad de victoria usando una gráfica de regresión con línea de regresión (sns.regplot).