精华内容
下载资源
问答
  • 绝对干货满满。 本书参考资料书籍: 《JavaScript权威指南(第6)》 《JavaScript高级程序设计》 《你不知道的JavaScript(上、中卷)》 《Effective JavaScript:编写高质量JavaScript代码的68个有效方法》
  • 刚工作那会儿在网上看到别人的自动吃的贪吃蛇,就想着自己也写一个,结果是基本活不过屏幕。 最近刷了一些算法,突然觉得自己能行了,就写了个h5的,结果还是差一些,才能吃。 不知道有没有大佬,给点思路...

    刚工作那会儿在网上看到别人的自动吃满的贪吃蛇,就想着自己也写一个,结果是基本活不过半屏幕。

    最近刷了一些算法,突然觉得自己能行了,就写了个h5版的,结果还是差一些,才能吃满。

    不知道有没有大佬,给点思路。

    h5贪吃蛇源码(需要引入vue)

    <style>
        html, body {
            height: 90%;
        }
    
        #app {
            width: 100%;
            height: 90%;
            display: flex;
            justify-content: center;
            align-items: center;
            flex-direction: column;
        }
    
        .one {
            display: flex;
            background: rgba(0, 0, 255, 0.28);
        }
    
        .two {
            width: 40px;
            height: 40px;
            border: aliceblue solid 1px;
        }
    
        .snack {
            background: rgba(0, 128, 0, 0.22);
        }
    
        .dian {
            background: rgba(255, 255, 0, 0.21);
        }
    
        .tou {
            background: rgba(255, 0, 0, 0.3);
        }
    
        .wei {
            background: rgba(0, 92, 128, 0.22);
        }
    
    </style>
    <body>
    <div id="app">
        <input id="input" type="text" @keydown="keyPress" style="width: 0;height: 0">
        <div @click="begin">开始{{cd}}</div>
        <div v-for="(one,index) in list" class="one">
            <div v-for="(two,index2) in list[index]" class="two"
                 :class="{'snack':two == 1,'dian':index==dian[0]&&index2==dian[1],'tou':index==tou.y&&index2==tou.x,'wei':index==wei.y&&index2==wei.x}">
    
            </div>
        </div>
    </div>
    </body>
    <script src="vue.js"></script>
    <script>
        let timer = null;
        let vm = new Vue({
            el: "#app",
            data() {
                return {
                    list: [],
                    dian: [5, 5],
                    temp: 2,
                    fx: 1,
                    tou: {},
                    wei: {},
                    cd: 0,
                }
            },
            methods: {
                keyPress(v) {
                    // this.fx = v.keyCode - 36
                },
                begin() {
                    timer = setInterval(() => {
                        this.move()
                        this.auto();
                        this.list[this.wei.y][this.wei.x] = 1
                    }, 10)
                },
                move() {
                    switch (this.fx) {
                        case 1:
                            this.snack(this.tou.x - 1, this.tou.y)
                            break
                        case 2:
                            this.snack(this.tou.x, this.tou.y - 1)
                            break
                        case 3:
                            this.snack(this.tou.x + 1, this.tou.y)
                            break
                        case 4:
                            this.snack(this.tou.x, this.tou.y + 1)
                            break
                        default:
                            alert("未知方向")
                            clearInterval(timer)
    
                    }
                },
                auto() {
                    let x = this.tou.x;
                    let y = this.tou.y
                    // this.rightStain(x, y)
                    this.isOne(x, y)
                    let canList = []
                    if (y < 14 && this.list[y + 1][x] === this.temp) {
                        canList.push(4)
                    }
                    if (y > 0 && this.list[y - 1][x] === this.temp) {
                        canList.push(2)
                    }
                    if (x > 0 && this.list[y][x - 1] === this.temp) {
                        canList.push(1)
                    }
                    if (x < 14 && this.list[y][x + 1] === this.temp) {
                        canList.push(3)
                    }
                    console.log(canList)
                    let yx = [];
                    if (y < 14 && this.dian[0] > y) {
                        if (this.list[y + 1][x] === this.temp) {
                            yx.push(4)
                        }
                    }
                    if (y > 0 && this.dian[0] < y) {
                        if (this.list[y - 1][x] === this.temp) {
                            yx.push(2)
                        }
                    }
                    if (x > 0 && this.dian[1] < x) {
                        if (this.list[y][x - 1] === this.temp) {
                            yx.push(1)
                        }
                    }
                    if (x < 14 && this.dian[1] > x) {
                        if (this.list[y][x + 1] === this.temp) {
                            yx.push(3)
                        }
                    }
                    if (yx.length > 0) {
                        this.fx = yx[Math.floor(Math.random() * yx.length)]
                        return
                    }
                    this.fx = canList[Math.floor(Math.random() * canList.length)]
                },
                isOne(x, y) {
                    let ex = this.wei.x
                    let ey = this.wei.y
                    this.list[ey][ex] = 0
                    let lists = this.getCanRunList(x, y);
                    console.log("可以的移动的")
                    console.log(lists)
                    let cans = [];
                    lists.forEach(o=>{
                        let lists = this.getCanRunList(o[0], o[1])
                        if (lists.length === 0){
                            return
                        }
                        this.temp++
                        this.list[o[1]][o[0]] = 1
                        let g = 0
                        this.stain(ex, ey)
                        this.list.forEach(one=>{
                            one.forEach(two=>{
                                if (two === this.temp){
                                    g++
                                }
                            })
                        })
                        if (g+this.cd === 225){
                            cans.push(o)
                        }
                        this.list[o[1]][o[0]] = 0
                    })
                    console.log("不分割地址")
                    console.log(cans)
                    if (cans.length > 0){
                        this.temp++
                        cans.forEach(o=>{
                            this.list[o[1]][o[0]] = this.temp
                        })
                    }else {
                        // alert("必须分")
                        // clearInterval(timer)
                        this.rightStain(x,y)
                    }
    
                    // if (lists.length > 1) {
                    //     this
                    //     can.forEach(l => this.list[l[1]][l[0]] = this.temp)
                    // } else {
                    //     this.rightStain(x, y)
                    // }
                },
                getCanRunList(x, y) {
                    let lists = []
                    if (x > 0 && this.list[y][x - 1] !== 1) {
                        lists.push([x - 1,y])
                    }
                    if (x < 14 && this.list[y][x + 1] !== 1) {
                        lists.push([x+1,y])
                    }
                    if (y > 0 && this.list[y-1][x] !== 1) {
                        lists.push([x,y - 1])
                    }
                    if (y < 14 && this.list[y+1][x] !== 1) {
                        lists.push([x,y + 1])
                    }
                    return lists;
                },
                rightStain(x, y) {
                    this.temp++
                    let ex = this.wei.x
                    let ey = this.wei.y
                    this.list[ey][ex] = 0
                    if (this.stainOne(x + 1, y)) {
                        this.stain(x + 1, y)
                        if (this.list[ey][ex] === this.temp) {
                            return
                        }
                    }
    
                    this.temp++
                    if (this.stainOne(x, y - 1)) {
                        this.stain(x, y - 1)
                        if (this.list[ey][ex] === this.temp) {
                            return
                        }
                    }
    
                    this.temp++
                    if (this.stainOne(x, y + 1)) {
                        this.stain(x, y + 1)
                        if (this.list[ey][ex] === this.temp) {
                            return
                        }
                    }
    
                    this.temp++
                    if (this.stainOne(x - 1, y)) {
                        this.stain(x - 1, y)
                    }
                },
                stain(x, y) {
                    if (this.stainOne(x + 1, y)) {
                        this.stain(x + 1, y)
                    }
                    if (this.stainOne(x - 1, y)) {
                        this.stain(x - 1, y)
                    }
                    if (this.stainOne(x, y + 1)) {
                        this.stain(x, y + 1)
                    }
                    if (this.stainOne(x, y - 1)) {
                        this.stain(x, y - 1)
                    }
                },
                stainOne(x, y) {
                    if (x < 0 || x >= 15 || y < 0 || y >= 15) {
                        return false
                    }
                    if (this.list[y][x] === 1 || this.list[y][x] === this.temp) {
                        return false
                    }
                    this.list[y][x] = this.temp
                    return true
                },
                snack(x, y) {
                    // console.log(x + 'ccc' + y)
                    if (x < 0 || x >= 15 || y < 0 || y >= 15) {
                        alert("越界")
                        clearInterval(timer)
                        return
                    }
                    this.list[this.wei.y][this.wei.x] = 0
                    if (this.list[y][x] === 1) {
                        alert("结束")
                        clearInterval(timer)
                        return;
                    }
                    vm.$set(this.list[y], x, 1);
                    if (this.dian[0] === y && this.dian[1] === x) {
                        this.list[this.wei.y][this.wei.x] = 1
                        let c = 15 * 15 - ++this.cd
                        if (c === 0) {
                            alert('完成')
                            clearInterval(timer)
                            return
                        }
                        let temp = Math.floor(Math.random() * c)
                        let tempTime = 0;
                        for (let i = 0; i < this.list.length && tempTime <= temp; i++) {
                            for (let j = 0; j < this.list[i].length; j++) {
                                if (this.list[i][j] !== 1) {
                                    tempTime++;
                                    if (tempTime === temp) {
                                        this.dian[0] = i
                                        this.dian[1] = j
                                        break
                                    }
                                }
                            }
                        }
                    } else {
                        this.list[this.wei.y][this.wei.x] = 0
                        this.wei = this.wei.previous
                    }
                    vm.$set(this.list[y], x, 1);
                    let n = {
                        x: x,
                        y: y,
                        next: this.tou
                    }
                    this.tou.previous = n
                    this.tou = n
                }
            },
            created() {
                for (let i = 0; i < 15; i++) {
                    this.list.push([])
                    for (let j = 0; j < 15; j++) {
                        this.list[i].push(2)
                    }
                }
                this.list[7][7] = 1
                this.list[7][8] = 1
                this.list[7][9] = 1
                this.tou = {
                    x: 7,
                    y: 7,
                    next: null,
                    previous: null
                }
                this.tou.next = {
                    x: 8,
                    y: 7,
                    next: null,
                    previous: this.tou
                }
                this.wei = {
                    x: 9,
                    y: 7,
                    next: null,
                    previous: this.tou.next
                }
                this.tou.next.next = this.wei
                this.cd = 3
            }
    
        })
    
        function cf1(one) {
            // console.log(one)
        }
    
        function cf2(one) {
            // console.log(one)
        }
    
        function cf3(one) {
            // console.log(one)
        }
    
        function cf4() {
            // console.log(one)
        }
    </script>

     

    展开全文
  • 文章目录可逆表示正定可逆实对称表示正定实对称表示正定正定表示正定正定表示正定正定与主子式一些重要的xiao结论列秩表示正定行秩表示正定上三角表示正定 可逆表示正定 实对称A为正定⇔\Leftrightarrow...

    可逆表示正定

    实对称A为正定\Leftrightarrow存在实可逆C使得A=CCA=C'C

    可逆实对称表示正定

    实对称A为正定\Leftrightarrow存在可逆实对称C使得A=C2A=C^2

    实对称表示半正定

    实对称A为半正定\Leftrightarrow存在实对称C使得A=C2A=C^2
    注意!这里不要求C是可逆啦!

    正定表示正定

    A为正定\Leftrightarrow存在唯一正定C使得A=C2A=C^2

    半正定表示半正定

    A为半正定\Leftrightarrow存在唯一半正定C使得A=C2A=C^2

    正定与主子式

    实对称A为正定A\Leftrightarrow A的主子式都>0>0

    一些重要的xiao结论

    • A正定,B半正定\Rightarrow A+B正定
    • A正定,B正定\Rightarrow A+B正定
    • A正定\Rightarrow A1,AA^{-1},A^*都是正定

    列满秩表示正定

    实对称A正定\Leftrightarrow存在m×nm×n列满秩矩阵P,使得A=PPA=P'P

    行满秩表示半正定

    实对称A半正定\Leftrightarrow存在r×nr×n列满秩矩阵Q,使得A=QQA=Q'Q

    上三角表示正定

    实对称A正定\Leftrightarrow存在上三角B,且B的主对角元都>0,使得A=BBA=B'B

    展开全文
  • 文章目录可逆表示正定证明可逆实对称表示正定证明实对称表示正定正定表示正定证明正定表示正定正定与主子式证明一些重要的xiao结论列秩表示正定证明行秩表示正定证明上三角表示正定证明 可逆表示正定 实...

    可逆表示正定

    实对称A为正定\Leftrightarrow存在实可逆C使得A=CCA=C'C

    证明

    • 实对称A为正定
    • \Leftrightarrow AIA\simeq I
    • \Leftrightarrow C使\exist实可逆C使得 A=CICA=C'IC

    可逆实对称表示正定

    实对称A为正定\Leftrightarrow存在可逆实对称C使得A=C2A=C^2

    证明

    • 必要性:由于A是正定实对称,则存在正交矩阵TT使得A=TDTA=T'DT D=diag{λ1,...,λn}D=diag\{\lambda_1,...,\lambda_n\} =diag{λ1,...,λn}2=D12=diag\{\sqrt{\lambda_1},...,\sqrt{\lambda_n}\}^2=D_1^2
    • 于是A=TD1TTD1T=C2A=T'D_1TT'D_1T=C^2,易得C是实对称

    实对称表示半正定

    实对称A为半正定\Leftrightarrow存在实对称C使得A=C2A=C^2
    注意!这里不要求C是可逆啦!

    正定表示正定

    A为正定\Leftrightarrow存在唯一正定C使得A=C2A=C^2

    证明

    这里的证明思路是:通过TD2T=T1D2T1T'D^2T=T_1'D^2T_1来证明:TDT=T1DT1T'DT=T_1'DT_1

    • 正定:由上可逆实对称表示正定得,C的特征值都是正数,所以这个C就是正定矩阵
    • 下面证明这样的C是唯一的,骚操作来啦
      • 反证,假设还有个C1C_1满足要求
      • C1C_1的全部特征值为v1,...,vnv_1,...,v_n,则A的全部特征值为v12,...,vn2v_1^2,...,v_n^2
      • CC的全部特征值为μ1,...,μn\mu_1,...,\mu_n,则A的全部特征值为μ12,...,μn2\mu_1^2,...,\mu_n^2
      • 所以适当调换位置后可以得到μi2=vi2\mu_i^2=v_i^2又∵μi,vi>0\mu_i,v_i>0μi=vi\mu_i=v_i
      • 又因为C,C1C,C_1均为实对称矩阵,所以存在正交矩阵T,T1T,T_1满足C=T1diag{μ1,...,μn}TC=T^{-1}diag\{\mu_1,...,\mu_n\}T C1=T11diag{v1,...,vn}T1C_1=T_1^{-1}diag\{v_1,...,v_n\}T_1下面证明:C=C1C=C_1
      • 由于C2=C12C^2=C_1^2,所以有T1diag{μ12,...,μn2}T=T11diag{μ12,...,μn2}T1T^{-1}diag\{\mu_1^2,...,\mu_n^2\}T=T_1^{-1}diag\{\mu_1^2,...,\mu_n^2\}T_1 \Leftrightarrow T1T1diag{μ12,...,μn2}=diag{μ12,...,μn2}T1T1(1)T_1T^{-1}diag\{\mu_1^2,...,\mu_n^2\}=diag\{\mu_1^2,...,\mu_n^2\}T_1T^{-1}\tag{1}
      • T1T1=(tij)T_1T^{-1}=(t_{ij}),比较(1)式两边的(i,j)(i,j)元素,得tijμj2=tijμi2t_{ij}\mu_j^2=t_{ij}\mu_i^2分两种情况讨论
        • tij0t_{ij}\ne0
          • μi=μj\mu_i=\mu_j,可得,所有μi\mu_i都相等,所以就有tijμj=tijμi(2)t_{ij}\mu_j=t_{ij}\mu_i\tag{2}
        • tij=0t_{ij}=0
          • 如此的话,显然(2)式也成立
        • 所以就有T1T1diag{μ1,...,μn}=diag{μ1,...,μn}T1T1(1)T_1T^{-1}diag\{\mu_1,...,\mu_n\}=diag\{\mu_1,...,\mu_n\}T_1T^{-1}\tag{1} \Leftrightarrow C=C1C=C_1

    注意!!
    这里证明的是C1=CC_1=C,还有一种思路是证T=T1T=T_1,虽然这样的证法理由看似直观,因为对角矩阵都一样了,那正交矩阵肯定都一样了呀,但是这是不对的,这是一个大坑!!因为可以用不同的正交矩阵得到一样的对角矩阵!还记得T是怎么来的吗?特征向量标准正交化,完全可选不同的特征向量呀!

    半正定表示半正定

    A为半正定\Leftrightarrow存在唯一半正定C使得A=C2A=C^2

    正定与主子式

    实对称A为正定A\Leftrightarrow A的主子式都>0>0

    证明

    之前和主子式有关的定理是:A正定A\Leftrightarrow A的所有顺序主子式都>0
    这里相当于拓展了一下结论

    • 由之前的可逆表正定得,存在可逆矩阵C满足A=CCA=C'C
    • A(i1i2...iki1i2...ik)=CC(i1i2...iki1i2...ik)A\begin{pmatrix}i_1&i_2&...&i_k\\i_1&i_2&...&i_k\end{pmatrix}=C'C\begin{pmatrix}i_1&i_2&...&i_k\\i_1&i_2&...&i_k\end{pmatrix} =C(i1i2...ikv1v2...vk)C(v1v2...vki1i2...ik)=\sum C'\begin{pmatrix}i_1&i_2&...&i_k\\v_1&v_2&...&v_k\end{pmatrix}C\begin{pmatrix}v_1&v_2&...&v_k\\i_1&i_2&...&i_k\end{pmatrix} =C2(v1v2...vki1i2...ik)=\sum C^2\begin{pmatrix}v_1&v_2&...&v_k\\i_1&i_2&...&i_k\end{pmatrix}
    • 由于C可逆,所以C的第i1,i2,...,iki_1,i_2,...,i_k列组成的子矩阵C1C_1是列满秩矩阵,故肯定存在一个不为0的k阶子式使得C2>0\sum C^2> 0

    一些重要的xiao结论

    • A正定,B半正定\Rightarrow A+B正定
    • A正定,B正定\Rightarrow A+B正定
    • A正定\Rightarrow A1,AA^{-1},A^*都是正定

    列满秩表示正定

    实对称A正定\Leftrightarrow存在m×nm×n列满秩矩阵P,使得A=PPA=P'P

    证明

    啊这里好简单的!我还想那么复杂真的是太傻啦

    • A正定\Rightarrow\exist实可逆C,使得A=CCA=C'C
    • 只要令P=(C0)m×nP=\begin{pmatrix}C\\0\end{pmatrix}_{m×n},则有(C,0)(C0)=A(C',0)\begin{pmatrix}C\\0\end{pmatrix}=A

    行满秩表示半正定

    实对称A半正定\Leftrightarrow存在r×nr×n列满秩矩阵Q,使得A=QQA=Q'Q

    证明

    • 假设rank(A)=rrank(A)=r,AIrA\simeq I_r(典型错误写法!!应该是A(Ir000)A\simeq\begin{pmatrix}I_r&0\\0&0\end{pmatrix})所以C\exist可逆C满足C(Ir000)C=AC'\begin{pmatrix}I_r&0\\0&0\end{pmatrix}C=A
    • ∴只要让C=(Qr×nH)C=\begin{pmatrix}Q_{r×n}\\H\end{pmatrix}(Q,H)(Ir000)(Qr×nH)=QQ(Q',H')\begin{pmatrix}I_r&0\\0&0\end{pmatrix}\begin{pmatrix}Q_{r×n}\\H\end{pmatrix}=Q'QQ当然是行满秩啦!C可是可逆矩阵

    上三角表示正定

    实对称A正定\Leftrightarrow存在上三角B,且B的主对角元都>0,使得A=BBA=B'B

    证明

    展开全文
  • 把 Node 放到 Bucket 中,当 Bucket 了后会进行 Bucket 分裂操作,目前的做法是,每个 Bucket 中最多可以放 8 个 Node,分裂规则是第一个 Bucket 的 nodeIdMax = 2 ^ 160, nodeIdMin = 0,第一次分裂变为两个 Bucket,.....

    用 findnodes 找到的节点几乎都无法访问, 不知道是不是解析 node 信息的时候出了问题.

    把 Node 放到 Bucket 中,当 Bucket 满了后会进行 Bucket 分裂操作,目前的做法是,每个 Bucket 中最多可以放 8 个 Node,分裂规则是第一个 Bucket 的 nodeIdMax = 2 ^ 160, nodeIdMin = 0,第一次分裂变为两个 Bucket,第一个 Bucket 的 nodeIdMax = 2 ^ 160 / 2, nodeIdMin = 0,第二个 Bucket 的 nodeIdMax = 2 ^ 160, nodeIdMin = 2 ^ 160 / 2 + 1,简单的说就是平均分为两个区间~这样做某些情况会产生很多空的 Bucket,例如 id[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}的情况....

    求建议要怎么样才能做出一个像样的 DHT 爬虫, 还有 Bucket 的分裂方法有没有什么好的方案.

    代码中有什么可以改进的地方, 谢啦~~

    展开全文
  • 原标题:《我的世界》PC正版盗版安装MOD方法《我的世界》PC如何安装MOD?...找到“Minecraft Versions”下面的“1.7并把鼠标移上去,点“1.7.10”然后点“Show all downloads”,会出来这个 标星的是最新...
  • RT-thread v2.1.0修正

    2015-06-05 23:18:00
    RT-Thread v2.1.0是v2.0.1正式这个系列的bug修正。RT-Thread v2.1.0修正的主要内容包括: 这个版本经历的时间比较长,并且原定的一些目标也还未能完成(更全的POSIX支持,包括device fd,socket等在内的select ...
  • 大家好,消失了几天我又血复活归来了,最近这几天太忙了一直在加班工作,这不昨天又干到凌晨一点,今天早上七点就起来了,到现在还都没有休息,现在只剩血了,不对应该说现在只能爬着走了,但是一想到几天没有...
  • 桃花庵(改编

    2020-03-06 03:40:41
    桃花庵(本人改编) —程序猿 写字楼里写字间,写字间中程序员; 程序人员写程序,又将程序换酒钱; 酒醒只在屏前坐,酒醉还来屏下眠; 酒醉酒醒日复日,屏前屏下年复年; 但愿老死电脑间,不愿鞠躬老板前; 奔驰...
  • 86五笔字根表及其mp3 五笔字根表口诀86 ...51N 已不出己,左框折尸心和羽 52B 子耳了也框向上,两折也在五耳里 53V 女刀九臼山向西 54C 又巴马,经有上,勇字头,丢矢矣 55X 慈母无心弓和匕,幼无力
  • 桃花庵--程序员

    2016-04-03 16:29:00
    桃花庵  ---程序猿 写字楼里写字间,写字间中程序员; 程序人员写程序,又将程序换酒钱;...但见街漂亮妹,哪个归得程序员。 自在,神仙; 苦乐,随缘。...
  • 平安京》OPL秋季赛季后赛可谓充满遗憾,如同夏季赛一样,他们再次倒在了决赛上。而本次OPL秋季赛季后赛开始前,LF战队众成员就纷纷表示对此次季后赛充满信心。而28岁老将BigG更是立下了“输一场减一斤”的Flag,让...
  • 部分 后部分 算法设计题目 1、回文如下 2、问题描述一下:假设在循环队列中能重复利用顺序空间的每一个存储单元,则需要另一个标识tag,以tag为0或1来区分队尾指针和头指针值相同时队列的状态时“空”还是...
  • 130116-121216(前:本发布制作日期,后:Raspbian原版制作日期) 所有版本下载地址: ://pan.baidu.com/share/link?shareid=228066&uk= 功能 默认英语(美国)键盘布局,与中国键盘一致 第一次启动扩展扩展...
  • 喝牛奶中的数学问题;喝牛奶;一杯纯牛奶乐乐喝了杯觉得有些凉就兑了热水她又喝了杯; 要求 1先独立解决这道题并用图示把思考过程表示出来? ? ? 2小组进行交流 ;一杯纯牛奶乐乐喝了杯觉得有些凉
  • 本书还有配套的《算法笔记上机训练实战指南》本书的作者是同样经历过考研机试和各类算法考试的专家型学长,知晓这类考试中的痛点,以及考生在学习算法时容易产生困惑的地方,因此可以把本书看作是学长为你奉献的满满...
  • 《红楼梦》里,尤二姐的笔墨不多,却妩媚至极,又浸了曹雪芹世的哀伤,其扮演者张明明很好的塑造了这一形象。 87电视剧《红楼梦》贾宝玉扮演者欧阳奋强23日在微信号发文称,出演《红楼梦》之后,...
  • 机房重构VB.Net进行中

    热门讨论 2015-08-16 22:26:13
     这个月,终于敲出了感觉,重构也要飞起来了,要知道,之前的两个月有很多个疑问,一步一个坎,虽然心里万分捉急,但是我喜欢荆棘路的感觉  重构的这段日子里,没有写过总结博客,是遗憾,也是教训,因为我...
  • 最近段老板带着我们一干小朋友在龙芯实习,周六一天趁着员工放假的机会给我们开小灶上了一堂干货满满的私房课,其实在大一的上学期就看过Linux的教学视频学习过Linux,尤其最近在做软件适配对Linux的理解加深了...
  • js版本水杯10/7/3

    2019-12-09 11:01:35
    /*群里发的小学二年级题目,花了一个小时才写出来, [ [10,0,0], [3,7,0], [3,4,3], [6,4,0], [6,1,3], [9,1,0], [9,0,1], [2,7,1], [2,5,3], [5,5,0] ]*/ //把b数组i的水倒入j,如果i没水或者j了返回...
  • (点击上方公众号,可快速关注) 转自:驱动之家 ...87电视剧《红楼梦》中的一位美女就是程序媛。...《红楼梦》里,尤二姐的笔墨不多,却妩媚至极,又浸了曹雪芹世的哀伤,其扮演者张明明很好地塑造了这
  • 回首还赠OI三分 化金牌徘徊指节手边 以报错研磨一次兴安 哈希肆意痴缠 放手晦暗 暴力掩于岁月打表万千 时光飞转 考前打个照面 骗分搁浅 到底是无缘 从此消磨世间 OI远 为梦续尾终是荒唐言 金明地毯北岸 ...
  • 在本文中,我们考虑了两台相同机器上的在线分层调度问题,目的是最大程度地减少工期。首先要研究的问题是缓冲区版本,其中固定容量为K的缓冲区可用于最多存储K个作业。给出当前作业后,我们就可以在不可恢复的机器...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 140
精华内容 56
关键字:

半版满版