गणना OEIS A005434

Question

कार्य OEIS A005434 को यथाशीघ्र गणना करना है।

Sलंबाई के एक बाइनरी स्ट्रिंग पर विचार करें n। को सूचीबद्ध करने से 1, हम अगर निर्धारित कर सकते हैं S[1..i+1]मैचों S[n-i..n]वास्तव में सभी के लिए iसे क्रम में 0करने के लिए n-1। उदाहरण के लिए,

S = 01010

देता है

[Y, N, Y, N, Y].

इसका कारण यह है है 0मैचों 0, 01से मेल नहीं खाता 10, 010मैचों 010, 0101मेल नहीं खाता 1010 और अंत में 01010खुद को मेल खाता है।

लंबाई के सभी अलग-अलग संभव तारों पर पुनरावृति होने पर एस और एस f(n)के अलग-अलग सरणियों की संख्या को परिभाषित करें ।YN2^nSn

पर्यवेक्षक इस सवाल को नोटिस करेंगे मेरा एक और हालिया प्रश्न का एक सरल संस्करण है । हालांकि, मुझे उम्मीद है कि चालाक चालें इसे बहुत तेज और आसान बना सकती हैं।

कार्य

बढ़ाने के लिए nसे शुरू 1, अपने कोड उत्पादन करना चाहिए n, f(n)।

उदाहरण उत्तर

इसके लिए n = 1..24, सही उत्तर हैं:

1, 2, 3, 4, 6, 8, 10, 13, 17, 21, 27, 30, 37, 47, 57, 62, 75, 87, 102, 116, 135, 155, 180, 194

स्कोरिंग

आपके कोड को बारी-बारी से n = 1प्रत्येक के लिए उत्तर देने से बचना चाहिए n। मैं पूरे समय का समय दूंगा, दो मिनट बाद इसे मारूंगा।

आपका स्कोर nउस समय का उच्चतम अंक है ।

एक टाई के मामले में, पहला उत्तर जीत जाता है।

मेरे कोड का परीक्षण कहां किया जाएगा?

मैं आपका कोड वर्चुअलबॉक्स के तहत एक ल्यूबंटू गेस्ट वीएम (मेरे विंडोज 7 होस्ट पर) चलाऊंगा ।

मेरे लैपटॉप में 8GB RAM और एक Intel i7 5600U@2.6 GHz (Broadwell) CPU है जिसमें 2 कोर और 4 धागे हैं। निर्देश सेट में SSE4.2, AVX, AVX2, FMA3 और TSX शामिल हैं।

प्रति भाषा प्रमुख प्रविष्टियाँ

• एन = 599 में जंग बू ऐन्डर्स Kaseorg।
• एन = 30 में सी मटमैला द्वारा। पैतृक संस्करण 32 में मिलता है जब मूल रूप से साइबरविन में चलाया जाता है ।

Comments

math.uni-bielefeld.de/~sillke/SEQUENCES/autocorrelation-range.c- (OEIS पेज से जुड़ा हुआ) -O3 के साथ चलने पर मेरी मशीन पर 100 से <कल तक की गणना की जा सकती है

— Vroomfondel

@rogaos ओह प्रिय। मुझे प्रश्न को हटा देना चाहिए लेकिन उसके पास पहले से ही एक उत्तर है।

मुझे लगता है कि यह अभी भी एक शांत समस्या है - लेकिन शायद इसके बजाय 1000 तक? या गोल्फ के उत्तर के लिए एक पर्याप्त तेजी से कार्यक्रम

— पूछें

@rogaos मैंने अभी पूरी तरह से हार्ड लिमिट हटा दी है।

Answer 1

जंग , एन ≈ 660

use std::collections::HashMap;
use std::iter::once;
use std::rc::Rc;

type Memo = HashMap<(u32, u32, Rc<Vec<u32>>), u64>;

