27

2013 में मुख्य कारक है 3*11*61। 2014 में प्रमुख कारक है 2*19*53। इन कारकों के संबंध में एक दिलचस्प संपत्ति यह है कि 2013 और 2014 के कारकों में अलग-अलग अपराध मौजूद हैं जो एक ही संख्या में हैं 11+61=19+53=72:।

एक प्रोग्राम या फ़ंक्शन लिखें जो इसके इनपुट के रूप में दो सकारात्मक पूर्णांक 1 से अधिक लेता है और एक सत्य मान देता है यदि एक नंबर के चयनित प्रमुख कारकों का योग है जो दूसरी संख्या में चयनित मुख्य कारकों के योग के बराबर है, और एक अन्यथा मूल्य।

स्पष्टीकरण

दो से अधिक प्रमुख कारकों का उपयोग किया जा सकता है। संख्या के सभी प्रमुख कारकों का योग में उपयोग करने की आवश्यकता नहीं है। यह आवश्यक नहीं है कि दो संख्याओं से उपयोग किए जाने वाले primes की संख्या समान हो।
यहां तक कि अगर किसी संख्या के गुणन में 1 से अधिक की शक्ति के लिए एक प्रमुख उठाया जाता है, तो इसका उपयोग केवल संख्या के लिए primes के योग में एक बार किया जा सकता है।
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

यह कोड गोल्फ है। मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

— आर्कटुरस
स्रोत

6

मुझे इस तरह की चुनौतियां पसंद हैं, लेकिन गोल्फ भाषाओं के लिए, यह बिल्ट-इन की एक श्रंखला होगी: फैक्टर, यूनिकिफाइ, सब्मिट, सम्स, ओवरलैप।

— xnor

क्या हम दो-आइटम सरणी के रूप में इनपुट ले सकते हैं?

— ETHproductions

@ETHproductions डिफ़ॉल्ट रूप से, हाँ।

— lirtosiast

14 (2 * 7) और 21 (3 * 7) के बारे में क्या, जैसा कि trueवे कारक साझा करते हैं 7?

— साइमन फोर्सबर्ग

@SimonForsbergMcFeely हाँ

— आर्कटुरस

10

जूलिया, 95 93 बाइट्स

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

प्राथमिक कार्य है fऔर यह एक सहायक कार्य कहता है g।

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 बाइट्स का धन्यवाद

— एलेक्स ए।
स्रोत

3

मैंने देखा कि यह खराब हो गया था। क्या कोई ऐसी चीज है जिसकी मैंने अनदेखी की है? अगर यह गलत है तो मुझे इसे ठीक करने में खुशी होगी, लेकिन जैसा कि यह खड़ा है यह मेरे लिए ठीक काम करता है और सभी परीक्षण मामलों को पारित करता है।

— एलेक्स ए।

मुझे लगता map(p->mapहै कि इससे छोटा है (m=map)(p->m।

— एलेफाल्फा

@DarthAlephalpha अच्छी कॉल, धन्यवाद।

— एलेक्स ए।

7

अजगर, 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.

— lirtosiast
स्रोत

1

यह अब एक स्थानांतरित पत्र के अपवाद के साथ अन्य पायथ उत्तर के समान है;)

— ETHproductions

@ETHproductions मैंने माल्टीसेन द्वारा तय किए जाने से पहले जवाब दिया; इसलिए मैं इसे रखूंगा।

— lirtosiast

7

पायथ - 17 12 11 बाइट्स

मेरे उत्तर को ठीक करने और एक बाइट को बचाने के लिए @FryAmTheEggman को धन्यवाद।

@FmsMty{PdQ

टेस्ट सूट ।

— Maltysen
स्रोत

मुझे लगता है कि tyकाम करता है और एक अलविदा बचाता है?

— फ्राईमईएग्गमैन

@FryAmTheEggman धन्यवाद!

— माल्टीसेन

17

@ मैल्टीसेन आप "ty" कहने का एक सुनहरा अवसर चूक गए

— भूमिगत

4

हास्केल, 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। यदि समान नहीं है, तो उनके पास कम से कम एक सामान्य तत्व है।

— nimi
स्रोत

3

जाप, 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

— ETHproductions
स्रोत

3

सीजेएम, 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.

— मार्टिन एंडर
स्रोत

3

ब्रेकीलॉग , 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 बाइट थैंक्स टू फेटाइज़ (ब्रेकीलॉग के निर्माता) ने मुझे याद दिलाते हुए कहा कि सत्यापित मेटा-विधेय मौजूद है।

— असंबंधित स्ट्रिंग
स्रोत

1

आप एक बाइट को बचाने के ᵛ - verifyबजाय उपयोग कर सकते हैं ˢ=।

— घातक

2

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

— लुइस मेंडो
स्रोत

2

मैथेमेटिका, 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]]सूचियां हैं, इसलिए हम इस बार एकत्रित परिणाम प्राप्त कर सकते हैं।

