Це Fortnightly Challenge # 3. Тема: Генетичні алгоритми

Цей виклик - трохи експеримент. Ми хотіли подивитися генетичні алгоритми, що ми можемо зробити, з викликом складності. Не все може бути оптимальним, але ми намагалися зробити це доступним. Якщо це вийде, хто знає, що ми можемо побачити в майбутньому. Може, генетичний Король гори?

Специфікація досить довга! Ми намагалися відокремити специфікацію на «Основи» - найголовніший мінімум, який потрібно знати, щоб почати грати з фреймворком та подати відповідь - та «The Gory Details» - повну специфікацію із усіма подробицями про контролер, на основі яких ви міг написати свій.
Якщо у вас є якісь питання, сміливо приєднуйтесь до нас у чаті!

Ви дослідник поведінкової психології. Увечері в п’ятницю, і ви та ваші колеги вирішили повеселитися та використати ваших лабораторних щурів для невеликої гонки з щурами. Насправді, перш ніж ми занадто емоційно прив’яжемось до них, давайте назвемо їх зразками .

Ви встановили невелику гоночну доріжку для екземплярів, і щоб зробити її цікавішою, ви поставили кілька стін, пасток і телепортаторів по всій трасі. Тепер ваші особини - це ще щури ... вони не мають поняття, що таке пастка чи телепорт. Вони бачать лише деякі речі різних кольорів. Вони також не мають жодної пам’яті - все, що вони можуть зробити, - це приймати рішення, виходячи з поточного оточення. Я здогадуюсь, що природний відбір вибере особин, які знають, як уникнути пастки від тих, хто цього не робить (ця гонка забирає деякий час ...). Нехай починаються ігри! ^†

^{† 84 465 екземплярів було завдано шкоди при здійсненні цього виклику.}

Основи

Це гра з одиночним гравцем (ви та ваші колеги не хотіли змішувати популяцію, тому кожен побудував власну гоночну доріжку). Гоночна доріжка - це прямокутна сітка, 15 комірок заввишки та 50 комірок завширшки. Ви починаєте з 15 зразків на випадкових (не обов'язково виразних) клітинках з лівого краю (де х = 0 ). Ваші екземпляри повинні намагатися досягти мети, яка є будь-якою клітиною при x ≥ 49 та 0 ≤ y ≤ 14 (екземпляри можуть перевернути доріжку праворуч). Щоразу, коли це відбувається, ви отримуєте бал. Ви також починаєте гру з 1 очка. Вам слід спробувати максимізувати свої очки після 10000 оборотів.

Кілька зразків можуть займати одну клітинку і не взаємодіють.

На кожному кроці кожен зразок бачить 5х5 сітку свого оточення (із самим собою в центрі). Кожна комірка цієї сітки буде містити колір -1для 15. -1являє собою клітини, що знаходяться поза межами. Ваш зразок гине, якщо він виходить за межі. Що стосується інших кольорів, вони представляють порожні клітини, пастки, стіни та телепортатори. Але ваш зразок не знає, який колір являє собою те, що, а також ви. Однак є деякі обмеження:

• 8 кольорів представлятимуть порожні клітинки.
• 4 кольори представлятимуть телепортер. Телепортер відправить зразок до певної комірки в межах 9x9. Це зміщення буде однаковим для всіх телепортерів одного кольору.
• 2 кольори представлятимуть стіни. Переміщення в стіну - це те саме, що стояти на місці.
• 2 кольори представлятимуть пастку. Пастка вказує на те, що одна з 9 комірок, що знаходяться в її найближчому сусідстві, смертельна (не обов'язково сама клітина пастки). Це зміщення буде однаковим для всіх пасток одного кольору.

Тепер про той природний відбір ... кожен зразок має геном, який є числом зі 100 бітами. Нові зразки будуть створені шляхом схрещування двох існуючих особин, а потім злегка мутувати геном. Чим успішніший зразок, тим більший його шанс на розмноження.

Отже, ось ваше завдання: Ви напишете одну функцію, яка отримує в якості введення 5x5 сітку кольорів, яку бачить зразок, а також його геном. Ваша функція поверне хід (Δx, Δy) для зразка, де Δx і Δy будуть один з {-1, 0, 1}. Ви не повинні зберігати жодних даних між функціями викликів. Це включає використання власних генераторів випадкових чисел. Вашій функції буде забезпечений посіяний РНГ, яким ви можете вільно користуватися як хочете.

Оцінка вашої заявки буде геометричним середнім числом балів у 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)). Пастка вказує, що клітина при цьому зміщенні є летальною . Примітка. Сама клітина пастки не обов'язково є летальною.
• Два решти кольору - це стіни, які перешкоджають руху. Спроба перейти на стінну камеру перетворить цей крок у нерухоме. Самі клітини стінки є летальними .
• Для кожної нецільової комірки сітки виберіть випадковий колір. Для кожної цільової комірки виберіть випадковий порожній колір.
• Для кожної комірки з лівого краю колії визначте, чи можна досягти мети протягом 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 .

