C# Regex Exercises: 30 Coding Problems with Solutions

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "12345";
        string pattern = @"^\d{5}$";

        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch);
    }
}Code language: C# (cs)

Explanation:

• ^ and $: Anchor the pattern to the very start and very end of the string, so partial matches inside a longer string don’t count.
• \d: A shorthand character class matching any single digit, 0 through 9.
• {5}: A quantifier requiring the preceding element, \d, to repeat exactly five times.
• Regex.IsMatch(input, pattern): Returns true only if the entire input satisfies the pattern from start to end, thanks to the anchors.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string sentence = "Hello, user123!";
        string pattern = @"\b[A-Za-z]+\b";

        MatchCollection matches = Regex.Matches(sentence, pattern);

        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}Code language: C# (cs)

Explanation:

• \b[A-Za-z]+\b: Matches a sequence of one or more letters bounded by word boundaries on both sides, so it won’t match a letter run that’s part of a mixed word like “user123”.
• Regex.Matches(sentence, pattern): Scans the entire input string and returns every non-overlapping match it finds, packaged as a MatchCollection.
• foreach (Match match in matches): Iterates over each match found, since there could be zero, one, or several in a given string.
• match.Value: Extracts the actual matched text from each Match object.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] words = { "apple", "awake", "table" };
        string pattern = @"^a.{3}e$";

        foreach (string word in words)
        {
            Console.WriteLine(word + ": " + Regex.IsMatch(word, pattern));
        }
    }
}Code language: C# (cs)

Explanation:

• ^a: Anchors the match to the beginning of the string and requires the very first character to be a literal a.
• .{3}: Matches any three characters in a row, allowing the middle of the word to be anything.
• e$: Requires the string to end immediately with a literal e.
• Overall length: Since the pattern accounts for exactly 1 + 3 + 1 = 5 characters between the anchors, only exactly five-letter words starting with a and ending with e can match.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "4820";
        string pattern = @"^\d+$";

        bool isMatch = Regex.IsMatch(input, pattern);
        Console.WriteLine(isMatch);
    }
}Code language: C# (cs)

Explanation:

• ^\d+$: Requires the entire string, from start to end, to consist of one or more digit characters and nothing else.
• \d+: The + quantifier allows the pattern to match whole numbers of any length, not just a fixed number of digits.
• Rejecting other formats: A string like “48.20” or “-4820” fails this pattern, since the decimal point and minus sign aren’t digit characters.
• Anchors matter: Without ^ and $, the pattern would also match a numeric substring found anywhere inside a larger, non-numeric string.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "Hello   World";
        string pattern = @" {2,}";

        string result = Regex.Replace(text, pattern, " ");
        Console.WriteLine(result);
    }
}Code language: C# (cs)

Explanation:

• " {2,}": Matches a run of two or more consecutive space characters, using the {2,} quantifier for “two or more” repetitions.
• Regex.Replace(text, pattern, " "): Finds every matching run of spaces in the input and replaces each one with a single space character.
• Returned as a new string: The original text variable is unaffected, since strings in C# are immutable; the result is captured in a separate result variable.
• Runs of any length: Whether there are two spaces or ten spaces in a row, the {2,} quantifier matches the whole run, and it gets collapsed down to one space.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] colors = { "#FF5733", "#00A3FF", "#GG1234" };
        string pattern = @"^#[0-9A-Fa-f]{6}$";

        foreach (string color in colors)
        {
            Console.WriteLine(color + ": " + Regex.IsMatch(color, pattern));
        }
    }
}Code language: C# (cs)

Explanation:

• ^#: Anchors the match to the start of the string and requires a literal # as the very first character.
• [0-9A-Fa-f]: A character class matching any single hexadecimal digit, including both uppercase and lowercase letters A through F.
• {6}: Requires exactly six hexadecimal digits to follow the # character.
• $: Anchors the end of the match, so a string with extra characters after the six digits, or fewer than six digits, would not match.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "An elephant ate an Apple";
        string pattern = @"\b[aeiou]\w*\b";

        MatchCollection matches = Regex.Matches(text, pattern, RegexOptions.IgnoreCase);

        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}Code language: C# (cs)

Explanation:

• \b[aeiou]\w*\b: Matches a word that starts with a single vowel, followed by zero or more additional word characters, bounded by word boundaries on both sides.
• RegexOptions.IgnoreCase: Makes the character class [aeiou] also match its uppercase equivalents, so words like “An” and “Apple” are included alongside lowercase ones.
• \w*: Allows the rest of the word to be any length, including zero additional characters, so a single-letter word starting with a vowel would still match.
• Regex.Matches(text, pattern, RegexOptions.IgnoreCase): Applies the case-insensitive option only to this particular search, without affecting how the pattern would behave elsewhere.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "The total is $100, plus a $5 fee";
        string pattern = @"\$\d+";

        MatchCollection matches = Regex.Matches(text, pattern);

        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}Code language: C# (cs)

