🧪 Simulacro de Examen – Programación II VJ1208 (Sin estructuras dinámicas)

Nombre:
DNI:

Ejercicio Único (10 puntos)

En un videojuego ambientado en una ciudad futurista, existen diferentes tipos de robots que patrullan zonas del mapa. Cada robot tiene energía, se mueve y puede realizar acciones específicas. Desarrolla el siguiente sistema:

Parte A – Clases y herencia (5 puntos)

1. Crea una clase Ciudad que representa el escenario, con límites XMax y YMax.
2. Crea una clase base Robot con:
   • Atributos x, y (posición), energia (int), y una referencia a la ciudad.
   • El constructor debe inicializar la posición en coordenadas aleatorias dentro de la ciudad y establecer la energía en 100.
   • Método Mover() que cambia aleatoriamente la posición entre -2 y 2 en ambos ejes, sin salirse del mapa, y resta 1 de energía.
   • Método virtual Actuar() que devuelve "".
3. Crea una clase RobotExplorador que sobrescriba Actuar() para devolver una de las siguientes frases aleatorias si tiene energía > 0:
   • "Explorando sector..."
   • "Escaneo ambiental en curso"
   • "Recolección de datos completada"
4. Crea una clase RobotGuardian que posee una lista de alertas (string).
   • Su método Actuar() devuelve y elimina aleatoriamente una alerta si hay alguna. Si no, devuelve "".

Parte B – Métodos globales (3 puntos)

5. Crea un método DescargarEnergia(List<Robot> robots, int x0, int y0, int rango) que reste 10 de energía a cada robot que esté a rango o menos de (x0, y0) (distancia Manhattan).
   • Los robots con energía negativa deben eliminarse de la lista.
6. Crea un método MensajesGuardianes(Robot[] robots) que recorra el array y retorne una cadena con los resultados de Actuar() de todos los RobotGuardian.

Parte C – Operación sobre listas (2 puntos)

7. Crea un método TopNRobotsConMasEnergia(Robot[] robots, int n) que devuelva un array con los n robots con mayor energía.

✅ Solución en C#

using System;
using System.Collections.Generic;

public class Ciudad
{
    public int XMax { get; }
    public int YMax { get; }

    public Ciudad(int xMax, int yMax)
    {
        XMax = xMax;
        YMax = yMax;
    }
}

public class Robot
{
    public int X { get; protected set; }
    public int Y { get; protected set; }
    public int Energia { get; protected set; }
    public Ciudad Ciudad { get; }

    private static Random rnd = new Random();

    public Robot(Ciudad ciudad)
    {
        Ciudad = ciudad;
        Energia = 100;
        X = rnd.Next(0, ciudad.XMax + 1);
        Y = rnd.Next(0, ciudad.YMax + 1);
    }

    public virtual string Actuar() => "";

    public void Mover()
    {
        X = Math.Clamp(X + rnd.Next(-2, 3), 0, Ciudad.XMax);
        Y = Math.Clamp(Y + rnd.Next(-2, 3), 0, Ciudad.YMax);
        Energia--;
    }
}

public class RobotExplorador : Robot
{
    public RobotExplorador(Ciudad ciudad) : base(ciudad) { }

    public override string Actuar()
    {
        if (Energia <= 0) return "";
        string[] frases = {
            "Explorando sector...",
            "Escaneo ambiental en curso",
            "Recolección de datos completada"
        };
        return frases[new Random().Next(frases.Length)];
    }
}

public class RobotGuardian : Robot
{
    private List<string> alertas = new List<string> { "Movimiento detectado", "Puerta forzada", "Intruso neutralizado" };

    public RobotGuardian(Ciudad ciudad) : base(ciudad) { }

    public override string Actuar()
    {
        if (alertas.Count == 0) return "";
        int i = new Random().Next(alertas.Count);
        string alerta = alertas[i];
        alertas.RemoveAt(i);
        return alerta;
    }
}

public static class Utilidades
{
    public static void DescargarEnergia(List<Robot> robots, int x0, int y0, int rango)
    {
        robots.RemoveAll(r =>
        {
            bool dentro = Math.Abs(r.X - x0) + Math.Abs(r.Y - y0) <= rango;
            if (dentro) r.Energia -= 10;
            return r.Energia < 0;
        });
    }

    public static string MensajesGuardianes(Robot[] robots)
    {
        string resultado = "";
        foreach (var r in robots)
        {
            if (r is RobotGuardian g)
                resultado += g.Actuar() + " ";
        }
        return resultado.Trim();
    }

    public static Robot[] TopNRobotsConMasEnergia(Robot[] robots, int n)
    {
        Array.Sort(robots, (a, b) => b.Energia.CompareTo(a.Energia));
        int cantidad = Math.Min(n, robots.Length);
        Robot[] resultado = new Robot[cantidad];
        Array.Copy(robots, resultado, cantidad);
        return resultado;
    }
}