Найновіша «приємна» послідовність OEIS - A328020 , була опублікована лише кілька хвилин тому.

Кількість чітких вирівнювань n X n квадрата з вільними n-поліомінами.

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

Приклад

Бо n=4існує 22 таких сітки, як показано на цьому зображенні від OEIS. Кредит: Джефф Бауермайстер, ілюстрація A328020 (4).

Виклик

Як і цей попередній виклик , мета цієї задачі - обчислити якомога більше термінів у цій послідовності, яка починається 1, 1, 2, 22, 515, 56734і де n-й член - це кількість нахилів сітки n X n з n-поліоміно.

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

Розширення до коду @ Grimy отримує N = 8

Це просто підкреслює, що @Grimy заслуговує на винагороду:

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

На машині, де початковий код зайняв 2m11s за N = 7, це займає 1m4s, а N = 8 було обчислено в 33h46m. Результат - 23437350133.

Ось моє доповнення як різниця:

--- tilepoly.c  2019-10-11 12:37:49.676351878 +0200
+++ tilepolyprune.c     2019-10-13 04:28:30.518736188 +0200
@@ -51,6 +51,30 @@
     return 1;
 } 

+static int check_component_sizes(u64 occupied, u64 total){
+    u64 queue[N*N];
+    while (total<N*N){
+        u64 count = 1;
+        u64 start = ctz(~occupied);
+        queue[0] = start;
+        occupied |= 1ul << start;
+        for(u64 current=0; current<count; ++current){
+            u64 free_adjacent = adjacency_matrix[queue[current]] & ~occupied;
+            occupied |= free_adjacent;
+            while (free_adjacent){
+                u64 next = ctz(free_adjacent);
+                free_adjacent &= ~(1ul << next);
+                queue[count++] = next;
+            }
+        }
+        if (count % N){
+            return 0;
+        }
+        total += count;
+    }
+    return 1;
+}
+
 static void recurse(u64 mino, u64 cell, u64 occupied, u64 adjacent, u64 forbidden)
 {
     if (cell >= N) {
@@ -61,6 +85,9 @@
             return;
         }

+        if(!check_component_sizes(occupied,N*mino))
+            return;
+
         u64 next = ctz(~occupied);
         board[next] = mino;
         recurse(mino, 1, occupied | 1ul << next, adjacency_matrix[next], 0);

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

C, 7 термінів

Сьомий термін - 19846102 . (Перші шість - це 1, 1, 2, 22, 515, 56734, як зазначено у запитанні).

#include <stdio.h>
#include <string.h>
#include <stdint.h>

#define N 7
#define ctz __builtin_ctzl

typedef uint64_t u64;

static u64 board[N*N] = { 0 };
static u64 adjacency_matrix[N*N] = { 0 };
static u64 count = 0;

static u64 check_symmetry()
{
    static const u64 symmetries[7][3] = {
        { 0,     +N, +1 },
        { N-1,   -1, +N },
        { N-1,   +N, -1 },
        { N*N-1, -1, -N },
        { N*N-1, -N, -1 },
        { N*N-N, +1, -N },
        { N*N-N, -N, +1 },
    };

    int order[N];

    for (u64 i = 0; i < 7; ++i) {
        u64 start = symmetries[i][0];
        u64 dcol = symmetries[i][1];
        u64 drow = symmetries[i][2];
        memset(order, 0xFF, N*sizeof(int));

        for (u64 row = 0, col = 0; col < N || (col = 0, ++row < N); ++col) {
            u64 base = board[col + N*row];
            u64 symmetry = board[start + dcol*col + drow*row];
            u64 lex = 0;

            while (order[lex] != symmetry && order[lex] != -1)
                ++lex;
            order[lex] = symmetry;

            if (lex < base)
                return 0;

            if (base < lex)
                break;
        }
    }

    return 1;
} 

static void recurse(u64 mino, u64 cell, u64 occupied, u64 adjacent, u64 forbidden)
{
    if (cell >= N) {
        ++mino;

        if (mino == N) {
            count += check_symmetry();
            return;
        }

        u64 next = ctz(~occupied);
        board[next] = mino;
        recurse(mino, 1, occupied | 1ul << next, adjacency_matrix[next], 0);
        return;
    }

    adjacent &= ~occupied & ~forbidden;
    while (adjacent) {
        u64 next = ctz(adjacent);
        adjacent &= ~(1ul << next);
        forbidden |= 1ul << next;
        board[next] = mino;
        recurse(mino, cell + 1, occupied | 1ul << next, adjacent | adjacency_matrix[next], forbidden);
    }
}

int main(void)
{
    for (u64 i = 0; i < N*N; ++i) {
        if (i % N)
            adjacency_matrix[i] |= 1ul << (i - 1);
        if (i / N)
            adjacency_matrix[i] |= 1ul << (i - N);
        if (i % N != N - 1)
            adjacency_matrix[i] |= 1ul << (i + 1);
        if (i / N != N - 1)
            adjacency_matrix[i] |= 1ul << (i + N);
    }

    recurse(0, 2, 3, 4 | 3 << N, 0);
    printf("%ld\n", count);
}

Спробуйте в Інтернеті! (для N = 6, оскільки час очікування очікується на N = 7.)

На моїй машині N = 6 займало 0,171 с, а N = 7 займало 2 м23. N = 8 зайняло б кілька тижнів.