13. Encontrar Números Duplicados en un Arreglo

class Solucion {
public:
    int encontrarDuplicado(vector<int>& arreglo) {
        if(arreglo.empty()) return -1;
        unordered_map<int, int> contador;
        int tam = arreglo.size();
        for(int num : arreglo) {
            if(num < 0 || num >= tam) 
                return -1;
            contador[num]++;
        }
        for(auto& par : contador) {
            if(par.second > 1) 
                return par.first;
        }
        return -1;
    }
};

15. Búsqueda en Matriz Bidimensional

class Solucion {
public:
    bool buscarMatriz(vector<vector<int>> matriz, int objetivo) {
        if(matriz.empty() || matriz[0].empty()) return false;
        int fila = 0, col = matriz[0].size() - 1;
        while(fila < matriz.size() && col >= 0) {
            int valor = matriz[fila][col];
            if(valor == objetivo) return true;
            else if(valor > objetivo) col--;
            else fila++;
        }
        return false;
    }
};

21. Secuencia Fiboancci

class Solucion {
public:
    int fibonacci(int n) {
        if(n == 0) return 0;
        int prev = 0, actual = 1;
        for(int i = 1; i < n; i++) {
            int sig = prev + actual;
            prev = actual;
            actual = sig;
        }
        return actual;
    }
};

22. Mínimo en Arreglo Rotado

class Solucion {
public:
    int encontrarMinimo(vector<int>& nums) {
        if(nums.empty()) return -1;
        int minimo = nums[0];
        for(int i = 1; i < nums.size(); i++) {
            minimo = min(minimo, nums[i]);
        }
        return minimo;
    }
};

26. Contar Bits Activos

class Solucion {
public:
    int bitBajo(int x) {
        return x & -x;
    }
    int contarUnos(int n) {
        int total = 0;
        while(n) {
            n -= bitBajo(n);
            total++;
        }
        return total;
    }
};

35. Invertir Lista Enlazada

// Iterativo
class Solucion {
public:
    ListNode* invertirLista(ListNode* cabeza) {
        if(!cabeza || !cabeza->next) return cabeza;
        ListNode* anterior = cabeza;
        ListNode* actual = cabeza->next;
        while(actual) {
            ListNode* sig = actual->next;
            actual->next = anterior;
            anterior = actual;
            actual = sig;
        }
        cabeza->next = nullptr;
        return anterior;
    }
};

// Recursivo
class Solucion {
public:
    ListNode* invertirLista(ListNode* cabeza) {
        if(!cabeza || !cabeza->next) return cabeza;
        ListNode* resto = invertirLista(cabeza->next);
        cabeza->next->next = cabeza;
        cabeza->next = nullptr;
        return resto;
    }
};

36. Fusionar Listas Ordenadas

class Solucion {
public:
    ListNode* fusionar(ListNode* lista1, ListNode* lista2) {
        ListNode* ficticio = new ListNode(-1);
        ListNode* actual = ficticio;
        while(lista1 && lista2) {
            if(lista1->val < lista2->val) {
                actual->next = lista1;
                lista1 = lista1->next;
            } else {
                actual->next = lista2;
                lista2 = lista2->next;
            }
            actual = actual->next;
        }
        actual->next = lista1 ? lista1 : lista2;
        return ficticio->next;
    }
};

52. Elemento Mayoritario

class Solucion {
public:
    int elementoMayoritario(vector<int>& nums) {
        int cont = 0, candidato;
        for(int num : nums) {
            if(!cont) candidato = num;
            if(num == candidato) cont++;
            else cont--;
        }
        return candidato;
    }
};

53. k Elementos Más Pequeños

// Ordenamiento
class Solucion {
public:
    vector<int> menoresK(vector<int> entrada, int k) {
        sort(entrada.begin(), entrada.end());
        return vector<int>(entrada.begin(), entrada.begin() + k);
    }
};

// Min-Heap
class Solucion {
public:
    vector<int> menoresK(vector<int> entrada, int k) {
        priority_queue<int, vector<int>, greater<int>> heap;
        for(int num : entrada) heap.push(num);
        vector<int> resultado;
        while(k--) {
            resultado.push_back(heap.top());
            heap.pop();
        }
        return resultado;
    }
};

55. Máxima Suma Subarreglo

class Solucion {
public:
    int maxSubArray(vector<int>& nums) {
        int maxActual = nums[0];
        int maxGlobal = nums[0];
        for(int i = 1; i < nums.size(); i++) {
            maxActual = max(nums[i], maxActual + nums[i]);
            maxGlobal = max(maxGlobal, maxActual);
        }
        return maxGlobal;
    }
};

62. Generar Número Ugly

class Solucion {
public:
    int obtenerUgly(int n) {
        vector<int> uglies = {1};
        int i2 = 0, i3 = 0, i5 = 0;
        while(--n) {
            int sig = min({uglies[i2]*2, uglies[i3]*3, uglies[i5]*5});
            uglies.push_back(sig);
            if(sig == uglies[i2]*2) i2++;
            if(sig == uglies[i3]*3) i3++;
            if(sig == uglies[i5]*5) i5++;
        }
        return uglies.back();
    }
};

263. Verificar Número Ugly

class Solucion {
public:
    bool esUgly(int n) {
        if(n < 1) return false;
        while(n % 2 == 0) n /= 2;
        while(n % 3 == 0) n /= 3;
        while(n % 5 == 0) n /= 5;
        return n == 1;
    }
};

68. Número Faltante

class Solucion {
public:
    int encontrarFaltante(vector<int>& nums) {
        for(int i = 0; i < nums.size(); i++)
            if(i != nums[i]) return i;
        return nums.size();
    }
};

69. Elemento Igual a Índice

class Solucion {
public:
    int elementoIgualIndice(vector<int>& nums) {
        for(int i = 0; i < nums.size(); i++)
            if(i == nums[i]) return i;
        return -1;
    }
};

71. Profundidad de Árbol Binario

class Solucion {
public:
    int profundidad(TreeNode* raiz) {
        if(!raiz) return 0;
        return max(profundidad(raiz->left), profundidad(raiz->right)) + 1;
    }
};

73. Elementos Únicos en Arreglo

class Solucion {
public:
    vector<int> encontrarUnicos(vector<int>& nums) {
        unordered_map<int, int> frecuencia;
        for(int num : nums) frecuencia[num]++;
        vector<int> resultado;
        for(int num : nums)
            if(frecuencia[num] == 1)
                resultado.push_back(num);
        return resultado;
    }
};

77. Invertir Palabras

class Solucion {
public:
    string invertirPalabras(string s) {
        reverse(s.begin(), s.end());
        int inicio = 0;
        for(int i = 0; i <= s.size(); i++) {
            if(i == s.size() || s[i] == ' ') {
                reverse(s.begin() + inicio, s.begin() + i);
                inicio = i + 1;
            }
        }
        return s;
    }
};

78. Rotación Izquierda de Cadena

class Solucion {
public:
    string rotarIzquierda(string str, int n) {
        reverse(str.begin(), str.end());
        reverse(str.begin(), str.end() - n);
        reverse(str.end() - n, str.end());
        return str;
    }
};