Verificación de propiedades en cadenas

Conteo de caracteres

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

int main() {
    string entrada;
    cin >> entrada;
    int frecuencia[256] = {0};
    
    for (char caracter : entrada) {
        frecuencia[caracter]++;
    }
    
    bool valido = true;
    for (char c = 'a'; c <= 'z'; c++) {
        if (frecuencia[c] % 2 != 0) {
            valido = false;
            break;
        }
    }
    
    cout << (valido ? "Yes" : "No");
    return 0;
}
</string></iostream>

Detección de caracteres únicos

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

bool tieneDuplicados(const string& texto) {
    for (size_t i = 0; i < texto.length(); i++) {
        for (size_t j = i + 1; j < texto.length(); j++) {
            if (texto[i] == texto[j]) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    string texto;
    cin >> texto;
    cout << (tieneDuplicados(texto) ? "no" : "yes");
    return 0;
}
</string></iostream>

Alternativa con array de frecuencia

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

int main() {
    char cadena[100];
    cin >> cadena;
    int contador[26] = {0};
    int longitud = strlen(cadena);
    
    for (int i = 0; i < longitud; i++) {
        contador[cadena[i] - 'a']++;
    }
    
    bool unicos = true;
    for (int i = 0; i < 26; i++) {
        if (contador[i] > 1) {
            unicos = false;
            break;
        }
    }
    
    cout << (unicos ? "yes" : "no");
    return 0;
}
</cstring></iostream>

Procesamiento secuencial de cadenas

Seguimiento de máximo valor

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    char operaciones[n];
    int contador = 0, maximo = 0;
    
    for (int i = 0; i < n; i++) {
        cin >> operaciones[i];
        if (operaciones[i] == 'I') contador++;
        else contador--;
        
        if (contador > maximo) maximo = contador;
    }
    
    cout << maximo;
    return 0;
}
</iostream>

Edición de cadenas con retroceso

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

int main() {
    string entrada, resultado;
    cin >> entrada;
    
    for (char c : entrada) {
        if (c == 'B') {
            if (!resultado.empty()) resultado.pop_back();
        } else {
            resultado.push_back(c);
        }
    }
    
    cout << resultado;
    return 0;
}
</string></iostream>

Mnaipulación de múltiples cadenas

Comparación de anagramas

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;

int main() {
    string s, t;
    cin >> s >> t;
    
    sort(s.begin(), s.end());
    sort(t.begin(), t.end(), greater<char>());
    
    cout << (s < t ? "Yes" : "No");
    return 0;
}
</char></string></iostream></algorithm>

Compresión de matriz de caracteres

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

int main() {
    int filas, columnas;
    cin >> filas >> columnas;
    vector<vector>> matriz(filas, vector<char>(columnas));
    
    for (int i = 0; i < filas; i++) {
        for (int j = 0; j < columnas; j++) {
            cin >> matriz[i][j];
        }
    }
    
    vector<bool> filaVacia(filas, false);
    vector<bool> columnaVacia(columnas, false);
    
    for (int i = 0; i < filas; i++) {
        bool vacia = true;
        for (int j = 0; j < columnas; j++) {
            if (matriz[i][j] != '.') {
                vacia = false;
                break;
            }
        }
        filaVacia[i] = vacia;
    }
    
    for (int j = 0; j < columnas; j++) {
        bool vacia = true;
        for (int i = 0; i < filas; i++) {
            if (matriz[i][j] != '.') {
                vacia = false;
                break;
            }
        }
        columnaVacia[j] = vacia;
    }
    
    for (int i = 0; i < filas; i++) {
        if (filaVacia[i]) continue;
        for (int j = 0; j < columnas; j++) {
            if (columnaVacia[j]) continue;
            cout << matriz[i][j];
        }
        cout << endl;
    }
    
    return 0;
}
</bool></bool></char></vector></vector></iostream>

Operaciones avanzadas con cadenas

Búsqueda de posiciones extremas

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

int main() {
    int casos;
    cin >> casos;
    
    while (casos--) {
        int n;
        string s;
        cin >> n >> s;
        
        int primeraA = -1, ultimaB = -1;
        for (int i = 0; i < n; i++) {
            if (s[i] == 'A' && primeraA == -1) {
                primeraA = i;
            }
            if (s[i] == 'B') {
                ultimaB = i;
            }
        }
        
        int resultado = 0;
        if (primeraA != -1 && ultimaB != -1 && ultimaB >= primeraA) {
            resultado = ultimaB - primeraA;
        }
        
        cout << resultado << endl;
    }
    
    return 0;
}
</string></iostream>

Ordanamiento cíclico de subsecuencias

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    int tests;
    cin >> tests;
    
    while (tests--) {
        int n;
        string s;
        cin >> n >> s;
        
        vector<int> indices;
        for (int i = n - 1; i >= 0; i--) {
            if (indices.empty() || s[i] >= s[indices.back()]) {
                indices.push_back(i);
            }
        }
        
        reverse(indices.begin(), indices.end());
        int operaciones = indices.size();
        
        int contador = 0;
        while (contador < indices.size() && s[indices[0]] == s[indices[contador]]) {
            contador++;
        }
        operaciones -= contador;
        
        for (int i = 0; i < indices.size() / 2; i++) {
            swap(s[indices[i]], s[indices[indices.size() - 1 - i]]);
        }
        
        if (!is_sorted(s.begin(), s.end())) {
            operaciones = -1;
        }
        
        cout << operaciones << endl;
    }
    
    return 0;
}
</int></algorithm></vector></string></iostream>