Python re.sub() is not replacing every match

Question

I'm using Python 3 and I have two strings: abbcabb and abca. I want to remove every double occurrence of a single character. For example:

abbcabb should give c and abca should give bc.

I've tried the following regex (here):

(.)(.*?)\1

But, it gives wrong output for first string. Also, when I tried another one (here):

(.)(.*?)*?\1

But, this one again gives wrong output. What's going wrong here?

---

The python code is a print statement:

print(re.sub(r'(.)(.*?)\1', '\g<2>', s)) # s is the string

Answer 1

It can be solved without regular expression, like below

>>>''.join([i for i in s1 if s1.count(i) == 1])
'bc'
>>>''.join([i for i in s if s.count(i) == 1])
'c'

Answer 2

re.sub() doesn't perform overlapping replacements. After it replaces the first match, it starts looking after the end of the match. So when you perform the replacement on

abbcabb

it first replaces abbca with bbc. Then it replaces bb with an empty string. It doesn't go back and look for another match in bbc.

If you want that, you need to write your own loop.

while True:
    newS = re.sub(r'(.)(.*?)\1', r'\g<2>', s)
    if newS == s:
        break
    s = newS
print(newS)

DEMO

Answer 3

Regular expressions doesn't seem to be the ideal solution

• they don't handle overlapping so it it needs a loop (like in this answer) and it creates strings over and over (performance suffers)
• they're overkill here, we just need to count the characters

I like this answer, but using count repeatedly in a list comprehension loops over all elements each time.

It can be solved without regular expression and without O(n**2) complexity, only O(n) using collections.Counter

• first count the characters of the string very easily & quickly
• then filter the string testing if the count matches using the counter we just created.

like this:

import collections

s = "abbcabb"

cnt = collections.Counter(s)

s = "".join([c for c in s if cnt[c]==1])

(as a bonus, you can change the count to keep characters which have 2, 3, whatever occurrences)

Answer 4

EDIT: based on the comment exchange - if you're just concerned with the parity of the letter counts, then you don't want regex and instead want an approach like @jon's recommendation. (If you don't care about order, then a more performant approach with very long strings might use something like collections.Counter instead.)

---

My best guess as to what you're trying to match is: "one or more characters - call this subpattern A - followed by a different set of one or more characters - call this subpattern B - followed by subpattern A again".

You can use + as a shortcut for "one or more" (instead of specifying it once and then using * for the rest of the matches), but either way you need to get the subpatterns right. Let's try:

>>> import re
>>> pattern = re.compile(r'(.+?)(.+?)\1')
>>> pattern.sub('\g<2>', 'abbcabbabca')
'bbcbaca'

Hmm. That didn't work. Why? Because with the first pattern not being greedy, our "subpattern A" can just match the first a in the string - it does appear later, after all. So if we use a greedy match, Python will backtrack until it finds as long of a pattern for subpattern A that still allows for the A-B-A pattern to appear:

>>> pattern = re.compile(r'(.+)(.+?)\1')
>>> pattern.sub('\g<2>', 'abbcabbabca')
'cbc'

Looks good to me.

Answer 5

The site explains it well, hover and use the explanation section.

(.)(.*?)\1 Does not remove or match every double occurance. It matches 1 character, followed by anything in the middle sandwiched till that same character is encountered again.

so, for abbcabb the "sandwiched" portion should be bbc between two a

EDIT: You can try something like this instead without regexes:

string = "abbcabb"
result = []
for i in string:
    if i not in result:
        result.append(i)
    else:
        result.remove(i)
print(''.join(result))

Note that this produces the "last" odd occurrence of a string and not first.

For "first" known occurance, you should use a counter as suggested in this answer . Just change the condition to check for odd counts. pseudo code(count[letter] %2 == 1)