इस अनंत तार में रन कहां हैं? (CCCCCC मिला!)

Question

स्ट्रिंग से शुरू करते हुए ABC, स्वयं के अंतिम आधे को खुद को बार-बार जोड़ने के परिणाम पर विचार करें (यदि लंबाई विषम है तो बड़े आधे का उपयोग करना)।

हमें प्रगति मिलती है:

ABC
ABCBC
ABCBCCBC
ABCBCCBCCCBC
ABCBCCBCCCBCBCCCBC
etc...

आइए Sपरिणामी अनंत स्ट्रिंग (या अनुक्रम) का प्रतिनिधित्व करें, जिसके परिणामस्वरूप यह प्रक्रिया हमेशा के लिए दोहराई जाती है।

लक्ष्य

इस कोड की चुनौती में लक्ष्य रन के पहले होने के सूचकांक का पता लगाना Cहै S।

यह पहली बार में आसान है: Cपहले इंडेक्स में होता है 2, CCएट 4, CCCएट 7, CCCCएट 26, लेकिन CCCCCइंडेक्स में सभी तरह से होता है 27308! इसके बाद मेरी याददाश्त खत्म हो गई।

विजेता वह सबमिशन होगा जो सही ढंग से सबसे अधिक रन इंडेक्स (क्रम में, शुरू C) उत्पन्न करता है । आप किसी भी प्रकार के एल्गोरिथ्म का उपयोग कर सकते हैं, लेकिन यदि आप मूल पाशविक बल का उपयोग नहीं कर रहे हैं, तो इसे समझाना सुनिश्चित करें। इनपुट और आउटपुट किसी भी प्रारूप को समझने में आसान हो सकते हैं।

महत्वपूर्ण नोट: मुझे आधिकारिक तौर पर नहीं पता कि Sवास्तव में सभी रन हैं या नहीं C। यह प्रश्न गणित स्टैक एक्सचेंज में इस एक से लिया गया है , जिसमें लेखक CCCCCCया तो नहीं मिला है । मैं उत्सुक हूँ अगर यहाँ कोई भी कर सकता है। (यह प्रश्न विषय पर मेरे मूल प्रश्न के आधार पर है ।)

यदि आप यह साबित कर सकते हैं कि सभी रन नहीं Cहोते हैं Sतो आप अपने आप जीत जाएंगे क्योंकि यह सवाल अब मान्य नहीं होगा। यदि कोई भी यह साबित नहीं कर सकता है और न ही पाया जाता है CCCCCCकि विजेता वह व्यक्ति होगा जो CCCCCC(या जो भी सबसे बड़ी अनसुलझी रन CCCCCCमिल जाए तो) के सूचकांक पर उच्चतम निचली सीमा प्राप्त कर सकता है ।

अपडेट: हमसॉग कुडोस से इजाक और रेस जिन्होंने CCCCCC२.१२४ * १० ^ ५१ ९ के खगोलीय सूचकांक में पाया है । इस दर पर मैं CCCCCCCकिसी भी विधि के साथ खोजने की कल्पना नहीं कर सकता जो कि जानवर बल पर निर्भर हो। अच्छे काम करने वाले लोग!

Comments

मुझे यह नहीं मिला - आप कह रहे हैं कि आप CCCCC27308 सूचकांक पर पाए गए हैं , लेकिन बाद में ऐसा लगता है कि आपको नहीं पता कि यह पहली बार कहाँ होता है। क्या आपका मतलब था CCCCCC?

— isaacg

@ आइसाकग ऊप्स। 6 सी है कि खोजने के लिए मुश्किल है। मैं ठीक कर दूँगा।

— केल्विन के

यदि अनुमान गलत है, तो एक N है जिसके लिए c ^ N सबसे लंबा रन है। मुझे पूरा यकीन है कि एक लंबे अनुक्रम का निर्माण संभव होना चाहिए, एक विरोधाभास के लिए अग्रणी और अनुमान साबित करना। मुझे यह भी नहीं लगता कि यह बहुत कठिन है, लेकिन दूसरी तरफ समस्याओं को आसानी से कम करके आंका जा सकता है ...

— इंगो बुर्क

मैं निश्चित रूप से आधी रात को अपने नए वोटों के साथ यहां वापस आ रहा हूं - सवाल और जवाब दोनों के लिए!

— ट्राइकोप्लाक्स

जो खोज रहे हैं, उनके लिए यह थोड़ा आसान हो सकता है: यदि आप पहले "ए" को हटाते हैं, तो आपको केवल "एबी" के साथ खेलना होगा और आप अगले पुनरावृत्ति के लिए आधा + 1 जोड़ देंगे।

— Faquarl

Answer 1

