标签: set-intersection

我有两个numpy整数数组,长度都是几亿.在每个数组中,值是唯一的,并且每个值最初都是未排序的.

我希望每个索引产生它们的排序交集.例如:

x = np.array([4, 1, 10, 5, 8, 13, 11])
y = np.array([20, 5, 4, 9, 11, 7, 25])

然后这些排序的交集是[4, 5, 11],所以我们想要将x和y中的每一个转换成该数组的索引,所以我们希望它返回:

mx = np.array([0, 3, 6])
my = np.array([2, 1, 4])

自那时候起 x[mx] == y[my] == np.intersect1d(x, y)

到目前为止,我们唯一的解决方案涉及三种不同的方法,因此似乎不太可能是最优的.

每个值代表一个星系,以防这个问题变得更有趣.

我有一个像这样的代码片段,在VC++ 2010下编译.

        std::set<int> s1;
        std::set<int> s2;
        std::set<int> res_set;
        std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), res_set.begin());

据我所知,这应该有效.但是,我得到了构建错误:

c:\program files (x86)\microsoft visual studio 10.0\vc\include\algorithm(4494): error C3892: 'std::_Tree_const_iterator<_Mytree>::operator *' : you cannot assign to a variable that is const
1>          with
1>          [
1>              _Mytree=std::_Tree_val<std::_Tset_traits<int,std::less<int>,std::allocator<int>,false>>
1>          ]
1>          c:\program files (x86)\microsoft visual studio 10.0\vc\include\algorithm(4522) : see reference to function template instantiation '_OutIt std::_Set_intersection<_InIt1,_InIt2,_OutIt>(_InIt1,_InIt1,_InIt2,_InIt2,_OutIt)' being compiled
1>          with
1>          [
1>              _OutIt=std::_Tree_const_iterator<std::_Tree_val<std::_Tset_traits<int,std::less<int>,std::allocator<int>,false>>>,
1>              _InIt1=std::_Tree_unchecked_const_iterator<std::_Tree_val<std::_Tset_traits<int,std::less<int>,std::allocator<int>,false>>>,
1>              _InIt2=std::_Tree_unchecked_const_iterator<std::_Tree_val<std::_Tset_traits<int,std::less<int>,std::allocator<int>,false>>>
1>          ]
1>          c:\program files (x86)\microsoft visual studio 10.0\vc\include\algorithm(4549) : …

我遇到了这个例子,我不明白这意味着什么.

(SELECT drinker FROM Frequents)
     EXCEPT ALL
(SELECT drinker FROM Likes);

关系:频繁(饮酒者,酒吧),喜欢(饮酒者,啤酒)

在这种情况下,ALL会做什么？结果与下面的查询有何不同？

(SELECT drinker FROM Frequents)
     EXCEPT
(SELECT drinker FROM Likes);

下面的例子展示了如何计算两个集合的交集。STL 是否提供了不仅可以为 2 组而且可以为N组执行此操作的工具？

#include <iostream>    
#include <algorithm>
#include <vector>

int main()
{
    std::vector<int> v1 = { 1,2,9,3,4,5 };
    std::vector<int> v2 = { 9,4,2,7,4,1 };
    std::vector<int> v(v1.size() + v2.size());
    std::vector<int>::iterator it;

    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());
    it = std::set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v.begin());

    v.resize(it - v.begin());
    std::cout << "Both sets have " << (v.size()) << " elements in common:\n";
    for (it = v.begin(); it != v.end(); ++it)
    {
        std::cout << *it << ' ';
    }
    std::cout << '\n';

    return …

以下代码的复杂性是什么？

set<int> S1, S2, ans;
set_intersection(S1.begin(), S1.end(), S2.begin(), S2.end(), inserter(ans, ans.begin()))

where S1和S2是一些non_empty集,ans是一个空集.

我知道将一个排序范围插入一个集合是线性的; 但是也使用插入线性插入？

考虑以下几组概率(三个事件不相互排斥):

• 0.05625成功,0.94375失败
• 0.05625成功,0.94375失败
• 0.05625成功,0.94375失败

如何计算至少一个事件发生的概率(即工会)？

如果可能的话,我更喜欢一个通用的,独立的解决方案,它也可以处理4个或更多事件.在这种情况下,我正在寻找的答案是:

0.05625 + 0.05625 + 0.05625 -
0.05625*0.05625 - 0.05625*0.05625 - 0.05625*0.05625 +
0.05625*0.05625*0.05625
##[1] 0.1594358

我的问题最终比标题更广泛,因为我正在寻找可以计算union,intersection(0.05625*0.05625*0.05625 = 0.0001779785),没有事件发生(1 - 0.1594358 = 0.8405642)或恰好发生一个事件(0.150300)的概率的函数.换句话说,这个在线连接三个事件计算器的R解决方案.我已经查看了这个prob包,但是对于这种简单的用例来说,它似乎有一个太复杂的界面.

给定输入 json

[
  {"title": "first line"},
  {"title": "second line"},
  {"title": "third line"}
]

我们如何仅提取包含在第二个“过滤器”数组中列出的关键字的标题。例如，在此处使用 shell 变量：

filter='["second", "third"]'

在这种情况下的输出将是

[
  {"title": "second line"},
  {"title": "third line"}
]

另外，如何使用数组过滤器来否定。例如：仅返回上一个示例中的“第一行”条目。

有一个类似的回复，但使用的是旧版本的 jq。我希望有一种更直观/可读的方式来使用当前版本的 jq 来做到这一点。

我正在与UpSetR进行一些比较进行一些比较，并且我想保存属于每个交叉点的元素列表。这可能吗？我在任何地方都找不到它...

手动执行此操作（许多列表）会非常乏味，而且由于它们是经过计算的，因此无法保存它们令人沮丧

这是一个简单的例子，展示了我正在尝试做的事情：

use std::collections::HashSet;

fn main() {
    let mut sets: Vec<HashSet<char>> = vec![];

    let mut set = HashSet::new();
    set.insert('a');
    set.insert('b');
    set.insert('c');
    set.insert('d');
    sets.push(set);

    let mut set = HashSet::new();
    set.insert('a');
    set.insert('b');
    set.insert('d');
    set.insert('e');
    sets.push(set);

    let mut set = HashSet::new();
    set.insert('a');
    set.insert('b');
    set.insert('f');
    set.insert('g');
    sets.push(set);

    // Simple intersection of two sets
    let simple_intersection = sets[0].intersection(&sets[1]);
    println!("Intersection of 0 and 1: {:?}", simple_intersection);

    let mut iter = sets.iter();
    let base = iter.next().unwrap().clone();
    let intersection = iter.fold(base, |acc, set| acc.intersection(set).map(|x| x.clone()).collect());
    println!("Intersection of all: {:?}", …

该包的当前版本gmp不支持集合操作，例如intersect、setdiff等。我正在使用数字序列进行一些工作（有关示例，请参阅OEIS）并且需要处理大整数的大集合。我目前一直坚持使用各种循环来生成所需的差异或交叉点；虽然我可能可以生成编译的（Rccp 等）代码，但我希望在现有的函数和包中找到一种方法R。