Question

I’m working on a WinForms app that accepts numeric strings as an input. If my user is entering a contiguous range of numbers, he/she may represent that range using a shorthand notation like this:

12[3-5]5550[000-100]

Using that example, I need to expand that string into the entire range of numbers that it encompasses like this:

1235550000
1235550001
1235550002
..........
1235550100

1245550000
1245550001
1245550002
..........
1245550100

1255550000
1255550001
1255550002
..........
1255550100

With the exception of 0-9, the strings will only contain [, – and ] which are the characters used to represent a range. As a part of the process of expanding the example string into individual numbers, I would like to validate the string, as well. For example, there must be an equal number of [ and ] characters. Inside of the brackets, the first number in the range must be less than the second number in the range. These types of things.

Is there an existing pattern that performs this kind of string manipulation?

Answer 1

There is nothing built in library in .net, that you can use. Your task is quite complex, considering that you want validation as well. I have created a small solution for generation of strings based on your initial input. Note this isn’t a production code and I have omitted some checks. This code only shown’s one possible way of how it could be done and is open to critique. Token represent each logical piece of your string, which in your case either a literal, or a range specifier.

class Token
{
    public string Value { get; set; }

    public IEnumerable<string> GetAllValues()
    {
        if(IsRange(Value))
        {
            var rangeValues = Value.Split(new[] {'[', '-', ']'}, StringSplitOptions.RemoveEmptyEntries);
            //numeric format defines minimal string length. [01-10] will have numericFormat = "{0:00}"
            string numericFormat = CreateNumericFormat(rangeValues.ElementAt(0).Length);

            int[] ranges = rangeValues.Select(val => int.Parse(val)).ToArray();

            foreach (var val in GetRange(ranges[0], ranges[1]))
                yield return string.Format(numericFormat, val);
        }
        else
        {
            yield return Value;
        }
    }
    //validation is ommited
    private bool IsRange(string val)
    {
        return Value.Contains("-");
    }
    private string CreateNumericFormat(int minimalLength)
    {
        return "{0:"+new string('0', minimalLength)+"}";
    }
    private IEnumerable<int> GetRange(int minValue, int maxValue)
    {
        return Enumerable.Range(minValue, maxValue - minValue + 1);
    }
}

Now usage is quite straightforward:

var initial = "12[05-10]3[008-010]";

var regularExp = @"\[\s*\d+\s*-\s*\d+\s*\]|\d+";

List<Token> tokens = new List<Token>();


foreach (Match match in Regex.Matches(initial , regularExp ))
{
    tokens.Add(new Token {Value = match.Value});
}


IEnumerable<string> result = new []{""};//empty source for start

foreach(var token in tokens)
{
    result = from v1 in result
             from v2 in token.GetAllValues()
             select v1 + v2;
}
//Dump is LinqPad specific call
result.Dump();

Prints:

12053008 
12053009 
12053010 
12063008 
12063009 
12063010 
12073008 
12073009 
12073010 
12083008 
12083009 
12083010 
12093008 
12093009 
12093010 
12103008 
12103009 
12103010