Explanation:

• \$: Escapes the dollar sign, since an unescaped $ normally represents the end-of-string anchor in regex rather than a literal character.
• \d+: Requires one or more digits to immediately follow the dollar sign, with no space or other character in between.
• Regex.Matches: Finds both occurrences in the sample text, “$100” and “$5”, even though they appear in different parts of the string.
• No upper bound on digits: \d+ matches as many digits as are actually present, so this same pattern works for both “$100” and “$5” without any changes.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] names = { "_userId", "data2", "2data" };
        string pattern = @"^[A-Za-z_]\w*$";

        foreach (string name in names)
        {
            Console.WriteLine(name + ": " + Regex.IsMatch(name, pattern));
        }
    }
}Code language: C# (cs)

Explanation:

• ^[A-Za-z_]: Requires the very first character to be a letter or an underscore, explicitly excluding digits from that position.
• \w*: Matches any number of additional letters, digits, or underscores after the first character, since \w includes all three.
• $: Anchors the end of the match, ensuring the entire string conforms to this pattern rather than just its beginning.
• Rejecting “2data”: Since the first character class doesn’t include digits, a string starting with a number fails to match right from the first character.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "Stop, look! Are you ready?";
        string pattern = @"[.,!?]";

        string result = Regex.Replace(text, pattern, "");
        Console.WriteLine(result);
    }
}Code language: C# (cs)

Explanation:

• [.,!?]: A character class listing the specific punctuation marks to match; inside a character class, a period doesn’t need to be escaped since it loses its special “any character” meaning there.
• Regex.Replace(text, pattern, ""): Replaces every character matching the class with an empty string, effectively deleting it from the result.
• Single pass: All four types of punctuation are handled by one pattern and one Replace call, rather than needing a separate call for each symbol.
• Spaces are preserved: Since the character class only targets punctuation, the spaces between words remain exactly as they were in the original text.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string email = "test.user@domain.com";
        string pattern = @"^[\w.]+@[\w.]+\.[A-Za-z]{2,4}$";

        bool isMatch = Regex.IsMatch(email, pattern);
        Console.WriteLine(isMatch);
    }
}Code language: C# (cs)

Explanation:

• [\w.]+ before the @: Matches one or more letters, digits, underscores, or periods, covering common local-part formats like “test.user”.
• @: A literal character requiring exactly one @ symbol between the local part and the domain.
• [\w.]+\.[A-Za-z]{2,4}: Matches the domain name followed by a literal period and a top-level domain of two to four letters, such as “.com” or “.org”.
• Anchors ^ and $: Ensure the entire string matches this structure, rather than just a portion of a longer string.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string date = "12/25/2026";
        string pattern = @"^(\d{2})/(\d{2})/(\d{4})$";

        Match match = Regex.Match(date, pattern);

        if (match.Success)
        {
            Console.WriteLine("Month: " + match.Groups[1].Value);
            Console.WriteLine("Day: " + match.Groups[2].Value);
            Console.WriteLine("Year: " + match.Groups[3].Value);
        }
    }
}Code language: C# (cs)

Explanation:

• (\d{2})/(\d{2})/(\d{4}): Three separate capture groups, each wrapped in parentheses, capturing the month, day, and year sections individually.
• Regex.Match(date, pattern): Returns a single Match object representing the first match found, along with access to each capture group.
• match.Groups[1], match.Groups[2], match.Groups[3]: Retrieve the captured text for the month, day, and year respectively, with index 0 representing the entire match.
• match.Success: Confirms a match was actually found before attempting to read from its groups, avoiding an error on invalid input.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string html = "<a href=\"https://example.com\">Visit</a>";
        string pattern = @"href=""([^""]+)""";

        Match match = Regex.Match(html, pattern);

        if (match.Success)
        {
            Console.WriteLine(match.Groups[1].Value);
        }
    }
}Code language: C# (cs)

Explanation:

