अंक योग अनुक्रम के तत्व को कुशलता से कैसे खोजें?

Question

ब्याज से बाहर मैंने प्रोजेक्ट यूलर ( डिजिट सम अनुक्रम ) की "हाल की" श्रेणी से एक समस्या को हल करने की कोशिश की । लेकिन मैं समस्या को कुशलता से हल करने का एक तरीका सोचने में असमर्थ हूं। समस्या निम्नानुसार है (मूल प्रश्न अनुक्रम में शुरुआत में दो हैं, लेकिन यह अनुक्रम नहीं बदलता है):

डिजिट सम अनुक्रम 1,2,4,8,16,23,28,38,49 है .... जहाँ अनुक्रम का शब्द अनुक्रम में पूर्ववर्ती अंकों का योग है । अनुक्रम के शब्द का पता लगाएं ।$n^{th}$$10^{15}th$

भोली समाधान को लागू नहीं किया जा सकता है क्योंकि इसमें बहुत समय लगता है। मैंने मैट्रिक्स एक्सप्रेशन के एक मामले में समस्या को कम करने की कोशिश की (जो कि समय की राशि लेती है ) लेकिन इस क्रम के लिए पुनरावृत्ति के रूप में रैखिक मानदंड को पुनरावृत्ति करने वाले ऐसे पुनरावृत्ति के साथ नहीं आ सकती है। काफी अजीब। यह देखा जा सकता है कि अनुक्रम पुनरावृत्ति द्वारा शासित है:$O(log ( 10^{15}))$

$$a_n = a_{n-1} + d( a_{n-1} ) ..... (1 )$$

जहां है क्रम और की अवधि (। उदाहरण के लिए एक समारोह है जो जब संख्या के अंकों के इनपुट रिटर्न राशि के रूप में एक प्राकृतिक संख्या दी है )। मेरा दूसरा दृष्टिकोण अनुक्रम में कुछ पैटर्न खोजने की कोशिश करना था। यह देखा जा सकता है कि अनुक्रम के पहले कुछ शब्दों को लिखा जा सकता है$a_n$$n^{th}$$d$$\;d(786)=21$

   a_1 = 1  
   a_2 = 1 + d( 1 )
   a_3 = 1 + d( 1 ) + d( 1 + d( 1 ) )
   a_4 = 1 + d( 1 ) + d( 1 + d( 1 ) ) + d( 1 + d( 1 ) + d( 1 + d( 1 ) ) )
   a_5 = 1 + d( 1 ) + d( 1 + d( 1 ) ) + d( 1 + d( 1 ) + d( 1 + d( 1 ) ) ) + d( 1 +  d(  
   1 ) + d( 1 + d( 1 ) ) + d( 1 + d( 1 ) + d( 1 + d( 1 ) ) ) )

ऊपर दिए गए पैटर्न से यह हो जाता है कि अनुक्रम का शब्द निम्नलिखित विधि द्वारा उत्पन्न किया जा सकता है:$n^{th}$

1. उनके बीच के सिंबल के साथ लिखें ।$2^{n-1}$ $1$
2. पहले छोड़कर , फिर अगले 2 0 पदों पर और फिर अगले 2 1 पदों पर, फिर अगले 2 2 पदों पर और इतने पर फ़ंक्शन डी लागू करें ।$1$$d$$2^{0}$$2^{1}$$2^{2}$
3. फिर उपरोक्त विधि को लागू किए गए प्रत्येक $d$ फ़ंक्शन के तर्कों पर पुनरावर्ती रूप से लागू करें।

उदाहरण के लिए यदि n = 3 हम निम्नलिखित जोड़तोड़ करते हैं:

    1 + 1 + 1 + 1 + 1 + 1 + 1 + 1
    1 + d( 1 ) + d( 1 + 1 ) + d( 1 + 1 + 1 + 1 )
    1 + d( 1 ) + d( 1 + d(1) ) + d( 1 + d( 1 ) + d( 1 +d( 1 ) ) )

गतिशील प्रोग्रामिंग करके मैं उत्पन्न कर सकते हैं समय में उपरोक्त विधि का उपयोग कर अवधि हे ( एल ओ जी ( 2 10 15 ) ) है, जो फिर से अनुभवहीन समाधान की तुलना में बेहतर नहीं है।$n^{th}$$O(log ( 2^{10^{15}} ) )$