Оцінка:

• Одна гра триває 10000 оборотів.
• Гравці починають гру з 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.
• Досить повільно.

Java

• Не особливо повільно. Не особливо швидко.

Попередня таблиця лідерів

Усі оцінки попередні. Тим не менш, якщо щось не так або застаріло, будь ласка, повідомте мене про це. Наш приклад подано для порівняння, але не заперечує.

  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

Кредити

Цей виклик був величезним спільним зусиллям:

• Натан Мерріл: Написав контролери Python та Java. Концепція виклику з Короля-Хілл перетворилася на щурячу гонку.
• трихоплакс: ігрові тести. Працював на контролері Python.
• feersum: Написав контролер C ++.
• VisualMelon: Написав контролер C #.
• Мартін Бюттнер: Концепція. Написав контролер Ruby. Ігрове тестування. Працював на контролері Python.
• T Авраам: Playtesting. Протестований Python та переглянуті контролери C # і C ++.

Усі перераховані вище користувачі (і, мабуть, ще пару я забув) внесли свій внесок у загальний дизайн завдання.

Оновлення контролера C ++

Якщо ви використовуєте C ++ з Visual Studio і багатопотоковою програмою, вам слід отримати останнє оновлення через помилку з висіванням їх генератора випадкових чисел, що дозволяє виробляти дублюючі дошки.

Сліпа віра - C ++ - здається, набрала понад 800 (!) За 2000 пробіжок

Геном кольорового кодування з таємничим зворотним зв'язком та ефективним засобом стримування на стінах

#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 балів).

Що змушує цих факторів поставити галочку

Замість того, щоб давати однакові пріоритети кожному кольору, я вважаю ці можливі значення:

1. добре -> щур думає, що туди може благополучно їхати
2. погано -> щур туди не поїде
3. пастка -> щур вважатиме позицію пастки поганою, а клітина вказує на пастку хорошу .
   Хоча я лінивий перейменувати це, це швидше "детектор небезпеки", що вказує на (передбачуване) місце фактичної пастки, стіни, телепортатора, що чекає, щоб відправити нічого підозрюючого мандрівника в неприємне місце або навіть вхід мертвого -закінчити. Одним словом, місце, куди б не ходив мудрий щур.

хороші або погані гени мають лише 2 біти для зберігання (наприклад, 11і 10), але для пасток потрібні 4 біти ( 0tttде tttпредставлено одне з можливих 8 "небезпечних" місць).

Щоб зберегти послідовність кожного гена (тобто зберегти його значення після змішування в абсолютно інший геном, який вимагає, щоб кожен ген, що кодує кольори, був у фіксованому місці), всі значення кодуються на 4 біти (так добре кодується як 11xxі погано, як 10xx), загалом 16 * 4 = 64 біт.