• href="([^"]+)": Matches the literal text href=" followed by a capture group, then a literal closing quote.
• [^"]+: A negated character class matching one or more characters that are not a double quote, capturing everything up until the next quote is found.
• match.Groups[1].Value: Retrieves just the captured URL, without the surrounding href=" and closing quote that were part of the overall match but not part of the group.
• Literal double quotes in the pattern: Written as "" inside a verbatim string, since a verbatim string represents a literal double quote by doubling it.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] phones = { "555-867-5309", "(555) 867-5309", "555.867.5309" };
        string pattern = @"^(\d{3}-\d{3}-\d{4}|\(\d{3}\) \d{3}-\d{4})$";

        foreach (string phone in phones)
        {
            Console.WriteLine(phone + ": " + Regex.IsMatch(phone, pattern));
        }
    }
}Code language: C# (cs)

Explanation:

• \d{3}-\d{3}-\d{4}: The first alternative, matching three digits, a dash, three more digits, another dash, and four final digits.
• \(\d{3}\) \d{3}-\d{4}: The second alternative, with the parentheses escaped using \( and \), since unescaped parentheses would otherwise define a group rather than match literal characters.
• |: The alternation operator, allowing the overall pattern to match either the first format or the second format.
• Rejecting other formats: A string using periods instead of dashes, like “555.867.5309”, doesn’t match either alternative, so it correctly returns false.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string url = "https://github.com/features";
        string pattern = @"https://([^./]+)\.\w+";

        Match match = Regex.Match(url, pattern);

        if (match.Success)
        {
            Console.WriteLine(match.Groups[1].Value);
        }
    }
}Code language: C# (cs)

Explanation:

• https://: Matches the literal protocol prefix at the start of the URL, ensuring the pattern only applies to URLs written this way.
• ([^./]+): A capture group using a negated character class to match one or more characters that are not a period or a forward slash, isolating just the “github” portion.
• \.\w+: Matches the literal period followed by the top-level domain, such as “com”, without including it inside the capture group.
• match.Groups[1].Value: Extracts only the captured domain name, ignoring both the protocol prefix and the top-level domain that surround it in the full match.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "This is the the end.";
        string pattern = @"\b(\w+)\s+\1\b";

        Match match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);

        if (match.Success)
        {
            Console.WriteLine(match.Value);
        }
    }
}Code language: C# (cs)

Explanation:

• (\w+): Captures a single word into the first group, storing whatever sequence of word characters is matched.
• \s+: Matches the whitespace separating the two occurrences of the word.
• \1: A backreference to the first capture group, requiring the exact same text captured earlier to appear again at this position.
• \b at both ends: Ensures the match starts and ends cleanly on word boundaries, so it identifies whole duplicated words rather than partial matches within longer words.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] values = { "-45.67", "100", "3.14", "-8" };
        string pattern = @"^-?\d+(\.\d+)?$";

        foreach (string value in values)
        {
            Console.WriteLine(value + ": " + Regex.IsMatch(value, pattern));
        }
    }
}Code language: C# (cs)

Explanation:

• -?: Makes the leading minus sign optional, so both positive and negative numbers can match the same pattern.
• \d+: Requires one or more digits for the main integer portion of the number.
• (\.\d+)?: Groups a literal period followed by one or more digits, then makes the entire group optional, allowing the pattern to match whole numbers that have no decimal portion at all.
• Anchors ^ and $: Ensure the full string represents a single valid number, rather than just containing one somewhere within a longer string.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string logEntry = "[ERROR] Connection failed.";
        string pattern = @"^\[[A-Z]+\]";

        Match match = Regex.Match(logEntry, pattern);

        if (match.Success)
        {
            Console.WriteLine(match.Value);
        }
    }
}Code language: C# (cs)

Explanation:

• ^: Anchors the match to the very beginning of the string, so the tag must appear as the first thing in the log entry.
• \[ and \]: Escape the literal square brackets, since unescaped brackets normally define a character class in regex.
• [A-Z]+: Matches one or more uppercase letters between the brackets, covering tags of different lengths like INFO, ERROR, and WARNING with the same pattern.
• match.Value: Returns the entire match, including the brackets, since this exercise wants the tag exactly as it appears, not just the letters inside it.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string password = "P@ssword123";
        string pattern = @"^(?=.*\d).{8,16}$";

        bool isMatch = Regex.IsMatch(password, pattern);
        Console.WriteLine(isMatch);
    }
}Code language: C# (cs)

Explanation:

• (?=.*\d): A positive lookahead requiring at least one digit to appear somewhere later in the string, without consuming any characters itself.
• .{8,16}: Matches the actual string content, requiring its total length to fall between 8 and 16 characters.
• Order matters conceptually, not positionally: Since the lookahead doesn’t consume characters, it can sit right at the start and still check the digit requirement across the whole string that .{8,16} later matches.
• Anchors ^ and $: Ensure both conditions, the digit requirement and the length range, apply to the complete password string rather than a substring of it.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "He said \"Secret Message\".";
        string pattern = @"""([^""]+)""";

        Match match = Regex.Match(text, pattern);

        if (match.Success)
        {
            Console.WriteLine(match.Groups[1].Value);
        }
    }
}Code language: C# (cs)