CCCCCC 2.124 * 10 ^ 519 पर मिला।

सटीक सूचकांक 2124002227156710537549582070283786072301315855169987260450819829164756027922998360364044010386660076550764749849261595395734745608255162468143483136030403857241667604197146133343367628903022619551535534430377929831860918493875279894519909944379122620704864579366098015086419629439009415947634870592393974557860358412680068086381231577773140182376767811142988329838752964017382641454691037714240414750501535213021638601291385412206075763857490254382670426605045419312312880204888045665938646319068208885093114686859061215 है

खोज के 3.5 घंटे के बाद, नीचे (कोड का पुराना संस्करण) कोड का उपयोग करके रेस द्वारा पाया गया।

उस सूचकांक के आसपास, स्ट्रिंग है: ...BCCBCBCCCBCCCCCCBCCB...

सत्यापित करने के लिए, नीचे दिए गए कोड को 2946 से शुरू करने के लिए कोड में बदलें। इसके बजाय 5. सत्यापन में 20 सेकंड लगते हैं।

अद्यतन: बेहतर कार्यक्रम। पुराने कार्यक्रम ने खोज की ~ 10x से अधिक स्थानों की आवश्यकता।

नया संस्करण CCCCCCकेवल 33 मिनट में मिल जाता है।

कोड कैसे काम करता है: मूल रूप से, मैं केवल उन क्षेत्रों को देखता हूं जो वृद्धिशील स्ट्रिंग्स के अंत के अनुरूप हैं, और पुन: मूल स्ट्रिंग को पुन: देख कर अक्षरों की गणना करते हैं। ध्यान दें कि यह एक ज्ञापन तालिका का उपयोग करता है, जो आपकी मेमोरी को भर सकता है। यदि आवश्यक हो तो मेमो तालिका की लंबाई पर एक टोपी रखो।

import time
import sys
sys.setrecursionlimit(4000)
ULIMIT=4000
end_positions=[]
current_end=2
while len(end_positions)<ULIMIT+3:
    end_positions.append(current_end)
    next_end=((current_end+1)*3+1)//2-1
    current_end=next_end
memo={}
def find_letter(pos):
    if pos in memo:
        return memo[pos]
    if pos<3:
        return 'ABC'[pos]
    for end_num in range(len(end_positions)-1):
        if pos>end_positions[end_num] and pos<=end_positions[end_num+1]:
            delta=end_positions[end_num+1]-end_positions[end_num]
            if len(memo)>5*10**6:
                return find_letter(pos-delta)
            memo[pos]=find_letter(pos-delta)
            return memo[pos]
time.clock()
for end_num in range(5,ULIMIT+1): # This line.
    diff = 1 # Because end_num is guaranteed to be a C
    while True:
        last_letter=find_letter(end_positions[end_num]+diff)
        if not last_letter=='C':
            break
        diff+=1
    if end_num%100==0:
        pos_str=str(end_positions[end_num])
        print(end_num,'%s.%s*10^%i'%(pos_str[0],pos_str[1:5],len(pos_str)-1),
        len(memo),diff,time.clock())
    if diff>=6:
        print(end_num,end_positions[end_num],diff,time.clock())

वर्तमान अधिकतम खोज: 4000 पुनरावृत्तियों

CCCCCC पुनरावृति (ओं) में पाया गया: 2946

Comments

यह पायथन सही है?

— केल्विन के

हाँ, मैं इसे जोड़ दूँगा।

— isaacg

(+1) आपका कार्यक्रम, पाया sys.setrecursionlimit(4000)और ULIMIT=4000, (मेरे सिस्टम पर लगभग 3.5 घंटे में) CCCCCC की पहली घटना इंडेक्स = 2.124 * 10 ^ 519 पर। सटीक सूचकांक अगली टिप्पणी में है ...

— रेस

2124002227156710537549582070283786072301315855169987260450819829164756027922998360364044010386660076550764749849261595395734745608255162468143483136030403857241667604197146133343367628903022619551535534430377929831860918493875279894519909944379122620704864579366098015086419629439009415947634870592393974557860358412680068086381231577773140182376767811142988329838752964017382641454691037714240414750501535213021638601291385412206075763857490254382670426605045419312312880204888045665938646319068208885093114686859061215

— रेस

बहुत बढ़िया! मुझे कभी संदेह नहीं हुआ कि यह सफल होने के इतना करीब था।

— ईसैक

Answer 2

CCCCCC 2.124 * 10 ^ 519 पर मिला।

निम्नलिखित रूबी कोड की खोज करने के लिए उपयोग किया गया था CCCCCC।

SEARCH = 6

k = [5,3]

