genera un programa para una torre de absorcion

Aquí te presento un ejemplo de programa en C++ para una torre de absorción. Esta torre tiene 5 niveles y cada nivel tiene 5 columnas. La torre puede absorber objetos de diferentes tamaños y pesos.

```cpp
#include <iostream>
#include <vector>

// Estructura para representar un objeto
struct Objeto {
    int tamano;
    int peso;
};

// Clase para representar la torre de absorción
class Torre {
private:
    int niveles;
    int columnas;
    std::vector<std::vector<Objeto>> torre;

public:
    // Constructor
    Torre(int niveles, int columnas) : niveles(niveles), columnas(columnas) {
        torre.resize(niveles);
        for (int i = 0; i < niveles; i++) {
            torre[i].resize(columnas);
        }
    }

    // Método para agregar un objeto a la torre
    void agregarObjeto(int nivel, int columna, Objeto objeto) {
        if (nivel >= 0 && nivel < niveles && columna >= 0 && columna < columnas) {
            torre[nivel][columna] = objeto;
        } else {
            std::cout << "Nivel o columna fuera de rango" << std::endl;
        }
    }

    // Método para eliminar un objeto de la torre
    void eliminarObjeto(int nivel, int columna) {
        if (nivel >= 0 && nivel < niveles && columna >= 0 && columna < columnas) {
            torre[nivel][columna] = Objeto{0, 0};
        } else {
            std::cout << "Nivel o columna fuera de rango" << std::endl;
        }
    }

    // Método para mostrar la torre
    void mostrarTorre() {
        for (int i = 0; i < niveles; i++) {
            for (int j = 0; j < columnas; j++) {
                if (torre[i][j].tamano == 0 && torre[i][j].peso == 0) {
                    std::cout << "Vacio ";
                } else {
                    std::cout << "Objeto de tamano " << torre[i][j].tamano << " y peso " << torre[i][j].peso << " ";
                }
            }
            std::cout << std::endl;
        }
    }

    // Método para calcular el peso total de la torre
    int calcularPesoTotal() {
        int pesoTotal = 0;
        for (int i = 0; i < niveles; i++) {
            for (int j = 0; j < columnas; j++) {
                pesoTotal += torre[i][j].peso;
            }
        }
        return pesoTotal;
    }
};

int main() {
    // Crear una torre de 5 niveles y 5 columnas
    Torre torre(5, 5);

    // Agregar objetos a la torre
    torre.agregarObjeto(0, 0, {3, 10});
    torre.agregarObjeto(0, 1, {2, 5});
    torre.agregarObjeto(1, 2, {4, 15});
    torre.agregarObjeto(2, 3, {1, 2});
    torre.agregarObjeto(3, 4, {5, 20});

    // Mostrar la torre
    std::cout << "Torre actual:" << std::endl;
    torre.mostrarTorre();

    // Eliminar un objeto de la torre
    torre.eliminarObjeto(1, 2);

    // Mostrar la torre actualizada
    std::cout << "Torre actualizada:" << std::endl;
    torre.mostrarTorre();

    // Calcular el peso total de la torre
    int pesoTotal = torre.calcularPesoTotal();
    std::cout << "Peso total de la torre: " << pesoTotal << std::endl;

    return 0;
}
```

Este programa define una clase `Torre` que representa la torre de absorción. La clase tiene métodos para agregar objetos a la torre, eliminar objetos de la torre, mostrar la torre y calcular el peso total de la torre.

En el `main` se crea una torre de 5 niveles y 5 columnas, se agregan objetos a la torre, se muestra la torre, se elimina un objeto de la torre, se muestra la torre actualizada y se calcula el peso total de la torre.