¿Ya estás perdido?

31

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, σ 0 (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 0 ((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 . ¡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 1 a f 7 .

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 σ 0 ((k - 1) / 3) = 1 . De hecho, σ 0 (1) = 1 .
  • 8 es el primer entero k tal que σ 0 ((k - 2) / 3) = 2 . De hecho, σ 0 (2) = 2 .
  • 15 es el primer entero k tal que σ 0 ((k - 3) / 3) = 3 . De hecho, σ 0 (4) = 3 .
  • 16 es el primer entero k tal que σ 0 ((k - 4) / 3) = 3 . De hecho, σ 0 (4) = 3 .
  • 23 es el primer entero k tal que σ 0 ((k - 5) / 3) = 4 . De hecho, σ 0 (6) = 4 .
  • 42 es el primer entero k tal que σ 0 ((k - 6) / 3) = 6 . De hecho, σ 0 (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
Dennis
fuente
14
Palabra clave en OEIS: tonto ("una secuencia sin importancia").
orlp
15
¿Tonto? ¡Podría salvar al mundo!
Dennis
3
Ese juego de palabras sin embargo ...
Mego

Respuestas:

7

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
PurkkaKoodari
fuente
3

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 n ) con uso de memoria O (4 n ) . 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 σ 0 (k) = ½ (f n + 1 - f n ) .

Como se señaló en la página OEIS, f n ~ ¼πn 2 , entonces f n + 1 - f n ~ ¼π (n + 1) 2 - ¼πn 2 = ¼π (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 n se mantendrá durante n suficientemente grande , y dado que 2 ¼πn <2 n << (2 n ) 2 = 4 n , 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 n - 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 n - 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 0 (k) a d .

    Como d se inicializó como una tupla singleton, 0 (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 0 (k) = f n + 1 - f n , luego calcula a n como 3k + 1 e imprime el resultado.

Dennis
fuente
2

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()));
    }
}
Bobas_Pett
fuente
Creo que al analizar los argumentos de línea de comando como intes más corto que el uso java.util.Scanner. Pero incluso si está utilizando el escáner, puede hacer System.out.print(h(new java.util.Scanner().nextInt()))y eliminar la línea anterior
Kritixi Lithos
@KritixiLithos thx, arreglando ahora ...
Bobas_Pett
En el interior int h(), puedes cambiarlo a int v = (g(k,k)-g(k,k-1))/2,u = 0,t = 1;. Puede cambiar su declaración if (que está dentro de su ciclo for) de if(t%i==0)aif(t%i<1)
Kritixi Lithos el
Además, puede cambiar su función gpara volver utilizando operadores ternarios algo así como return s==0?N+1:g(s-1,N+N/2)-ish
Kritixi Lithos
2
@KritixiLithos lol en este punto deberías publicar esto como tu propia solución separada
Bobas_Pett
1

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,∞}]&
JungHwan Min
fuente
1

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
}
Sean
fuente
1

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!

Osable
fuente
No estoy seguro de entender. ¿Por qué no puede calcular el tamiz por encima de 65.536?
Dennis
Proviene del hecho de que genera todos los enteros entre 0 y 65536 ( žHL) y luego filtra los valores que no satisfacen las restricciones de tamiz. Creo que la primera parte de este programa debería reescribirse por completo con un enfoque completamente diferente para que sea golfable.
Osable
A menos que haya limitaciones (como enteros de ancho fijo) que le impiden hacerlo, se espera que las respuestas funcionen para cualquier entrada, dado el tiempo y la memoria suficientes.
Dennis
Es por eso que se me ocurrió otro algoritmo de tamizado. Puede ser golfable pero no he encontrado mejor en 05AB1E. Sin embargo, existe un contraejemplo given enough time and memory, ya que ya vi varias respuestas sobre otras preguntas que corrieron tan lentamente que era casi imposible decir si produjeron el resultado correcto o no. Por esta razón, puse el cálculo del tamiz a un lado del ciclo y me costó 2 bytes.
Osable
No es necesario que su código sea eficiente. Puede hacer que la implementación de golf / lenta sea su presentación e incluir la más rápida / más larga como nota al margen. Sin embargo, me temo que tengo que insistir en el límite dinámico, incluso si cuesta un byte.
Dennis