Il tuo compito è implementare la sequenza intera A130826 :

un _n è il più piccolo intero positivo tale che un _n - n è un intero multiplo di 3 e due volte il numero di divisori di (a _n - n) / 3 dà la n ^esimo termine nelle prime differenze della sequenza ottenuta per Flavius Setaccio di Giuseppe.

Perso ancora? Bene, in realtà è abbastanza facile.

Il setaccio Flavio Giuseppe Flavio definisce una sequenza intera come segue.

1. Inizia con la sequenza di numeri interi positivi e imposta k = 2 .

2. Rimuovi ogni k ^° intero della sequenza, iniziando dal k ^° .

3. Incrementa k e torna al passaggio 2.

f _n è il n ^° intero (1-indicizzato) che non viene mai rimosso.

Se - come al solito - σ ₀ (k) indica il numero di divisori positivi dell'intero k , possiamo definire a _n come il numero intero positivo più piccolo tale che 2σ ₀ ((a _n - n) / 3) = f _{n + 1} - f _n .

Sfida

Scrivi un programma o una funzione che accetta un numero intero positivo n come input e stampa o restituisce un _n .

Si applicano le regole standard del code-golf . Che vinca il codice più corto!

Esempi lavorati

Se rimuoviamo ogni secondo elemento degli interi positivi, rimaniamo con

 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 ...

Dopo aver rimosso ogni terzo elemento del resto, otteniamo

 1  3  7  9 13 15 19 21 25 27 31 33 37 39 ...

Ora, rimuovendo ogni quarto, poi quinto, poi il sesto elemento ci ottiene

 1  3  7 13 15 19 25 27 31 37 39 ...
 1  3  7 13 19 25 27 31 39 ...
 1  3  7 13 19 27 31 39 ...
 1  3  7 13 19 27 39 ...

L'ultima riga mostra i termini da f ₁ a f ₇ .

Le differenze degli elementi consecutivi di questi termini sono

 2  4  6  6  8 12

Dividendo queste differenze in avanti per 2 , otteniamo

 1  2  3  3  4  6 

Questi sono i conteggi dei divisori target.

• 4 è il primo intero k tale che σ ₀ ((k - 1) / 3) = 1 . In effetti, σ ₀ (1) = 1 .
• 8 è il primo intero k tale che σ ₀ ((k - 2) / 3) = 2 . In effetti, σ ₀ (2) = 2 .
• 15 è il primo intero k tale che σ ₀ ((k - 3) / 3) = 3 . In effetti, σ ₀ (4) = 3 .
• 16 è il primo intero k tale che σ ₀ ((k - 4) / 3) = 3 . In effetti, σ ₀ (4) = 3 .
• 23 è il primo intero k tale che σ ₀ ((k - 5) / 3) = 4 . In effetti, σ ₀ (6) = 4 .
• 42 è il primo intero k tale che σ ₀ ((k - 6) / 3) = 6 . In effetti, σ ₀ (12) = 6 .

Casi test

   n     a(n)

   1        4
   2        8
   3       15
   4       16
   5       23
   6       42
   7       55
   8      200
   9       81
  10       46
  11      119
  12      192
  13      205
  14   196622
  15    12303
  16       88
  17      449
  18      558
  19      127
  20     1748
  21   786453
  22       58
  23     2183
  24     3096
  25     1105
  26   786458
  27 12582939
  28      568
  29     2189
  30     2730

Gelatina, 30 29 27 25 byte

Ho salvato 2 byte grazie a @Dennis che mi ha avvisato Æde altri 2 byte per aver combinato le due catene.

RUð÷‘Ċ×µ/
‘Ç_ÇH0Æd=¥1#×3+

Provalo online!

Questo è stato probabilmente il più divertente che abbia mai avuto con Jelly. Ho iniziato dalla seconda riga, che calcola f _n da n usando la formula su OEIS, ed è piuttosto bello.

Spiegazione

RUð ÷ 'Ċ × µ / Link helper per calcolare F n . Argomento: n
R Ottieni numeri [1..n]
 U inversa
        / Riduci di "arrotondare per eccesso ai successivi 2 multipli":
   ÷ Dividi per il numero successivo
    'Incremento per saltare un multiplo
     Ċ Ceil (arrotondato per eccesso)
      × Moltiplicare per il numero successivo

