人力资源机吧 关注:632贴子:2,283
  • 16回复贴,共1

【新手向的三元法设计】面向过不了关的小伙伴们。

只看楼主收藏回复

一楼喂了吧】


IP属地:江苏1楼2017-03-13 22:29回复
    前言:
    1 首先本教程完全没有追求双成就的意向(有成就也是凑巧),是面向清晰的解题思路而设计的教程。
    并以浅显易懂为目标去排列代码以实现目标。
    如果是追求优化和双成就的朋友,这个吧里你也许会找到较好的其他帖子。
    2 因为面向的特殊性,有些地方将会出现一些诡异的安排(例如原地jump跨越一个标签),
    这将会增加无谓的步骤,但这和即将介绍的三元法有着很大的关系。
    3 如果有更加清晰易懂的方案,请不要客气随意在楼下发。
    4 我会放出几乎不带长标签的代码以便于你们复制和方便复制去研究,
    能通过这种形式教会不理解的人那是最好的了。
    (从 -- HUMAN RESOURCE MACHINE PROGRAM -- 到 ===线前一行,复制下来就可以黏贴进游戏使用了)
    5 同时在这里巨大感谢不愿透露姓名和来历的我的友人 @太猫鯼
    在这个教程里扮演了巨大的苦力和分担了五五开的工作量。(包括修正我混乱的表达语句)
    最后:感谢观众大老爷花时间来嚼我这个教程(笑。
    其他唠嗑:啊……强迫症大法好,工整规范大法好】】】那么我们开始吧、
    ================================================
    :第一关:那么首先,我们就第一次的,进入到游戏的界面里面了,
    你可以看到这个界面里,有着右边的一个框,这个框里可以放入指令,而这个框将会陪伴你一段时间。
    在框的左侧有着一个深色的框,那里面有着两个绿色的贴纸,显然这个贴纸是可以摘下来的,
    而工人就会照着编写的指令来行动。这可真是……

    -- HUMAN RESOURCE MACHINE PROGRAM --
    INBOX
    OUTBOX
    INBOX
    OUTBOX
    INBOX
    OUTBOX
    ================================================
    :第二关:是的,事情远远没有结束,现在又多了一个jump指令,这是一条非常好用又丧病的指令,
    有了它,你不用再放入三遍,之前的那个in out 了,你只需要把jump放在一组 in out的结尾,
    然后再把另一头放到开头,这样,当按照顺序执行到jump的时候,它就会带你回到解放前……

    -- HUMAN RESOURCE MACHINE PROGRAM --
    a:
    INBOX
    OUTBOX
    JUMP a
    ================================================
    :第三关:啊看那,那是什么 那是设备管理部的员工铺的地毯,我要是有办法把他们捡起来……
    ……是的,你可能已经注意到一个红通通的指令,那是一个copyfrom。
    他的作用也就是把地上的东西捡起来了,当然还附带一个数字,捡起哪一格里的东西。

    -- HUMAN RESOURCE MACHINE PROGRAM --
    COPYFROM 4
    OUTBOX
    COPYFROM 0
    OUTBOX
    COPYFROM 3
    OUTBOX
    ================================================
    :第四关:如果你觉得这关很难的话!
    那没有什么关系,我有很大的把握能教会你、 这关的目的是,交换每两个输入的顺序并输出。
    比如: A,B→B,A, 那首先,你可能会想以现在的能力,并不能做到这么高大上的事情,
    但你看左边,可以用的指令又多了一个,那个短一点的红指令,作用是把手里的复制到地上去。
    那事情就很好解决了,只要把第一格数字拿起来,放到随便一个格子里,
    然后在这时候直接的输出第二个数B,然后回过头来,输出还在格子里的A,事情就解决了,
    最后在结束的时候用jump,跳回到一开始的地方,就会循环了。
    (你不用担心输入框里没东西的时候指令还会不会再继续运作,不会的。)
    ps:为什么我会放在格子1,仅仅只是个习惯,不必深究。

    -- HUMAN RESOURCE MACHINE PROGRAM --
    a:
    INBOX
    COPYTO 1
    INBOX
    OUTBOX
    COPYFROM 1
    OUTBOX
    JUMP a
    ================================================
    :喝过咖啡后的,第六关:
    天下雨了,汇编的魔爪也靠近了你一分,这时候指令框里浮现一个橙灿灿的东西……
    啊那是什么……,那是一个加法指令。
    加法指令很好用,你使用的时候,会用手上的数,加上地面的数字,最后拿在手里。
    地面的数字不会受到任何影响,倒反而是你加之前手上的数字不复存在了。
    首先就是拿起第一个数字,他注定要放在地上,那就放吧,接着拿起第二个数字,
    使用了加法指令,这样你手上就有一个加法的结果了,也是输出所需要的。
    最后用jump循环这个过程。
    (也许你会问,啊那地上的那个数字A怎么办呢,不用担心,后来的数字会覆盖他原本的数字)

    -- HUMAN RESOURCE MACHINE PROGRAM --
    a:
    INBOX
    COPYTO 1
    INBOX
    ADD 1
    OUTBOX
    JUMP a
    ================================================
    :第七关:自古七关…… 好像没有这样的梗。。。
    但你如果下翻的快的话,一定发现了有点异样的配图,也许你会想(是不是编者出了什么bug)
    对啊,为什么那里多了两个jump,而且还是毫无作用的,那么是的,在这一关,
    你就要接触到三元法结构了。
    那么三元法到底是什么,首先需要从他的名字开始说起,三元法 他是一种设计的方法。
    这种方法里,包含着三种元素,所以叫三元法。
    这三种元素分别是:
    执行器,判断器,结束器。
    他们分别有各自的作用,各自的书写格式,以及组合方式。
    三元法的特点就是,他绝对不会给你带来什么双成就的过关,但是他最大限度的实现了可读性和结构工整。
    那么你也许要说那原地jump就是工整吗……
    很遗憾是的,不光是这一关,以后的很多关都会有原地jump的步骤,那些步骤有些还跨越了一个标签。
    为什么会这么做呢?那是因为这个两个jump不是独立的个体,而是元素的部件之一。
    第一个jump,和jump上方的jumpZ,组成的是一个判断器
    而第二个jump,则是执行器用于跳出自身步骤,而使用的jump,至于跳到哪里了,结束器里。
    这个第七关,就是一个最简单的三元法里会出现的结构。 DO IF DO END 执行,判断,执行,结束。
    首先说说判断器,顾名思义,用于判断手中的数字,他会有三种类型的jump组成,这关才只解锁两个。
    范围:02-03
    接着是执行器,用来执行指令。范围:01 还有 04
    最后是结束器,用来跳回起始,有些不需要跳回起始。范围:06
    接着我们来讲讲这关的通关过程,以加深三元法使用的熟练。
    1 首先,第一步我们就进入了执行器,拿起了数字。
    2 接着,就进入了判断器。到达判断器后,判断器是否手中的数为0(指令作用详见游戏)
    如果是0,判断器出口就指向了结束器,如果不是0,就指向了下一个执行器。
    3 非0进入了另一个执行器,执行了输出,然后就跳入了结束器。
    4 最后 被两个箭头指向的结束器跳回了起始。开始判断下一个数。
    ps:jumpZ(是jump if zero的缩写)

    -- HUMAN RESOURCE MACHINE PROGRAM --
    a:
    INBOX
    JUMPZ d
    JUMP b
    b:
    OUTBOX
    JUMP c
    c:
    d:
    JUMP a
    ================================================

    :在第七关结束了以后,我唐突在这个位置补充巩固一下三元法书写的规则。
    好的,首先是感叹你看到这里已经挺了不起,突然在第七关加入很多新的概念,也许是难以接受的。
    同时也非常的酸涩。不过你不用担心,第七关详细解读了最一般的结构,
    在这一层我将会稍微的补充一下三元法的内容,你就可以对这套理论系统有更完整和清楚的认识。
    首先就是,三元法是一种书写和设计的模式,同样也是拥有它的特定格式,那这个格式究竟是怎么样子的。
    你已经知道了,三种元素分别是差别非常大的三种。他们之间有着互不重复的作用。
    首先是执行器的说明:
    一个正确的执行器,是从他执行的第一个指令一路执行到执行器里最后一个指令的。
    执行器甚至可以仅仅包括着一个指令(但那种情况也意味着执行完这个也就结束了)
    但一般的执行器会拥有两个或者以上的指令,为什么一般是两个呢,因为第二个指令是一个jump,
    执行器的结尾总会跟着一个jump的头部,因为这可以使他跳出jump区域,但是有些情况可以忽略,
    比如两个执行区域上下连接在一起,而且也是顺序执行,同时他们当中没有插入什么jump尾部的指令。
    既然是规范,那一定会有,一定的表达,
    执行器的jump头部,一定位于执行器的底部。一定只有一个。一定是指向下方的。
    也许会有多个jump尾部跳入执行器,但他们一定都在执行器最顶上。
    接着是判断器的说明:
    一个判断器里,会有两种或者三种类型的jump,这个之后会接触到,现在已经接触到了jumpZ了。
    他的作用就是,做出判断并指向不同的地方,也许是执行器,也许是结束器,
    也有可能是另一个判断器(但是这个情况非常的少,几乎没有,因为没有理由连续对同一个数判断两次)
    判断器里,一定只有两到三种jump存在,一定都是朝下指向。
    也许会有多个jump尾部,但同样一定在判断器顶端。
    最后是结束器的说明:
    结束器的作用非常的特殊,他是一个微妙的元素,他内部仅仅包含一个jump的头部,
    而更加离奇的是,这个jump,也是唯一一个可以是逆向箭头的jump,这种规则也是三元法的基础。
    结束器的作用也就是回跳到任何地方了,执行器也不能直接进入,而需要jump的书写来跳入结束器。
    他的意义非同小可。和另外两个元素意义,他可以被数个jump尾部跳入,但是这些尾部都在jump的上方。
    结束器,一定只包含一个逆向的普遍jump。
    总结:除了一些简写习惯(讲会在引入标签那关提到)其他任何破坏了上述结构的写法,都不属于三元法了。
    经过一番考虑,我最终还是没有引用结束器的简写规则,如我所说,结束器太意义非凡了。
    好的看到这里,你可能还没有掌握的太清楚,那么请回去再看一遍吧。(或者放空大脑让自己缓缓)
    这里的一段,和上面的那一段就是三元法的几乎全部内容了,
    如果你掌握了,那么恭喜你之后的内容就十分的轻松了。
    ================================================


    IP属地:江苏2楼2017-03-13 22:32
    收起回复
      :第八关:哇,扩大三倍,这看起来非常的厉害,
      但是并不复杂,同样你也才从三元法教学的房间里开门出来呢,迎面就撞上了三元法的简写格式之一……
      首先我们来分析自己要干嘛,想都不用想,把数字放在地上,加上自己,然后再一次加上自己,
      最后结果输出就ok了。那么最后说好的结束器需要jump跳入的呢。
      这便是简写格式之一了,这个指令他仅仅只有一个执行和一个结束啊!
      在这种极简结构的时候,是的,跳入用的jump是可以忽略的。

      -- HUMAN RESOURCE MACHINE PROGRAM --
      a:
      INBOX
      COPYTO 1
      ADD 1
      ADD 1
      OUTBOX
      JUMP a
      ================================================
      :第九关:啊哈,好景不长,你真的觉得每一关都能遇到1执行2结束的简单结构吗?
      这一关只要输出0就可以了,该怎么输出0我想初学者的你一定也许会有一定的懵逼情绪。
      但是不要紧,你现在已经手握三元法了。
      同样首先分析思路,如果手里是0就输出,不是就结束本次流程。
      这么一想是不是容易多了啊。
      1 执行 拿起数字
      2 判断 是0就跳入执行器,不是就跳入结束器
      3 执行器输出了以后,也跳入结束器
      4 给您拜个早年了!(雾)

      -- HUMAN RESOURCE MACHINE PROGRAM --
      a:
      INBOX
      JUMPZ b
      JUMP d
      b:
      OUTBOX
      JUMP c
      c:
      d:
      JUMP a
      ================================================
      :第十关:啊……极简结构,仿佛天眷顾,于是这关的跳入结束器的jump又可以省掉了。
      总之这关的意思是要乘以8,但是我们加8次虽然可以达到效果,但是很蠢。
      就假设我们拿到了一个1 放在地上
      加起来自己得到 2 放回地上,
      再加就得到了4 。再次就是8。 是的,8是2的三次方。只要反复的加自己然后结果加结果,
      结果的结果加结果的结果,于是就得到八倍了。

      -- HUMAN RESOURCE MACHINE PROGRAM --
      a:
      INBOX
      COPYTO 1
      ADD 1
      COPYTO 1
      ADD 1
      COPYTO 1
      ADD 1
      OUTBOX
      JUMP a
      ================================================
      :十一关:好吧……又极简结构,这关微妙的多了一个指令sub,那是一个减法,
      用法和加法完全一样。
      这关需要输出两个数,分别是互相减出来的结果。
      那么思路就是:
      首先拿起数A保存,
      拿起数B保存并减A,得到结果一输出,
      最后拿起保存的结果A减去结果B输出。
      最后循环过程。

      -- HUMAN RESOURCE MACHINE PROGRAM --
      a:
      INBOX
      COPYTO 1
      INBOX
      COPYTO 2
      SUB 1
      OUTBOX
      COPYFROM 1
      SUB 2
      OUTBOX
      JUMP a
      ================================================
      :十二关:好的好的好的……得寸进尺,这次居然就让我们乘以40倍。
      首先你需要排除的思路是 你知道的,,add39遍。这种方法在上次乘法就摒弃掉了。
      然后正好这个时候,太猫在研究快速次方运算,正好其中的思路和乘法也就非常的相似,
      于是最后我也采用了这种方法。
      如下是当时所考虑的三种做法的列出:
      一:40=4*2*5 也就是把40拆成了add步骤不多的4.2.5三个部分分别相乘。
      二:40==2^3*5 根据第一种发现2的反复自加三次,再次乘以5也可以实现40倍。
      三:40=32+8=2^5+2^3 最终极方案,把40倍拆成32和8倍,也就是分别自加结果三次和五次,
      但由于自加了五次,经过自加三次的情况,也就是最终只要执行五次add,
      和一次前后两个值相加,就最终达成了40倍。
      虽然这个算法听起来很复杂,但在实现的时候却依旧是极简结构。所以就没需要跳入end器的。
      而且最终这个解法,达成了双成就。(非本意)

      -- HUMAN RESOURCE MACHINE PROGRAM --
      a:
      INBOX
      COPYTO 1
      ADD 1
      COPYTO 1
      ADD 1
      COPYTO 1
      ADD 1
      COPYTO 1
      ADD 1
      COPYTO 2
      ADD 2
      ADD 1
      OUTBOX
      JUMP a
      ================================================
      【【标签的使用】】
      【首先我定义了五种标签类型,分别为,横线标签,空标签,纵线标签,三点标签,点标签】
      【之所以标签都是很简单的元素,是为了节约标签带来的不必要篇幅。
      【横线标签:当上下两个元素并不先后执行,比如 结束器跳回上面,而下面的执行器则由别的jump跳入执行。
      这种情况下,两个元素之间用横线分隔开。
      【空标签:空标签是一个弱化的横线标签,当两个执行器连在一起执行,作用又大相径庭,可以考虑使用。
      【纵线标签:上方一定是执行器,下方一定是判断器,而且两者中间没有别的什么跳入。
      【三点标签:出现在判断器的尾部,意味着判断器的指向从这里发散出去了。
      【点标签:点标签以下就是结束器,跳入说明跳入了结束器。
      那么在了解标签使用之后,就可以先提及哪些情况是可以简写三元法了。
      1 首先就是你经常遇到的极简结构,只有一个结束器和执行器,这时候不需要多此一举的加jump跳入。
      2 其次就是接下来你会经常遇到的,上面是执行器,下面是判断器的结构(执行+判断)
      一旦这两者中间是没有jump尾部跳入的,那这两个元素就是连在一起的,这时候就只用标签分隔。
      {可参考第13关代码 04-05,而19关 03-04 则是因为插入箭头没忽略的情况,}

      :第十三关:判断两个数是否相等吗。这并不很难,
      首先就是拿起数字A保存,
      接着拿起数字B,减去数字A,如果相等,就能减出0的接过来。
      如果是0,就拿起地上的数字A输出,并结束
      如果不是0,则直接结束。
      最后由结束器跳回到起始位置。

      -- HUMAN RESOURCE MACHINE PROGRAM --
      a:
      INBOX
      COPYTO 1
      INBOX
      SUB 1
      COMMENT 0
      JUMPZ b
      JUMP d
      COMMENT 1
      b:
      COPYFROM 1
      OUTBOX
      JUMP c
      COMMENT 2
      c:
      d:
      JUMP a
      DEFINE COMMENT 0
      eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
      DEFINE COMMENT 1
      eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
      DEFINE COMMENT 2
      eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
      ================================================
      :第亲爱的十四关:在写这关的时候记事本闪退了,产生了惨绝人寰的,严重的……并没有什么后果()
      那么这关我们将在两个一组的数里输出比较大的那个。
      显然意见,只有之前的指令完全的满足不了这个要求,所以,指令又+1了。
      一个jumpN,他显然是用来判断你手里的是不是负数,当然字母不会有反映,而且他是判断器第三个成员。
      所以首先把AB存一份,接着A-B然后判断
      正数和0就拿起A(别问为什么)负数就B。输出
      最后循环。
      这里你可以发现,你的编写的三元法指令作用,是很好用口头描述出来的,反之,
      口头能描述的,这里也能清晰的实现它。

      -- HUMAN RESOURCE MACHINE PROGRAM --
      a:
      INBOX
      COPYTO 1
      INBOX
      COPYTO 2
      SUB 1
      COMMENT 0
      JUMPN c
      JUMPZ b
      JUMP d
      COMMENT 1
      b:
      c:
      COPYFROM 1
      OUTBOX
      JUMP f
      COMMENT 2
      d:
      COPYFROM 2
      OUTBOX
      JUMP e
      COMMENT 3
      e:
      f:
      JUMP a
      DEFINE COMMENT 0
      eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
      DEFINE COMMENT 1
      eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
      DEFINE COMMENT 2
      eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
      DEFINE COMMENT 3
      eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;


      IP属地:江苏3楼2017-03-13 22:35
      回复
        :第十六关:把所有的有负号的数去掉,然后再输出。
        乍一看有难度,这是什么样子的黑科技才能去掉负号,但其实很简单啦,
        因为0减去任何数,都会得到这个数的正数,所以这并不难。
        只要首先拿起一个数判断,正数就去执行输出,如果负数,就放在地上。
        那么0怎么得呢……减自己就是0了,拿着手里的0,去减地上的数,得到的结果就是正数,随后跳入输出。
        最后循环。

        -- HUMAN RESOURCE MACHINE PROGRAM --
        a:
        INBOX
        COMMENT 0
        JUMPN b
        JUMPZ d
        JUMP c
        COMMENT 1
        b:
        COPYTO 1
        SUB 1
        SUB 1
        OUTBOX
        JUMP f
        COMMENT 2
        c:
        d:
        OUTBOX
        JUMP e
        COMMENT 3
        e:
        f:
        JUMP a
        DEFINE COMMENT 0
        eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
        DEFINE COMMENT 1
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 2
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 3
        eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
        ================================================
        :第十七观:这任何两个数的符号相同的时候,输出数字0,反之1。
        光是想想就不知道这关容易还是难,或者难吧,但是没关系,依旧化为简单的问题去思考。
        这关我有想到两个方法去解决,这两个方法,效果当然都能过关,但是做法上区别很大。
        首先方法1,区域判断法:
        根据他的名字,是利用区域来实现判断的。而这个区域不是地板上的区域,而是代码的区域。
        首先,拿起数字A,接着就判断了,当时正数的时候进入了代码区域【04-06】在这个位置说明这个结果是正数。
        同理,负数进入区域【07-09】,
        接着我们从区域【04-06】的出发,同样是个判断器在区域下端。如果是正数,跳入【10-12】,以0输出。
        负数,【13-15】以1输出。这两者最后统一跳入了end,并回跳了。
        然后我们从【07-09】出发,这个时候第一数字已经是负数了,所以,正数。跳入输出1的,反之输出0的。
        利用区域,这关就可以过了,而且这是官方的成就方案的思路。用自己的所在位置,去储存之前的结论。
        =========
        方法2:异或法,你也许认为这种方法不对胃口,给我一件件事好好的去做啦,什么jump用区域跳来跳去的。
        那么异或法由此诞生。关于异或是什么,可以百度 异或门 当然理解不了也无所谓,不是什么很重要的东西,
        如果你对这异或法没啥兴趣的话。
        0 0=0
        0 1=1
        1 0=1
        1 1=0
        这是一份异或门的真值表,可以看出,前面两个数,有一个是1的时候,结果也是1,而两个都是1的时候反而是0。
        是很眼熟吧,假如负数看做1,正数看过0,那似乎这就是一个异或门。
        那么问题来了,怎么在游戏里制造一个可以给我们结果用的异或门,这里依旧有两种方法,但是异曲同工。
        那么首先要解决的是,这个异或门怎么在游戏里存在,那么这关问题是这么解决的,把异或方法写在代码里,
        但把数据的结果,放在地砖里。
        首先做法A,在第一次判断的时候,如果是负数,则放数字1在格子1里,如果正数,就放0,
        接着第二次判断,如果负数,就拿1去减之前格子里的数,如果正数,则拿0去减。
        这样你想想会有什么结果,如果两次负数,会有1-1=0,如果都正数则0-0=0,
        如果前后有那么一次的负数,那结果将会是1或-1,但是别担心,只要判断结果是0非0,就得出了异或的结论。
        做法B,先在格子1里放数字1,如果第一次是负数,则格子1,减去1,如果正数则什么都不做,
        第二次重复同样的步骤。最后会有什么结果呢,减1次会得到0,不止一次或一次没有得到非0,加以判断就可输出。
        我个人是非常喜欢这样的一个结构的。

        ===区域判断法:
        -- HUMAN RESOURCE MACHINE PROGRAM --
        a:
        INBOX
        COMMENT 0
        JUMPN c
        JUMP b
        COMMENT 1
        b:
        INBOX
        COMMENT 2
        JUMPN g
        JUMP d
        COMMENT 3
        c:
        INBOX
        COMMENT 4
        JUMPN e
        JUMP f
        COMMENT 5
        d:
        e:
        COPYFROM 4
        OUTBOX
        JUMP h
        COMMENT 6
        f:
        g:
        COPYFROM 5
        OUTBOX
        JUMP i
        COMMENT 7
        h:
        i:
        JUMP a
        DEFINE COMMENT 0
        eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
        DEFINE COMMENT 1
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 2
        eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
        DEFINE COMMENT 3
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 4
        eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
        DEFINE COMMENT 5
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 6
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 7
        eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
        ===异或判断法:(做法A)
        -- HUMAN RESOURCE MACHINE PROGRAM --
        a:
        INBOX
        COMMENT 0
        JUMPN c
        JUMP b
        COMMENT 1
        b:
        COPYFROM 4
        COPYTO 1
        JUMP d
        COMMENT 2
        c:
        COPYFROM 5
        COPYTO 1
        JUMP e
        COMMENT 3
        d:
        e:
        INBOX
        COMMENT 4
        JUMPN g
        JUMP f
        COMMENT 5
        f:
        COPYFROM 4
        SUB 1
        JUMP h
        COMMENT 6
        g:
        COPYFROM 5
        SUB 1
        JUMP i
        COMMENT 7
        h:
        i:
        JUMPZ j
        JUMP k
        COMMENT 8
        j:
        COPYFROM 4
        JUMP l
        COMMENT 9
        k:
        COPYFROM 5
        JUMP m
        COMMENT 10
        l:
        m:
        OUTBOX
        JUMP n
        COMMENT 11
        n:
        JUMP a
        DEFINE COMMENT 0
        eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
        DEFINE COMMENT 1
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 2
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 3
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 4
        eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
        DEFINE COMMENT 5
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 6
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 7
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 8
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 9
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 10
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 11
        eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
        ================================================
        短暂的休息~

        =================================================
        :第十九关:滴答滴答。
        是的,从某个数到0,都需要输出一遍,名副其实的倒计时。
        这时候,我们拥抱了最后两个加入的指令,接下来这些指令将陪伴到通关了。
        那么你问这关怎么做吗,现在你有自加1和自减1了,你还有jumpZ还有什么难办的呢,
        不断的减1,输出,直到判断出了0,这是正数,负数就是不断加1了。

        -- HUMAN RESOURCE MACHINE PROGRAM --
        a:
        INBOX
        COPYTO 1
        JUMP b
        COMMENT 0
        b:
        c:
        JUMPN e
        JUMPZ h
        JUMP d
        COMMENT 1
        d:
        OUTBOX
        BUMPDN 1
        JUMP f
        COMMENT 2
        e:
        OUTBOX
        BUMPUP 1
        JUMP g
        COMMENT 3
        f:
        g:
        JUMP c
        COMMENT 4
        h:
        OUTBOX
        JUMP i
        COMMENT 5
        i:
        JUMP a
        DEFINE COMMENT 0
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 1
        eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
        DEFINE COMMENT 2
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 3
        eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
        DEFINE COMMENT 4
        eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
        DEFINE COMMENT 5
        eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;


        IP属地:江苏4楼2017-03-13 22:41
        回复
          :那么在20关之前,提一下一个有趣的东西,一个程序会有两到三个只在end器内部的逆向jump,
          但这些jump从来都不会有连线交叉的情况,而总是距离大的jump的内部存在着距离小的jump、
          编程玩家也许会了解jump在编程语言里几乎是goto指令的用法,但goto……是个灾难。
          所以这三元法里逆jump的限制使用,其实就是实现了把逆jump转化为了while或者for的用法。
          :第二十冠:乘法,同样没有难度的东西。
          还记得那个40倍放大器吗,和这里的区别,只是那时候的40倍需要我们自己去写入,但这次不一样了,
          我们需要做的只是一个结构,这个结构就能自动的把两个数乘在一起。
          关卡的设计其实是非常的亲切的。为什么我会这么说,是因为这关给了你提示,在哪里呢,在上一关。
          上一关叫做倒计时,他其实变相的提示了你这个自加1,和自减1的用法。
          那么实际上硬背乘法口诀表,而不知道乘法原理的朋友,请耐心听我以下描述:
          {A和B相乘,为了看的清楚我这里把A和B分别的设置为3和6。
          这意味着什么,一般来说的3*6=18,这众所周知,但是实际上他是怎么得出这个结果的。
          乘法的本质,实际上是 3 个 6 相加。(或者6个3相加结果是一致的)}
          现在你知道乘法的本质是加法了,那A个B相加要怎么实现,同样很简单,利用自减1来实现。
          【A每自减1一次,B遍加B一次。】最后的结果就会是A个B相加,也就是AB相乘。
          ,,那这个什么时候结束?当然是A到0的时候。
          步骤:
          1 备份好AB两数,并备份一个0(以便运行B+B第一回合的时候不至于加到空地板上报错)
          2 这里似乎采取的B自减1的做法,没事,两数对调完全没有区别。接着就判断B是否为0,
          是就输出格子1里的最后结果,否就自减1,并让A去加一次格子1的结果(第一次时为0),并放在格子里。
          3,在最后跳回循环。

          -- HUMAN RESOURCE MACHINE PROGRAM --
          a:
          INBOX
          COPYTO 2
          INBOX
          COPYTO 3
          COPYFROM 9
          COPYTO 1
          JUMP b
          COMMENT 0
          b:
          c:
          COPYFROM 3
          COMMENT 1
          JUMPZ f
          JUMP d
          COMMENT 2
          d:
          BUMPDN 3
          COPYFROM 2
          ADD 1
          COPYTO 1
          JUMP e
          COMMENT 3
          e:
          JUMP c
          COMMENT 4
          f:
          COPYFROM 1
          OUTBOX
          JUMP g
          COMMENT 5
          g:
          JUMP a
          DEFINE COMMENT 0
          eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
          DEFINE COMMENT 1
          eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
          DEFINE COMMENT 2
          eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
          DEFINE COMMENT 3
          eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
          DEFINE COMMENT 4
          eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
          DEFINE COMMENT 5
          eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
          ================================================
          :第二十一贯:串是什么:3,6,3,1,9,0。总之就是类似这个结构,他的结尾是0,也就是到0就结束,如果两个0?
          那第二个0就是一个,只包含0结束的串。
          这关的目的吗?是把所有一个串的数加在一起,输出。并不难啦……不断的加,直到遇到0,就输出。
          1 便利于计算和应对只有0的串,我自然在格子1里放上0数字。
          2 拿起输出就先判断是否为0,是就输出格子1,否就和格子1相加,放入格子1,就可以不断循环这过程了。
          3 等结束了回跳一下。

          -- HUMAN RESOURCE MACHINE PROGRAM --
          a:
          COPYFROM 5
          COPYTO 1
          JUMP b
          COMMENT 0
          b:
          c:
          INBOX
          COMMENT 1
          JUMPZ f
          JUMP d
          COMMENT 2
          d:
          ADD 1
          COPYTO 1
          JUMP e
          COMMENT 3
          e:
          JUMP c
          COMMENT 4
          f:
          COPYFROM 1
          OUTBOX
          JUMP g
          COMMENT 5
          g:
          JUMP a
          DEFINE COMMENT 0
          eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
          DEFINE COMMENT 1
          eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
          DEFINE COMMENT 2
          eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
          DEFINE COMMENT 3
          eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
          DEFINE COMMENT 4
          eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
          DEFINE COMMENT 5
          eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
          ================================================
          :喜闻乐见的二十二关:……斐波那契数列。1,1,2,3,5,8,13,21。
          他的特征就是,任何位置的第三个数字,等于前两个数字相加。
          这关我依旧因为做法之一的不满意而提供了两个做法。
          首先他需要输出的是,到某个数为止,之前的数组:
          如果输出的是6,那我们需要输出 1,1,2,3,5 。而需要注意,自身也算,所以输出是5的时候,最后一个输出的也是5。
          那么做法1,交错输出法:
          对于这种方法,我只用一个蛋疼来形容……
          也许有好奇这个数组是怎么搞出来的,以及老是做不对第一数的输出,那么这里是这么做的。
          首先根据名字,这个数字是以扭曲可憎的交错形式,存在在格子1和格子2的,
          这意味着,一个数组:1,1,2,3,5,8,13,21 其中的1,2,5,13,存在在格子1,而1,3,8,21则在格子2里出现。
          这也就意味着你得做两遍差不多的步骤,什么A+B的结果放回A啊,什么输出当前格子啊,这就很费。
          但是也是能达到效果的,那么关于这个数组的初始化是这么设置的,分别在格子1,2里放入数1,0
          这里采用先加出结果,再减去对比数(输入数)的做法判断。
          交错相加法步骤:
          1 首先安置好格子1,2里的数字1,0,接着安置对比的输入数,在格子5里,接着就可以做第一套操作了。
          2 拿起格子1(1),去加格子2(0),得到了1,再放回格子1,这看起来没啥意义,因为本来这格里就是1,
          但他的作用其实是在以后的循环里都是这样的步骤,所以才这样做。然后就得到了数组第一数,
          就立刻去减待机数格子5,得到三种结果,负数,0,正数。
          负数:没能超过对比数,可以输出这个数,并需要继续朝下执行步骤,
          0:和对比数相同,结果归为负数,因为下次减法就立刻变正数了所以无妨。
          正数:超过了对比数,停止当前的输入了。而且甚至步骤结束,应该end并跳回起始。
          3 现在就非常的微妙,因为3的步骤是:拿起格子2,去加格子1,得到了数,再放回格子2,
          接下来甚至就完全和步骤2一样了,所以这就非常的,重复。并在结尾处跳回步骤2的开始处。
          4 于是在底端迎接从上面两处中任何一处跳入的end,并回到起始。
          移位相加法:这个做法就是为了弥补交错法的不足。
          他仅仅多一个步骤,就删去了之前交错法中的步骤三。
          1 首先和之前一样,安置好三个数,
          2 接着和步骤2执行一样的过程,但是仅仅有一点的区别,那就是当有负数和0结果的时候,
          移位法会额外执行一个,交换两个数的步骤,这个步骤意义重大1,这意味着,当结束交换的时候,
          数组和之前的交错法相比,再也不用执行另一套步骤3了,因为当前数组的状态,完全可以去重新执行步骤2.
          于是就省掉了再写一套步骤3,除此以外再无区别。执行完成后同样的输出。循环。

          ===交错相加法:
          -- HUMAN RESOURCE MACHINE PROGRAM --
          a:
          COPYFROM 9
          COPYTO 1
          COPYTO 2
          BUMPUP 1
          INBOX
          COPYTO 5
          JUMP b
          COMMENT 0
          b:
          c:
          COPYFROM 1
          ADD 2
          COPYTO 1
          SUB 5
          COMMENT 1
          JUMPN e
          JUMPZ d
          JUMP i
          COMMENT 2
          d:
          e:
          COPYFROM 1
          OUTBOX
          COMMENT 3
          COPYFROM 2
          ADD 1
          COPYTO 2
          SUB 5
          COMMENT 4
          JUMPN g
          JUMPZ f
          JUMP j
          COMMENT 5
          f:
          g:
          COPYFROM 2
          OUTBOX
          JUMP h
          COMMENT 6
          h:
          JUMP c
          COMMENT 7
          i:
          j:
          JUMP a
          DEFINE COMMENT 0
          eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
          DEFINE COMMENT 1
          eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
          DEFINE COMMENT 2
          eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
          DEFINE COMMENT 3
          eJxjYBgFo2AUjGQAAAQEAAE;
          DEFINE COMMENT 4
          eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
          DEFINE COMMENT 5
          eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
          DEFINE COMMENT 6
          eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
          DEFINE COMMENT 7
          eJxjYmBgOFXcUsQwCkbBKBiRAADVswI2;
          ===移位相加法:(这里的格子3就是对比数,而格子4是用于两个数交换。)
          -- HUMAN RESOURCE MACHINE PROGRAM --
          a:
          COPYFROM 9
          COPYTO 1
          COPYTO 2
          BUMPUP 1
          INBOX
          COPYTO 3
          JUMP b
          COMMENT 0
          b:
          c:
          COPYFROM 1
          ADD 2
          COPYTO 1
          SUB 3
          COMMENT 1
          JUMPN e
          JUMPZ d
          JUMP g
          COMMENT 2
          d:
          e:
          COPYFROM 1
          OUTBOX
          COMMENT 3
          COPYFROM 1
          COPYTO 4
          COPYFROM 2
          COPYTO 1
          COPYFROM 4
          COPYTO 2
          JUMP f
          COMMENT 4
          f:
          JUMP c
          COMMENT 5
          g:
          JUMP a
          DEFINE COMMENT 0
          eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
          DEFINE COMMENT 1
          eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
          DEFINE COMMENT 2
          eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
          DEFINE COMMENT 3
          eJxjYBgFo2AUjGQAAAQEAAE;
          DEFINE COMMENT 4
          eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
          DEFINE COMMENT 5
          eJxjYmBgmNGg2sIwCkbBKBiRAAAOHwHE;


          IP属地:江苏5楼2017-03-13 22:47
          回复
            :第二十三馆:把串里最小的数输出吧(没有空串)
            这一关在二周目审核的时候,下定决心使用一种数据找回的方法,因为我想缓存方法你们都直接能理解。
            但数据找回的方法更加有趣一点,这种做法也是从太猫那里学的。
            (ps:这关的纵标签挺累赘的,我把它省了吧)
            步骤:
            1 首先你将会接收到串里的第一个数字,这不会是0,但是他也没什么值得比较的,所以简单的放在格子1里。
            2 你进入了某个循环里,这时候会拿出第二个数字,当然这个数就有可能是0了,
            当时0的时候,直接的去输出格子1,并end本次循环。
            但是更多时候不是0,那继续往下,直接拿着手里的数去减去本来格子1里的数。
            你将会得到三种结果:
            负数:显然手里的数更小,于是加回地板上的数,手中的数恢复原样,并放置在格子1。这就是新的最小数了。
            0:放哪边都一样,归为正数,因为步骤更方便。
            正数:这意味着手里的数是较大的数,所以忽视这个数,进入内end,回跳到第二个拿起一个数的步骤。
            3 当最终你拿到了0,这时候的格子1里就是这个串里最小的数了,你输出他并end,然后循环吧。
            ps:你是要问提到的缓存法怎么做吗,当你拿出第二个数去减之前,随便在格子x里备份一个,根据结果,
            如果是负数结果,那就从格子x里提取出之前的缓存,放到格子1里。

            -- HUMAN RESOURCE MACHINE PROGRAM --
            a:
            INBOX
            COPYTO 1
            JUMP b
            COMMENT 0
            b:
            c:
            INBOX
            JUMPZ i
            JUMP d
            COMMENT 1
            d:
            SUB 1
            JUMPN e
            JUMPZ g
            JUMP h
            COMMENT 2
            e:
            ADD 1
            COPYTO 1
            JUMP f
            COMMENT 3
            f:
            g:
            h:
            JUMP c
            COMMENT 4
            i:
            COPYFROM 1
            OUTBOX
            JUMP j
            COMMENT 5
            j:
            JUMP a
            DEFINE COMMENT 0
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 1
            eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
            DEFINE COMMENT 2
            eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
            DEFINE COMMENT 3
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
            DEFINE COMMENT 4
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 5
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
            ========================================================
            :地二十四层:你居然让我输出余数!
            (不过并不难)
            别担心,你其实并不需要做除法,那是因为你只有减法用。
            求余的除法并不难做,甚至可以说很好做,把A不断的减去B,直到不能再减了,那剩下的就是余数了。
            步骤:
            1 一如既往的先置入两个输入,接着直接就A-B判断了:
            负数:那说明已经完了,现在我们身处循环内部,所以这负数也许是N次以后的结论,
            但现在已经可以输出A里剩下的数了。
            0和正数:把余数0交给下一次减法出负数的情况吧,而正数代表还可以再尝试减一次,
            2 于是把正数和0时候的结果,放回了格子2,并end了,直到出负数,就输出格子2,并end当前循环。并开始新一轮循环。
            于是看起来添麻烦的余数关就这么化解了。

            -- HUMAN RESOURCE MACHINE PROGRAM --
            a:
            INBOX
            COPYTO 2
            INBOX
            COPYTO 3
            JUMP b
            COMMENT 0
            b:
            c:
            COPYFROM 2
            SUB 3
            COMMENT 1
            JUMPN g
            JUMPZ d
            JUMP e
            COMMENT 2
            d:
            e:
            COPYTO 2
            JUMP f
            COMMENT 3
            f:
            JUMP c
            COMMENT 4
            g:
            COPYFROM 2
            OUTBOX
            JUMP h
            COMMENT 5
            h:
            JUMP a
            DEFINE COMMENT 0
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 1
            eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
            DEFINE COMMENT 2
            eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
            DEFINE COMMENT 3
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
            DEFINE COMMENT 4
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 5
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
            ========================================================
            :嘀25年:累加の倒计时。
            让我们把输入的数比如说5,就结果5+4+3+2+1的结果输出。
            步骤:
            1 首先就一如既往的置入输入于格子2,并置入0在格子1以便于加法。
            2 拿起格子2,判断是否是0,那如果是0的话,就要把放结果的格子1输出了。
            那么一般来说还不是0,这时候就把这个数和旁边的格子1相加,放回,并自减1了格子2的输入数。
            最终格子2的输入会被减成0,这时候就结束了。
            3 最后循环这个过程。

            -- HUMAN RESOURCE MACHINE PROGRAM --
            a:
            COPYFROM 5
            COPYTO 1
            INBOX
            COPYTO 2
            JUMP b
            COMMENT 0
            b:
            c:
            COPYFROM 2
            COMMENT 1
            JUMPZ f
            JUMP d
            COMMENT 2
            d:
            ADD 1
            COPYTO 1
            BUMPDN 2
            JUMP e
            COMMENT 3
            e:
            JUMP c
            COMMENT 4
            f:
            COPYFROM 1
            OUTBOX
            JUMP g
            COMMENT 5
            g:
            JUMP a
            DEFINE COMMENT 0
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 1
            eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
            DEFINE COMMENT 2
            eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
            DEFINE COMMENT 3
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
            DEFINE COMMENT 4
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 5
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
            ========================================================
            :二石榴年:小除
            总之就是上次要除法的余数,而这次是要除法的除数结果。这的确没有太大的区别。
            (于是我也就复制了一份之前的来修改)
            步骤:
            1 这次不光配置好了两个数,还在格子1里放入了一个0,用来输出结果。
            2 这次的做法就改成了,每减少一次,首先判断结果:
            正数:还可以再减,于是把减下来的结果,放回格子2,并给格子1自加1。
            0:归为正数。
            负数:那就不可再减了,把格子1的结果输出。
            3 最后就循环一下,就过关了。于是就(再次的)轻松解决。

            -- HUMAN RESOURCE MACHINE PROGRAM --
            a:
            COPYFROM 9
            COPYTO 1
            INBOX
            COPYTO 2
            INBOX
            COPYTO 3
            JUMP b
            COMMENT 0
            b:
            c:
            COPYFROM 2
            SUB 3
            COMMENT 1
            JUMPN g
            JUMPZ d
            JUMP e
            COMMENT 2
            d:
            e:
            COPYTO 2
            BUMPUP 1
            JUMP f
            COMMENT 3
            f:
            JUMP c
            COMMENT 4
            g:
            COPYFROM 1
            OUTBOX
            JUMP h
            COMMENT 5
            h:
            JUMP a
            DEFINE COMMENT 0
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 1
            eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
            DEFINE COMMENT 2
            eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
            DEFINE COMMENT 3
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
            DEFINE COMMENT 4
            eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
            DEFINE COMMENT 5
            eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;


            IP属地:江苏6楼2017-03-13 22:49
            回复
              :荻二十八鲶:这三排序……真是非常的……困难……
              有关雨点一般多的排序方法的实现,我将会在最终关(大量的)列出。【一周目校对:然而并没有】
              在这里我们就迅速的解决问题吧。【一周目教程原话】
              【二周目校对:在这里我决定摒除原本的繁琐方法。原因是一周目的做法,就是分别做了三次检测,非常的……蠢。
              原本的这里,就是分别导入三个数,然后比较1和2,比较2和3,再比较1和2,中间有调换步骤,但是这令人难以接受,
              所以我在这里写出一种……【三周目校对:在这里二周目突然懒虫上脑,于是最后还是采用了一周目的方法】
              排序:排序是什么,不知道的请度一下,这里的要求是从小到大的输出。排序在这里怎么实现?
              比如比较先后两个格子的大小,于是一旦不符合标准,就调换这两个格子的顺序。
              步骤:
              1 先置入了三个数。
              2 执行了,比较1和2,把小的放前面,然后比较2和3,小的放前面,但是由于分辨不了现在的1和2,所以再比较一遍。
              最后排序完成,顺次输出1,2,3,三个数字。
              3 并重复这个过程。

              -- HUMAN RESOURCE MACHINE PROGRAM --
              a:
              INBOX
              COPYTO 1
              INBOX
              COPYTO 2
              INBOX
              COPYTO 3
              COMMENT 0
              COPYFROM 1
              SUB 2
              COMMENT 1
              JUMPN e
              JUMPZ b
              JUMP c
              COMMENT 2
              b:
              c:
              COPYFROM 1
              COPYTO 7
              COPYFROM 2
              COPYTO 1
              COPYFROM 7
              COPYTO 2
              JUMP d
              COMMENT 3
              d:
              e:
              COPYFROM 2
              SUB 3
              COMMENT 4
              JUMPN i
              JUMPZ f
              JUMP g
              COMMENT 5
              f:
              g:
              COPYFROM 3
              COPYTO 7
              COPYFROM 2
              COPYTO 3
              COPYFROM 7
              COPYTO 2
              JUMP h
              COMMENT 6
              h:
              i:
              COPYFROM 1
              SUB 2
              COMMENT 7
              JUMPN m
              JUMPZ j
              JUMP k
              COMMENT 8
              j:
              k:
              COPYFROM 2
              COPYTO 7
              COPYFROM 1
              COPYTO 2
              COPYFROM 7
              COPYTO 1
              JUMP l
              COMMENT 9
              l:
              m:
              COPYFROM 1
              OUTBOX
              COPYFROM 2
              OUTBOX
              COPYFROM 3
              OUTBOX
              JUMP n
              COMMENT 10
              n:
              JUMP a
              DEFINE COMMENT 0
              eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
              DEFINE COMMENT 1
              eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
              DEFINE COMMENT 2
              eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
              DEFINE COMMENT 3
              eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
              DEFINE COMMENT 4
              eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
              DEFINE COMMENT 5
              eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
              DEFINE COMMENT 6
              eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
              DEFINE COMMENT 7
              eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
              DEFINE COMMENT 8
              eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
              DEFINE COMMENT 9
              eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
              DEFINE COMMENT 10
              eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
              ========================================================
              :迪贰拾⑨蹭:
              的的的的那么现在你可以使用了,
              使用通过特定格子的里面的值变的可以指向值里数字的方块了,
              当然字母的还有不存在数字的名字的话,是会报错的哦,

              -- HUMAN RESOURCE MACHINE PROGRAM --
              a:
              INBOX
              COPYTO 12
              COPYFROM [12]
              OUTBOX
              JUMP a
              ========================================================
              :第散失层:(内容被河蟹)
              (被河蟹):
              ① (被河蟹)首先载入串
              ② 然后按照指针输出,每次-1
              ③ 最后循环(其他话语被河蟹)

              -- HUMAN RESOURCE MACHINE PROGRAM --
              a:
              INBOX
              COPYTO 24
              JUMP b
              COMMENT 0
              b:
              c:
              COPYFROM [24]
              COMMENT 1
              JUMPZ f
              JUMP d
              COMMENT 2
              d:
              OUTBOX
              BUMPUP 24
              JUMP e
              COMMENT 3
              e:
              JUMP c
              COMMENT 4
              f:
              JUMP a
              DEFINE COMMENT 0
              eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
              DEFINE COMMENT 1
              eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
              DEFINE COMMENT 2
              eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
              DEFINE COMMENT 3
              eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
              DEFINE COMMENT 4
              eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
              ==================================================
              :理智的间隙:
              那个……,我要讲什么来的,对了,人群中冒出来一个,光头!
              ……………………………………
              那个……,对了,串的载入,怎么把输入里的几个元素,顺次排列进地砖0,1,2,3,4等等等等
              那个,首先你会拥有一个指针格子,指针是什么?就是那种第二个模式的,用值来指向方块的做法,
              每次你把输入放入了一个格子,就把指针方块自加1,然后下次使用指针方块,指向了新的方块,。
              就是这么做的,这些长串的串就是这么载入的。
              好的我匿了


              IP属地:江苏7楼2017-03-13 23:00
              回复
                :层噫失散第::
                5 最后循环这整个过程。
                4 这样的话,最终会因为指针变为0,且被检测到,而输出结束,
                如果非0的话,就输出,并指针-1。
                3 后半段就是输出,先拿起指针,判断是不是0,是0就该结束了,
                2 这时候的指针是x+1的,所以把他恢复成x,
                1 第一步首先还是要把整个串的信息载入。但是这里提供的方法,不放入0做结尾。
                步骤:(注:标签符号有误(似乎顺序被打乱),请忽视)

                -- HUMAN RESOURCE MACHINE PROGRAM --
                a:
                b:
                INBOX
                COMMENT 0
                JUMPZ e
                JUMP c
                COMMENT 1
                c:
                COPYTO [14]
                BUMPUP 14
                JUMP d
                COMMENT 2
                d:
                JUMP b
                COMMENT 3
                e:
                BUMPDN 14
                JUMP f
                COMMENT 9
                f:
                g:
                COPYFROM 14
                COMMENT 4
                JUMPN j
                JUMP h
                COMMENT 5
                h:
                COPYFROM [14]
                OUTBOX
                BUMPDN 14
                JUMP i
                COMMENT 6
                i:
                JUMP g
                COMMENT 7
                j:
                BUMPUP 14
                JUMP k
                COMMENT 8
                k:
                JUMP a
                DEFINE COMMENT 0
                eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                DEFINE COMMENT 1
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn
                DEFINE COMMENT 2
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                DEFINE COMMENT 3
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 4
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 5
                eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                DEFINE COMMENT 6
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn
                DEFINE COMMENT 7
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                DEFINE COMMENT 8
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 9
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                ========================================================
                :第0三十2关:要把相同字母的总量,给 输出,
                这关非常的 简单。
                步骤:(我省略两个纵标签)
                1 这关开辟两个新的 地砖去使用,分别是位于格子18的,指针,和19的计数器。
                14格的0我不会动他,因为判断是否扫描结束就靠他了 。最后置入输入数字于格子17。
                2 接着就拿起格子18里指向的地砖,判断是否为0并,如果是,则于步骤4说明。
                3 如果非0,则拿起手中的元素减去格子17的对比元素。
                (字母的特点,字母不可和数字或字母相加,但字母减字母会得到两个字母的差值,例如B-A=1)
                对比结果如果为0,则计数格19自加1,否则无视,结束时,指针+1,并回跳。
                4 如果是0的话,字母扫描结束,输出计数器结果,并循环这个过程。

                -- HUMAN RESOURCE MACHINE PROGRAM --
                a:
                COPYFROM 14
                COPYTO 19
                COPYTO 18
                INBOX
                COPYTO 17
                JUMP b
                COMMENT 0
                b:
                c:
                COPYFROM [18]
                JUMPZ i
                JUMP d
                COMMENT 1
                d:
                SUB 17
                JUMPZ e
                JUMP g
                COMMENT 2
                e:
                BUMPUP 19
                JUMP f
                COMMENT 3
                f:
                g:
                BUMPUP 18
                JUMP h
                COMMENT 4
                h:
                JUMP c
                COMMENT 5
                i:
                COPYFROM 19
                OUTBOX
                JUMP j
                COMMENT 6
                j:
                JUMP a
                DEFINE COMMENT 0
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 1
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                DEFINE COMMENT 2
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                DEFINE COMMENT 3
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 4
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                DEFINE COMMENT 5
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 6
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                ================================================
                :第不知道多少关:请把元音去掉;
                和上一关几乎一样,只是这次出现减出0的情况,就应该立刻终止这个轮回了。
                步骤:
                1 开辟指针,输入一个数放置在缓存,
                2 通过指针从5个元素里逐个比对,一旦有减出0结果,就跳出循环,从头开始。
                3 扫描到头都没有重复的话,就输出这个缓存数,并从头开始

                -- HUMAN RESOURCE MACHINE PROGRAM --
                a:
                COPYFROM 5
                COPYTO 6
                INBOX
                COPYTO 7
                JUMP b
                COMMENT 0
                b:
                c:
                COPYFROM [6]
                COMMENT 1
                JUMPZ g
                JUMP d
                COMMENT 2
                d:
                SUB 7
                COMMENT 3
                JUMPZ i
                JUMP e
                COMMENT 4
                e:
                BUMPUP 6
                JUMP f
                COMMENT 5
                f:
                JUMP c
                COMMENT 6
                g:
                COPYFROM 7
                OUTBOX
                JUMP h
                COMMENT 7
                h:
                i:
                JUMP a
                DEFINE COMMENT 0
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 1
                eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                DEFINE COMMENT 2
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                DEFINE COMMENT 3
                eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                DEFINE COMMENT 4
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                DEFINE COMMENT 5
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                DEFINE COMMENT 6
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 7
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                ================================================
                :第这里的墙破了一个洞关:
                ……就是,当输入过这个时候,比如c,那下次就,不需要输出c了。
                这关比较微妙,他有两个指针,一个指针负责库存,也就是定位到所有元素的长度,以便扩展。
                还有一个就是每输出一次,就把库存从头扫描一遍,去查看是否有重复的元素。
                步骤:
                1 结构比较类似,所以一部分可以借鉴大概上一关,首先就配置一个,%%%数据删除】
                【意外现象修复,在三周目审核时发现看不懂自己做的什么东西,于是重做。】
                【以下内容为重做版】
                步骤:首先同样还是双指针系统。(纵线标签pass)
                1 首先是配置,就先把大指针【两个大圆】配置一下,然后在格子0里也配0,到时候可以省点功夫,大概
                2 这里的开始前配置一下小指针【两个小圆】,因为一个数字扫一遍,所以一个循环重置一次。
                3 进入第一重循环,先拿起小指针指向的格子,这个格子可能是0也可能非0。
                是0的话意味着整个库存扫描完了,没有相同的,所以输出当前的,和推动大指针 {还有储存这个数} 并end。
                非0的话,就进一步的去减自己的输入对比数。结果:
                是0的话意味着相同,就直接跳出这个数的循环,
                非0的话,就推动小指针前进一步,然后循环,下一次的开始是重新拿一个小指针的数。
                4 最后就跳回到配置小指针之前了。

                -- HUMAN RESOURCE MACHINE PROGRAM --
                COPYFROM 14
                COPYTO 11
                COPYTO 0
                a:
                COMMENT 0
                COPYFROM 14
                COPYTO 12
                INBOX
                COPYTO 10
                JUMP b
                COMMENT 1
                b:
                c:
                COPYFROM [12]
                JUMPZ g
                JUMP d
                COMMENT 2
                d:
                SUB 10
                JUMPZ h
                JUMP e
                COMMENT 3
                e:
                BUMPUP 12
                JUMP f
                COMMENT 4
                f:
                JUMP c
                COMMENT 5
                g:
                COPYFROM 10
                COPYTO [11]
                OUTBOX
                BUMPUP 11
                COPYFROM 14
                COPYTO [11]
                JUMP i
                COMMENT 6
                h:
                i:
                JUMP a
                DEFINE COMMENT 0
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 1
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 2
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                DEFINE COMMENT 3
                eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                DEFINE COMMENT 4
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                DEFINE COMMENT 5
                eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                DEFINE COMMENT 6
                eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                DEFINE LABEL 10
                eJxjYWBg4EmYl8IAptP7GUbBKBgFIwoAAEQGAtU;
                DEFINE LABEL 11
                eJxjYWBgYA5aVAakGOZGQ+hRMApGwcgBAPJeA4I;
                DEFINE LABEL 12
                eJxjYWBgOOP/qAJIMVSUQuhRMApGwcgBAOvOBME;


                IP属地:江苏8楼2017-03-13 23:06
                回复
                  :第七七三十六关:hell
                  这关……好长啊……
                  步骤:
                  1 就先把串,载入在0开头的和10开头的两行里。然后重置一下指针。{01-28行}
                  2 判断一下第一行的当前指针个,是否为0,
                  如果是0就暂时吧0塞入格子22,
                  如果非0,就进一步判断第二行的指针是否为0
                  如果是0的话,就暂时把10塞入格子22.
                  如果非0的话,才走到最终一条线,那就是,比较两个数的大小,
                  如果第一个数大,则放10在格22,
                  如果第二个数大,则放0在格子22、
                  最后如果两个数相等,就推进两个指针,进行下一轮。
                  3 最后我们得到格子22里有一个数,可能是1或者10,我们就按照这个输出就可以了。
                  注意点:首先载入两个串很容易,这关的难度在于输出短的那个串,但是由于0不能参与字符加减
                  所以需要专门的开空间去比较哪个数先到0,很长的步骤2都是在做这个。

                  -- HUMAN RESOURCE MACHINE PROGRAM --
                  COPYFROM 23
                  COPYTO 20
                  COPYFROM 24
                  COPYTO 21
                  COMMENT 0
                  a:
                  INBOX
                  JUMPZ d
                  JUMP b
                  COMMENT 1
                  b:
                  COPYTO [20]
                  BUMPUP 20
                  JUMP c
                  COMMENT 2
                  c:
                  JUMP a
                  COMMENT 3
                  d:
                  COPYFROM 23
                  COPYTO [20]
                  JUMP e
                  COMMENT 4
                  e:
                  f:
                  INBOX
                  JUMPZ i
                  JUMP g
                  COMMENT 5
                  g:
                  COPYTO [21]
                  BUMPUP 21
                  JUMP h
                  COMMENT 6
                  h:
                  JUMP f
                  COMMENT 7
                  i:
                  COPYFROM 23
                  COPYTO [21]
                  COPYFROM 23
                  COPYTO 20
                  COPYFROM 24
                  COPYTO 21
                  JUMP j
                  COMMENT 8
                  j:
                  k:
                  COPYFROM [20]
                  JUMPZ q
                  JUMP l
                  COMMENT 9
                  l:
                  COPYFROM [21]
                  JUMPZ s
                  JUMP m
                  COMMENT 10
                  m:
                  COPYFROM [20]
                  SUB [21]
                  JUMPN p
                  JUMPZ n
                  JUMP r
                  COMMENT 11
                  n:
                  BUMPUP 20
                  BUMPUP 21
                  JUMP o
                  COMMENT 12
                  o:
                  JUMP k
                  COMMENT 13
                  p:
                  q:
                  COPYFROM 23
                  COPYTO 22
                  JUMP u
                  COMMENT 14
                  r:
                  s:
                  COPYFROM 24
                  COPYTO 22
                  JUMP t
                  COMMENT 15
                  t:
                  u:
                  v:
                  COPYFROM [22]
                  JUMPZ y
                  JUMP w
                  w:
                  OUTBOX
                  BUMPUP 22
                  JUMP x
                  x:
                  JUMP v
                  y:
                  DEFINE COMMENT 0
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 1
                  eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                  DEFINE COMMENT 2
                  eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                  DEFINE COMMENT 3
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 4
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 5
                  eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                  DEFINE COMMENT 6
                  eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                  DEFINE COMMENT 7
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 8
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 9
                  eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                  DEFINE COMMENT 10
                  eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                  DEFINE COMMENT 11
                  eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                  DEFINE COMMENT 12
                  eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                  DEFINE COMMENT 13
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 14
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 15
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  ================================================
                  :第三十七个年头:要求自己多看几遍我这里不唠嗑了
                  这数据分两个部分=-数据部分和指向下一个地址的部分·总的来说这个关没难度:’
                  {那么步骤*
                  1拿起输入并jump,因为之后的步骤和这里的置入是重复的。
                  @把输入赋值入格子22(和格子17…分别代表指针与指针+1、这是访问数据下一个的最清晰方法。
                  同时注意把指针+1给自加一下.这样这里就是一个置入指针区域】
                  2¥拿起格22[x]输出,再拿起指针+1进判断,是负数就进外end,非0进里end,外end跳到起始,
                  里end回到指针置入区域。这样就整个结束。

                  -- HUMAN RESOURCE MACHINE PROGRAM --
                  a:
                  INBOX
                  JUMP b
                  COMMENT 0
                  b:
                  c:
                  COPYTO 22
                  COPYTO 17
                  BUMPUP 17
                  COMMENT 1
                  COPYFROM [22]
                  OUTBOX
                  COPYFROM [17]
                  COMMENT 2
                  JUMPN e
                  JUMP d
                  COMMENT 3
                  d:
                  JUMP c
                  COMMENT 4
                  e:
                  JUMP a
                  DEFINE COMMENT 0
                  eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                  DEFINE COMMENT 1
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 2
                  eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                  DEFINE COMMENT 3
                  eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                  DEFINE COMMENT 4
                  eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                  ==============================================================
                  :第数位炸弹:
                  这关最终我改了结构,之前的结构拖的太长,以至于中途jump胡乱的跳跃。
                  这关需要先判断他的位数,如果跳过这一步,两位数或者一位数的输出结果会异常。
                  之前用了一种前后结构,判断在前,执行在后,分成三段好似一个蜈蚣。
                  这次修改了结构,单独把判断位数安排在一起,分别三个出口,再把三个执行安排在了一起。
                  这样的效果会更加清楚一点。位数位数需要跳过,是因为输出是即时输出的,十位之后输出十位的结果,
                  如果连在一起就会有12输出0 1 2的错误结果。
                  【以及,这关用三元法的格式的话,真的会非常的累赘,所以是时候离开三元法了】
                  步骤:
                  1 配置好十位和百位的0,然后把输入的数放在个位,因为最后结果能直接输出。
                  2 接着就是判断位数,位数对结果影响很大。首先就是-100判断是否三位数。
                  如果是正数和0,则跳入百位开始的正数除结果循环,
                  如果负数,则需要加回100,然后再次的减去10
                  如果正数,同理直接跳入十位数,
                  负数则直接跳入个位数的输出。
                  3 两个百位和十位的执行区,每成功减一次,就给计数+1,所以当减出负数的时候,就直接输出。
                  这样就把拆数位完成了。

                  -- HUMAN RESOURCE MACHINE PROGRAM --
                  a:
                  COPYFROM 9
                  COPYTO 4
                  COPYTO 5
                  INBOX
                  COPYTO 3
                  COMMENT 0
                  SUB 11
                  JUMPN b
                  JUMP c
                  COMMENT 1
                  b:
                  ADD 11
                  SUB 10
                  JUMPN k
                  JUMP g
                  COMMENT 2
                  c:
                  d:
                  COPYFROM 3
                  SUB 11
                  JUMPN e
                  COPYTO 3
                  BUMPUP 5
                  JUMP d
                  COMMENT 3
                  e:
                  COPYFROM 5
                  OUTBOX
                  JUMP f
                  COMMENT 4
                  f:
                  g:
                  h:
                  COPYFROM 3
                  SUB 10
                  JUMPN i
                  COPYTO 3
                  BUMPUP 4
                  JUMP h
                  COMMENT 5
                  i:
                  COPYFROM 4
                  OUTBOX
                  JUMP j
                  COMMENT 6
                  j:
                  k:
                  COPYFROM 3
                  OUTBOX
                  JUMP l
                  COMMENT 7
                  l:
                  JUMP a
                  DEFINE COMMENT 0
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 1
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 2
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 3
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 4
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 5
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 6
                  eJxjYBgFo2AUjGQAAAQEAAE;
                  DEFINE COMMENT 7
                  eJxjYBgFo2AUjGQAAAQEAAE;


                  IP属地:江苏9楼2017-03-13 23:11
                  回复
                    :第三十九重设坐标:
                    【第三周目审核到此一游】
                    【啊不对不是说这个,这关审核到这里的时候,就发现了出现严重的方法错误,所以重制了。】
                    来说个思路吧,这已经39关了,我觉得到这里的人都已经十分的能跟上思路了。
                    有这种类型的自信存在没错,
                    首先就是,要分解两种坐标,并不需要开两个前置格子,因为减去很多4以后,
                    自然剩下的数就是另一个坐标的值。(第一周目我不厌其烦的减1宛若智障:还好机制的三周目发现了)
                    所以……我已经讲完了,就是这样,不断的减去4,每可以减一次就坐标+1。
                    当不能减了,那就把除数和余数输出了就可以了。

                    -- HUMAN RESOURCE MACHINE PROGRAM --
                    a:
                    COPYFROM 14
                    COPYTO 4
                    INBOX
                    COPYTO 0
                    JUMP b
                    COMMENT 0
                    b:
                    c:
                    COPYFROM 0
                    SUB 15
                    COMMENT 1
                    JUMPN f
                    JUMP d
                    COMMENT 2
                    d:
                    COPYTO 0
                    BUMPUP 4
                    JUMP e
                    COMMENT 3
                    e:
                    JUMP c
                    COMMENT 4
                    f:
                    COPYFROM 0
                    OUTBOX
                    COPYFROM 4
                    OUTBOX
                    JUMP g
                    COMMENT 5
                    g:
                    JUMP a
                    DEFINE COMMENT 0
                    eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                    DEFINE COMMENT 1
                    eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                    DEFINE COMMENT 2
                    eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                    DEFINE COMMENT 3
                    eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                    DEFINE COMMENT 4
                    eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                    DEFINE COMMENT 5
                    eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                    ==============================================================
                    :第四十关:质数工厂:
                    哈哈哈哈哈哈,勇者哦,你终于来到了这里,来一盘新鲜的三文鱼生鱼片吗
                    首先请切记,1不要问我质数是什么,然后就没了。
                    那个,写程序的时候,有上过第一课,那可真是过瘾啊,因为平时觉得复杂的问题。
                    第一节课就咔嚓嚓的给解决了,
                    那时候印象最深的就是……自己先把问题复杂化了,最后发现了自己用的是质数筛法。
                    但是看到了老师教的算法还是感触颇深,十分的暴力朴实,
                    那就是从2开始,一个个对比是不是能除的尽。
                    所以,步骤:
                    1 配置了输入数{顶端},商{中央},还有除数{左侧}
                    2 开始了,首先在格子3里备份了一个被除数,所有操作都对格子3做,保留了格子2的正确性。
                    接着去格子2,验证一下是否为1,因为未来的商里,除到最后的结果将会是1。
                    而如果这里是1的话,则直接跳入end了,因为意味着素数的拆解已经结束了。
                    但更多情况这里不是1,则处理一下变回刚才的值,接着就拿起备份的格子3,去减除数。
                    如果是负数,说明这个数没能被当前除数整除,所以把商结果复位成0,
                    然后把被除数加1,进入下一个循环。
                    如果是0的话,就把商结果+1,然后放进格子2,这是新的一轮需要计算的被除数了,
                    接着复位了商为0,最后输出当前除数,因为有可能同时有两个或者多个同样的质因子,
                    所以这里不把除数加1.
                    如果是正数,则拷贝回格子3,并给商+1,循环这个过程。
                    3 最后这个循环会出来,假如输入的数是17,则不断的被除数+1,直到加到自身,商一下子变为1,
                    跳出了循环。
                    【那么这里介绍一个简化……个头啊,介绍一个优化步骤,这中间有这么一个原理。
                    一个数的质因子一定会在这个数的开方以内。什么意思呢,比如说18=2*9
                    18的开方是4.242,也就是,18的开方的数一定会有一个在4.242以内。不论是2还是
                    3,都是4以内。为什么会是开方呢,因为开方的时候假如出的是两个整数,比如64=8*8;
                    是一个两个因子一致的数,也就是这两个的分布是最大了,如果一方提高到16,
                    另外一边就不得不降到4.绝对会在开方以内包括开方。
                    这能如何帮助我们呢,观察这关出数规律,没有数到的了25,所以也就是说25以内的合数,
                    因数之一不会超过4,如果是素数,那就是自身,【于是判断这么做,如果2-4里没有出结果,
                    则可以直接去输出自身了,比如17,判断过程就是 2-3-4-然后就17了。

                    -- HUMAN RESOURCE MACHINE PROGRAM --
                    a:
                    INBOX
                    COPYTO 2
                    COPYFROM 24
                    COPYTO 12
                    COPYTO 10
                    BUMPUP 10
                    BUMPUP 10
                    JUMP b
                    COMMENT 0
                    b:
                    c:
                    d:
                    COPYFROM 2
                    COPYTO 3
                    BUMPDN 2
                    COMMENT 1
                    JUMPZ n
                    JUMP e
                    COMMENT 2
                    e:
                    BUMPUP 2
                    JUMP f
                    COMMENT 3
                    f:
                    g:
                    COPYFROM 3
                    SUB 10
                    COMMENT 4
                    JUMPN l
                    JUMPZ j
                    JUMP h
                    COMMENT 5
                    h:
                    COPYTO 3
                    BUMPUP 12
                    JUMP i
                    COMMENT 6
                    i:
                    JUMP g
                    COMMENT 7
                    j:
                    BUMPUP 12
                    COPYTO 2
                    COPYFROM 24
                    COPYTO 12
                    COPYFROM 10
                    OUTBOX
                    JUMP k
                    COMMENT 8
                    k:
                    JUMP d
                    COMMENT 9
                    l:
                    COPYFROM 24
                    COPYTO 12
                    BUMPUP 10
                    JUMP m
                    COMMENT 10
                    m:
                    JUMP c
                    COMMENT 11
                    n:
                    JUMP a
                    DEFINE COMMENT 0
                    eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                    DEFINE COMMENT 1
                    eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                    DEFINE COMMENT 2
                    eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                    DEFINE COMMENT 3
                    eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                    DEFINE COMMENT 4
                    eJxjZmBgKCm+qVhSPPclwygYBaNgxAEAOGsEUg;
                    DEFINE COMMENT 5
                    eJxjY2Bg+KY9LQFIMUx1h9DySRB6FIyCUTD8AQBvnwVn;
                    DEFINE COMMENT 6
                    eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                    DEFINE COMMENT 7
                    eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                    DEFINE COMMENT 8
                    eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                    DEFINE COMMENT 9
                    eJxjZmBgOO2cNfXZgaypDKNgFIyCEQcAyGEEtg;
                    DEFINE COMMENT 10
                    eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                    DEFINE COMMENT 11
                    eJxjZmBg+F8PggwNDKNgFIyCEQcA6zwE/g;
                    ================================================
                    :最终关!【排序楼层】
                    呜哇!,最终还是到了这里,这就是最后的最后啦。
                    这个最终的boss,给出了算法界最佳经典的题目,排序。
                    本来是打算把排序算法们实现个遍,但最后经过讨论还是觉得,在这边就先把冒泡排序说了吧
                    {其实教程到这里的时候,已经实现了插入排序和插入排序的变体}
                    【也就是这个时候,你要离开三元法了,他带领和陪伴你走到了这一关,但是终于大幅度的编辑不再适合用它,
                    它所展现的魅力是追求工整的极致,有种稚气的青春感(青春才没这个生硬好不好)
                    好的,那么我们来看最后一关吧】
                    说明:冒泡排序使用的方法是,一次把数组里最小的一个数推到一边去,第二次则推到第一格数旁边,
                    这样,当整个数组都扫了一遍以后,就可以输出了、
                    步骤:
                    1 我这里采取相反的,把最大 数推到最右边,效果是一样的,首先配置
                    输出一整个串,并且保留串长度(不包括0)在格子23。这里的串当做了接下来的大指针。
                    2 配置扫描过程里的小指针两个,其中21其实是指针+1,用于便利,
                    接着首先判断指针的位置,如果当前的大指针,和小指针+1,重合了那说明当前一轮扫描结束,
                    那给大指针-1,朝左边移动,直到大指针+1是1,小指针是0,这时候按照判断,大指针还会-1.
                    然后大指针就变成0了,下一次计算的似乎,会得出-1的结论,这样一来就循环就结束了,
                    可以输出了。
                    3 大的循环是步骤2,小的循环则是,当那时候小指针+1还没碰到大指针的时候,
                    将提取[20]-[21]这样比较两个数的大小,当正数的时候,就需要执行一次调换位置了,
                    但是不论结果要不要调换,最后的部分总是给指针和指针+1,都自加1。
                    4 当到达快输出的时候,你会发现,最初的串计数器格子23,后来的串大指针,到现在变回0了。
                    所以我们再次加以利用,直接获取[0],然后再给格子自加,直到拿起的是0,
                    这一组的排序就算完成啦、
                    (感慨万千,无以言语)

                    -- HUMAN RESOURCE MACHINE PROGRAM --
                    a:
                    COPYFROM 24
                    COPYTO 23
                    b:
                    INBOX
                    COPYTO [23]
                    JUMPZ c
                    BUMPUP 23
                    JUMP b
                    COMMENT 0
                    c:
                    d:
                    COPYFROM 24
                    COPYTO 20
                    COPYTO 21
                    BUMPUP 21
                    e:
                    COPYFROM 23
                    SUB 21
                    JUMPN i
                    JUMPZ h
                    COMMENT 2
                    COPYFROM [20]
                    SUB [21]
                    JUMPN g
                    JUMPZ f
                    COMMENT 3
                    COPYFROM [21]
                    COPYTO 22
                    COPYFROM [20]
                    COPYTO [21]
                    COPYFROM 22
                    COPYTO [20]
                    f:
                    g:
                    BUMPUP 20
                    BUMPUP 21
                    JUMP e
                    h:
                    BUMPDN 23
                    JUMP d
                    COMMENT 1
                    i:
                    j:
                    COPYFROM [23]
                    JUMPZ k
                    OUTBOX
                    BUMPUP 23
                    JUMP j
                    k:
                    JUMP a
                    DEFINE COMMENT 0
                    eJxjYBgFo2AUjGQAAAQEAAE;
                    DEFINE COMMENT 1
                    eJxjYBgFo2AUjGQAAAQEAAE;
                    DEFINE COMMENT 2
                    eJxjZmBgqF3+I7h2+fschlEwCkbBiAMAt9gE8g;
                    DEFINE COMMENT 3
                    eJxjZmBgmFr+y29qeUEWwygYBaNgxAEA634EPg;
                    DEFINE LABEL 22
                    eJxjYWBgCGdtfAGkGH78gNAu1Y7PGUbBKBgFIwIAAOROBwo;

                    最后,这里是zat和太猫的人力资源机器教程,感谢阅者的支持和鼓励~


                    IP属地:江苏10楼2017-03-13 23:15
                    回复
                      首先我得问下吧主现在精品怎么说加就加而且连吱都不吱一下
                      还没仔细看 不过说实话楼主的排版有点让我没有看下去的动力
                      虽然贴子发出去已经改不了了我还是想说下
                      首先我觉得解释程序最好配流程图解释 当然纯文字也不是不可以 但是流程图更简洁而且更直观
                      其次能不能不要N多关全都挤在一楼里。。。完全可以一关一楼 也方便定位(我回来想找某关的时候找到这层楼就行)如果嫌楼数太多也可以找思路差不多的放一起 不过这样全都挤在一起起码我手机看着很难受。。。。
                      嘛这是排版上的建议(?)具体内容待会再看 可能要看好久


                      IP属地:广东来自iPhone客户端11楼2017-03-14 00:08
                      收起回复
                        。。。。讲真没看懂_(:з」∠)_理解有限,不知道什么叫三远法,只知道百合大法


                        IP属地:广东来自手机贴吧13楼2018-12-08 21:02
                        收起回复