fn f(memo: &mut Memo, mut n: u32, p: u32, mut s: Rc<Vec<u32>>) -> u64 {
    debug_assert!(p != 0);
    let d = n / p;
    debug_assert!(d >= 1);
    let r = n - p * if d >= 2 { d - 1 } else { 1 };

    let k = s.binary_search(&(n - r + 1)).unwrap_or_else(|i| i);
    for &i in &s[..k] {
        if i % p != 0 {
            return 0;
        }
    }

    if d >= 3 {
        let o = n - (p + r);
        n = p + r;
        s = Rc::new(s[k..].iter().map(|i| i - o).collect());
    } else if n == p {
        return 1;
    } else if k != 0 {
        s = Rc::new(s[k..].to_vec());
    }

    let query = (n, p, s);
    if let Some(&c) = memo.get(&query) {
        return c;
    }
    let (n, p, s) = query;

    let t = Rc::new(s.iter().map(|i| i - p).collect::<Vec<_>>());
    let c = if d < 2 {
        (1..r + 1).map(|q| f(memo, r, q, t.clone())).sum()
    } else if r == p {
        (1..p + 1)
            .filter(|&q| p % q != 0 || q == p)
            .map(|q| f(memo, r, q, t.clone()))
            .sum()
    } else {
        let t = match t.binary_search(&p) {
            Ok(_) => t,
            Err(k) => {
                Rc::new(t[..k]
                            .iter()
                            .cloned()
                            .chain(once(p))
                            .chain(t[k..].iter().cloned())
                            .collect::<Vec<_>>())
            }
        };
        (1..t.first().unwrap() + 1)
            .filter(|&q| p % q != 0 || q == p)
            .map(|q| f(memo, r, q, t.clone()))
            .sum()
    };
    memo.insert((n, p, s), c);
    c
}

fn main() {
    let mut memo = HashMap::new();
    let s = Rc::new(Vec::new());
    for n in 1.. {
        println!("{} {}",
                 n,
                 (1..n + 1)
                     .map(|p| f(&mut memo, n, p, s.clone()))
                     .sum::<u64>());
    }
}

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

यह लियो गुइबास, "पीरियड्स इन स्ट्रिंग्स" (1981) में दिए गए पुनरावर्ती विधेय This का एक यादगार कार्यान्वयन है । फ़ंक्शन छोटी अवधि के साथ f(memo, n, p, s)लंबाई के सहसंबंधों की संख्या और सेट में प्रत्येक nअवधि pको भी पाता है s।

Comments

आपको आश्चर्य होता है कि क्या अन्य संबंधित समस्या का तेज़ समाधान है। बहुत प्रभावशाली!

दिलचस्प है कि यह पूरी तरह से मेमोरी सीमित है। यह ~ 500 तक गति देता है और फिर रैम से बाहर निकलते ही अचानक धीमा हो जाता है।

Answer 2

चुनौती शुरू करने के लिए बस एक सरल जानवर बल खोज:

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

typedef uint16_t u16;
typedef uint64_t u64;

static u64 map[1<<16];

int main(void)
{
    for (u64 n = 1;; ++n) {
        u64 result = 1;
        u64 mask = (1ul << n) - 1;
        memset(map, 0, sizeof(map));

        #pragma omp parallel
        #pragma omp for
        for (u64 x = 1ul << (n - 1); x < 1ul << n; ++x) {

            u64 r = 0;
            for (u64 i = 1; i < n; ++i)
                r |= (u64) (x >> i == (x & (mask >> i))) << i;
            if (!r)
                continue;

            u16 h = (u16) (r ^ r >> 13 ^ r >> 27);
            while (map[h] && map[h] != r)
                ++h;

            if (!map[h]) {
                #pragma omp critical
                if (!map[h]) {
                    map[h] = r;
                    ++result;
                }
            }
        }

        printf("%ld\n", result);
    }
}

के साथ संकलित करें clang -fopenmp -Weverything -O3 -march=native। मेरी मशीन पर यह 2 मिनट में n = 34 पर पहुंच जाता है।

संपादित करें: आसान समानता के लिए कुछ OMP निर्देशों को छिड़का।

Comments

@Lembik विलोपन के लिए SE मैदान के बाहर एक अच्छे उत्तर का अस्तित्व है? क्या आपको इस एल्गोरिथम को उत्तर के रूप में प्रस्तुत करने और उस उत्तर को स्वीकार करने के लिए किसी (संभवत: टिप्पणीकार) की प्रतीक्षा नहीं करनी चाहिए?

— ग्रिमी

आप एक बहुत अच्छी बात करते हैं

अफसोस की बात है कि मैं वास्तव में वर्चुअलबॉक्स में आपके समानांतर कोड का परीक्षण नहीं कर सकता क्योंकि मेरे सीपीयू पर कुल दो कोर हैं।

मैंने इसे