Su tarea es implementar la secuencia de enteros A130826 :

un _n es el número entero positivo más pequeño de tal manera que un _n - n es un múltiplo entero de 3 y dos veces el número de divisores de (a _n - n) / 3 da n ^º plazo en las primeras diferencias de la secuencia producida por el Flavius Josefo tamiz.

Perdido todavía? Bueno, en realidad es bastante fácil.

El tamiz Flavius ​​Josephus define una secuencia entera de la siguiente manera.

1. Comience con la secuencia de enteros positivos y establezca k = 2 .

2. Retirar cada k ^ésimo número entero de la secuencia, empezando por el k ^ésimo .

3. Incremente ky regrese al paso 2.

f _n es el n ^º entero (1-indexado) que nunca se retira.

Si, como de costumbre, σ ₀ (k) denota el número de divisores positivos del entero k , podemos definir a _n como el entero positivo más pequeño de modo que 2σ ₀ ((a _n - n) / 3) = f _{n + 1} - f _n .

Reto

Escriba un programa o función que tome un entero positivo n como entrada e imprima o devuelva un _n .

Aplican reglas estándar de código de golf . ¡Que gane el código más corto!

Ejemplos trabajados

Si eliminamos cada segundo elemento de los enteros positivos, nos queda con

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

Después de eliminar cada tercer elemento del resto, obtenemos

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

Ahora, quitando cada cuarto, luego quinto y luego sexto elemento

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

La última fila muestra los términos f ₁ a f ₇ .

Las diferencias de los elementos consecutivos de estos términos son

 2  4  6  6  8 12

Dividiendo estas diferencias hacia adelante por 2 , obtenemos

 1  2  3  3  4  6 

Estos son los recuentos de divisores objetivo.

• 4 es el primer entero k tal que σ ₀ ((k - 1) / 3) = 1 . De hecho, σ ₀ (1) = 1 .
• 8 es el primer entero k tal que σ ₀ ((k - 2) / 3) = 2 . De hecho, σ ₀ (2) = 2 .
• 15 es el primer entero k tal que σ ₀ ((k - 3) / 3) = 3 . De hecho, σ ₀ (4) = 3 .
• 16 es el primer entero k tal que σ ₀ ((k - 4) / 3) = 3 . De hecho, σ ₀ (4) = 3 .
• 23 es el primer entero k tal que σ ₀ ((k - 5) / 3) = 4 . De hecho, σ ₀ (6) = 4 .
• 42 es el primer entero k tal que σ ₀ ((k - 6) / 3) = 6 . De hecho, σ ₀ (12) = 6 .

Casos de prueba

   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

Jalea, 30 29 27 25 bytes

Ahorré 2 bytes gracias a @Dennis que me notificó Ædy otros 2 bytes por combinar las dos cadenas.

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

Pruébalo en línea!

Esta fue probablemente la más divertida que he tenido con Jelly. Comencé desde la segunda línea, que calcula f _{n a} partir de n usando la fórmula en OEIS, y es bastante hermosa.

Explicación

RUð ÷ 'Ċ × µ / Enlace auxiliar para calcular F n . Argumento: n
R Obtener números [1..n]
 U inversa
        / Reducir en "redondear a los siguientes 2 múltiplos":
   ÷ Dividir por el siguiente número
    'Incremento para omitir un múltiplo
     Ċ Techo (redondear hacia arriba)
      × Multiplica por el siguiente número

'Ç_ÇH0Æd = ¥ 1 # × 3 + Enlace principal. Argumento: n
'Incremento n
 Ç Calcular F n + 1 
   Ç Calcular F n
  _ Restar
    H Dividir por 2
     0 1 # A partir de 0, encuentre el primer candidato para (a n -n) / 3
                   eso satisface ...
      Æd σ 0 ((a n -n) / 3)
        = = (F n + 1 -F n ) / 2
            × 3 Multiplica por 3 para convertir (a n -n) / 3 en n -n
              + Agregar n para convertir una n -n en una n

Python 2 , 121 119 118 bytes

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

El tiempo de ejecución debe ser aproximadamente O (16 ⁿ ) con uso de memoria O (4 ⁿ ) . Reemplazar 4**ncon 5<<n, lo que creo que es suficiente, mejoraría dramáticamente esto, pero no estoy convencido de que funcione para valores arbitrariamente grandes de n .

