_{Lấy cảm hứng từ mục Numberphile này}

Lý lịch

Các số khoảng cách khối của một số nguyên n được xác định ở đây là tập hợp các số nguyên cách xa x³ cho một x đã cho . Đối với một ví dụ đơn giản, với n=100và x=2, các số khoảng cách khối là {92,108}.

Điều này có thể được mở rộng thành một tập lớn hơn chỉ bằng cách thay đổi x . Với x ∈ {1,2,3,4}và giống nhau n=100, chúng ta có tập kết quả {36,73,92,99,101,108,127,164}.

Hãy xác định CD (n, x) là tập hợp của tất cả các số nguyên n ± z³với z ∈ {1,2,3,...,x}.

Bây giờ chúng ta có thể tập trung vào một số tính chất đặc biệt của các số khoảng cách khối này . Trong số nhiều thuộc tính đặc biệt mà số có thể có, hai thuộc tính chúng ta quan tâm ở đây là số nguyên tố và ước số nguyên tố .

Đối với CD ví dụ trên (100,4) , lưu ý rằng 73, 101, 127tất cả đều là số nguyên tố. Nếu chúng tôi xóa chúng khỏi tập hợp, chúng tôi sẽ rời đi {36,92,99,108,164}. Tất cả các ước số nguyên tố của các số này là (theo thứ tự) {2,2,3,3,2,2,23,3,3,11,2,2,3,3,3,2,2,41}, có nghĩa là chúng ta có 5 ước số nguyên tố riêng biệt {2,3,23,11,41}. Do đó chúng tôi có thể xác định rằng CD (100,4) có ravenity ¹ của 5.

Thách thức ở đây là viết một hàm hoặc chương trình, trong một vài byte, sẽ tạo ra độ quậy của một đầu vào đã cho.

Đầu vào

• Hai số nguyên dương, nvà x, trong bất kỳ định dạng thuận tiện.

Đầu ra

• Một số nguyên duy nhất mô tả độ quạ của hai số đầu vào, khi được tính bằng CD (n, x) .

Quy tắc

• Đầu vào / đầu ra có thể thông qua bất kỳ phương pháp phù hợp .
• Hạn chế kẽ hở tiêu chuẩn áp dụng.
• Để dễ tính toán, bạn có thể giả sử rằng dữ liệu đầu vào sẽ sao cho CD (n, x) sẽ chỉ có số dương trong tập hợp (nghĩa là không có CD (n, x) nào có số âm hoặc bằng 0).
• Hàm hoặc chương trình sẽ có thể xử lý các số đầu vào sao cho n + x³phù hợp với kiểu dữ liệu nguyên gốc của ngôn ngữ của bạn. Ví dụ, đối với loại số nguyên có chữ ký 32 bit, tất cả các số đầu vào n + x³ < 2147483648đều có thể.

Ví dụ

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

Chú thích

1 - Vì vậy, đặt tên bởi vì chúng ta không quan tâm đến các hồng y ity của bộ này, nhưng một loại khác nhau của con chim. Vì chúng ta đang làm việc với các ước số "chung", tôi đã chọn sử dụng con quạ thông thường .

Thạch, 16 byte

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

Lấy x và n làm đối số dòng lệnh, theo thứ tự đó. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Œ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

Tôi tự hỏi nếu có một mẹo.

l{st#mP+Q^d3s_BMSE

Phòng thử nghiệm .

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

Đây là hàm chấp nhận hai số nguyên và trả về một số nguyên.

Ung dung:

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

Mã số:

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

Đầu vào trong mẫu x, n. Sử dụng mã hóa CP-1252 .

Hãy thử trực tuyến!

MATL , 21 byte

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

Đầu vào là x, ncách nhau bởi một dòng mới.

Hãy thử trực tuyến!

Giải trình

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

Đây là một động từ dyadic, được sử dụng như sau:

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

Hãy thử nó ở đây.

Giải trình

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

( Cảm ơn @Blue đã tiết kiệm cho tôi 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))})

Một chức năng lambda một hàng đẹp, mặc dù nó có thể hơi dài. Vì tôi đang sử dụng Python, tôi đã phải tự mình tìm ra các vật liệu tổng hợp cho bước đầu tiên, và sau đó là ước số chính cho bước cuối cùng, vì vậy nó không dễ dàng gì, và đây là bản thân tôi ngắn nhất . có thể có được nó để. Tuy nhiên, nó làm những gì nó cần, và tôi tự hào về nó. :) Tuy nhiên, bất kỳ lời khuyên cho việc chơi golf này xuống một chút nữa đều được chào đón.

PARI / GP , 79 byte

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

Đây là thực hiện đơn giản ban đầu của tôi. Phiên bản tối ưu hóa ở trên kết hợp hai vectơ thành một vectơ đơn, phức tạp hơn một chút.

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

Đó là một thử thách chơi chữ . :-)

Ruby, 132 120 114 byte

Tôi nhận thức rõ rằng giải pháp này vẫn cần rất nhiều chơi golf. Bất kỳ lời khuyên chơi golf đều được chào đón.

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 byte

Mọi lời khuyên chơi golf đều được chào đón :)

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

Ung dung:

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)

Ngôn ngữ Wolfram (Mathicala) , 90 byte

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

Hãy thử trực tuyến!

un-golfed: mã được đọc chủ yếu từ phải sang trái,

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