_{Inspiriert von diesem Numberphile-Eintrag}

Hintergrund

Die Würfel Abstand Nummern einer ganzen Zahl n sind hier als die Menge der ganzen Zahlen definiert, die X³ Abstand für eine gegebene x . Für ein einfaches Beispiel mit n=100und x=2die Würfel Abstand Zahlen sind {92,108}.

Dies kann durch einfaches Variieren von x zu einer größeren Menge erweitert werden . Mit x ∈ {1,2,3,4}und n=100haben wir die Ergebnismenge {36,73,92,99,101,108,127,164}.

Definieren wir CD (n, x) als die Menge aller ganzen Zahlen n ± z³mit z ∈ {1,2,3,...,x}.

Jetzt können wir uns auf einige der besonderen Eigenschaften dieser Würfelabstandszahlen konzentrieren . Von den vielen speziellen Eigenschaften , die Zahlen haben können, sind die beiden Eigenschaften , die wir hier interessiert sind primality und Primteilern .

Beachten Sie für die obige Beispiel- CD (100,4) , dass 73, 101, 127alle Primzahlen sind. Wenn wir diese aus dem Set entfernen, bleibt uns nichts anderes übrig {36,92,99,108,164}. Alle Primteiler dieser Zahlen sind (in der richtigen Reihenfolge). Dies {2,2,3,3,2,2,23,3,3,11,2,2,3,3,3,2,2,41}bedeutet, dass wir 5 verschiedene Primteiler haben {2,3,23,11,41}. Wir können daher definieren, dass CD (100,4) den Rabenwert ¹ von hat 5.

Die Herausforderung hierbei besteht darin, eine Funktion oder ein Programm in den wenigsten Bytes zu schreiben, die bzw. das die Ravenität einer bestimmten Eingabe ausgibt .

Eingang

• Zwei positive ganze Zahlen nund xin jedem geeigneten Format.

Ausgabe

• Eine einzelne Ganzzahl, die die Ravenität der beiden eingegebenen Zahlen beschreibt, wenn sie mit CD (n, x) berechnet wird .

Regeln

• Die Eingabe / Ausgabe kann über jede geeignete Methode erfolgen .
• Es gelten die üblichen Lückenbeschränkungen.
• Zur Vereinfachung der Berechnung können Sie davon ausgehen, dass die Eingabedaten so sind, dass CD (n, x) nur positive Zahlen im Satz enthält (dh keine CD (n, x) hat jemals negative Zahlen oder Null).
• Die Funktion oder das Programm sollte in der Lage sein, Eingabenummern so zu verarbeiten, dass sie n + x³in den nativen Ganzzahldatentyp Ihrer Sprache passen. Beispielsweise sind für einen 32-Bit-Integer-Typ mit Vorzeichen alle Eingabenummern mit n + x³ < 2147483648möglich.

Beispiele

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

Fußnoten

1 - So genannt, weil wir nicht an der Kardinalität des Sets interessiert sind , sondern an einem anderen Vogeltyp. Da es sich um "gemeinsame" Teiler handelt, habe ich mich für den gemeinsamen Raben entschieden .

Gelee, 16 Bytes

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

Nimmt x und n als Befehlszeilenargumente in dieser Reihenfolge. Probieren Sie es online!

Wie es funktioniert

Œ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

Ich frage mich, ob es einen Trick gibt.

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

Dies ist eine Funktion, die zwei Ganzzahlen akzeptiert und eine Ganzzahl zurückgibt.

Ungolfed:

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 bis 19 Bytes

Code:

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

Eingabe in Form x, n. Verwendet die CP-1252- Codierung.

Probieren Sie es online!

MATL , 21 Bytes

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

Eingegeben wird x, ndurch eine neue Zeile getrennt werden .

Probieren Sie es online!

Erläuterung

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

Dies ist ein dyadisches Verb, das wie folgt verwendet wird:

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

Probieren Sie es hier aus.

Erläuterung

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

( Danke an @Blue, dass du mir 20 Bytes gespart hast.)

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

Eine schöne einzeilige Lambda-Funktion, auch wenn sie etwas lang sein kann. Da ich Python benutzte, musste ich meine eigene Methode finden, um die Komposite für den ersten Schritt und dann die Hauptteiler für den letzten Schritt zu finden. Es war also nicht sehr einfach, und dies war der kürzeste Weg für mich . könnte es schaffen. Trotzdem tut es, was es braucht, und ich bin stolz darauf. :) Allerdings sind alle Tipps zum Golfen ein bisschen mehr willkommen.

PARI / GP , 79 Bytes

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

Hier ist meine ursprüngliche, unkomplizierte Implementierung. Die optimierte Version oben kombiniert die beiden Vektoren zu einem einzelnen, etwas komplizierteren Vektor.

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

Ruby, 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}

Es war ein Wortspiel y Herausforderung. :-)

Ruby, 132 120 114 Bytes

Mir ist klar, dass diese Lösung noch viel Golf erfordert. Alle Golftipps sind willkommen.

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 Bytes

Irgendwelche Golftipps willkommen :)

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

Ungolfed:

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-Sprache (Mathematica) , 90 Bytes

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

Probieren Sie es online!

nicht golfen: der Code wird meistens von rechts nach links gelesen,

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