_{Terinspirasi oleh entri Numberphile ini}

Latar Belakang

Angka jarak kubus bilangan bulat n didefinisikan di sini sebagai himpunan bilangan bulat yang berjarak x³ untuk x yang diberikan . Untuk contoh sederhana, dengan n=100dan x=2, angka jarak kubus adalah {92,108}.

Ini dapat diperluas ke set yang lebih besar hanya dengan memvariasikan x . Dengan x ∈ {1,2,3,4}dan yang sama n=100, kita memiliki set yang dihasilkan {36,73,92,99,101,108,127,164}.

Mari kita mendefinisikan CD (n, x) sebagai himpunan semua bilangan bulat n ± z³dengan z ∈ {1,2,3,...,x}.

Sekarang kita dapat fokus pada beberapa sifat khusus dari angka jarak kubus ini . Dari sekian banyak properti khusus yang bisa dimiliki oleh angka, dua properti yang kami minati di sini adalah pembagi-pembagi primality dan prime .

Untuk CD contoh di atas (100,4) , perhatikan bahwa 73, 101, 127semuanya prima. Jika kita menghapusnya dari set, kita pergi dengan {36,92,99,108,164}. Semua pembagi utama dari angka-angka ini adalah (dalam urutan) {2,2,3,3,2,2,23,3,3,11,2,2,3,3,3,2,2,41}, yang berarti kita memiliki 5 pembagi utama yang berbeda {2,3,23,11,41}. Oleh karena itu kita dapat mendefinisikan bahwa CD (100,4) memiliki ravenity ¹ of 5.

Tantangannya di sini adalah untuk menulis fungsi atau program, dalam byte paling sedikit, yang menghasilkan kerakusan dari input yang diberikan.

Memasukkan

• Dua bilangan bulat positif, ndan x, dalam format apa pun yang nyaman.

Keluaran

• Sebuah bilangan bulat tunggal yang menggambarkan kerakusan dari dua angka input, bila dihitung dengan CD (n, x) .

Aturan

• Input / output dapat melalui metode yang sesuai .
• Batasan celah standar berlaku.
• Untuk memudahkan perhitungan, Anda dapat mengasumsikan bahwa data input akan sedemikian rupa sehingga CD (n, x) hanya akan memiliki angka positif di set (yaitu, tidak ada CD (n, x) yang akan memiliki angka negatif atau nol).
• Fungsi atau program harus dapat menangani nomor input sehingga n + x³sesuai dengan tipe data integer asli bahasa Anda. Misalnya, untuk tipe integer bertanda 32-bit, semua angka input dengan n + x³ < 2147483648dimungkinkan.

Contohnya

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

Catatan kaki

1 - Dinamakan demikian karena kita tidak tertarik pada kardinal set, tetapi jenis burung yang berbeda. Karena kita sedang berurusan dengan pembagi "umum", saya memilih untuk menggunakan gagak umum .

Jelly, 16 byte

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

Membutuhkan x dan n sebagai argumen baris perintah, dalam urutan itu. Cobalah online!

Bagaimana itu bekerja

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

Saya ingin tahu apakah ada trik.

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 byte

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

Ini adalah fungsi yang menerima dua bilangan bulat dan mengembalikan bilangan bulat.

Tidak Disatukan:

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 byte

Kode:

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

Masukan dalam bentuk x, n. Penggunaan pengodean CP-1252 .

Cobalah online!

MATL , 21 byte

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

Input x, ndipisahkan oleh baris baru.

Cobalah online!

Penjelasan

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

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

Ini adalah kata kerja diad, yang digunakan sebagai berikut:

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

Coba di sini.

Penjelasan

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

( Terima kasih kepada @Blue karena telah menyelamatkan saya 20 byte.)

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

Fungsi lambda satu-baris yang bagus, meskipun mungkin agak panjang. Karena saya menggunakan Python, saya harus menemukan cara saya sendiri untuk menemukan komposit untuk langkah pertama, dan kemudian pembagi utama untuk langkah terakhir, jadi itu tidak terlalu mudah, dan ini adalah saya yang terpendek, sendiri . bisa mendapatkannya. Meskipun demikian, ia melakukan apa yang diperlukan, dan saya bangga karenanya. :) Namun, ada tips untuk bermain golf ini sedikit lebih baik.

PARI / GP , 79 byte

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

Ini adalah implementasi langsung saya yang asli. Versi yang dioptimalkan di atas menggabungkan dua vektor menjadi satu, vektor yang sedikit lebih rumit.

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

Ruby, 138 byte

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

Itu adalah pelesetan y tantangan. :-)

Ruby, 132 120 114 byte

Saya sadar betul bahwa solusi ini masih membutuhkan banyak golf. Semua kiat bermain golf dipersilakan.

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}

Tidak melakukan pelanggaran:

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

Selamat datang tips golf :)

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

Tidak Disatukan:

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)

Bahasa Wolfram (Mathematica) , 90 byte

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

Cobalah online!

un-golfed: kebanyakan kode dibaca dari kanan ke kiri,

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