Решта 36 біт використовуються як "анти-стіни" (докладніше про це пізніше). 25 навколишніх кольорів хешируются в індекс цих 36 біт. Кожен біт вказує бажаний вертикальний напрямок (вгору або вниз), який використовується, коли можливий вибір між двома клітинками.

Стратегія така:

• декодувати кожен колір відповідно до геному (або звіт прямого контролера для позашляхових "поганих" комірок)
• побудувати карту найближчого оточення (3х3 комірки, 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

Тут рано з'явилася порода супер-щурів (доріжка, ймовірно, дозволяла бігати по прямій лінії, і якийсь щасливий щур в перших поколіннях мав право використовувати ДНК). Кількість зразків в кінцевому підсумку становить приблизно половину теоретичного максимуму приблизно 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

Тут ми можемо побачити вдосконалення геному в роботі. Рядок між останніми двома геномами відображається чітко. В хороші і погані оцінки є найбільш значущими. У пастці показання , здається, вібрувати , поки вони або не стабілізуються до «корисною» пастці або мутувати в добре або погано .

Здається, кольорові гени мають кілька корисних характеристик:

• вони мають автономне значення
  (конкретний колір повинен оброблятися певним чином)
  Кожне кольорове кодування можна перекинути на зовсім інший геном, не змінюючи різко поведінку - якщо тільки колір не є насправді вирішальним (зазвичай стіни або телепортатора, що веде до нескінченної петлі).
  Це менше у випадку з основним кодуванням пріоритету, оскільки найбільш пріоритетний колір є єдиною інформацією, яка використовується для вирішення, куди рухатися. Тут усі "хороші" кольори рівні, тому заданий колір, доданий до списку "хороший", матиме менший вплив.
• вони відносно стійкі до мутацій,
  кодування хорошого / поганого кодування має лише 2 значущі біти з 4, і місце розташування пастки може бути змінено більшу частину часу, не змінюючи істотно поведінку щурів.
• вони невеликі (4 біти), тому ймовірність бути розбитою кросовером дуже низька.
• мутації спричиняють або нешкідливі значущі зміни
  . Ген, що мутує на "добре", або матиме незначний ефект (якщо, наприклад, це відповідає порожній клітині, це може дати можливість знайти новий, коротший шлях, але це також може привести щура прямо в пастка), або драматична (якщо колір являє собою стіну, новий щур кудись застрягне).
  Перехід гена на «пастку» позбавить щура від істотного забарвлення або не матиме помітного ефекту.
  Мутація місця пастки матиме значення лише в тому випадку, якщо попереду справді є пастка (або щось шкідливе), яке має порівняно невелику ймовірність (я б сказав щось на зразок 1/3).

Нарешті, я здогадуюсь, що останні 36 бітів сприяють не тільки уникненню застрягання щурів, але й більш рівномірному поширенню щурів на трасі, таким чином зберігаючи генетичне різноманіття, поки геном, що виграє, не з’явиться і не стане домінуючим за допомогою кольорової частини.

Подальша робота

Треба сказати, що мені здається, що ці маленькі життєві риси заворожують.
Ще раз дякую всім учасникам цього відмінного виклику.

Я маю намір додатково розрізати контролер, щоб відобразити більш вагомі дані, на зразок походження успішного щура.

Я також дуже хотів би бачити цих щурів у дії, але ця мова C ++ b ** ch робить створення - не кажучи вже про анімацію - зображення (серед багатьох інших) безладною справою.

Зрештою, я хотів би дати хоча б пояснення системи пасток і, можливо, вдосконалити її.

Злом контролера

Якщо хтось зацікавлений, я можу опублікувати зміни, які я внесла до контролера.
Вони брудні та дешеві, але вони роблять роботу.

Я не кмітливий у GitHub, тому це повинно було пройти через просту посаду.

Жорсткі віруючі - C ++ - (покращені телепортатори): 10 000+ за 2000 циклів

(це еволюція сліпої віри , тому ви, можливо, захочете піднятися на іншу стінку тексту перед цією)

#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";
}

