Javascript 查找数组中通常相邻出现的元素

我试图找到数组中通常彼此相邻的值

例如，给定阵列：

["dog","cat","goat","dog","cat","elephant","dog","cat","pig","seal","dog","cat","pig","monkey"]

它应该返回类似于以下内容的内容：

[[["dog","cat"],4],[["cat","pig"],2],[["dog","cat","pig"],2]]

以下是一些更好的数据：

非常感谢您的帮助。以下是我目前尝试做类似事情的失败尝试：

function findAssociations(words){
  var temp = [],tempStore = [],store = [],found = false;
  //loop through the words counting occurrances of words together with a window of 5
  for(var i = 0;i<words.length-1;i++){
    if(i % 5 == 0){
      //on every fith element, loop through store attempting to add combinations of words stored in tempStore
      for(var j = 0;j<5;j++){
        temp = []
        //create the current combination
        for(var k = 0;k<j;k++){
          temp.push(tempStore[k]);
        }
        //find if element is already stored, if it is, increment the occurrence counter
        for(var k = 0;k<store.length;k++){
          if(store[k][0]===temp){
            found = true;
            store[k][1] = store[k][1]+1;
          }
        }
        //if it isn't add it
        if(found == false){
          store.push([temp,1]);
        }
        found == false;
      }
      tempStore = [];
    } else {
      //add word to tempStore if it i isnt a multiple of 5
      tempStore.push(words[i]);
    }
  }
}