EDIT 1
एक और चीज़ जो देखी जा सकती है वह है । उदाहरण के लिए d ( a 6 ) = d ( 23 ) = d ( 32 ) = 5 । लेकिन मैं इस बिंदु का उपयोग करने में असमर्थ हूं। मैंने फिर से एक रैखिक पुनरावृत्ति संबंध (मैट्रिक्स घातांक के लिए) खोजने की कोशिश की, लेकिन मैं इसे खोजने में असमर्थ हूं।$d(a_n) = d(2^{n-1})$$d(a_6)=d(23)=d(32)=5$

EDIT 2

निम्न ग्राफ है जब अनुक्रम को छोटी श्रेणी के लिए प्लॉट किया जाता है ( अनुक्रम के पहले शब्द प्लॉट किए जाते हैं)। $10^6$

पुनश्च: मुझे पता है कि प्रोजेक्ट यूलर से समाधान पूछना उचित नहीं है। लेकिन मैं सिर्फ एक नई दिशा या संकेत चाहता हूं, जैसा कि मैं पिछले कुछ दिनों से हलकों में घूम रहा हूं। अगर वह भी अस्वीकार्य है तो मैं सुझाव दिए गए प्रश्न को हटा सकता हूं।

Comments

मुझे लगता You are given a106 = 31054319.है कि मूल यूलर समस्या एक संकेत है।

— फिलिप हगलुंड

@FilipHaglund जो संकेत नहीं है। के रूप में अकेले जानवर बल द्वारा मैं आसानी से उस मूल्य की गणना कर सकता हूं। यह सिर्फ आपके दृष्टिकोण की जाँच के लिए है।

— सासस

इसके अलावा OEIS पर: oeis.org/A004207 ।

— युवल फिल्मस 15

@ ईवीएलजेएस हां मैं ग्राफ को एक ज़ैग ज़ैग फैशन में धीरे-धीरे बढ़ाता है। क्या आप अपने अंतिम बिंदु "" कैशिंग पैटर्न .. "को विस्तृत कर सकते हैं।

— शाशास

यह देखते हुए कि दिलचस्प पैटर्न mod 9 दिखाई देते हैं, क्या कुछ दिलचस्प होता है अगर हम अनुक्रम mod 11 या mod 99 को देखते हैं? मान मॉड 11 को विषम-अनुक्रमित अंकों के योग और समान-अनुक्रमित अंकों के योग से प्राप्त किया जा सकता है। मान mod 99 को आसन्न जोड़े के अंकों से प्राप्त किया जा सकता है।

— DW

Answer 1

आपका अनुक्रम oeis.org/A004207 अंकों के योग के रूप में वर्णित है । वहाँ की तरह अनुक्रम आधुनिक 9 पैटर्न दोहरा है कुछ अच्छे अंक हैं , इसके साथ डिजिटल जड़ों के शेयरों oeis.org/A065075 और oeis.org/A001370 । यदि वे गुण उपयोगी हैं तो खुली समस्या है (क्योंकि n - t h संख्या के लिए कोई बंद प्रपत्र समीकरण नहीं है )।$(1, 2, 4, 8, 7, 5)^\infty$$n-th$

इस क्रम के कुछ गुण हैं जो उल्लेख के लायक हैं:
जब आप संख्या की गणना करते हैं , तो आपको केवल काउंटर (यह जानने के लिए कि यह कौन सा अंक है) और स्वयं संख्या को संग्रहीत करने की आवश्यकता है। पुनः आरंभ करने के लिए और अधिक आवश्यक नहीं है, क्योंकि अगला नंबर वर्तमान अंक है + यह अंकों का योग है।$n-th$

गति को सुनिश्चित करने के लिए कुछ कदम उठाते हुए, संख्याओं को सरणी में रखना अच्छा है, भोली मॉड और div गणनाओं से बचना, जो कि महंगे हैं। यह लगातार स्पीडअप देता है, लेकिन कई बार देखने से बात बन जाती है।

शुरुआती बिंदु से आप अगले और अगले की गणना कर सकते हैं, और यह कुछ बिंदु तक काम करता है, यह बहुत बिंदु अंकों के परिवर्तन की संख्या है।
क्या अधिक महत्वपूर्ण है, पैटर्न संख्या की वृद्धि के साथ बदल रहे हैं।
अंकों की संख्या संख्या की तुलना में छोटी होती है, इसलिए केवल संख्या का हिस्सा सबसे अधिक संचालन पर बदल जाएगा।
तो क्या हम वास्तव में कैश कर सकते हैं?