Епізод IV: отримання наших підшипників на сітці

Результати

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), стане частиною домінуючого геному і вб'є майже всіх щурів, які вважають його «завжди безпечним».
Оскільки щури не мають можливості знати своє положення Х, єдине рішення для виявлення цих підступних телепортерів - це вирішити, чи слід наступати на них, грунтуючись на єдиних наявних контекстних даних, тобто кольоровій сітці 5x5.

Для цього я визначив 4 типи кольорових генів:

• детектор пастки небезпеки
• порожній прохідний кудись на трасі
• блокувати заборонено будь-де на трасі
• промінь розглядається як порожній або блоковий залежно від оточення

Ідея полягає у тому, щоб спробувати розрізнити телепортатора, поглянувши на своїх найближчих 8 сусідів. Оскільки ймовірність наявності 8 однакових сусідів у даному місці дуже низька, це повинно дозволяти ідентифікувати унікальний примірник кожного телепортатора.

8 сусідніх кольорів можна комбінувати для формування локального підпису, який є інваріантним відповідно до положення в лабіринті. На жаль, 8 сусідів видно лише для комірок, розташованих у внутрішньому квадраті поля зору 3x3, тому підписи будуть неточними на краю поля зору.
Тим не менш, це дасть нам постійну контекстну інформацію в безпосередньому сусідстві, що достатньо для збільшення ймовірності успішного навігації телепортерів.

пучки генів мають 2 бітове мінливе поле.
Для місцевого підпису телепортатора є чотири шанси на те, що комірка променя буде вважатися непрохідною. Кожне значення поля вибирає одну з цих чотирьох можливостей.
Як результат, мутація гена пучка на цих 2 бітах буде проходити через 4 можливі контекстні значення кольору.

Крім того, найважливіші кольори, про які можна здогадатися, - це все ще стіни та пастки. Це означає, що ми повинні дозволити виявлення телепортера лише після того, як щури дізнаються, де знаходяться стінки та пастки.

Це робиться шляхом оновлення місцевих підписів лише поступово. Поточним критерієм оновлення локального підпису має бути в'язкість кольору, визначеного як потенційний телепортер.

Кодування використовує 5 біт на кольоровий ген і групує типи, щоб звільнити 3 менш значущі біти для кодування значення 0..7:

• 4 небезпека
• 4 порожній
• 4 блок
• 4 промінь

Кожен ген пучка має 1/4 шансу вважатись блоком і 3/4 шансів вважати порожнім, тому 4 пучка представляють в середньому 1 блок і 3 порожні.

Середня частка, представлена ​​випадковим поширенням 16 кольорів, становить:

• 4 небезпека
• 7 порожньо
• 5 блок

Цей мікс, здається, дає найкращі результати поки що, але я не закінчив його налаштовувати.

Генна мінливість

Одне напевне: значення коду, обрані для представлення типів генів, є критичними. Інвертування двох значень може коштувати 2000 балів і більше.

Ось знову причина, чому поза моєю математикою.

Я здогадуюсь, що ймовірність мутації від одного типу до іншого повинна бути збалансована, інакше, як у матриці Маркова, кумулятивні ймовірності мають тенденцію обмежувати значення для підмножини, що має найвищі ймовірності вхідного переходу.

Шлях на допомогу

Шлях дозволить різко зменшити кількість відвідуваних осередків, що дозволить протестувати лише найімовірніші, що призводять до досягнення мети. Таким чином, не тільки уникають деяких частих тупиків, але неправильні кольорові коди також набагато частіше виявляються раніше.
Як результат, час конвергенції сильно скорочується.

Однак це не допомагає вирішити карти, коли геном не в змозі створити належне зображення сліду.

Що робити з дебілами?