'Ç_ÇH0Æd = ¥ 1 # × 3 + Link principale. Argomento: n
'Incremento n
 Ç Calcola F n + 1 
   Ç Calcola F n
  _ Sottrai
    H Dividi per 2
     0 1 # A partire da 0, trova il primo candidato per (a n -n) / 3
                   che soddisfa ...
      Æd σ 0 ((a n -n) / 3)
        = = (F n + 1 -F n ) / 2
            × 3 Moltiplicare per 3 per trasformare (a n -n) / 3 in n -n
              + Aggiungi n per trasformare un n -n in un n

Python 2 , 121 119 118 byte

n=input();r=range(1,4**n);d=s,=r*1,
for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,
print d.index(s[n]-s[n-1])*3+n

Il tempo di esecuzione dovrebbe essere all'incirca O (16 ⁿ ) con l' utilizzo della memoria O (4 ⁿ ) . Sostituire 4**ncon 5<<n- che penso sia sufficiente - migliorerebbe drasticamente questo, ma non sono convinto che funzioni con valori arbitrariamente grandi di n .

Provalo online!

Comportamento asintotico e limiti superiori di un _n

Definisci b _n come (a _n - n) / 3 , ovvero il numero intero positivo più piccolo k tale che σ ₀ (k) = ½ (f _{n + 1} - f _n ) .

Come notato nella pagina OEIS, f _n ~ ¼πn ² , quindi f _{n + 1} - f _n ~ ¼π (n + 1) ² - ¼πn ² = ¼πn (2n + 1) ~ ½πn .

In questo modo, ½ (f _{n + 1} - f _n ) ~ ¼πn . Se il numero effettivo è un numero primo p , il numero intero positivo più piccolo con divisori p è 2 ^p-1 , quindi b _n può essere approssimato di 2 ^{c _n} , dove c _n ~ ¼πn .

Pertanto b _n <4 ⁿ rimarrà per n sufficientemente grande , e dato che 2 ^¼πn <2 ⁿ << (2 ⁿ ) ² = 4 ⁿ , sono sicuro che non ci sono controesempi.

Come funziona

n=input();r=range(1,4**n);d=s,=r*1,

Questo crea alcuni riferimenti per il nostro processo iterativo.

• n è l'input dell'utente: un numero intero positivo.

• r è l'elenco [1, ..., 4 ⁿ - 1] .

• s è una copia di r .

  Ripetendo l'elenco una volta con si r*1crea una copia superficiale, quindi modificando s non si modifica r .

• d è inizializzato come tupla / e .

  Questo primo valore non è importante. Tutti gli altri terranno conteggi divisori di numeri interi positivi.

for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,

Per ogni intero k da 1 a 4 ⁿ - 1 , facciamo quanto segue.

• del s[k::k+1]prende ogni (k + 1) ^th intero in s - a partire da (k + 1) ^th - ed elimina quella sezione da s .

  Questo è un modo semplice per memorizzare un intervallo iniziale del setaccio Flavio Giuseppe in s . Calcolerà molto più dei necessari n + 1 condizioni iniziali, ma utilizzando un singolo forciclo per aggiornare sia s e d salva alcuni byte.

• d+=sum(k%j<1for j in r)*2,conta quanti elementi di r dividono k uniformemente e aggiunge 2σ ₀ (k) a d .

  Poiché d è stato inizializzato come una tupla singleton, 2σ ₀ (k) è memorizzato all'indice k .

print d.index(s[n]-s[n-1])*3+n

Questo trova il primo indice di f _{n + 1} - f _n in d , che è il più piccolo k tale che 2σ ₀ (k) = f _{n + 1} - f _n , quindi calcola un _n come 3k + 1 e stampa il risultato.

Java 8, 336 , 305 , 303 , 287 , 283 279 byte

57 byte rimossi grazie a Kritixi Lithos

golfed