हम जानते हैं कि एक ही अंक के दो अंकों के साथ अगली संख्या प्राप्त करने का योग समान होगा। अगले के बारे में क्या?

साशा

स्पोइलर अलर्ट, नीचे काफी स्पष्ट कैश पैटर्न है

यह अतिरिक्त स्थितियों पर निर्भर करता है, जैसे कि संख्या जो रन में नहीं बदलती है , मैं इसे शिफ्ट कहूंगा , शुरुआती राशि शुरू के रूप में ।

कुछ मनमाना रन लेना , जैसे , और 0 से 9 तक शुरू करना हम हर पैटर्न को शुरुआती बिंदु से 100 तक कैश कर सकते हैं , तत्वों की संख्या (काउंटर से निपटने के तरीके जानने के लिए, जो कुछ एन - टी एच देने की आवश्यकता है संख्या), और इसे याद करें। $100$$0$$9$$100$$n-th$

ठीक है। अब तक किसी भी शुरुआत को कवर किया गया है, क्या से परे बदलता है ? दुर्भाग्य से यह पैटर्न काम करना बंद कर देता है, क्योंकि यदि आप 100 बनाने की कोशिश 1 के बराबर शुरू करते हैं, तो अगली संख्या की गणना पूरी तरह से की जाती है, लेकिन दूसरा टूट जाता है। $100$
$100$$1$

यहां हमें 1 पर सेट शिफ्ट को कवर करना होगा और सेट को 0 पर शुरू करना होगा । इसका मतलब विभिन्न पारियों के लिए तालिकाओं की गणना करना भी है । $1$$0$

क्या हमें वास्तव में उन सभी की गणना करने की आवश्यकता है ? नहीं वास्तव में कोई नहीं।
तालिकाओं का हिस्सा सिर्फ एक और एक शुरुआती आइटम है। 1 , 2 , 4 , 8
से शुरू होने वाले उदाहरण के लिए , समान अनुक्रम को स्थानांतरित कर दिया जाता है। तो क्या हमें लंबी कैश की गणना करने की आवश्यकता है? नहीं, हम इसे किसी अन्य रन को लेने के लिए बदलाव को शिफ्ट करने के लिए गणना करते हैं , इसलिए यह बहुत सारी मेमोरी को बचाएगा। $1, 2, 4, 8$

अब जब तालिका को कवर किया जाता है, तो हम प्रारंभिक सेटिंग से शुरू करते हैं, तालिका से योग उठाते हैं, काउंटर जोड़ते हैं और देखते हैं कि: हम 101 तक पहुंचते हैं , चर को अपडेट करते हैं और 218 पर कूदते हैं , चरणों को दोहराते हुए 305 -> 406 -> 517 -> 607 -> 719 -> 805 -> 904 -> 1003 । ठीक है। अब क्या? $1$$101$$218$$305$$406$$517$$607$$719$$805$$904$$1003$

जब तक हम जारी रख सकते हैं पारी गणना की तुलना में अधिक है।
आगे चलकर हम मक्खी पर और अधिक रन बना सकते हैं, बड़े रन बना सकते हैं, या अन्य पैटर्न का निरीक्षण कर सकते हैं (जैसे हम पहले से गणना की गई तालिका का पुन: उपयोग कर सकते हैं)।
अलग पर एक नजर डालें बदलाव की तरह वे सभी एक ही देना रन अंकों रकम के लिए एक ही वातावरण में किया जा रहा है, इसलिए हम बहुत ही तालिकाओं का उपयोग कर सकते हैं। 100 से अधिक तत्वों को बड़ा करने से प्रक्रिया में तेजी आती है, जिससे एक ही बार में बड़ी छलांग लगती है।$100, 1000, 10000, 100000, 1000000...$
$100$

Answer 2

चूंकि आपने "एक नई दिशा या एक संकेत" के लिए कहा था और मुझे जवाब नहीं पता है, मैं इसे यहाँ छोड़ दूँगा, मुझे आशा है कि यह उपयोगी है। कुछ विचार:

यह समझ में आता है कि एक पैटर्न 9 होगा, क्योंकि

$\forall k > 1,k \in \mathbb{Z}\quad10^k \equiv 1 \mod 9$

