#include <bits/stdc++.h>
using namespace std;

int main() {
    // 1. vector (Array dinámico)
    std::vector<int> v = {1, 2, 3};
    v.push_back(4); v.pop_back();
    v.insert(v.begin(), 0); v.erase(v.begin());
    std::cout << "Vector first element: " << v.front() << "\n";
    std::cout << "Vector last element: " << v.back() << "\n";

    // 2. deque (Doble extremo)
    std::deque<int> d = {1, 2, 3};
    d.push_front(0); d.push_back(4); d.pop_front(); d.pop_back();
    std::cout << "Deque first element: " << d.front() << "\n";
    std::cout << "Deque last element: " << d.back() << "\n";

    // 3. list (Lista doblemente enlazada)
    std::list<int> l = {1, 2, 3};
    l.push_front(0); l.push_back(4); l.pop_back(); l.remove(2);
    std::cout << "List first element: " << l.front() << "\n";
    std::cout << "List last element: " << l.back() << "\n";

    // 4. forward_list (Lista enlazada simple)
    std::forward_list<int> fl = {1, 2, 3};
    fl.push_front(0); fl.pop_front(); fl.remove(2);
    std::cout << "Forward List first element: " << fl.front() << "\n";

    // 5. stack (Pila LIFO)
    std::stack<int> s;
    s.push(1); s.push(2); s.push(3);
    std::cout << "Stack top: " << s.top() << "\n";

    // 6. queue (Cola FIFO)
    std::queue<int> q;
    q.push(1); q.push(2); q.push(3);
    std::cout << "Queue front: " << q.front() << "\n";
    std::cout << "Queue back: " << q.back() << "\n";

    // 7. priority_queue (Cola con prioridad)
    std::priority_queue<int> pq;
    pq.push(3); pq.push(1); pq.push(2);
    std::cout << "Priority Queue top: " << pq.top() << "\n";

    // 8. set (Conjunto ordenado)
    std::set<int> st = {3, 1, 2};
    std::cout << "Set first element: " << *st.begin() << "\n";

    // 9. unordered_set (Conjunto desordenado)
    std::unordered_set<int> ust = {3, 1, 2};
    std::cout << "Unordered Set contains 2? " << (ust.count(2) ? "Yes" : "No") << "\n";

    // 10. multiset (Conjunto ordenado con duplicados)
    std::multiset<int> ms = {1, 2, 2, 3};
    std::cout << "Multiset first element: " << *ms.begin() << "\n";

    // 11. map (Diccionario ordenado)
    std::map<int, std::string> mp = {{1, "uno"}, {2, "dos"}, {3, "tres"}};
    std::cout << "Map first element: " << mp.begin()->first << " -> " << mp.begin()->second << "\n";

    // 12. unordered_map (Diccionario hash)
    std::unordered_map<int, std::string> ump = {{1, "uno"}, {2, "dos"}, {3, "tres"}};
    std::cout << "Unordered Map contains key 2? " << (ump.count(2) ? "Yes" : "No") << "\n";

    // 13. bitset (Manejo de bits)
    std::bitset<8> bs("1010");
    std::cout << "Bitset: " << bs << "\n";

    return 0;
}

//--------------------------------------
// ordenar vector

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// Definición de la estructura Persona
struct Persona {
    string nombre;
    int edad;

    // Sobrecarga del operador < para ordenar por edad (ascendente)
    bool operator<(const Persona& otra) const {
        return edad < otra.edad; // Menor edad primero
    }
};

// Comparador personalizado para ordenar por edad descendente
bool compararPorEdadDesc(const Persona& a, const Persona& b) {
    return a.edad > b.edad; // Mayor edad primero
}

// Comparador para ordenar por nombre alfabéticamente
bool compararPorNombre(const Persona& a, const Persona& b) {
    return a.nombre < b.nombre; // Orden lexicográfico (A-Z)
}

int main() {
    vector<Persona> personas = {
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 20},
        {"David", 35},
        {"Eve", 28}
    };

    // Ordenar por edad (menor a mayor) usando operador sobrecargado
    sort(personas.begin(), personas.end());

    cout << "Ordenado por edad (ascendente):" << endl;
    for (const auto& p : personas) {
        cout << p.nombre << " - " << p.edad << " años" << endl;
    }
    cout << endl;

    // Ordenar por edad (mayor a menor) usando comparador personalizado
    sort(personas.begin(), personas.end(), compararPorEdadDesc);

    cout << "Ordenado por edad (descendente):" << endl;
    for (const auto& p : personas) {
        cout << p.nombre << " - " << p.edad << " años" << endl;
    }
    cout << endl;

    // Ordenar por nombre alfabéticamente
    sort(personas.begin(), personas.end(), compararPorNombre);

    cout << "Ordenado por nombre (alfabéticamente):" << endl;
    for (const auto& p : personas) {
        cout << p.nombre << " - " << p.edad << " años" << endl;
    }
    cout << endl;

    return 0;
}



