这是每两周挑战＃3。主题：遗传算法

这个挑战有点实验。我们想看看我们可以用遗传算法做些什么。并非所有内容都是最佳的，但我们尽了最大努力使其变得可访问。如果能够解决问题，谁会知道我们将来会看到什么。也许是希尔的遗传之王？

规格很长！我们已尝试将规范分为基础知识-开始使用框架并提交答案所需的最低知识-和Gory Details-完整规范，以及有关控制器的所有详细信息，可以自己写。
如果您有任何疑问，请随时加入我们的聊天室！

您是行为心理学的研究者。今天是星期五晚上，您和您的同事决定找点乐子，并用您的实验用老鼠参加小老鼠赛跑。实际上，在我们对它们过于迷恋之前，我们称它们为标本。

您已经为标本设置了一个小小的赛道，并且为了使其更加有趣，您在赛道上放置了一些墙壁，陷阱和传送器。现在，您的标本仍然是老鼠……他们不知道什么是陷阱或传送器。他们所看到的只是一些颜色不同的东西。他们也没有任何记忆力-他们所能做的就是根据当前环境做出决定。我猜自然选择会从那些不知道如何避免陷阱的标本中挑选出来（这场比赛将需要一段时间...）。让游戏开始！^†

^{†84,465个样本在进行挑战时受到了伤害。}

基础

这是一款单人游戏（您和您的同事不想混合人口，因此每个人都建立自己的赛车场）。赛道是一个矩形网格，高15格，宽50格。您从左边缘（其中x = 0）上随机（不一定不同）的15个样本开始。您的标本应尝试达到x≥49和0≤y≤14的任何单元的目标（标本可能会超出右侧的轨道）。每次发生这种情况，您都会得到一点。您也以1点开始游戏。您应该尝试在10,000转后最大化积分。

多个标本可能占据同一个细胞，并且不会相互作用。

在每个转弯处，每个标本都看到一个5x5的周围网格（自身位于中心）。该网格的每个单元包含一个颜色-1来15。-1表示超出范围的单元格。如果标本超出范围，则标本会死亡。至于其他颜色，它们代表空的单元，陷阱，墙壁和传送器。但是您的标本不知道哪种颜色代表什么，您也不知道。但是有一些限制：

• 8种颜色代表空单元格。
• 4种颜色代表一个传送器。传送器会将标本发送到其9x9邻域内的某个单元中。对于所有相同颜色的传送器，此偏移量将相同。
• 2种颜色代表墙壁。进入墙壁等同于静止不动。
• 2种颜色代表陷阱。甲陷阱表明一个的9个单元在其近邻的是致死的（不一定是陷阱细胞本身）。对于所有相同颜色的陷阱，此偏移量将相同。

现在，关于自然选择……每个标本都有一个基因组，即一个具有100位的数字。通过杂交两个现有的标本，然后稍微突变基因组，可以创建新的标本。标本越成功，复制的机会就越大。

因此，这是您的任务：您将编写一个函数，该函数接收标本所见颜色的5x5网格及其基因组作为输入。您的函数将返回样本的移动（Δx，Δy），其中Δx和Δy分别为之一{-1, 0, 1}。您不得在函数调用之间保留任何数据。这包括使用您自己的随机数生成器。您的函数将提供带种子的RNG，您可以随意使用它。

您提交的分数将是50条随机轨道上的点数的几何平均值。我们发现该分数存在一定差异。因此，这些分数将是初步的。一旦挑战消失，将宣布截止日期。在截止日期结束时，将随机选择100个委员会，所有提交的意见将在这100个委员会中重新评分。请随意在您的答案中加上预估的分数，但我们会为每份提交的作品评分，以确保没有人作弊。

我们提供了几种语言的控制器程序。目前，您可以使用Python（2或3），Ruby，C ++，C＃或Java编写提交内容。控制器生成棋盘，运行游戏并为遗传算法提供框架。您所要做的就是提供移动功能。

等一下，那么我该如何处理基因组呢？

挑战在于弄清楚！

由于标本没有记忆，因此您在给定回合中所拥有的只是5x5的颜色网格，对您没有任何意义。因此，您必须使用基因组来达到目标​​。通常的想法是，您使用基因组的一部分来存储有关颜色或网格布局的信息，而您的机器人则根据存储在基因组中的其他信息来做出决定。

现在，您当然不能实际在此处手动存储任何内容。因此，在那里存储的实际信息最初将是完全随机的。但是遗传算法将很快选择那些基因组包含正确信息的标本，同时杀死那些信息错误的标本。您的目标是找到从基因组位和视野到移动的映射，这使您可以快速找到目标的路径，并且始终如一地发展为制胜法宝。

这应该是足够的信息，可以帮助您入门。如果需要，可以跳过下一部分，并从底部的控制器列表中选择您要选择的控制器（还包含有关如何使用该特定控制器的信息）。

继续阅读...

血腥细节

^{该规范已完成。所有控制器都必须执行这些规则。}

除非另有说明，否则所有随机性均使用均匀分布。

轨道生成：

• 轨道是一个矩形网格，X = 53单元宽，Y = 15单元高。与细胞X≥49是目标细胞（其中，X是从零开始）。
• 每个单元格只有一种颜色，并且可能是致命的，也可能不是致命的 -除非由以下一种单元格类型指定，否则这些单元格不是致命的。
• 有16种不同的单元格颜色，从标记0为15，其含义将因游戏而异。另外，-1表示超出范围的细胞-这些是致命的。
• 选择8种随机颜色。这些将是空单元格（无效）。
• 再选择4种随机颜色。这些是传送器。对于其中两种颜色，请在9x9邻域中选择一个非零偏移量（从（-4，-4）到（4,4），除了（0,0）以外）。对于其他两种颜色，请反转这些偏移量。如果样本踩在传送器上，它将立即移动该偏移量。
• 再选择2种随机颜色。这些是陷阱。对于每种颜色，在3x3邻域中选择一个偏移量（从（-1，-1）到（1,1））。陷阱表示该偏移量处的单元格是致命的。注意：陷阱单元本身不一定具有致命性。
• 剩下的2种颜色是墙壁，阻碍运动。尝试移动到墙单元上将使移动变得静止。壁细胞本身具有致命性。
• 对于网格的每个非目标单元，选择一种随机颜色。为每个目标单元选择一个随机的空色。
• 对于轨道左边缘的每个像元，确定是否可以在100转内达到目标（根据下面的转弯顺序规则）。如果是这样，则此单元格是允许的起始单元格。如果起始单元少于10个，则丢弃轨道并生成一个新轨道。
• 创建15个样本，每个样本具有随机的基因组，年龄为0。将每个标本放在随机的起始细胞上。

转订单：

1. 对于每个样本，将依次执行以下步骤。标本不会相互作用或看不见，可能会占据同一单元格。
   1. 如果标本的年龄为100岁，则会死亡。否则，将其年龄增加1。
   2. 给标本以其视野-以标本为中心的5x5颜色网格-并在其3x3邻域中返回移动。超出此范围将导致控制器终止。
   3. 如果目标单元是墙，则移动更改为（0,0）。
   4. 如果目标单元是传送器，则样本会按传送器的偏移量移动。注意：此步骤执行一次，而不是迭代执行。
   5. 如果当前被标本占据的细胞（可能是在使用一个传送器之后）是致命的，则标本会死亡。这是样品死亡的唯一时间（除了上述步骤1.1。）。特别是，在致死细胞上产生的新标本不会立即死亡，而是有机会先移出危险细胞。
   6. 如果标本占据目标格，则得分，将标本移至随机起始格，并将其年龄重置为0。
2. 如果板上剩下的样本少于两个，则游戏结束。
3. 创建10个年龄为0的新标本。每个基因组（分别）由以下育种规则确定。将每个标本放在随机的起始细胞上。

配种：

• 创建新标本时，随机选择两个不同的亲本，偏向于向右进一步发展的标本。选择标本的概率与其当前的适应度得分成正比。标本的健身得分为

  1 + x + 50 *达到目标的次数

  其中x是从0开始的水平索引。同一回合中创建的标本不能选择为父本。

• 在两个亲本中，选择一个随机的一个作为第一个基因组位。

• 现在，当您沿着基因组行走时，以0.05的概率切换亲本，并继续从所得亲本中获取位。
• 突变完全组装的基因组：对于每个位，以0.01的概率翻转。

得分：

• 一局游戏持续10,000回合。
• 玩家以1分开始游戏（允许使用几何平均值）。
• 每当标本达到目标时，玩家就会得分。
• 目前，每个玩家的提交将运行50场比赛，每场比赛都有不同的随机轨迹。
• 上述方法导致比期望更多的变化。一旦挑战消失，将宣布截止日期。在截止日期结束时，将随机选择100个委员会，所有提交的意见将在这100个委员会中重新评分。
• 玩家的总得分是这些单个游戏得分的几何平均值。

控制器

您可以选择以下任何控制器（因为它们在功能上是等效的）。我们已经测试了所有这些，但是如果您发现错误，想要提高代码或性能或添加图形输出等功能，请在GitHub上发送引发问题或发送拉动请求！也欢迎您添加其他语言的新控制器！

单击每个控制器的语言名称，以转到GitHub上的正确目录，其中包含README.md带有正确用法说明的。

如果您不熟悉git和/或GitHub，则可以从首页以ZIP格式下载整个存储库（请参见侧栏中的按钮）。

蟒蛇

• 经过最彻底的测试。这是我们的参考实现。
• 可与Python 2.6+和Python 3.2+一起使用！
• 非常慢 我们建议与PyPy一起运行以大幅提高速度。
• 支持使用pygame或进行图形输出tkinter。

红宝石

• 已在Ruby 2.0.0上测试。应该与较新的版本一起使用。
• 它也相当慢，但是Ruby可能会方便地为提交的原型制作原型。

C ++

• 需要C ++ 11。
• （可选）支持多线程。
• 迄今为止最快的控制器。

C＃

• 使用LINQ，因此需要.NET 3.5。
• 相当慢。

爪哇

• 并不是特别慢。并不是特别快。

初步排行榜

所有分数均为初步分数。不过，如果出现明显错误或过时，请通知我。我们列出的示例提交供比较，但没有争用。

  Score   | # Games | User               | Language   | Bot           
===================================================================================
2914.13   |   2000  | kuroi neko         | C++        | Hard Believers
1817.05097|   1000  | TheBestOne         | Java       | Running Star
1009.72   |   2000  | kuroi neko         | C++        | Blind faith
 782.18   |   2000  | MT0                | C++        | Cautious Specimens
 428.38   |         | user2487951        | Python     | NeighborsOfNeighbors
 145.35   |   2000  | Wouter ibens       | C++        | Triple Score
 133.2    |         | Anton              | C++        | StarPlayer
 122.92   |         | Dominik Müller     | Python     | SkyWalker
  89.90   |         | aschmack           | C++        | LookAheadPlayer
  74.7    |         | bitpwner           | C++        | ColorFarSeeker
  70.98   |   2000  | Ceribia            | C++        | WallGuesser
  50.35   |         | feersum            | C++        | Run-Bonus Player
  35.85   |         | Zgarb              | C++        | Pathfinder
 (34.45)  |   5000  | Martin Büttner     | <all>      | ColorScorePlayer
   9.77   |         | DenDenDo           | C++        | SlowAndSteady
   3.7    |         | flawr              | Java       | IAmARobotPlayer
   1.9    |         | trichoplax         | Python     | Bishop
   1.04   |   2000  | fluffy             | C++        | Gray-Color Lookahead

学分

这项挑战是一项巨大的协作努力：

• Nathan Merril：编写了Python和Java控制器。将挑战概念从山丘之王转变为老鼠赛跑。
• trichoplax：游戏测试。在Python控制器上工作。
• feersum：编写了C ++控制器。
• VisualMelon：编写了C＃控制器。
• 马丁·布特纳（MartinBüttner）：概念。写了Ruby控制器。游戏测试。在Python控制器上工作。
• T亚伯拉罕：游戏测试。测试了Python，并检查了C＃和C ++控制器。

以上所有用户（可能还有更多我忘记了的用户）都为挑战的总体设计做出了贡献。

C ++控制器更新

如果将C ++与Visual Studio和多线程一起使用，则应获得最新更新，因为它们的随机数生成器种子存在错误，该错误允许生成重复的电路板。

盲目信仰-C ++-在2000次运行中得分超过800（！）

对基因组进行彩色编码，具有神秘的轨迹反馈和有效的威慑力

#include "./gamelogic.cpp"

#define NUM_COLORS 16

// color meanings for our rats
typedef enum { good, bad, trap } colorType_t;
struct colorInfo_t {
    colorType_t type;
    coord_t offset; // trap relative location
    colorInfo_t() : type(good) {} // our rats are born optimists
};

// all 8 possible neighbours, carefully ordered
coord_t moves_up  [] = { { 1, 0 }, { 1,  1 }, { 1, -1 }, { 0,  1 }, { 0, -1 }, { -1, 0 }, { -1,  1 }, { -1, -1 } };  // toward the goal, going up   first
coord_t moves_down[] = { { 1, 0 }, { 1, -1 }, { 1,  1 }, { 0, -1 }, { 0,  1 }, { -1, 0 }, { -1, -1 }, { -1,  1 } };  // toward the goal, going down first

// map of the surroundings
struct map_t {
    static const size_t size = 5;
    static const int max = size / 2;
    static const int min = -max;
    colorType_t map[size*size];
    colorType_t & operator() (int x, int y) { return map[(x + max)*size + y + max]; }
    colorType_t & operator() (coord_t pos) { return operator()(pos.x, pos.y); }
    bool is_inside(int x, int y) { return abs(x) <= max && abs(y) <= max; }
    bool is_inside(coord_t pos) { return is_inside(pos.x,pos.y); }
};

// trap mapping info
struct trap_t {
    coord_t detector;
    colorInfo_t color;
    trap_t(int x, int y, colorInfo_t & color) : color(color) { detector.x = x; detector.y = y; }
    trap_t() {}
};

