2013年には素因数分解があり3*11*61ます。2014年には素因数分解があり2*19*53ます。これらの因数分解に関する興味深い特性は、2013年と2014年の因数分解に異なる数の素数が存在し、それらの合計が同じ数になることです11+61=19+53=72。

2番目の数の選択された素因数の合計に等しい1つの数の選択された素因数の合計が存在する場合、1より大きい2つの正の整数を入力として受け取り、真理値を返すプログラムまたは関数を記述します。それ以外の場合はfalsey値。

明確化

• 3つ以上の素因数を使用できます。数のすべての素因数を合計で使用する必要はありません。2つの数から使用される素数の数が同じである必要はありません。
• 数の因数分解で素数が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、115 106バイト

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。等しくない場合、少なくとも1つの共通要素があります。

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

余分なバイトについては、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の作成者）のおかげで、メタ述語の検証が存在することを思い出させてくれました。

MATL、23バイト

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

このチャレンジよりも前の現在のリリース2.0.2を使用します。

番号は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@##&

説明：

これは匿名関数です。

最初に、IntersectingQ2つのリストが交差しているかどうかを確認します。ただし、入力はリストではなく数値であるため、未評価のままです。たとえば、入力が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]）、空でないサブセットのループ、合計、およびuniqを実行し、2つの数値の結果を交差させます。返される値は交差点の数であり、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

-5 ngnに感謝

匿名の暗黙の挿入機能。

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

オンラインでお試しください！

⍥{… } 次の匿名関数を両方の引数に適用します。

 ⍭ 素因数

 ⍤ それから

 ∪ それらのユニークなもの

 0+⍀., 各要因に連結されたゼロの追加テーブル削減

 ∊ ϵ nlist（平坦化）

∩ 交差点

⍤ それから

≢ それらの集計

1< 複数ありますか？（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

Japt、12バイト

®k â à mx
rø

オンラインで実行する

Python 3 3、206バイト

これはラムダ関数（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↓⍵} 

すべてのサブセットを見つける関数になります... {⍵operatoritsArguments}¨（各左）および¨（各右）は一定のサイクル数でループを模倣でき、¨¨は大丈夫だと言わなければなりません1つのセットのサブセットを表示するには...この方法で、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)

Japt -¡、14バイト

®k â ã mx
rf Ê

@Shaggyのおかげで3バイト節約

それを試してみてください

ゼリー、18 9バイト

ÆfŒPḊ§)f/

オンラインでお試しください！

-9の@Jonathan Allanに感謝します。

入力を2つの要素の配列として受け取ります。コードの説明：

      )    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Σ¦
↑@↑&ỵ!

オンラインでお試しください！

上の関数（最初の行）は素因数のべき集合の合計を計算し、2番目の関数は交点の要素のいずれかがゼロでないかどうかを調べます。