数学划掉了

Math crossing out

本文关键字：掉了      更新时间：2023-09-26

我正在寻找涉及很多大数字的概率。为了节省计算时间，我正在考虑让计算机像在常规数学中那样划掉项。例如：

（2*3*

7*3）/（3*2*3*3）

可以简化为 7/3

如果我要创建一个 Javascript 函数并向其传递两个包含要划掉的乘法数字的数组，我将如何做到这一点？

需要明确的是：

如果我传入 [3, 4, 6, 4] 和 [4, 7, 3, 2] ，它将返回两个数组：[4, 6] 和 [7, 2]

如果您不需要取消超出确切数字的取消，这应该可以：

var x = [3, 4, 6, 4];
var y = [4, 7, 3, 2];
for(var i in x)
{
  for(var j in y)
  {
    if(x[i]==y[j])
    {
      x.splice(i,1);
      y.splice(j,1);
    }
  }
}
console.log(x);
console.log(y);

但是，如果您有兴趣进一步取消，请采取以下措施：

var x = [3, 4, 6, 4];
var y = [4, 7, 3, 2];
for(var i in x)
{
  for(var j in y)
  {
    if(x[i]%y[j] == 0)
    {
      if(x[i]/y[j] > 1)
      {
        x[i] = x[i]/y[j];
      }
      else{
        x.splice(i,1);
      }
      y.splice(j,1);
    }
  }
}
console.log(x);
console.log(y);

另一种方法是使用inArray的一个版本（取自jQuery），然后检查每个元素并根据需要删除元素。不过，我不确定与仅进行计算相比，这表现如何，值得在 jsPerf 上进行测试。

例如：

removeDuplicates([3, 4, 6, 4], [4, 7, 3, 2]);
function removeDuplicates( array_1, array_2 ) {
    array_1.forEach(function(value, index) {
        var in_array = inArray( value, array_2 );
        if ( in_array !== false ) {
            array_1.splice( index, 1 );
            array_2.splice( in_array, 1 );
        }
    });
    console.log(array_1); // [4, 6]
    console.log(array_2); // [7, 2]
}
// from jQuery
function inArray(needle, haystack) {
    var length = haystack.length;
    for(var i = 0; i < length; i++) {
        if(haystack[i] == needle) return i;
    }
    return false;
}

js小提琴：http://jsfiddle.net/tj6crcdt/

是的，或者：

var arr1 = [5,2,3,7,8];
var arr2 = [3,5,2,3];
arr1.sort();
arr2.sort();
var i = 0, j = 0;
while (i < arr1.length && j < arr2.length) {
    if (arr1[i] < arr2[j]) {
        ++i;
    } else if (arr1[i] > arr2[j]) {
        ++j;
    } else {
        arr1.splice(i, 1);
        arr2.splice(j, 1);
    }
}
alert(arr1.toString() + "/" + arr2.toString());

更新：显示分数

function prod(arr) {
    var res = 1, i;
    for (i = 0; i < arr.length; ++i) {
        res *= arr[i];
    }
    return res;
}
alert(prod(arr1) + "/" + prod(arr2));

这是一个没有依赖项的方法。有几个假设可能会咬你。

  • 它基于相等性测试数字。在您的用例（概率）中，这将影响浮点值。

  • 运行计算可能更好。就我们所知，无论如何，选择的JavaScript引擎正在做更好的优化。

下面是代码和示例用法： 

var numerator = [2,3,7,3],
denominator = [3,2,3,3],
numerator2 = [3,4,6,4],
denominator2 = [4,7,3,2];
function simplify(num, den) {
  var value = {
    numerator: num.slice(),
    denominator: den.slice()
  },
  done = false,
  remove = function (a, b) {
    for (var aIdx = 0; aIdx < a.length; aIdx++) {
      for (var bIdx = 0; bIdx < b.length; bIdx++) {
        if (a[aIdx] === b[bIdx]) {
          a.splice(aIdx, 1);
          b.splice(bIdx, 1);
          return;
        }
      }
    }
    done = true;
  };
  while (!done) {
    remove(value.numerator, value.denominator);
  }
  return value;
}
simplify(numerator, denominator);
simplify(numerator2, denominator2);

在做了更多的研究之后，我找到了一种方法。

var arr1 = [5,2,3,7,8];
var arr2 = [3,5,2,3];
var extraVals = _.intersection(arr1,arr2);
var arr1Simp = _.difference(arr1, extraVals);
var arr2Simp = _.difference(arr1, extraVals);

或作为函数

var likeTerms = function(num, down){
    var extraVals = _.intersection(num,down);
    var numSimp = _.difference(num, extraVals);
    var downSimp = _.difference(down, extraVals);
    if(numSimp.length==0){
        numSimp.push(1);
    }
    if(downSimp.length==0){
        downSimp.push(1);
    }
    return {
        num: numSimp,
        down: downSimp
    };
};

演示

相关文章：