2013 3*11*61มีตัวประกอบที่สำคัญ 2014 2*19*53มีตัวประกอบที่สำคัญ คุณสมบัติที่น่าสนใจเกี่ยวกับ factorizations เหล่านี้ก็คือว่ามีอยู่ช่วงเวลาที่แตกต่างกันใน factorizations ของปี 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

นี่คือรหัสกอล์ฟ ใช้กฎมาตรฐาน รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

Julia, 95 93 ไบต์

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

ฟังก์ชั่นหลักและสายงานผู้ช่วยfg

Ungolfed:

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

บันทึก 2 ไบต์ต้องขอบคุณ Darth Alephalpha

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

Test Suite

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 # 2014True

pทำให้รายการของปัจจัยสำคัญทั้งหมดของมันโต้แย้งลบรายการที่ซ้ำกันทำรายการของทุกองค์ประกอบลดลงหนึ่งคนแรก (ซึ่งมักจะเป็นรายการที่ว่างเปล่า) และในที่สุดก็สรุปผลประกอบการ #การตรวจสอบว่าไม่เท่ากับความแตกต่างp a p a \\ p bหากไม่เท่ากันพวกเขามีองค์ประกอบทั่วไปอย่างน้อยหนึ่งองค์ประกอบ

Japt 25 ไบต์

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

ขาออกหรือtrue ลองออนไลน์!false

Ungolfed และคำอธิบาย

[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-combination-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.

-1 ขอบคุณไบต์ Fatalize (ผู้สร้างของ Brachylog) ที่เตือนผมว่าตรวจสอบ meta-กริยาที่มีอยู่

MATL , 23 ไบต์

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

ใช้รีลีสปัจจุบัน2.0.2ซึ่งเร็วกว่าความท้าทายนี้

ตัวเลขถูกระบุเป็นอินพุตแยกกันสองตัว เอาท์พุทเป็นหรือ01

ตัวอย่าง

>> 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ตรวจสอบว่ามีสองรายการที่ตัดกันหรือไม่ แต่อินพุตเป็นตัวเลขแทนที่จะเป็นรายการดังนั้นจึงไม่มีการประเมินค่า ตัวอย่างเช่นถ้า input 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]คูณgrab primes ( ) วนรอบเซ็ตย่อย nonempty sum และ 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 Extended) , 23 17 ไบต์^SBCS

-5 ขอบคุณ ngn

ฟังก์ชั่นเงียบสงบไม่ระบุชื่อ

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

ลองออนไลน์!

⍥{... } ใช้ฟังก์ชันที่ไม่ระบุชื่อต่อไปนี้กับทั้งสองข้อโต้แย้ง:

 ⍭ ปัจจัยสำคัญ

 ⍤ แล้วก็

 ∪ สิ่งที่ไม่เหมือนใครของสิ่งเหล่านั้น

 0+⍀., การลดตารางเพิ่มเติมของการรวมศูนย์ให้เข้ากับแต่ละปัจจัย

 ∊ ϵ รายการ (แผ่)

∩ ทางแยก

⍤ แล้วก็

≢ นับของเหล่านั้น

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 ไบต์

นี่คือฟังก์ชั่นแลมบ์ดา (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↓⍵}¨∪¨π¨⍵}

ที่นี่ find จะพบกับปัจจัยหลายประการเกี่ยวกับการโต้แย้ง

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

จะเป็นฟังก์ชันที่ค้นหาชุดย่อยทั้งหมด ... ฉันต้องบอกว่ามันดูเหมือน {{operator 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 Ê

บันทึก 3 ไบต์ด้วย @Shaggy

ลองมัน

เยลลี่ , 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

¹

Gaiaขนาด16 11 ไบต์

ḍzΣ¦
↑@↑&ỵ!

ลองออนไลน์!

ฟังก์ชั่นด้านบน (บรรทัดแรก) คำนวณผลรวมของมหาอำนาจของปัจจัยสำคัญและฟังก์ชั่นที่สองค้นหาว่าองค์ประกอบใด ๆ ของการแยกเป็นศูนย์