精华内容
下载资源
问答
  • 补一下数学基础 集合间的数学操作 ... 对称差集: 调用函数symmetric_difference() 或者 ^ ,原集合不发生变化 代码 """ 集合间的数学操作 交集: 调用函数intersection()或者 & ,原集合不发生

    补一下数学基础
    在这里插入图片描述

    集合间的数学操作
        交集: 调用函数intersection()或者 & ,原集合不发生变化
        并集: 调用函数union() 或者 | ,原集合不发生变化
        差集: 调用函数difference()或者 - ,原集合不发生变化
        对称差集: 调用函数symmetric_difference() 或者 ^ ,原集合不发生变化
    

    代码

    """
        集合间的数学操作
            交集: 调用函数intersection()或者 & ,原集合不发生变化
            并集: 调用函数union() 或者 | ,原集合不发生变化
            差集: 调用函数difference()或者 - ,原集合不发生变化
            对称差集: 调用函数symmetric_difference() 或者 ^ ,原集合不发生变化
    """
    # 求交集
    s1 = {"python", "PYTHON", 1}
    s2 = {1, 2, 3}
    
    print("交集:", s1.intersection(s2))
    print("交集:", s1 & s2)
    print("并集:", s1.union(s2))
    print("并集:", s1 | s2)
    print("差集:", s1.difference(s2))
    print("差集:", s1 - s2)
    print("对称差集:", s1.symmetric_difference(s2))
    print("对称差集:", s1 ^ s2)
    

    截图
    在这里插入图片描述

    展开全文
  • 两个集合求对称差集

    千次阅读 2019-09-22 13:04:55
    对称差集,两个集合的并集,减去交集。 比如,集合1,2,3和集合3,3,4,5的对称差是集合1,2,4,5。 想到的解法,将两个排序,两个集合分别用两个工作指针i,j。比较两个指针指向的元素,相同就都后移,不相同,更小的...

    对称差集,两个集合的并集,减去交集。

    比如,集合1,2,3和集合3,3,4,5的对称差是集合1,2,4,5。

    想到的解法,将两个排序,两个集合分别用两个工作指针i,j。比较两个指针指向的元素,相同就都后移,不相同,更小的指针后移。

    以下代码,给出了求对称差集数量的代码。

     

    public static int distinctElementCount(int arr1[], int arr2[])
        {
            if (arr1.length == 0) {
                return arr2.length;
            }
            if (arr2.length == 0) {
                return arr1.length;
            }
            int count = 0;
            Arrays.sort(arr1);
            Arrays.sort(arr2);
            int i=0,j=0, same = -1;
            while (i< arr1.length && j<arr2.length) {
                if (arr1[i] == arr2[j]) {
                    same = arr1[i];
                    i++;j++;
                } else if (arr1[i] == same) {
                    i++;
                } else if (arr2[j] == same) {
                    j++;
                } else if (arr1[i] < arr2[j]) {
                    i++;
                    count++;
                } else {
                    j++;
                    count++;
                }
            }
            count += arr1.length + arr2.length - i - j;
    
            return count;
        }
    
        @Test
        public void testDistinct() {
            Assert.assertEquals(6, distinctElementCount(new int[]{1,2,3,4}, new int[]{4,5,6,7}));
            Assert.assertEquals(7, distinctElementCount(new int[]{4,3,5,6}, new int[]{3,2,1,6,3,9,8,13}));
            Assert.assertEquals(12, distinctElementCount(new int[]{1,2,3,4,5,6,7,8,9,10}, new int[]{11,12,13,4,5,6,7,18,19,20}));
        }

     

    转载于:https://www.cnblogs.com/23lalala/p/5209238.html

    展开全文
  • Python Set集合 定义 创建 基本方法 集合运算 交并差集 对称差集 增加 删除 遍历 定义 Set Types-Set,frozenset set 对象是由具有唯一性的 hashable对象所组成的无序多项集。常见的用途包括成员测试、从序列中...

    Python Set集合 定义 创建 基本方法

    定义

    • Set Types-Set,frozenset

    • set 对象是由具有唯一性的 hashable对象所组成的无序多项集。常见的用途包括成员测试、从序列中删除重复项以及计算数学运算,如交集、并集、差分和对称差分

    • 与其他集合一样,set支持x in setlen(set)For x in set。集合是无序集合,不记录元素位置或插入顺序。因此,集合不支持索引、切片或其他类似序列的行为。

    • 当前有两种内置的set类型,setfrozenset。集合类型是可变的-可以使用add()remove()等方法更改内容。因为它是可变的,所以它没有哈希值,不能用作字典键或另一个集合的元素。frozenset类型是不可变的和可散列的-它的内容在创建之后不能被更改;因此,它可以用作字典键或另一个集合的元素。

    • 除了set构造函数之外,还可以通过在大括号中放置逗号分隔的元素列表(例如:{'jack','sjoerd})来创建非空集(不是frozensets)。

    • 返回一个新的set或frozenset对象,其元素取自iterable。集合的元素必须是可哈希的。要表示集合的集合,内部集合必须是frozenset对象。如果未指定iterable,则返回一个新的空集。

    创建

    集合可以通过多种方式创建:

    1. 使用逗号分隔的大括号内元素列表:{'jack', 'sjoerd'}

    2. 使用集合理解:{c for c in 'abracadabra' if c not in 'abc'}

    3. 使用类型构造函数:set()set('foobar')set(['a','b','foo'])

    >>> {c for c in 'abracadabra' if c not in 'abc'}
    {'d', 'r'}
    >>> set('foobar')
    {'b', 'r', 'f', 'o', 'a'}
    >>> set(['a','b','foo'])
    {'b', 'foo', 'a'}
    

    显示

    • 集合显示 集合显示由大括号表示,并且由于缺少分隔键和值的冒号而与字典显示区分开来:
    set_display ::=  "{" (starred_list | comprehension) "}"
    
    • 集合显示产生一个新的可变集合对象, 由表达式序列或推导式指定的内容。 当提供一个逗号分隔的表达式列表时,它的元素从左到右求值并添加到集合对象中。 当提供了一个推导式时,集合是由推导式产生的元素构造的。

    • 不能用 {} 构造空集; 这个字面量构造了一个空字典。

    方法

    集合操作

    查看

    setfrozenset 的实例提供以下操作:

    • len(s) 返回集合s中元素的数量(s的基数)。

    • x in s 测试 xs中的成员资格。

    • x not in s中测试 x是否为 s中的非成员。

    >>> a = set("fyznb")
    {'z', 'b', 'n', 'f', 'y'}
    >>> b = {'a', 'b', 'x', 'y'}
    {'y', 'b', 'x', 'a'}
    >>> len(b)
    4
    >>> 'x' in b, 'c' not in b
    (True, True)
    
    • isdisjoint(other)如果集合中没有与 other共有的元素则返回 True。 当且仅当两个集合的交集为空集合时,两者为不相交集合。
    >>> a, b
    ({'z', 'b', 'n', 'f', 'y'}, {'y', 'b', 'x', 'a'})
    >>> a.isdisjoint(b), a.isdisjoint({'c', 'd'})
    (False, True)
    
    • issubset(other)

      • set <= other 测试set中的每个元素是否都在 other中。
      • set < other 测试set是否是other的真子集,即set <= other and set != other
      >>> set("abc").issubset(set('abcd'))
      True
      >>> set("abc") <= set('abcd')
      True
      >>> set("abc") < set('abc')
      False
      
    • issuperset(other)

      • set >= other 测试 other中的每个元素是否都在set中。
      • set > other 测试该set是否是other的真超集,即set >= other and set != other
      >>> set("abcd").issuperset(set('ab'))
      True
      >>> set("abcd") >= set('ab')
      True
      >>> set("abcd") > set('ab')
      True
      

    运算

    • 并集union(*others)

      • set | other | ...返回一个包含set中的元素和others的新集合。
    • 交集intersection(*others)

      • set & other & ...返回一个新的集合,其中包含setothers共有的元素。
    >>> set("abc").union(set("bcd"))
    {'d', 'c', 'a', 'b'}
    >>> set("abc") | set("bcd")
    {'d', 'c', 'a', 'b'}
    >>> set("abc").intersection(set("bcd"))
    {'b', 'c'}
    >>> set("abc") & set("bcd")
    {'b', 'c'}
    
    • 差集difference(*others)

      • set - other - ...返回一个新集合,该集合中的元素不在others中。
    • 对称差集symmetric_difference(other)

      • set ^ other 返回一个新集合,其中的元素或属于set或属于 other 指定的其他集合,但不能同时属于两者。
    >>> set("abc").difference(set("bcd"))
    {'a'}
    >>> set("abc") - set("bcd")
    {'a'}
    >>> set("abc").symmetric_difference(set("bcd"))
    {'d', 'a'}
    >>> set("abc") ^ set("bcd")
    {'d', 'a'}
    

    Notes:union()intersection()difference()symmetric_difference()issubset()issuperset()方法的非运算符版本将接受任何可迭代对象作为参数。 相比之下,它们的基于运算符的对应物需要设置它们的参数。 这排除了像 set('abc') & 'cbs'这样容易出错的结构,而支持更易读的 set('abc').intersection('cbs')

    set&frozenset的区别

    setfrozenset均支持集合与集合的比较。 两个集合当且仅当每个集合中的每个元素均包含于另一个集合之内(即各为对方的子集)时则相等。 一个集合当且仅当其为另一个集合的真子集(即为后者的子集但两者不相等)时则小于另一个集合。 一个集合当且仅当其为另一个集合的真超集(即为后者的超集但两者不相等)时则大于另一个集合。

    set的实例与 frozenset的实例之间基于它们的成员进行比较。 例如 set('abc') == frozenset('abc')返回 Trueset('abc') in set([frozenset('abc')])也一样。

    子集与相等比较并不能推广为完全排序函数。 例如,任意两个非空且不相交的集合不相等且互不为对方的子集,因此以下 所有 比较均返回 False: a<b, a==b, or a>b

    由于集合仅定义了部分排序(子集关系),因此由集合构成的列表list.sort()方法的输出并无定义。

    集合的元素,与字典的键类似,必须为 hashable

    混合了 set实例与 frozenset的二进制位运算将返回与第一个操作数相同的类型。例如: frozenset('ab') | set('bc') 将返回 frozenset 的实例。

    下面列出了可用于 set而不能用于不可变的 frozenset实例的操作:

    自运算

    • update(*others)
      • set |= other | ...更新集合,添加来自 others 中的所有元素。
    • intersection_update(*others)
      set &= other & ...更新集合,只保留其中在所有 others 中也存在的元素。
    >>> s = {'b', 'c', 'a'}
    >>> s.update(set("bcd"))
    #   s |= set("bcd")
    >>> s
    {'d', 'c', 'a', 'b'}
    >>> s.intersection_update(set("bcd"))
    #   s &= set("bcd")
    >>> s
    {'b', 'd', 'c'}
    
    • difference_update(*others)
      set -= other | ...更新集合,移除其中也存在于 others 中的元素。
    • symmetric_difference_update(other)
      set ^= other更新集合,只保留存在于集合的一方而非共同存在的元素。
    >>> s = {'b', 'c', 'a'}
    >>> s.difference_update(set("bcd"))
    #   s -= set("bcd")
    >>> s
    {'a'}
    >>> s.symmetric_difference_update(set("bcd"))
    #   s ^= set("bcd")
    >>> s
    {'b', 'd', 'c', 'a'}
    

    增删改

    • add(elem)将元素 elem添加到集合中。
    • remove(elem)从集合中移除元素 elem。 如果 elem不存在于集合中则会引发 KeyError
    • discard(elem)如果元素 elem存在于集合中则将其移除。
    • pop()从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError
    >>> s = {'b', 'd', 'c', 'a'}
    >>> s.add("e")
    {'e', 'd', 'b', 'c', 'a'}
    >>> s.remove("e")
    {'d', 'b', 'c', 'a'}
    >>> s.discard("e")
    >>> s.remove("e")
    KeyError: 'e'
    >>> s.pop()
    'd'
    
    • clear()从集合中移除所有元素。
    • copy()返回集合的浅拷贝。
    >>> s = {'b', 'd', 'c', 'a'}
    >>> sa = s.copy()
    >>> s.clear()
    >>> s, sa
    (set(), {'b', 'd', 'c', 'a'})
    

    Notes,非运算符版本的 update(), intersection_update(), difference_update()symmetric_difference_update()方法将接受任意可迭代对象作为参数。

    Notes__contains__(), remove()discard() 方法的 elem参数可能是一个 set。 为支持对一个等价的 frozenset进行搜索,会根据 elem临时创建一个该类型对象。

    集合遍历

    由于set 对象是由具有唯一性的 hashable对象所组成的无序多项集,故不能用下标来访问,但可以使用迭代把集合中的值读出来。也可以转为其它格式查看

    >>> s = {'b', 'd', 'c', 'a'}
    
    >>> for i in s:
    	print(i, end = ' ')
    
    	
    b d c a 
    
    >>> list(s)  # 列表
    ['b', 'd', 'c', 'a']
    >>> tuple(s) # 元组
    ('b', 'd', 'c', 'a')
    
    展开全文
  • 交集定义为同时出现在两个文件中的记录项,并集定义为出现在任何一个文件中的记录项,差集(A-B)定义为出现在A中而且不出现在B中的记录,对称差集定义为只出现在一个文件中的记录。 假设 a.txt 包括 a, c, b

    网上转的,不错,比使用awk容易点


    给定两个文件 a.txt 和 b.txt ,每行是一个记录(假设没有重复),要求输出两集合的交集、并集、差集,输出的结果只包括唯一项。交集定义为同时出现在两个文件中的记录项,并集定义为出现在任何一个文件中的记录项,差集(A-B)定义为出现在A中而且不出现在B中的记录,对称差集定义为只出现在一个文件中的记录。


    假设 a.txt 包括 a, c, b 三行。假设 b.txt 包括 d, e, c, b 四行。

    交集,把两个文件放到一起排序,只输出次数多于一次的项:
    $ sort a.txt b.txt | uniq -d
    b
    c

    并集,把两个文件放到一起排序,重复的项只算一次:
    $ sort a.txt b.txt | uniq
    a
    b
    c
    d
    e

    差集(A-B),把B的元素重复2份和A的元素放到一起排序,只输出出现一次的项:
    $ sort a.txt b.txt b.txt | uniq -u
    a

    对称差,把两个文件放到一起排序,只输出出现一次的项:
    $ sort a.txt b.txt | uniq -u
    a
    d
    e
    展开全文
  • 集合中的(交集,并集,差集,补集,对称差集)老是会弄混了 常用的集合类有一下几种: List结构的集合类:ArrayList类,LinkedList类,Vector类,Stack类 Map结构的集合类:HashMap类,Hashtable类 Set结构的...
  • 在许多情况下,需要比较多个列表,获取它们有或没有交集、差集等等,在 JavaScript 有一个数据类型可以很好的实现这些需求,那就是 Set 。Set对象就像一个数组,但是仅包含唯一项。...
  • 计算 两个集合的交集、并集、差集对称集 import sys import time #刷新缓冲区 def flush(): time.sleep(1) #除去重复元素 def duplicate_removal(lt): lt1 = [] for i in lt: if i not in lt1: lt1....
  • STL库中有丰富的集合运算方法,我们可以使用它们快速完成交集、并集、差集、对称差集的运算。(转载请指明出于breaksoftware的csdn博客) 交集(intersection) 交集是集合运算中经常会用到的计算,其表达是两个...
  • STL库中有丰富的集合运算方法,我们可以使用它们快速完成交集、并集、差集、对称差集的运算。(转载请指明出于breaksoftware的csdn博客) 交集(intersection) 交集是集合运算中经常会用到的计算,其表达是两个...
  • 对称差集,把两个 set 各自的、与对面不同的部分、拿出来 { 1 , 2 , 7 } 5.定义一个空的集合set。 >> > type ( { } ) < class 'dict' > 定义失败,什么都没有成为一个空字典。 >> > type ( ...
  • 博文首先贴出交集、并集、差集对称差运算的C++代码以及程序运行结果,然后再进行一个比较完整的构建代码思路解析,整个项目的实现功能如下: 文章目录 1. 实现代码以及程序运行结果 1.1 头文件定义 UFSets.h 1.2 ...
  • 通过证明循环请求集与松弛循环差集的等价性,将求取包含任意数量节点的分布式系统对称请求集的问题转化为求取任意数量节点集合的松弛差集问题,并在此基础上提出了一种基于循环松弛差集对称分布式互斥请求集生成...
  • # 定义新的空集合的方法, 只有一种, 不能写: {}, {}是空字典的定义创建方法 set_a = set() # 非空集合创建 set_b = {value0, value1, value2, ...} set_c = set(value0, value1, value2, ...) 内置基本操作 # ...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    7. 数据结构是研讨数据的_(1)物理结构_和_(2)逻辑结构 _,以及它们之间的相互关系,并对与这种结构定义相应的_操作(3)_,设计出相应的(4)算法_。【西安电子科技大学 1998 二、2(3分)】 8. 一个算法具有 ...
  • 也就是说对称差集是去除同时出现在两个集合中的元素后,两集合其他元素组成的集合。例如:集合{1,2,3,7,9}和{3,4,5,7}的对称差为{1,2,4,5,9}。集合论中的这个运算相当于布尔逻辑中的异或运算。集合A和B的对称差通常...
  • 离散数学之集合笔记一

    千次阅读 2019-02-02 16:30:06
    1.1 集合的定义 集合: 是由指定范围内的满足给定条件的所有对象聚集在一起构成,每一个对象称 为这个集合的元素。 外延公理 + 空集存在公理 + 无序对公理 + 并集公理 + 幂集公理 + 无穷公理 + 替换公理 + 正则公理 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,826
精华内容 1,930
关键字:

对称差集的定义