जिसे आप इंडक्शन के द्वारा साबित कर सकते हैं।

इसका अर्थ है कि सभी संख्याएँ उनके अंकों के योग के अनुरूप हैं।

इसके अलावा, $a_n = d(a_n) \mod 9 \implies$

$$a_{n} = a_{n-1} + d(a_{n-1}) = 2d(a_{n-1}) \mod 9$$

यदि हम इस पुनरावृत्ति को बढ़ाते रहें तो हम प्राप्त करते हैं

$a_{n} = 2^n \mod 9$

जो पैटर्न मॉड 9 की व्याख्या करता है।

यह भी हमें हो जाता है । प्रत्येक पुनरावृत्ति से हमें एक अंतर मिलता है जो 9 से विभाज्य है। वे अंतराल कितने विस्तृत हैं?$a_n = 9k + 2^n$

यहाँ सामान्य कोड से कुछ कम है:

import matplotlib.pyplot as plt
import numpy as np

#sum digits of n
def sum_digits(n):
    s = 0
    while n:
        s += n % 10
        n //= 10
    return s

#get the sequence to n digits
def calculate(n):
    retval = [1]
    for i in range(n):
        retval.append(retval[-1] + sum_digits(retval[-1]))
    return retval;

#empirically confirm that a_n = 2^n mod 9
def confirmPow2(a):
    count = 0
    for i in a[:10000]:
        if((i%9) != (2**count % 9)):
            print "false"
        count = count + 1

#find gaps divisible by 9 in a subset of a
def find9Gaps(a):
    count = 0
    S = []
    for i in a[:10000]:
         S.append(((2**count ) - i)/9)
         count = count + 1
    return S

#repeatedly sum the digits until they're less than 9...
#gives some interesting patterns
def repeatedDigitSum():
    for i in range(1000, 1100):
         print "=========for ",i
         while i > 9:
                 i = sum_digits(i)
                 print i 


a = calculate(10**6)
b = find9Gaps(a)
plt.plot(range(len(b[:100])), b[:100])
plt.show()

साजिश (पहले 100 के लिए) घातीय लगती है, लेकिन मुझे नहीं लगता कि यह सही है।

यहाँ का उत्पादन है

>>> plt.plot(range(len(b[5:60])), np.log2(np.array(b[5:60])))
>>> plt.show()

मेरे पास आखिरी बात यह है कि ऐसा लगता है कि यदि आप किसी संख्या के अंकों को जोड़ते हैं, और फिर परिणामी संख्या के अंकों को जोड़ते हैं, और इसे दोहराते हैं, तो आप अंततः उस नंबर को प्राप्त करते हैं मॉड 9।

10 मॉड 9 की शक्तियों के बारे में उपरोक्त तथ्य से समझ में आता है।

$$n \equiv d(n) \equiv d(d(n)) \equiv \cdots \mod 9$$

यह संख्या का एक दिलचस्प अनुक्रम देता है।

संपादित करें: जाहिरा तौर पर इसे "डिजिटल रूट" कहा जाता है।

Comments

यह थोड़े कम से कम तीन बार टिप्पणी की गई थी। जब आप प्लॉट करते हैं जो आपके लिए घातीय दिखता है, तो शायद आपको लघुगणक का उपयोग करना चाहिए, इसके बारे में स्केल अक्ष पर सूचित करें? यदि आपने पठनीय 10 ^ 16 शब्द दिए हैं तो मैं वास्तव में प्रभावित होऊंगा।

— ईविल

3 बार क्या टिप्पणी की गई थी? लोग कह रहे थे कि "पैटर्न मॉड 9" था, लेकिन मुझे लगा कि यह स्पष्ट नहीं था कि यह क्या था। मैंने अभी कुछ खोज की और टिप्पणी की कि मेरे पास क्या था, क्योंकि मुझे नहीं लगता कि मैं इस पर काम करना जारी रख पाऊंगा। फिर, मेरे पास कोई हल नहीं है, लेकिन सवाल एक के लिए नहीं पूछा।

— चुपचाप

EvilJS सुझाव के अनुसार एक लॉग प्लॉट जोड़ा गया, कोई भी बड़ा प्लॉट नहीं किया जा सकता क्योंकि खौफनाक ब्रेक और मेरे पास वास्तव में इस समस्या को आगे बढ़ाने के लिए समय नहीं है

— शांतचित्त