_{Inspirado en esta entrada de Numberphile}

Antecedentes

Los números de distancia de cubo de un entero n se definen aquí como el conjunto de enteros que están a una distancia de x³ para una x dada . Para un ejemplo simple, con n=100y x=2, los números de distancia del cubo son {92,108}.

Esto se puede extender a un conjunto más grande simplemente variando x . Con x ∈ {1,2,3,4}y lo mismo n=100, tenemos el conjunto resultante {36,73,92,99,101,108,127,164}.

Definamos CD (n, x) como el conjunto de todos los enteros n ± z³con z ∈ {1,2,3,...,x}.

Ahora podemos centrarnos en algunas de las propiedades especiales de estos números de distancia de cubo . De las muchas propiedades especiales que los números pueden tener, las dos propiedades que nos interesa aquí son primalidad y divisores primos .

Para el ejemplo de CD anterior (100,4) , tenga en cuenta que 73, 101, 127todos son primos. Si los eliminamos del conjunto, nos quedamos con {36,92,99,108,164}. Todos los divisores primos de estos números son (en orden) {2,2,3,3,2,2,23,3,3,11,2,2,3,3,3,2,2,41}, lo que significa que tenemos 5 divisores primos distintos {2,3,23,11,41}. Por lo tanto, podemos definir que CD (100,4) tiene ravenidad ¹ de 5.

El desafío aquí es escribir una función o programa, en la menor cantidad de bytes, que genere la escasez de una entrada dada.

Entrada

• Dos enteros positivos ny x, en cualquier formato conveniente.

Salida

• Un entero único que describe la raveza de los dos números de entrada, cuando se calcula con CD (n, x) .

Reglas

• La entrada / salida puede ser a través de cualquier método adecuado .
• Se aplican restricciones de escapatoria estándar .
• Para facilitar el cálculo, puede suponer que los datos de entrada serán tales que CD (n, x) solo tendrá números positivos en el conjunto (es decir, ningún CD (n, x) tendrá números negativos o cero).
• La función o el programa deberían poder manejar los números de entrada para que se n + x³ajusten al tipo de datos de entero nativo de su idioma. Por ejemplo, para un tipo entero con signo de 32 bits, todos los números de entrada con n + x³ < 2147483648son posibles.

Ejemplos

n,x   - output
2,1   - 0   (since CD(2,1)={1,3}, distinct prime divisors={}, ravenity=0)
5,1   - 2
100,4 - 5
720,6 - 11

Notas al pie

1 - Llamado así porque no estamos interesados ​​en la cardinalidad del conjunto, sino en un tipo diferente de ave. Como estamos tratando con divisores "comunes", elegí usar el cuervo común .

Jalea, 16 bytes

ŒRḟ0*3+µÆfFœ-µQL

Toma x y n como argumentos de línea de comandos, en ese orden. Pruébalo en línea!

Cómo funciona

ŒRḟ0*3+µÆfFœ-µQL  Main link. Arguments, x, n

ŒR                Range; yield [-x, ..., x].
  ḟ0              Filter out 0.
    *3            Cube each remaining integer.
      +           Add n to all cubes.
       µ          Begin a new, monadic link. Argument: A (list of sums)
        Æf        Factorize each k in A.
          F       Flatten the resulting, nested list.
           œ-     Perform multiset difference with A.
                  If k in A is prime, Æf returns [k], adding on k too many to the
                  flat list. Multiset difference with A removes exactly one k from
                  the results, thus getting rid of primes.
                  If k is composite (or 1), it cannot appear in the primes in the
                  flat list, so subtracting it does nothing.
             µ    Begin a new, monadic link. Argument: D (list of prime divisors)
              Q   Unique; deduplicate D.
               L  Compute the length of the result.

Pyth - 21 19 18 bytes

Me pregunto si hay un truco.

