Adding an incremental number to duplicate string

Question

I'm working in c# (.Net4 using Visual Studio) and I'm trying to figure out an algorithm to append incremental numbers to strings entered, based on existing strings in the program. Not doing too well searching around for an answer.

I have a List<string>. An example would be

{"MyItem (2)", "MyItem", "Other thing", "string here", "MyItem (1)"}

So say the user wants to add another string to this list, and they've selected "MyItem" as the string to add. So given the input and the existing list, the algorithm would return "MyItem (3)" as the new string to add.

It's the same function as in Windows Explorer where you keep adding New Folders ("New Folder (1)", "New Folder (2)" and on and on)

I'm trying just looping through the list and figuring out what the next logical number should be but I'm getting stuck (and the code's getting large). Anyone know an elegent way of doing this? (I'm not too good with Regex so maybe that's what I'm missing)

Answer 1

The following is a useful extension method that I came up with to simulate the behaviour of Windows Explorer.

The previous answers I feel were too simple and only partially satisfied the requirements, they were also not presented in a way that you could easily reuse them.

This solution is based on you first identifying the list of strings that you want to compare against, they might come from a file system, or database, its up to you to resolve the list of values from your business domain, then the process of identifying the duplicates and generating a unique values is very repeatable.

Extension Method:

/// <summary>
/// Generate a uniquely numbered string to insert into this list
/// Uses convention of appending the value with the duplication index number in brackets "~ (#)"
/// </summary>
/// <remarks>This will not actually add this list</remarks>
/// <param name="input">The string to evaluate against this collection</param>
/// <param name="comparer">[Optional] One of the enumeration values that specifies how the strings will be compared, will default to OrdinalIgnoreCase </param>
/// <returns>A numbered variant of the input string that would be unique in the list of current values</returns>
public static string GetUniqueString(this IList<string> currentValues, string input, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
{
    // This matches the pattern we are using, i.e. "A String Value (#)"
    var regex = new System.Text.RegularExpressions.Regex(@"\(([0-9]+)\)$");

    // this is the comparison value that we want to increment
    string prefix = input.Trim();
    string result = input.Trim();

    // let it through if there is no current match
    if (currentValues.Any(x => x.Equals(input, comparison)))
    {
        // Identify if the input value has already been incremented (makes this more reusable)
        var inputMatch = regex.Match(input);
        if (inputMatch.Success)
        {
            // this is the matched value
            var number = inputMatch.Groups[1].Captures[0].Value;
            // remove the numbering from the alias to create the prefix
            prefix = input.Replace(String.Format("({0})", number), "").Trim();
        }

        // Now evaluate all the existing items that have the same prefix
        // NOTE: you can do this as one line in Linq, this is a bit easier to read
        // I'm trimming the list for consistency
        var potentialDuplicates = currentValues.Select(x => x.Trim()).Where(x => x.StartsWith(prefix, comparison));
        int count = 0;
        int maxIndex = 0;
        foreach (string item in potentialDuplicates)
        {
            // Get the index from the current item
            var indexMatch = regex.Match(item);
            if (indexMatch.Success)
            {
                var index = int.Parse(indexMatch.Groups[1].Captures[0].Value);
                var test = item.Replace(String.Format("({0})", index), "").Trim();
                if (test.Equals(prefix, comparison))
                {
                    count++;
                    maxIndex = Math.Max(maxIndex, index);
                }
            }
        }
        int nextIndex = Math.Max(maxIndex, count) + 1;
        result = string.Format("{0} ({1})", prefix, nextIndex);
    }

    return result;
}

Implementation:

var list = new string [] { "MyItem (2)", "MyItem", "Other thing", "string here", "MyItem (1)" };
string input = Console.ReadLine(); // simplify testing, thanks @selman-genç

var result = list.GetUniqueString(input, StringComparison.OrdinalIgnoreCase);

// Display the result, you can add it to the list or whatever you need to do
Console.WriteLine(result);

Input        |   Result
---------------------------------
MyItem       |   MyItem (3)
myitem (1)   |   myitem (3)
MyItem (3)   |   MyItem (3)
MyItem (4)   |   MyItem (4)
MyItem 4     |   MyItem 4
String Here  |   String Here (1)
a new value  |   a new value

Answer 2

Get the input and search for it, if it's present in the list then get the count and concatenate input string and count + 1 otherwise just add the input to the list:

var input = Console.ReadLine(); // just for example

if(list.Any(x => x == input))
{
    var count = list.Count(x => x == input);
    list.Add(string.Format("{0} ({1})", input, count+1);
} 
else list.Add(input);

Answer 3

Pseudo-code: If the list has no such string, add it to the list. Otherwise, set variable N = 1. Scan the list and look for strings like the given string + " (*)" (here Regex would help). If any string is found, take the number from the braces and compare it against N. Set N = MAX( that number + 1, N ). After the list has been scanned, N contains the number to add. So, add the string + " (N)" to the list.

Answer 4

This should work:

var list = new List<string>{"MyItem (2)", "MyItem", "Other thing", "string here", "MyItem (1)"}   ; 

string str = "MyItem";
string newStr = str;

int i = 0;
while(list.Contains(newStr))
{
   i++;
   newStr = string.Format("{0} ({1})",str,i);
}

// newStr = "MyItem (3)"