Regex to extract initials from Name

Personally, I prefer this Regex

Regex initials = new Regex(@"(\b[a-zA-Z])[a-zA-Z]* ?");
string init = initials.Replace(nameString, "$1");
//Init = "JD"

That takes care of initials, and whitespace removal (thats the ' ?' at the end there).

The only thing you have to worry about are titles and puctuation like Jr. or Sr., or Mrs....etc etc. Some people do include those in their full names

Here is my solution. My goal was not to provide the simplest solution, but one that can take a variety of (sometimes weird) name formats, and generate the best guess at a first and last name initial (or in the case of mononymous people) a single initial.

I also tried to write it in a way that is relatively international-friendly, with unicode regexes, although I don't have any experience in generating initials for many kinds of foreign names (e.g. Chinese), though it should at least generate something usable to represent the person, in under two characters. For example, feeding it a name in Korean like "행운의 복숭아" will yield 행복 as you might have expected (although perhaps that is not right way to do it in Korean culture).

/// <summary>
/// Given a person's first and last name, we'll make our best guess to extract up to two initials, hopefully
/// representing their first and last name, skipping any middle initials, Jr/Sr/III suffixes, etc. The letters 
/// will be returned together in ALL CAPS, e.g. "TW". 
/// 
/// The way it parses names for many common styles:
/// 
/// Mason Zhwiti                -> MZ
/// mason lowercase zhwiti      -> MZ
/// Mason G Zhwiti              -> MZ
/// Mason G. Zhwiti             -> MZ
/// John Queue Public           -> JP
/// John Q. Public, Jr.         -> JP
/// John Q Public Jr.           -> JP
/// Thurston Howell III         -> TH
/// Thurston Howell, III        -> TH
/// Malcolm X                   -> MX
/// A Ron                       -> AR
/// A A Ron                     -> AR
/// Madonna                     -> M
/// Chris O'Donnell             -> CO
/// Malcolm McDowell            -> MM
/// Robert "Rocky" Balboa, Sr.  -> RB
/// 1Bobby 2Tables              -> BT
/// Éric Ígor                   -> ÉÍ
/// 행운의 복숭아                 -> 행복
/// 
/// </summary>
/// <param name="name">The full name of a person.</param>
/// <returns>One to two uppercase initials, without punctuation.</returns>
public static string ExtractInitialsFromName(string name)
{
    // first remove all: punctuation, separator chars, control chars, and numbers (unicode style regexes)
    string initials = Regex.Replace(name, @"[\p{P}\p{S}\p{C}\p{N}]+", "");

    // Replacing all possible whitespace/separator characters (unicode style), with a single, regular ascii space.
    initials = Regex.Replace(initials, @"\p{Z}+", " ");

    // Remove all Sr, Jr, I, II, III, IV, V, VI, VII, VIII, IX at the end of names
    initials = Regex.Replace(initials.Trim(), @"\s+(?:[JS]R|I{1,3}|I[VX]|VI{0,3})$", "", RegexOptions.IgnoreCase);

    // Extract up to 2 initials from the remaining cleaned name.
    initials = Regex.Replace(initials, @"^(\p{L})[^\s]*(?:\s+(?:\p{L}+\s+(?=\p{L}))?(?:(\p{L})\p{L}*)?)?$", "$1$2").Trim();

    if (initials.Length > 2)
    {
        // Worst case scenario, everything failed, just grab the first two letters of what we have left.
        initials = initials.Substring(0, 2);
    }

    return initials.ToUpperInvariant();
}

This is my approach:

public static string GetInitials(string names) {
    // Extract the first character out of each block of non-whitespace
    // exept name suffixes, e.g. Jr., III. The number of initials is not limited.
    return Regex.Replace(names, @"(?i)(?:^|\s|-)+([^\s-])[^\s-]*(?:(?:\s+)(?:the\s+)?(?:jr|sr|II|2nd|III|3rd|IV|4th)\.?$)?", "$1").ToUpper();
}

Handled cases:

// Mason Zhwiti                               -> MZ
// mason zhwiti                               -> MZ
// Mason G Zhwiti                             -> MGZ
// Mason G. Zhwiti                            -> MGZ
// John Queue Public                          -> JQP
// John-Queue Public                          -> JQP
// John Q. Public, Jr.                        -> JQP
// John Q Public Jr.                          -> JQP
// John Q Public Jr                           -> JQP
// John Q Public Jraroslav                    -> JQPJ
// Thurston Howell III                        -> TH
// Thurston Howell, III                       -> TH
// Thurston Howell the III                    -> TH
// Malcolm X                                  -> MX
// A Ron                                      -> AR
// A A Ron                                    -> AAR
// Madonna                                    -> M
// Chris O'Donnell                            -> CO
// Chris O' Donnell                           -> COD
// Malcolm McDowell                           -> MM
// Éric Ígor                                  -> ÉÍ
// 행운의 복숭아                               -> 행복

Not handled cases:

// James Henry George Michael III the second  -> JHGMIts
// Robert "Rocky" Balboa, Sr.                 -> R"B
// 1Bobby 2Tables                             -> 12 (is it a real name?)

How about this?

var initials = Regex.Replace( "John Deer", "[^A-Z]", "" );