l{st#mP+Q^d3s_BMSE

Test Suite .

l                   Length
 {                  Uniquify
  s                 Combine divisor lists
   t#               Filter by if more than one element
     PM             Take prime factorization of each number
       +RQ          Add each num in list to input
          s_BM      Each num in list and its negative (with bifurcate)
              ^R3   Cube each num in list
                 SE Inclusive unary range - [1, 2, 3,... n] to input

Julia, 107 bytes

f(n,x)=endof(∪(foldl(vcat,map(k->[keys(factor(k))...],filter(i->!isprime(i),[n+z^3for z=[-x:-1;1:x]])))))

Esta es una función que acepta dos enteros y devuelve un entero.

Sin golf:

function f(n, x)
    # Get all cube distance numbers
    cubedist = [n + z^3 for z = [-x:-1; 1:x]]

    # Filter out the primes and zeros
    noprimes = filter(i -> !isprime(i) && i > 0, cubedist)

    # Factor each remaining number
    factors = map(k -> [keys(factor(k))...], noprimes)

    # Flatten the list of factors
    flat = foldl(vcat, factors)

    # Return the number of unique elements
    return endof(∪(flat))
end

05AB1E , 20 19 bytes

Código:

L3mD(«-Dp_Ïvyf`})Úg

En la forma interactiva x, n. Utiliza la codificación CP-1252 .

Pruébalo en línea!

MATL , 21 bytes

:3^t_h+tZp~)"@Yf!]vun

La entrada es x, nseparada por una nueva línea.

Pruébalo en línea!

Explicación

:       % take n implicitly. Generate [1,2,...,n]
3^      % raise to 3, element-wise
t_h     % duplicate, negate, concatenate horizontally: [1,2,...,n,-1,2,...-n]
+       % take x implicitly. Add to that array
t       % duplicate
Zp      % array that contains true for primes
~       % logical negate
)       % apply index to keep only non-primes
"       % for each number in that array
  @     %   push that number
  Yf!   %   prime factors, as a column array
]       % end for each
v       % concatenate vertically all factors
u       % remove repeated factors
n       % number of elements of that array. Implicitly display

J, 30 bytes

#@~.@(,@:q:-.0&,)@:+(|#^&3)@i:

Este es un verbo diádico, usado de la siguiente manera:

   f =: #@~.@(,@:q:-.0&,)@:+(|#^&3)@i:
   100 f 4
5

Pruébalo aquí.

Explicación

#@~.@(,@:q:-.0&,)@:+(|#^&3)@i:
                            i:  Range from -x to x
                    (     )@    Apply this verb to the range:
                       ^&3        a) every item cubed
                     |            b) absolute value of every item
                      #           c) every item in a) repeated b) times; this removes 0
                                     and produces some harmless duplication
                   +            Add n to every element of the resulting list
     (          )@:             Apply this verb to the resulting vector:
             0&,                  a) the vector with 0 appended
      ,@:q:                       b) flat list of prime divisors in the vector
                                     (and some extra 0s since we flatten an un-even matrix)
           -.                     c) list b) with elements of a) removed; this gets rid of
                                     the extra 0s and all primes that were in the list
#@~.@                           Remove duplicates and take length

Python 3.5, 218 198 bytes:

( Gracias a @Blue por salvarme 20 bytes).

lambda r,n:len({z for z in{v for f in{t for u in[[r-q**3,r+q**3]for q in range(1,n+1)]for t in u if any(t%g<1 for g in range(2,t))}for v in range(2,f)if f%v<1}if all(z%g>0 for g in range(2,z))})

Una buena función lambda de una línea, aunque puede ser un poco larga. Como estaba usando Python, tuve que encontrar mi propia forma de encontrar los compuestos para el primer paso, y luego los divisores principales para el último paso, por lo que no fue muy fácil, y este fue el más corto que yo solo. . podría hacerlo. No obstante, hace lo que necesita y estoy orgulloso de ello. :) Sin embargo, cualquier consejo para jugar golf un poco más es bienvenido.

PARI / GP , 79 bytes

(n,x)->omega(factorback(select(k->!isprime(k),vector(2*x,i,n+(i-(i<=x)-x)^3))))

Aquí está mi implementación directa original. La versión optimizada anterior combina los dos vectores en un solo vector un poco más complicado.

(n,x)->omega(factorback(select(k->!isprime(k),concat(vector(x,i,n-i^3),vector(x,i,n+i^3)))))

Rubí, 138 bytes

->(n,x){require'prime'
v=((-x..x).to_a-[0]).map{|i|n+i**3}.reject{|e|Prime.prime?(e)}
Prime.each(v[-1]).select{|i|v.any?{|e|e%i==0}}.size}

Fue un desafío insignificante . :-)

Ruby, 132 120 114 bytes

Soy consciente de que esta solución todavía necesita mucho golf. Cualquier consejo de golf es bienvenido.

require'prime'
->n,x{(-x..x).map{|i|j=n+i**3;j.prime?||(j==n)?[]:j.prime_division.map{|z|z[0]}}.flatten.uniq.size}

No golfista:

require 'prime'

def ravenity(n, x)
  z = []
  (-x..x).each do |i|
    j = n + i**3
    m = j.prime_division
    if j.prime? || j == n
      z << []
    else
      z << m.map{|q| q[0]}
    end
  return z.flatten.uniq.size
end

Python 3.5 - 177 175 159 bytes

Cualquier consejo de golf bienvenido :)

a=range
p=lambda n:any(n%x<1for x in a(2,n))
r=lambda n,x:len(set(sum([[x for x in a(2,z+1)if z%x<1&1>p(x)]for z in filter(p,[n+z**3for z in a(-x,x+1)])],[])))

Sin golf:

def is_composite(n):
    return any(n % x == 0 for x in range(2, n))

def prime_factors(n):
    return {x for x in range(2, n+1) if n % x == 0 and not is_composite(x)}

def ravenity(n, x):
    nums = [n + z**3 for z in range(-x, x+1)]
    nums = filter(is_composite, nums)
    factors = map(prime_factors, nums)
    factors = sum(factors, [])
    #remove duplicates
    factors = set(factors)
    return len(factors)

Wolfram Language (Mathematica) , 90 bytes

Tr[1^Union[First/@Join@@FactorInteger/@Select[z=Range@#2^3;Join@@{#-z,#+z},Not@*PrimeQ]]]&

Pruébalo en línea!

sin golf: el código se lee principalmente de derecha a izquierda,

F[n_, x_] := 
  Length[Union[                                        (* number of unique elements   *)
    First /@                                           (* drop multiplicities         *)
      Join @@                                          (* join all prime factor lists *)
        FactorInteger /@                               (* compute prime factors       *)
          Select[                                      (* select those...             *)
            Join @@ {n - Range[x]^3, n + Range[x]^3},  (* ...candidates...            *)
            Not@*PrimeQ]]]                             (* ...that are not prime       *)