在元素数组中查找重复的元素系列

Question

I have an array like this

 var randomArray = [1,2,1,1,1,1,0,2,1,2,3,10,12,54,10,12] etc..

I can Remove duplicate elements or find duplicate elements in this. But I want to log all repeating sequence of elements repeated in array. Here is the code I have tried, but it is running into infinite loop

  for (i = 0; i < randomLength; i++) {
    var cycle = [i],
    flag = 0,
    start = i;
    for (var j = i + 1; j < randomLength; j++) {
       if (randomArray[i] == randomArray[j]) {
         cycle.push(randomArray[j]);
         while (i <= j) {
            if (randomArray[i + 1] == randomArray[j + 1]) {
                cycle.push(randomArray[j + 1]);
            }
            i = i + 1;
            j = j + 1;
         }
         console.log(cycle);
       }
       i = start;
    }
   i = start;
 }  

It should return me. And I don't want to regex to do the same

1,2
1,1
10,12

If array is ["a","d","z","e","g","h","a","d","z"]  

then

output would be "a","d","z"

And it should be optimal solution. Please suggest me on this. At least corrections to my current code..

Answer 1

var randomArray = [1,2,1,1,1,1,0,2,1,2,3,10,12,54,10,12];

for(var i = 0; i < randomArray.length; i++) {
    var item = randomArray[i];
    var str  = "";    

    while(randomArray[i] == item) {
        str = str + " " + randomArray[i];   
        i++;
    }

    document.write(str + "<br />");
}

See this JSFiddle: http://jsfiddle.net/Ucgtm/

Answer 2

Here is a solution I just wrote in Haskell. (You can see how concise the language can be.) Below the code is an example of how it is implemented in the interpreter command line.

import Data.List

findSequences list length
  | length >= 2 = repeatedPattern list length ++ findSequences list (length-1)
  | otherwise = []
    where repeatedPattern [] _ = []
          repeatedPattern list size
            | take size list `isInfixOf` drop size list = 
                take size list : repeatedPattern (tail list) size
            | otherwise = repeatedPattern (tail list) size

Prelude> :load "findSequences.hs"
[1 of 1] Compiling Main ( findSequences.hs, interpreted )
Ok, modules loaded: Main.
*Main> let randomArray = [1,2,1,1,1,1,0,2,1,2,3,10,12,54,10,12]
*Main> findSequences randomArray (floor $ (/2) $ fromIntegral (length randomArray))
[[1,2],[2,1],[1,1],[10,12]]
*Main> let array = ["a","d","z","e","g","h","a","d","z"]
*Main> findSequences array (floor $ (/2) $ fromIntegral (length array))
[["a","d","z"],["a","d"],["d","z"]]

Answer 3

I've used a "trie" tree datastructure (google it for more info). The tree branches for each sequence. It finds 1,1,1 as a solution since 1,1,1 occurs twice. (if you want to stop a number being repeated in two sequences, you need to count unique indexes against each node of the trie).

Here is the code: Runtime should be something like O(N^2) which could be improved on slightly.

var randomArray = [1,2,1,1,1,1,0,2,1,2,3,10,12,54,10,12]

var solve = function(a) {
    var trie = {};
    var sequence_set = {};
    for (var start = 0; start < a.length - 1; start += 1)  {
        var sub_trie = trie[a[start]] || {};
        trie[a[start]] = sub_trie;
        sequence = "" + a[start]
        for (var i = start + 1; i < a.length; i += 1) {
            sequence += "," + a[i]
            sub_trie[a[i]] = sub_trie[a[i]] || {};
            sub_trie = sub_trie[a[i]];
            var sub_trie_count = sub_trie.count || 0;
            sub_trie.count = sub_trie_count + 1;
            if (sub_trie_count >= 1) {
                sequence_set[sequence] = "found";
                console.log(sequence);
            }
        }
    }
    solution = "";
    for (sequence in sequence_set) {
        solution += sequence + ", ";
    }
    console.log(trie)
    return solution;
}

Output:

1,1 fiddle.jshell.net:37
1,1,1 fiddle.jshell.net:37
1,1 fiddle.jshell.net:37
2,1 fiddle.jshell.net:37
1,2 fiddle.jshell.net:37
10,12 fiddle.jshell.net:37
Object {0: Object, 1: Object, 2: Object, 3: Object, 10: Object, 12: Object, 54: Object}
 fiddle.jshell.net:45

Answer 4

Here is my solution , much like @robert king 's (as I discovered after tackling the problem myself) except mine is complete (already is capable of not counting overlapping patterns) and optimised (as much as I can).

Also, returns a map of objects, so you can enumerate over it and only pull out patterns of size X, or ones that repeated Y times etc.

The following line (with the below function)

getPatterns([1,2,1,1,1,1,0,2,1,2,3,10,12,54,10,12]).showRepeated();

will result in this;

1 2 found 2 times
2 1 found 2 times
1 1 found 2 times
10 12   found 2 times

CODE

function getPatterns(input, generateAll) {
    var patternMap = new getPatterns.presentation();

    var generated = [];
    var patternObj;
    var start;
    //for each item
    for (var index = 0; index < input.length; ++index) {
        //open a new slot for a new pattern start at this index
        generated.push('');

        start = 0;
        //unless told to generate all
        //skip patterns that cant possibly be repeated
        //(i.e. longer than half the input length)
        if (!generateAll && generated.length > input.length / 2)
            start = generated.length - Math.floor(input.length / 2);

        //test patterns we have generated for this index
        for (var index2 = start; index2 < generated.length; ++index2) {
            //generate a fresh lot of patterns for this index
            generated[index2] += ' ' + input[index];

            //unless told to generate all, dismiss patterns of length 1
            if (!generateAll && index2 == generated.length - 1)
                break;

            //try to fetch a pre-existing pattern, O(1)
            patternObj = patternMap[generated[index2]];
            //if this is a new pattern
            if (!patternObj) {
                //generate an object
                patternMap[generated[index2]] = {
                    lastSeen : index,
                    count : 1,
                    size : generated.length - index2
                };
                continue;
            }

            //unless told to generate all, skip patterns that overlap with themselves
            if (!generateAll && index - patternObj.lastSeen < patternObj.size)
                continue;

            //this pattern has repeated! update the object data
            ++patternObj.count;
            patternObj.lastSeen = index;
        }
    }

    return patternMap;
}
//just for a function prototype
getPatterns.presentation = function() {};
getPatterns.presentation.prototype = {
    showRepeated : function() {
        var patternObj;
        for (var pattern in this) {
            patternObj = this[pattern];
            if (patternObj.count > 1)
                console.log(pattern + '\tfound ' + patternObj.count + ' times');
        }
    }
};

Answer 5

If you want it in php, it goes like this:

Create an array in php outside the <script>

$array=array("1","2","2","1".....);

$result = array_unique($array);

Then

var randomArray = <?php echo json_encode($result) ?>;

Answer 6

我认为你的代码可能会遇到无限循环，因为i和j在“while”循环内以相同的速率增加，因此“while”条件不会得到满足。