coord_t blindFaith(dna_t d, view_t v)
{
    colorInfo_t color[NUM_COLORS]; // color informations

    // decode colors
    for (size_t c = 0; c != 16; c++)
    {
        size_t base = c * 4;
        if (d[base])
        {
            color[c].type = d[base+1] ? good : bad;
        }
        else // decode trap location
        {
            color[c].type = trap;
            int offset = d[base+1] + 2 * d[base+2] + 4 * d[base+3];
            color[c].offset = moves_up[offset]; // the order is irrelevant as long as all 8 neighbours are listed
        }
    }

    // build a map of the surrounding cells
    map_t map;
    unsigned signature = 0;
    int i = 0;
    for (int x = map.min; x <= map.max; x++)
    for (int y = map.min; y <= map.max; y++)
    {
        int c = v(x, y);
        map(x, y) = (c == -1) ? bad : color[c].type;
        if (c != -1) signature ^= v(x, y) << ((i++) % 28);
    }

    // map traps
    for (int x = map.min; x <= map.max; x++)
    for (int y = map.min; y <= map.max; y++)
    {
        if (map(x, y) != trap) continue;
        const colorInfo_t & trap = color[v(x, y)];
        int bad_x = x + trap.offset.x;
        int bad_y = y + trap.offset.y;
        if (!map.is_inside(bad_x, bad_y)) continue;
        map(bad_x, bad_y) = bad;
        map(x, y) = good;
    }

    // pick a vertical direction according to surroundings signature
    int go_up = d[64 + signature % (DNA_BITS - 64)];

    // try to move to a good cell nearer the goal
    for (const coord_t &move : go_up ? moves_up : moves_down) if (map(move.x, move.y) == good) return move;

    // try not to increase fitness of this intellectually impaired specimen
    return{ -1, 0 };
}

int main() {
    time_t start = time(NULL);
    double score = runsimulation(blindFaith);
    slog << "Geometric mean score: " << score << " in " << time(NULL) - start << " seconds";
}

样本结果：

Scores: 15 4113306 190703 1 1 44629 118172 43594 63023 2 4 1 1 205027 1 455951 4194047 1 5 279 1 3863570 616483 17797 42584 1 37442 1 37 1 432545 5 94335 1 1 187036 1 4233379 1561445 1 1 1 1 35246 1 150154 1 1 1 1 90141 6 1 1 1 26849 1 161903 4 123972 1 55 988 7042063 694 4711342 90514 3726251 2 1 383389 1 593029 12088 1 149779 69144 21218 290963 17829 1072904 368771 84 872958 30456 133784 4843896 1 2 37 381780 14 540066 3046713 12 5 1 92181 5174 1 156292 13 1 1 29940 66678 125975 52714 1 5 3 1 101267 69003 1 1 10231 143110 282328 4 71750 324545 25 1 22 102414 1 3884626 4 28202 64057 1 1 1 1 70707 4078970 1623071 5047 1 1 549040 1 1 66 3520283 1 6035495 1 79773 1 1 1 218408 1 1 15 33 589875 310455 112274 1 1 4 1 3716220 14 180123 1 2 12785 113116 12 2 1 59286 822912 2244520 1840950 147151 1255115 1 49 2 182262 109717 2 9 1049697 59297 1 11 64568 1 57093 52588 63990 331081 54110 1 1 1537 3 38043 1514692 360087 1 260395 19557 3583536 1 4 152302 2636569 12 1 105991 374793 14 3934727 1 2 182614 1 1675472 121949 11 5 283271 207686 175468 1 1 173240 1 138778 1 1 59964 3290382 1 4 1757946 1 23520 1 2 94 1 124577 497071 1749760 39238 1 301144 3 1 2871836 1 1 10486 1 11 8 1 111421 11 1807900 1 587479 1 42725 116006 3 1 6 5441895 1 1 22 52465 952 1 18 1 1 46878 2 1 1 1994 4 593858 123513 4692516 820868 4247357 1 1 2 1 2 8770 2 1 95371 4897243 2 22741 1 1 1 1 325142 6 33650 4 51 102993 1 182664 1 4040608 18153 2045673 462339 1 1 617575 2 2551800 3 7760 1 108012 76167 143362 1148457 1 53460 1 71503 1 1 1 1 81482 3208 62286 69 139 1 3503941 1 253624 101903 3081954 80123 84701 9 16 1 1070688 71604 613064 2076 15009 9 1 1 1 199731 1 2 1 63132 1 1843855 27808 1 3569689 273144 1 460524 2703719 22443 10876 51242 1 6972678 4591939 1 140506 43981 45076 2 1 91301 5 1 1874615 1758284 608 13 1 96545 75161 1 618144 4 2056133 1 1 2 57401 1394307 6 188116 83545 1 41883 1 1 467189 371722 1 1122993 1 17912 159499 1 5 3355398 33 1 2 246304 1 2 168349 1 50292 12 141492 2723076 3 1 6 3060433 223360 171472 106409 1 2 1 102729 8814 1 285154 1 11 1 65 930 2 689644 3271116 1 5 4 60 77447 1 1 1477538 256023 100403 2480335 1 39888 1 1 70052 66090 1 250 1 2 8 115371 1523106 1424 168148 1 1 1 42938 17 1 364285 185080 1 1 36 4903764 13 51987 1106 276212 67460 1 251257 2 6867732 1 1 1890073 1 1 8 5 2118932 210 0 3792346 5209168 1 1 1 1 51 1 4621148 1 37 337073 3506096 1 1 1 1 458964 2 16 52930 1 15375 267685 1 1 1259646 14930 3248678 527105 1 103 24 1 3252685 6009 1 1 176340 3971529 121 1722808 1 31483 194232 2314706 95952 3625407 3 216755 56 1 8 1 1 1 1 885 229 9056 172027 31516 2526805 1 76076 1589061 1 1 8 90812 1 21 72036 1681271 2 212431 1581814 85993 79967 4 7 514708 1070070 1 71698 1 23478 15882 94453 1 27382 495493 277308 12127 91928 248593 1 1 1 26540 1709344 2119856 1 1 48867 107017 251374 64041 15924 15 87474 8 1 23 9 48 1 1 1 51793 2 61029 84803 15 689851 1 1 873503 10 140084 420034 87087 82223 1 163273 12 1 5 570463 19 26665 1 170311 1 39983 1 475306 1 2 36417 746105 11 141345 1 3 1 30 3 1 1 1 1 1312289 408117 1 42210 273871 561592 1 1 1 1 4448568 48448 7 378508 1 351858 278331 1 79515 1169309 3670107 14711 4686395 1156554 33 2528441 24537 76 335390 63545 122108 76675 21929 34 1 861361 83000 417781 1 90487 1 1 85116 7 2 1 60129 647991 79 1 2755780 726845 244217 50007 187212 1 3674051 286071 44068 3 307427 26973 1 26059 1957457 230783 58102 545318 1 4 172542 168365 1 89402 1 4 1 1 1 1 2 3 16 62935 5643183 117961 109942 85762 5 117376 118883 1 61 23893 122536 70185 1 64252 208409 179269 55381 1579240 3434491 1 4964284 3356245 3 21 2197119 346542 44340 59976 772220 5590844 199721 90858 63785 125989 57219 129737 81836 1 3671 16810 1 4151040 1 15 40108 1 443679 3224921 2 27498 2 3 146529 169409 19 1 1 1 1 41627 1 3 2722438 1 2013730 1 1649406 1 1 6943 125772 58652 1 1 1 2413522 1 2 48 36067 253807 2 146464 1 248 07 3359223 139896 395985 65241 43988 594638 69033 275085 1 17973 1 1 1 594835 1 1 4468341 3496274 222854 94769 55 161056 36185 8793 277592 3 1 6746 1 138151 66 37365 1 2729315 1 3 57091 22408 249875 246514 85058 1 20 5463152 1 3 1 45293 1 70488 2792458 461 441 951926 2236205 2 171980 1 1 48 3893009 1 458077 1 268203 1 70005 7 19299 1 278978 1 45286 26 2 1883506 274393 342679 1 1 913722 911600 12688 1 1 115020 1249307 1529878 53426 1 226862 3721440 23537 86033 397433 1 1 1 161423 96343 94496 1 1 1 2 1 111576 1 4039782 1 1 1 5742393 3569 46072 1 1 2 1 1 85335 219988 1 78871 115876 43405 1 300835 1 166684 53134 1 3 111487 6 3 3 77 1 115971 3 205782 10 1932578 356857 43258 47998 1 27648 127096 573939 32650 523906 45193 1 2 128992 1 10144 1 257941 1 19841 5077836 14670 5 3 6 1 1 21 14651 2906084 37942 45032 9 304192 3035905 6214026 2 177952 1 51338 1 65594 46426 553875 2676479 245774 95881 3 216364 3064811 1198509 223982 3 6 1 533254 1 590363 264940 68346 127284 1 7 1 1 4617874 5 45400 1 1 3097950 360274 1 3 1 8421 14 469681 418563 3 1 6 1 1 575766 405239 11 2631108 152667 1 1 1 467383 1 1 775499 1 157998 2 1 143351 92021 1 1 1173046 3636579 1 70635 162303 1 1534876 834682 2 1 1 11981 346908 245124 607794 17 1570641 126995 13 57050 1 2 33731 29739 1 1 35460 1 33716 168190 214704 1 443156 701674 2636870 108081 1604895 1 1 11 115901 23 571891 360680 1 1 35 1 2036975 1 1 2555536 4742615 5 360553 287044 1 1814255 7 59632 1 216 41546 1 540920 353424 2625301 223744 1 1 1 15717 3 429871 1 4 2329632 18 11 1 2 4 1 3905 5 1 1 1 2 5431442 1 859628 1 3 338378 15236 13764 1 3384362 1 15 65293 24 619599 152620 2 189921 35854 16647 7 2 404790 360096 1 2 189459 1097768 191610 1 1 470254 1 12 2 330299 364219 2365542 312023 2273374 2 10527 1 115453 1 2 3845592 52388 913449 1 14695 1 44 37352 90302 1 1 1 233577 51639 3474983 44010 1650727 31 2 2 1 8 7 1 3 5 25603 17799 45630 758457 1 4571839 37 4 3 2 1 1 1351271 196673 12 2880765 263886 2926173 1 2 1 241502 5 6 1 278576 9 7 290722 42749 143391 82753 21771 57887 1 1 60400 1766903 1 296392 1 5 2861787 125560 1 9 199218 1 1 308226 517598 2246753 12 1168981 3 98447 1 488613 9 842865 202108 10 1 238493 1 1523706 5383982 29435 1 1 207071 1 8 4 125742 70531 253135 72207 124291 23364 184376 2 40034 9569353 194109 102854 2 3247153 58313 85995 1 598 63 1 2676692 10 3573233 1 36651 118016 2486962 65456 46760 1 5813 723 178120 2 153305 1 1 2 1 2354413 3 1 17126 132953 437123 299778 3070490 1 6490 403704 2261 511439 1 39 33410 173045 1 1 120970 641346 132042 1 44906 1 33940 132124 467702 45472 9 44 1 1 1 107008 1 46635 1 121431 130760 1 7 3 1 56251 1299306 3 1 1 1 15 2147678 215169 1374943 1 332995 231089 269310 1 7816944 1 1 1 46 134426 1 1 1 2 76112 1 1 30438 299927 25 139373 76048 278757 71 3474997 1 294046 1 3126554 2518019 2 1 6 1 3054393 1 1 1 2 525 96 419528 1 1 154718 233 207879 26 1 6 57436 3 5944942 1 1 318198 147536 1 22 420557 1 1 120938 1 1 167412 4082969 73299 1 11 3557361 1 4 330028 269051 1 2569546 2 1 1 4 1 1 377412 1 1 1 213800 58131 1422177 54 109617 117751 12432 3830664 419046 3 6821 741 919 1 22335 1 1 15069 80694 488809 2389 2308679 145548 51411 115786 110984 107713 1 12 6 1 5 8365 1 2001874 210250 4674015 14 1 1204101 314354 89066 1 1 2438200 68350 1 1575329 5593838 2743787 151670 57 16 5948210 597158 128060 189160 23628 1 1 15 4171774 1 8206 4157492 1 2 315607 1618680 24736 18520 4787225 33842 134431 1 1 1 1 1 1115809 17759 1 33016 123117 1 77322 169633 219091 1 321593 57231 135536 175401 4 1 435702 1 253132 100707 114547 1 119324 6382967 1472898 3 72567 1707408 177958 26 208719 1 27083 74 12 576410 19375 177069 4 3 1 31 507048 2 1 1 2 1 2 1 40 7 99892 95202 60649 241396 232370 1 136579 70649 1 2877 280695 13603 102860 404583 29717 112769 1 54089 1 97579 40819 2 868629 64848 2 63432 5 1 1888426 99623 2 1 7911 53646 3047637 1 2 3 152910 1 3244662 105187 1 1 1 1 8966 200347 1 1 22 302654 6 17 1 10 328150 55259 1016 117291 2 1 224524 23846 74645 1 1 1 1 1 3117394 10847 33976 144613 4 201584 1 1 26959 3 4410588 27019 6 66749 55935 23 4126812 4089989 99959 1 1 1 1 55490 1 4275599 13652 33967 2 8126062 337093 320653 128015 4 1 7729132 1 10594 116651 20990 3046630 1 353731 132989 2066431 4 80 15575 147430 1 621461 3100943 2306122 5 33439 407945 25634 1 2911806 32511 2174235 298281 15159 54125 1 2 3063577 2205013 1 407984 1 319713 1 22171 1 2763843 1 2607606 1 100015 3096036 1 55905 1 1 635265 2890760 1 1 1 1 35854 1 352022 2652014 1 2 274366 1 4 1 602980 4 83828 602270 2816 2 59116 25340 1 11 1 5162051 34 8 218372 1186732 142966 1 1 170557 503302 1 84924 5 1 1350329 1 1 1 130273 78055 902762 1 8581 5 1 3635882 1 1 1 224255 44044 61250 2 438453 8 1 2729357 28 1 17658 82640 1 31809 10 1 33 1 1 45495 5798 5000217 40018 588787 67269 1 12 83512 2798339 1 609271 1 3 1 7 67912 189808 3388775 60961 81311 1167 24939 433791 405306 85934 1 1170651 2 1 66 552579 122985 515363 2188340 1 1 1 3807012 1502582 4 13 149593 1 1 2108196 3 34279 24613 1282047 27 1 2 1 1 584435 27487 1 1 5 33278 1 1 1202843 1 1 1 6 3649820 3100 2 266150 13 164117 10 53163 3295075 1 1 1 1 77890 1 286220 90823 18866 3139039 481826 1 3994676 23 116901 132290 6 3927 84948 1 1 1 1 256310 1 11 8 1 102002 8392 887732 98483 444991 1 1 49408 409967 1158979 1 1 1 81469 189764 3960930 296231 64258 1 1 176030 4 1 2 1 486856 1 1135146 31 2 13112 227077 31
Geometric mean score: 831.185 in 14820 seconds

