Năm 2013 có yếu tố chính 3*11*61. Năm 2014 có yếu tố chính 2*19*53. Một tính chất thú vị liên quan đến các yếu tố này là tồn tại các số nguyên tố khác nhau trong các yếu tố của năm 2013 và 2014 có cùng số : 11+61=19+53=72.

Viết chương trình hoặc hàm lấy hai số nguyên dương đầu vào lớn hơn 1 và trả về giá trị trung thực nếu tồn tại tổng các thừa số nguyên tố được chọn của một số bằng tổng các thừa số nguyên tố được chọn trong số thứ hai và giá trị falsey khác.

Làm rõ

• Nhiều hơn hai yếu tố chính có thể được sử dụng. Không phải tất cả các thừa số nguyên tố của số cần được sử dụng trong tổng. Không cần thiết cho số lượng các số nguyên tố được sử dụng từ hai số bằng nhau.
• Ngay cả khi một số nguyên tố được nâng lên một số lũy thừa lớn hơn 1 trong hệ số của một số, nó chỉ có thể được sử dụng một lần trong tổng số các số nguyên tố cho số đó.
• 1 không phải là số nguyên tố.
• Cả hai số đầu vào sẽ ít hơn 2^32-1.

Các trường hợp thử nghiệm

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

Đây là mã golf. Quy tắc tiêu chuẩn áp dụng. Mã ngắn nhất trong byte thắng.

Julia, 95 93 byte

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

Hàm chính là fvà nó gọi hàm helper g.

Ung dung:

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

Đã lưu 2 byte nhờ Darth Alephalpha

Bình thường, 11 byte