— alephalpha
स्रोत

IntersectingQपहले फोन करना अद्भुत है! :)

— मार्टिन एंडर

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— लिन

2

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

— चार्ल्स
स्रोत

2

APL (Dyalog Extended) , 23 17 बाइट्स ^SBCS

-5 ngn के लिए धन्यवाद

बेनामी tacit infix फ़ंक्शन।

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

इसे ऑनलाइन आज़माएं!

⍥{… } दोनों तर्कों के लिए निम्नलिखित अनाम फ़ंक्शन लागू करें:

⍭ प्रधान कारण

⍤ फिर

∪ उन लोगों के अद्वितीय

0+⍀., इसके अलावा प्रत्येक कारक के लिए शून्य की तालिका में कमी

∊ ϵ nlist (समतल)

∩ चौराहा

⍤ फिर

≢ उन लोगों की

1< क्या एक से अधिक है? (एक क्योंकि बिना कारकों के रकम)

— एडम
स्रोत

उचित से केवल सुविधाओं का उपयोग करना: p+.×⊤1↓⍳2*≢p←->1↓∊(⊢,+)/0,⍨

— ngn

इससे भी कम:1↓∊∘.+/0,¨

— nn

जो 1↓∊0∘.+.,एक इनवर्टर उत्पाद है - आप कितनी बार देखते हैं कि :)

— ngn

अगर मैं ⍥सही ढंग से 1<∘≢∩⍥{∊0∘.+.,∪⍭⍵}

— समझूं

@ धन्यवाद धन्यवाद। किया हुआ।

— आदम

2

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

— केविन क्रूज़सेन
स्रोत

1

