如何检查字符串是否仅由相同长度的字符组组成？

Question

I want to identify strings that are made up exclusively of same-length character groups. Each one of these groups consists of at least two identical characters. So, here are some examples:

aabbcc          true
abbccaa         false
xxxrrrruuu      false (too many r's)
xxxxxfffff      true
aa              true (shortest possible positive example)
aabbbbcc        true // I added this later to clarify my intention

@ilkkachu: Thanks for your remark concerning the repetition of the same character group. I added the example above. Yes, I want the last sample to be tested as true: a string made up of the two letter groups aa, bb, bb, cc .

Is there a simple way to apply this condition-check on a string using regular expressions and JavaScript?

My first attempt was to do something like

var strarr=['aabbcc','abbccaa','xxxrrrruuu',
            'xxxxxfffff','aa','negative'];
var rx=/^((.)\2+)+$/;

console.log(strarr.map(str=>str+': '+!!str.match(rx)).join('\n'));

It does look for groups of repeated characters but does not yet pay attention to these groups all being of the same length , as the output shows:

aabbcc: true
abbccaa: false
xxxrrrruuu: true // should be false!
xxxxxfffff: true
aa: true
aabbbbcc: true
negative: false

How do I get the check to look for same-length character groups?

Answer 1

To get all the groups of the same character has an easy regex solution:

/(.)\1*/g

Just repeating the backreference \\1 of the character in capture group 1.

Then just check if there's a length in the array of same character strings that doesn't match up.

Example snippet:

 function sameLengthCharGroups(str) { if(!str) return false; let arr = str.match(/(.)\\1*/g) //array with same character strings .map(function(x){return x.length}); //array with lengths let smallest_length = arr.reduce(function(x,y){return x < y ? x : y}); if(smallest_length === 1) return false; return arr.some(function(n){return (n % smallest_length) !== 0}) == false; } console.log("-- Should be true :"); let arr = ['aabbcc','xxxxxfffff','aa']; arr.forEach(function(s){console.log(sameLengthCharGroups(s)+' : '+ s)}); console.log("-- Should also be true :"); arr = ['aabbbbcc','224444','444422', '666666224444666666','666666444422','999999999666666333']; arr.forEach(function(s){console.log(sameLengthCharGroups(s)+' : '+ s)}); console.log("-- Should be false :"); arr = ['abbcc','xxxrrrruuu','a','ab','',undefined]; arr.forEach(function(s){console.log(sameLengthCharGroups(s)+' : '+ s)}); 

ECMAScript 6 version with fat arrows (doesn't work in IE)

function sameLengthCharGroups(str)
{
     if(!str) return false;
     let arr = str.match(/(.)\1*/g)
                  .map((x) => x.length);
     let smallest_length = arr.reduce((x,y) => x < y ? x : y);
     if(smallest_length === 1) return false;
     return arr.some((n) => (n % smallest_length) !== 0) == false;
}

Or using exec instead of match, which should be faster for huge strings.
Since it can exit the while loop as soon a different length is found.
But this has the disadvantage that this way it can't get the minimum length of ALL the lengths before comparing them.
So those with the minimum length at the end can't be found as OK this way.

 function sameLengthCharGroups(str) { if(!str) return false; const re = /(.)\\1*/g; let m, smallest_length; while(m = re.exec(str)){ if(m.index === 0) {smallest_length = m[0].length} if(smallest_length > m[0].length && smallest_length % m[0].length === 0){smallest_length = m[0].length} if(m[0].length === 1 || // m[0].length !== smallest_length (m[0].length % smallest_length) !== 0 ) return false; } return true; } console.log("-- Should be true :"); let arr = ['aabbcc','xxxxxfffff','aa']; arr.forEach(function(s){console.log(sameLengthCharGroups(s)+' : '+ s)}); console.log("-- Should also be true :"); arr = ['aabbbbcc','224444','444422', '666666224444666666','666666444422','999999999666666333']; arr.forEach(function(s){console.log(sameLengthCharGroups(s)+' : '+ s)}); console.log("-- Should be false :"); arr = ['abbcc','xxxrrrruuu','a','ab','',undefined]; arr.forEach(function(s){console.log(sameLengthCharGroups(s)+' : '+ s)}); 

Answer 2

Here's one that runs in linear time:

function test(str) {
    if (str.length === 0) return true;

    let lastChar = str.charAt(0);
    let seqLength = 1;
    let lastSeqLength = null;
    for (let i = 1; i < str.length; i++) {
        if (str.charAt(i) === lastChar) {
            seqLength++;
        }
        else if (lastSeqLength === null || seqLength === lastSeqLength) {
            lastSeqLength = seqLength;
            seqLength = 1;
            lastChar = str.charAt(i);
        }
        else {
            return false;
        }
    }
    return (lastSeqLength === null || lastSeqLength === seqLength);
}

Answer 3

Using sticky flag y and replace method you could do this much more faster. This trick replaces occurrences of first one's length with an empty string (and stops as soon as an occurrence with different length happens) then checks if there are some characters left:

 var words = ['aabbcc', 'abbccaa', 'xxxrrrruuu', 'xxxxxfffff', 'aa']; words.forEach(w => { console.log(w + " => " + (w.replace(/(.)\\1+/gy, ($0, $1, o) => { return $0.length == (o == 0 ? l = $0.length : l) ? '' : $0; }).length < 1)); }); 

Answer 4

Another workaround would be using replace() along with test() . First one replaces different characters with their corresponding length and the second looks for same repeated numbers in preceding string:

var str = 'aabbc';
/^(\d+\n)\1*$/.test(str.replace(/(.)\1+/gy, x => x.length + '\n'));

Demo:

 var words = ['aabbcc', 'abbccaa', 'xxxrrrruuu', 'xxxxxfffff', 'aa']; words.forEach(w => console.log(/^(\\d+\\n)\\1*$/.test(w.replace(/(.)\\1+/gy, x => x.length + '\\n'))) ); 

Answer 5

Since requirements changed or weren't clear as now this is the third solution I'm posting. To accept strings that could be divided into smaller groups like aabbbb we could:

• Find all lengths of all different characters which are 2 and 4 in this case.
• Push them into an array named d .
• Find the lowest length in set named m .
• Check if all values in d have no remainder when divided by m

Demo

 var words = ['aabbbcccdddd', 'abbccaa', 'xxxrrrruuu', 'xxxxxfffff', 'aab', 'aabbbbccc']; words.forEach(w => { var d = [], m = Number.MAX_SAFE_INTEGER; var s = w.replace(/(.)\\1+/gy, x => { d.push(l = x.length); if (l < m) m = l; return ''; }); console.log(w + " => " + (s == '' && !d.some(n => n % m != 0))); }); 

Answer 6

The length of the repeated pattern of same charcters needs to be specified within the regular expression. The following snippet creates regular expressions looking for string lengths of 11 down to 2. The for-loop is exited once a match is found and the function returns the length of the pattern found:

function pat1(s){
  for (var i=10;i;i--)
    if(RegExp('^((.)\\2{'+i+'})+$').exec(s)) 
      return i+1;
  return false;}

If nothing is found false is returned.

If the length of the pattern is not required, the regular expression can also be set up in one go (without the need of the for loop around it):

function pat2(s){
  var rx=/^((.)\2)+$|^((.)\4{2})+$|^((.)\6{4})+$|^((.)\8{6})+$/;
  return !!rx.exec(s);
}

Here are the results from both tests:

console.log(strarr.map(str=>
     str+': '+pat1(str)
         +' '+pat2(str)).join('\n')+'\n');

aabbcc: 2 true
abbccaa: false false
xxxrrrruuu: false false
xxxxxfffff: 5 true
aa: 2 true
aabbbbcc: 2 true
negative: false false

The regex in pat2 looks for certain repetition-counts only. When 1, 2, 4 or 6 repetitions of a previous character are found then the result is positive. The found patterns have lengths of 2,3,5 or 7 characters (prime numbers!). With these length-checks any pattern-length dividable by one of these numbers will be found as positive (2,3,4,5,6,7,8,9,10,12,14,15,16,18,20,21,22,24,...).

Answer 7

Since regex has never been my forte here's an approach using String#replace() to add delimiter to string at change of letter and then use that to split into array and check that all elements in array have same length

 const values = ['aabbcc', 'abbccaa', 'xxxrrrruuu', 'xxxxxfffff', 'aa']; const expect = [true, false, false, true, true]; const hasMatchingGroups = (str) => { if(!str || str.length %2) return false; const groups = str.replace(/[az]/g,(match, offset, string) => { return string[offset + 1] && match !== string[offset + 1] ? match + '|' : match; }).split('|'); return groups.every(s => s.length === groups[0].length) } values.forEach((s, i) => console.log(JSON.stringify([s,hasMatchingGroups(s), expect[i]])))