- 
                
塑料小白
                
                
                0星
             
            - 
                
一指青铜
                
                
                100星
             
            - 
                
二指白银
                
                
                200星
             
            - 
                
十指黄金
                
                
                300星
             
            - 
                
流云蓝珀
                
                
                400星
             
            - 
                
幻影钻石
                
                
                500星
             
            - 
                
键影星耀
                
                
                800星
             
            - 
                
神速大师
                
                
                1000星
             
            - 
                
键舞王者
                
                
                200CPM
             
            - 
                
星河宗师
                
                
                400CPM
             
        
     
    
  
    
    
        闯关失败!💔
        你打错了太多字,再接再厉吧!
        
            
        
     
   
        
                
            
                        
                
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        o 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                     
                
                rust ˈkɒləkʃn
                rust集合类型,存储多个元素的容器
             
                     
                
            
                        
                
                
                rust ˈɪtəreɪtər
                rust迭代器,用于遍历集合元素的模式
             
                     
                
                
                
                
                
                
                
            
                        
                
                
                ˈbiːtriː mæp
                b树映射,有序键值对集合
             
                     
                
            
                        
                
                
                ˈbiːtriː set
                b树集合,有序唯一值集合
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                     
                
                ˈɪtəreɪtər treɪt
                迭代器trait,定义迭代行为的接口
             
                     
                
            
                        
                
                
                ˈɪntuː ˈɪtəreɪtər
                转换为迭代器,实现into_iter方法
             
                     
                
            
                        
                
                
                ˈnekst ˈmeθəd
                next方法,获取迭代器的下一个元素
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                     
                
                ˈɪtəreɪtər əˈdæptər
                迭代器适配器,转换迭代器行为的工具
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                     
                
                ˈɪtəreɪtər kənˈsjuːmər
                迭代器消费者,消费迭代器元素的工具
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        o 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                kəˈlekt ˈmeθəd
                collect方法,将迭代器收集为集合
             
                     
                
            
                        
                
                
                fɔːr luːp
                for循环,使用迭代器遍历集合的标准语法
             
                     
                
            
                        
                
                
                ˈɪtər ˈmeθəd
                iter方法,创建不可变引用的迭代器
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        _ 
                    
                                        
                        m 
                    
                                        
                        u 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                ˈɪtər ˈmjuːt ˈmeθəd
                iter_mut方法,创建可变引用的迭代器
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        _ 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                ˈɪntuː ˈɪtər ˈmeθəd
                into_iter方法,创建所有权转移的迭代器
             
                     
                
            
                        
                
                
                mæp ˈmeθəd
                map方法,对迭代器元素进行转换
             
                     
                
            
                        
                
                
                ˈfɪltər ˈmeθəd
                filter方法,过滤迭代器元素
             
                     
                
            
                        
                
                                        
                        f 
                    
                                        
                        i 
                    
                                        
                        l 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        _ 
                    
                                        
                        m 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                ˈfɪltər mæp ˈmeθəd
                filter_map方法,过滤并转换元素
             
                     
                
            
                        
                
                                        
                        f 
                    
                                        
                        l 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        _ 
                    
                                        
                        m 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                ˈflæt mæp ˈmeθəd
                flat_map方法,扁平化映射元素
             
                     
                
            
                        
                
                
                foʊld ˈmeθəd
                fold方法,通过累加器归约迭代器元素
             
                     
                
            
                        
                
                
                rɪˈduːs ˈmeθəd
                reduce方法,归约迭代器元素
             
                     
                
            
                        
                
                
                kəˈlekt ˈɪntuː
                收集到集合,将迭代器结果存入集合
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        h 
                    
                                        
                        a 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                     
                
                ˈɪtəreɪtər tʃeɪn
                迭代器链,连接多个迭代器
             
                     
                
            
                        
                
                
                zɪp ˈmeθəd
                zip方法,组合多个迭代器的元素
             
                     
                
            
                        
                
                
                ˈpiːkəbl
                可查看的迭代器,查看下一个元素而不消耗
             
                     
                
            
                        
                
                
                skɪp ˈmeθəd
                skip方法,跳过迭代器中的元素
             
                     
                
            
                        
                
                
                teɪk ˈmeθəd
                take方法,获取迭代器中的前n个元素
             
                     
                
                
            
                        
                
                
                ˈklɒnd ˈmeθəd
                cloned方法,克隆迭代器元素
             
                     
                
            
                        
                
                
                ˈkɒpɪd ˈmeθəd
                copied方法,复制迭代器元素
             
                     
                
            
                        
                
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                ɪˈnjuːməreɪt ˈmeθəd
                enumerate方法,为迭代器元素添加索引
             
                     
                
            
                        
                
                
                ˈeni ˈmeθəd
                any方法,检查迭代器中是否有元素满足条件
             
                     
                
            
                        
                
                
                ɔːl ˈmeθəd
                all方法,检查迭代器中所有元素是否满足条件
             
                     
                
            
                        
                
                
                faɪnd ˈmeθəd
                find方法,查找迭代器中第一个满足条件的元素
             
                     
                
            
                        
                
                                        
                        p 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                pəˈzɪʃn ˈmeθəd
                position方法,查找满足条件的元素位置
             
                     
                
            
                        
                
                
                mæks ˈmeθəd
                max方法,获取迭代器中的最大元素
             
                     
                
            
                        
                
                
                mɪn ˈmeθəd
                min方法,获取迭代器中的最小元素
             
                     
                
            
                        
                
                
                sʌm ˈmeθəd
                sum方法,计算迭代器元素的总和
             
                     
                
            
                        
                
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                        
                        u 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                     
                
                ˈprɒdʌkt ˈmeθəd
                product方法,计算迭代器元素的乘积
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        o 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                          
                    
                                        
                        v 
                    
                                        
                        e 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                     
                
                kəˈlekt ˈɪntuː ˈvektər
                收集到向量,将迭代器结果存入vector
             
                     
                
            
                        
                
                                        
                        v 
                    
                                        
                        e 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                     
                
                ˈvektər ˌɪtəˈreɪʃn
                vector迭代,遍历vector元素
             
                     
                
            
                        
                
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        y 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                     
                
                ˈɑːrəɪ ˌɪtəˈreɪʃn
                数组迭代,遍历array元素
             
                     
                
            
                        
                
                                        
                        h 
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                        h 
                    
                                        
                        m 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                     
                
                ˈhæʃmæp ˌɪtəˈreɪʃn
                哈希映射迭代,遍历键值对
             
                     
                
            
                        
                
                                        
                        h 
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                        h 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                     
                
                ˈhæʃset ˌɪtəˈreɪʃn
                哈希集合迭代,遍历唯一值
             
                     
                
                
                
                
                
            
                        
                
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        _ 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        v 
                    
                                        
                        e 
                    
                                        
                        c 
                    
                                     
                
                ˈɪntuː ˈɪtər fɔːr vɛk
                vector的所有权转移迭代器
             
                     
                
            
                        
                
                
                ˈɪtər fɔːr ˈɑːrəɪ
                数组的不可变引用迭代器