Este artigo apresenta exemplos práticos de manipulação de strings em C++, focando em problemas comuns que envolvem operações de busca, comparação e transformação. Os exemplos demontsram técnicas como ponteiros duplos, contagem de frequência e processamento de strings como números.

Inverter Apenas Letras em uma String

Este problema requer a inversão de apenas os caracteres alfabéticos, mantendo a posição de outros símbolos. A solução utiliza dois ponteiros movendo-se das extremidades para o centro, pulando caracteres não-alfabéticos.

#include <string>
using namespace std;

class Solucao 
{
public:
    bool ehLetra(char c)
    {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }
    string inverterSomenteLetras(string texto) 
    {
        if(texto.empty()) return texto;
        int esquerda = 0;
        int direita = texto.size() - 1;
        while(esquerda < direita)
        {
            while(esquerda < direita && !ehLetra(texto[esquerda]))
            {
                esquerda++;
            }
            while(esquerda < direita && !ehLetra(texto[direita]))
            {
                direita--;
            }
            swap(texto[esquerda], texto[direita]);
            esquerda++;
            direita--;
        }
        return texto;
    }
};

Encontrar o Primeiro Caractere Único

Para localizar o primeiro caractere que aparece apenas uma vez, utiliza-se um array de contagem para registrar a frequência de cada caractere. Em seguida, percorre-se a string original para identificar o primeiro com contagem igual a um.

#include <string>
using namespace std;

class Solucao 
{
public:
    int primeiroCaractereUnico(string s) 
    {
        int frequencias[26] = {0};
        for(size_t i = 0; i < s.size(); i++)
        {
            frequencias[s[i] - 'a']++;
        }
        for(size_t i = 0; i < s.size(); i++)
        {
            if(frequencias[s[i] - 'a'] == 1)
            {
                return i;
            }
        }
        return -1;
    }
};

Comprimento da Última Palavra

Este problema pode ser resolvido encontrando a posição do último espaço na string e calculando a diferença entre o tamanho total e essa posição. O código abaixo lê múltiplas linhas de entrada e aplica essa lógica.

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

int main() 
{
    string linha;
    while(getline(cin, linha))
    {
        size_t posEspaco = linha.rfind(' ');
        if(posEspaco == string::npos)
        {
            cout << linha.size() << endl;
        }
        else
        {
            cout << linha.size() - posEspaco - 1 << endl;
        }
    }
}

Verificar se uma String é Palíndromo

A verificação de palíndromo envolve normalizar a string para minúsculas e ignorar caracteres não alfanuméricos. Dois ponteiros percorrem a string comparando os caracteres nas extremidades.

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

class Solucao 
{
public:
    bool ehAlfanumerico(char c)
    {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
    }
    bool ehPalindromo(string s) 
    {
        if(s.empty()) return true;
        transform(s.begin(), s.end(), s.begin(), ::tolower);
        int inicio = 0;
        int fim = s.size() - 1;
        while(inicio < fim)
        {
            while(inicio < fim && !ehAlfanumerico(s[inicio]))
            {
                inicio++;
            }
            while(inicio < fim && !ehAlfanumerico(s[fim]))
            {
                fim--;
            }
            if(s[inicio] != s[fim])
            {
                return false;
            }
            inicio++;
            fim--;
        }
        return true;
    }
};

Adicionar Duas Strings Representando Números

Para somar duas strings que representam números inteiros, percorre-se de trás para frente, convertendo cada caractere para dígito e tratando o transporte. O resultado é construído invertido e depois revertido.

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

class Solucao 
{
public:
    string adicionarStrings(string num1, string num2) 
    {
        string resultado;
        int pos1 = num1.size() - 1;
        int pos2 = num2.size() - 1;
        int carry = 0;
        while(pos1 >= 0 || pos2 >= 0 || carry)
        {
            int digito1 = pos1 >= 0 ? num1[pos1--] - '0' : 0;
            int digito2 = pos2 >= 0 ? num2[pos2--] - '0' : 0;
            int soma = digito1 + digito2 + carry;
            carry = soma / 10;
            resultado += (soma % 10) + '0';
        }
        reverse(resultado.begin(), resultado.end());
        return resultado;
    }
};

Estes exemplos ilustram técnicas fundamentais de manipulação de strings em C++, aplicáveis em contextos de algoritmos e estruturas de dados.