Поглянувши візуально на доріжку, я зрозумів, чому стратегія за замовчуванням, яка намагається рухатися вперед, навіть коли здається, що нічого іншого, крім стін попереду, справді краще, ніж стримувати.
"стіни" можуть бути насправді телерепортерами, які дають стільки прикрих результатів, що геном відображає їх як перешкоди, які ніколи не будуть натрапляти, але в рідкісних випадках певний екземпляр цього неслухняного телепортатора може мати позитивний (або принаймні не летальний) ефект , тож прийняття його замість того, щоб рухатись назад, збільшує шанси знайти шлях до перемоги.

Рання конвергенція

Мені здається, частота мутацій є занадто низькою (як мінімум, для моїх гризунів).

Поточний показник 0,01 дає ДНК 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; 
}

Java

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 ++, моделювання пітона все ще не припинилося.

Це вдосконалений варіант 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. (Thx feersum за допомогу мені імітувати та його палаючу швидку програму)

Оцінки з моїх пробігів: 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 556 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 526001 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 68594 145434 87763 150187 169 185518 1 1 1 1 24208 2570 1 1 537 1 1 462284 1 2 55 1 1 214365 1 40147 2 213952 1 29 3 1 2144435 5 4502444 72111 1 1 1 1 1 774547

Єпископ - Пітон, попередній бал 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)]

Незважаючи на ці обмеження, Єпископ в рідкісних випадках справляється добре, окремі екземпляри заповнюють по кілька кіл дошки кожен. Я думав, що на даному колі копія зразка може переміщатися лише на половині дошки (рівнозначно лише чорним квадратам або лише білим квадратам на шаховій дошці). Однак, як зазначив Мартін Бюттнер, телепортатор може перемістити зразок з чорного квадрата до білого квадрата або навпаки, тому на більшості дощок вони не обмежуватимуться.

(Є дві пари відповідних типів телепортерів, і кожна з них має ймовірність 0,5 зсуву, який переміщує зразок в іншу половину чорно-білих квадратів. Отже, ймовірність того, що на борту є лише телепортери, які обмежують зразок одним половина дошки на коліні становить лише 0,25.)

Оцінки показують, що випадкові тріумфи перемежовуються довгими періодами, що не дотягують до фінішу:

Рахунок: 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 3 7554 1 1 + 1 1 1

Пробіг-бонус: Геометричне середнє 50,35 (тест 5000 гри)

Цей бот розбиває квадрати за своїми індивідуальними кольорами на основі 6-бітової секції ДНК, як гравець з кольоровою шкалою, але з іншою системою числення. Цей бот був мотивований думкою, що досить умовно, що один з бітів змінює значення бала на 32, а інший - лише на 1. Він присвоює значення n (n + 1) / 2 пробігу n послідовних 1 біт. Крім того, він додає механізм рандомізації, щоб уникнути застрявання. Це зробить випадковий рух вперед з шансом 1 на 30.

Для порівняння, гравець з кольоровою шкалою набрав 30 - 35 за пару тестів на 1000 ігор. Цікаво, що максимальний рахунок гравців з кольоровим балом був у діапазоні 3-5 мільйонів, тоді як максимум запуску бонусу становив лише 200 тисяч. Виграйте бонус від логарифмічної середньої системи балів, отримуючи ненульовий бал більш послідовно.

Запуск 5000 ігор зайняв близько 20 хвилин з 6 потоками на контролері C ++.

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 - Набрав 113,266 в тесті на 1000 ігор

Кодування

Я зробив дійсно просте 6-бітове / кольорове кодування. Для декодування кольору [n]

• Підсумовуйте кожен n-й біт у геномі до 96
• Якщо бальна сума> = 4, скажімо, що цей квадрат заблокований
• Якщо бальна сума <= 4, то її кінцева оцінка дорівнює 2 ^ її підсумкової оцінки

Поширюючи шматочки для кольору по всьому геному, я збільшую шанс, що біти обох батьків будуть використані для кожного кольору.