// --------------------------------------
// Prioirty queue amb comparador

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

// Estructura Persona
struct Persona {
    string nombre;
    int edad;

    // Sobrecarga del operador < para definir la prioridad (mayor edad primero)
    bool operator<(const Persona& otra) const {
        return edad < otra.edad; // Se usa < porque priority_queue es un max-heap por defecto
    }
};

// Comparador personalizado para usar en priority_queue
struct ComparadorPersona {
    bool operator()(const Persona& a, const Persona& b) {
        return a.edad > b.edad; // Cambia el orden a un min-heap (menor edad primero)
    }
};

int main() {
    // Priority queue con enteros (por defecto, max-heap)
    priority_queue<int> pqEnteros;
    pqEnteros.push(10);
    pqEnteros.push(30);
    pqEnteros.push(20);

    cout << "Priority Queue de enteros (max-heap): ";
    while (!pqEnteros.empty()) {
        cout << pqEnteros.top() << " ";
        pqEnteros.pop();
    }
    cout << endl;

    // Priority queue con estructura Persona (por defecto, max-heap basado en edad)
    priority_queue<Persona> pqPersonas;
    pqPersonas.push({"Alice", 25});
    pqPersonas.push({"Bob", 30});
    pqPersonas.push({"Charlie", 20});

    cout << "Priority Queue de Personas (mayor edad primero):" << endl;
    while (!pqPersonas.empty()) {
        cout << pqPersonas.top().nombre << " - " << pqPersonas.top().edad << " años" << endl;
        pqPersonas.pop();
    }

    // Priority queue con comparador personalizado (min-heap basado en edad)
    priority_queue<Persona, vector<Persona>, ComparadorPersona> pqPersonasMinHeap;
    pqPersonasMinHeap.push({"Alice", 25});
    pqPersonasMinHeap.push({"Bob", 30});
    pqPersonasMinHeap.push({"Charlie", 20});

    cout << "Priority Queue de Personas (menor edad primero):" << endl;
    while (!pqPersonasMinHeap.empty()) {
        cout << pqPersonasMinHeap.top().nombre << " - " << pqPersonasMinHeap.top().edad << " años" << endl;
        pqPersonasMinHeap.pop();
    }

    return 0;
}

// ------
// Àrees i volumns

#include <iostream>
#include <cmath>
using namespace std;

void pentagono() {
    double L;
    cout << "Introduce el lado del pentágono: ";
    cin >> L;
    double area = (5.0 / 4.0) * L * L / tan(M_PI / 5);
    cout << "Perímetro: " << 5 * L << endl;
    cout << "Área: " << area << endl;
}

void trapecio() {
    double b1, b2, h, l1, l2;
    cout << "Introduce la base mayor, base menor, altura y los dos lados no paralelos: ";
    cin >> b1 >> b2 >> h >> l1 >> l2;
    double area = ((b1 + b2) * h) / 2;
    cout << "Perímetro: " << (b1 + b2 + l1 + l2) << endl;
    cout << "Área: " << area << endl;
}

void triangulo() {
    double a, b, c;
    cout << "Introduce los tres lados del triángulo: ";
    cin >> a >> b >> c;
    double s = (a + b + c) / 2;
    double area = sqrt(s * (s - a) * (s - b) * (s - c));
    cout << "Perímetro: " << (a + b + c) << endl;
    cout << "Área: " << area << endl;
}

void prisma() {
    double b, h, l;
    cout << "Introduce la base, altura y longitud del prisma: ";
    cin >> b >> h >> l;
    cout << "Volumen: " << b * h * l << endl;
    cout << "Área superficial: " << 2 * (b * h + b * l + h * l) << endl;
}

void esfera() {
    double r;
    cout << "Introduce el radio de la esfera: ";
    cin >> r;
    cout << "Volumen: " << (4.0 / 3.0) * M_PI * r * r * r << endl;
    cout << "Área superficial: " << 4 * M_PI * r * r << endl;
}

int main() {
    int opcion;
    do {
        cout << "\nSeleccione una figura para calcular:\n";
        cout << "1. Pentágono\n2. Trapecio\n3. Triángulo\n4. Prisma\n5. Esfera\n6. Salir\n";
        cout << "Opción: ";
        cin >> opcion;
        
        switch (opcion) {
            case 1: pentagono(); break;
            case 2: trapecio(); break;
            case 3: triangulo(); break;
            case 4: prisma(); break;
            case 5: esfera(); break;
            case 6: cout << "Saliendo...\n"; break;
            default: cout << "Opción no válida. Intente de nuevo.\n";
        }
    } while (opcion != 6);
    
    return 0;
}