Appena per interesse ho cercato di risolvere un problema dalla categoria "Recenti" di Project Euler ( sequenza di cifre ). Ma non sono in grado di pensare a un modo per risolvere il problema in modo efficiente. Il problema è il seguente (nella sequenza di domande originale ne ha due all'inizio, ma non cambia la sequenza):

La sequenza della somma delle cifre è 1,2,4,8,16,23,28,38,49 .... dove il termine della sequenza è la somma delle cifre che la precedono nella sequenza. Trova il termine della sequenza. 10 15 t $n^{th}$$10^{15}th$

La soluzione ingenua non può essere implementata perché richiede molto tempo. Ho cercato di ridurre il problema a un caso di esponenziazione della matrice (che richiederebbe tempo) ma non sono riuscito a trovare una tale ricorrenza che si adattava ai criteri lineari come la ricorrenza per questa sequenza è abbastanza strano. Si può vedere che la sequenza è governata dalla ricorrenza:$O(log ( 10^{15}))$

dove è termine della sequenza e è una funzione che quando viene dato un numero naturale come input restituisce la somma delle cifre del numero (es. ). Il mio secondo approccio è stato quello di cercare di trovare uno schema nella sequenza. Si può vedere che i primi termini della sequenza possono essere scritti come$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 ) ) ) )

Dal modello sopra diventa che termine della sequenza può essere generato con il seguente metodo:$n^{th}$

1. Scrivi con il simbolo di aggiunta tra di loro.$2^{n-1}$ $1$
2. Lasciando il primo , quindi applicare la funzione sui termini successivi, quindi sui termini 2 ^ {1} successivi, quindi sui termini 2 ^ {2} successivi e così via.$1$$d$$2^{0}$$2^{1}$$2^{2}$
3. Quindi applicare il metodo sopra ricorsivamente sugli argomenti di ciascuna funzione $d$ applicata.

ad esempio se n = 3 eseguiamo le seguenti manipolazioni:

    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 ) ) )

Tramite la programmazione dinamica posso generare il termine usando il metodo sopra nel tempo , che di nuovo non è migliore della soluzione ingenua. O ( l o g ( 2 10 15 ) $n^{th}$$O(log ( 2^{10^{15}} ) )$

EDIT 1
Un'altra cosa che si può osservare è che . Ad esempio . Ma non sono in grado di sfruttare questo punto. Ho di nuovo provato a trovare una relazione di ricorrenza lineare (per esponenziazione di matrice), ma non riesco a trovarla.d ( a 6 ) = d ( 23 ) = d ( 32 ) = $d(a_n) = d(2^{n-1})$$d(a_6)=d(23)=d(32)=5$

MODIFICA 2

Di seguito è riportato il grafico quando la sequenza viene tracciata per un intervallo più piccolo ( vengono tracciati i primi termini della sequenza). $10^6$

PS: So che non è consigliabile chiedere soluzioni al Progetto Euler. Ma voglio solo una nuova direzione o un suggerimento, poiché mi sono spostato in cerchio negli ultimi giorni. Se anche questo è inaccettabile, posso rimuovere la domanda se suggerito.

La sequenza è descritta in oeis.org/A004207 come somma delle cifre. Ci sono alcuni punti positivi come la sequenza 9 ha un modello ripetitivo , condivide le radici digitali con oeis.org/A065075 e oeis.org/A001370 . Se queste proprietà sono utili è un problema aperto (perché non esiste un'equazione in forma chiusa per l' numero). n - t $(1, 2, 4, 8, 7, 5)^\infty$$n-th$

Vi sono alcune proprietà di questa sequenza degne di nota:
quando si calcola l' numero, è necessario memorizzare solo il contatore (per sapere quale numero era) e il numero stesso. Per riavviare non è necessario altro, poiché il numero successivo è il numero corrente + somma delle sue cifre.$n-th$

Adottare alcune misure per garantire la velocità all'inizio è bene mettere i numeri nell'array, evitando calcoli ing mod e div, che sono costosi. Questo accelera costantemente, ma a volte è importante.

Dal punto di partenza è possibile calcolare il prossimo e il successivo, e funziona fino a un certo punto, proprio questo è il numero di cifre che cambiano.
Ciò che è più importante, i modelli stanno cambiando con l'aumento dei numeri.
Le somme delle cifre sono piccole rispetto ai numeri stessi, quindi solo la parte del numero cambierà nella maggior parte delle operazioni.
Quindi cosa possiamo davvero memorizzare nella cache?

Sappiamo che con due numeri con la stessa somma di cifre l'aggiunta per ottenere il numero successivo sarà la stessa. E il prossimo?

sasha

Avviso spoiler, di seguito è riportato un pattern cache abbastanza esplicito

Dipende da condizioni aggiuntive, come i numeri che non cambiano durante la corsa , lo chiamerò shift , importo iniziale come inizio .

$100$$0$$9$$100$$n-th$

$100$
$100$$1$

Qui dobbiamo coprire shift impostato su e iniziare impostato su . Significa anche calcolare tabelle per turni diversi . $1$$0$

Dobbiamo davvero calcolarli tutti ? Non proprio no.
Parte delle tabelle è solo un altro elemento iniziale ulteriormente.
Ad esempio a partire da ottiene la stessa sequenza spostata. Quindi dobbiamo calcolare cache più lunghe? No, lo calcoliamo per spostare il cambio per riprendere un'altra corsa , quindi risparmierà molta memoria. $1, 2, 4, 8$

$1$$101$$218$$305$$406$$517$$607$$719$$805$$904$$1003$

$100, 1000, 10000, 100000, 1000000...$
$100$

Dato che hai chiesto "una nuova direzione o un suggerimento" e non conosco la risposta, lascio questo qui, spero sia utile. qualche idea:

Ha senso che ci sarebbe un modello mod 9, da allora

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

Che puoi provare per induzione.

Ciò significa che tutti i numeri sono congruenti con la somma delle loro cifre mod 9.

Inoltre, $a_n = d(a_n) \mod 9 \implies$

Se continuiamo ad espandere questa ricorrenza otteniamo

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

Il che spiega il modello mod 9.

Ci anche . Ogni iterazione otteniamo un divario che è divisibile per 9. Quanto sono ampie queste lacune?$a_n = 9k + 2^n$

Ecco un po 'meno del codice generale:

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()

La trama (per i primi 100) sembra esponenziale, ma non credo sia perfetta.

Ecco l'output di

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

L'ultima cosa che ho è che sembra che se sommi le cifre di un numero, quindi sommi le cifre del numero risultante e ripeti questo, alla fine ottieni quel numero mod 9.

Ha senso dato il fatto sopra riguardo ai poteri di 10 mod 9.

Dà comunque un'interessante sequenza di numeri.

Modifica: apparentemente questo si chiama "radice digitale".