Лягушка Чемпион


11

Игра

Большинство из нас знает о Frogger , аркадной игре 80-х годов, цель которой - безопасно перелезть лягушке через оживленную трассу и заполненный опасными водоемами, чтобы благополучно добраться до дома.

Несколько месяцев назад была поставлена ​​задача разработать клон Frogger. Но зачем клонировать Frogger, когда можно играть в Frogger? :)

Рассмотрим следующую упрощенную игровую сетку:

 XXXXXXXXXXXXXXXXXXXXXXX  North Safe Zone
 -----------------------
|                       | <<<<       Express Lane West        (Lane 1)
|                       |     >      Gridlock East            (Lane 2)
|                       |   <<       Freeflowing Traffic West (Lane 3)
|                       |    <       Gridlock West            (Lane 4)
|                       |     >>>>   Express Lane East        (Lane 5)
 -----------------------
 XXXXXXXXXXX@XXXXXXXXXXX  South Safe Zone
 \__________ __________/
            '
  23 cells horizontally

У нас есть пять полос движения, каждая шириной 23 ячейки, и две безопасные зоны (где лягушка может безопасно перемещаться влево и вправо), также шириной 23 ячейки. Вы можете игнорировать правую и левую границы, так как они для наглядности.

Наша лягушка начинается в южной безопасной зоне, в центральной (12-й) ячейке, как показано на @рисунке выше.

Время в игре делится на отдельные шаги, называемые кадрами. Froggy - быстрая лягушка, которая может прыгать на одну клетку в любом направлении (вверх, вниз, вправо, влево) за кадр. Он также может остаться на любом кадре. Движение по пяти полосам движения происходит с постоянной скоростью следующим образом:

  • движение в экспресс-полосе на запад (полоса 1) перемещается на 2 ячейки влево на каждый кадр
  • движение в безвыходном положении на восточной полосе (полоса 2) перемещается на 1 ячейку вправо каждый второй кадр
  • движение в свободном потоке на западную полосу движения (полоса 3) перемещается на 1 ячейку влево на каждый кадр
  • движение в тупике западная полоса (полоса 4) перемещается на 1 ячейку влево каждый второй кадр
  • движение на экспресс-полосе на восток (полоса 5) перемещается на 2 ячейки вправо каждый кадр

Сам трафик однозначно определен для ок. 3000 шагов в этом текстовом файле . «Движение» состоит из транспортных средств и пространства между транспортными средствами. Любой персонаж, который не является пробелом, является частью транспортного средства. Текстовый файл содержит пять строк, соответствующих пяти полосам трафика (в том же порядке).

Для западных полос движения в начале кадра 0 (начало игры) мы считаем, что первое транспортное средство на полосе движения находится прямо за правым краем игровой сетки.

Для полос движения в восточном направлении дорожную полосу следует считать «задом наперед» в том смысле, что транспортные средства появляются в конце строки. В начале кадра 0 мы считаем, что первый автомобиль на этих дорожках находится чуть дальше левого края игрового поля.

Рассмотрим в качестве примера:

Traffic Lane 1:  [|==|  =
Traffic Lane 2:  |) =  o
Traffic Lane 3:  (|[]-[]:
Traffic Lane 4:  <| (oo|
Traffic Lane 5:  |==|] :=)

Тогда игровая сетка будет выглядеть следующим образом:

Start of Frame 0       XXXXXXXXXXXXXXXXXXXXXXX
                                              [|==|  =
                |) =  o
                                              (|[]-[]:
                                              <| (oo|
              |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 1       XXXXXXXXXXXXXXXXXXXXXXX
                                            [|==|  =
                |) =  o
                                             (|[]-[]:
                                              <| (oo|
                |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 2       XXXXXXXXXXXXXXXXXXXXXXX
                                          [|==|  =
                 |) =  o
                                            (|[]-[]:
                                             <| (oo|
                  |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 3       XXXXXXXXXXXXXXXXXXXXXXX
                                        [|==|  =
                 |) =  o
                                           (|[]-[]:
                                             <| (oo|
                    |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

После того, как весь трафик на линии «исчерпан» (т. Е. Заканчивается строка), мы считаем все символы в строке пробелами.

Наша лягушка сплющивается, если происходит любое из следующего:

  • лягушка занимает клетку, занятую транспортным средством, на любом кадре
  • лягушка остается неподвижной в экспресс-полосе, и транспортное средство шириной 1 ячейка проезжает над ним в этой раме
  • лягушка прыгает на восток "через" транспортное средство, направляющееся на запад, или прыгает на запад через транспортное средство, направляющееся на восток
  • лягушка выпрыгивает за пределы игровой сетки 7 (линия) на 23 (клетка) в любом кадре

Обратите внимание, что это единственные условия, при которых лягушка сплющивается. В частности, допускается прыгание лягушки по трафику «с», равно как лягушка прыгает в или из ячейки на экспресс-полосе, которую проезжает транспортное средство шириной 1 в той же раме.

Цель и оценка

Цель задачи программирования - перевести лягушку через дорогу как можно больше раз, прежде чем последний автомобиль покинет игровую сетку . То есть программа завершается сразу после завершения кадра X , где кадр X - это первый кадр, который переводит сетку в состояние, когда больше нет транспортных средств.

Вывод вашей программы должен быть строкой (или текстовым файлом), содержащей последовательность ходов лягушки с использованием следующей кодировки:

<   frog moves left
>   frog moves right
^   frog moves up
v   frog moves down
.   frog remains stationary

Например, строка <<^.^указывает, что лягушка дважды перемещается влево, затем вверх, затем делает паузу на один кадр, а затем снова поднимается вверх.

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

Некоторые важные правила:

  1. Лягушка не должна быть раздавлена.
  2. Пожалуйста, опубликуйте свое решение (последовательность шагов) вместе с программным кодом, встроенным или в виде текстового файла (например, с использованием pastebin.com).
  3. Наша лягушка является дальновидной и предвидящей, поэтому ваша программа может использовать любые данные о трафике в любом кадре, находя решения. Сюда входят данные о трафике, который еще не достиг игровой сетки.
  4. Сетка не оборачивается. Выход из сетки вызовет сплющивание лягушки и, следовательно, не допускается.
  5. Ни в коем случае трафик не «сбрасывается» или лягушка «телепортируется». Симуляция непрерывная.
  6. Лягушка может вернуться в южную безопасную зону после выхода из нее, но это не считается точкой. Аналогично для северной безопасной зоны.
  7. Победителем конкурса является программа, которая генерирует последовательность ходов, дающую наибольшее количество пересечений.
  8. Любые дополнительные вопросы или проблемы, пожалуйста, не стесняйтесь задавать в разделе комментариев.

Для некоторого дополнительного стимула я добавлю награду +100 повторений к победившей программе, когда смогу это сделать.

Бонусы

+ 2,5% к базовому счету * (до + 10%) за каждый угол игровой сетки, к которой прикоснулась лягушка. Четыре угла сетки являются самыми левыми и правыми ячейками двух безопасных зон.

+ 25% к базовому счету *, если ваша последовательность движений удерживает лягушку в пределах +/- 4 клетки слева или справа от его начальной клетки в течение всего моделирования (он, конечно, может свободно перемещаться по вертикали).

Бонус за выигрыш отсутствует, но специальные реквизиты в ОП будут доступны всем, кто публикует быстрый и грязный валидатор решений, так что мне не нужно его программировать. ;) Валидатор просто примет последовательность ходов, обеспечит ее законность (согласно правилам и файлу трафика) и сообщит свою оценку (т. Е. Общее количество пересечений).

* Общая оценка равна базовой оценке плюс бонус, округленный до ближайшего целого числа.

Удачи, лягушка!


Всем, кто хочет опубликовать валидатор решения: не публикуйте его как ответ .
Geobits

Верно. Ссылка на код в комментарии или дополнение к решению будет предпочтительным способом отправки валидатора.
COTO

Должен ли первый кадр, в котором продвигаются медленные полосы, быть таким же, как первый кадр, в котором продвигаются другие полосы, или на один кадр позже?
февраля

Кроме того, можно ли забить, достигнув конечной зоны на первом кадре, в котором все машины очистили поле?
Feersum

@feersum: медленные полосы продвигаются на один кадр позже. Они остаются неподвижными в самом первом кадре, как показано в примере. Что касается выигрыша лягушки на самом последнем кадре: да, это возможно. Если лягушка переместилась в безопасную зону на том же кадре, где последний автомобиль покидает игровое поле, набирается одно очко.
COTO

Ответы:


5

С ++: 176

Выход:

176
^^^^^^>vvvvvv>^^^^>^^>>>>>>><<<.vv>v<<<.vvv<<<<<<^.^.^.^.>.>^^<.>>>>>>v>v>.>v<<<<v.<.vv<<<<<^^.<^<<<<<<^.^^>>>>vv>.>.v<v.vv>>^>>^<^<<<<<<<^>.>^^<<<.>>>>>vv>v<vvv<<<<<^^.<^^^^.....vv>.>.>.>v<<vvv<<>>>>^>^<.<.^^>^^>>>>vv.>v<vv.v^>^<.<.<^<^>.>^^>>>>vv.v<<<<<<.vvv<<<<^^^<<v^^.>.^^..>>>>>>vv>.>.v.vvv>>>^>^^<<<<<<<<<^>.>^^>>>>vvv<<v.<.vv<<<<<<>>>>>^^^<<<^^^<<>>vv>.v<<>vvv<<><>>>>>>>^>^^<^^^<.>>>>>>>>vv>.>v<<<vvv<<<<<^^^<<v.<.<^<<^.^<<^...>>>>>>>>>>>>>vv>v<vvv<<<<<<<<^>^.<.^^>.>^^<<<<<<<..>>>>vv>.vvvv<<<<>^.v>>>^^.^^>^<^<>>>>>>>>>vv>vvvv<<<<^^^<^>^<<^.>>vv>v<vvv<<<<<<<>>>>>>>^>^^^.^^>>>>>vvv<<vvv<<<^^^^^^<vvv<<<<<<<vvv<<<>>>>>>>>^^.<.<.^.^.^<^<>>>>>>>>>>vvv<<.vvv<<<^^<^<<^^<<^<<<>>>>vv>.vvvv>>^>>^<.<.<^<<<<<.^^<<^.......>vv.>.>.>v<vvv>>>>>>^>^.<.<^<.^^^<.>>>>>>>vvv<<<v.<vv<<<^^<.<.<.<^<<<^>^^..........v<vvvv>v>>>>>^>>^^^>^^>>>vv>v<vvv<<<<<<<<>^^.<.<^<^^^<.........>vv.>.vvvv>>>>^^<.<.<^^^<^<<.v<v>.>.>.>.>.>.>.vvv.v<<<<<^^<^<^>.>.>.>.^<^.>>>>>>>>vv>v<<vvv<<>>>>>^^^.^.>^<^<<<<<<<<.vv.>.v<<<.vvv<>>>>>^>^.<.<.<.<^^.^<<^<.....>>vvv<.>>vvv<<<>>>>>>>>^^^<<<.^.>.>^^.>>>>>vv.>v<vvv<<<>>>>>>^>^<^<<^.^^<vvv<<<<<vv.v<>>>>>>>>>>^>^.^^>^^<<<<.>vv.>.vvvv>^>>^.<.<.<^<<<^>^^>>>vv>v<<<<<vvv<<<>>>>>^^<.<.<.<.<^<^>.^^.>>>>>vv>v<>vvv<<<<<<<^>^.<^<<<<<<<^^^.>>>>>vv>v<>vvv>>>^^<.<^<<<^>^^.>>>>vv>.v<<vvv<<<<<^^^<<<<<^>.^^<>>>>>>>vv>.>v<<vvv<<<<<<<>>>^>>.>^^^.>^^<>>>>>>vv>vv.<.<.vv>>>>^^<.<.<.<^<<^.>^^.>>>>>vv.>.>v<<vvv<<>>>>>^^<.<.<.^^>.>.>^^<<<<<<<<.>>>>>>vv>v<<v.<.<vv<<<<^^.<^<<<.^^^<.vv.>v<vvv<<<>>>>>>^>^<^<<^.^<^<<.>>vv>.>.>.>vvvv>>>>>>^>^^^^^<<<.vvv<<<<<<vvv>>>>>^>^<.<^<<^.>.>.^^>>>>vv>.>v<<<<<<vvv<<<<^^^<.^.>^^>>>>vvv<<v.vv<<<^>>^^<<<.^^<<^>>>>>>>>>vvv.v.vv<>>>>>^>^^<<<<<<<<<<<<<<<<^^^..>>>>>vv>.>.>.>v<<v.<.<.vv<<<<<^^^<^>.^^...>>>>>>>>vv.v<.vvv>>>^>^<.<^^^^>>>vv>v<<<vvv<<<<>>>>>>^>^.<.<^<^>.>^^.>>>>>vv.v<<<<<<<<vvv<<<<^^<^<<<<<><^>.>^^>>>>vv.>.>.vvv.v>>>>>>>^^<.<^<<^^^>>>vv>.>.>.>.>v<<v.<.<vv>>>>^^^<<<<<.^.>^^>>>vv>.>v<vvv<<<<^^<.<.<.^^>^^>>>vv>.>.v<<<v.<vv<<<<^^.<^<<<^^^>>>>vvvvvv<<<<<<<<>^^.^>>^^^<>>>>>>>vvv<<<v.vv>>>>>^>>^^<<<<<^>.^^>>>>vv>.>v<<<<vvv<<<^^<.<.<.<^<<<<<^>^^>>>>vv.>vv.v.v<^>.>^.<.^^^^>>>>vv>.>.>.v<<<<<<vvv>>>>^^<.<.<^<<^^<^>>>>>>vv>v<<.vvv^>^^<<<^>^^<<<<<<.vvv<<vv>.v>>>>>>^>.>^^<<<<<^>.>.>.>.>.^^>>>>vv>.>.>v<<<<<vvv<<<<^^<^<<^.^^>>>>vv>.>.>.>v<vvv<<<<<^^.<.<^<<^^^>>>>>>>>>>>vv>.>.>.>.>vvvv<<<<^^.<.<^<^^^<<<<<<vvv<v.<vv<<<<^v>>>>>>>>>>^^^<.^.>.>.^^>>>>vvv<<<<<<<vvv<<<<<<<>^^.<^<.^^^.>>>>vv>v<vvv<>>>>^^.<.^.^.>.^<^>>>>>>>>vvvv.<.<vv<<<<^^^<<<<<^>.^^<.vv>.v<<vvv<<><>>>>>^>>^.<^<^^^<<<.>>vv>.>v<<<<v.vv>^>>^.<^^.^^.>>>>>vv>.>.>.v<v.<vv<<<<<^.^^^.>^^<>>>>>>vv>.v<<<v.<vv<<<<>>>>>>>>>>>^^<.<.<.<.<^<<^^<^<<<>>>>>>>vv>v<<<vv.v>>>>>>>>^>^<.<^<<<<<<<<<<<.^.>^^<<<vvv.v.<vv<<<^.>>^.<^^.>.>^^<<......vv.v>vvv>>>^.v^>>^^<<^^^<.>>>>>>>vvv<v.<.<.vv<<<<^^<.<.<.^^^^<.>>>>>>>>vvv<v.<vv^.>^^<<^^^vv>vvvv^>>>>>>>^^^^^vvvvvv^^^^^^vvvvvv>>>>

Есть до 8 миллионов состояний комбинаций позиции X время X множества посещаемых углов, так что они могут быть исчерпывающе искали менее чем за 1 секунду. Если в коде нет ошибок, его нельзя победить. Оптимальная стратегия состояла в том, чтобы использовать всю доску, поскольку это позволяет лягушке пересекать дорогу 160 раз по сравнению с 120, когда ограничены центром. Посещение углов не стоило пересечений, так как движение было очень интенсивным.

/* feersum  2014/9
 /codegolf/37975/frogger-champion */

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <cstring>

#define B(F, CST, X, Y) best[ ((F)*NCST + (CST)) * BS + (Xmax-Xmin+1) * ((Y)-Ymin) + (X)-Xmin]
#define TL(i) ((int)t[i].length())
#define ABSPEED(I) (speed[i]<0?-speed[i]:speed[i])
#define errr(X) { cout<<"ERROR!!!!!!!!"; return X; }

#define DRAW 0
#if DRAW
    #include <unistd.h>
#endif


using namespace std;

int bc(int cs) {
    int c = 0;
    while(cs) {
        c += cs&1;
        cs >>= 1;
    }
    return c;
}

int main()
{
    const bool bonusTwentyfive = false;
    const int COLS = 23, T_ROWS = 5, YGS = T_ROWS + 2, XGS = COLS + 2;
    string t[5];
    int speed[] = {-4, 1, -2, -1, 4};
    ifstream f("t.txt");
    for(int i = 0; i < T_ROWS; i++)
        getline(f, t[i]);
    if(f.fail())
        return 1;
    f.close();
//for(int i = 0; i < 5; i ++)t[i]="xxx";

    char g[XGS][YGS];

    int mov[][3] = { {-1,  0, '<'},
                     {+1,  0, '>'},
                     { 0, -1, '^'},
                     { 0, +1, 'v'},
                     { 0,  0, '.'} };


    int Ymin = 0, Ymax = YGS-1;


    const int Xstart = 11, Xmaxmove = bonusTwentyfive ? 4 : 10;
    const int Xmin = Xstart - Xmaxmove, Xmax = Xstart + Xmaxmove;

    const int NCST = bonusTwentyfive ? 1 : 1<<4;

    int maxfr = 0;
    for(int i = 0; i < T_ROWS; i++) {
        if(speed[i] < 0) {
            for(int m = 0, n = t[i].length()-1; m < n; ++m,--n)
                swap(t[i][m], t[i][n]);
        }
        int carslen = TL(i);
        for(char*c = &t[i][speed[i]>0?TL(i)-1:0]; carslen; carslen--, speed[i]>0?--c:++c)
            if(*c != ' ')
                break;
        if(carslen)
            maxfr = max(maxfr, ( (carslen + COLS) * 2 + ABSPEED(i)-1 ) / ABSPEED(i));
    }
    const int BS = (Xmax-Xmin+1)*(Ymax-Ymin+1);
    int *best = new int[(maxfr+1)*NCST*BS];
    memset(best, 0xFF, (maxfr+1)*NCST*BS*sizeof(int));
    memset(g, ' ', sizeof(g));
    B(0, 0, Xstart, Ymax) = 0;

    for(int fr = 0; fr < maxfr; fr++) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;
                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(N > B(fr+1, cs|csor, X, Y))
                            B(fr+1, cs|csor, X, Y) = N;
                    }


                }
            }
        }
    }

    int score = 0, xb, yb, cb, nb;
    for(int x = Xmin; x <= Xmax; x++) {
        for(int y = Ymin; y <= Ymax; y++) {
            for(int cs = 0; cs < NCST; cs++) {
                if(B(maxfr, cs, x, y) * (40 + bc(cs)) / 40 >= score) {
                    score = B(maxfr, cs, x, y) * (40 + bc(cs)) / 40;
                    xb = x, yb = y, cb = cs, nb = B(maxfr, cs, x, y);
                }
            }
        }
    }
    char *mvs = new char[maxfr+1];
    mvs[maxfr] = 0;

    for(int fr = maxfr-1; fr >= 0; --fr) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;

                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(X==xb && Y==yb && N == nb && (cs|csor) == cb) {
                            mvs[fr] = mov[m][2];
                            xb = x, yb = y, nb = B(fr, cs, x, y), cb = cs;
                            goto fr_next;
                        }
                    }
                }
            }
        }
        errr(3623);
        fr_next:;
    }

    if((xb-Xstart)|(yb-Ymax)|nb)
        errr(789);
    #if DRAW

        for(int fr = 0; fr <= maxfr; ++fr) {
            memset(g, ' ', sizeof(g));
            for(int r = 0; r < T_ROWS; r++) {
                for(int x = 0; x < XGS; x++) {
                    int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                    ind >= 0 && ind < TL(r) ? g[x][r+1] = t[r][ind] : ' ';
                }
            }
            g[xb][yb] = 'F';
            for(int y = 0; y < YGS; y++) {
                for(int x = 0; x < XGS; x++)
                    cout<<g[x][y];
                cout<<endl;
            }
            cout<<string(XGS,'-')<<endl;
            usleep(55*1000);
            for(int i = 0; i < 5; i++) {
                if(mvs[fr] == mov[i][2]) {
                    xb += mov[i][0];
                    yb += mov[i][1];
                    break;
                }
            }
        }

    #endif
    cout<<score<<endl;
    cout<<mvs<<endl;
}

