Regex for Repeated Characters: (.)\1+ in 4 Engines

Revised November 2026. This tutorial first appeared in Korean in 2021, where it introduced +, * and ? through examples such as \w+@\w+\.\w+ and Player[0-9][0-9]*. We re-ran all six examples with identical inputs in .NET 10, Python 3.9 and 3.12 re, PHP 8.5 (PCRE2 10.47, with and without /u) and Dart 3.11, whose RegExp follows JavaScript rules. The matches agreed in every engine. One definition was wrong for half the engines: \w is not [a-zA-Z0-9_] in .NET, Python or PHP with /u. The quantifier theory now lives in our quantifier article; this version focuses on what the title promises: finding runs of the same character.

This article is for anyone who needs to detect or shorten repeated characters: soooo, !!!!, PIN codes like 1111, or laughter in chat logs. The short answer is (.)\1+: capture one character, then require that exact character one or more times. A plain quantifier cannot do this, because a+ only repeats a character you name in advance and .+ accepts any mix of characters. The method relies on a backreference, which our backreferences article covers in depth.

The 2021 examples, re-checked

Here are the original examples with the results every engine returned (inputs one per line):

The last row deserves a remark: the 2021 page showed aabbcc twice, and the third line was probably aabcc before formatting was lost, since that is the case b? exists to accept. Note also that Player[0-9][0-9]? does not reject Player100; it matches the first ten characters. If the number must be at most two digits, end the pattern with \b: on Player1, Player100, Player12, the pattern Player[0-9][0-9]?\b matched only Player1 and Player12 in every engine.

Two points from the 2021 text needed correcting.

\w is not always [a-zA-Z0-9_]. On the input 홍길동@예시.한국, \w+@\w+\.\w+ matched the whole address in .NET, Python and PHP with /u, and nothing in PHP without /u or in Dart. Our character set article has the full table.

The email pattern is a demonstration, not a validator. On first.last@mail.example.co.jp every engine returned last@mail.example: \w does not include the dot, so the local part and the domain are both cut short. For real validation, check for one @ and send a confirmation mail.

Matching the same character again: (.)\1+

(.) captures any one character into group 1. \1 then demands the text group 1 captured, and + lets that repeat. Together they find runs of length two or more:

Pattern: (.)\1+
Text:    aaabccddddd
Matches: aaa (group 1 = a), cc (c), ddddd (d)

All four engines agreed, in both modes. Compare it with the patterns people try first:

The (.)+ row is a common trap. A quantified group does not "remember" all its characters; group 1 holds only the last iteration, c. .NET keeps the history in Groups[1].Captures (a|b|c in our run), but no other engine exposes it in its standard library.

Swap . for something narrower to choose which runs count:

(\w)\1+     on "100% cool --- yes"         → 00, oo   (the dashes are ignored)
(\d)\1{3,}  on "PIN 1111, 1234, 00007"     → 1111, 0000
(.)\1+      on "AaA bB" (case-insensitive) → AaA, bB

The last line shows that with case-insensitive matching on, the backreference comparison also ignores case in every engine we tested.

Collapsing repeats with a replacement

Finding runs is usually the first step toward shortening them. The replacement refers back to group 1, and the syntax depends on the engine:

Every engine produced the same output. Dart's replaceAll has no replacement syntax, so we used replaceAllMapped(re, (m) => m[1]! * 2), which gave the same string. The {2,} version is the one you usually want for user text: good book soooo became good book soo, so normal double letters survive and only runs of three or more are trimmed.

If you write \1 in a .NET replacement, or $1 in Python, the engine does not complain; it inserts the characters literally. The backreferences article has the full table of which spelling each engine accepts.

Emoji and other characters outside the BMP

The same pattern stopped agreeing when the input contained emoji:

.NET strings, like JavaScript strings, are UTF-16. An emoji such as 😀 is a surrogate pair, two code units ("😀😀".Length is 4 in C#), and . matches only one of them. Group 1 captures the first half, the next unit is the second half, and they differ, so there is no run. Python works with code points, and Dart and PHP do too once Unicode mode is on. PHP without /u works on bytes, which even breaks three-byte Hangul jamo.

In .NET, capture a surrogate pair as one unit:

Regex.Match("😀😀", @"([\uD800-\uDBFF][\uDC00-\uDFFF]|.)\1+").Value   // "😀😀"

Emoji with skin-tone modifiers or joiners are several code points long, so even this only handles the simple ones. For a feature like "collapse repeated emoji in comments", split the text into grapheme clusters first (StringInfo in .NET, the characters package in Dart) and compare clusters in code.

How fast is it? A one-million-character run

To see whether a regex is a reasonable tool for cleaning large text, we generated 1,000,000 characters of chat-like text (a fixed seed, words such as soooo, !!!!, ㅋㅋㅋㅋ and wwww mixed with normal words) and replaced (.)\1{2,} with two copies of group 1. There were 78,072 runs; the output was 859,424 characters in every case. Three runs each, Apple Silicon Mac:

The regex is not the bottleneck at this size, and in Python it was five times faster than the obvious hand-written loop. Unlike the nested quantifiers in our quantifier article, (.)\1+ cannot blow up: each run is consumed once and there is nothing ambiguous to backtrack over.

Cheat sheet and how we tested

Engines: .NET 10.0.14 (Regex.Matches, Regex.Replace), Python 3.9.6 and 3.12.14 (re.finditer, re.sub), PHP 8.5.6 with PCRE2 10.47 (preg_match_all, preg_replace, with and without /u), and Dart 3.11.5 (RegExp.allMatches, replaceAllMapped, default and unicode: true). Node.js was not installed, so JavaScript rules were checked through Dart. Patterns and inputs came from one JSON file, so every engine read the same bytes.

Tested on macOS on an Apple Silicon Mac, November 2026.