Check if a string has 20 numbers in a row in it

Question

My code will check if the variable myString has 20 running numbers. I'm new to JavaScript and I'm wondering if there is a simpler way to do this. How can I shorten my code and possibly make it more efficient?

var myString = "tuxwuhkocx14789470019215498263ljmgwsxvne";
var runningNumbers = 0;

for (i = 0; i < myString.length; i++) {

    var character = myString.charAt(i);

    if (!isNaN(character)) {
        // If character is a number:
        runningNumbers = runningNumbers + 1;
    } else {
        // If character is NOT a number:
        runningNumbers = 0;
    }

    if (runningNumbers == 20) {
        console.log("myString has 20 running numbers.");
    }

}

Output:

myString has 20 running numbers.

Answer 1

If you use a regular expression to look for 20 digit characters (\d) in a row, then the code would be compact and the goal would be visible at a glance:

var twentyDigits = /\d{20}/;
if (twentyDigits.test(myString)){
  console.log("My string has 20 running numbers");
}

You can shorten this further as just:

if (/\d{20}/.test(myString)) console.log("Yup. 20");

Answer 2

It's simpler to use a regex as @Phrogz already pointed out.

There are other issues too in the posted code that should be pointed out and improved.

After finding 20 consecutive digits, the program will continue counting, pointlessly. I'm wondering if this was really your intention. It seems that perhaps you want to break out of the loop after finding 20 and stop searching.

Also note that you could move the condition on runningNumbers == 20 right after runningNumbers is incremented. When runningNumbers was not changed (character is not a digit), it's pointless to check its value (you know it's 0).

Instead of printing in a loop, I recommend to rewrite your test as a function returning a boolean value, true if a sequence was found. This way the responsibilities of searching and printing will be well separated.

As a tip on style, note that instead of x = x + 1, you can use the shorter x += 1 or ++x or x++.

Answer 3

The regular expression /\d{20}/, as suggested by @Phrogz, is definitely the simplest and most idiomatic way to do this in JavaScript.

Since this is Code Review, I'm obligated to point out that you neglected to write var i, which is a likely cause of future bugs.

I also suggest using a conditional expression

runningNumbers = isNaN(myString[i]) ? 0 : runningNumbers + 1;

to emphasize the fact that one way or another, runningNumbers will get a new value.

Answer 4

As for efficiency, you can significantly reduce the number of characters you need to check by only checking every 20th character - you are guaranteed to hit every sequence of 20 consequtive numbers.

As so:

For every 20th character:
    if character is a number:
        length = 1
        loop backwards to count numbers (add to length)
        loop forwards to count numbers (add to length)
        if length >= 20, break out with positive result

Whether this actually performs better than lets say using the regex method, youd need to measure that (I dont know how things compare in javascript...).

If Im thinking this correctly, this should be beneficial as long as over 1/20 of the characters are not numbers. In reality its probably higher due to the increased complexity of counting the 20 numbers (looping backwards and all...)

Works for any length of number sequence, of course.

If efficiency is not a concern, or if this actually performs worse in the real world, one of the shorter solutions is probably preferable.