f€æO`å¦à8 के लिए काम करना चाहिए

— Emigna

1

जाप, 12 बाइट्स

®k â à mx
rø

इसे ऑनलाइन चलाएं

— ओलिवर
स्रोत

1

पायथन 3 , 206 बाइट्स

यह एक लैम्ब्डा फ़ंक्शन (एम) है, जो 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))

इसे ऑनलाइन आज़माएं!

— senox13
स्रोत

यह पहले परीक्षण के मामले के लिए काम नहीं करता है 5,6, क्योंकि यह प्राइम इनपुट को हैंडल नहीं करता है

— जो किंग

@JoKing को पकड़ने के लिए धन्यवाद। उत्तर अपडेट कर दिया गया है।

— सेनॉक्स 13

1

एपीएल (एनएआरएस), 50 चार, 100 बाइट्स

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

यहाँ here इसके तर्क पर कारकों की सरणी का पता लगाएगा;

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

ऐसा फ़ंक्शन होगा जो सभी सबसेट ढूंढता है ... मुझे कहना होगा कि यह {Aoperator itsArguments} left (प्रत्येक बाएं के लिए) और ¨ (प्रत्येक दाएं के लिए) निश्चित संख्या में चक्रों के साथ लूप की नकल कर सकता है और ¨¨ ठीक है एक सेट के सबसेट को देखने के लिए ... देखने का यह तरीका लगता है कि छोरों का वर्णन करने में प्रतीकों को कम करें ...; परीक्षा

  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)

— RosLuP
स्रोत

1

जाप `-¡` , 14 बाइट्स

®k â ã mx
rf Ê

@ बस्ती के लिए 3 बाइट्स को सहेजा गया

कोशिश करो

— अज्ञान का अवतार
स्रोत

दूसरी पंक्ति ÎfUÌ lया, अभी भी छोटी हो सकती है rf l। røऐसा करने का सबसे छोटा तरीका होगा, लेकिन ओलिवर ने आपको हरा दिया।

— झबरा

1

जेली , 18 9 बाइट्स

ÆfŒPḊ§)f/

इसे ऑनलाइन आज़माएं!

@ जोनाथन एलन को -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

¹

— Ven
स्रोत

इनपुट को दो मानों की सूची के रूप में लें और इससे बचें ,। ẒƇबेमानी है, वहाँ कोई गैर प्राइम प्राइम कारक हैं। फिर ÆFḢ€ बस Æf, सिवाय इसके कि बाद वाला हमें दोहराव देता है जिसकी हमें वास्तव में आवश्यकता हो सकती है, उदाहरण के लिए 26=2*13और 125=5*5*5जबकि 2+13=5+5+5। हालांकि इसके साथ भी, Ẇयह काफी अच्छा नहीं है, उदाहरण के लिए 26उपयोग के बजाय 182=2*7*13जो यह भी पता होना चाहिए कि 2+13=5+5+5लेकिन नहीं है - इसके बजाय हम पावर-सेट ( ŒP) अग्रणी, खाली, तत्व (हम उपयोग कर सकते हैं Ḋ) के बिना चाहते हैं। S€यहाँ के साथ प्रतिस्थापित किया जा सकता है §। - आप शायद बाइट्स के साथ $और Ɗ- बचा सकते हैं ।

— जोनाथन एलन

उन तेज गेंदबाजों मैं अंत हम उपयोग कर सकते हैं पर उल्लेख के लिए कोई ज़रूरत नहीं )यह सही ढंग से काम (प्लस की जगह बनाने के लिए और मेरे सुधारों के साथ œ&साथ f:) कोड 9 बाइट्स ÆfŒPḊ§)f/ कोशिश यह

— जोनाथन एलन

स्पष्टीकरण के साथ अपडेट किया गया। फिर से धन्यवाद :)!

— Ven

1

मैंने आपके स्पष्टीकरण को थोड़ा अद्यतन किया।

— जोनाथन एलन

0

गैया , 16 11 बाइट्स

ḍzΣ¦
↑@↑&ỵ!

इसे ऑनलाइन आज़माएं!

शीर्ष फ़ंक्शन (पहली पंक्ति) मुख्य कारकों के अधिकार के योगों की गणना करता है, और दूसरा फ़ंक्शन पाता है कि चौराहे के तत्वों में से कोई भी गैर-शून्य है।

— ग्यूसेप
स्रोत

प्रमुख कारकों के योग

जूलिया, 95 93 बाइट्स

अजगर, 11 बाइट्स

पायथ - 17 12 11 बाइट्स

हास्केल, 115 106 बाइट्स

जाप, 25 बाइट्स

अपुष्ट और व्याख्या

सीजेएम, 23 बाइट्स

व्याख्या

ब्रेकीलॉग , 10 9 बाइट्स

MATL , 23 बाइट्स

उदाहरण

व्याख्या

मैथेमेटिका, 58 बाइट्स

स्पष्टीकरण:

PARI / GP , 98 बाइट्स

APL (Dyalog Extended) , 23 17 बाइट्स SBCS

05AB1E , 10 8 बाइट्स

जाप, 12 बाइट्स

पायथन 3 , 206 बाइट्स

एपीएल (एनएआरएस), 50 चार, 100 बाइट्स

जाप -¡ , 14 बाइट्स

जेली , 18 9 बाइट्स

गैया , 16 11 बाइट्स

APL (Dyalog Extended) , 23 17 बाइट्स ^SBCS

जाप `-¡` , 14 बाइट्स