计算连续重复的次数

Question

I have a list of elements:

list = ['green','green','red','blue','red','blue','yellow','white','black','yellow','white','black','red','green','yellow','black']

I want to group the consecutive repetitions, no matter what size they are. meaning that this is my desired output.

['green x2','red-blue-x2','yellow-white-black x2','red,'green','yellow','black']

I was able to achieve only a part of it with js , here's the code:

let sentence = ""
let index = 0
let repetition_count = 1
let repetition_list = []
list.forEach(element => {
    let prev_elem = list[index-1]
    if(element == prev_elem)
        {
            repetition_count++
            repetition_list.push(element)
        }
    else if(repetition_count>1){
            if(sentence.endsWith(repetition_list[0]+"-")){
                sentence = remove_last_word(sentence)
            }
            sentence+= repetition_list[0] + "x"+repetition_count+"-"
            repetition_count = 1
            repetition_list = []
        }
        sentence+= element+"-"
        index++;
    }
    

with some tweaks to the above code it produced the following output:

['green x2','red','blue','red','blue','yellow','white','black','yellow','white','black','red,'green','yellow','black']

now I don't know how to check more than one element for repetition.

I tried list comprehension with groupby (itertools) in python but it didn't do much more than the JS code.

PYTHON CODE :

grouped_sentence = [(k, sum(1 for i in g)) for k, g in groupby(list)]

and it gave me this output:

[ ('green',2),('red',1),('blue',1),('red',1),('blue',1),('yellow',1),('white',1),('black',1),('yellow',1),('white',1),('black',1),('red',1),('green',1),('yellow',1),('black',1)]

any suggestions?

Answer 1

First, this was an interesting mental exercise, so thank you.

This function will check an array for repeats up to a maximum grouping size.

function getRepeats(list, maxgroupingsize) {
    var temparray = [...list];
    // iterate through each grouping size
    for (var grpcounter = maxgroupingsize; grpcounter > 0; --grpcounter) {
        // iterate through the array
        for (var pos = 0; pos < temparray.length - grpcounter + 1; ++pos) {
            if (temparray[pos] == "") {continue;}
            // create a current selection string
            var myselection = "";
            for (var selectionbuild = 0; selectionbuild < grpcounter; ++selectionbuild) {
                if (myselection != "") { myselection += "-"; }
                myselection += temparray[pos + selectionbuild]
            }
            var matches = 0;
            // iterate through the array forward looking for matches
            for (var checkpos = pos + grpcounter; checkpos < temparray.length - grpcounter + 1; ++checkpos) {
                // create a test selection string
                var testselection = "";
                for (var selectionbuild = 0; selectionbuild < grpcounter; ++selectionbuild) {
                    if (testselection != "") { testselection += "-"; }
                    testselection += temparray[checkpos + selectionbuild];
                }
                // test to see if the selections match
                if (testselection === myselection) {
                    ++matches;
                    // empty out the array values that we matched
                    for (var cleancounter = 0; cleancounter < grpcounter; ++cleancounter) {
                        temparray[checkpos + cleancounter] = "";
                    }
                    checkpos += grpcounter - 1;
                } else {
                    break;
                }
            }
            // if we had matches, update the current array value
            if (matches > 0) {
                myselection += " x" + (matches + 1);
                checkpos += ((matches + 1) * grpcounter)
                temparray[pos] = myselection;
                for (var cleancounter = 1; cleancounter < grpcounter; ++cleancounter) {
                    temparray[pos + cleancounter] = "";
                }
            }
        }
    }
    
    // create a new array without empty values
    var myresult = [];
    for (var counter = 0; counter < temparray.length; ++counter) {
        if (temparray[counter] != "") { myresult.push(temparray[counter]); }
    }
    
    // return the result
    return myresult;
}

And you would call it like this:

var result = getRepeats(mylist, 3);

Where mylist is your array and 3 means it will check for groups up to 3 elements long.

The following array:

[ "red", "orange", "orange", "orange", "yellow", "green", "blue", "green", "blue", 
"green", "blue", "orange", "orange", "red", "yellow", "yellow", "indigo", "violet", 
"red", "green", "violet", "red", "green", "violet", "red", "green", "violet", "orange", 
"red", "indigo", "indigo", "indigo", "orange" ]

Returns:

[ "red", "orange x3", "yellow", "green-blue x3", "orange x2", "red", "yellow x2", 
"indigo", "violet-red-green x3", "violet", "orange", "red", "indigo x3", "orange" ]