根据feersum自愿进行的长时间测试，我认为2000次运行足以产生可接受的稳定结果。
由于修改后的控制器在每次运行后都会显示当前的几何平均值，因此我通过视觉确认了最近50次运行的变化相对较小（+/- 10点）。

是什么让这些小动物tick

我没有为每种颜色赋予相同的优先级，而是考虑了以下可能的值：

1. 好 ->老鼠认为它可以安全地进入那里
2. 不好 ->老鼠不会去那里
3. 陷阱 ->大鼠会考虑陷阱的位置不好，表示陷阱的细胞良好。
   尽管我懒得将其重命名，但它是一个“危险检测器”，指示实际陷阱的位置（假定），墙壁，传送器，等待将毫无戒心的流浪者送到不愉快的地方，甚至是死者的入口。 -结束。简而言之，是一个明智的老鼠宁愿不去的地方。

好的或坏的基因只需要2位来存储（例如11和10），但是陷阱需要4位（0ttt其中ttt代表8个“危险”位置之一）。

为了保持每个基因的一致性（即，将其混合到一个完全不同的基因组后仍保持其含义，这要求每个颜色编码基因都位于固定的位置），所有值都编码在4位上（好编码为11xx，差编码为10xx），总共16 * 4 = 64位。

其余的36位用作“防撞墙”（稍后会详细介绍）。25种周围的颜色将散列到这36位的索引中。每一位表示一个优选的垂直方向（上或下），在两个单元之间可能进行选择时使用。

该策略如下：

• 根据基因组对每种颜色进行解码（或对偏离轨道的“坏”细胞进行直接控制器报告）
• 绘制周围环境的地图（3x3单元，可能有8个邻居）
• 计算周围环境的特征（25种颜色的散列（偏离轨道的单元除外））
• 从签名中选择一个首选的垂直方向（在36个哈希桶中）
• 尝试移动到提示为“好”的邻居，从最接近目标的目标开始，然后首先沿首选垂直方向前进
• 如果找不到“好”邻居，请尝试向后移动一个牢房（因此可能是不幸事故的受害者，并避免以任何方式增加健康状况）

啮齿动物，看看你这种敌人

种群可能发生的最糟糕的事情是尚未产生任何获胜者，但是许多老鼠要么贴在墙上，要么贴在无限接近目标的无限传送环内，从而有机会被选中进行繁殖。
与老鼠被困在陷阱中或被传送到墙壁中相反，这些啮齿动物只会在年老时被杀死。
从一开始，它们就没有表亲卡住了3个细胞的竞争优势，但是他们将有足够的时间繁殖克汀素，直到它们的基因组成为优势基因为止，从而无缘无故地严重损害了遗传多样性。

为了减轻这种现象，我们的想法是让这些坏老鼠的后代更有可能避免跟随其祖先的脚步。
垂直方向指示仅1位长（通常说“尝试在这些环境中先上升或下降”），并且相当多的位可能会影响所遵循的路径，因此突变和/或交叉点应具有显着影响。
许多后代的行为会有所不同，并且最终不会将头撞在同一堵墙上（在挨饿的祖先的尸体中）。
这里的亚妙之处在于，这种迹象并不是大鼠行为的主要因素。在大多数情况下，颜色解释仍将占上风（向上/向下选择仅在确实存在两个“好”的情况下才重要和正是大鼠视为一个无害的颜色没有等待，扔在墙上的传送点）。

为什么它（似乎）起作用？

我仍然不知道为什么。

陷阱映射逻辑是仍然未解之谜的绝对运气。毫无疑问，这是成功的基石，但它以其自己的神秘方式起作用。

使用编码后，随机基因组将产生25％的“好”，25％的“差”和50％的“陷印”颜色标识符。
“陷阱”标识符将依次产生与5x5周围环境相关的“好”和“坏”估计。
结果，在给定位置的老鼠会将“世界”视为稳定的和上下文的“执行/不执行”颜色的混合。

正如非常成功的防撞机制似乎表明的那样，轨道上最糟糕的一种元素是可怕的墙（及其在传送环中的表亲，但我想它们很少见）。

结论是，一个成功的程序首先必须设法让老鼠能够检测出导致缓慢饥饿而又未达到目标的位置。

即使没有“猜测”代表墙壁的两种颜色，“陷井”颜色似乎也可以通过允许老鼠绕过一些障碍来帮助避开墙壁，这不是因为它“看见”了墙壁，而是因为“陷井”的估计排除了这些障碍。在这些特定环境中的特定壁单元。

即使老鼠试图朝目标移动（这可能导致认为最“有用的”陷阱指示符是指示前方有危险的指示标），但我认为所有陷阱方向都具有大致相同的影响：指示“背后存在危险的陷阱”位于大鼠前面2个单元格的影响与当大鼠站在其顶部时表示“前方危险”的影响相同。

不幸的是，为什么这种混合具有使基因组如此成功融合的特性，这远远超出了我的数学范围。

我对壁垒式的威慑感到更自在。这只是按计划进行，但大大超出了我的期望（分数基本上乘以四）。

我重击了控制器以显示一些数据。这是几个运行：

Turns:2499 best rat B  B  B  G  B  G  T3 G  T4 B  G  B  B  B  G  G  ^vv^^vv^v^v^^^vvv^v^^^v^^^v^vv^^v^^^ Max fitness: 790 Specimens: 1217 Score: 2800
Turns:4999 best rat B  B  B  G  B  G  T3 G  T4 B  G  B  B  B  G  G  ^vv^^vv^v^v^^^vvv^v^^^v^^^v^vv^^v^^^ Max fitness: 5217 Specimens: 15857 Score: 685986
Turns:7499 best rat B  B  B  G  B  G  T3 G  T4 B  G  B  B  B  G  G  ^vv^^vv^v^v^^^vvv^v^^^vvvvv^^v^v^^^^ Max fitness: 9785 Specimens: 31053 Score: 2695045
Turns:9999 best rat B  B  B  G  B  G  T3 G  T4 B  G  B  B  B  G  G  ^vv^^vv^v^v^^^vvv^v^^^vvvvv^^v^v^^^^ Max fitness: 14377 Specimens: 46384 Score: 6033904
Scored 6035495 in game 146 current mean 466.875

在这里，一种超级大鼠出现得很早（这条赛道很可能是一条直线，第一代的一些幸运鼠就拥有利用它的正确DNA）。最后的标本数量大约是大约100.000只大鼠的理论最大值的一半，这意味着将近一半的小动物获得了无限期地生存在该特定轨道上的能力（！）。
当然，结果分数只是令人讨厌-顺便说一下，计算时间也是如此。

Turns:2499 best rat B  T0 G  B  T7 B  G  B  T6 T0 T3 B  G  G  G  T4 ^v^^^^^v^^v^v^^^^^^^^v^v^v^^vvv^v^^^ Max fitness: 18 Specimens: 772 Score: 1
Turns:4999 best rat T7 G  G  G  G  T7 G  B  T6 T0 T3 T5 G  G  B  T4 ^vvvvvvv^^^vvv^^v^v^^^^^^^^^^^^^v^^^ Max fitness: 26 Specimens: 856 Score: 1
Turns:7499 best rat G  T0 G  T3 G  T0 G  B  T6 T0 T2 B  T4 G  B  T4 ^^v^vvv^^^vv^^v^vvv^v^^vvvv^^^^^^^^^ Max fitness: 55 Specimens: 836 Score: 5
Turns:9999 best rat T6 T0 G  T5 B  T1 G  B  T6 T0 T3 B  T4 G  B  T4 ^^vv^^^^vv^^v^v^^v^^vvv^vv^vvv^^v^^v Max fitness: 590 Specimens: 1223 Score: 10478
Scored 10486 in game 258 current mean 628.564

在这里，我们可以看到工作中的基因组细化。最后两个基因组之间的谱系清晰可见。在好和坏的评价是最显著。该陷阱迹象似乎振荡，直到他们要么稳定到一个“有用” 的陷阱或变异成好或坏。

颜色基因似乎具有一些有用的特征：

• 它们具有独立的含义
  （一种特定的颜色必须以一种特定的方式进行处理）
  每种颜色编码都可以扔到一个完全不同的基因组中，而无需显着改变其行为-除非该颜色实际上是一种决定性的颜色（通常是这种颜色）导致无限循环的墙壁或传送器）。
  对于基本优先级编码，情况就更少了，因为最优先的颜色是用于决定移动位置的唯一信息。在这里，所有“好”颜色都是相等的，因此添加到“好”列表中的给定颜色影响较小。
• 它们对突变具有相对的抵抗力，
  好的/不好的编码只有4个有效位中的2个有效位，并且陷阱位置在大多数时间都可能会更改，而不会显着改变大鼠的行为。
• 它们很小（4位），所以被分频器破坏的可能性非常低。
• 突变产生无害的有意义的改变
  突变为“好”的基因要么影响很小（例如，如果它对应于一个空细胞，它可能允许寻找一条新的，更短的路径，但这也可能导致大鼠直接进入一个陷阱）或一个戏剧性的陷阱（如果颜色代表一堵墙，那只新老鼠很可能会卡在某个地方）。
  翻转为“捕获”的基因将使大鼠失去必需的颜色，或者没有明显的作用。
  陷阱位置的突变只有在确实存在一个陷阱（或任何有害的东西）的情况下才有意义，该可能性相对较小（我会说类似1/3）。

最后，我想最后36位不仅有助于避免老鼠卡住，而且有助于在轨道上更均匀地扩散老鼠，从而保留了遗传多样性，直到获胜的基因组出现并通过颜色编码部分成为主导。

进一步的工作

我必须说，我发现这些小动物令人着迷。
再次感谢所有为这一出色挑战做出贡献的人。

我正在考虑进一步屠宰控制器以显示更重要的数据，例如成功老鼠的祖先。

我也非常想看到这些老鼠的行为，但是这种C ++语言使创建（更不用说动画）图像变得杂乱无章了。

最后，我想至少对陷阱系统进行解释，并可能对其进行改进。

控制器骇客

如果有人感兴趣，我可以发布对控制器所做的修改。
他们很脏又便宜，但是他们能干。

我对GitHub并不精通，因此只需要写一篇文章。

坚定的信徒-C ++-（改进的传送器）：2000运行时10.000+

（这是盲目的信仰的演变，因此您可能希望在此之前攀登另一堵文字墙）

#ifndef NDEBUG
#define NDEBUG
#include "./gamelogic.cpp"
#endif // NDEBUG
#include <cassert>

#define NUM_COLORS 16
#define BITS_OFFSET  3
#define BITS_TYPE    2
#define BITS_SUBTYPE 2
#define BITS_COLOR (BITS_TYPE+BITS_OFFSET)

// how our rats see the world
typedef unsigned char enumSupport_t;
typedef unsigned char trapOffset_t;
typedef enum : enumSupport_t {
    danger,   // code      trap detector
    beam,     // code      safe teleporter
    empty,    // code      empty
    block,    // code      wall, pit or teleporter
    trap,     // computed  detected trap
    pit,      // read      off-board cell
} colorType_t;

// color type encoding (4 first bits of a color gene)
// the order is critical. A single block/empty inversion can cost 2000 points or more
const colorType_t type_decoder[16] = {
    /*00xx-*/
    danger,
    empty,
    beam,
    block,
    /*01xx-*/
    beam,
    danger,
    empty,
    block,
    /*10xx-*/
    empty,
    beam,
    block,
    danger,
    /*11xx-*/
    block,
    empty,
    danger,
    beam,
};

// all 8 possible neighbours, carefully ordered
typedef coord_t neighborhood_t[8];
neighborhood_t moves_up =   { { 1, 0 }, { 1,  1 }, { 1, -1 }, { 0,  1 }, { 0, -1 }, { -1, 0 }, { -1,  1 }, { -1, -1 } };  // toward the goal, going up   first
neighborhood_t moves_down = { { 1, 0 }, { 1, -1 }, { 1,  1 }, { 0, -1 }, { 0,  1 }, { -1, 0 }, { -1, -1 }, { -1,  1 } };  // toward the goal, going down first

// using C++ as a macro-assembler to speedup DNA reading
/*
Would work like a charm *if* a well-paid scatterbrain at Microsoft had not defined
std::bitset::operator[] as

bool operator[](size_t _Pos) const
{   // subscript nonmutable sequence
return (test(_Pos));
}

Bounds checking on operator[] violates the spec and defeats the optimization.
Not only does it an unwanted check; it also prevents inlining and thus generates
two levels of function calls where none are necessary.
The fix is trivial, but how long will it take for Microsoft to implement it, if
the bug ever makes it through their thick layer of tech support bullshit artists?
Just one of the many reasons why STL appears not to live up to the dreams of
Mr Stroustrup & friends...
*/
template<size_t BITS> int DNA_read(dna_t dna, size_t base)
{
    const size_t offset = BITS - 1;
    return (dna[base + offset] << offset) | DNA_read<offset>(dna, base);
}
template<> int DNA_read<0>(dna_t, size_t) { return 0; }

// color gene
struct colorGene_t {
    colorType_t  type;
    trapOffset_t offset;  // trap relative location
    colorGene_t() : type(empty) {} // our rats are born optimists
};

// decoded DNA
class dnaInfo_t {
private:
    const dna_t & dna;
    static const size_t
        direction_start = NUM_COLORS*(BITS_TYPE + BITS_OFFSET),
        direction_size = DNA_BITS - direction_start;

public:
    colorGene_t color[NUM_COLORS];
    int         up_down; // anti-wall-banger

    // decode constant informations during construction
    dnaInfo_t(const dna_t & d) : dna(d)
    {
        for (size_t c = 0; c != NUM_COLORS; c++)
        {
            unsigned raw = DNA_read<BITS_COLOR>(d, c * BITS_COLOR);
            color[c].type = type_decoder[raw >> 1];
            if      (color[c].type == danger) color[c].offset = raw & 7;
            else if (color[c].type == beam  ) color[c].offset = raw & 3;
        }
    }

    // update with surroundings signatures
    void update(size_t signature)
    {
        // anti-blocker
        up_down = (direction_size > 0) ? dna[direction_start + signature % direction_size] : 0;
    }
};

// map of the surroundings
class map_t {
    struct cell_t {
        coord_t pos;
        int     color;
    };

    static const size_t size = 5;
    static const int max = size / 2;
    static const int min = -max;

