What is the best way to find length of split characters from the given string by using String.Split() Method or Linq Lambda Expression in C#

Question

I have String called "RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa". I want to know number of "a" characters available in the give String. As per my knowledge I found two ways to find the count. That are: 1) By using String.Split() 2) Linq Lambda Expression

My Observations:

1) If i use String.Split() it is returning wrong result 2) If i use Linq Lambda Expression it is returning correct result.

Here my doubt is how can i get the count of the given split character from the given string by using String.Split()

And also please suggest me which is the best way to get count of the given split character from the given string either "String.Split()" or "Linq Lambda" expression?

Please find the complete example:

                                                                                                                   using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SplitData
{
    class Program
    {
        static void Main(string[] args)
        {
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'a');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'r');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'R');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'm');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'd');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'g');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 's');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'o');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'c');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'u');
            SplitData("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'f');


            Console.ReadKey();
        }

        private static void SplitData(string data,char split)
        {

            // using lambda expresion
            int len = data.AsEnumerable().Where(x => x.ToString().ToLower().Contains(split)).Count();  
            Console.WriteLine("Total '" + split + "' available are:{0} using lambda", len.ToString());

            //using normal split function
            len = data.Split(split).Length;

            Console.WriteLine("Total '" + split + "' available are:{0} using normal split", len.ToString());


        }
    }
}

Answer 1

string str = "RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa";
int countA = str.Count(r => r == 'a');

If you want case insensitive count then:

string str = "RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa";
char searchChar = 'a';
int countA = str.Count(r => char.ToUpperInvariant(r) == char.ToUpperInvariant(searchChar));

If you ask for best option between string.Split and Linq Count, then IMO, LINQ is more readable. I am not sure about the performance but I suspect LINQ version to be faster.

---

If you want to use string.Split and make it case insensitive then construct a character array of two elements, (with upper case and lower case) and then use Split like:

string str = "RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa";
char searchChar = 'a';
char[] delimeters = new char[2];
delimeters[0] = char.ToLowerInvariant(searchChar);
delimeters[1] = char.ToUpperInvariant(searchChar);
var count = str.Split(delimeters).Length - 1;

Answer 2

You mean you want to count the occurances of a letter? Like this?

String data = "RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa";
Char letter = 'a';
Int32 totalOccurances = data.Count(character => character == letter);

Answer 3

For case-insensitive comparison, you can use a StringComparer instance or equivalent StringComparison enum.. As far as how you want to write it, pick your poison. =)

// caller specifies comparison type
int Count1(string str, char searchChar, StringComparison comparison = StringComparison.CurrentCultureIgnoreCase)
{
    string searchStr = searchChar.ToString();
    int count = 0;
    for (int i = 0; i < str.Length; i++)
        if (string.Equals(searchStr, str[i].ToString(), comparison))
            count++;
    return count;
}
// ordinal comparison
int Count2(string str, char searchChar)
{
    string searchStr = searchChar.ToString();
    int count = 0;
    for (int i = 0; i < str.Length; i++)
        if (searchChar == str[i])
            count++;
    return count;
}
// ordinal comparison
int Count3(string str, char searchChar)
{
    return str.Split(searchChar).Length - 1;
}
// ordinal comparison
int Count4(string str, char searchChar)
{
    return str.Count(c => c == searchChar);
}
// caller specifies comparison type
int Count5(string str, char searchChar, StringComparison comparison = StringComparison.CurrentCultureIgnoreCase)
{
    string searchStr = searchChar.ToString();
    return str.Count(c => string.Equals(c.ToString(), searchStr, comparison));
}

Answer 4

Not a fancy LINQ solution but nevertheless

int count = CountChar("RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa", 'a');
.....

int CountChar(string input, char toFind)
{
    int count = 0;
    int pos = -1;
    while((pos = input.IndexOf(toFind, pos+1)) != -1)
        count++;
    return count;
}

String.IndexOf starting from a position
and there is also the case insensitive option

EDIT: Well now I was curious and decided to measure the timing with this and the lambda solution.
The difference is remarkable.....

void Main()
{
    string str = "RamaSubbaReddyabcdaacacakkkoooahgafffgahgghsa";
    Stopwatch sw = new Stopwatch();
    sw.Start();
    for(int i = 0; i < 10000000; i++)
    {
        int count = CountChar(str, 'a');
     }   
    sw.Stop();
    Console.WriteLine("Using IndexOf:" + sw.ElapsedMilliseconds.ToString());  
    sw.Reset();
    sw.Start();
    for(int i = 0; i < 10000000; i++)
    {
        int countA = str.Count(r => r == 'a');
    }
    sw.Stop();
    Console.WriteLine("Using Count:" + sw.ElapsedMilliseconds.ToString());
}

The first loop ends in 1160 milliseconds and the second one in 6200 milliseconds.
Can someone spot if there are problems in this measurements?