Математика, пересекающая

Question

Я ищу, чтобы поиграть с вероятностью, которая вовлекает много, если большие числа. Чтобы сэкономить вычислительное время, я думал о том, что компьютер перечеркивает термины, как в обычной математике. Например:

(2 * 3 * 7 * 3)/(3 * 2 * 3 * 3)

Может быть упрощено до 7/3

Если бы я создать функцию Javascript и передать ему два массива, содержащие числа умножения, чтобы перечеркнуть, как бы я это сделал?

Просто чтобы быть ясно:

Если я прошел в [3, 4, 6, 4] и [4, 7, 3, 2], было бы возвращать два массива: [4, 6] и [7, 2]

Answer 1

Если вы не требуют отмены за пределы точных цифр, это нужно сделать:

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

Answer 2

После этого совсем немного больше исследований я нашел способ сделать это.

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

Demo

Answer 3

Да, или:

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()); 

UPDATE: чтобы отобразить часть

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

alert(prod(arr1) + "/" + prod(arr2)); 

Answer 4

Другой способ - использовать версию 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; 
} 

jsFiddle: http://jsfiddle.net/tj6crcdt/

Answer 5

Вот способ сделать это, что не имеет зависимостей. Есть несколько предположений, которые могут вас укусить.

• Он проверяет номера на основе равенства. В вашем случае использования (вероятности) это будет кусаться по значениям с плавающей запятой.

• Возможно, лучше выполнить расчеты. Насколько нам известно, механизм выбора 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);