Каков самый быстрый и элегантный способ вычисления разности множеств с использованием массивов Javascript?
-
19-09-2019 - |
Вопрос
Позволять A
и B
быть два комплекта.Я ищу Действительно быстрые или элегантные способы вычисления установленной разницы (A - B
или A \B
, в зависимости от ваших предпочтений) между ними.Как следует из названия, эти два набора хранятся и обрабатываются как массивы Javascript.
Примечания:
- Уловки, специфичные для гекконов, допустимы.
- Я бы предпочел придерживаться собственных функций (но я открыт для облегченной библиотеки, если она намного быстрее)
- Я видел, но не проверял, JS.Set (см. предыдущий пункт)
Редактировать: Я заметил комментарий о наборах, содержащих повторяющиеся элементы.Когда я говорю «набор», я имею в виду математическое определение, которое означает (помимо прочего), что они не содержат повторяющихся элементов.
Решение
если не знаю, наиболее ли это эффективно, но, возможно, самое короткое
A = [1, 2, 3, 4];
B = [1, 3, 4, 7];
diff = A.filter(function(x) { return B.indexOf(x) < 0 })
console.log(diff);
Обновлено до ES6:
A = [1, 2, 3, 4];
B = [1, 3, 4, 7];
diff = A.filter(x => !B.includes(x) );
console.log(diff);
Другие советы
Ну а 7 лет спустя, с Набор ES6 объект это довольно просто (но все же не так компактно, как питоны A - B), и, как сообщается, быстрее, чем indexOf
для больших массивов:
console.clear();
let a = new Set([1, 2, 3, 4]);
let b = new Set([5, 4, 3, 2]);
let a_minus_b = new Set([...a].filter(x => !b.has(x)));
let b_minus_a = new Set([...b].filter(x => !a.has(x)));
let a_intersect_b = new Set([...a].filter(x => b.has(x)));
console.log([...a_minus_b]) // {1}
console.log([...b_minus_a]) // {5}
console.log([...a_intersect_b]) // {2,3,4}
Вы можете использовать объект в качестве карты, чтобы избежать линейного сканирования. B
для каждого элемента A
как в ответ пользователя 187291:
function setMinus(A, B) {
var map = {}, C = [];
for(var i = B.length; i--; )
map[B[i].toSource()] = null; // any other value would do
for(var i = A.length; i--; ) {
if(!map.hasOwnProperty(A[i].toSource()))
C.push(A[i]);
}
return C;
}
Нестандартный toSource()
метод используется для получения уникальных имен свойств;если все элементы уже имеют уникальные строковые представления (как в случае с числами), вы можете ускорить код, убрав toSource()
призывы.
Самый короткий вариант с использованием jQuery:
var A = [1, 2, 3, 4];
var B = [1, 3, 4, 7];
var diff = $(A).not(B);
console.log(diff.toArray());
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
Я бы хэшировал массив B, а затем сохранял значения из массива A, отсутствующие в B:
function getHash(array){
// Hash an array into a set of properties
//
// params:
// array - (array) (!nil) the array to hash
//
// return: (object)
// hash object with one property set to true for each value in the array
var hash = {};
for (var i=0; i<array.length; i++){
hash[ array[i] ] = true;
}
return hash;
}
function getDifference(a, b){
// compute the difference a\b
//
// params:
// a - (array) (!nil) first array as a set of values (no duplicates)
// b - (array) (!nil) second array as a set of values (no duplicates)
//
// return: (array)
// the set of values (no duplicates) in array a and not in b,
// listed in the same order as in array a.
var hash = getHash(b);
var diff = [];
for (var i=0; i<a.length; i++){
var value = a[i];
if ( !hash[value]){
diff.push(value);
}
}
return diff;
}
Включив идею Кристофа и приняв пару нестандартных методов итерации для массивов и объектов/хешей (each
и друзья), мы можем получить разность множеств, объединение и пересечение за линейное время, всего примерно за 20 строк:
var setOPs = {
minusAB : function (a, b) {
var h = {};
b.each(function (v) { h[v] = true; });
return a.filter(function (v) { return !h.hasOwnProperty(v); });
},
unionAB : function (a, b) {
var h = {}, f = function (v) { h[v] = true; };
a.each(f);
b.each(f);
return myUtils.keys(h);
},
intersectAB : function (a, b) {
var h = {};
a.each(function (v) { h[v] = 1; });
b.each(function (v) { h[v] = (h[v] || 0) + 1; });
var fnSel = function (v, count) { return count > 1; };
var fnVal = function (v, c) { return v; };
return myUtils.select(h, fnSel, fnVal);
}
};
Это предполагает, что each
и filter
определены для массивов, и что у нас есть два служебных метода:
myUtils.keys(hash)
:возвращает массив с ключами хешаmyUtils.select(hash, fnSelector, fnEvaluator)
:Возвращает массив с результатами вызоваfnEvaluator
на парах ключ/значение, для которыхfnSelector
возвращает истину.
А select()
вдохновлен Common Lisp и является просто filter()
и map()
слились в одно.(Было бы лучше определить их на Object.prototype
, но это приводит к хаосу в jQuery, поэтому я остановился на статических служебных методах.)
Производительность:Тестирование с
var a = [], b = [];
for (var i = 100000; i--; ) {
if (i % 2 !== 0) a.push(i);
if (i % 3 !== 0) b.push(i);
}
дает два набора с 50 000 и 66 666 элементами.При этих значениях A-B занимает около 75 мс, а объединение и пересечение — около 150 мс каждое.(Mac Safari 4.0, для определения времени используется дата Javascript.)
Я думаю, это достойная плата за 20 строк кода.
С использованием Underscore.js (Библиотека для функционального JS)
>>> var foo = [1,2,3]
>>> var bar = [1,2,4]
>>> _.difference(foo, bar);
[4]
Некоторые простые функции, заимствованные из ответа @milan:
const setDifference = (a, b) => new Set([...a].filter(x => !b.has(x)));
const setIntersection = (a, b) => new Set([...a].filter(x => b.has(x)));
const setUnion = (a, b) => new Set([...a, ...b]);
Использование:
const a = new Set([1, 2]);
const b = new Set([2, 3]);
setDifference(a, b); // Set { 1 }
setIntersection(a, b); // Set { 2 }
setUnion(a, b); // Set { 1, 2, 3 }
Что касается способа натощак, то он не так элегантен, но я провел несколько тестов, чтобы убедиться в этом.Загрузка одного массива как объекта гораздо быстрее обрабатывается в больших количествах:
var t, a, b, c, objA;
// Fill some arrays to compare
a = Array(30000).fill(0).map(function(v,i) {
return i.toFixed();
});
b = Array(20000).fill(0).map(function(v,i) {
return (i*2).toFixed();
});
// Simple indexOf inside filter
t = Date.now();
c = b.filter(function(v) { return a.indexOf(v) < 0; });
console.log('completed indexOf in %j ms with result %j length', Date.now() - t, c.length);
// Load `a` as Object `A` first to avoid indexOf in filter
t = Date.now();
objA = {};
a.forEach(function(v) { objA[v] = true; });
c = b.filter(function(v) { return !objA[v]; });
console.log('completed Object in %j ms with result %j length', Date.now() - t, c.length);
Полученные результаты:
completed indexOf in 1219 ms with result 5000 length
completed Object in 8 ms with result 5000 length
Однако это работает с только струны.Если вы планируете сравнивать пронумерованные наборы, вам нужно будет сопоставить результаты с помощью анализироватьFloat.
Это работает, но я думаю, что другой вариант намного короче и элегантнее.
A = [1, 'a', 'b', 12];
B = ['a', 3, 4, 'b'];
diff_set = {
ar : {},
diff : Array(),
remove_set : function(a) { ar = a; return this; },
remove: function (el) {
if(ar.indexOf(el)<0) this.diff.push(el);
}
}
A.forEach(diff_set.remove_set(B).remove,diff_set);
C = diff_set.diff;