在JavaScript中检查字符串中的符号

Question

I am doing a problem on coderbyte and the problem is as follows:

Using the JavaScript language, have the function SimpleSymbols(str) take the str parameter being passed and determine if it is an acceptable sequence by either returning the string true or false . The str parameter will be composed of + and = symbols with several letters between them (ie. ++d+===+c++==a ) and for the string to be true each letter must be surrounded by a + symbol. So the string to the left would be false . The string will not be empty and will have at least one letter.

The code that I have written is this:

var SimpleSymbols = function(str){
    var alpha = /[A-Za-z]/;
    var symbolarr = str.split("");
    for(var i = 0; i < symbolarr.length; i++) {
        if(alpha.test(symbolarr[i])) { 
            if(symbolarr[i-1] != "+" & symbolarr[i+1] != "+") {
                return false;
            }
        }
    }   
    return true;
}    

The problem is that when I test the case SimpleSymbols("+a=") I am getting true I have read through my code a few times and can't debug this. Can anyone spot the error?

Answer 1

Tweaking your solution

Replace & with && , they mean very different things.

Minor comment: you don't need to split the string into an array to access its characters; you can access them directly with str[i] .

Ignore the commenter who said you need a range check: arr[-1] will just return undefined , which will not be equal to + as you would expect.

Regexp solution

Test for the presence of a regexp giving the invalid sequence. If it's there, the string is illegal.

function SimpleSymbols(str) {
    return !/([^+]|^)[A-Za-z]([^+]|$)/).test(str);
}

In English:

Test for the presence of the following regexp:
    Find any character other than +, or the beginning of the string
    followed by a letter
    followed by any character other than +, or the end of the string
If it is present, return false, else true

State machine approach

A useful way to think about writing such programs is as a state machine. We will use three states: start for the beginning, have_plus when we have just seen a plus sign, and need_plus when we need a plus sign following a letter.

function SimpleSymbols(str) {
    var state = "start";
    var alpha = /[A-Za-z]/;

    for (var i = 0; i < str.length; i++) {
        var type = alpha.test(str[i]) ? 'letter' : str[i] === '+' ? 'plus' : 'other';

        switch (state) {
            case "start":
                switch (type) {
                    case 'letter':                      return false;
                    case 'plus'    state = "have_plus"; break;
                    case 'other':                       break; 
                }
                break;
            case "need_plus":
                switch (type) {
                    case 'letter':                      return false;
                    case 'plus':   state = "have_plus"; break;
                    case 'other':                       return false;
                }
                break;
            case "have_plus":
                switch (type) {
                    case 'letter': state = "need_plus"; break;
                    case 'plus':                        break;
                    case 'other':  state = "start";     break;
                }
                break;
        }

    }
    if (state === "need_plus") return false;
    return true;
}

It's a little longer, but it might be more readable and more maintainable. But we can do better. We will encapsulate the state logic in a data structure as follows:

var transitions = {
    start:     {letter: "fail",      plus: "have_plus",   other: "start"},
    need_plus: {letter: "fail",      plus: "have_plus",   other: "fail"},
    have_plus: {letter: "need_plus", plus: "have_plus",   other: "start"},
    fail:      {letter: "fail",      plus: "fail",        other: "fail"}
};

Now our program just runs through the state machine:

function SimpleSymbols(str) {
    var state = "start",
        alpha = /[A-Za-z]/;

    for (var i = 0; i < str.length; i++) {
        var type = alpha.test(str[i]) ? 'letter' : str[i] === '+' ? 'plus' : 'other';
        state = transitions[state][type];
    }
    return state != "fail";
}

We could bundle this up into a state-machine object:

function stateMachine(state, transitions) {
    return {
        go: function(type) { state = transitions[state][type]; }
        state: function() { return state; }
    };
}

Now we can write `SimpleSymbols' as

function SimpleSymbols(str) {
    var machine = stateMachine("start", transitions),
        alpha = /[A-Za-z]/;

    for (var i = 0; i < str.length; i++) {
        var type = alpha.test(str[i]) ? 'letter' : str[i] === '+' ? 'plus' : 'other';
        machine.go(type);
    }
    return machine.state() != "fail";
}

It would be good practice to disentangle the classification of tokens from the logic for running the machine:

function token_type(c) {
    return /A-Za-z]/.test(str[i]) ? 'letter' : str[i] === '+' ? 'plus' : 'other';
}

Then just

function SimpleSymbols(str) {
    var machine = stateMachine("start", transitions);
    for (var i = 0; i < str.length; i++) { machine.go(token_type(str[i])); }
    return machine.state() != "fail";
}