精华内容
下载资源
问答
  • 一、 有序对 、 二、 有序对性质的引理、定理 、 三、 有序三元组 、 四、 有序 n 元组性质定理 、





    一、 有序对



    有序对概念 :

    <a,b>={{a},{a,b}}<a, b> = \{ \{ a \} , \{ a , b \} \}

    其中 aa 是第一个元素 , bb 是第二个元素 ;

    记做 <a,b><a, b> , 也可以记做 (a,b)(a , b)


    理解 1 : a,ba, b 是有顺序的 , 单个元素的集合中的元素是第一个元素 , 两个元素集合中的另一个元素是第二个元素 ;

    理解 2 ( 推荐 ) : 第一个元素出现在每个子集合中 , 第二个元素只出现在一个子集合中 , 通过这种方式 , 保证了有序对的定义 , 一前一后两个元素 , 前后顺序不同 , 对应的有序对不同 ;


    下面是相同的两个元素的不同的有序对 :

    有序对 <a,b>={{a},{a,b}}<a, b> = \{ \{ a \} , \{ a , b \} \}

    有序对 <b,a>={{b},{a,b}}<b, a> = \{ \{ b \} , \{ a , b \} \}





    二、 有序对性质的引理、定理



    1. 引理 1 : {x,a}={x,b}\{ x , a \} = \{ x, b \} \Leftrightarrow a=ba=b

    两个集合如果相等 , 当且仅当 a=ba = b ;



    2. 引理 2 :A=B\mathscr{A} = \mathscr{B} \not= \varnothing , 则有

    A=B\bigcup \mathscr{A} = \bigcup \mathscr{B}

    A=B\bigcap \mathscr{A} = \bigcap \mathscr{B}


    说明 : 集族 A\mathscr{A} 与 集族 B\mathscr{B} 相等 , 并且 两个集族都不为空 , 那么 两个集族的广义交相等 , 两个集族的广义并也相等 ;



    3. 定理 : <a,b>=<c,d><a,b> = <c, d> \Leftrightarrow a=cb=da = c \land b = d

    通过上述定理 , 说明有序对是有顺序的 ;



    4. 推论 : aba \not= b \Rightarrow <a,b><b,a><a,b> \not= <b, a>





    三、 有序三元组



    有序三元组 :

    <a,b,c>=<<a,b>,c><a, b, c> = < <a, b> , c >

    有序三元组是有序二元组在前 , 第三个元素在后 , 组成的有序对 ;


    有序 nn 元祖 : n2n \geq 2

    <a1,a2,,an>=<<a1,,an1>,an><a_1, a_2, \cdots , a_n> = < <a_1, \cdots , a_{n-1}> , a_n >

    先拿前 n1n-1 个元素组成一个有序 n1n-1 元祖 , n1n-1 元祖在前 , 然后跟第 nn 个元素 ana_n 在后 , 构成有序对 ;





    四、 有序 n 元组性质定理



    有序 nn 元组性质定理 :

    <a1,a2,,an>=<b1,b2,,bn><a_1, a_2, \cdots , a_n> = <b_1, b_2, \cdots , b_n> \Leftrightarrow ai=bi,i=1,2,,na_i = b_i , i = 1, 2, \cdots , n

    说明 : 两个有序 nn 元祖 , 每个对应位置上的元素两两相同 , 两个 nn 元组有序对才相等 ;

    展开全文
  • VPP的N元组分类器简介

    2020-06-03 15:21:20
    给定传入数据包,它将搜索mask和match有序列表。如果分类器找到匹配的条目,它将采取指示的操作。 如果不是,则采取最终的措施。 这样做确实很简单,但是需要花费一些时间来学习如何对其进行有效编程,您可以在性能...

    vpp分类器操作理论

    分类器是规则的集合。在某种程度上,VPP分类器只是一个笨拙的机器人,具有相当简单的控制平面API。给定传入数据包,它将搜索mask和match有序列表。如果分类器找到匹配的条目,它将采取指示的操作。 如果不是,则采取最终的措施。

    这样做确实很简单,但是需要花费一些时间来学习如何对其进行有效编程,您可以在性能和规模上创造一些成果。

    我们使用MMX单元一次匹配或哈希16字节数据,为了实现硬件的向后兼容性,该代码[当前]不使用256位(32字节)向量指令。

    分类器以构建表为中心,并在可行的情况下尽快“命中”。在大多数情况下,已建立的会话(session)会出现在第一个表格中,在这种操作模式下,分类器可以轻松处理多个MPPS /core-即使数据库中有数百万个会话。定期搜索357个表格将巧妙地解决暂停问题。

    基本操作

    分类器掩码和匹配操作如下进行。 给定分类器表起始索引, 在构建表时,掩码遵守mmx单位(16字节)的对齐方式。

    我们知道数据包数据的第一个八位位组从高速缓存行边界开始,此外,一般情况下不在L2头部上使用分类器, 倾向于手动解码以太类型,该方案使在ip4 / ip6 / MPLS等分类器表之间进行选择变得容易。

    一个没有vlan的l2头部长度为14个字节,典型的ipv4头部以0x4500开头:version = 4,header_length = 5,DSCP = 0,ECN = 0。 如果对DSCP,ECN不感兴趣,我们可以对分类器进行编程,以跳过第一个16字节的向量。

    为了对源地址上未打标签的ipv4数据包进行分类,我们对分类器进行编程,以跳过一个向量,并对一个向量进行掩码和匹配。
    基本的掩码和匹配代码如下:

     switch (t->match_n_vectors)
       {
       case 1:
         result = (data[0 + t->skip_n_vectors] & mask[0]) ^ key[0];
         break;
     
       case 2:
         result =  (data[0 + t->skip_n_vectors] & mask[0]) ^ key[0];
         result |= (data[1 + t->skip_n_vectors] & mask[1]) ^ key[1];
         break;
     
         <etc>
        }
     
     result_mask = u32x4_zero_byte_mask (result);
     if (result_mask == 0xffff)
         return (v);
    

    掩码和匹配将花费几个始终周期。

    创建分类表

    通过控制平面API“classify_add_del_table”可以创建一个分类表。
    创建分类表的原型:

     int vnet_classify_add_del_table (vnet_classify_main_t * cm,
                                      u8 * mask, 
                                      u32 nbuckets,
                                      u32 memory_size,
                                      u32 skip,
                                      u32 match,
                                      u32 next_table_index,
                                      u32 miss_next_index,
                                      u32 * table_index,
                                      int is_add)
    

    如果直接调用此例程,则传递cm =&vnet_classify_main。
    mask,skip,match按照上面描述的进行设置。mask不需要对齐,但必须和match的16字节匹配。

    分类器使用线程安全的,无需阅读器锁定的有界索引可扩展哈希。 Nbuckets是哈希存储桶向量的[固定]大小。 该算法可在恒定时间内工作,而与哈希冲突无关,但是当存储桶数组太小时会浪费空间。 一条好的经验法则:让nbuckets =预期的条目数。

    目前不支持动态扩充nbuckets。

    每个分类器表都有自己的clib mheap内存分配区域。 要选择memory_size参数,请注意每个分类器表条目需要16 *(1 + match_n_vectors)个字节。 在合理的范围内,目标较高。 Clib mheap内存使用o / s级别的虚拟内存-而不是有线内存或hugetlb内存-因此最好不要限制大小。

    next_table_index参数描述如下:下一个要搜索的表的vnet_classify_main.tables中的池索引。 代码〜0表示表列表的末尾。 0是有效的表索引!

    特定的分类器客户端节点-例如,… / vnet / vnet / classify / ip_classify.c-将“ miss_next_index”参数解释为vpp图节点的下一个索引。 当数据包分类无法产生匹配时,ip_classify_inline将数据包发送到指示的配置。

    最后,is_add参数指示是添加还是删除指示的表。 删除情况通过释放指定的clib mheap隐式终止会话。

    创建分类器会话

    通过控制平面API“classify_add_del_session”可以创建一个分类器会话。
    会话原型如下:

     int vnet_classify_add_del_session (vnet_classify_main_t * cm, 
                                        u32 table_index, 
                                        u8 * match, 
                                        u32 hit_next_index,
                                        u32 opaque_index, 
                                        i32 advance,
                                        int is_add)
    

    cm参数传递传递cm =&vnet_classify_main,is_add参数指示是添加还是删除会话。

    match是会话的关键。 它不必对齐,但长度必须为table-> match_n_vectors * 16字节。 vnet_classify_add_del_session将表的mask应用于存储键值。 通过这种方式,可以通过传递未屏蔽的(packet_data + offset)作为“ match”参数来创建会话,最后得到不混淆的会话密钥。

    特定的分类器客户端节点-例如,… / vnet / vnet / classify / ip_classify.c-将每个会话的hit_next_index参数解释为vpp图节点的下一个索引。 当数据包分类产生匹配时,ip_classify_inline将数据包发送到指定的位置。

    ip4 / 6_classify将每个会话的opaque_index参数放入vnet_buffer(b)-> l2_classify.opaque_index; 分类器应用程序都可以将会话命中的数据包发送到特定的图节点,并在缓冲区元数据中提供有用的值。 根据所需的语义,我们将已知会话流量发送到某个节点,例如 缓冲区元数据中的会话池索引。 这完全取决于控制平面和特定的用例。

    最后,诸如ip4 / 6-classify之类的节点将advance参数作为[signed]参数应用于vlib_buffer_advance(…); “消费”网络层。 示例:如果我们按(内部)源/目标地址和源/目标端口对传入的隧道IP数据包进行分类,则可能会选择对内部数据包进行解封装和重新封装。 在这种情况下,对高级参数进行编程以执行隧道解封装,然后对next_index进行编程,以将流量发送到使用opaque_index在特定隧道接口上输出流量的节点。

    展开全文
  • 只不过是 nchoosek 的语法糖,这个小但令人惊讶的有争议的函数返回非负整数的(有序n 元组的数量,加起来为 k,如果提供第二个参数,则返回它们的列表。 作为下载的替代方法,只需剪切并粘贴以下内容: m = ...
  • 在集合 {1, 2, ..., N} 上使用词法顺序,输出有序元组 x 的下一个排列。 当 All(nextperm(x,N) == x) 为 TRUE 时,您已经用尽了列表。 例如nextperm([1 5 4], 5) 返回 [2 1 3] nextperm([2 1 3], 5) 返回 [2 1 4] ...
  • 元组

    2019-10-08 16:38:46
    元组:(n1,[n2,n3...n]) 一个有序的元素组成的集合 使用小括号()表示 元组是不可变对象,元组的元素不能增加,修改,删除。 元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用: ...

    元组:(n1,[n2,n3...n])
    一个有序的元素组成的集合
    使用小括号()表示

    元组是不可变对象,元组的元素不能增加,修改,删除。

    元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用:

    一、增
    + 通过+对元组进行连接组合,返回一个新的元组
    tup1 = (12, 34.56);
    tup2 = ('abc', 'xyz')

    # 创建一个新的元组
    tup3 = tup1 + tup2;
    print (tup3)
    (12, 34.56, 'abc', 'xyz')

    二、删
    元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
    del tuple()

    三、改
    元组中的元素值是不允许更改的

    四、查
    1.tuple[index] 查询索引位置的值。也可通过索引来截取部分或全部元素
    元组:

    L = ('Google', 'Taobao', 'Runoob')
    Python 表达式 结果 描述
    L[2] ' Runoob' 读取第三个元素
    L[-2] 'Taobao' 反向读取;读取倒数第二个元素
    L[1:] ('Taobao', 'Runoob') 截取元素,从第二个开始后的所有元素。


    2.index(value,[start,[stop]])
    通过值value,从指定区间查找元组内的元素是否匹配
    匹配第一个就立即返回索引
    匹配不到,抛出异常IndexError

    备注:start 表示是从哪个索引号开始查找

    五、其他
    1.len(tuple) 返回元组中元素的个数

    2.count(value) 返回元组中value的个数

    3.max(tuple) 返回元组中元素最大值

    4.min(tuple) 返回元组中元素最小值。

    5.tuple(seq) 将列表转换为元组。

    六、命名元组 namedtuple
    namedtuple(typename,field_names,verbose=False,rename=False)

    命名元组,返回一个元组的子类,并定义了字段
    field_names可以是空格或逗号分隔的字段的字符串,可以是字段的列表

    exp:
    from collections import namedtuple
    Point = namedtuple('_Point','x','y') #Point为返回的类
    p = Point(11,22)


    Student = namedtuple('Student','name age')
    tom = Student('tom',20)
    jerry = Student('jerry',18)

    tom.name


     

    转载于:https://www.cnblogs.com/Felix-DoubleKing/p/9647303.html

    展开全文
  • Python元组

    2019-04-23 13:37:22
    是一个有序,可重复的,不可更改的对象; 特点: 1.与list类似; 2.不可变类型数据; 3.元组使用的是() 元组的基本使用格式: (元素1,元素2,...,元素n) 基本描述: ​ 元组是用()包裹起来的多个元素的数据...

    元组

    元组:
    是一个有序,可重复的,不可更改的对象;
    
    特点:
    	1.与list类似;
    	2.不可变类型数据;
    	3.元组使用的是()
    
    元组的基本使用格式:
    (元素1,元素2,...,元素n)
    

    基本描述:

    ​ 元组是用()包裹起来的多个元素的数据类型,每个元素之间用“,"隔开;

    1.元组的创建

    • 创建一个空元组
    >>> tl = ()
    >>> type(tl)
    <class 'tuple'>
    
    • 创建只含有一个元素的元组

    需要注意的地方是:如果我们创建只含有一个元素的元组,我们必须在这仅有的一个元素后加上一个人","。

    >>> tl = (6)
    >>> tl,type(tl)
    (6, <class 'int'>)
    
    >>> tl = (6,)#只有一个元素的元组,必须加上","
    >>> tl,type(tl)
    ((6,), <class 'tuple'>)
    
    • 创建含有多个元素的元组
    >>> tl = (1,2,3,4,5,6)
    

    和列表一样,元组的元素也可以是不同的数据类型的元素。

    >>>tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
    

    2.元组的基本操作

    • 通过索引值查找对应的元素
    >>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
    >>> tl[4]
    {'name': 'Tom', 'age': 18}
    >>> tl[-1]
    {'name': 'Tom', 'age': 18}
    >>> tl[::-2]
    ({'name': 'Tom', 'age': 18}, ['h', 'u', 'n', 'a', 'n'], 1)
    
    • 查找元素的索引值
    >>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
    >>> tl.index("hunan")
    1
    >>> tl.index("hunan",1,4)
    1
    

    注意:元组是不可变的数据类型:不能够增,删,改。

    >>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
    >>> tl[0] = 0
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment
    >>>
    
    

    注意到tl里有个列表,那么这个列表的元素是否可以更改:

    >>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
    >>> tl[2]
    ['h', 'u', 'n', 'a', 'n']
    >>> tl[2][2]
    'n'
    >>> tl[2][2] = "N"
    >>> tl
    (1, 'hunan', ['h', 'u', 'N', 'a', 'n'], ('I', 'love', 'python'), {'name': 'Tom', 'age': 18})
    >>>
    

    拼接

    >>> t1 = ('a','b','c')
    >>> t2 = ('d','e','f')
    >>> t1 + t2
    ('a', 'b', 'c', 'd', 'e', 'f')
    >>>
    

    重复

    >>> t1 * 3
    ('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')
    >>>
    

    判断元素是否存在

    >>> t1 = ('a','b','c')
    >>> 'a' in t1
    True
    >>> 'a' not in t1
    False
    >>>
    

    内置函数(最大值最小值)

    >>> t1 = ('a','b','c')
    >>> max(t1)
    'c'
    >>>
    
    元组的遍历

    1)值遍历

    >>> tp = ('Python','Java','C++')
    >>> for i in tp:
    ...     print(i,end = " ")
    ...
    Python Java C++ >>>
    

    2)索引遍历

    >>> tp = ('Python','Java','C++')
    >>> for i in range(len(tp)):
    ...     print(tp[i],end = " ")
    ...
    Python Java C++ >>>
    

    3)索引-值,遍历

    枚举(enumerate),对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串),enumerate将其组成一个人索引序列,利用它可以同时获得索引和值。

    >>> tp = ('Python','Java','C++')
    >>> for index,value in enumerate(tp):
    ...     print(index,':',value)
    ...
    0 : Python
    1 : Java
    2 : C++
    >>>
    

    print(index + values)

    二维数组
    >>> tp = ((1,2,3),(4,5,6),(7,8,9))
    >>> tp[1][1]
    5
    
    三维数组
    >>> tp = (((1,2,3),(4,5,6),(7,8,9)),
    ...     ((1,2,3),(4,"Hunan",6),(7,8,9)),
    ... ((1,2,3),(4,5,6),(7,8,9)))
    >>> tp[1][1][1]
    'Hunan'
    >>>
    
    展开全文
  • tuple元组

    2019-07-25 14:56:00
    元组(tuple)是一种有序的集合,与list相似,元组是不可变的,用()创建 元组的创建 语法格式: 元组名 = (元素1, 元素2,…..元素n) • 注:元组中的元素⽤逗号隔开。 • 注:元组⾥⾯的元素可以是不同类型的...
  • Tuple元组

    2019-09-23 18:22:37
    Tuple为何物? msdn之Tuple详解 如果不想给一个不常使用对象建一个类...在.NET中Tuple被实现为泛型类型,n-Tuple表示有n个元素的Tuple,集合的元素可以是任何类型。 Example 1: // 创建一个 7-tuple. va...
  • 离散数学-二元关系

    2021-02-22 09:16:36
    序偶与有序n元组 由两个对象x、y组成的序列称为有序n元组,也称之为序偶,记作<x,y>,称x,y为其中的第一元素和第二元素。 序偶中的x,y有次序。 如果<x,y>和<u,v>两个序偶,如果x=u且y=v,则两个序偶...
  • Python-06-元组

    2021-04-26 20:37:57
    元组是不可变数据类型,它是有序的、可迭代的。 一、元组的创建 格式 (数据1, 数据2, ... , 数据n) 元组的创建 # 1. 创建一个至少两个元素的元组 t1 = (11, 22, 33) print(t1, type(t1)) # (11, 22, 33) <...
  • 列表和元组

    2019-10-22 16:04:08
    「列表」定义语法为 [元素1, 元素2, …, 元素n] 关键点是「中括号 []」和「逗号 ,」 中括号 把所有元素绑在一起 逗号 将每个元素一一分开 列表是有序集合,没有固定大小, 能够保存任意数量任意类型的 Python ...
  • Python学习笔记-元组

    2019-07-13 15:37:18
    #元组tuple 本质:是一种有序集合 #特点: #1、与列表非常相似 #2、一旦初始化就不能修改 #3、使用小括号 #创建tuple #格式:元组名 = (元组元素1,元组元素2,……,元组元素n) #定义元组只有一个元素时,元素后边...
  • 序列及元组

    2018-04-19 20:56:09
    序列是具有先后关系的一组元素序列是一维元素向量,元素类型可以不同元素有序号引导,通过下标访问序列的特定元素序号从0开始正向递增,反向从-1递减序列类型是一个基类类型包括字符串类型、元组类型、列表类型1、...
  • 列表 元组 字符串

    2020-07-28 22:06:58
    列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。 关键点是「中括号 []」和「逗号 ,」 中括号 把所有元素绑在一起 逗号 将每个元素一一分开 2、元组 「...
  • 定义:笛卡尔积中的每一个元素,叫做一个n元组或简称元组 什么是笛卡尔积? 笛卡尔积是指在数学中,两个集合X和Y的笛卡尔积,表示为 X × Y,第一个对象是X的成员 而第二个对象是Y的所有可能有序对的其中一个成员。 ...
  • 元组中存储的数据是有序的,每个元素都可以使用索引进行访问,索引规则与列表一致。 元组的大小和元组中的元素都是只读的、不可变的。 元组中可以存储不同数据类型的数据。 创建元组 【语法】 变量=(数据1,数据2...
  • python学习网站推荐 Python 3 教程 Python部落 Python中文学习大本营 莫烦Python ...格式:元组名 = (元组元素1, 元组元素2, ……, 元组元素n) 创建空的元组 tuple1 = () print(tuple1) 2.创建...
  • (元素1,元素2,...,元组n) 基本描述: 元祖是用()包裹气啦的多个元素的数据类型,每个元素之间用,“隔开”; 1.元组的创建 创建一个空元组 >>> t1=() >>> type(t1) <c...
  • 打卡第四天1. 列表的定义1.2 列表的创建1.3 向列表中添加元素1.4 删除列表中的元素1.5 获取列表...列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, ..., 元素n]。 关键
  • **格式:**元组名 = (元组元素1, 元组元素2, ……, 元组元素n) 注意: 创建带有元素的元组 元组中的元素的类型可以不同 tuple2 = (1, 2, 3, &amp;quot;good&amp;quot;, True) print(tuple2) #定义只有...
  • 列表元组字符串

    2020-07-28 20:55:27
    1.列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。 2.列表定义:a = [1,2,3] 3.列表内容可更改 (mutable),因此附加 (append, extend)、插入 (insert)...
  • 列表、元组和字符串

    2020-07-28 23:51:13
    列表是有序集合,没有固定大小,能够保存任意数量任意类型的Python对象,语法为[元素1,元素2,…,元素n] 关键点是[]和, []把所有元素绑在一起 , 将每个元素一一分开 2、列表的创建 ##1)创建一个普通列表 x=['...
  • 列表、元组、字符串

    2020-07-28 21:39:07
    一、列表 整型<class ‘int’> 浮点型<class ‘float’> 布尔型 <...#列表是有序集合,没有固定大小,能够保存任意数量任意类型的python对象,语法为[元素1,元素2,……,元素n] 中括
  • 定义列表的格式:[元素1,元素2,元素3, … ,元素n ] 列表内的元素可以是不同类型的 列表内的元素是有序可变的,可以使用下标来对元素进行切片和修改 列表(list)是一个可迭代对象 # 字符串转列表 name = list('张三'...
  • 列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。 x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] 也可以用推导式创造列表。 由于list...
  • ''''''"""# 生成随机验证码大写字母 小写字母 数字5位数的随机验证码chrrandom.choice封装成一个函数,用户想生成几位就生成几位# import random # 导入随机模块# def get_code(n): # 定义一个函数,需要参数n# code ...
  • 2、 元组 学习产出: 1.1.列表的概念 列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象, 语法为 :[元素1, 元素2, …, 元素n]。 逗号将每个元素一一分开,中括号把所有元素绑在一起 1.2.列表...
  • S4--列表、元组和字符串4 列表、元组和字符串4.1 列表4.1.1列表定义4.1.2 列表的创建4.1.3 列表对象的...列表是有序集合,没有固定的大小,能够保存任意任意数量类型的python对象,语法为【元素1,元素2,…元素n】。
  • 一、列表与元组 列表(它是一种有序的集合): 创建列表: 列表名 = [列表选项1,列表选项2,列表选项3,列表选项4.......,列表选项n] 空列表:列表名 = [] 列表中的元素数据可以是不同的类型 列表访问(注意...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 158
精华内容 63
关键字:

有序n元组