_{이 Numberphile 항목에서 영감을 얻었습니다}

배경

정수 n 의 큐브 거리 수 는 여기 에서 주어진 x에 대해 x³ 거리 떨어져있는 정수 세트로 정의됩니다 . 간단한 예를 들어,로 와 의 큐브 거리 숫자 입니다 .n=100x=2{92,108}

이것은 단순히 x 를 변경하여 더 큰 세트로 확장 할 수 있습니다 . 와 x ∈ {1,2,3,4}동일하게 n=100, 결과 집합이 {36,73,92,99,101,108,127,164}있습니다.

하자의 정의 CD (N, X)를 모든 정수의 집합으로 n ± z³와 z ∈ {1,2,3,...,x}.

이제 우리는 이러한 큐브 거리 수 의 특별한 특성에 중점을 둘 수 있습니다. 숫자가 가질 수있는 많은 특수 속성 중에서, 우리가 관심을 갖는 두 가지 속성은 소수 와 소수 입니다.

위의 예를 들어 CD (100,4) , 주 73, 101, 127모든 주요이다. 우리가 세트에서 그것들을 제거하면 우리는로 남습니다 {36,92,99,108,164}. 이 수의 모든 소수는 (순서대로) {2,2,3,3,2,2,23,3,3,11,2,2,3,3,3,2,2,41}, 5 개의 고유 소수를 갖습니다 {2,3,23,11,41}. 따라서 우리는 것을 정의 할 수 있습니다 CD (100,4)이 있다 ravenity ¹ 의를 5.

여기서 과제 는 주어진 입력 의 까다로운 결과를 출력하는 함수 또는 프로그램을 가장 적은 바이트로 작성하는 것 입니다.

입력

• 편리한 형식의 두 양의 정수 n및 x.

산출

• CD (n, x)로 계산할 때 두 입력 숫자 의 정확성 을 설명하는 단일 정수 입니다.

규칙

• 입 / 출력은 적절한 방법을 통해 가능합니다 .
• 표준 허점 제한이 적용됩니다.
• 계산이 쉽도록 입력 데이터가 CD (n, x) 에 세트의 양수 만있는 것으로 가정 할 수 있습니다 (즉, CD (n, x) 에는 음수 또는 0이 없음).
• 함수 또는 프로그램은 n + x³언어의 고유 정수 데이터 유형에 맞게 입력 번호를 처리 할 수 ​​있어야 합니다. 예를 들어, 32 비트 부호있는 정수 유형의 경우 모든 입력 번호 n + x³ < 2147483648가 가능합니다.

예

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

각주

1-우리는 세트 의 기본 특성에 관심이 없지만 다른 유형의 새에 관심이 있기 때문에 명명되었습니다 . 우리는 "공통"제수를 다루기 때문에 공통 까마귀 를 사용하기로 결정했습니다 .

젤리, 16 바이트

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

취하고 X 와 N 의 순서로, 명령 라인 인수있다. 온라인으로 사용해보십시오!

작동 원리

Œ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 바이트

트릭이 있는지 궁금합니다.

l{st#mP+Q^d3s_BMSE

테스트 스위트 .

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

줄리아, 107 바이트

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

이것은 두 정수를 허용하고 정수를 반환하는 함수입니다.

언 골프 드 :

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 바이트

암호:

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

형태로 입력 x, n. CP-1252 인코딩을 사용합니다 .

온라인으로 사용해보십시오!

MATL , 21 바이트

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

입력되고 x, 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 바이트

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

이 동사는 다음과 같이 사용됩니다.

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

여기에서 시도하십시오.

설명

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

( 20 바이트를 절약 한 @Blue 덕분에)

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

한 줄로 된 멋진 람다 함수이지만 조금 길 수 있습니다. 파이썬을 사용하고 있었기 때문에 첫 번째 단계에서 복합 재료를 찾는 마지막 방법과 마지막 단계에서 주요 제수를 찾아야했기 때문에 쉽지 않았습니다. . 그것을 얻을 수 있었다. 그럼에도 불구하고, 그것은 필요한 것을 수행하며, 나는 그것을 자랑스럽게 생각합니다. :) 그러나, 이것을 조금 더 아래로 골프에 대한 팁은 환영합니다.

PARI / GP , 79 바이트

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

다음은 원래의 간단한 구현입니다. 위의 최적화 된 버전은 두 벡터를 하나의 약간 더 복잡한 벡터로 결합합니다.

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

루비, 138 바이트

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

그것은이었다 말장난의 Y 도전. :-)

루비, 132 (120) 114 바이트

이 솔루션에는 여전히 많은 골프가 필요하다는 것을 잘 알고 있습니다. 모든 골프 팁을 환영합니다.

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}

풀기 :

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

파이썬 3.5- (177) 175 (159) 바이트

모든 골프 팁 : :)

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

언 골프 드 :

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 바이트

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

온라인으로 사용해보십시오!

ungolfed : 코드는 대부분 오른쪽에서 왼쪽으로 읽습니다.

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