    size_t local_signature[size*size]; // 8 neighbours signatures for teleporters
    cell_t track_cell[size*size]; // on-track cells
    size_t cell_num;
    colorType_t map[size*size];
    size_t raw_index(int x, int y) { size_t res = x * size + y + max + max * size; assert(res < size*size); return res; }
    size_t raw_index(coord_t pos) { return raw_index(pos.x, pos.y); }

    bool is_inside(int x, int y) { return abs(x) <= max && abs(y) <= max; }

public:
    size_t compute_signatures(view_t v, dnaInfo_t genome)
    {
        cell_num = 0;
        size_t signature = 0;
        memset (local_signature, 0, sizeof(local_signature));
        int i = 0;
        for (int x = min; x <= max; x++)
        for (int y = min; y <= max; y++)
        {
            int c = v(x, y);
            if (c == -1)
            {
                (*this)(x, y) = pit; continue;
            }
            track_cell[cell_num++] = { { x, y }, c };
            signature ^= c << (4 * (i++ & 1));

            if (genome.color[c].type == beam)
            {
                int in = 0;
                for (coord_t n : moves_up)
                {
                    coord_t pn = {x+n.x,y+n.y};
                    if (!is_inside(pn)) continue;
                    int cn = v(pn.x, pn.y);
//                    if (cn == -1) continue;
                    local_signature[raw_index(pn.x,pn.y)] ^= cn << (4 * (in++ & 1));
                }
            }
        }
        return signature;
    }

    void build(dnaInfo_t genome)
    {
        coord_t traps[size*size];
        size_t t_num = 0;

        // plot color meanings
        for (size_t c = 0; c != cell_num; c++)
        {
            const cell_t& cell = track_cell[c];
            const colorGene_t& color = genome.color[cell.color];
            (*this)(cell.pos) = (color.type == beam && (local_signature[raw_index(cell.pos.x,cell.pos.y)] % 4) == color.offset)
                    ? block
                    : color.type;

            // build a list of trap locations
            if (color.type == danger)
            {
                coord_t location = cell.pos + moves_up[color.offset];
                if (is_inside(location)) traps[t_num++] = location;
            }
        }

        // plot trap locations
        while (t_num) (*this)(traps[--t_num]) = trap;
    }

    // quick & dirty pathing
    struct candidate_t {
        coord_t pos;
        candidate_t * parent;
        candidate_t() {} // default constructor does not waste time in initializations
        candidate_t(int) : parent(nullptr) { pos.x = pos.y = 0; } // ...this is ugly...
        candidate_t(coord_t pos, candidate_t * parent) : pos(pos), parent(parent) {} // ...but so much fun...
    };

    coord_t path(const neighborhood_t & moves)
    {
        candidate_t pool[size*size]; // private allocation for express garbage collection...
        size_t alloc;

        candidate_t * border[size*size]; // fixed-size FIFO 
        size_t head, tail;

        std::bitset<size*size>closed;

        // breadth first search. A* would be a huge overkill for 25 cells, and BFS is already slow enough.
        alloc = head = tail = 0;
        closed = 0;
        closed[raw_index(candidate_t(0).pos)] = 1;
        border[tail++] = new (&pool[alloc++]) candidate_t(0);
        while (tail > head)
        {
            candidate_t & candidate = *(border[head++]); // FIFO pop
            for (const coord_t move : moves)
            {
                coord_t new_pos = candidate.pos + move;
                if (is_inside(new_pos))
                {
                    size_t signature = raw_index(new_pos);
                    if (closed[signature]) continue;
                    closed[signature] = 1;
                    if ((*this)(new_pos) > empty) continue;
                    if (new_pos.x == 2) goto found_exit; // a path to some location 2 cells forward
                    assert(alloc < size*size);
                    assert(tail < size*size);
                    border[tail++] = new(&pool[alloc++]) candidate_t(new_pos, &candidate); // allocation & FIFO push
                    continue;
                }
                // a path out of the 5x5 grid, though not 2 cells forward
            found_exit:
                if (candidate.parent == nullptr) return move;
                candidate_t * origin;
                for (origin = &candidate; origin->parent->parent != nullptr; origin = origin->parent) {}
                return origin->pos;
            }
        }

        // no escape
        return moves[1]; // one cell forward, either up or down
    }

    colorType_t & operator() (int x, int y) { return map[raw_index(x, y)]; }
    colorType_t & operator() (coord_t pos) { return operator()(pos.x, pos.y); }
    bool is_inside(coord_t pos) { return is_inside(pos.x, pos.y); }
};

std::string trace_DNA(const dna_t d, bool graphics = false)
{
    std::ostringstream res;
    dnaInfo_t genome(d);
    for (size_t c = 0; c != NUM_COLORS; c++)
    {
        if (graphics)
        {
            res << "tbew--"[genome.color[c].type];
            if (genome.color[c].type == danger) res << ' ' << moves_up[genome.color[c].offset].x << ' ' << moves_up[genome.color[c].offset].y;
            if (genome.color[c].type == beam) res << ' ' << genome.color[c].offset << " 0";
            if (c != NUM_COLORS - 1) res << ',';
        }
        else switch (genome.color[c].type)
        {
        case danger: res << "01234567"[genome.color[c].offset]; break;
        case beam  : res <<     "ABCD"[genome.color[c].offset]; break;
        default: res << "!*-#X@"[genome.color[c].type]; break;
        }
    }
    return res.str();
}

coord_t hardBelievers(dna_t d, view_t v)
{
    dnaInfo_t genome(d); // decoded DNA
    map_t     map;       // the surroundings seen by this particular rodent

    // update genome with local context
    genome.update(map.compute_signatures(v, genome));

    // build a map of the surrounding cells
    map.build(genome);

    // move as far to the right as possible, in the contextually preffered direction
    return map.path(genome.up_down ? moves_up : moves_down);
}

int main() {
    time_t start = time(NULL);
    double score = runsimulation(hardBelievers, trace_DNA);
    slog << "Geometric mean score: " << score << " in " << time(NULL) - start << " seconds";
}

第四集：让我们的网格站起来

结果

Scores: 309371 997080 1488635 1 19 45832 9 94637 2893543 210750 742386 1677242 206614 111809 1 1738598 1 1 342984 2868939 190484 3354458 568267 280796 1 1 1 679704 2858998 1 409584 3823 200724 1 973317 849609 3141119 1 1987305 1 1 57105 245412 1223244 2 1603915 2784761 9 12 1 1839136 1 298951 2 14 138989 501726 1365264 308185 707440 22 772719 17342 63461 3142044 19899 3 409837 48074 3549774 138770 32833 1 1 1184121 67473 310905 1996452 4201 1701954 2799895 2041559 218816 174 433010 51036 1731159 1871641 1 23 2877765 1 127305 27875 626814 142177 2101427 167548 2328741 4 8433 2674119 2990146 466684 1 2 8 83193 388542 2350563 1 1140807 100543 1313548 31949 73117 73300 121364 1899620 1280524 1 10726 12852 7 2165 1 3 44728 2 122725 41 2 1902290 3 1 8581 70598 1148129 429767 1 112335 1931563 521942 3513722 1 2400069 1 3331469 141319 220942 205616 57033 63515 34 6 1419147 1983123 1057929 1 599948 2730727 2438494 5586 268312 1728955 1183258 95241 1537803 11 13 1157309 1750630 1 1 2690947 101211 3463501 1 258589 101615 212924 137664 19624 251591 509429 510302 1878788 1 4045925 1 21598 459159 118663 7 3606309 3 13016 17765 640403 1 72841 695439 1 135297 2380810 1 43 31516 14 1442940 1001957 95903 194951 1 238773 773431 1 1 975692 2 4990979 52016 3261784 2 413095 12 3 420624 7905 60087 760051 2702333 2572405 1 1717432 1 12 3040935 1 1 31787 60114 513777 1 3270813 9639 581868 127091 270 164228 274393 1275008 261419 597715 138913 28923 13059 1848733 2895136 7754 14 1 107592 1 3557771 2067538 147790 112677 119004 1 13791082842974 249727 838699 4067558 6 470799 695141 1 3 1 1276069 23691 831013 5 165142 1236901 1 187522 2599203 1 67179 81345 44111 2909946 94752 7 406018 991024 4 1 3 573689 6 748463 2166290 33865 670769 322844 5657 1131171 1990155 5 4536811 1785704 3226501 2030929 25987 3055355 192547 1761201 433330 27235 2 312244 13203 756723 81459 12 1 1 54142 307858 2 25657 30507 1920292 3945574 1 191775 3748702 3348794 4188197 366019 1540980 3638591 1 1840852 1 26151 2888481 112861 8 11 2 1 27231 1 74 106853 3 173389 2390495 25 1 83116 3238625 75443 1 1 2125260 1 49626 1 6 312084 159735 358268 54351 367201 2868856 5779 172554 119016 141728 3 1 6 9 1 1504011 1 168968 1868493 1 5 1 244563 2 2887999 3144375 1598674 1 1578910 45313 176469 30969 8 127652 1911075 9 1300092 224328 168752 8 1619669 292559 9090 2040459 705819 1852774 10 139217 16 1221670 355060 339599 3 2184244 2546028 1 1 11 70958 242187 1 80737 1 190246 3 1 1 577711 150064 1 1047154 3851461 92399 224270 612237 1 3 3330053 1 1 1192533 615756 267923 144724 2 1 150018 4621881 1 6 299247 115996 2 10 6 185495 76351 465554 178786 1802565 257101 56 2491615 1 24547 1 1203267 32 5741149 541203 11393 1 368082 540534 16167 113481 2004136 13045 17 1 12 333803 14 1955075 1 4 38034 1286203 2382725 26777 1 180312 1 87161 4773392 1244024 1146401 3 80598 2983715 1 63741 1 1 2561436 16 1 1 1807854 1239680 200398 2 46153 1400933 11 5058787 8787 1 98841 89162 1106459 112566 1 4138891 2858906 101835 81375 539485 6587808 1 5359988 1 1 869106 443452 120748 436156 2 2 3944932 1 1875599 2 3081185 733911 447824 1 1 23187 3082414 33 3 1 1 2053904 410824 104571 885952 1946162 2 294773 364169 1 101310 2166548 1177524 2192461 12 4 3457016 90975 2356374 573234 53746 187527 7837 1441335 458407 52139 3387239 2030900 38 1648216 215105 212589 8278 1201586 244282 1 1 1897515 3957343 46 1 134481 1 1 2041785 3 1 37593 163173 1565457 3 1026885 1 34530 4655639 2 18 1940645 1550444 593209 1 2270700 706918 1 1 610113 9 1287883 3 1472134 1998685 1916822 1 296017 2 1 1737607 4155665 1510560 553342 56130 14436 13240604 4025888 1 4253261 174177 2043316 504151 2370989 420666 155232 1 219327 3752236 130062 571247 24 1 29015 31392 1020196 3 1117502 460873 7 1 228 8 133656 1 147008 1 93471 1 1 1 513410 4834094 1 14 1875636 182714 1504903 95263 4418053 1 357853 1135536 3698641 3 239316 4237884 131730 3878724 2158931 55650 1906785 1 26372 32 99217 1645677 379838 1 450352 7329657 112909 1 897980 2114198 308917 126215 1 53839 539997 238036 2 2270000 5 2388928 1668820 519153 58227 347528 1 1 2339954 10 5 2031341 54 2341529 2189774 112731 1 21918 748662 2068921 2 2232504 2923457 97740 3858 16604 398940 388755 1875003 667810 53633 315866 839868 1 7 1 14238 185 4 14 1 2 178947 1965719 398323 120849 48 1397222 961772 34124 2 160652 1 252629 246554 14529 1 299866 135255 490837 2863773 8 10 2 1906405 57 9782 118940 870003 255097 6 4187677 50965 3354376 17611 1804789 183601 158748 1539773 116107 77684 34738 2862836 1 2081903 727739 50328 2740070 17 923524 18 3089706 3144082 1 20 205247 347420 2076952 3725220 39270 2 15 49329 422629 5 1693818 2570558 2146654 1 5 129085 653766 47438 102243 389910 59715 21769 1246783 361571 4 120502 255235 1314165 3 3 5 2902624 76351 3117137 174413 2546645 14534 166054 1013583 1 1 2 9 3027288 3173742 338261 94929 1071263 4659804 1 506576 42798 4 984508 1 4 4 1 18541 7 1 269761 188905 2 1 92011 147031 677955 27484 1291675 2420682 99970 57943 1 4081062 1 250953 704904 4 349180 4273479 30528 2092508 2352781 3700946 1 77799 328993 3684623 3930179 1250080 1975798 54981 1621677 91664 1355832 1084049 721612 56950 197563 246868 5031 1 924076 1328694 58562 1 457662 2445958 1345169 957845 1056809 2485300 1687907 199029 3 9474 86928 1 2419980 3585265 570673 1 1514184 437383 1596697 29709 199606 126031 2 1541777 1 3 2090249 2402438 15 19 1423959 28 37852 4 1652596 1 405512 52 3 1948029 1 2 376 1155902 3 631665 3741991 57673 284026 424787 1 11569 5 1200313 1 20 2360854 1 119994 3889143 673424 797763 1 1 144306 1007659 1231874 75607 1 15 66187 8763 21366 146277 2684501 4458542 162223 3 1 5 94232 3036009 401312 19775 510737 3305062 58905 125783 274094 3089988 118483 1 106213 1 1289180 127905 30 528859 2 1215596 1955900 30 2236528 218643 1 2396631 1598175 1148688 452064 1 1840394 198540 1 1307187 107463 341396 2684981 9602 536871 1 148107 4068 4918434 1 2430254 2066144 88915 3585780 6464 259394 3098337 49601 42 79205 925658 1 2513666 26817 2738302 1 28 345735 5086930 361294 505662 386194 1103890 2653001 412247 4074274 2217918 1 519433 1338570 4289317 140138 18 2519983 168656 4546204 8 1 76545 511580 979214 9318 210013 50508 40 152908 17969 922507 1 7 32 1 388579 1 49886 13319 1066048 4663 27883 38419 1418098 2538216 1 778734 3556791 490764 666880 22746 5666164 4 20 1806284 21142 1 527906 2 12417 182224 49536 105029 206917 2427623 294247 1405136 321480 354137 84225 50 128073 1391176 352835 26074 91159 34229 237942 1 1519676 1 2428669 272681 148689 528951 560736 1 3548197 3833513 1438699 286613 1 1290904 47145 3456135 249648 277045 1012397 271073 1 6 149276 94843 11 177134 32336 2772732 7 22 37065 1 105299 76735 44 2211334 511942 30639 522056 5162 1899842 74 1 1448039 1 88817 21 1027532 555416 1 364383 1335609 167332 283252 49564 220972 1006800 3108886 801258 265596 61651 1 2413276 252747 416606 960925 54 311956 267135 3871698 22581 8978 2 10 1966155 3123429 28 46409 1 18433963725323 1769396 114766 49071 1 1 4228762 3483932 1139490 602592 2700468 770273 3 1 1 212087 281247 27093 156094 286299 1204001 18374 1 330780 1 1 25384 906728 99334 1250819 2161201 34 1027892 1 33449 2 129787 52246 94872 1536841 23470 1 1700323 1 1 3785351 1 95315 1014155 56570 22586 66842 7 156840 48752 1 3143722 1 1168309 2 4 101423 385892 42868 2893851 7 1783109 217499 24 460497 2003214 180135 3503010 131137 2 5240 1621601 2754811 11198 1 1 1105643 1 1671021 3 139611 18268 107229 44582 2211034 1 2880152747163 231008 262504 1 257760 1 1 52992 804418 2 2 4811272 1772250 3 1796530 1918647 1 1934549 1 100550 3448657 1681262 3 604526 320865 1901079 556908 2794800 2472000 637735 123663 1 3213187 118199 2553610 1 1750628 2563806 1 1670872 1 999609 50200 654831 1 164612 2865759 1841739 9 3744159 1331395 3202501 1 7 1 1 239868 1 1 581984 112413 401 1 29656 359367 74532 27226 51752 2583 1 645443 1559731 1 114195 1 85473 229474 111353 1 1521653 1 2568733 444398 2593568 18546 1 158085 1211147 1020006 23407 42514941388799 158442 1 1660358 5 34874 1594789 1551270 386464 502417 32280 170606 1954278 72486 3406066 11 52896 345631 4010742 33307 1951926 1441325 1886066 1 3 402778 3089364 351 28028 4301364 1 431569 5 3054030 375986 404966 1 449317 1230292 1 7 763949 1 2 3197443 1537806 335317 2 1 161263 1 1959902 1664530 139136 447570 1 1 50 158825 222939 1842131 11252 1680094 1017889 71 144808 1 53679 1 41278 1226724 1 1 2 10 2 1 112451 42133 1406662 1 112593 2 2832116 1544488 3579017 3029492 2752014 6 255091 731329 540861 1 426725 440330 212602 202358 173553 4 1189793 11031 84073 2084554 3963 1473295 1 642570 1 1423688 34509 75056 163273 490193 3200250 451777 157797 4156542 2386299 2794795 2735308 1332758 1193296 1131014 1001570 414257 4415511 4 3 1 3499595 536583 16731 93839 92382 1 45890 1 17695 8 867246 18 1607123 3197052 5 40009 1 329895 3497309 2416600 2316390 11 118179 2166659 2 136426 76762 2 14 2 3632525 214889 6 3900942 270409 230143 120414 417489 16706 1563597 31418 2 73 468763 88585 428274 3537347 2 1 491461 2806485 1 7 2950804 115684 4 1 429002 85771 2480 285541 186486 1 1 2430862 6 9 4 1833423 17143 353689 2568741 408890 2929237 208679 2198380 1 2501053 1933666 180843 1 1 2569886 1 17035 3449472 71357 246257 217898 1 47601 589824 401679 362878 13178 34464 1076419 1 554417 1 21248 2136449 1068 23029 8 766649 4 302879 274751 19 1 390259 1899931 233910 1392272 184492 2 2752059 55813 1 6 64674 205205 595508 1714309 582492 4821971 63973 1708726 189200 4548446 479425 2866037 1 1 1 2139319 1 1 3 1572621 2086152 2341038 1 619612 1 78942 772466 18932 1404368 936790 2263929 230200 3009227 251065 835010 88225 642856 824193 5559048 1 36348 2338046 481447 108132 2728223 3539009 1 197164 181408 171634 2172263 2317332 1598340 1318829 1746303 7 59657 1 1415452 122924 915828 1063890 40339 430186 4 2165185 2250922 704568 85138 4417453 255 326360 33541 3 49759 72127 912537 599665 1 29169 168741 349838 996835 1548193 2 28449 803521 4 2 2 3359043 3243259 1 491574 1675000 186105 3203018 11 39127 959876 334480 873131 70262 137080 1076591 1 2155613 74804 893022 2473922 1 1 269835 5 2407308 3 55200 905207 1 1 1245609 65934 7 1372126 530582 1383562 1 1 2718341 1 3947638 4 76837 412551 11 1 1 1208080 3024670 277 46485 1 9 562183 46 2985858 3379885 67816 1896527 1 105478 2035453 3026415 1 189256 2992616 2098002 1099666 775250 5913 13 406948 166773 1 322250 41919 480047 64950 17435 2147428 2336270 3330243 352709 86029 1398723 106236 312951 1 408211 252689 847088 2 17 34088 13128 187366 2 1559482 2349010 1651122 2371088 401005 1715445 1 29483921 1464444 50228 2365851 1651636 768715 226704 23677 83501 1 252623 444628 34 3640316 3602127 45369 1 1 1978261 1 3019189 1 25411 2177552 192839 191146 293712 3840622 182598 4069200 175757 1 2250458 4 1 7 2740824 2753005 1 2836428 1 12 19 2 1788326 3302198122211 3386546 1176663 20847 28 1194294 794665 2630378 13624 722012 2273872 1549353 1 3 1735700 1668388 416 970581 258382 295427 1 121571 3193610 3764806 1 368985 20436 89411 3 16130 2 241879 1 2996216 136958 2382095 510146 1762872 1372194 4215387 346915 4423 1 904153 2004500 248495 836598 3529163 27 2547535 1424181 1885308 1 1056747 289743 176929 2299073 170473 1 1 839941 12382 51457 608526 1684239 4843522 34550 929855 2767014 2979286 1 340808 184830 131077 57298 63854 381689 201998 1715328 118687 69190 123466 1 2 69392 159797 382756 1513430 2506318 457 1
Geometric mean score: 10983.8 in 31214 seconds

