Question

我试图返回数组的模式。我有一个内循环和外部比较每个元素彼此。数组= [5,3,6,3,3,3]。

function mode(arr){
    for (var i = 0; i < arr.length; i++) {
        for (var k = i+1; k < arr.length; k++) {
            if (arr[i] == arr[k]) { 
            modeItems += arr[k];
            }else {
            otherItems +=arr[i];
        }
    }
}return modeItems;

}

结果回来＆＃34; 333333＆＃34;而不是＆＃34; 3333＆＃34;。我看到这是如何在excel表上发生的，比较aar [i]和arr [k]的15个总循环，但我不知道该怎么做。

Answer 1

以下是大杂烩答案。我的困惑源于标题

如何消除单个数组中元素的额外匹配

与问题的这一部分混合

我正在尝试返回数组的模式。

将数组减少为单个实例的数组，以及所有重复数组的数组。

DEMO

var arra = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4];

function simplify(arr) {
  var c = {}, o = [], d = [], i;
  
  for (i = 0; i < arr.length; i++) {
    if (!c.hasOwnProperty(arr[i])) {
      c[arr[i]] = arr[i];
      o.push(arr[i]);
    } else {
      d.push(arr[i]);
    }
  }
  
  return {
    reduced: o,
    duplicates: d
  };
}

console.log(simplify(arra));
// >> [object Object] {
// >>  duplicates: [2, 3, 3, 4, 4, 4],
// >>  reduced: [1, 2, 3, 4]
// >> }

从阵列中删除重复项。

DEMO

var arr = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4];

function elim (arra) {
  var c = {}, i = 0;
  
  while (i < arra.length) {
    if (c[arra[i]]) {
      arra.splice(i, 1);
    } else {
      c[arra[i]] = true;
      i++;
    }
  }
  
  return arra; // only required for debug.
}

console.log(elim(arr.slice()));

在阵列上多次循环只是为了找到模式是不必要的。您可以使用对象文字作为缓存来更新计数。如果你想要一个减去模式的数组（或只有模式的数组），你可以在之后使用.filter。

这是一个基本的实现。如果没有模式，我们返回null。

DEMO

function findMode (a) {
  var cache = {},
      len = a.length,
      mode,
      max = 0,
      matched = false;
  
  for (var i = 0; i < len; i++) {
    cache[a[i]] = (cache[a[i]] + 1 || 1);
    
    if (cache[a[i]] === max) {
      matched = true;
    } else if (cache[a[i]] > max) {
      max = cache[a[i]];
      mode = a[i];
      
      matched = false;
    }
  }
  
  return (matched ? null : mode);
}

var arr = [5,3,6,3,3,3],
    myMode = findMode(arr),
    filteredArr = arr.filter(function (e) {
      return (e !== myMode);
    }),
    modeItems = arr.filter(function (e) {
      return (e === myMode);
    });

console.log(arr); // >> [5,3,6,3,3,3]
console.log(myMode); // >> 3
console.log(filteredArr); // >> [5, 6]
console.log(modeItems); // >> [3, 3, 3, 3]

此处没有模式：

findMode([5, 7, 5, 7]); // >> null

稍微复杂的东西。返回原始数组的两次传递中的模式，模式数组和反向数组。

DEMO

var findMode = (function () {
  function getMode (a) {
    var cache = {},
        len = a.length,
        mode,
        max = 0,
        matched = false;

    for (var i = 0; i < len; i++) {
      cache[a[i]] = (cache[a[i]] + 1 || 1);

      if (cache[a[i]] === max) {
        matched = true;
      } else if (cache[a[i]] > max) {
        max = cache[a[i]];
        mode = a[i];

        matched = false;
      }
    }

    return (matched ? null : mode);
  }
  
  function split (arr, mode) {
    var set = [],
        inverse = [];
    
    if (mode !== null) {
      for (var i = 0; i < arr.length; i++) {
        if (arr[i] === mode) {
          set.push(arr[i]);
        } else {
          inverse.push(arr[i]);
        }
      }
    }
    
    return [set, inverse];
  }
  
  
  return (function (arr) {
    var mode = getMode(arr),
        lists = split(arr, mode);
       
    return {
      mode: mode,
      set: lists[0],
      inverse: lists[1]
    };
  });
}());


var info = findMode([5,3,6,3,3,3]),
    noMode = findMode([5, 7, 5, 7]);

console.log(info);
console.log(noMode);

Answer 2

你的代码正在匹配，对于循环中的每个数字，索引i+1之后的数字：

[5,3,6,3,3,3]
   ^   ^       //first match
[5,3,6,3,3,3]
   ^     ^    // match 2
[5,3,6,3,3,3]
   ^       ^  // match 3
[5,3,6,3,3,3]
       ^ ^    // match 4
[5,3,6,3,3,3]
       ^   ^  // match 5
[5,3,6,3,3,3]
         ^ ^  // match 6

解决此问题的一种简单方法是，如果continue已匹配，则使用i重置循环;但如果你有多次双重发生，它就会失败。

Answer 3

维护一个对象数组以保留已处理的项目，并忽略下一个已处理的迭代器中的项目。

function mode(arr) {
var processed = {};
for (var i = 0; i < arr.length; i++) {
    for (var k = i + 1; k < arr.length; k++) {
        if (arr[i] == arr[k]) {
            modeItems += arr[k];
            modeItems += !processed[arr[k]] ? arr[k] : '';
            processed[arr[k]] = i;
            break;
        } else {
            otherItems += arr[i];
        }
      }
  }
  return modeItems;
}

Output: 3,3,3,3

Answer 4

我还要加两分钱。此代码删除匹配的项目，不再使用它:)

    private void DefineCamera()
    {
        PerspectiveCamera camera = new PerspectiveCamera
        {
            FieldOfView = 60
        };

        PositionCamera(camera);
        Viewport.Camera = camera; // Must be run in Main thread.
    }

如何消除单个数组中元素的额外匹配

4 个答案: