Підрахунок істот на шестикутній плитці


18

Цей виклик змусить вас порахувати "істот" у грі на плитці Palago.

Істота - це будь-яка закрита форма, яку можна утворити плитками Palago відповідного кольору в шестикутній сітці.

Гра Palago складається з таких плиток:

Плитка Palago

Ці плитки можна обертати на 120 , 240 або взагалі не розміщувати і розміщувати десь на шестикутній сітці. Наприклад, ось (червона) істота, якій потрібно 12 плиток.Дванадцять створінь плитки.

Виклик

Мета цього виклику - написати програму, яка приймає ціле число nяк вхід і обчислює кількість істот (до обертання та відбиття), яким потрібні nплитки. Програма повинна мати можливість працювати n=10з TIO . Це , тому виграє найменше байтів.

Приклад даних

Значення повинні відповідати даним, знайденим у розділі "Підрахунки та оцінки історій" на веб-сайті творця . А саме

 n | output
---+-------
 1 | 0
 2 | 0
 3 | 1 
 4 | 0
 5 | 1
 6 | 1
 7 | 2
 8 | 2
 9 | 9
10 | 13
11 | 37
12 | 81

"Програма повинна мати можливість працювати n=10з TIO." - якщо це вимога швидкості виконання, будь ласка, використовуйте код-виклик замість коду-гольфу , останній посилається на завдання оптимізації чистого байту.
Джонатан

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

2
+1 Подібно до спіральної послідовності , цей виклик легко зрозуміти і вирішити насправді цікаво ... але вимагає зовсім небагато коду. : Р
Arnauld

1
Отже .... ми просто беремо введення та повертаємо висновок зі списку вище, для n від 1 до 10? Чи можу я просто використовувати таблицю пошуку?
BradC

6
н=10

Відповіді:


5

JavaScript (Node.js) , 480 417 байт

-63 байти завдяки @Arnauld. Ого.

n=>(E=(x,y,d,k,h)=>V[k=[x+=1-(d%=3),y+=~d%3+1,d]]?0:(V[k]=1,h=H.find(h=>h[0]==x&h[1]==y))?(d^(t=2-h[2])?E(x,y,t)||E(x,y,h[2]*2):E(x,y,t+2)):[x,y,0],I=c=>c.map(([x,y,t])=>[x-g(0),y-g(1),t],g=p=>Math.min(...c.map(h=>h[p]))).sort(),S=e=>(V={},e=E(0,0,0))?(--n&&H.pop(H.push(e),S(),S(e[2]=1),S(e[2]=2)),++n):n-1||E[I(c=H)]||[0,0,0,++N,0,0].map(r=>E[I(c=c.map(([x,y,t])=>[-x-y,r?y:x,(r?t*2:t+1)%3]))]=1))(H=[[N=0,0,1]])&&N

Спробуйте в Інтернеті!

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

Пошук порожніх шестикутників

Пошук істот:

  • Ініціалізуйте список плиток з плиткою 1 на 0,0
  • Рекурсивно:
    • Шукайте порожній шестигранник, необхідний для завершення створіння
    • Якщо порожній шестигранник знайдений
      • Додайте кожен тип плитки 0,1,2 до порожнього шестигранника та повторіть
    • Якщо порожній шістнадцятковий не знайдено
      • Якщо істота правильного розміру і її вже немає в зоопарку
        • Приріст кількості виразних істот, знайдених одним
        • Додайте до зоопарку всі обертання та відображення істоти

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

Ось оригінальний напрямок та ключ плитки Arnauld:

Направлення та ключ плитки Арнольда

Уявіть, що ми починаємо з плитки A типу 1 у синій крапці. Здається, що нам доводиться повторюватися у d = 0 і d = 5. Однак, яка б плитка розміщена у d = 0, вона, безумовно, матиме вихід у d = 4, який відвідає той самий шестигранник, що й вихідний плитку A в d = 5. Це відкриття Арнольда, і саме це мене і задумало.

Зауважте, що:

  • Кожна плитка, яка має вихід у d = 0, має вихід у d = 5
  • Кожна плитка, яка має вихід у d = 2, має вихід у d = 1
  • Кожна плитка, яка має вихід у d = 4, має вихід у d = 3

  • Кожна плитка, яку можна ввести з d = 0, має вихід у d = 4

  • Кожна плитка, яку можна ввести з d = 2, має вихід у d = 0
  • Кожна плитка, яку можна ввести з d = 4, має вихід у d = 2

Це означає, що нам потрібно розглянути лише напрямки 0,2,4. Будь-які виходи в напрямках 1,3,5 можна ігнорувати, оскільки замість них можна досягти шестигранних напрямків у напрямках 1,3,5 із сусіднього шестигранника, використовуючи напрямки 0,2 або 4.

Як це круто !?

Розділені напрямки

Тож я позначаю такі напрямки та плитки (зображення Арнольда відредаговано):

Спрощені вказівки

Тепер у нас є такі відносини між плитками, записами та виходами:

    |  t=0  |  t=1  |  t=2
----+-------+-------+-------
d=0 |  0,2  |  1,2  |    2
d=1 |  0,2  |    0  |  0,1
d=2 |    1  |  1,2  |  0,1

Тож виходи такі: d + t == 2? (4-т)% 3: 2-т і 2 * т% 3

Шестикутні обертання та відбиття

Для обертання та відбиття я вирішив спробувати x, y шестикутні осьові координати замість координат куба x, y, z.

-1,2   0,2   1,2   2,2
    0,1   1,1   2,1
 0,0   1,0   2,0   3,0

У цій системі обертання та відбиття були простішими, ніж я очікував:

120 Rotation:   x=-x-y   y=x   t=(t+1)%3
Reflection:     x=-x-y   y=y   t=(t*2)%3

Щоб отримати всі комбінації, які я виконував: гниль, гниль, гниль, відбиття, гниття, гниль

Код (оригінальний 480 байт)

f=n=>(
    // H:list of filled hexes [x,y,tile] during search for a complete creature
    // N:number of distinct creatures of size n
    // B:record of all orientations of all creatures already found
    H=[[0,0,1]],N=0,B={},

// E: find an empty hex required to complete creature starting in direction d from x,y
    E=(x,y,d,k,h)=>(
        x+=1-d,
        y+=1-(d+1)%3,
        // V: list of visited hexes during this search in E
        V[k=[x,y,d]] ? 
            0
        : (V[k]=1, h=H.find(h=>h[0]==x&&h[1]==y)) ? 
            // this hex is filled, so continue search in 1 or 2 directions
            (d==2-h[2] ? E(x,y,(4-h[2])%3) : (E(x,y,2-h[2]) || E(x,y,h[2]*2%3))) 
        : [x,y,0] // return the empty hex 
    ),

    // I: construct unique identifier for creature c by moving it so x>=0 and y>=0
    I=c=>(
        M=[0,1].map(p=>Math.min(...c.map(h=>h[p]))),
        c.map(([x,y,t])=>[x-M[0],y-M[1],t]).sort()
    ),

    // A: add complete creature c to B
    A=c=>{
        n==1&&!B[I(c)]&&(
            // creature is correct size and is not already in B
            N++,
            [0,0,0,1,0,0].map(
                // Add all rotations and reflections of creature into B
                // '0' marks a rotation, '1' marks a (vertical) reflection
                // rotation:   x=-x-y   y=x   t=(t+1)%3
                // reflection: x=-x-y   y=y   t=(t*2)%3
                r=>B[I(c=c.map(([x,y,t])=>[-x-y,r?y:x,(r?t*2:t+1)%3]))]=1)          
        )
    },

    // S: recursively search for complete creatures starting with hexes H
    S=e=>{
        V={};
        (e=E(0,0,0)) ?
            // e is a required empty hex, so try filling it with tiles 0,1,2
            (--n && (H.push(e),S(),S(e[2]=1),S(e[2]=2),H.pop()), ++n)
        : A(H) // creature is complete, so add it to B
    },

    S(),
    N
)

Код (Arnauld 417 байт)

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

f=n=>(
    // E:find an empty hex required to complete creature starting in direction d from x,y
    E=(x,y,d,k,h)=>
      V[k=[x+=1-(d%=3),y+=~d%3+1,d]] ?
        0
      :(V[k]=1,h=H.find(h=>h[0]==x&h[1]==y)) ?
        (d^(t=2-h[2]) ? E(x,y,t) || E(x,y,h[2]*2) : E(x,y,t+2))
      :[x,y,0],

    // I: construct unique identifier for creature c by moving it so x>=0 and y>=0
    I=c=>c.map(([x,y,t])=>[x-g(0),y-g(1),t],g=p=>Math.min(...c.map(h=>h[p]))).sort(),

    // S: recursively search for complete creatures starting with hexes H
    S=e=>
      (V={},e=E(0,0,0)) ?
        (--n&&H.pop(H.push(e),S(),S(e[2]=1),S(e[2]=2)),++n)
      :n-1
        ||E[I(c=H)] 
        // creature is the correct size and has not been seen before
        // so record all rotations and reflections of creature in E[]
        ||[0,0,0,++N,0,0].map(r=>E[I(c=c.map(([x,y,t])=>[-x-y,r?y:x,(r?t*2:t+1)%3]))]=1)
)
// This wonderfully confusing syntax initializes globals and calls S()
(H=[[N=0,0,1]]) && N

Приємного розуміння напрямків! І я думаю, що це може бути гольф нижче розміру моєї відповіді.
Арнольд


@Arnauld Це приголомшливо! У мене зараз великий робочий день, але сподіваємось перевірити це завтра. Спасибі.
Джон Різ

20

JavaScript (Node.js) ,  578 ... 433  431 байт

f=(n,T=[B=[N=0,0,0,1,1]])=>!n||T.some(([x,y,q,m])=>B.some((p,d)=>m>>d&1&&((p=x+~-s[d],q=y+~-s[d+2],t=T.find(([X,Y])=>X==p&Y==q))?(q=t[3])&(p=D[d*3+t[4]])^p?t[f(n,T,t[3]|=p),3]=q:0:[0,1,2].map(t=>f(n-1,[...T,[p,q,-p-q,D[d*3+t],t]])))),s="2100122",D=Buffer("160).(9!'8 &$<%"))|n>1||[0,1,2,1,2,0].some((_,d,A)=>B[k=T.map(a=>[(h=n=>Math.min(...T.map(R=a=>a[A[(d+n)%6]]))-R(a))(0),h(3),(x=(a[4]+d*2)%3,d>2)*x?3-x:x]).sort()])?N:B[k]=++N

н=1н=13

Як?

Напрямки та плитка

Ми використовуємо наступні коди для 6-ти напрямних компасів та плиток:

напрямки та плитки

Ми припускаємо, що істота синя.

З'єднання

Нам потрібна таблиця, щоб знати, які частини істоти потрібно з'єднати з іншими плитками, коли ми вводимо задану плитку в заданому напрямку:

     |  T=0  |  T=1  |  T=2
-----+-------+-------+-------
 d=0 | 0,4,5 | 1,2,4 |   4
 d=1 | 0,3,5 | 1,2,3 |   3
 d=2 | 0,3,4 |   0   | 0,1,2
 d=3 | 3,4,5 |   5   | 1,2,5
 d=4 |   2   | 2,3,4 | 0,2,5
 d=5 |   1   | 1,3,4 | 0,1,5

Приклад:

15134

з'єднання

5

     |  T=0  |  T=1  |  T=2
-----+-------+-------+-------
 d=0 |  0,4  | 1,2,4 |   4
 d=1 |  0,3  | 1,2,3 |   3
 d=2 | 0,3,4 |   0   | 0,1,2
 d=3 |  3,4  |   -   |  1,2
 d=4 |   2   | 2,3,4 |  0,2

+32

     |  T=0  |  T=1  |  T=2              |  T=0  |  T=1  |  T=2
-----+-------+-------+-------       -----+-------+-------+-------
 d=0 |   17  |   22  |   16          d=0 |  "1"  |  "6"  |  "0"
 d=1 |    9  |   14  |    8          d=1 |  ")"  |  "."  |  "("
 d=2 |   25  |    1  |    7    -->   d=2 |  "9"  |  "!"  |  "'"
 d=3 |   24  |    0  |    6          d=3 |  "8"  |  " "  |  "&"
 d=4 |    4  |   28  |    5          d=4 |  "$"  |  "<"  |  "%"

Після вирівнювання це дає:

D = Buffer("160).(9!'8 &$<%")

Координати

х+у+z=0

координати куба

Кредити: www.redblobgames.com

Це полегшить обертання та відображення на останньому кроці алгоритму.

Кодування плитки

Плитки зберігаються у списку, без конкретного порядку. Це означає, що нам не потрібно турбуватися про динамічне розподіл 2D, і ми можемо легко переглядати наявні плитки. Мінус полягає в тому, що, враховуючи конкретні координати, нам потрібно find()відповідна плитка у списку.

(х,у,z,м,т)

  • (х,у,z)
  • м
  • т012

Алгоритм

1(0,0,0)0

початкова плитка

Тому ця плитка кодується як [0,0,0,1,1].

При кожній ітерації ми шукаємо:

  • Плитка з відсутніми з'єднаннями: у цьому випадку ми послідовно намагаємось виконати з'єднання з кожним типом плитки.

  • Плитки, які вже підключені, але для яких потрібно додати нові підключення, оскільки вони були досягнуті в іншому напрямку: у цьому випадку ми оновлюємо маску напрямку (побіжно АБО) і примушуємо нову ітерацію.

Якщо всі з'єднання є дійсними і ми досягли потрібної кількості плиток, нам все-таки потрібно перевірити, чи це нове створіння, чи просто модифікована версія існуючого:

  1. Ми застосовуємо такі перетворення:

    • (х,у)(х,у)(у,z)(z,х)

    • (х,у)(у,х)(z,у)(х,z)

  2. (0,0)

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

  4. Нарешті ми примушуємо отриманий список до ключового рядка, який можна порівняти з іншими клавішами.

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

Прокоментував

f = (n, T = [B = [N = 0, 0, 0, 1, 1]]) =>
  // abort if n = 0
  !n ||
  // for each tile in T
  T.some(([x, y, q, m]) =>
    // for d = 0 to d = 4
    B.some((p, d) =>
      // if this tile requires a connection in this direction
      m >> d & 1 && (
        // look for a connected tile t at the corresponding position (p, q)
        (
          p = x + ~-s[d],
          q = y + ~-s[d + 2],
          t = T.find(([X, Y]) => X == p & Y == q)
        ) ?
          // if t exists, make sure that its direction mask is up-to-date
          (q = t[3]) & (p = D[d * 3 + t[4]]) ^ p ?
            // if it's not, update it and force a new iteration
            t[f(n, T, t[3] |= p), 3] = q
          :
            0
        :
          // if t does not exist, try each type of tile at this position
          [0, 1, 2].map(t => f(n - 1, [...T, [p, q, -p - q, D[d * 3 + t], t]]))
      )
    ),
    // s is used to apply (dx, dy)
    s = "2100122",
    // D holds the direction masks for the connections
    D = Buffer("160).(9!'8 &$<%")
  ) |
  // stop here if the above some() was truthy or we have more tiles to add
  n > 1 ||
  // otherwise, apply the transformations
  [0, 1, 2, 1, 2, 0].some((_, d, A) =>
    B[
      // compute the key k
      k =
        // by generating the updated tuples [x, y, type] and sorting them
        T.map(a =>
          [
            // transform the 1st coordinate
            (h = n => Math.min(...T.map(R = a => a[A[(d + n) % 6]])) - R(a))(0),
            // transform the 2nd coordinate
            h(3),
            // update the type
            (x = (a[4] + d * 2) % 3, d > 2) * x ? 3 - x : x
          ]
        ).sort()
    ]
  ) ?
    // if the key was found, just return N
    N
  :
    // if this is a new creature, store its key and increment N
    B[k] = ++N

Люблю цю відповідь. Отриманий мені весь вистрілений, щоб дати йому постріл протягом вихідних!
Джон Різ

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

@JohnRees Звичайно, немає проблем.
Арнольд
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.