精华内容
下载资源
问答
  • 我们知道,所谓区块链,就是一个个的区块数据,通过区块的哈希值(相当于区块的身份证号)串联起来,如此而形成一个链条般的账本数据。在这里先问大家一个问题,假设在区块增长到2号的时候,此时软件升级了,增加了...

    我们知道,所谓区块链,就是一个个的区块数据,通过区块的哈希值(相当于区块的身份证号)串联起来,如此而形成一个链条般的账本数据。

    image.png

    在这里先问大家一个问题,假设在区块增长到2号的时候,此时软件升级了,增加了之前版本中不能识别的一些数据结构,会发生什么?在传统的中心化软件体系中,似乎并没有什么问题,无论是微信、支付宝、美团等,隔三差五就升个级,能有什么问题呢。

    这是因为这些中心化的系统,数据存储都是集中的,版本管理也是集中的,如果是重大的升级,完全可以设置为若不更新 到最新版就不能进行登录操作,从而确保用户使用的总是正确的版本。然而区块链先天是去中心的使用方式,一旦有新的软件版本发布后,是不是每个人都会去升级 到新版本是很难控制的,这就可能导致如下图所示的问题。在2号区块生成的时候发布了新的版本,且新的版本增加了之前版本不能识别的数据结构,此时部分用户 升级了新版,部分用户还没有升级,这些新旧版本的软件仍然在各自不停的挖矿、验证、打包区块,一段时间过后就会变成这样:

    image.png

    这个就叫分叉,现在读者应该很容易理解了吧,实际上根据不同情况,分叉的情况可以继续细分为如下两类。

    1.新版本节点认为老版本节点发出的区块/交易合法

    此时对于新版本来说,仍然是可以保留之前的区块链数据的,因为完全兼容,但是老版本的节点是否能依然接受新版本节点发出的区块就不一定了。

    问:新版本能兼容老版本的区块,这个我能理解,但是老版本不一定是什么意思?难道说老版本还能继续识别新版本?新版本升级之后既然增加了新的数据结构,老版本肯定不能识别呀?

    答:这个确实是需要分情况的,比如老版本中有一个备用的数据字段,这个数据字段一直都是闲置的,在老版本中也没起什么作用,而新版本使用了这个备用的字段,此时由于老版本本来也没使用这个备用字段,因此对于新版本发出的区块是依然能接受的,相当于欺骗了老版本节点。

    这种情况下,区块链的生成如下图所示:

    image.png

    可以看到,此时在区块链中,无论是老节点维护的区块链数据还是新节点维护的区块链数据,都有可能既包含老版本的区块也 包含新版本的区块。不过实际上,在区块链应用程序进行重大升级时,都会事先取得社区的投票同意,保证大部分的运行节点都愿意升级到新版本,这种情况下,由 于新版本节点的算力要大于老版本的节点,所以一旦完成升级后,后续的打包区块基本都是新版本节点发出来的,也就不太会发生老版本区块和新版本区块交错链接 的情况。

    2.新版本节点认为老版本节点发出的区块/交易不合法

    这种情况下,新版本节点基本上就是另外一套区块链程序了,如下图所示:

    image.png

    老节点如果还能接受新节点发出的区块,那么在老节点维护的区块链数据中,还有可能会插入新版本的区块,但是对于新节点 来说,不再会有老版本的区块了。不但不接受新产生的老版本区块,对于之前的老版本区块也不再认可,因此这种情况下等于新版本的节点单独另外开辟了一条区块 链。

    上述解释了区块链程序由于版本升级的原因导致的几种可能的分叉情况,实际上站在老节点的角度,无非就是新版本节点产生的区块自己还能不能认识,通过能不能认识,导致两种类型的分叉:软分叉和硬分叉。

    (1)软分叉

    老节点不能发现新协议的变化,从而继续接受新节点用新协议所挖出的区块,这种情况称为软分叉,此时老节点矿工将可能在它们不能完全理解和验证的新区块上继续添加区块。

    (2)硬分叉

    当系统中出现了新版本的软件,并且和之前版本软件不能兼容,老节点无法接受新节点挖出的全部或部分区块,导致同时出现两条链,这种情况称为硬分叉。

    无论是软分叉还是硬分叉,对于区块链应用来说都是一件重大的事情,如果新版本在没有取得社区(主要是占据主要算力 的矿池用户)一致认可的情况下就强制推行升级,很有可能就会导致严重的分叉问题,分叉后会发生些什么是很难预料的,目前比特币就出现了数个不同的版本,包 括BitcoinCore,还有新推出的BitcoinClassic、BitcoinXT以及BitcoinUnlimited(无事务块大小和费用限 制)。而以太坊在经历了著名的TheDAO合约漏洞攻击事件后直接就进行了硬分叉,分为了以太坊经典(ETC)和以太坊(ETH),这其中又纠结了各种价 值观问题、利益问题等。

    那么,除了上述的版本升级会导致分叉问题,还有别的什么场景吗?假设版本都是统一的,还会有分叉产生吗?当然有, 大家要知道,区块链应用程序是没有一个固定的服务器来作为数据的一致性保证的,它靠的是网络共识算法,在异步网络环境下(我们的互联网就是属于异步网络环 境),任何一个节点都是独立工作的,它可能会被关机,可能处于网络不良好的环境,而在接受其他节点发过来的区块数据时,也有可能会收到多个临时版本,需要 裁决到底使用哪一个,等等。所有节点都只能进行“最终一致性”,最终一致性就是现在还不一致,但是过段时间大家就会依靠规则互相同步达成一致!

    在这些情况下导致的分叉属于临时性分叉。这里解释一种情况,在一个节点接收其他节点发送过来的区块数据时,假设当 前区块号是10号,下一个是11号区块。以比特币为例,要等待矿工发送11号区块出来,而此时,可能会有多个矿工都挖矿成功,也就是说会发送多个11号区 块过来,这个时候节点对于接收到的多个区块会都存储下来,等待以后的筛选,最终会淘汰掉其他只剩下其中一个纳入主链接收(网络会以最终最长的那条链为准, 这也是为什么在比特币中,会建议交易至少等待6个区块确认后才算是确定了),在没有决定哪个区块会进入到最长的那条链时,就会临时性产生分叉,如下图所 示:

    image.png

    事实上,这种情况的分叉仅仅是一种竞争过程的中间产物。

    接下来让我们来设想另外一种情况。假如某个人,比如Bob,他组了一个大型的局域网,这个局域网很大,横跨了大江 南北,同时这个局域网不与外网相通。现在在这个局域网中安装了大量的比特币节点程序,这些节点程序可以正常挖矿、验证、交易等,但数据就是不能与外网相 通。这种情况下,如果过了很长时间,某一天突然让这个局域网能够与外网相通了,能够发现到外网的其他比特币节点了,会发生什么?当这个局域网封闭足够长的 时间后再与外网相通,网内和网外的节点还能正常同步吗?实际上这种情况会对比特币的主链网络产生比较大的影响。假如把这个封锁与外网连接的局域网作为一种 攻击手段,实际上就是一种针对比特币的“分割攻击”。将一批比特币节点与主网络分割出来的攻击行为称为分割攻击,如果只是延迟一下新区块的广播,则称为 “延迟攻击”,这些情况导致的问题并不是分叉那么简单了,而是会引起其他问题,比如重复支付或者浪费大量矿工的资源。

    当然,这些问题并不只是比特币会有,只要是区块链应用,都会面临这些问题。

    来源:我是码农,转载请保留出处和链接!

    本文链接:http://www.54manong.com/?id=65

    '); (window.slotbydup = window.slotbydup || []).push({ id: "u3646208", container: s }); })();
    '); (window.slotbydup = window.slotbydup || []).push({ id: "u3646147", container: s }); })();
    展开全文
  • 儿叉平衡树的删除

    2017-04-28 16:31:00
    转载于:https://www.cnblogs.com/zhoug2020/p/6782175.html

     

     

    转载于:https://www.cnblogs.com/zhoug2020/p/6782175.html

    展开全文
  • 如果你厌倦了所有这些美丽的设计模式和最佳实践,并且想写些疯狂的东西,请继续阅读。# 对一切使用异常你知道循环对吗?差一错误(英语:Off-by-one error,缩写 OBOE,是在计数时由于边界条件判断失误导致结果多了一...

    b3ac2f8a6771f0b057ba4d0fbacc0dc3.png

    作者:武培轩

    来源:https://urlify.cn/AbeIbu

    我决定告诉你如何编写可怕的Java代码。如果你厌倦了所有这些美丽的设计模式和最佳实践,并且想写些疯狂的东西,请继续阅读。

    # 对一切使用异常

    你知道循环对吗?差一错误(英语:Off-by-one error,缩写 OBOE,是在计数时由于边界条件判断失误导致结果多了一或少了一的错误,通常指计算机编程中循环多了一次或者少了一次的程序错误,属于逻辑错误的一种)很容易犯。当你迭代一个集合时,很容易出错。让我们看看如何使用 Java 异常处理来解决该问题,而不用担心这些讨厌的差一错误!

    public static void horribleIteration(String [] words){int i = 0;try {while(true){System.out.println(words[i]);i++;}} catch (IndexOutOfBoundsException e){//iteration complete}}

    # 不用担心访问修饰符

    你说什么?Java 中的访问修饰符,这不是浪费时间嘛!你是否知道将属性/方法等设为私有只是一个建议?如果你想修改它,那就去做吧!没什么能阻止你(除了缺乏知识之外)。如果是这种情况,请看如下代码。

    public static void readPrivate() throws NoSuchFieldException, IllegalAccessException {Field f = System.class.getDeclaredField("lineSeparator");f.setAccessible(true);String separator = (String) f.get(System.class);System.out.println("Line separator is " + separator + ".");}

    我们在这里读取 lineSeparator,这并没有什么。但是修改 lineSeparator 会带来更多乐趣!在我们修改代码中的 lineSeparator 之后,看看 System.out.println 发生了什么:

    public static void readWritePrivate() throws NoSuchFieldException, IllegalAccessException {Field f = System.class.getDeclaredField("lineSeparator");f.setAccessible(true);String separator = (String) f.get(System.class);System.out.println("Line separator is " + separator + ".");f.set(System.class ,"!!!");System.out.println("Line one");System.out.println("Line two");System.out.println("Line three");}

    输出为:

    Line separator isWARNING: All illegal access operations will be denied in a future release.Line one!!!Line two!!!Line three!!!

    看起来不错!

    # 在 Java 中没有什么是真正的 final

    一些开发人员认为他们通过将 final 关键字放在变量前面来以说明不会去更改这个值。事实是——有时候你真的想要改变一个 final 字段的值,所以这是如何做的:

    public static void notSoFinal() throws NoSuchFieldException, IllegalAccessException, InterruptedException {ExampleClass example = new ExampleClass(10);System.out.println("Final value was: "+ example.finalValue);Field f = example.getClass().getDeclaredField("finalValue");Field modifiersField = Field.class.getDeclaredField("modifiers");modifiersField.setAccessible(true);modifiersField.setInt(f, f.getModifiers() & ~Modifier.FINAL);f.setInt(example, 77);System.out.println("Final value was: "+ example.finalValue);}public static class ExampleClass {final int finalValue;public ExampleClass(int finalValue){this.finalValue = finalValue;}}

    注意,在构造函数中提供最终值时,这对我很有用。如果你在类中设置了 final 值,那么它将不起作用。(可能是一些编译器级别的优化破坏了所有的乐趣)

    # 使用 Java 序列化,干就对了

    这很简单,用 Java 序列化,玩得开心,好好享受。

    好吧,我想你想要一些理由。我看到 Java 平台首席架构师 Mark Reinhold 表示,他们后悔将序列化引入到 Java。显然,Java 中大约 1/3 的安全漏洞仅来自于序列化。

    # 将对象用于一切

    你知道类吗?浪费时间!你是否想看到代码重用的巅峰之作?你去!

    public static void printThings (List things){int i = 0;try {while(true){System.out.println(things.get(i));i++;}} catch (IndexOutOfBoundsException e){//iteration complete}}List superList = new ArrayList();superList.add(7);superList.add("word");superList.add(true);superList.add(System.class);printThings(superList);

    您可以相信我们一直以来都拥有这种力量吗?另外,组合两个模式还有额外的好处!

    这只是你使用 Object 进行操作的开始。如果有疑问,请记住-使用对象。如果需要,你随时可以使用这种惊人的模式进行回退!

    public static void printThingsUppercaseStrings (List things){int i = 0;try {while(true){Object o = things.get(i);System.out.println(o);if(o.getClass() == String.class){String so = (String) o;so = so.toUpperCase();System.out.println(so);}i++;}} catch (IndexOutOfBoundsException e){//iteration complete}}

    这还是类型安全的,多么健壮的解决方案。

    # 充分拥抱便捷编程的艺术

    你知道比尔·盖茨更喜欢懒惰的开发人员吗?比尔·盖茨说过:

    "I will always choose a lazy person to do a difficult job...because, he will find an easy way to do it. --Bill Gates"

    "我总是会选择一个懒人去完成一份困难的工作...因为,他会找到捷径。" -- 比尔盖茨

    因此,有了比尔·盖茨(Bill Gates)的大力支持,我们可以完全接受我们的懒惰。你准备好了吗?那就开始吧!

    永远不要编写测试,只是不要编写错误!

    将所有都定义为 public -方便访问!

    支持全局变量–您可能需要它们!

    大型接口优于小型专用接口–可以使用的方法越多越好!

    支持继承而不是合成(使用接口中的默认方法从未如此简单)!

    始终使用装箱类型–它们也可以用作对象!

    尽可能使用最短的名字(a, b, n 最好)!

    # 不要学习任何新知识–你总是最了解

    一个程序员最重要的品质就是对自己有信心。相信自己什么都懂,没有什么可学的!

    考虑到这一点,请确保不要学习:

    新类库

    新语言

    新框架

    这样可以节省你的时间!你永远都不应学习任何新知识,因为你已经是最好的了。

    你有能力去做这件事,并不代表你应该做。

    - End-

    点下面

    给个在看呗

    c82dee2446e0f79153e3e2fffa01a8cc.gif

    展开全文
  • 【1】个人想法:前后看了2~3周吧感觉真难。不参考别人的代码,要自己想出来难度很大。但也可以试着想一想代码是用C写的。【2】重点知识:(1)二叉树并不难理解(2)n个节点的二叉树,有空域n+1个。...

    【1】个人想法:前后看了2~3周吧感觉真难。不参考别人的代码,要自己想出来难度很大。但也可以试着想一想

    代码是用C写的。


    【2】重点知识:

    (1)二叉树并不难理解

    (2)n个节点的二叉树,有空域n+1个。证明:n个节点有域2n个;那个树形图里面,一条线代表占用了一个域,只有根上面没线,所以共占用n-1个域。那剩下的域就是n+1个了。

    (3)给二叉树加上线索后,感觉就像是个循环链表一样的。但并不是,具体像什么并不能直观地想象出来,或许不需要


    【3】关于代码:代码里面比较有意思的函数是:

    create_tree(二叉树初始化。一开始觉得这个函数挺简单,后来觉得有点意思);

    thrTree_mid_inner(中序线索化。它把前驱,后继分在2个循环里面赋值,这个想法很重要);

    last_ergodic(后序线索化二叉树遍历。我想了一阵后序到底该怎么遍历,看到可以反过来遍历才觉得醍醐灌顶)


    【4】代码

    #include <stdio.h>
    #include <malloc.h>
     
    typedef char ElemType;
    typedef enum {
        OK=1,
        ERROR=0
    }Status;
    typedef enum {Link=0,Thread=1}clue;
    typedef struct Tnode{
        ElemType data;
        struct Tnode *lchild,*rchild;
        clue ltag,rtag;
    }TNode,*thrBitTree;
    thrBitTree pre;
     
    void create_tree(thrBitTree *T,char **arr){
        char c;
        sscanf(*arr,"%c",&c);
        (*arr)++;
         
        if(c=='.'){
            *T=NULL;
        }else{
            *T=(thrBitTree)malloc(sizeof(TNode));
            (*T)->data=c;
            (*T)->ltag=(*T)->rtag=Link;
            create_tree(&(*T)->lchild,arr);
            create_tree(&(*T)->rchild,arr);
        }
    }
     
    void visit(TNode* T){
        if(T){
            printf("%c ",T->data);
        }
    }
    void visit_d(TNode* T){
        if(T){
            printf("%d|%c|%d\n",T->ltag,T->data,T->rtag);
        }
    }
     
    //递归前序遍历
    void pre_ergodic_r(thrBitTree T){
        if(T){
            visit(T);
            pre_ergodic_r(T->lchild);
            pre_ergodic_r(T->rchild);
        }
    }
    //递归中序遍历
    void mid_ergodic_r(thrBitTree T){
        if(T){
            mid_ergodic_r(T->lchild);
            visit(T);
            mid_ergodic_r(T->rchild);
        }
    }
    //递归后序遍历
    void last_ergodic_r(thrBitTree T){
        if(T){
            last_ergodic_r(T->lchild);
            last_ergodic_r(T->rchild);
            visit(T);
        }
    }
     
    //-----------------------------前序线索化----
    void pre_ergodic(thrBitTree P){
        thrBitTree T=(thrBitTree)malloc(sizeof(TNode));
        T=P->lchild;
        while(T!=P){
            visit(T);
            if(T->ltag==Link){
                T=T->lchild;
            }
            else{
                T=T->rchild;
            }
        }
    }
     
    void thrTree_pre_inner(thrBitTree T){
        if(T){
            if(T->lchild==NULL){
                T->lchild=pre;
                T->ltag=Thread;
            }
            if(pre->rchild==NULL){
                pre->rchild=T;
                pre->rtag=Thread;
            }
            pre=T;
            if(T->ltag==Link)
                thrTree_pre_inner(T->lchild);
            if(T->rtag==Link)
                thrTree_pre_inner(T->rchild);
        }
    }//-----------------------------endl----
     
    //-----------------------------中序线索化----
    void mid_ergodic(thrBitTree P){
        thrBitTree T=(thrBitTree)malloc(sizeof(TNode));
        T=P->lchild;
        while(T!=P){
            while(T->ltag==Link){
                T=T->lchild;
            }
            visit(T);
            while(T->rtag==Thread && T->rchild!=P){
                T=T->rchild;
                visit(T);
            }
            T=T->rchild;
        }
    }
     
    void thrTree_mid_inner(thrBitTree T){
        if(T){
            thrTree_mid_inner(T->lchild);
            if(T->lchild==NULL){
                T->lchild=pre;
                T->ltag=Thread;
            }
            if(pre->rchild==NULL){
                pre->rchild=T;
                pre->rtag=Thread;
            }
            pre=T;
            thrTree_mid_inner(T->rchild);
        }
    }//-----------------------------endl----
     
    //-----------------------------后序线索化----
    typedef struct SNode{
        ElemType data;
        struct SNode* next;
    }SNode,*StackList;
    
    
    //带头节点的栈初始化
    void initStack(StackList *S){
        *S=(StackList)malloc(sizeof(SNode));
        (*S)->next=NULL;
    }
    
    
    void Push(StackList S,ElemType e){
        if(S==NULL) return;
    
    
        SNode* newNode=(SNode*)malloc(sizeof(SNode));
        newNode->data=e;
        newNode->next=S->next;
        S->next=newNode;
    }
    
    
    void printStack(StackList S){
        if(S==NULL) return;
        SNode* p=S->next;
        while(p){
            printf("%c ", p->data);
            p=p->next;
        }
        printf("\n");
    }
    
    
    //可以按 根-右-左 再倒过来
    //倒过来这个,用栈实现吧
    void last_ergodic(thrBitTree P){
        thrBitTree T=P->rchild;
        StackList S=NULL;
        initStack(&S);
        while(T!=P){
            //visit(T);
            Push(S,T->data);
            if(T->rtag==Link){
                T=T->rchild;
            }
            else{
                T=T->lchild;
            }
        }
        printStack(S);
    }
     
    void thrTree_last_inner(thrBitTree T){
        if(T){
            if(T->ltag==Link)
                thrTree_last_inner(T->lchild);
            if(T->rtag==Link)
                thrTree_last_inner(T->rchild);
            if(T->lchild==NULL){
                T->lchild=pre;
                T->ltag=Thread;
            }
            if(pre->rchild==NULL){
                pre->rchild=T;
                pre->rtag=Thread;
            }
            pre=T;
        }
    }
    //-----------------------------endl----
     
    //给树加头节点
    void thrTree(thrBitTree *P,thrBitTree T,void (*thrTree_inner)()){
        *P=(thrBitTree)malloc(sizeof(TNode));
        (*P)->rchild=*P;
        (*P)->rtag=Thread;
        (*P)->ltag=Thread;
        if(T==NULL){
            (*P)->lchild=*P;
        }
        else{
            (*P)->lchild=T;
            pre=*P;
            thrTree_inner(T);
             
            //防止后续线索化中根节点的右孩子被污染
            if(pre!=(*P)->lchild){
                pre->rtag=Thread;
                pre->rchild=*P;
            }
            (*P)->rchild=pre;
        }
    }
     
    void main(){
        thrBitTree P,T;
     
        //char *arr="ab.c..de...";
        char *arr="HDA..C.B..GF.E....";
        create_tree(&T,&arr);
         
        //递归 遍历
        printf("recrution:\n");
     
        printf("pre_r:");
        pre_ergodic_r(T);
        printf("\n");
        printf("mid_r:");
        mid_ergodic_r(T);
        printf("\n");
        printf("last_r:");
        last_ergodic_r(T);
        printf("\n\n");
     
        //无递归 遍历
        printf("no-recrution:\n");
     
        thrTree(&P,T,thrTree_pre_inner);
        printf("pre:");
        pre_ergodic(P);
        printf("\n");
     
        free(P);free(T);
        arr="HDA..C.B..GF.E....";
        create_tree(&T,&arr);
        thrTree(&P,T,thrTree_mid_inner);
        printf("mid:");
        mid_ergodic(P);
        printf("\n");
     
        free(P);free(T);
        arr="HDA..C.B..GF.E....";
        create_tree(&T,&arr);
        thrTree(&P,T,thrTree_last_inner);
        printf("last_reverse:");
        last_ergodic(P);
     
        printf("\n");
    }
    


    【5】结果

    C:\Users\xxx>gcc D:/testP/cc.c -o D:/testP/cc.o


    C:\Users\xxx>D:/testP/cc.o
    recrution:
    pre_r:H D A C B G F E
    mid_r:A D C B H F E G
    last_r:A B C D E F G H


    no-recrution:
    pre:H D A C B G F E
    mid:A D C B H F E G
    last_reverse:A B C D E F G H

    展开全文
  • 本期内容导读本期课程,来自中国骨科菁英会小儿骨科专业会员、中国医科大学附属盛京医院的王恩波医生,为大家分享儿童高位肱骨髁上骨折(MDJ骨折)的内固定选择。本期嘉宾 王恩波中国骨科菁英会小儿骨科专业会员中国...
  • 新建的maven项目有一个红色的叉叉,看着总是觉得不舒服,虽然项目跑起来没有问题,依赖也都下好了,在buildpath下也没发现问题,但是就是找不到解决办法,弄了一会,发现有人也有同样问题,记录一下解决方法。...
  • 由于每两个无理数之间都夹有有理数,因此任意两个圆都没挨在一块。  给你一张纸,要求你在上面画尽可能多的,使得所有的都不相交。你最多能画多少个?  你可以画无穷多个不相交的。画法有很多...
  • 比特币分叉2周年

    2019-08-15 11:32:31
    两天后,比特币分叉,加密货币领域迎来了一位新生:BCH。 两年后的今天,BCH价格涨至4000美金又跌回300美金,主导分叉的比特大陆,在为上市奔波,矿霸吴忌寒有了新业务,BCH又新分叉出了BSV,比特币内部各派...
  • 比如,凭借孕妇的信息预测低出生体重的结局。怎么建立预测模型呢?常见的做法是这样的:以低出生体重为因变量,以相关的孕妇信息作为自变量,建立logistic回归模型。有了模型,一般还需要验证模型的可靠性稳定性...
  • 眼睛作为易于获取影像数据的体表器官,其健康状况对于人的生活、学习所造成的影响不容忽视。借由人工智能提前预测、辅助诊断眼科疾病,为守护“心灵的窗户”带来更多希望。 12月12日,中山大学中山眼科中心副主任...
  • 交叉链接的基础照常情谊链接,然则寻常的友情链接是两个站之间换取...切实关于这些基本的概念各人也均可以恣意的去网上查找的到,但在这内里有缔造了一些题目,有很多多少人还会把交叉链接与链轮搞混在一块。在...
  • 今天我们来介绍flex里非常重要的一个新概念——轴。...等会我们来看一下主轴和交叉轴有什么意义和作用,现在我们先来实现一种效果。 先改一下我们的”justify-content“: .container{ displa...
  • ~事实上这是在差点相同一年前实现的东西,但当时没作好记录。放了那么久了,假设不做点总结的话,好像有点对不起自己,于是·········还是做点什么吧。 我脑洞比較小,仅仅能大量參考“潘李亮”大神的四...
  • 幼儿户外活动项目有哪些_幼儿户外活动方案大全 必须承认,常组织有教育目的的户外活动能让孩子们在愉快的前提下还可以接受良好的教育,以下是小编精心收集整理的幼儿户外活动方案,下面小编就和大家分享,来欣赏一下...
  • 现在大家都在加紧赶论文,码字,现在可能还没有遇到编号问题,例如参考...实际上,word是很聪明的,解决这个问题很easy,就是用“交叉引用”这玩意,使用交叉引用的好处就是将正文中的编号与实际的图、表、项目编号等
  • 我一会把各业务部门的需求列表发给你,你给粘在一个Sheet里就行。”Gavin:“好嘞!老大啥时候要?”Boss:“下午周会上,我要跟那帮业务拍优先级。14:00 PM吧。”Gavin: “收到。”10:05 AM打开新公司给...
  • ldc2一定要在github下载.我觉得唯一下载地址就是这样的麻烦. 两个工具fdw,thunder轮流下,都下不了.折腾死人. 每次都下载不了全部,都是一会就断(99%)是最恶心的. 华为录音放在.sounds目录下 ...
  • 题意:在Japan的东西两边都有海岸线。两边分别有n,m个城市,他们的编号分别都为1....n, 1....m。要在东西海岸的城市间建立一些...则问题变成求一对的x和y完全大于另一对的对数。这与苹果那题便如出一辙。将(n,m
  •  我们在访问一些销售网站时,常常会碰上这种情况:浏览某商品信息的同时,网页上会打出促销广告,购买此商品加另一商品可以享受折扣,就像下面图片中的那样。  实现这种功能关键步骤是找到商品间的关联规则...
  • 许多早产患有由早产并发症引起的神经疾病。 儿童神经系统疾病的检测是一项重要的挑战。 脑电图是建立长期神经系统预后的重要技术。 在此范围内,本研究的目的是提出一种自动检测异常早产婴儿的脑电图(EEG)的方法...
  • 前言 要不是想起来这篇文章想写一个关于游戏服务器开发过程中关于AOI相关的文章,我都差不点忘了我是一个...AOI(Area Of Interest)翻译过来就是“感兴趣的区域”,这个玩意在很多的游戏中都会出现,比如在MMORPG
  • 要想知道一个人有没有喝过酒有很多种方法:闻一闻有没有酒味,或是让他走个直线···交警们最常用的是测酒仪,不过这破玩意老是摆乌龙–就吃了两块豆腐乳或是蛋黄派也能测出酒精超标!为了避免此类乌龙事件再次...
  • 儿童机器人课程管理

    2021-03-15 13:20:16
    人工智能是跨学科的综合领域,建模与仿真、数据挖掘、计算机视觉、自然语言处理、语音智能、人工智能与生物学、自动驾驶、大健康与人工智能、计算社会科学等多门前沿交叉课程,格物斯坦认为:重在培养学生的创新思维...
  • Quick版本是一个不错的解决方案,现在虽然从被触控收购到摒弃,到社区版本,并不是这个玩意不行,而是时代在发展。它就大量给我们提供了大量的集成和封装,我们可以更关注于逻辑层的开发。对于很多小开发团队来讲...
  • 街头儿童是未成年的男孩或女孩,街头的一般儿童(被遗弃的房屋,空地等)已成为他们的惯常住所和财物。 在刚果民主共和国,其中许多儿童估计在整个国家为70,000,仅在金沙萨为20,000,这个数字每年都在增长。...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 286
精华内容 114
关键字:

叉儿