问在迭代数组时检查某些“分隔符元素”是否有规律的间距？

EN

var isCorrect = function( str, divider ) {

    process.stdout.write( str + ': ' );

    // First check the obvious cases. These allow us to skip these checks
    // within the loop.
    if( str[0] !== divider )
        return "Doesn't start with divider";
    if( str[ str.length - 1 ] !== divider )
        return "Doesnt' end with divider";

    // Two variables to hold the state.
    // The second variable (divisions) is required only if we want to make
    // sure that the last segment is "optimal".
    var division = null;
    var divisions = 0;

    // First find the first divider.
    var i = 1;
    for( ; i < str.length; i++ ) {
        if( str[i] === divider ) {
            division = i;
            divisions++;
            break;
        }
    }

    // Now that we know the division length, make sure the dividers
    // are in expected positions.
    for( ; i < str.length; i++ ) {

        var expectedDivider = ( (i) % division === 0 );

        // See if we are expecting a divider.
        if( expectedDivider ) {
            if( str[i] !== divider )
                return "Expected divider at position " + i;
            divisions++;
            continue;
        }

        // Since we are not expecting a divider, make sure we don't have one.
        if( str[i] === divider ) {

            // We had a divider in an unexpected place. This is only allowed for
            // the last segment.
            if( i < str.length - 1 )
                return "Divider not expected at position " + i;

            // This is last segment. We could return 'ok' here unless we want
            // the optimal segments.

            // For optimal segments we want to know whether the last segment
            // could have "borrowed" items from the previous ones while still
            // remaining smaller than the rest.

            // Calculate the bits missing from the last segment.
            var offset = ( (i-1) % division );
            var missing = division - offset - 1;

            if( offset === 0 )
                return "Empty division at the end";

            // Could the missing bits be taken from the previous divisions?
            if( missing > divisions )
                return "Last division too short";

            // Last segment was OK.
            return "ok";
        }
    }

    // All divisions were in expected places:
    // Last segment was as long as the rest.
    return "ok";
};

// Simple cases

// OK
console.log( isCorrect( '*--*--*--*', '*' ) );
console.log( isCorrect( '*---*---*---*', '*' ) );
console.log( isCorrect( '*---*---*--*', '*' ) );

// Middle segment too short.
console.log( isCorrect( '*-----*----*-----*', '*' ) );

// First segment too short
console.log( isCorrect( '*----*-----*-----*', '*' ) );

// "Optimality" tests

// In "optimal" division the segments could be divided to three with
// *----*----*---* so *-----*-----*-* is "unoptimal"
console.log( isCorrect( '*-----*-----*-*', '*' ) );

// These are "optimal"
console.log( isCorrect( '*-----*-----*--*', '*' ) );
console.log( isCorrect( '*-----*-----*---*', '*' ) );
console.log( isCorrect( '*-----*-----*----*', '*' ) );
console.log( isCorrect( '*-----*-----*-----*', '*' ) );

// Last segment too long
console.log( isCorrect( '*-----*-----*------*', '*' ) );

// Last segment empty
console.log( isCorrect( '*--*--*--*--*--**', '*' ) );