2013에는 주요 인수 분해 기능이 3*11*61있습니다. 2014 년에는 주요 요인이 2*19*53있습니다. 이러한 인수 분해와 관련하여 흥미로운 특성은 2013과 2014의 인수 분해에서 동일한 수에 해당하는 뚜렷한 소수가 있다는 것 11+61=19+53=72입니다.

1보다 큰 두 개의 양의 정수를 입력으로 취하고 두 번째 숫자에서 선택한 소수 요인의 합과 같은 한 숫자의 선택된 소수 요인의 합이 존재하는 경우 참값을 리턴하는 프로그램 또는 함수를 작성하십시오. 그렇지 않으면 거짓 값.

설명

• 두 가지 이상의 주요 요소를 사용할 수 있습니다. 숫자의 모든 주요 요소를 합산 할 필요는 없습니다. 두 숫자에서 사용 된 소수의 숫자가 같을 필요는 없습니다.
• 소수의 인수 분해에서 소수가 1보다 큰 거듭 제곱으로 증가하더라도 소수의 소수에 한 번만 사용할 수 있습니다.
• 1은 소수가 아닙니다.
• 두 입력 숫자는 모두보다 작습니다 2^32-1.

테스트 사례

5,6
    5=5
    6=2*3
    5=2+3
==>True

2013,2014
    2013=3*11*61
    2014=2*19*53
    11+61=19+53
==>True

8,15
    8=2^3
    15=3*5
    No possible sum
==>False

