Не достатньо обізнаний у Python, щоб відповісти на це запитуваною мовою, але в C / C ++, з огляду на параметри вашого запитання, я перетворив би нулі та одиниці в біти і натиснув їх на найменш значущі біти uint64_t. Це дозволить вам порівняти всі 55 біт одним махом - 1 годин.
Злісно швидко, і вся справа впишеться в чіпи кешу (209,880 байт). Апаратна підтримка для одночасного переміщення всіх 55 членів списку доступна лише в регістрах процесора. Те саме стосується порівняння всіх 55 членів одночасно. Це дозволяє зіставити проблему 1 на 1 із програмним рішенням. (і за допомогою 256-бітових регістрів SIMD / SSE, до 256 членів, якщо потрібно). В результаті код читачеві відразу стає очевидним.
Можливо, ви зможете реалізувати це в Python, я просто не знаю цього досить добре, щоб знати, чи можливо це чи яка може бути ефективність.
Після сну на ньому кілька речей стали очевидними, і все на краще.
1.) Настільки легко закручувати круговий список за допомогою бітів, що дуже розумний трюк Далі не потрібен. Всередині 64-розрядного регістру стандартне переміщення бітів здійснить обертання дуже просто, і намагаючись зробити це ще більш зручним для Python, використовуючи арифметику замість бітових ops.
2.) Переміщення бітів можна легко здійснити, використовуючи ділення на 2.
3.) Перевірка кінця списку на 0 або 1 може бути легко виконана за модулем 2.
4.) "Переміщення" 0 на голову списку з хвоста можна здійснити діленням на 2. Це тому, що якби нуль був фактично переміщений, це зробило б 55-й біт помилковим, що вже робиться абсолютно нічого.
5.) "Переміщення" a 1 на голову списку з хвоста можна зробити, поділивши на 2 і додавши 18,014,398,509,481,984 - це значення, створене шляхом позначення 55-го біта істинним, а всі інші помилковими.
6.) Якщо порівняння якоря і складеного uint64_t дорівнює TRUE після будь-якого заданого обертання, перервіть і поверніть ІСТИНА.
Я перетворив би весь масив списків у масив uint64_ts прямо вперед, щоб уникнути повторного перетворення.
Провівши кілька годин, намагаючись оптимізувати код, вивчаючи мову складання, я зміг поголити 20% часу виконання. Додам, що компілятор O / S та MSVC також вчора оновився в середині дня. З будь-якої причини / s, якість коду, який видав компілятор C, значно покращився після оновлення (15.11.2014). Час виконання становить ~ 70 годин, 17 наносекунд для складання та порівняння якірного кільця з усіма 55 витками тестового кільця та NxN всіх кілець проти всіх інших робиться за 12,5 секунд .
Цей код настільки щільний, що всі, крім 4 реєстрів, сидять, не займаючись нічого 99% часу. Мова складання майже відповідає рядку коду С для рядка. Дуже легко читати та розуміти. Чудовий монтажний проект, якби хтось навчав цього.
Обладнання Hazwell i7, 64-розрядний MSVC, повна оптимізація.
#include "stdafx.h"
#include "stdafx.h"
#include <string>
#include <memory>
#include <stdio.h>
#include <time.h>
const uint8_t LIST_LENGTH = 55; // uint_8 supports full witdth of SIMD and AVX2
// max left shifts is 32, so must use right shifts to create head_bit
const uint64_t head_bit = (0x8000000000000000 >> (64 - LIST_LENGTH));
const uint64_t CPU_FREQ = 3840000000; // turbo-mode clock freq of my i7 chip
const uint64_t LOOP_KNT = 688275225; // 26235^2 // 1000000000;
// ----------------------------------------------------------------------------
__inline uint8_t is_circular_identical(const uint64_t anchor_ring, uint64_t test_ring)
{
// By trial and error, try to synch 2 circular lists by holding one constant
// and turning the other 0 to LIST_LENGTH positions. Return compare count.
// Return the number of tries which aligned the circularly identical rings,
// where any non-zero value is treated as a bool TRUE. Return a zero/FALSE,
// if all tries failed to find a sequence match.
// If anchor_ring and test_ring are equal to start with, return one.
for (uint8_t i = LIST_LENGTH; i; i--)
{
// This function could be made bool, returning TRUE or FALSE, but
// as a debugging tool, knowing the try_knt that got a match is nice.
if (anchor_ring == test_ring) { // test all 55 list members simultaneously
return (LIST_LENGTH +1) - i;
}
if (test_ring % 2) { // ring's tail is 1 ?
test_ring /= 2; // right-shift 1 bit
// if the ring tail was 1, set head to 1 to simulate wrapping
test_ring += head_bit;
} else { // ring's tail must be 0
test_ring /= 2; // right-shift 1 bit
// if the ring tail was 0, doing nothing leaves head a 0
}
}
// if we got here, they can't be circularly identical
return 0;
}
// ----------------------------------------------------------------------------
int main(void) {
time_t start = clock();
uint64_t anchor, test_ring, i, milliseconds;
uint8_t try_knt;
anchor = 31525197391593472; // bits 55,54,53 set true, all others false
// Anchor right-shifted LIST_LENGTH/2 represents the average search turns
test_ring = anchor >> (1 + (LIST_LENGTH / 2)); // 117440512;
printf("\n\nRunning benchmarks for %llu loops.", LOOP_KNT);
start = clock();
for (i = LOOP_KNT; i; i--) {
try_knt = is_circular_identical(anchor, test_ring);
// The shifting of test_ring below is a test fixture to prevent the
// optimizer from optimizing the loop away and returning instantly
if (i % 2) {
test_ring /= 2;
} else {
test_ring *= 2;
}
}
milliseconds = (uint64_t)(clock() - start);
printf("\nET for is_circular_identical was %f milliseconds."
"\n\tLast try_knt was %u for test_ring list %llu",
(double)milliseconds, try_knt, test_ring);
printf("\nConsuming %7.1f clocks per list.\n",
(double)((milliseconds * (CPU_FREQ / 1000)) / (uint64_t)LOOP_KNT));
getchar();
return 0;
}
