Regexp, замена двух одинаковых символов одним

#cpp #регулярные_выражения

Задание: избавление от буквы c, которая в сочетаниях
сi и сe будет изменяться на s, в сочетании ck — опускаться, а в остальных случаях
заменяться на k,изьятие всех удвоенных букв: ee изменят
на i, oo - на u, a в остальных комбинациях будут просто писать одну букву вместо
двух одинаковых, а так же отмена артиклей.

Вопрос: не могу разобраться, как заменить 2 одинаковые буквы одной и как передать
букву в Replacement.

Заранее благодарю за ответ.

#include 
#include 
#include 
#include 

using namespace std;

struct Lexer {
    vector rule;
    vector replacement;
};

string Parser(string words, Lexer* Rules) {

    //unsigned long length = Rules->rule.size();
    for (unsigned i = 0; i < Rules->rule.size(); i++) {
        regex rule(Rules->rule[i]);
        words = regex_replace(words, rule, Rules->replacement[i]);
    }

    return words;
}

void init(Lexer* Rules) {
    Rules->rule = { "(\\W[A-a]\\W)", "\\W[A-a] \\W", "\\W [A-a]\\W", "^([A-a])",
"(\\W[A-a])+$",
                    "(\\W[A-a]n\\W)", "\\W[A-a]n \\W", "\\W [A-a]n\\W", "^([A-a]n)",
"(\\W[A-a]n)+$",
                    "(\\W[T-t]he\\W)", "\\W[T-t]he \\W", "\\W [T-t]he\\W", "^([T-t]he)",
"(\\W[T-t]he)+$",
                    "(C|c)i", "(C|c)e", "(C|c)k", "(C|c)",
                    "(E|e){2}", "(O|o){2}", "([a-zA-Z]{2,2})*\1" // замена любых
одинаковых букв
    };
    Rules->replacement = { "", " ", " ", "", "", // [5] ( [A-a])+$
                           "", " ", " ", "", "",
                           "", " ", " ", "", "",
                           "s", "s", "", "k",
                           "i", "u", "+" //"+" подстановка для двух одинаковых букв.
    };
}

void output(string words) {
    cout << words << endl;
}

int main()
{
    Lexer* Rules = new Lexer();

    string words;
    getline(cin, words);

    ::init(Rules);
    words = ::Parser(words, Rules);
    output(words);

    return 0;
}

    

Ответы

Ответ 1

Чтобы заменить повторяющиеся буквы одной, нужно

Найти:      ([a-zA-Z])\1
Заменить:$1

Подробности:


([a-zA-Z]) - Захватывающая подмаска №1: латинская буква
\1 - обратная ссылка, в которой "хранится" значение, захваченное первой подмаской.


В шаблоне замены используется та же обратная ссылка на значение первой подмаски.

Кроме того, [A-a] находит не только A и a. Замените [A-a] на [Aa] и (C|c) на [Cc].

Используйте

void init(Lexer* Rules) {
    Rules->rule = { "(\\W[Aa]\\W)", "\\W[Aa] \\W", "\\W [Aa]\\W", "^([Aa])", "(\\W[Aa])+$",
                    "(\\W[Aa]n\\W)", "\\W[Aa]n \\W", "\\W [Aa]n\\W", "^([Aa]n)",
"(\\W[Aa]n)+$",
                    "(\\W[Tt]he\\W)", "\\W[Tt]he \\W", "\\W [Tt]he\\W", "^([Tt]he)",
"(\\W[Tt]he)+$",
                    "[Cc]i", "[Cc]e", "[Cc]k", "[Cc]",
                    "[Ee]{2}", "[Oo]{2}", "([a-zA-Z])\\1" // замена любых одинаковых букв
    };
    Rules->replacement = { "", " ", " ", "", "", // [5] ( [A-a])+$
                           "", " ", " ", "", "",
                           "", " ", " ", "", "",
                           "s", "s", "", "k",
                           "i", "u", "$1" //"+" подстановка для двух одинаковых букв.
    };
}