Рух

Я використовую (я впевнений, не дуже ефективний) пошук на основі *, щоб шукати шлях з найнижчою вартістю до будь-якого з квадратів правого краю. Якщо колір відображається на "заблокованому", він ніколи не буде введений пошуком. Якщо пошук не може знайти шлях, він передбачає, що цей щур не підходить для розмноження, і намагається закінчити його, перемістивши його вліво.

Зменшення кількості непридатних щурів

Оскільки мій геном ефективно здогадується про те, які квадрати є настінними або відсталими телепортерами, щури, які не здогадуються (жодні кольори, які відображаються на заблоковані), не дуже підходять. Щоб спробувати видалити цих щурів, якщо жоден колір не буде позначений як заблокований, то КОЖЕН колір позначений як заблокований, а щур завжди буде рухатись ліворуч.

РОБИТИ

В даний час немає випадковості в поведінці, тому щурам легко застрягти.

#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;
}

FITTEST - середній геометричний бал: ~ 922 (пробіг 2К)

Мій підхід:

1. Дізнайтеся, що вбиває видів, і визначте бажану поведінку (функціональну)
2. Реалізація бажаної поведінки в коді (технічному)
3. Дайте пріоритет . Це важливіше чи менш важливо, ніж інша бажана поведінка.
4. Оптимізуйте середній геометричний бал, налаштувавши параметри розчинів.

Я випробував понад 2000 наборів параметрів з тими ж 50 насінням. Були відібрані найперспективніші набори, які були забиті за допомогою 250 однакових насінин, а ті, що мають найвищий ранг, були подачею для наступного раунду тесту. Тому мені вдалося створити генетичний алгоритм, щоб знайти оптимальний генетичний алгоритм для цієї проблеми, як це запропонував користувач mbomb007 .

Бажана поведінка:

1. Вид повинен дізнатися, які кольори безпечні, а які - погані.
2. Вид повинен головним чином зосередити своє рішення, куди рухатись, базуючись на 3 клітинках прямо спереду, але якщо відсутні хороші рухи, слід враховувати вертикальні або назад руху
3. Вид також повинен виглядати те, що знаходиться за межами 8 клітин навколо нього, і використовувати це в інформації для прийняття рішень
4. Вид повинен навчитися визначати пастки .
5. Деякі види помилково припускають, що стіни хороші і намагаються постійно переміщатися до них і тому застрягають перед стінами. Якщо вони є видом з найвищим показником в цей момент, їх ДНК з неправильним припущенням про стінку багато разів дублюється у новонароджених . Через деякий час усі види застрягають перед стінами, і жоден з них не досягає мети набрати очки. Як зупинити дебілів?

Способи зберігання даних:

Ми хочемо, щоб вид навчився речам, пристосувався до його оточення, став найбільш придатним. Це неминуче працює лише, якщо навчання можна якось зберігати. Навчання буде «зберігатися» у 100 бітах ДНК. Це дивний спосіб зберігання, оскільки ми не можемо змінити значення нашої ДНК. Отже, ми припускаємо, що ДНК вже зберігає інформацію про погані та добрі кроки. Якщо для певного виду правильна інформація зберігається в його ДНК, він буде рухатися швидко вперед і виробляти багато нових видів з його ДНК.

Я з’ясував, що середній геометричний бал чутливий до того, як зберігається інформація. Давайте припустимо, що ми читаємо перші 4 біти зі 100 біт ДНК і хочемо зберігати це в цілій змінній. Це можна зробити кількома способами:

