c# how to check whether a Long string contains any letters or not?

Question

Okay so I have a long string of digits, but I need to make sure it hasn't got any digits, whats the easiest way to do this?

Answer 1

You could use char.IsDigit:

var containsOnlyDigits = "007".All(char.IsDigit); // true

Answer 2

Scan the string, test the char... s.All(c => Char.IsDigit(c))

Enumerable.All will exit as soon as it finds a non-digit characted. IsDigit is very fast at checking the char. Cost is O(N) (as good as it can get); for sure, it is bettet than trying to parse the string (which will fail if the string is really long) or use a regexpr...

If you try this solution and see it is too slow for you, you can always go back to good old loops to scan the string..

foreach (char c in s) { 
   if (!Char.IsDigit(c))
      return false;
}
return true;

or even better:

for (int i = 0; i < s.Length; i++){
   if (!Char.IsDigit(s[i]))
      return false;
}
return true;

---

EDIT: Benchmarks, at last!

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


namespace FindTest
{
    class Program
    {


        const int Iterations = 1000;

        static string TestData;
        static Regex regex;
        static bool ValidResult = false;


        static void Test(Func<string, bool> function)
        {
            Console.Write("{0}... ", function.Method.Name);
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < Iterations; i++)
            {
                bool result = function(TestData);
                if (result != ValidResult)
                {
                    throw new Exception("Bad result: " + result);
                }
            }
            sw.Stop();
            Console.WriteLine(" {0}ms", sw.ElapsedMilliseconds);
            GC.Collect();
        }

        static void InitializeTestDataEnd(int length)
        {
            TestData = new string(Enumerable.Repeat('1', length - 1).ToArray()) + "A";
        }

        static void InitializeTestDataStart(int length)
        {
            TestData = "A" + new string(Enumerable.Repeat('1', length - 1).ToArray());
        }

        static void InitializeTestDataMid(int length)
        {
            TestData = new string(Enumerable.Repeat('1', length / 2).ToArray()) + "A" + new string(Enumerable.Repeat('1', length / 2 - 1).ToArray());
        }

        static void InitializeTestDataPositive(int length)
        {
            TestData = new string(Enumerable.Repeat('1', length).ToArray());
        }

        static bool LinqScan(string s)
        {
            return s.All(Char.IsDigit);
        }

        static bool ForeachScan(string s)
        {
            foreach (char c in s)
            {
                if (!Char.IsDigit(c))
                    return false;
            }
            return true;
        }

        static bool ForScan(string s)
        {
            for (int i = 0; i < s.Length; i++)
            {
                if (!Char.IsDigit(s[i]))
                    return false;
            }
            return true;
        }

        static bool Regexp(string s)
        {
            // String contains numbers
            return regex.IsMatch(s);

           // String contains letters
           //return Regex.IsMatch(s, "\\w", RegexOptions.Compiled);
        }

        static void Main(string[] args)
        {
            regex = new Regex(@"^\d+$", RegexOptions.Compiled);

            Console.WriteLine("Positive (all digitis)");

            InitializeTestDataPositive(100000);
            ValidResult = true;            

            Test(LinqScan);
            Test(ForeachScan);
            Test(ForScan);
            Test(Regexp);

            Console.WriteLine("Negative (char at beginning)");
            InitializeTestDataStart(100000);
            ValidResult = false;            

            Test(LinqScan);
            Test(ForeachScan);
            Test(ForScan);
            Test(Regexp);

            Console.WriteLine("Negative (char at end)");
            InitializeTestDataEnd(100000);
            ValidResult = false;

            Test(LinqScan);
            Test(ForeachScan);
            Test(ForScan);
            Test(Regexp);

            Console.WriteLine("Negative (char in middle)");
            InitializeTestDataMid(100000);
            ValidResult = false;

            Test(LinqScan);
            Test(ForeachScan);
            Test(ForScan);
            Test(Regexp);

            Console.WriteLine("Done");
        }
    }
}

I tested positive, and three negatives, to 1) test which regex is the correct one, 2) look for confirmation of a suspect I had...

My opinion was that Regexp.IsMatch had to scan the string as well, and so it seems to be: Times are consistent with scans, only 3x worse:

Positive (all digitis)
LinqScan...  952ms
ForeachScan...  1043ms
ForScan...  869ms
Regexp...  3074ms
Negative (char at beginning)
LinqScan...  0ms
ForeachScan...  0ms
ForScan...  0ms
Regexp...  0ms
Negative (char at end)
LinqScan...  921ms
ForeachScan...  958ms
ForScan...  867ms
Regexp...  3986ms
Negative (char in middle)
LinqScan...  455ms
ForeachScan...  476ms
ForScan...  430ms
Regexp...  1982ms

Credits: I borrowed the Test function from Jon Skeet

Conclusions: s.All(Char.IsDigit) is efficient, and really easy (which was the original question, after all). Personally, I find it easier than regular expressions (I had to look on SO which was the correct one, as I am not familiar with C# regexp syntax - which is standard, but I didn't know - and the proposed solution was wrong). So.. measure, and don't believe in myths like "LINQ is slow" or "RegExp are slow". After all, they are both OK for the task (it really depends on what you need it for), pick the one you prefer.

Answer 3

Use regular expressions:

using System.Text.RegularExpressions;

string myString = "some long characters...";
if(Regex.IsMatch(myString, @"^\d+$", RegexOptions.Compiled))
{
    // String contains only numbers
}
if(Regex.IsMatch(myString, @"^\w+$", RegexOptions.Compiled))
{
    // String contains only letters
}

Answer 4

Try using TryParse

bool longStringisInt = Int64.TryParse(longString, out number);

If the string (i.e. longString) cannot be converted to an int (i.e. has letters in it) then the bool is false, otherwise it would be true.

EDIT: Changed to Int64 to ensure wider coverage

Answer 5

You can use IndexOfAny

bool containsDigits = mystring.IndexOfAny("0123456789".ToCharArray()) != -1;

In Linq you'd have to do:

bool containsDigits = mystring.Any(char.IsDigit);

Edit:

I timed this and it turns out the Linq solution is slower.

For string length 1,000,000 the execution time is ~13ms for the linq solution and 1ms for IndexOfAny.
For string length 10,000,000 the execution time for Linq is still ~122ms, whereas IndexOfAny is ~18ms.