Pruébalo en línea!

Comportamiento asintótico y límites superiores de una _n

Defina b _n como (a _n - n) / 3 , es decir, el entero positivo más pequeño k tal que σ ₀ (k) = ½ (f _{n + 1} - f _n ) .

Como se señaló en la página OEIS, f _n ~ ¼πn ² , entonces f _{n + 1} - f _n ~ ¼π (n + 1) ² - ¼πn ² = ¼π (2n + 1) ~ ½πn .

De esta manera, ½ (f _{n + 1} - f _n ) ~ ¼πn . Si el número real es un primo p , el entero positivo más pequeño con p divisores es 2 ^p-1 , por lo que b _n puede aproximarse por 2 ^{c _n} , donde c _n ~ ¼πn .

Por lo tanto, b _n <4 ⁿ se mantendrá durante n suficientemente grande , y dado que 2 ^¼πn <2 ⁿ << (2 ⁿ ) ² = 4 ⁿ , estoy seguro de que no hay contraejemplos.

Cómo funciona

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

Esto establece algunas referencias para nuestro proceso iterativo.

• n es la entrada del usuario: un entero positivo.

• r es la lista [1, ..., 4 ⁿ - 1] .

• s es una copia de r .

  Repetir la lista una vez con r*1crea una copia superficial, por lo que modificar s no modificará r .

• d se inicializa como la tupla (s) .

  Este primer valor no es importante. Todos los demás tendrán recuentos de divisores de enteros positivos.

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

Para cada entero k de 1 a 4 ⁿ - 1 , hacemos lo siguiente.

• del s[k::k+1]toma cada entero (k + 1) ^th en s , comenzando con el (k + 1) ^th , y elimina esa porción de s .

  Esta es una forma directa de almacenar un intervalo inicial del tamiz Flavio Josefo en s . Se calculará mucho más que las requeridas n + 1 términos iniciales, pero utilizando un único forbucle para actualizar ambos s y d ahorra algunos bytes.

• d+=sum(k%j<1for j in r)*2,cuenta cuántos elementos de r dividen k de manera uniforme y agrega 2σ ₀ (k) a d .

  Como d se inicializó como una tupla singleton, 2σ ₀ (k) se almacena en el índice k .

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

Esto encuentra el primer índice de f _{n + 1} - f _n en d , que es el k más pequeño de modo que 2σ ₀ (k) = f _{n + 1} - f _n , luego calcula a _n como 3k + 1 e imprime el resultado.

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

57 bytes eliminados gracias 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()));}}

Sin golf

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 bytes

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,∞}]+#&

Terminó siendo casi idéntico al código Jelly de @ Pietu1998 ...

Explicación

Catch@

Catchlo que sea Throw-ed (arrojado)

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

Bucle infinito; kcomienza 1e incrementa cada iteración.

f= ...

Asignar f:

Reverse@Range@#

Encuentra {1, 2, ... , n}. Revertirla.

#2⌈#/#2+1⌉&

Una función que emite ceil (n1 / n2 + 1) * n2

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

Asigne funa función que aplique recursivamente la función anterior a la lista de los dos pasos anteriores, usando cada salida como la primera entrada y cada elemento de la lista como la segunda entrada. La "salida" inicial (primera entrada) es el primer elemento de la lista.

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

Compruebe si dos veces el número de divisores de kes igual a f (n + 1) - f (n).

If[ ... ,Throw@k]

Si la condición es True, Throwel valor de k. De lo contrario, continúe en bucle.

3 ... +#&

Multiplique la salida por 3 y agregue n.

Versión de 130 bytes

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 bytes

->\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}

Sin golf:

-> \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 bytes

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

Se ve horrible, al igual que el rendimiento en tiempo de ejecución. La entrada tarda varios segundos en obtener valores pequeños. No intentes números como el 14; eventualmente encontrará el resultado, pero llevaría años.

Explicación

Funciona como 2 programas llamados secuencialmente. El primero calcula F _{n + 1} - F _n y el segundo determina un _n basado en su definición, utilizando un enfoque de fuerza bruta.

F _{n + 1} : F _n se evalúa para cada iteración aunque sea invariante en bucle. Hace que el tiempo del código sea ineficiente, pero lo hace más corto.

Pruébalo en línea!