我切换到g ++ / MinGW和3个线程。
GNU生成的代码的速度是Microsoft的两倍以上。
难怪，令人震惊的STL实现会带来什么。

传送器

传送效应是高度依赖位置的。直到现在，我还是很高兴将传送器视为好（总是被视为空白空间）或总是坏（被当作墙壁，因此没有啮齿动物可以接受）。

这个模型太粗糙了。
给定的传送器可以将老鼠向前推进，直到离目标只有几个格，但是一旦到达该传送器，它就可以将老鼠从板上抛下。
这样的传送器很可能会被认为是合格的（因为它提高适应性的速度比“步行”到相同的x位置时更快），成为显性基因组的一部分，并杀死几乎所有将其视为“永远安全”的大鼠。
由于老鼠无法知道它们的X位置，因此检测这些诡tele的传送者的唯一解决方案是基于唯一可用的上下文数据（即5x5彩色网格）来决定是否踩踏它们。

为此，我定义了4种颜色基因：

• 危险陷阱探测器
• 在轨道上的任何地方都是空的
• 禁止在赛道上的任何地方封锁
• 根据周围环境，光束被视为空的或块状的

这样做的目的是通过查看其紧邻的8个邻居来区分其。由于在给定位置拥有8个相同邻居的可能性非常低，因此应该可以识别每个传送器的唯一实例。

可以将8种相邻颜色组合起来以形成局部签名，该局部签名对于迷宫中的位置是不变的。不幸的是，只有位于3x3视野内部正方形内的单元格才可见8个邻居，因此在视野边缘上的签名将不准确。
尽管如此，这将为我们提供附近社区的恒定上下文信息，这足以增加成功驾驭瞬移传送带的可能性。

梁基因具有2位可变字段。
对于给定的传送器本地签名，有四分之一的机会将波束单元视为不可通过。该字段的每个值都选择这四种可能性之一。
结果，这两个位上的波束基因突变将循环显示该颜色的4种可能的上下文指示。

此外，最重要的颜色仍然是墙壁和陷阱。这意味着只有在老鼠知道墙壁和陷阱的位置之后，才应允许进行传送传送带检测。

这是通过仅少量更新本地签名来完成的。当前更新本地签名的标准是在被识别为潜在隐形传送带的颜色附近。

编码每个颜色基因使用5位，并对类型进行分组以释放3个较低有效位以编码0..7值：

• 4危险
• 4空
• 4块
• 4光束

每个波束基因有1/4的机会被视为一个区块，有3/4的机会被视为是空的，因此4个波束平均代表1个区块，而3个代表空的。

因此，由16种颜色的随机分布表示的平均比例为：

• 4危险
• 7空
• 5块

到目前为止，这种混合似乎提供了最好的结果，但是我还没有完成调整。

基因变异

可以肯定的是，选择用来代表基因类型的代码值很关键。取反两个值可能要花费2000点或更多。

在此再次说明其原因超出了我的数学范围。

我的猜测是，必须平衡从一种类型到另一种类型的突变的概率，否则，就像在Markow矩阵中一样，累积概率倾向于将值限制为具有最高传入转换概率的子集。

救援之路

路径设置将显着减少访问单元的数量，从而仅测试最有可能达到目标的单元。因此，不仅避免了一些频繁的死角，而且更容易在早期发现错误的颜色代码。
结果，收敛时间大大减少。

但是，这无助于解决基因组无法正确显示轨迹的图谱。

白痴怎么办？

在视觉上看了看赛道之后，我理解了为什么即使在前面似乎只有墙的情况下也尝试前进的默认策略确实比抑制前进更好。
“墙壁”实际上可能是传送器，会产生许多不幸的结果，以致基因组将它们映射为永不踩踏的障碍，但在极少数情况下，这种顽皮的传送器的特定情况会产生积极的（或至少非致命的）影响，因此采取行动而不是后退增加了找到胜利之路的机会。

早期收敛

在我看来，突变率有点低（至少对我的啮齿动物而言）。

当前的0.01设置使DNA完整存活突变过程的机会为37％。将参数更改为0.0227可以将该概率降低到大约10％

神秘的公式是P _1位突变 = 1-P _{完整基因组完整}^1/100，其中100是基因组位长。

例如，对于10％的概率，P _1位突变 = 1 - 0.1 ^1/100 = 0.0277
为5％的概率，P = 1 - 0.05 ^1/100 = 0.0295
反相式中，我们发现，0.01给出的是一个37分％的机会不变。

我以10％的概率重新运行了完全相同的测试（使用固定顺序的随机种子）。
在许多地图上，以前的失败变成了（有限的）成功。另一方面，大量的人口爆炸却更少了（这具有大大加快计算速度的有趣副作用）。
即使非常高的分数（超过一百万）并不常见，但成功的跑步次数却足以弥补。
最后，平均数从1400+上升到大约2000。

相反，将P设置为5％则产生的平均值约为600。
我认为突变率是如此之高，以致于获胜大鼠的基因组过于频繁地转化为效率较低的变异体。

这是怎么工作的

使用增加的传送器检测器，失败的游戏数量（得分<10）显着下降。
在2000年的运行试验中，只有1/3的失败。
几何平均数仅从2900上升到3300，但是这个数字不能反映出这种改善。

空色经常被猜为是光束和危险（通常是2到5）。基因组“使用”这些颜色来阻止可能招致老鼠麻烦的路径。

基因组非常擅长猜测陷阱（即一旦老鼠能够达到目标，大约90％的时间就会猜出代表实际陷阱检测器的颜色）。
它也为传送者使用了新的光束代码，尽管这种情况更为罕见（可能是因为“奸诈”的传送者比陷阱更不常见，并且其他光束/危险颜色也逐渐发展为阻塞了通往这些叛徒最后一幕的道路）。

从获胜的基因组经过5000转或更多转会出现的游戏数量来看，我认为这种新品种将从突变率提高中受益匪浅。

ColorScorePlayer，初步得分≈22

您是挑战赛中在GIF中工作的机器人。

这是我们在整个开发阶段的测试机器人。它使用基因组来存储16种颜色中每种颜色的质量得分。然后，它向前移动，将其移动到得分最高的颜色上（从不移动到-1）。如果出现平局，则在绑定单元之间随机选择一个动作。

我们已将此播放器移植到所有控制器语言中，因此它充当了如何使用它们的示例：

蟒蛇

class ColorScorePlayer(Player):
    def __init__(self):
        Player.__init__(self)
        self.coords = [Coordinate( 1, 0),
                       Coordinate( 1,-1),
                       Coordinate( 1, 1)]
        self.n_moves = len(self.coords)

    def turn(self):
        max_score = max([self.bit_chunk(6*self.vision_at(c.x, c.y), 6) for c in self.coords if self.vision_at(c.x, c.y)>=0])
        restricted_coords = [c for c in self.coords if self.vision_at(c.x, c.y)>=0 and self.bit_chunk(6*self.vision_at(c.x,c.y), 6) == max_score]

        return random.choice(restricted_coords)

红宝石

class ColorScorePlayer < Player
    def initialize(rng)
        super(rng)
        @coords = [Vector2D.new( 1,-1),
                   Vector2D.new( 1, 0),
                   Vector2D.new( 1, 1)]
    end

    def vision_at(vec2d)
        @vision[vec2d.x+2][vec2d.y+2]
    end

    def turn
        max_score = @coords.map { |c|
            color = vision_at(c)
            color < 0 ? -1 : bit_chunk(6*color, 6)
        }.max

        restricted_coords = @coords.select { |c|
            color = vision_at(c)
            color >= 0 && bit_chunk(6*color, 6) == max_score
        }

        restricted_coords.sample(random: @rng)
    end
end

C ++

coord_t colorScorePlayer(dna_t d, view_t v) {
    const int chunklen = DNA_BITS / N_COLORS;
    int ymax[3], nmax, smax = -1;
    for(int y = -1; y <= 1; y++) {
        if(v(1, y) == OUT_OF_BOUNDS) continue;
        int score = dnarange(d, v(1, y)*chunklen, chunklen);
        if(score > smax) {
            smax = score;
            nmax = 0;
        }
        if(score == smax) ymax[nmax++] = y;
    }
    return {1, ymax[v.rng.rint(nmax)]};
}

C＃

public static void ColorScorePlayer(GameLogic.IView v, GameLogic.IGenome g, Random rnd, out int ox, out int oy)
{
    ox = 0;
    oy = 0;

    var max_score = cspcoords.Where(c => v[c.x, c.y] > -1).Select(c => g.cutOutInt(6 * v[c.x, c.y], 6)).Max();
    var restrictedCoords = cspcoords.Where(c => v[c.x, c.y] > -1 && g.cutOutInt(6 * v[c.x, c.y], 6) == max_score).ToArray();

    Coord res = restrictedCoords[rnd.Next(restrictedCoords.Length)];

    ox = res.x;
    oy = res.y; 
}