1
Я не уверен, как вы определяете "состояния". Если мы рассматриваем состояние системы как временной профиль движения лягушки, существует приблизительно 5 ^ 3000 состояний, соответствующих профилю движения для 5 ^ 3000 возможных входов (пять возможных входов на ~ 3000 кадров). Очевидно, что только часть из них окажется приемлемой, но число допустимых состояний будет невозможно найти на многие сотни порядков. Когда вы отправляете свой окончательный ответ, пожалуйста, отправьте список ходов вместе с ним.
COTO

Кроме того, в случае, если неясно, обратите внимание, что лягушка может прыгать влево и вправо, находясь в пробке, если не нарушено ни одно из «сжатых» правил. Вы не ограничены в ожидании окон, в которых лягушка может прыгать вертикально, без боковых движений.
COTO

@COTO При расчете «состояний» я забыл важную вещь, а именно количество пересечений, поэтому попытался дать более четкое объяснение. Спецификация была довольно хорошо написана. Кажется, я правильно истолковал все эти конкретные вопросы с первого раза.
feersum

Я вычисляю оптимум как 162 + 10% = 178 пересечений, но у вас достаточно близко. Я действительно не хотел, чтобы это оказалось грубым, но, очевидно, мне следовало подумать над этой проблемой. Справедливости ради, я награду вас 100 представителями.
COTO

Видимо, мне нужно подождать 24 часа, прежде чем присудить «награду». По какой причине: кто знает. SE не должен хотеть, чтобы ответы были вознаграждены пунктуально. Если бы мы сделали это, террористы победили бы. : O
COTO
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.