Explanation:

• "" in a verbatim string: A doubled double-quote represents a single literal double-quote character within the pattern.
• ([^"]+): A capture group matching one or more characters that are not a double quote, isolating the text found between the two quote marks.
• Surrounding literal quotes: Match the opening and closing double quotes themselves, but since they sit outside the parentheses, they aren’t included in the captured group.
• match.Groups[1].Value: Returns only the inner text, “Secret Message”, without the quote marks that surrounded it in the original string.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "Total Price: 49.99";
        string pattern = @"(?<=Price: )\d+\.\d+";

        Match match = Regex.Match(text, pattern);

        if (match.Success)
        {
            Console.WriteLine(match.Value);
        }
    }
}Code language: C# (cs)

Explanation:

• (?<=Price: ): A lookbehind assertion requiring the literal text “Price: ” to appear immediately before the current position, without that text becoming part of the match.
• \d+\.\d+: Matches the numeric price itself, requiring digits, a literal decimal point, and more digits.
• match.Value: Contains only “49.99”, since the lookbehind’s text, “Price: “, was checked but never consumed or included in the result.
• Positional requirement: This pattern would not match a number that isn’t immediately preceded by “Price: “, such as a quantity or a different label entirely.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string html = "<p>Hello</p>";
        string pattern = @"<[^>]+>";

        string result = Regex.Replace(html, pattern, "");
        Console.WriteLine(result);
    }
}Code language: C# (cs)

Explanation:

• <[^>]+>: Matches a literal opening angle bracket, one or more characters that aren’t a closing angle bracket, and a literal closing angle bracket, capturing an entire tag as a single match.
• [^>]+: Prevents the match from accidentally spanning across two separate tags, since it stops as soon as it hits the first closing angle bracket.
• Regex.Replace(html, pattern, ""): Removes every matched tag from the string, since Replace with an empty string effectively deletes whatever the pattern finds.
• Result: Only the plain text content, “Hello”, remains once both the opening and closing tags have been stripped out.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string config = "Timeout=30";
        string pattern = @"(?<key>\w+)=(?<value>\w+)";

        Match match = Regex.Match(config, pattern);

        if (match.Success)
        {
            Console.WriteLine("Key: " + match.Groups["key"].Value);
            Console.WriteLine("Value: " + match.Groups["value"].Value);
        }
    }
}Code language: C# (cs)

Explanation:

• (?<key>\w+): Defines a named capture group called “key”, matching one or more word characters before the equals sign.
• (?<value>\w+): Defines a second named capture group called “value”, matching one or more word characters after the equals sign.
• match.Groups["key"] and match.Groups["value"]: Retrieve each captured piece of text using its descriptive name, rather than remembering which numeric index corresponds to which group.
• Readability benefit: Named groups make patterns with several captured pieces much easier to work with correctly, especially as a pattern grows more complex.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string ip = "192.168.1.254";
        string octet = @"(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)";
        string pattern = "^" + octet + @"\." + octet + @"\." + octet + @"\." + octet + "$";

        bool isMatch = Regex.IsMatch(ip, pattern);
        Console.WriteLine(isMatch);
    }
}Code language: C# (cs)

Explanation:

• 25[0-5]: The first alternative, matching numbers from 250 to 255.
• 2[0-4]\d: The second alternative, matching numbers from 200 to 249.
• 1\d\d: The third alternative, matching any three-digit number from 100 to 199.
• [1-9]?\d: The final alternative, matching any one or two digit number from 0 to 99, with the leading digit optional so single-digit octets like “5” are still valid.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string[] words = { "product", "programming", "profile" };
        string pattern = @"^pro(?!.*ing$)\w*$";

        foreach (string word in words)
        {
            Console.WriteLine(word + ": " + Regex.IsMatch(word, pattern));
        }
    }
}Code language: C# (cs)

Explanation:

• ^pro: Anchors the match to the start of the string and requires the literal prefix “pro”.
• (?!.*ing$): A negative lookahead checking that the rest of the string does not end in “ing”; if it does, the overall match fails at this position.
• \w*$: Matches the remainder of the word after the lookahead succeeds, anchored to the end of the string.
• Rejecting “programming”: Even though it starts with “pro”, the negative lookahead detects the “ing” ending later in the string and prevents a match, while “product” and “profile” pass through since neither ends that way.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string mac = "00:1A:2B:3C:4D:5E";
        string pattern = @"^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$";

        bool isMatch = Regex.IsMatch(mac, pattern);
        Console.WriteLine(isMatch);
    }
}Code language: C# (cs)

