_{Inspiré par cette entrée Numberphile}

Contexte

Les nombres de distance de cube d'un entier n sont définis ici comme l'ensemble des entiers qui sont à une distance de x³ pour un x donné . Pour un exemple simple, avec n=100et x=2, les nombres de distance de cube sont {92,108}.

Cela peut être étendu à un ensemble plus grand en faisant simplement varier x . Avec x ∈ {1,2,3,4}et le même n=100, nous avons l'ensemble résultant {36,73,92,99,101,108,127,164}.

Définissons CD (n, x) comme l'ensemble de tous les entiers n ± z³avec z ∈ {1,2,3,...,x}.

Nous pouvons maintenant nous concentrer sur certaines des propriétés spéciales de ces nombres de distance de cube . Parmi les nombreuses propriétés spéciales que les nombres peuvent avoir, les deux propriétés qui nous intéressent ici sont la primauté et les diviseurs premiers .

Pour l'exemple CD ci-dessus (100,4) , notez qu'ils 73, 101, 127sont tous premiers. Si nous les supprimons de l'ensemble, nous nous retrouvons avec {36,92,99,108,164}. Tous les diviseurs premiers de ces nombres sont (dans l'ordre) {2,2,3,3,2,2,23,3,3,11,2,2,3,3,3,2,2,41}, ce qui signifie que nous avons 5 diviseurs premiers distincts {2,3,23,11,41}. On peut donc définir que CD (100,4) a la corvée ¹ de 5.

Le défi ici est d'écrire une fonction ou un programme, dans le moins d'octets, qui génère la ravenity d'une entrée donnée.

Contribution

• Deux entiers positifs net xdans n'importe quel format pratique.

Production

• Un entier unique décrivant la ravenity des deux nombres d'entrée, lorsqu'il est calculé avec CD (n, x) .

Règles

• L'entrée / sortie peut se faire via n'importe quelle méthode appropriée .
• Des restrictions standard contre les échappatoires s'appliquent.
• Pour faciliter le calcul, vous pouvez supposer que les données d'entrée seront telles que CD (n, x) n'aura que des nombres positifs dans l'ensemble (c'est-à-dire qu'aucun CD (n, x) n'aura jamais de nombres négatifs ou zéro).
• La fonction ou le programme doit être en mesure de gérer les numéros d'entrée de manière à ce qu'ils n + x³correspondent au type de données entier natif de votre langue. Par exemple, pour un type entier signé 32 bits, tous les numéros d'entrée avec n + x³ < 2147483648sont possibles.

Exemples

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

Notes de bas de page

1 - Ainsi nommé car nous ne nous intéressons pas à la cardinalité de l'ensemble, mais à un type d'oiseau différent. Puisque nous avons affaire à des diviseurs "communs", j'ai choisi d'utiliser le corbeau commun .

Gelée, 16 octets

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

Prend x et n comme arguments de ligne de commande, dans cet ordre. Essayez-le en ligne!

Comment ça fonctionne

Œ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 octets

Je me demande s'il y a un truc.

l{st#mP+Q^d3s_BMSE

Suite de tests .

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 octets

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

Il s'agit d'une fonction qui accepte deux entiers et renvoie un entier.

Non 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 octets

Code:

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

Entrée sous la forme x, n. Utilise l' encodage CP-1252 .

Essayez-le en ligne!

MATL , 21 octets

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

L'entrée est x, nséparée par une nouvelle ligne.

Essayez-le en ligne!

Explication

:       % 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 octets

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

Il s'agit d'un verbe dyadique, utilisé comme suit:

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

Essayez-le ici.

Explication

#@~.@(,@: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 octets:

( Merci à @Blue de m'avoir sauvé 20 octets.)

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

Une belle fonction lambda à une ligne, même si elle peut être un peu longue. Depuis que j'utilisais Python, j'ai dû trouver ma propre façon de trouver les composites pour la première étape, puis les diviseurs principaux pour la dernière étape, donc ce n'était pas très facile, et ce fut le plus court moi-même, par moi-même . pourrait y arriver. Néanmoins, il fait ce dont il a besoin et j'en suis fier. :) Cependant, tous les conseils pour jouer au golf un peu plus sont les bienvenus.

PARI / GP , 79 octets

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

Voici ma mise en œuvre simple et originale. La version optimisée ci-dessus combine les deux vecteurs en un seul vecteur légèrement plus compliqué.

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

Rubis, 138 octets

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

Ce fut un jeu de mots y défi. :-)

Rubis, 132 120 114 octets

Je suis bien conscient que cette solution nécessite encore beaucoup de golf. Tous les conseils de golf sont les bienvenus.

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}

Ungolfing:

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 octets

Tous les conseils de golf sont les bienvenus :)

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)])],[])))

Non 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 octets

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

Essayez-le en ligne!

sans golf: le code est lu principalement de droite à gauche,

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