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

测试套件。

Haskell，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 a不等于差额p a \\ p b。如果不相等，则它们至少具有一个公共元素。

Japt，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

对于一个额外的字节，您可以在两个输入之间拆分因式分解唯一组合和代码，其额外的优势是时间复杂度为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.

-1个字节感谢Fatalize（Brachylog的创建者）提醒我验证元谓词存在。

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

Mathematica，58个字节

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

说明：

这是一个匿名函数。

首先，IntersectingQ检查两个列表是否相交。但是输入是数字而不是列表，因此它没有被评估。例如，如果输入是2013和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]），遍历非空子集，求和和uniq，然后将其结果与两个数字相交。返回值是交叉点数，除非它们为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扩展），23 17 字节^SBCS

-5感谢ngn

匿名默认隐式函数。

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

在线尝试！

⍥{… } 对两个参数都应用以下匿名函数：

 ⍭ 主要原因

 ⍤ 然后

 ∪ 这些独特的

 0+⍀., 加法表归零到每个因子

 ∊ ε NLIST（扁平化）

∩ 十字路口

⍤ 然后

≢ 那些合计

1< 有不止一个吗？（一个因为没有因素的总和）

05AB1E，10 8 字节

f€æO`å¦à

-2个字节，感谢@Emigna。

在线尝试或验证所有测试用例。

说明：

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

Japt，12个字节

®k â à mx
rø

在线运行

Python 3，206字节

这是一个lambda函数（m），它接受2个数字并返回一个集合，其中包含它们共同拥有的任何素数和。在Python中，非空值是真实值，空值是假值。

编辑：原来我的原始答案不适用于主要输入，如@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↓⍵} 

将是找到所有子集的函数...我不得不说，{seemsoperator itsArguments}（对于每个左）和¨（对于每个右）似乎可以模仿具有固定循环数的循环，并且¨看到一组子集...这种方式似乎可以减少描述循环中的符号...; 测试

  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)

Japt -¡，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Σ¦
↑@↑&ỵ!

在线尝试！

顶部函数（第一行）计算素因子幂集的总和，第二个函数查找相交的元素是否为非零。