आपकी अनुरोधित भाषा में इसका उत्तर देने के लिए अजगर में पर्याप्त ज्ञान नहीं है, लेकिन आपके प्रश्न के मापदंडों को देखते हुए, C / C ++ में, मैं शून्य और बिट्स को बिट्स में परिवर्तित करूँगा और उन्हें एक uint64_t के कम से कम महत्वपूर्ण बिट्स पर धकेलूंगा। यह आपको एक ही झपट्टा - 1 घड़ी में सभी 55 बिट्स की तुलना करने की अनुमति देगा।
बुरी तरह से तेज, और पूरी चीज चिप-कैश (209,880 बाइट्स) में फिट होगी। सभी 55 सूची सदस्यों को एक साथ स्थानांतरित करने के लिए हार्डवेयर समर्थन केवल एक सीपीयू रजिस्टर में उपलब्ध है। एक ही साथ सभी 55 सदस्यों की तुलना करने के लिए जाता है। यह सॉफ़्टवेयर समाधान के लिए समस्या की 1-फॉर -1 मैपिंग की अनुमति देता है। (और यदि आवश्यक हो तो SIMD / SSE 256 बिट रजिस्टरों का उपयोग करते हुए, 256 सदस्यों तक) परिणामस्वरूप कोड पाठक के लिए तुरंत स्पष्ट हो जाता है।
आप इसे पायथन में लागू करने में सक्षम हो सकते हैं, मुझे अभी यह अच्छी तरह से पता नहीं है कि यह संभव है या प्रदर्शन क्या हो सकता है।
उस पर सोने के बाद कुछ चीजें स्पष्ट हो गईं, और सभी बेहतर के लिए।
1.) बिट्स का उपयोग करके परिपत्र रूप से जुड़ी सूची को स्पिन करना इतना आसान है कि डाली की बहुत चालाक चाल आवश्यक नहीं है। 64-बिट रजिस्टर के अंदर मानक बिट शिफ्टिंग रोटेशन को बहुत सरलता से पूरा करेगा, और बिट ऑप्स के बजाय अंकगणित का उपयोग करके इस सभी अधिक पायथन को अनुकूल बनाने के प्रयास में।
2.) बिट शिफ्टिंग को 2 से भाग करके आसानी से पूरा किया जा सकता है।
3.) 0 या 1 के लिए सूची के अंत की जाँच करना modulo 2 द्वारा आसानी से किया जा सकता है।
4.) पूंछ से सूची के प्रमुख के लिए "0" चलना 2. द्वारा विभाजित किया जा सकता है क्योंकि यह अगर शून्य वास्तव में ले जाया गया था तो यह 55 वें बिट को झूठा बना देगा, जो पहले से ही बिल्कुल कुछ भी नहीं है।
5.) पूंछ से सूची के प्रमुख के लिए "1" चलना 2 से विभाजित करके और 18,014,398,509,481,984 जोड़कर किया जा सकता है - जो कि 55 वें बिट सच और बाकी सभी झूठे को चिह्नित करके बनाया गया मूल्य है।
6.) यदि किसी दिए गए रोटेशन के बाद लंगर और रचित uint64_t की तुलना TRUE है, तो TRUE को तोड़ें और वापस लौटाएँ।
मैं बार-बार रूपांतरण करने से बचने के लिए सूचियों के पूरे सरणी को सीधे सामने uint64_ts की एक सरणी में बदल दूंगा।
कोड को अनुकूलित करने की कोशिश में कुछ घंटे बिताने के बाद, विधानसभा भाषा का अध्ययन करते हुए मैं रनटाइम से 20% दाढ़ी बनाने में सक्षम था। मुझे यह जोड़ना चाहिए कि ओ / एस और एमएसवीसी कंपाइलर को कल के साथ-साथ मिड-डे अपडेट मिला। जो भी कारण / कारण के लिए, सी कंपाइलर उत्पादित कोड की गुणवत्ता में सुधार के बाद नाटकीय रूप से सुधार हुआ (11/15/2014)। रन-टाइम अब ~ 70 घड़ियां, 17 नैनोसेकंड एक लंगर की अंगूठी की रचना और तुलना करने के लिए एक परीक्षण रिंग के सभी 55 मोड़ के साथ और अन्य सभी के खिलाफ सभी रिंगों के एनएक्सएन 12.5 सेकंड में किया जाता है ।
यह कोड बहुत तंग है, लेकिन 4 रजिस्टर 99% समय के आसपास कुछ भी नहीं कर रहे हैं। असेंबली भाषा C कोड को लाइन के लिए लगभग लाइन से मेल खाती है। पढ़ने और समझने में बहुत आसान है। एक महान विधानसभा परियोजना अगर कोई खुद को सिखा रहा था कि।
हार्डवेयर हेज़वेल i7, MSVC 64-बिट, पूर्ण अनुकूलन है।
#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;
}