t@FmsMy{PdQ

Đầu vào theo mẫu 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 byte

Cảm ơn @FryAmTheEggman đã sửa câu trả lời của tôi và lưu một byte.

@FmsMty{PdQ

Phòng thử nghiệm .

Haskell, 115 106 byte

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

Ví dụ sử dụng: 2013 # 2014-> True.

plập danh sách tất cả các yếu tố chính của đối số, loại bỏ các mục trùng lặp, tạo danh sách tất cả các chuỗi con, bỏ cái đầu tiên (luôn luôn là danh sách trống) và cuối cùng tính tổng các chuỗi. #kiểm tra xem p akhông phải là tương đương với phần chênh lệch p a \\ p b. Nếu không bằng nhau, chúng có ít nhất một yếu tố chung.

Japt, 25 byte

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

Đầu ra truehay false. Hãy thử trực tuyến!

Ung dung và giải thích

[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

Đối với một byte bổ sung, bạn có thể phân tách mã tổng hợp nhân tố duy nhất giữa hai đầu vào, với lợi thế bổ sung là có độ phức tạp về thời gian là O(O(25-byte version)^2):

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

CJam, 23 byte

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

Kiểm tra nó ở đây.

Giá trị trung thực sẽ là tất cả các khoản tiền chung được nối, giá trị giả là chuỗi rỗng.

Giải trình

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 byte

{ḋd⊇+ℕ₁}ᵛ

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

Vị ngữ thành công trở lại [the sum, the sum]nếu nó tồn tại và thất bại nếu tổng không tồn tại.

{            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 byte nhờ Fatalize (người tạo ra Brachylog) nhắc nhở tôi rằng vị từ meta xác minh tồn tại.

MATL , 23 byte

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

Sử dụng bản phát hành hiện tại, 2.0.2 , sớm hơn thử thách này.

Các số được cung cấp như hai đầu vào riêng biệt. Đầu ra là 0hoặc 1.

Thí dụ

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

Giải trình

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

Toán học, 58 byte

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

Giải trình:

Đây là một chức năng ẩn danh.

Đầu tiên, IntersectingQkiểm tra nếu hai danh sách đang giao nhau. Nhưng đầu vào là số thay vì danh sách, vì vậy nó vẫn không được đánh giá. Ví dụ, nếu đầu vào là 2013và 2014sau đó IntersectingQ@##&trả về IntersectingQ[2013, 2014].

Tr/@Rest@Subsets[#&@@@FactorInteger@#]&là một hàm ẩn danh khác lấy một số nguyên, lấy danh sách các thừa số nguyên tố của nó mà không lặp lại, lấy tập hợp sức mạnh, loại bỏ tập hợp trống và sau đó lấy tổng của mỗi tập hợp. Vì vậy, Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]trở về {3, 11, 61, 14, 64, 72, 75}.

Sau đó ánh xạ Tr/@Rest@Subsets[#&@@@FactorInteger@#]&qua biểu thức IntersectingQ[2013, 2014]. Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]và Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2014]]là danh sách, vì vậy chúng ta có thể nhận được kết quả thu thập lần này.

PARI / GP , 98 byte

Hệ số, lấy các số nguyên tố ( [,1]), lặp trên các tập con không trống, tổng và uniq, sau đó cắt kết quả của điều này cho hai số. Giá trị trả về là số giao điểm, là giá trị trung thực trừ khi chúng bằng 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 byte ^SBCS

-5 cảm ơn ngn

Chức năng ẩn danh ẩn danh.

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

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

⍥{... } áp dụng các chức năng ẩn danh sau đây để cả hai đối số:

 ⍭ thừa số nguyên tố

 ⍤ sau đó

 ∪ những cái độc đáo của những cái đó

 0+⍀., bảng bổ sung giảm 0 không nối với từng yếu tố

 ∊ ε nlist (flatten)

∩ ngã tư

⍤ sau đó

≢ kiểm đếm của những người đó

1< có nhiều hơn một không? (một vì tổng không có yếu tố)

05AB1E , 10 8 byte

f€æO`å¦à

-2 byte nhờ @Emigna .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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 byte

®k â à mx
rø

Chạy nó trực tuyến

Python 3 , 206 byte

Đây là hàm lambda (m), có 2 số và trả về một tập hợp chứa bất kỳ tổng các thừa số nguyên tố nào mà chúng có chung. Trong Python đây là một giá trị trung thực khi không rỗng và giá trị falsey khi trống.

Chỉnh sửa: Hóa ra câu trả lời ban đầu của tôi không hoạt động đối với các đầu vào chính, như được chỉ ra bởi @JoKing. Điều này đã được sửa (cùng với một số lỗi khác) với chi phí bi thảm là 40 byte.

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

Giải thích nhanh bằng các bình luận:

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

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

APL (NARS), 50 char, 100 byte

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

Ở đây, π sẽ tìm thấy các mảng của các yếu tố trên đối số của nó;

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

sẽ là hàm tìm tất cả các tập con ... tôi phải nói rằng có vẻ như {⍵operator ItsArgument} ¨ (cho mỗi bên trái) và ¨ (cho mỗi bên phải) có thể bắt chước vòng lặp với số chu kỳ cố định và vẫn ổn để xem các tập hợp con của một tập hợp ... cách nhìn này dường như làm giảm các ký hiệu trong các vòng lặp mô tả ...; kiểm tra

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

Một phân tích nhỏ:

π¨⍵  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 byte

®k â ã mx
rf Ê

Đã lưu 3 byte nhờ @Shaggy

Thử nó

Thạch , 18 9 byte

ÆfŒPḊ§)f/

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

Cảm ơn @Jonathan Allan cho -9 và sự giúp đỡ tuyệt vời :).

Đưa đầu vào là một mảng gồm hai phần tử. Mã giải thích:

      )    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

¹

Gaia , 16 11 byte

ḍzΣ¦
↑@↑&ỵ!

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

Hàm trên cùng (dòng đầu tiên) tính tổng các lũy thừa của các thừa số nguyên tố và hàm thứ hai tìm thấy nếu bất kỳ phần tử nào của giao điểm là khác không.