Finding повторил ряд элементов в массиве элементов

Question

У меня есть массив как этот

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

я могу удалить дубликаты элементов или найти дубликаты элементов в этом. Но я хочу записать всю повторяющуюся последовательность элементов, повторяющихся в массиве. Вот код, который я пробовал, но он работает в бесконечном цикле

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; 
} 

Он должен вернуть меня. И я не хочу, чтобы регулярное выражение, чтобы сделать то же самое

1,2 
1,1 
10,12 

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

затем

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

И это должно быть оптимальным решением. Пожалуйста, предложите мне об этом. По крайней мере, поправки к моему текущему коду ..

Answer 1

Here is my solution, так же, как @robert царского (как я обнаружил, после решения проблемы самого), за исключением шахты завершен (уже может не считать пересекающиеся узоры) и оптимизированы (насколько я могу).

Кроме того, возвращает карту объектов, так что вы можете перечислить на него и только вытаскивать модели размера X, или те, которые повторяются Y раз и т.д.

Следующая строка (с приведенной ниже функции)

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

приведет к этому;

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

КОД

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 2

Если вы хотите его в PHP, это выглядит следующим образом:

Создание массива в PHP вне <script>

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

$result = array_unique($array);

Затем

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

Answer 3

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 />"); 
} 

Смотрите эту JSFiddle: http://jsfiddle.net/Ucgtm/

Answer 4

Я думаю, что ваш код может быть запущен в бесконечный цикл, потому что я и J растет с той же скоростью внутри «а» цикл, так что «в то время как» условие не довольный.

Answer 5

Вот решение, которое я только что написал в Haskell. (Вы можете видеть, насколько кратким может быть язык.) Ниже код является примером того, как он реализован в командной строке интерпретатора.

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>: нагрузка "findSequences.hs"
[1 из 1] компиляцией Main (findSequences.hs, интерпретируемые)
Хорошо, модули загружены: Main.
* Главная> let randomArray = [1,2,1,1,1,1,0,2,1,2,3,10,12,54,10,12]
* Главная> findSequences randomArray (floor $ (/ 2) $ fromIntegral (длина randomArray))
[[1,2], [2,1], [1,1], [10,12]]
* Main> let array = ["a "," d "," z "," e "," g "," h "," a "," d "," z "]
* Главная> findSequences array (floor $ (/ 2) $ fromIntegral (длина массива))
[["a", "d", "z"], ["a", "d"], ["d", "z"]]

Answer 6

Я использовал древовидная структура дерева «trie» (google для получения дополнительной информации). Ветвь дерева для каждой последовательности. Он находит 1,1,1 в качестве решения, так как 1,1,1 встречается дважды. (если вы хотите, чтобы число повторялось в двух последовательностях, вам нужно подсчитывать уникальные индексы против каждого узла trie).

Вот код: Runtime должно быть чем-то вроде O (N^2), которое можно было бы слегка улучшить.

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; 
} 

Выход:

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