爪哇

package game.players;

import java.awt.*;
import java.util.Map;

public class ColorScorePlayer extends Player{
    private static final Point[] possibleMoves = {new Point(1, 0), new Point(1, -1), new Point(1, 1)};

    @Override
    public Point takeTurn(String genome, Map<Point, Integer> vision) {
        int chunkLength = genome.length()/16;
        int maxSum = -1;
        Point maxSumMove = possibleMoves[0];
        for (Point move: possibleMoves){
            if (vision.get(move) == -1){
                continue;
            }
            int initialPoint = chunkLength*vision.get(move);
            int sum = 0;
            for (int i = initialPoint; i < initialPoint + chunkLength; i++){
                sum = (sum<<1)+Integer.parseInt(genome.charAt(i)+"");
            }
            if (sum > maxSum){
                maxSum = sum;
                maxSumMove = move;
            }
        }
        return maxSumMove;
    }
}

球员得分相当不一致。这是50次随机运行：

Scores: 1 1 1132581 3 43542 1 15 67 57 1 11 8 623162 1 1 1 134347 93198 6 1 2 1 1 245 3 1 1 27 1 31495 65897 9 5 1 2 20 2 117715 1 1 1 20 64616 5 38 1 2 1 2 12

ColorFarSeeker，C ++≈74.7

如果您尝试的话，这一挑战确实非常有趣且简单。

不要被冗长的描述所困扰。
只需访问GitHub并检查一下...一切将变得更加清晰！:)

强烈建议使用C ++模拟器以提高速度。即使在我将python程序转换为C ++之后，python模拟仍然没有停止。

这是ColorScorePlayer的改进版本。为了充分利用其5x5视图，它考虑使用加权函数从其移动2步。向前移动1步具有较高的权重，因为它们对生存率具有更直接的影响。将前进2步的重量较小。

尝试向前移动，但是如果看不到安全移动...则尝试侧向...如果其他所有方法均失败，则随机向后移动。

coord_t colorFarSeeker(dna_t d, view_t v) {
#define s(w,x,y) (v(x,y)>-1?((b+dnarange(d,l+m+n*v(x,y),n))*w):0)
#define max2(a,b) (((a)>(b))?(a):(b))
#define max3(a,b,c) (max2(a,max2(b,c)))
#define push(vec,maxScore,score,x,y) if(score==maxScore&&v(x,y)>-1)vec.push_back({x,y});
#define tryReturn() if(vec.size()){return vec[v.rng.rint((int)vec.size())];}vec.clear();

    // Some constants to tweak
    int k = 4;
    int l = 3;
    int m = dnarange(d, 0, l);
    int n = 4;
    int b = dnarange(d, l, k) + 10;

    std::vector<coord_t> vec;

    // Looks forward for good moves...
    int upRightScore = s(1,0,-2) + s(1,1,-2) + s(1,2,-2) + s(5,1,-1);
    int forwardScore = s(1,2,-1) + s(1,2,0) + s(1,2,1) + s(5,1,0);
    int downRightScore = s(1,0,2) + s(1,1,2) + s(1,2,2) + s(5,1,1);
    int maxForwardScore = max3(upRightScore,forwardScore,downRightScore);
    push(vec,maxForwardScore,upRightScore,1,-1);
    push(vec,maxForwardScore,forwardScore,1,0);
    push(vec,maxForwardScore,downRightScore,1,1);
    tryReturn();

    // Looks sideways for good moves...
    int upScore = s(1,-1,-2) + s(1,0,-2) + s(1,1,-2) + s(5,0,-1);
    int downScore = s(1,-1,2) + s(1,0,2) + s(1,1,2) + s(5,0,1);
    int maxSideScore = max2(upScore,downScore);
    push(vec,maxSideScore,upScore,0,-1);
    push(vec,maxSideScore,downScore,0,1);
    tryReturn();

    // If all else fails, move backwards randomly.
    // I have tried considering the scores of backmoves,
    // but it seems worse than just randomly moving backwards. 
    vec.push_back({-1,-1});
    vec.push_back({-1,0});
    vec.push_back({-1,1});
    return vec[v.rng.rint((int)vec.size())];

}

得分：

相当多的1 ...当您看到控制台彼此后退1时，这可能有点令人沮丧。就像一个拥有生活必需品的星球，但没有先进的老鼠文明的迹象...
然后偶有高峰。:)

嗯...显然我很幸运，因为我进行了第一批跑步，获得了300+的几何图形。分数确实确实有很大的波动。但是无论如何，随着模拟器的运行次数增加，它可能会接近≈74。

我的跑步成绩：6 6 53 1 5 101223 89684 17 2 303418 4 85730 24752 1 1 1 3482515 39752 1 59259 47530 13 554321 1 563794 1 1770329 1 57376 1 123870 4 1 1 79092 69931 594057 1 69664 59 1 6 37857 1733138 55616 2 1 51704 1 254006 4 24749 1 117987 49591 220151 26 4292194 23 57616 72 67 1 4 308039 1 1 103 89258 1 286032 1 5 3 1 5 114851 46 143712 5 15 9 80 7425 1 1 7 1 108379 70122 97238 1 1 5 2 23 104794 1 10476 59245 1 204 1 1 12 1 29641 1 314894 18785 13 1 3 1 1 1 1 2 526001 1 1 1 1 27559 29285 3 3 128708 70386 30 2 2 1 208531 331 1 2 1 61 114993 1 15 51997 1 2 1 146191 1 31 4 3 1 161422 207 1 64 1 1 1 68594 145434 87763 150187 169 185518 1 1 1 1 24208 2570 1 1 537 1 1 462284 1 2 55 1 1 1 214365 1 40147 2 213952 1 29 3 1 2144435 5 4502444 72111 1 1 1 1 1 774547

Bishop-Python，初步得分1.901

主教总是沿对角线移动，因此在给定的全途跋涉中无法到达一半的棋盘，但这确实意味着要编码的潜在动作更少，因此基因组的每个位都可以代表一个动作（主教永不退缩）。根据样本前面（右侧）的3x3正方形块确定要指的是哪一位。在给定情况下，最好的举措就是只有一次突变。

该机器人起初学习速度很快，但是在到达终点之前经常碰上顶峰，大概是以下两个问题之一发生的地方：

• 电路板的两个或更多部分映射到同一位，但需要不同的移动。
• 某些板不能仅通过对角线移动来通过。

码

class BishopPlayer(Player):
    def __init__(self):
        Player.__init__(self)
        self.coords = [Coordinate(1,-1),
                       Coordinate(1, 1),
                       ]
        self.inputs = [(x,y) for x in (0,1,2) for y in (-1,0,1)]

    def turn(self):
        # Move away from out of bounds areas
        if self.vision_at(0,-1) == -1:
            return self.coords[1]
        if self.vision_at(0,1) == -1:
            return self.coords[0]

        # Move right, and either up or down based on one bit of the genome
        bit_to_use = sum(self.vision_at(self.inputs[i][0],
                                        self.inputs[i][1]
                                        ) * (16 ** i) for i in range(9)
                         ) % 100
        return self.coords[self.bit_at(bit_to_use)]

尽管有这些限制，主教在极少数情况下还是表现出色，每个标本都在木板上完成了几圈。我曾想过，在给定的一圈中，一个标本只能在棋盘的一半上移动（仅相当于国际象棋棋盘上的黑色方块或白色方块）。但是，正如MartinBüttner指出的那样，传送器可以将标本从黑色正方形移动到白色正方形，反之亦然，因此在大多数板上都不受限制。

（有两对匹配的传送器类型，每对都有0.5的偏移概率，可将样本移动到黑色和白色正方形的另一半。因此，板中只有传送器将样本限制为一个的概率每圈一半的木板只有0.25。）

得分显示，偶尔的胜利穿插在很长一段时间内未能达到终点：

分数：1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11 1 2 1 1 1 1 1 6 1 8 1 10 15 1 1 12544 1 2 1 1 1 1 1 3 7554 1 1 1 1 1

红利玩家：几何平均值50.35（5000游戏测试）

该机器人根据DNA的6位片段（例如颜色得分播放器），通过正方形的颜色对正方形进行评分，但是编号系统不同。该机器人的动机是，一个位将得分的值更改为32，而另一位仅将其更改为1，这是相当随意的。它将值n（n + 1）/ 2分配给n个连续的1位。另外，它添加了一种随机化机制，以防止卡住。它将以30分之一的机会随机向前移动。

为了进行比较，在两次1000次游戏测试中，颜色得分玩家得分为30到35。有趣的是，颜色得分玩家的最高游戏分数在3-5百万范围内，而奔跑奖金的最高分数仅为20万。通过更一致地获得非零分数，运行奖金受益于对数平均评分系统。

在C ++控制器上使用6个线程运行5000个游戏大约需要20分钟。

coord_t runbonus(dna_t d, view_t v) {
    int ymax[3], nmax, smax = -1;
    if(!v.rng.rint(30)) {
        int y;
        while(!~v(1, y = v.rng.rint(-1, 1)));
        return {1, y};
    }
    for(int y = -1; y <= 1; y++) {
        if(v(1, y) == OUT_OF_BOUNDS) continue;
        int score = 0;
        int streak = 0;
        for(int i = 0; i < 6; i++) {
            if(d[6*v(1,y) + i])
                score += ++streak;
            else
                streak = 0;
        }
        if(score > smax) {
            smax = score;
            nmax = 0;
        }
        if(score == smax) ymax[nmax++] = y;
    }
    return {1, ymax[v.rng.rint(nmax)]};
}

StarPlayer | C ++ | 得分：162（基于500场比赛）

该玩家尝试使用A *寻找最佳前进方式。它以与ColorScorePlayer相同的方式分配权重，并尝试将其寻路到视图的右边缘。该实现不是我做过的最漂亮的事情，但至少并不太慢。

#include <utility>

#define IDX(a,b) a[VIEW_DIST + b.x][VIEW_DIST + b.y]

std::pair<coord_t,int> planAhead(int weights[N_COLORS], view_t &v, coord_t target) {
    bool open[VIEW_DIST*2+1][VIEW_DIST*2+1] = {false};
    bool closed[VIEW_DIST*2+1][VIEW_DIST*2+1] = {false};
    int f_score[VIEW_DIST*2+1][VIEW_DIST*2+1] = {0};
    int g_score[VIEW_DIST*2+1][VIEW_DIST*2+1] = {0};
    coord_t came_from[VIEW_DIST*2+1][VIEW_DIST*2+1] = {{0,0}};
    open[VIEW_DIST][VIEW_DIST] = true;
    g_score[VIEW_DIST][VIEW_DIST] = v.rng.rint(5);
    f_score[VIEW_DIST][VIEW_DIST] = (abs(target.x) + abs(target.y)) * 10;
    for (;;) {
        coord_t current{VIEW_DIST+1,0};
        for (int x = 0; x < (VIEW_DIST*2+1); x++)
            for (int y = 0; y < (VIEW_DIST*2+1); y++)
                if (open[x][y] && (current.x > VIEW_DIST || f_score[x][y] < IDX(f_score,current)))
                    current = {x - VIEW_DIST, y - VIEW_DIST};
        if (current.x > VIEW_DIST)
            return {{1,0}, 1000000};
        if (current.x == target.x && current.y == target.y)
            break;
        IDX(open,current) = false;
        IDX(closed,current) = true;
        for (int dx = -1; dx <= 1; dx++) for (int dy = -1; dy <= 1; dy++) {
            if (dx == 0 && dy == 0)
                continue;
            coord_t tentative{current.x + dx, current.y + dy};
            if (abs(tentative.x) > VIEW_DIST || abs(tentative.y) > VIEW_DIST)
                continue;
            if (IDX(closed,tentative))
                continue;
            auto color = v(tentative.x, tentative.y);
            if (color == OUT_OF_BOUNDS)
                continue;
            auto tentative_g = IDX(g_score,current) + weights[color];
            if (!IDX(open,tentative) || tentative_g < IDX(g_score,tentative)) {
                IDX(came_from,tentative) = current;
                auto distance = abs(tentative.x - target.x) + abs(tentative.y - target.y);
                IDX(f_score,tentative) = tentative_g + distance * 10;
                IDX(g_score,tentative) = tentative_g;
                IDX(open,tentative) = true;
            }
        }
    }
    auto prev = target, current = target;
    while (current.x != 0 || current.y != 0)
        prev = current, current = IDX(came_from,current);
    return {prev, IDX(g_score,target)};
}

coord_t starPlayer(dna_t d, view_t v) {
    const int chunklen = DNA_BITS / N_COLORS;
    int weights[N_COLORS];
    for (int i = 0; i < N_COLORS; i++)
        weights[i] = dnarange(d, i*chunklen, chunklen);
    std::pair<coord_t,int> choice{{1,0}, 1000000};
    for (int y = -VIEW_DIST; y <= VIEW_DIST; y++) {
        auto plan = planAhead(weights, v, {VIEW_DIST, y});
        if (plan.second < choice.second)
            choice = plan;
    }
    return choice.first;
}

样本分数：

4 92078 1 10 1 1 3 2 2862314 5 24925 1 3 2 126502 1 24 1097182 39 1 1 1 47728 227625 137944 15 1 30061 1 1 1 3171790 19646 10 345866 1 1 1 829756 425 6699 22 8 1 1 6 6 104889 125608 1

WallGuesser-在1000游戏测试中得分113.266

编码方式

我做了一个非常简单的6位/颜色编码。解码颜色[n]

• 将基因组中的第n个位相加，总计为96
• 如果总分> = 4，则说该方块被遮挡了
• 如果总分<= 4，则其最终得分为其总分的2 ^

通过将一种颜色的位散布到整个基因组中，我增加了将两个亲本的位用于每种颜色的机会。

运动

我使用（我肯定不太高效）基于A *的搜索来寻找成本最低的通往任何右边缘正方形的路径。如果颜色映射到“已阻止”，则搜索将永远不会输入该颜色。如果搜索找不到路径，则假定该老鼠不适合繁殖，并通过向左移动一只老鼠来结束它。

减少不健康大鼠的数量

由于我的基因组有效地猜测了哪些正方形是墙壁或向后的传送者，所以没有猜测（没有颜色映射到被阻止的）的老鼠不太适合。要尝试删除这些老鼠，如果没有颜色将被标记为阻塞，则将每种颜色标记为阻塞，并且老鼠将始终向左移动一只。