函数FindAssociation（字）{
变量temp=[]，tempStore=[]，store=[]，found=false；
//循环通过单词计算单词的发生率，窗口为5
对于（var i=0；i这是我想到的。它只查找对，但您可以根据您的
%
修改它以查找3、4等的集合

const animals = ['dog','cat','goat','dog','cat','elephant','dog','cat','pig','seal','dog','cat','pig','monkey'];

let pairs = ',';
animals.forEach((animal, i) => {
  let separator = ',';
  if (i % 2 === 0) {
    separator = ';'
  }
  pairs += animal + separator;
});

const evenPairs = pairs.split(',');
const oddPairs = pairs.split(';');
const allPairs = evenPairs.concat(oddPairs).map(pair => pair.replace(/[;,]/, ' '));

let result = {}

allPairs.forEach(pair => {
  if (pair.length) {
    if (result[pair] === undefined) {
      result[pair] = 1;
    } else {
      result[pair]++;
    }
  }
});

结果：

dog: 1
cat elephant: 1
cat goat: 1
cat pig: 2
dog cat: 4
elephant dog: 1
goat dog: 1
monkey : 1
pig monkey: 1
pig seal: 1
seal dog: 1

你需要弄清楚你所说的“接近”是什么意思以及距离有多近。只要看看第一个邻居，你就可以试试：

const findaassociations=words=>{
常量关联={}
for（设i=0；i=0）{
协会[关键]++
}否则{
关联[键]=1
}
}
常量键=对象键（关联）
常量值=对象值（关联）
const zipped=keys.map（（键，索引）=>[key，values[index]]）
zipped.sort（（a，b）=>a[1]

您可以在另一个函数中使用此函数，并在
[“dog”，“cat”]


const arr=[“狗”、“猫”、“山羊”、“狗”、“猫”、“狗”、“猫”、“大象”、“狗”、“猫”、“猪”、“海豹”、“狗”、“猫”、“猪”、“猴子”]
常量findArrayInArray=（arr1，arr2）=>{
让count=0，
arrString1=arr1.join（“”），
arrString2=arr2.join（“”）；
while（arrString2.indexOf（arrString1）>-1）{
计数+=1；
arrString2=arrString2.替换（arrString1'）；
}
返回计数；
}
console.log（`[“dog”，“cat”]exist${findArrayInArray（[“dog”，“cat”]，arr）}次`）
假设列表中的每个项目都是一个集合的分隔符，每个集合对每个项目计数一次（即
[“dog”，“cat”，“goat”]
计数为
[“dog”，“cat”]
和
[“dog”，“cat”，“goat”]
，假设您不希望出现任何单一事件，那么这里有一种方法：

const full_list = ["dog","cat","goat","dog","cat","dog","cat","elephant","dog","cat","pig","seal","dog","cat","pig","monkey"];

// create list of unique items
const distinct = (value, index, self) => {
    return self.indexOf(value) ===index;
}
const unique_items = full_list.filter(distinct);

// get all patterns
var pre_report = {};
for (var i in unique_items) {
    item = unique_items[i];
    var pattern = [item];

    var appending = false;
    for (var j = full_list.indexOf(item) + 1; j < full_list.length; ++j) {
         const related_item = full_list[j];
         if (item == related_item) {
             pattern = [item]
             continue;
         }

         pattern.push(related_item);
         if (pattern in pre_report) {
             ++pre_report[pattern];
         } else {
             pre_report[pattern] = 1;
         }  
    }
}

// filter out only single occurring patterns
var report = {};
for (key in pre_report) {
    if (pre_report[key] > 1) {
        report[key] = pre_report[key];
    }
}

console.log(report);

这是一个通用的解决方案，适用于多个组大小。

您可以为2到4个元素的组指定一个组大小范围，例如
[2,4]
，以及最小出现次数

然后，该函数生成给定大小的所有相邻组，对每个组进行排序并对重复项进行计数。排序步骤可以根据组中的顺序删除

通过创建一个字典对重复项进行计数，该字典的键是用特殊标记排序和连接的组元素。字典中的值就是计数

然后返回按事件排序的组，然后按组大小排序


const data=[“狗”、“猫”、“山羊”、“狗”、“猫”、“大象”、“狗”、“猫”、“猪”、“海豹”、“狗”、“猫”、“猪”、“猴”]；
函数findSimilarNeights（groupSizeRange、minoccurrences、data）{
const getneights=（大小，arr）=>arr.reduce（（acc，x）=>{
acc.push（[]）；
对于（设i=0；ix.length==size）；
常量组=[]；
for（让groupSize=groupsizerage[0]；groupSize group.sort（）.join（'@#@'）；//使用字符串中不会出现的分隔符
const groupsInfo=groups.reduce（（acc，group）=>{
const name=groupName（组）；
acc[名称]=acc[名称]| |{}；
acc[name]={组，计数：（acc[name].计数| | 0）+1}；
返回acc；
}, {});
返回Object.values（groupsInfo）
.filter（组=>group.count>=minoccurrences）
.排序（（a，b）=>{
const countDiff=b.count-a.count；
返回countDiff？countDiff:b.group.length-a.group.length；
})
.map（（{group，count}）=>[group，count]）；
};
log（findsimilarneights（[2,4]，2,data））；
console.log（findsimilarneights（[4,4]，2，data））；
为什么这里没有一个
[“猫”，“猪”]，2
？定义“通常出现”。你的出现频率下限是多少？子序列有大小限制吗？
[“狗”，“猫”]，4]不应该是[“狗”，“猫”]，5]
？这正是我想做的，但我得到了“无效标记压缩接近堆限制分配失败-JavaScript堆内存不足“当我运行此程序时。这是代码中的一个错误，还是仅仅因为我在处理大文件？@Eidolon:是的，我尝试了你的pastebin数据并得到了相同的结果。可能是数据大小和分隔符之间的距离的函数。可能是设置了“距离限制”-或者更可能更好地利用内存。我现在没有太多时间，但我会看看我能想出什么。这将非常有用。我正在尝试处理相当多的数据，粘贴箱只是一个查询的四分之一…当我回到这个问题时，我将尝试的第一件事是将填充pre_报告的部分替换为对fi的转储然后处理文件（此时简单计数）也许在等待我的时候，你可以玩这个。另外：它必须是针对内存中的数组的JavaScript吗？你试过把数据放在数据库中并运行分析/查询吗？同样：如果你回答了这个问题，你会考虑把它标记为被接受的答案吗？好吧，我会给它一个答案。不，它不需要T。是的，但是仅仅因为我已经处理了很多复杂的查询，所以将额外的查询减少到最少是很有用的。
{ 'dog,cat': 5, 'dog,cat,pig': 2, 'cat,pig': 2 }