1. десяткове зберігання даних: використовуючи вбудовану dnarangeфункцію, приклад: 10114 біти стануть `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функції (визначеної нижче), приклад: 4bit 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функції (визначеної нижче), приклад: 4 біт 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;
}

Різниця між методами зберігання:

• Десятковий спосіб зберігання є вразливим для однієї бітової зміни ДНК. Коли значення бітсума змінюється з 1011 на 0011, його значення змінюється від 3 до 2, що є незначним зміною.
• Десятковий спосіб зберігання є однорідним . Кожне з можливих значень має відбуватися однакові зміни. Шанс, що ви прочитаєте значення 15 з 4-бітного блоку пам'яті, становить 1/16 = 6%. Спосіб зберігання смуг не є однорідним . Шанс, що значення 4 бітової смуги менше або рівне, що 6 дорівнює (15-3) / 16 = 81% (усі 16 комбінацій, крім 0111,1110,111). Нижче візуального зображення, яке показує форму розподілу. Як ви бачите на синій стрілці, шанс 4-бітової смуги бути меншим або рівним 6 становить 81%:

Визначте пріоритетні рішення.

Коли ColorScorePlayer виявив два ходи вперед з однаковими оцінками, робиться довільний вибір. ІМХО, ви ніколи не повинні використовувати функцію випадкової v.rng.rint()функції . Натомість ви повинні використовувати цю можливість рівних балів як гачок, щоб оцінити рішення для ефектів другого порядку.

Ефект першого порядку отримує найвищий пріоритет. Якщо досягнуто рівних балів, рішення з пріоритетом 2 переважає тощо. Налаштування параметрів рішення ви можете впливати на ймовірність виникнення рівних балів і таким чином змінювати вагу рішень пріоритету 1 та пріоритету 2.

Реалізація бажаної поведінки

Дізнайтеся, які кольори безпечні:

• 33% з 16 кольорів погані, тому, коли оцінка ходу нижче 63/3, переміщення заборонено. Тому threshold = 63/3=21де 63 - максимальна оцінка для 6 біт, а 33% = 1/3 (можна переглянути на графіку вище).

Якщо хороших рухів немає, рухайтеся вертикально або назад:

• Якщо не дозволяється рухатись вперед, вертикальні рухи будуть порівнюватися один з одним аналогічно. Якщо також не допускаються вертикальні ходи, то зворотні рухи рейтингуються. Це досягається за допомогою weightMoveзмінної.

Подивіться, що далі:

• Якщо 2 або 3 ходи мають однакові бали, поле 3x3 навколо цих ходів визначатиме (через x2та y2циклі), який є найкращим варіантом (через mainSubScoreзмінну). Найправіший стовпець у цьому полі 3х3 веде.

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 (2К пробіжки)

Перші 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

Визначте пастки:

Я досліджував ДНК виду з найвищим балом, коли довільна гра закінчилася з використанням накопичувача bitsum4 (тому оцінка кольорів має діапазон [0,4]):

• оцінка 0: Телепорт назад, обидві стіни, 1x сейф
• забив 1: Пастка назад (так нешкідливо), Телепорт назад, 1x сейф
• забив 2: Пастка вперед (настільки небезпечно), 1x безпечно
• забив 3: Телепорт вперед, 5-кратний сейф
• забив 4: Телепорт вперед, 1x сейф

З цього можна зробити висновок, що стіни та телепорти отримують правильну оцінку. Пастки не визначаються, оскільки вони залежать від напрямку та кольору походження, в той час як оцінка проводиться за кольором призначення. Тому є необхідність також зберігати дані про колір походження, так v(0,0). В ідеальному світі ми хотіли б зберігати інформацію для 16 кольорів х 8 напрямків х 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 (2К пробіжки)

Перші 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 201,080 1 1 102 1 104 94,444 2 95 1 44 94 444

Неправильне припущення про стіну дублюється багато разів новонародженим дебілами:

Деякі види неправильно припускають, що стіни хороші і намагаються постійно переміщатися до них і тому застрягають перед стінами. Вони також можуть застрягти в нескінченних петлях телепортерів. Ефект однаковий в обох випадках.

Основна проблема полягає в тому, що після декількох сотень ітерацій деякі гени стають дуже домінуючими . Якщо це "правильні" гени, ви можете отримати дуже високі бали (> 1 мільйон балів). Якщо це неправильно, ви застрягли, оскільки вам потрібна різноманітність, щоб знайти «правильні» гени.

Бійці дебілів: Рішення 1: інверсія кольору

Першим рішенням я спробував використовувати частину невикористаної пам'яті, яка все ще дуже різноманітна. Припустимо, ви виділили 84 біт на вашу кольорову пам'ять і пам'ять пошуку пастки. Решта 16 біт будуть дуже різноманітними. Ми можемо заповнити 2 десяткових змінних, які мають значення на проміжку [0,255], і вони є однорідними, це означає, що кожне значення має шанс 1/256. Змінні будуть називатися inInverseі inReverse.

Якщо inInverseдорівнює 255 (шанс 1/256), то ми будемо зворотно тлумачити кольорові оцінки . Тож стіна, яку дебіл вважає безпечною через її високу оцінку, отримає низький бал і тому стане поганою ходою. Недоліком є ​​те, що це також вплине на гени "прав", тому ми матимемо менш високі результати. Крім того, цьому inInverseвиду доведеться відтворювати себе, і його діти також отримають частини домінуючої ДНК. Найважливіша частина - це повернення різноманітності.

Якщо inReverseдорівнює 255 (шанс 1/256), ми повернемо порядок зберігання позицій кольорових балів . Тому раніше колір 0 зберігався в бітах 0-3. Тепер колір 15 буде зберігатися в цьому положенні. Різниця у inInverseпідході полягає в тому, що inReverseволя скасує виконану досі роботу. Ми знову на площі. Ми створили вид, який має схожі гени, як і коли розпочалася гра (за винятком пам'яті пошуку пастки)

Через оптимізацію він перевіряється, якщо розумно використовувати inInverseі inReverseодночасно. Після оптимізації було зроблено висновок, що бал не збільшувався. Проблема полягає в тому, що у нас є більш різноманітна популяція генів, але це також впливає на «правильну ДНК». Нам потрібне інше рішення.

Бійці дебілів: Рішення 2: хеш-код

У виду є 15 можливих вихідних позицій, і в даний час є занадто велика ймовірність, що він піде точно таким же шляхом, якщо він почне ставитись в одне і те ж вихідне положення. Якщо він дебіл, який любить стіни, він буде застрягати на одній стіні знову і знову. Якщо йому пощастило вдатися до стіни, що передує далеко, він почне домінувати над складом ДНК зі своїми помилковими припущеннями. Нам потрібно, щоб його нащадки йшли дещо іншим шляхом (оскільки для нього все одно пізно), і не застряватимуть на далеко передній стіні, а на більш сусідній стіні . Цього можна досягти, ввівши хеш-код .

Хеш - код повинен мати мету , щоб однозначно ідентифікувати і маркувати поточний стан на дошці. Мета - не з’ясувати, що таке (x, y) позиція, а відповісти на запитання, які раніше мої предки були в цьому місці?

Припустимо, ви мали б перед собою повну дошку, і ви зробили б jpg кожні 5 на 5 можливих клітин. Ви б закінчилися (53-5) x (15-5) = 380 зображень. Наведемо ці числа зображень від 1 до 380. Наш хеш-код слід розглядати як такий ідентифікатор, з тим різним, що він не працює від 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 і прочитаємо там, якщо нам слід вибрати верхню або нижню клітинку (коли там - рівний бал). Таким чином, ми опинилися б у абсолютно такій же ситуації (коли ми, наприклад, подорожуємо дошкою вдруге і починаємо з тієї ж позиції), приймаємо ті самі рішення. Оскільки у нас немає нескінченної пам’яті, ми застосуємо модуль розміру наявної пам’яті до хеш-коду . Поточний хеш-код хороший тим, що розподіл після операції модуля є однорідним.

Коли потомство подорожує тією ж дошкою з дещо зміненою ДНК, він у більшості випадків (> 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};
}