去做

目前，行为尚无随机性，因此老鼠很容易被卡住。

#include "./gamelogic.cpp"

#include <algorithm>
#include <set>
#include <map>
#include <climits>

bool operator< (const coord_t &a, const coord_t &b){
    if(a.x != b.x){ return a.x < b.x; }
    else if (a.y != b.y){ return a.y < b.y; }
    else{ return false; }
}

bool operator== (const coord_t &a, const coord_t &b){
    return (a.x == b.x) && (a.y == b.y);
}

int coordDistance(const coord_t &a, const coord_t &b){
    int xDif = abs(a.x - b.x);
    int yDif = abs(a.y - b.y);
    return xDif > yDif ? xDif : yDif;
}

int coordMinSetDistance(const coord_t &a, const std::set<coord_t> &ends){
    int min = INT_MAX;
    for (auto i : ends){
        int cur = coordDistance(a, i);
        if (cur < min){
            min = cur;
        }
    }
    return min;
}


class ColorMap{
public:
    view_t *v;
    int colors[16] = {};
    const int Blocked = -1;

    ColorMap(dna_t &d, view_t *v){
        this->v = v;

        //Decode the genome
        for (int i = 0; i <= (16*6); i++){
            if (d.at(i) == true){
                colors[i % 16]++;
            }
        }

        //Encode the result
        bool guessedWalls = false;
        for (int i = 0; i < 16; i++){
            if (colors[i] >= 4){
                colors[i] = Blocked;
                guessedWalls = true;
            }
            else{
                colors[i] = pow(2, colors[i]);
            }
        }

        if (guessedWalls == false){
            for (auto i : colors){
                i = Blocked;
            }
        }
    }

    int operator() (coord_t pos){
        if (abs(pos.x) > VIEW_DIST || abs(pos.y) > VIEW_DIST){
            return Blocked;
        }

        int value = (*v)(pos.x, pos.y);
        if (value == OUT_OF_BOUNDS){
            return Blocked;
        }
        else{
            return colors[value];
        }
    }

    void print(){
        int lower = -1 * VIEW_DIST;
        int upper = VIEW_DIST;
        for (int y = lower; y <= upper; y++){
            for (int x = lower; x <= upper; x++){
                std::cout << std::setw(3) << this->operator()({ x, y });
            }
            std::cout << std::endl;
        }
    }
};

class node{
public:
    coord_t pos;
    coord_t cameFrom;
    int gScore;
    int minDistance;

    node(coord_t pos, coord_t cameFrom, int gScore, int minDistance){
        this->pos = pos;
        this->cameFrom = cameFrom;
        this->gScore = gScore;
        this->minDistance = minDistance;
    }

    int fScore() const{ return gScore + minDistance; };

    bool operator< (const node &rhs) const{ return fScore() < rhs.fScore(); }
};

class EditablePriorityQueue{
private:
    //This is reversed so smallest are on top
    struct lesser{
        bool operator()(node *a, node *b) const{
            return (*b) < (*a);
        }
    };

    std::vector<node*> queue; // Use heap functions to maintain the priority queue ourself
    std::map<coord_t, node*> members;

public:
    EditablePriorityQueue(){};

    ~EditablePriorityQueue(){
        for (auto &m : members){
            delete m.second;
        }
    }

    bool empty(){ return members.empty(); }

    node *top(){
        auto top = this->queue.front();
        std::pop_heap(queue.begin(), queue.end(), lesser());
        queue.pop_back();
        members.erase(top->pos);
        return top;
    }

    void set(coord_t target, coord_t cameFrom, int gScore, int minDistance){
        auto targetLocation = members.find(target);

        //If the target isn't a member add it
        if (targetLocation == members.end()){
            auto *newNode = new node(target, cameFrom, gScore, minDistance);
            queue.push_back(newNode);
            std::push_heap(queue.begin(), queue.end(), lesser());
            members[target] = newNode;
        }
        //The target must be updated
        else{
            auto currentNode = targetLocation->second;
            if (currentNode->gScore > gScore){
                currentNode->gScore = gScore;
                currentNode->cameFrom = cameFrom;
                std::make_heap(queue.begin(), queue.end()); //More efficient way to do this?
            }
        }
    }
};

std::pair<coord_t, int> pathCost(ColorMap &m, coord_t start, const std::set<coord_t> &ends){
    EditablePriorityQueue openSet;
    std::set<coord_t> closedSet;
    std::map<coord_t, coord_t> cameFrom;

    openSet.set(start, start, 0, coordMinSetDistance(start, ends));
    while (openSet.empty() == false){
        auto current = openSet.top();
        closedSet.insert(current->pos);
        cameFrom[current->pos] = current->cameFrom;

        //Check if we're done
        if (ends.count(current->pos) != 0){
            //Recover the path
            coord_t path = current->pos;
            int finalScore = current->gScore;
            delete current;
            while (!(cameFrom[path] == start)){
                path = cameFrom[path];
            }

            return{ path, finalScore };
        }               

        //Examine current's neighbours
        for (int x = -1; x <= 1; x++) for (int y = -1; y <= 1; y++){
            coord_t neighbour = { current->pos.x + x, current->pos.y + y };

            if (x == 0 && y == 0){ continue; }

            closedSet.count(neighbour);
            if (closedSet.count(neighbour) != 0){ continue; }

            int neighbourScore = m(neighbour);
            if (neighbourScore == m.Blocked){ continue; }

            int tentativeScore = current->gScore + neighbourScore;
            openSet.set(neighbour, current->pos, tentativeScore, coordMinSetDistance(neighbour, ends));

        }
        delete current;
    }

    return{ { -1, 0 }, INT_MAX }; //Try to end it
}

coord_t myPlayer(dna_t d, view_t v) {
    auto ourMap = ColorMap(d, &v);

    std::set<coord_t> edges;
    for (coord_t edge = { VIEW_DIST, -1 * VIEW_DIST }; edge.y <= VIEW_DIST; edge.y++){
        edges.insert(edge);
    }

    //Move to the neighbor closest to a square on the right
    auto result = pathCost(ourMap, { 0, 0 }, edges);
    auto minMove = result.first;

    return minMove;
}

int main() {
    slog << "Geometric mean score: " << runsimulation(myPlayer) << std::endl;
}

最出色-几何平均得分：〜922（2K跑步）

我的方法是：

1. 找出杀死该物种的原因并定义所需的行为（功能性）
2. 在代码中实现所需的行为（技术）
3. 给它一个优先事项。它比其他期望的行为重要还是重要？
4. 通过调整解决方案的参数来优化几何平均得分。

我用相同的50个种子测试了2000多个参数。选择最有前途的组合，并使用250颗相同的种子进行评分，等级最高的组合将用于下一轮测试。因此，我设法创建了一种遗传算法，以根据用户mbomb007的建议为该问题找到最佳的遗传算法。。

所需的行为：

1. 该物种应了解哪些颜色是安全的，哪些不好。
2. 该物种应主要根据前面的3个单元格决定其移动的位置，但是如果没有好的移动可用，则垂直移动或向后移动则应考虑
3. 该物种还应该寻找超越他周围的8个细胞的并将其用于决策信息中
4. 该物种应学会识别陷阱。
5. 一些物种错误地认为墙壁是好的，并试图一直向它们移动，因此卡在墙壁的前面。如果他们是当时优胜劣汰分数最高的物种，他们对壁的错误假设的DNA将被复制多次进入新生儿。一段时间后，所有物种都被困在墙前，没有一个达到得分目标。如何制止白痴？

数据存储方式：

我们希望物种学习事物，适应其环境并成为最适者。如果学习内容可以某种方式存储，那么这不可避免地起作用。学习内容将被“存储”在100个DNA位中。这是一种奇怪的存储方式，因为我们无法更改 DNA的价值。因此，我们假设 DNA已经存储了坏运和好运的信息。如果对于某个物种正确的信息存储在其DNA中，他将快速前进并利用其DNA产生许多新物种。

我发现几何平均分数对信息的存储方式很敏感。假设我们读取了100位DNA的前4位，并将其存储在整数变量中。我们可以通过几种方式做到这一点：

1. 十进制数据存储：通过使用“内置” dnarange功能，例如：4位1011将变为“ 1x2 ^ 3 + 0x2 ^ 2 + 1x2 ^ 1 + 1x2 ^ 0 =15。可能的值（4位）：[0，1 ，2、3、4、5、6、7、8、9、10、11、12、13、14、15]
2. 条纹数据存储：通过使用dnaStreakRange函数（定义如下），例如：4bits 1011将变为1x1 + 0x1 + 1x1+ 1x2 = 4。可能的值（4位）：[0，1，2，3，6，10]

int dnaStreakRange(dna_t &d, int start, int chunklen) {
    int score = 0;
    int streak = 0;
    for(int i = 0; i < chunklen; i++) {
        if(d[start + i])
            score += ++streak;
        else
            streak = 0;
    };  
    return score;
}

3. 比特数据存储：通过使用dnaCountRange函数（定义如下），例如：4bits 1011将变为1x1 + 0x1 + 1x1 + 1x1 = 3。可能的值（4位）：[0，1，2，3，4]

int dnaCountRange(dna_t &d, int start, int chunklen) {
    int score = 0;
    for(int i = 0; i < chunklen; i++) {
        if(d[start + i])
            score ++;
    };  
    return score;
}

两种存储方法之间的区别是：

• 十进制存储方法很容易对 DNA进行一点更改。当比特值从1011更改为0011时，其值从3更改为2，这是一个很小的更改。
• 十进制存储方法是同构的。每个可能的值都会发生相同的变化。您从4位存储内存块中读取值15的机会是1/16 = 6％。的条纹的存储方法是不均匀的。条纹4位值小于或等于6的机会是（15-3）/ 16 = 81％（除0111、1110、111以外的所有16种组合）。视觉下方显示了分布的形状。如您所见，在蓝色箭头处，4位条纹小于或等于6的几率是81％：

确定解决方案的优先级。

当ColorScorePlayer识别出两个得分相同的向前移动时，将做出任意选择。恕我直言，您永远不要使用随机函数v.rng.rint()function。取而代之的是，您应该利用这个机会，将分数相等作为评估二阶效应解的钩子。

一阶效应获得最高优先级。如果达到相等分数，则优先级为2的解决方案为准，依此类推。通过调整解决方案的参数，您可以影响出现相等分数的机会，并以此方式更改优先级1和优先级2解决方案的权重。

实现期望的行为

了解哪些颜色是安全的：

• 16种颜色中有33％是不良的，因此，当移动的分数低于63/3时，将不允许移动。因此threshold = 63/3=21，63是6位的最高分，而33％= 1/3（可以在上图中查询）。

如果没有好的移动可用，请垂直或向后移动：

• 当不允许向前移动时，垂直移动将以相同的方式相互比较。如果也不允许垂直移动，则将向后移动排序。这是通过weightMove变量实现的。

看看超越了什么：

• 当2或3个动作得分相同时，这些动作周围的3x3框将确定（通过x2和y2循环）什么是最佳选择（通过mainSubScore变量）。该3x3框中最右边的列处于领先地位。

coord_t adjustedColorPlayer(dna_t d, view_t v) {
    const int chunklen = 6,threshold = 63/3;
    int xBestScore=0, yBestScore=0;
    long bestScore=-1, weightMove, weightMove2, mainScore;
    for(int x = -1; x <= 1; x++) {
        if (x < 0) weightMove = 1000; // moving backward
        if (x== 0) weightMove = 10000; //moving vertical
        if (x > 0) weightMove = 100000; //moving forward
        for(int y = -1; y <= 1; y++) {
            if(v(x, y) == OUT_OF_BOUNDS || (x==0&&y==0) ) continue;
            mainScore = dnarange(d,v(x,y)*chunklen,chunklen);
            if (mainScore<threshold+1) {
                mainScore =  0; //not a suitable move because too low score
            }else{
                mainScore*= weightMove;
                // when equal score, use sub score by examining 5x5 box to rank moves
                for(int x2 = x-1; x2 <= x+1; x2++){     
                    if (x2 < x) weightMove2 = 1; // moving backward
                    if (x2== x) weightMove2 = 10; //moving vertical
                    if (x2 > x) weightMove2 = 100; //moving forward
                    for(int y2 = x-1; y2 <= y+1; y2++){     
                        if(v(x2, y2) != OUT_OF_BOUNDS){
                            long mainSubScore = dnarange(d,v(x2,y2)*chunklen,chunklen);
                            if (mainSubScore>=threshold+1) mainScore+=mainSubScore*weightMove2;
                        }
                    }
                 }
            }
            if(mainScore > bestScore) {
                bestScore = mainScore;              
                xBestScore = x;
                yBestScore = y;
            }
        }
    }
    return{xBestScore,yBestScore};
}

得分：123（2K跑步）

前50个得分（18场比赛仅获得1分）：

1 10 1 79947 3 1 11 125 7333287 23701 310869 53744 1 2 2 2 2 1 1 57556 2 688438 60 1 2 2636261 26306 1 125369 1 1 1 61895 27 1 36 1 91100 87636 1 2 47497 53 16 1 11 222384 1 1 1 1

识别陷阱：

当使用bitsum4存储终止任意游戏时，我检查了得分最高的物种的DNA（因此颜色得分的范围为[0,4]）：

• 得分0：向后传送，两面墙壁，安全1x
• 得分1：向后陷阱（非常无害），向后传送，安全1倍
• 得分2：陷阱向前（太危险），安全1倍
• 得分3：向前传送，安全5倍
• 得分4：向前传送，安全1倍

由此可以得出结论，墙壁和传送带获得正确的分数。无法识别陷阱，因为它们取决于方向和原产地颜色，而得分是根据目的地的颜色进行的。因此，还需要存储有关原色的数据v(0,0)。在理想的世界中，我们希望存储16种颜色x 8个方向x 3位= 384位的信息。

不幸的是，由于只有100位可用，因此我们无法全部使用，因为上述解决方案还需要一些内存。因此，我们将创建4个颜色容器：

• 0：颜色0-颜色3，
• 1：颜色4-颜色7
• 2：颜色8-颜色11
• 3：颜色12-颜色16

和4个移动方向箱

• 0：垂直或向后移动，
• 1：向前移动
• 2：前进
• 3：向前走

当十进制分数等于或大于4（100,101,110,111）时，将认为此单元格关联有陷阱，因此，当出现相等分数时，将不会选择此举动。因此，陷阱识别是一种二阶效应，而“寻找超越”将是第三优先解决方案。