class f{static int g(int s,int N){return s<1?N+1:g(s-1,N+N/s);}static int h(int k){int u=0,t=1,i;for(;u!=(g(k,k)-g(k,k-1))/2;t++)for(i=1,u=0;i<=t;)if(t%i++<1)u++;return 3*t-3+k;}public static void main(String[]a){System.out.print(h(new java.util.Scanner(System.in).nextInt()));}}

Ungolfed

class f {
    static int g(int s,int N){return s < 1 ? N + 1 : g(s - 1, N + N / s);}

    static int h(int k) {
        int u = 0, t = 1, i;
        // get the first number with v divisors
        while(u != (g(k, k) - g(k, k - 1))/2){
            u = 0;
            for (i = 1; i <= t; i++)
                if (t % i < 1) u++;
            t++;
        }
        // 3*(t-1)+k = 3*t+k-3
        return 3 * t + k - 3;
    }

    public static void main(String[] a) {
        System.out.print(h(new java.util.Scanner(System.in).nextInt()));
    }
}

Mathematica, 130 116 106 103 byte

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[Tr[2+0Divisors@k]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

o

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[2DivisorSum[k,1&]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

Finì per essere quasi identico al codice Jelly di @ Pietu1998 ...

Spiegazione

Catch@

Catchqualunque cosa sia Throw-ed (generata).

Do[ ... ,{k,∞}]

Ciclo infinito; kinizia da 1e incrementa ogni iterazione.

f= ...

Assegna f:

Reverse@Range@#

Trova {1, 2, ... , n}. Invertire.

#2⌈#/#2+1⌉&

Una funzione che emette ceil (n1 / n2 + 1) * n2

f= ... ~Fold~ ... &

Assegna funa funzione che applica ricorsivamente la funzione sopra all'elenco da due passaggi precedenti, usando ogni output come primo input e ogni elemento dell'elenco come secondo input. L '"output" iniziale (primo input) è il primo elemento dell'elenco.

Tr[2+0Divisors@k]==f[#+1]-f@#

Controlla se il numero di divisori di due volte kè uguale a f (n + 1) - f (n).

If[ ... ,Throw@k]

Se la condizione è True, Throwil valore di k. In caso contrario, continua il loop.

3 ... +#&

Moltiplica l'output per 3 e aggiungi n.

Versione da 130 byte

Catch@Do[s=#+1;a=k-#;If[3∣a&&2DivisorSigma[0,a/3]==Differences[Nest[i=1;Drop[#,++i;;;;i]&,Range[s^2],s]][[#]],Throw@k],{k,∞}]&

Perl 6 , 154 149 136 107 byte

->\n{n+3*first ->\o{([-] ->\m{m??&?BLOCK(m-1).rotor(m+0=>1).flat!!1..*}(n)[n,n-1])/2==grep o%%*,1..o},^Inf}

Ungolfed:

-> \n {                    # Anonymous sub taking argument n
  n + 3 * first -> \o {    # n plus thrice the first integer satisfying:
    (                      #
      [-]                  #
      -> \m {              # Compute nth sieve iteration:
        m                  # If m is nonzero,
          ?? &?BLOCK(m-1).rotor(m+0=>1).flat # then recurse and remove every (m+1)-th element;
          !! 1..*          # the base case is all of the positive integers
      }                    #
      (n)                  # Get the nth sieve
      [n,n-1]              # Get the difference between the nth and (n-1)th elements (via the [-] reduction operator above)
    ) / 2                  # and divide by 2;
    ==                     # We want the number that equals
    grep o %% *, 1..o      # the number of divisors of o.
  }
  ,^Inf
}

05AB1E ,35 34 39 byte

1Qi4ë[N3*¹+NÑg·¹D>‚vyy<LRvy/>îy*}}‚Æ(Q#

Sembra orribile, così come le prestazioni di runtime. Ci vogliono diversi secondi per l'input che produce valori piccoli. Non provare numeri come 14; alla fine troverà il risultato ma ci vorranno anni.

Spiegazione

Funziona come 2 programmi chiamati in sequenza. Il primo calcola F _{n + 1} - F _n e il secondo determina una _{n in} base alla sua definizione, usando un approccio bruteforce.

F _{n + 1} : F _n viene valutato per ogni iterazione anche se è invariante di loop. Rende il tempo in codice inefficiente, ma abbrevia il codice.

Provalo online!