21,25
    21=3*7
    25=5^2
    No possible sum (can't do 3+7=5+5 because of exponent)
==>False

이것은 코드 골프입니다. 표준 규칙이 적용됩니다. 바이트 단위의 최단 코드가 이깁니다.

줄리아, 95 93 바이트

g(x)=reduce(vcat,map(p->map(sum,p),partitions([keys(factor(x))...])))
f(a,b)=g(a)∩g(b)!=[]

기본 함수는 f도우미 함수 g입니다.

언 골프 드 :

function g(x::Integer)
    # Find the sum of each combination of prime factors of the input
    return reduce(vcat, map(p -> map(sum, p), partitions([keys(factor(x))...])))
end

function f(a::Integer, b::Integer)
    # Determine whether there's a nonzero intersection of the factor
    # sums of a and b
    return !isempty(g(a) ∩ g(b))
end

Darth Alephalpha 덕분에 2 바이트 절약

Pyth, 11 바이트

t@FmsMy{PdQ

형식으로 입력하십시오 30,7.

t@FmsMy{PdQ     implicit: Q=input tuple
      y         powerset of
       {        unique elements of
        Pd      prime factorizations of d
    sM          Map sum over each element of the powerset
    sMy{Pd      lambda d: all sums of unique prime factors of d
   m      Q     Map over Q. Produces a two-element list.
 @F             Fold list intersection
t               Remove first element, which is a 0.
                If no other common sums, the remaining empty list is falsy.

Pyth- 17 12 11 바이트

내 대답을 수정하고 바이트를 저장 한 @FryAmTheEggman에게 감사합니다.

@FmsMty{PdQ

테스트 스위트 .

하스켈, 115106 바이트

import Data.Numbers.Primes
import Data.List
p=map sum.tail.subsequences.nub.primeFactors
a#b=p a/=p a\\p b

사용 예 : 2013 # 2014-> True.

p인수의 모든 주요 요소 목록을 만들고, 중복 항목을 제거하고, 모든 하위 시퀀스의 목록을 만들고, 첫 번째 하위 항목 (항상 빈 목록 임)을 삭제하고 하위 시퀀스를 합칩니다. 차이와 같은지 #여부를 확인합니다 . 같지 않으면 하나 이상의 공통 요소가 있습니다.p ap a \\ p b

apt, 25 바이트

[UV]=N®k â à mx};Ud@J<VbX

출력 true또는 false. 온라인으로 사용해보십시오!

언 골프와 설명

[UV]=N®   k â à mx};Ud@ J<VbX
[UV]=NmZ{Zk â à mx};UdX{J<VbX

          // Implicit: N = list of inputs
[UV]=N    // Set variables U and V to the first to items in N,
mZ{    }  // with each item Z mapped to:
Zk        //  Generate list of Z's factors.
â         //  Keep only the unique items.
à         //  Generate all combinations.
mx        //  Sum each combination.
UdX{      // Check if any item X in U fulfills this condition:
J<VbX     //  -1 is less than V.indexOf(X).
          // Implicit: output last expression

여분의 바이트의 경우, 시간 입력이 다음과 같은 장점으로 인해 두 입력간에 factorize-Unique-Combine-sum 코드를 분할 할 수 있습니다 O(O(25-byte version)^2).

Uk â à mx d@J<Vk â à mx bX

CJam, 23 바이트

q~{mf_&0a\{1$f++}/}/&0-

여기에서 테스트하십시오.

진실 값은 모든 공통 합계가 연결되고 허위 값은 빈 문자열입니다.

설명

q~     e# Read and evaluate input.
{      e# For each of the two numbers...
  mf   e# Get the prime factors.
  _&   e# Remove duplicates.
  0a\  e# Put an array containing a 0 below to initialise the list of possible sums.
  {    e# For each prime factor...
    1$ e#   Make a copy of the available sums so far.
    f+ e#   Add the current factor to each of them.
    +  e#   Combine with the list of sums without that factor.
  }/
}/
&      e# Set intersection between the two lists of sums.
0-     e# Remove the 0 which is always in the intersection.

Brachylog , 10 9 바이트

{ḋd⊇+ℕ₁}ᵛ

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

술어는 [the sum, the sum]존재 하면 리턴에 성공 하고 합계가 없으면 실패합니다.

{            Start of inline predicate.
 ḋ           The prime factors of the input,
  d          with duplicates removed.
   ⊇         Some subset of the unique prime factors
    +ℕ₁      has a sum greater than 0 which is output.
       }ᵛ    The predicate can have the same output for both elements of the input.

Fatalize (Brachylog 제작자) 덕분에 -1 바이트 덕분에 meta-predicate 확인이 있음을 알려줍니다 .

MATL , 23 바이트

2:"iYfutn2w^1-:B!Y*]!=z

이 문제보다 빠른 현재 릴리스 2.0.2를 사용합니다 .

숫자는 두 개의 개별 입력으로 제공됩니다. 출력은 0또는 1입니다.

예

>> matl 2:"iYfutn2w^1-:B!Y*]!=z
> 2013
> 2014
1

설명

2:           % vector of two numbers, to generate two iterations
"            % for loop
  i          % input number                                                 
  Yfu        % get prime factors without repetitions
  tn         % duplicate and get number of elements in array N 
  2w^1-:     % numbers from 1 to 2^N                                        
  B!Y*       % convert to binary, transpose and matrix multiply to produce all sums
]            % end                                                      
!=z          % true if any value is equal to any other

수학, 58 바이트

Tr/@Rest@Subsets[#&@@@FactorInteger@#]&/@IntersectingQ@##&

설명:

이것은 익명의 기능입니다.

먼저 IntersectingQ두 목록이 교차하는지 확인합니다. 그러나 입력은 목록이 아닌 숫자이므로 평가되지 않은 상태로 남아 있습니다. 예를 들어 입력이 2013and 2014인 경우을 IntersectingQ@##&반환합니다 IntersectingQ[2013, 2014].

Tr/@Rest@Subsets[#&@@@FactorInteger@#]&정수를 사용하고 반복없이 주요 요소 목록을 가져오고, 전력 세트를 취한 다음, 빈 세트를 제거한 다음 각 세트의 합을 취하는 또 다른 익명 함수입니다. 따라서를 Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]반환합니다 {3, 11, 61, 14, 64, 72, 75}.

그런 다음 Tr/@Rest@Subsets[#&@@@FactorInteger@#]&표현식 위에 맵핑 하십시오 IntersectingQ[2013, 2014]. Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]그리고 Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2014]]우리가 수집 결과이 시간을 얻을 수 있도록, 목록입니다.

PARI / GP , 98 바이트

팩터를 잡고 소수 ( [,1])를 잡고 비어 있지 않은 서브 세트를 반복하고 합계 및 유니크를 제거한 다음 두 숫자의 결과를 교차시킵니다. 리턴 된 값은 교차점의 수이며, 0이 아닌 경우 진실입니다.

f(n,v=factor(n)[,1])=Set(vector(2^#v-1,i,vecsum(vecextract(v,i))))
g(m,n)=#setintersect(f(m),f(n))

APL (Dyalog Extended) , 23 17 바이트 ^SBCS

ngn 덕분에 -5

익명의 암묵적 삽입 기능.

1<≢⍤∩⍥(∊0+⍀.,∪⍤⍭)

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

⍥{… } 다음의 익명 함수를 두 인수 모두에 적용하십시오.

 ⍭ 주요 요인

 ⍤ 그때

 ∪ 그것들의 독특한 것들

 0+⍀., 각 요인에 연결된 0의 추가 테이블 감소

 ∊ ε NLIST (편평한)

∩ 교차점

⍤ 그때

≢ 그 탈리

1< 둘 이상 있습니까? (하나의 요인이 없기 때문에)

05AB1E , 10 8 바이트

f€æO`å¦à

@Emigna 덕분에 -2 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

f         # Get all distinct prime factors of both values in the (implicit) input-list
          #  i.e. [2013,2014] → [[3,11,61],[2,19,53]]
 ۾       # Get the powerset for each
          #  → [[[],[3],[11],[3,11],[61],[3,61],[11,61],[3,11,61]],
          #     [[],[2],[19],[2,19],[53],[2,53],[19,53],[2,19,53]]]
   O      # Sum each inner-most list
          #  → [[0,3,11,14,61,64,72,75],[0,2,19,21,53,55,72,74]]
    `     # Push both lists to the stack
     å    # Check for each value in the second list if it's present in the first list
          #  → [1,0,0,0,0,0,1,0]
      ¦   # Remove the first item (since the powerset included empty leading lists)
          #  → [0,0,0,0,0,1,0]
       à  # Check if any are truthy by taking the maximum (which is output implicitly)
          #  → 1

apt, 12 바이트

®k â à mx
rø

온라인으로 실행

파이썬 3 , 206 바이트

이것은 람다 함수 (m)이며, 2 개의 숫자를 취하고 공통된 소인수의 합을 포함하는 집합을 반환합니다. 파이썬에서 이것은 비어 있지 않을 때 진실한 값이고 비어있을 때 틀린 값입니다.

편집 : @ JoKing이 지적한 것처럼 원래 답변이 소수 입력에 대해 작동하지 않는 것으로 나타났습니다. 이것은 40 바이트의 비극적 인 비용으로 (다른 버그와 함께) 수정되었습니다.

q=__import__('itertools').permutations
def p(n):
 i,s=2,set()
 while~-n:
  if n%i:i+=1
  else:n//=i;s|={i}
 return s
s=lambda f:{sum(i)for l in range(1,len(f)+1)for i in q(f,l)}
m=lambda a,b:s(p(a))&s(p(b))

주석을 사용한 빠른 설명 :

#Alias for permutations function
q=__import__('itertools').permutations
#Returns set of prime factors of n, including n, if prime
def p(n):
 i,s=2,set()
 while~-n:
  if n%i:i+=1
  else:n//=i;s|={i}
 return s
#Returns all possible sums of 2 or more elements in the given set
s=lambda f:{sum(i)for l in range(1,len(f)+1)for i in q(f,l)}
#Returns any shared possible sums of prime factors of a and b (the intersection of the sets)
m=lambda a,b:s(p(a))&s(p(b))

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

APL (NARS), 50 자, 100 바이트

{⍬≢↑∩/+/¨¨{⍵∼⊂⍬}¨{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}¨∪¨π¨⍵}

여기에서 π는 인수에 대한 요인 배열을 찾습니다.

{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵} 

모든 하위 집합을 찾는 함수가 될 것입니다 ... 나는 {⍵operator itsArguments} ¨ (왼쪽)와 ¨ (오른쪽)는 고정 된 수의 사이클로 루프를 모방 할 수 있고 ¨ 한 세트의 부분 집합을보기 위해 ... 이런 방식으로 describe 루프에서 심볼을 줄이는 것 같습니다. 테스트

  h←{⍬≢↑∩/+/¨¨{⍵∼⊂⍬}¨{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}¨∪¨π¨⍵}
  h 5 6
1
  h 2013 2014
1
  h 8 15
0
  h 21 25
0

하나의 작은 분석 :

π¨⍵  for each arg apply factor 
∪¨ for each arg apply unique
{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}¨ for each arg apply subsets
{⍵∼⊂⍬}¨ for each argument subtract Zilde enclosed (that would be the void set)
+/¨¨ for each arg (for each arg apply +/)
⍬≢↑∩/ apply intersection, get the first argument and see if it is Zilde (this it is right because enclosed Zilde it seems is the void set)

apt -¡ , 14 바이트

®k â ã mx
rf Ê

@Shaggy 덕분에 3 바이트 절약

시도 해봐

젤리 , 18 9 바이트

ÆfŒPḊ§)f/

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

@Jonathan Allan에게 -9와 놀라운 도움을 주셔서 감사합니다 :).

두 요소의 배열로 입력을받습니다. 코드 설명 :

      )    Call Chain 1 for each integer in the input array

ÆfŒPḊ§     Chain 1:
Æf           Compute a list of the prime factors of the integer
  ŒP         Powerset of P, with duplicates and an empty element
    Ḋ        Drop said empty element
     §       Vectorized sum: sum every combination

       f/  Chain 2:
        /    Reduce (the resulting list of two lists of possible sums) by...
       f     ...removing elements to the left that are not in the right

¹

가이아 , 16 11 바이트

ḍzΣ¦
↑@↑&ỵ!

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

상단 함수 (첫 번째 줄)는 소인수의 거듭 제곱의 합을 계산하고 두 번째 함수는 교차 요소 중 하나가 0이 아닌지를 찾습니다.