int dnaLookup2(dna_t &d, int start, int chunklen, int storageMethod) {
    // Definition of storageMethod: 0=decimal, 1=streak, 2=bitsum
    int score = 0, streak = 0;
    for(int i = start; i < start+chunklen; i++) {
        int value = d[i];
        if (storageMethod==0) {
            score = (score << 1) |value;
        }else{
            if (storageMethod==1){
                if(value) score += ++streak; else streak = 0;
            }else{
                if(value) score ++;         
            }
        }
    };  
    return score;
}

coord_t theTrapFighter(dna_t d, view_t v) {
    // Definition of storageMethod: 0=decimal, 1=streak, 2=bitsum
    const int colorMemStorageMethod = 1, colorMemBlockSize = 3;
    const int trapMemStorageMethod = 0, trapMemBlockSize = 3;
    const int trapMemTopThreshold = 4, nDirBins = 4, nColorBins = 4;

    int xBestScore=0, yBestScore=0;
    long bestScore=-1, weightMove, weightMove2, mainScore;
  for(int x = -1; x <= 1; x++) {
        if (x < 0) weightMove = 1000; // moving backward
        if (x== 0) weightMove = 10000; //moving vertical
        if (x > 0) weightMove = 100000; //moving forward
        for(int y = -1; y <= 1; y++) {          
            int color = v(x, y);
            if(color == OUT_OF_BOUNDS || (x==0&&y==0) ) continue;
            mainScore = dnaLookup2(d,color*colorMemBlockSize,
             colorMemBlockSize,colorMemStorageMethod);
            if (mainScore==0) {
                //not a suitable move because too low score
            }else{
                mainScore*= weightMove;
                //lookup trap likelihood
                int directionBin = 0;
                if (nDirBins==3) directionBin = x>0?y+1:-1;
                if (nDirBins==4) directionBin = x>0?y+2:0;
                // put 16 colors in nColorBins bins
                int colorBin = v(0,0)*nColorBins/N_COLORS; 
                colorBin = colorBin>(nColorBins-1)?(nColorBins-1):colorBin;
                if (directionBin >= 0 &&
                 dnaLookup2(
                   d,
                   colorMemBlockSize*16
                    +trapMemBlockSize*(nColorBins*directionBin+colorBin),
                   trapMemBlockSize,
                   trapMemStorageMethod
                 ) >=trapMemTopThreshold){
                  //suspect a trap therefore no sub score is added                  
                 }else{
                    // when equal score, use sub score by examining 5x5 box to rank moves
                    for(int x2 = x-1; x2 <= x+1; x2++){     
                        if (x2 < x) weightMove2 = 1; // moving backward
                        if (x2== x) weightMove2 = 10; //moving vertical
                        if (x2 > x) weightMove2 = 100; //moving forward
                        for(int y2 = x-1; y2 <= y+1; y2++){     
                            int color2 = v(x2, y2);
                            if(color2 != OUT_OF_BOUNDS){
                                mainScore+=weightMove2 * dnaLookup2(d,color2*colorMemBlockSize,
                                 colorMemBlockSize,colorMemStorageMethod);
                            }
                        }
                    }               
                 }
            }
            if(mainScore > bestScore) {
                bestScore = mainScore;              
                xBestScore = x;
                yBestScore = y;
            }
        }
    }
    return{xBestScore,yBestScore};
}

得分：580（2K次）

前50个得分（13场比赛仅获得1分）：

28,044 14,189 1 2,265,670 2,275,942 3 122,769 109,183 401,366 61,643 205,949 47,563 138,680 1 107,199 85,666 31 2 29 1 89,519 22 100,908 14,794 1 3,198,300 21,601 14 3,405,278 1 1 1 2 74,167 1 71,242 97,331，109,080 1 1 102 94

关于白墙的错误假设多次被白痴复制到新生儿中：

一些物种错误地认为墙壁是好的，并试图一直向它们移动，因此卡在墙壁的前面。它们也可能陷入无限的瞬态传送器中。在两种情况下，效果是相同的。

主要的问题是，经过几百次迭代，某些基因变得非常占优势。如果这些是“正确的”基因，您将获得非常高的分数（> 1百万分）。如果这些是错误的，那么您就被困住了，因为您需要多样性才能找到“正确的”基因。

白痴战斗：解决方案1：颜色反转

我尝试的第一个解决方案是努力利用仍然非常多样化的未使用内存的一部分。假设您已将84位分配给彩色内存和陷阱查找内存。其余的16位将非常多样化。我们可以填充2个十进制8变量，它们的值在[0,255]之间，并且是同质的，这意味着每个值都有1/256的机会。变量将称为inInverse和inReverse。

如果inInverse等于255（机会为1/256），那么我们将反转颜色分数的解释。因此，白痴认为安全的那堵墙是高分的，将获得低分，因此将成为一个坏举动。缺点是，这也会影响“权利”基因，因此我们的得分将不高。此外，该inInverse物种将不得不繁殖，其子代也将获得部分优势DNA。最重要的部分是它带回了多样性。

如果inReverse等于255（机会为1/256），那么我们将颠倒颜色分数的存储位置的顺序。因此，在将颜色0存储在位0-3中之前。现在，颜色15将存储在该位置。与该inInverse方法的不同之处在于，该方法inReverse将撤消到目前为止已完成的工作。我们回到了第一广场。我们创建了一个与游戏开始时具有相似基因的物种（陷阱发现记忆除外）

通过优化，可以测试同时使用inInverse和是否明智inReverse。优化后得出的结论是分数没有增加。问题在于我们拥有更多的基因种群，但这也影响了“正确的DNA”。我们需要另一个解决方案。

白痴之战：解决方案2：哈希码

该物种有15个可能的起始位置，目前如果他从相同的起始位置开始，他将遵循完全相同的路径的可能性太大。如果他是一个热爱墙壁的白痴，他会一遍又一遍地卡在同一堵墙上。如果他幸运地成功到达了遥远的墙，他将以错误的假设开始主导DNA库。我们需要的是他的后代将走一条稍微不同的路径（因为对他而言无论如何都为时已晚），并且不会卡在遥远的墙壁上，而会卡在更近的墙壁上。这可以通过引入哈希码来实现。

一个哈希码应该有目的的唯一标识和标签电路板上的当前位置。目的不是要找出（x，y）的位置，而是要回答我的祖先以前在这个位置上遇到过的问题？

假设您前面有完整的电路板，并且每5 x 5单元可能的正方形制作一个jpg。您最终将获得（53-5）x（15-5）= 380张图像。让我们给这些图像编号从1到380。我们的哈希码 应被视为这样的ID，不同之处在于它不会从1到330运行，但缺少IDS，例如563、3424、9424、21245等。

unsigned long hashCode=17;
for(int x = -2; x <= 2; x++) {
    for(int y = -2; y <= 2; y++) {
        int color = v(x, y)+2;
        hashCode = hashCode*31+color;
    }
}       

质数17和31在那里防止在循环开始时添加的信息消失。稍后将详细介绍如何将我们的哈希码集成到程序的其余部分。

让我们用另一种评分机制代替“看看超越了”的评分机制。当两个或三个单元具有相同的主要分数时，将有50％的机会被选为顶部单元，有50％的机会将被选为底部单元，而有0％的机会将被选为中间单元。机会不是由随机生成器确定的，而是由内存中的位确定的，因为这样可以确保在相同情况下做出相同的选择。

在理想的世界中（我们拥有无限的内存量），我们将为当前情况计算一个唯一的哈希码，例如25881，然后转到内存位置25881并在此处读取，如果我们应该选择顶部或底部的单元格（当存在是相等的分数）。这样，我们将处在完全相同的情况下（例如，当我们第二次旅行董事会并在同一位置开始时）做出相同的决定。由于我们没有无限的内存，因此我们将可用内存大小的模应用于哈希码。当前的哈希码在模运算后的分布是均匀的意义上是好的。

当后代在DNA稍有变化的情况下到达同一块板时，在大多数情况下（> 99％），他将做出完全相同的决定。但是他越走越远，他的祖先就越有机会变得与众不同。因此，他被卡在这堵遥远的墙上的机会很小。尽管他的祖先被卡在附近的同一堵墙上相对较大，但这并不算糟，因为他不会产生太多后代。如果没有哈希码方法，卡在附近和远处的墙上的机会几乎相同

优化

经过优化后，得出的结论是不需要陷阱识别表，每种颜色2位就足够了。存储器100-2x16 = 68位的其余部分用于存储哈希码。似乎哈希码机制可以避免陷阱。

我已经针对15个参数进行了优化。这段代码包含了迄今为止最好的一组调整参数：

int dnaLookup(dna_t &d, int start, int chunklen, int storageMethod,int inInverse) {
    // Definition of storageMethod: 0=decimal, 1=streak, 2=bitsum
    int score = 0;
    int streak = 0;
    for(int i = start; i < start+chunklen; i++) {
        int value = d[i];
        if (inInverse) value = (1-d[i]);            
        if (storageMethod==0) {
            score = (score << 1) |value;
        }else{
            if (storageMethod==1){
                if(value) score += ++streak; else streak = 0;
            }else{
                if(value) score ++;         
            }
        }
    };  
    return score;
}

coord_t theFittest(dna_t d, view_t v) {
    // Definition of storageMethod: 0=decimal, 1=streak, 2=bitsum
    const int colorMemStorageMethod = 2, colorMemBlockSize = 2, colorMemZeroThreshold = 0;
    const int useTrapMem = 0, trapMemStorageMethod = -1, trapMemBlockSize = -1;
    const int trapMemTopThreshold = -1, nDirBins = -1, nColorBins = -1;
    const int reorderMemStorageMethod = -1, reorderMemReverseThreshold = -1;
    const int reorderMemInverseThreshold = -1;
    // Definition of hashPrority: -1: no hash, 0:hash when 'look beyond' scores equal,
    // 1: hash replaces 'look beyond', 2: hash replaces 'trap finder' and 'look beyond'
    // 3: hash replaces everything ('color finder', 'trap finder' and 'look beyond')
    const int hashPrority = 2;
    int inReverse = reorderMemReverseThreshold != -1 && 
     (dnaLookup(d,92,8,reorderMemStorageMethod,0) >= reorderMemReverseThreshold);
    int inInverse = reorderMemInverseThreshold != -1 && 
     (dnaLookup(d,84,8,reorderMemStorageMethod,0) >= reorderMemInverseThreshold);
    int trapMemStart=N_COLORS*colorMemBlockSize;
    unsigned long hashCode=17;
    int moveUp=0;
    if (hashPrority>0){
        for(int x = -2; x <= 2; x++) {
            for(int y = -2; y <= 2; y++) {
                int color = v(x, y)+2;
                hashCode = hashCode*31+color;
            }
        }       
        unsigned long hashMemStart=N_COLORS*colorMemBlockSize;
        if (useTrapMem==1 && hashPrority<=1) hashMemStart+=nDirBins*nColorBins*trapMemBlockSize;
        if (hashPrority==3) hashMemStart=0;
        int hashMemPos = hashCode % (DNA_BITS-hashMemStart);
        moveUp = dnaLookup(d,hashMemStart+hashMemPos,1,0,inInverse);
    }

    int xBestScore=0, yBestScore=0;
    long bestScore=-1, weightMove, weightMove2, mainScore;
    for(int x = -1; x <= 1; x++) {
        if (x < 0) weightMove = 1000; // moving backward
        if (x== 0) weightMove = 10000; //moving vertical
        if (x > 0) weightMove = 100000; //moving forward
        for(int y = -1; y <= 1; y++) {          
            int color = v(x, y);
            if (inReverse) color = 15-v(x, y);
            if(color == OUT_OF_BOUNDS || (x==0&&y==0) ) continue;
            //when MoveUp=1 -> give move with highest y most points (hashScore=highest)
            //when MoveUp=0 -> give move with lowest y most points (hashScore=lowest)
            int hashScore = (y+2)*(2*moveUp-1)+4; 
            mainScore = dnaLookup(
              d,
              color*colorMemBlockSize,
              colorMemBlockSize,
              colorMemStorageMethod,
              inInverse
             );
            if (mainScore<colorMemZeroThreshold+1) {
                mainScore =  0; //not a suitable move because too low score
            }else{
                mainScore*= weightMove;
                //lookup trap likelihood
                int directionBin = 0;
                if (nDirBins==3) directionBin = x>0?y+1:-1;
                if (nDirBins==4) directionBin = x>0?y+2:0;
                // put 16 colors in nColorBins bins
                int colorBin = v(0,0)*nColorBins/N_COLORS; 
                if (inReverse) colorBin = (15-v(0,0))*nColorBins/N_COLORS; 
                colorBin = colorBin>(nColorBins-1)?(nColorBins-1):colorBin;
                if (useTrapMem && directionBin >= 0 &&
                 dnaLookup(
                   d,
                   trapMemStart+trapMemBlockSize*(nColorBins*directionBin+colorBin),
                   trapMemBlockSize,
                   trapMemStorageMethod,
                   0
                 )>=trapMemTopThreshold){
                  //suspect a trap therefore no sub score is added                  
                 }else{
                    if (hashPrority>=1){
                        mainScore+=hashScore;
                    } else{
                        // when equal score, use sub score by examining 5x5 box to rank moves
                        for(int x2 = x-1; x2 <= x+1; x2++){     
                            if (x2 < x) weightMove2 = 1; // moving backward
                            if (x2== x) weightMove2 = 10; //moving vertical
                            if (x2 > x) weightMove2 = 100; //moving forward
                            for(int y2 = x-1; y2 <= y+1; y2++){     
                                int color2 = v(x2, y2);
                                if (inReverse) color2 = 15-v(x2, y2);
                                if(color2 != OUT_OF_BOUNDS){
                                    long mainSubScore = dnaLookup(
                                      d,
                                      color2*colorMemBlockSize,
                                      colorMemBlockSize,
                                      colorMemStorageMethod,
                                      inInverse
                                    );
                                    if (mainSubScore>=colorMemZeroThreshold+1){
                                        mainScore+=mainSubScore*weightMove2;
                                    }
                                }
                            }
                        }
                    }               
                 }
            }
            if (hashPrority==2 || (useTrapMem<=0 && hashPrority>=1)) mainScore+=hashScore*10;
            if (hashPrority==3) mainScore=hashScore*weightMove;         

            if(mainScore > bestScore) {
                bestScore = mainScore;              
                xBestScore = x;
                yBestScore = y;
            }
        }
    }
    return{xBestScore,yBestScore};
}