Explanation:

• [0-9A-Fa-f]{2}: Matches exactly two hexadecimal digits, representing one byte of the MAC address.
• [:-]: A character class allowing either a colon or a hyphen as the separator between each pair of digits.
• ([0-9A-Fa-f]{2}[:-]){5}: Groups the pair-and-separator combination together and repeats it exactly five times, covering the first five bytes of the address.
• [0-9A-Fa-f]{2}$: Matches the sixth and final pair of digits with no trailing separator, anchored to the end of the string.

using System;
using System.Text.RegularExpressions;
using System.Diagnostics;

class Program
{
    static void Main()
    {
        string input = new string('a', 30) + "!";
        string pattern = @"^(a+)+$";

        Regex regex = new Regex(pattern, RegexOptions.NonBacktracking);

        Stopwatch stopwatch = Stopwatch.StartNew();
        bool isMatch = regex.IsMatch(input);
        stopwatch.Stop();

        Console.WriteLine("Match: " + isMatch);
        Console.WriteLine("Completed in " + stopwatch.ElapsedMilliseconds + " ms");
    }
}Code language: C# (cs)

Explanation:

• RegexOptions.NonBacktracking: Switches the regex engine to a linear-time matching algorithm, which cannot exhibit the exponential slowdown that a classic backtracking engine can hit on patterns like nested repetition.
• (a+)+: A deliberately vulnerable pattern structure, an inner repetition wrapped in an outer repetition, that’s known to cause catastrophic backtracking against certain crafted inputs under a normal backtracking engine.
• Stopwatch: Measures how long the match takes, illustrating that the non-backtracking engine completes quickly even against an input designed to be adversarial.
• Trade-off: NonBacktracking mode doesn’t support every regex feature, such as backreferences or lookaround, so it’s chosen specifically for patterns and use cases where guaranteed linear-time matching matters more than those features.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "camelCaseExample";
        string pattern = @"(?<=[a-z])(?=[A-Z])";

        string[] words = Regex.Split(text, pattern);

        foreach (string word in words)
        {
            Console.WriteLine(word);
        }
    }
}Code language: C# (cs)

Explanation:

• (?<=[a-z]): A lookbehind confirming the character immediately before the current position is a lowercase letter.
• (?=[A-Z]): A lookahead confirming the character immediately after the current position is an uppercase letter.
• Combined lookbehind and lookahead: Together they pinpoint the exact boundary between a lowercase letter and an uppercase letter without matching or consuming either character.
• Regex.Split(text, pattern): Splits the original string at every position the pattern matches, producing “camel”, “Case”, and “Example” as three separate array elements.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string code = "int x = 5; // set x\n/* TODO: fix */";
        string pattern = @"//.*|/\*.*?\*/";

        MatchCollection matches = Regex.Matches(code, pattern);

        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
    }
}Code language: C# (cs)

Explanation:

• //.*: Matches two literal forward slashes followed by any characters up to, but not including, the newline, capturing a single-line comment.
• /\*.*?\*/: Matches a literal /*, followed by as few characters as possible, followed by a literal */; the non-greedy .*? stops at the very first */ it finds, avoiding accidentally spanning multiple separate block comments.
• |: Combines the two alternatives, so the pattern matches either style of comment wherever it appears.
• Default . behavior: Since . doesn’t match a newline character by default, the single-line comment alternative naturally stops at the end of its line without needing an explicit anchor.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string cardNumber = "4111-2222-3333-4444";
        string pattern = @"\d{4}[- ]\d{4}[- ]\d{4}([- ]\d{4})";

        string masked = Regex.Replace(cardNumber, pattern, "XXXX-XXXX-XXXX$1");
        Console.WriteLine(masked);
    }
}Code language: C# (cs)

Explanation:

• \d{4}[- ]\d{4}[- ]\d{4}: Matches the first three groups of four digits, each followed by a dash or a space, without wrapping them in a capture group since they’ll be discarded entirely from the output.
• ([- ]\d{4}): Captures the final separator together with the last four digits, preserving that portion so it can be reused in the replacement.
• "XXXX-XXXX-XXXX$1": The replacement string; $1 inserts whatever was captured by the first group, appending the real final separator and last four digits after the fixed masked portion.
• Result: The first twelve digits, along with their original separators, are replaced by literal X’s and dashes, while the actual last four digits from the input remain visible in the output.