getc=->i{
  j=i
  k.unshift(k[0]+(k[0]+1)/2)while(k[0]<=j)
  k.each_cons(2){|f,g|j-=f-g if j>=g}
  "ABC"[j]
}

while true
  x=k[0]
  x-=1 while getc[x]=="C"
  x+=1 
  l=1
  l+=1 while getc[x+l]=="C"

  break if l>=SEARCH
end

puts x
puts (x-14..x+l+13).map{|i|getc[i]}*""

सूचकांक @isaacg के उत्तर के समान है।

6 के लिए उपरोक्त कोड का रनटाइम मेरे कंप्यूटर पर दस सेकंड के क्रम में है। फिर भी, यह अभी भी के लिए एक जवाब के लिए खोज रहा है CCCCCCC(यदि आप इसे अपने आप को सेट लगातार कोशिश करना चाहते SEARCHकरने के लिए 7)।

आप getcएक विशिष्ट स्थान पर चरित्र को खोजने के लिए उपयोग कर सकते हैं iक्योंकि यह अंतिम पंक्ति में किया जाता है जहां सूचकांक के चारों ओर स्ट्रिंग मुद्रित होती है।

Comments

अच्छी नौकरी ने इसे और तेज कर दिया - मेरा समाधान बहुत ही कठिन और अपूर्व था।

— isaacg

कुछ अजीब: मैं ऊपर कोड को चलाने के लिए # 34000 है ब्रेक को हटाने के बाद और परीक्षणों को थोड़ा इधर-उधर करने के बाद, और यह केवल 6. का एक रन पाता है। क्या यह कोड के साथ कोई समस्या है (मुझे संदेह है) या यह अनुक्रम का सिर्फ एक अजीब संपत्ति है?

— ईसैक

@isaacg ध्यान दें कि हम केवल प्रत्येक अनुक्रम के विराम पर जांच करते हैं और इस तरह सभी कॉपी-सीक्वेंस C ^ 6 को याद करते हैं। ब्रेक पर वे बहुत दुर्लभ प्रतीत होते हैं - इस प्रकार मुझे लगता है कि हम जल्द ही C ^ 7 नहीं देखेंगे।

— हावर्ड

मुझे पता है, लेकिन चूंकि केवल 2946 पुनरावृत्तियों के बाद एक सीक्वेंस ब्रेक पर पाया गया था, मैं 40000 पुनरावृत्तियों द्वारा एक दूसरे को देखने की उम्मीद करूंगा, जो कि मैं अभी हूं।

— isaacg

@isaacg आप यहां (बहुत तेज) कोड का उपयोग कर सकते हैं: ideone.com/HoEKOB । यहां तक ​​कि इसके साथ मैं एक और सी ^ 6 को एक अनुक्रम बिंदु पर नहीं पा सकता था (यहां तक ​​कि एक सी ^ 7 भी कम)।

— हावर्ड

Answer 3

(एक जवाब नहीं, लेकिन एक टिप्पणी के लिए बहुत लंबा है।)

निम्नलिखित हावर्ड्स रूबी कार्यक्रम का पायथन अनुवाद है ( getcखोज लूप में केवल एक होने से 3 के पास एक कारक द्वारा वर्तनी)। मेरे सिस्टम पर, यह 3 सेकंड में पहला C ^ 6 पाता है। 93 घंटों में, यह 231,000 पुनरावृत्तियों में कोई C ^ 7 नहीं पाता है, इसलिए पहले C ^ 7 (यदि यह मौजूद है) को अनंत स्ट्रिंग में 10 ^ 40677 पदों के बाद होना चाहिए।

import time

L = [5, 3]      #list grows "backwards" (by insertion on the left)

def getc(i):    #return the letter at index i
    while L[0] <= i: L.insert(0,L[0] + (L[0] + 1)//2)
    for k in range(len(L)-1): 
        if i >= L[k+1]: i -= L[k] - L[k+1]
    return 'abc'[i]

def search(k):  #find the first occurrence of c^k
    start = time.time()
    iter = 0
    while True:
        iter += 1
        if iter % 1000 == 0: print iter, time.time()-start
        p = L[0] - 1
        l = 1
        while getc(p+l)=='c': l += 1
        if l == k: break 
    return p, iter, time.time()-start

k = 6

(indx, iter, extime) = search(k)
print 'run length:', k
print 'index:', indx, '    (',len(str(indx)),'digits )'
print 'iteration count:', iter
print 'neighborhood:', ''.join([getc(i) for i in range(indx-1,indx+k+10)])
print 'execution time:', extime

Comments

PyPy के साथ, यह C ^ 6 को मेरी मशीन पर एक सेकंड से भी कम समय में पाता है।

— डेनिस