Seperating numbers, punctuation and letters trought the whole case

Question

What I'm trying to achieve: Split the string into separate parts of numbers, punctuation(except the . and , these should be found in the number part), and letters. Example:

Case 1: C_TANTALB

Result:

Alpha[]: C, TANTALB
Beta[]:
Zeta[]: _

Case 2: BGA-100_T0.8

Result:

Alpha[]: BGA, T
Beta[]: 100, 0.8
Zeta[]: -, _

Case 3: C0201

Result:

Alpha[]: C
Beta[]: 0201
Zeta[]: 

I've found this post but it doesn't the entire job for me as it fails on example 1 not returning even the alpha part. And it doesn't find the punctuation.

Any help would be appricated.

Answer 1

Probably the simplest way to do this is with 3 separate regular expressions; one for each class of characters.

• [A-Za-z]+ for letter sequences
• [\d.,]+ for numbers
• [-_]+ for punctuation (incomplete for now; please feel free to extend the list)

Example:

using System;
using System.Linq;
using System.Text.RegularExpressions;

class MainClass
{
  private static readonly Regex _regexAlpha = new Regex(@"[A-Za-z]+");
  private static readonly Regex _regexBeta = new Regex(@"[\d.,]+");
  private static readonly Regex _regexZeta = new Regex(@"[-_]+");

  public static void Main (string[] args)
  {
    Console.Write("Input: ");
    string input = Console.ReadLine();

    var resultAlpha = _regexAlpha.Matches(input).Select(m => m.Value);
    var resultBeta = _regexBeta.Matches(input).Select(m => m.Value);
    var resultZeta = _regexZeta.Matches(input).Select(m => m.Value);

    Console.WriteLine($"Alpha: {string.Join(", ", resultAlpha)}");
    Console.WriteLine($"Beta: {string.Join(", ", resultBeta)}");
    Console.WriteLine($"Zeta: {string.Join(", ", resultZeta)}");
  }
}

Sample output:

Input: ABC_3.14m--nop
Alpha: ABC, m, nop
Beta: 3.14
Zeta: _, --

Live demo: https://repl.it/repls/LopsidedUsefulBucket

Answer 2

If iterating the string an test with IsDigit and IsLetter a bit to complexe,
You can use Regex for this : (?<Alfas>[a-zA-Z]+)|(?<Digits>\d+)|(?<Others>[^a-zA-Z\d])

1/. Named Capture Group Alfas (?<Alfas>[a-zA-Z]+)

Match a single character present in the list below [a-zA-Z]+

a-z a single character in the range between a (index 97) and z (index 122) (case sensitive)
A-Z a single character in the range between A (index 65) and Z (index 90) (case sensitive)

+ Quantifier — Matches between one and unlimited times, as many times as possible, giving back as needed (greedy)

2/. Named Capture Group Digits (?<Digits>[\d,.]+)

\d+ matches a digit (equal to [0-9])
+ Quantifier — Matches between one and unlimited times, as many times as possible, giving back as needed (greedy)

3/. Named Capture Group Others (?<Others>[^a-zA-Z\d]+)

Match a single character not present in the list below [^a-zA-Z\d]

a-z a single character in the range between a (index 97) and z (index 122) (case sensitive)
A-Z a single character in the range between A (index 65) and Z (index 90) (case sensitive)
\d matches a digit (equal to [0-9])

+ Quantifier — Matches between one and unlimited times, as many times as possible, giving back as needed (greedy)

Then to get one goup values:

var matches = Regex.Matches(testInput, pattern).Cast<Match>();
            
var alfas = matches.Where(x => !string.IsNullOrEmpty(x.Groups["Alfas"].Value))
                    .Select(x=> x.Value)
                    .ToList();

LiveDemo