अभाज्य-शक्ति कारक से भाजक योग

Question

कार्य एक संख्या के विभाजक योग की गणना करना है जिसे इसका मुख्य कारक दिया गया है।

इनपुट

लंबाई n के दो सरणियाँ (या कुछ समतुल्य) , एक जिसमें प्रमुख कारक है और दूसरा जिसमें समान प्रतिपादक है।

उत्पादन

सभी भाजक का योग (संख्या सहित)।

उदाहरण

संख्या 240 में 2, 3, और 5 प्रमुख कारक के रूप में 4, 1, और 1 संबंधित प्रतिपादक के रूप में हैं। तब अपेक्षित आउटपुट 744 होगा।

Input: [2,3,5] [4,1,1]
Output: 744

स्कोरिंग

बाइट्स जीत में सबसे छोटा कोड!

यदि आपके समाधान की रन टाइम जटिलता O (घातांक की राशि) है, तो O (घातांक का उत्पाद) के बजाय, आपका स्कोर 0.8 से गुणा किया जा सकता है।

---

यहां एक समान प्रश्न पोस्ट किया गया था, लेकिन यह एक चुनौती नहीं थी। मुझे लगता है कि समस्या दिलचस्प है गोल्फ होने के लिए पर्याप्त है।

विजेता इस सप्ताह के अंत में चुना जाएगा

Comments

क्या प्राइम फैक्टर एरे को हमेशा पहला और एक्सपोनेंट एरे को दूसरा होना चाहिए या हम मान सकते हैं कि एरे को दूसरे तरीके से इनपुट किया गया है?

— Sp3000

आप प्रस्तावित इनपुट

— मोर्टेम

यह अभी नहीं मिल सकता है, लेकिन मुझे लगता है कि यह या ऐसा ही कुछ projecteuler.net पर है

— दोष

Answer 1

पायथ, 13 बाइट्स * 0.8 = 10.4

*Fms^LhdhedCQ

प्रदर्शन।

यह उत्तर ऊपर के लोगों से कुछ अलग तरीके से काम करता है। संख्या की प्रमुख शक्तियों के कारकों की राशि की गणना करने के लिए, अंकगणितीय सूत्र का उपयोग करने के बजाय, कारकों का निर्माण और सारांशित किया जाता है।

उदाहरण के लिए, [अभाज्य, प्रतिपादक] जोड़ी पर [2, 4], हम नक्शा देते 2 ^ xहैं 0, 1, 2, 3, 4, दे रहे हैं [1, 2, 4, 8, 16], जिसे बाद में 31 तक समेट दिया जाता है।

परिणाम फिर एक साथ गुणा और मुद्रित होते हैं।

यदि घातांक को ठीक से लागू किया जाता है, या यदि मध्यवर्ती परिणाम कैशिंग है, तो यह होगा O(sum of exponents)।

Comments

कार्यान्वयन की स्वतंत्र रूप से, मैं यह पहली गणना करने के लिए संभव है नहीं लगता कि एन की शक्ति एक हे (एन) के समय में, जब तक आप को लगता है कि गुणा हे (1) है।

— डेनिस

@ डेनिस, उच्च क्रम की शर्तें हावी हैं, इसलिए संभवत: यह उच्चतम क्रम गुणा का क्रम है, जो कि O(n)अगर हम मान सकते हैं कि आधार एक स्थिर है।

— ईसैक

Answer 2

सीजाम, 15 बाइट्स * 0.8 = 12

q~.{_@)#(\(/}:*

इसे ऑनलाइन आज़माएं । इनपुट ऑर्डर एक्सपोनेंट लिस्ट पहले है, फिर प्रिम्स की लिस्ट (-3 बाइट्स थैंक्स टू @ डेनिस) ।

प्रत्येक प्राइम-एक्सपोनेंट जोड़ी के (p, e)लिए

(p^(e+1) - 1)/(p - 1)

फिर इन सभी के उत्पाद का पता लगाएं। उदाहरण के लिए 240 यह होगा

(1 + 2 + 4 + 8 + 16)(1 + 3)(1 + 5) = 31 * 4 * 6 = 744

घातांक कैसे लागू किया जाता है, इसके आधार पर, यह बेहतर हो सकता है O(sum of exponents)।

Answer 3

एपीएल, 18 13 बाइट्स * 0.8 = 10.4

×/(1-⊣×*)÷1-⊣

यह एक डाइएडिक फ़ंक्शन ट्रेन बनाता है जो बाईं ओर कारकों की सरणी लेता है और दाएं पर घातांक।

×/             ⍝ Vector product of
  (1-⊣×*)      ⍝ each factor^(exponent+1)-1
         ÷1-⊣  ⍝ divided by factor-1

इसे ऑनलाइन आज़माएं । ध्यान दें कि यह Sp3000 के अजीब चालाक CJam उत्तर के समान दृष्टिकोण है ।

डेनिस की बदौलत 5 बाइट बच गईं!

Answer 4

TI-BASIC, 17 बाइट्स * 0.8 = 13.6

इसके अलावा Sp3000 की विधि का उपयोग करता है, हालांकि मैंने इसे स्वतंत्र रूप से पाया। एक सूची इनपुट से और एक होमस्क्रीन से लेता है।

Input E
prod(AnsAns^∟E-1)/prod(Ans-1

ठेस का उपयोग करना (दो बार छोटा है क्योंकि यह हमें खुली कोष्ठक का उपयोग मुफ्त में करने देता है। ध्यान दें कि यह उत्तर खाली सरणियों का समर्थन नहीं करता है, क्योंकि TI-BASIC में कोई खाली सरणियाँ नहीं हैं।

Answer 5

हास्केल, 38 * 0.8 = 30.4

product$zipWith(\p e->(p*p^e-1)/(p-1))

उपयोग:

product$zipWith(\p e->(p*p^e-1)/(p-1)) [2,3,5] [4,1,1]
744.0

अनाम फ़ंक्शन ज्यामितीय श्रृंखला योग के माध्यम से (p,e)विभाजक-योग में ले जाता है p^e। जुड़ने और उत्पाद लेने के रूप में इसके साथ दो सूचियों को एक साथ जोड़ना परिणाम देता है।

मैं कुछ भी कम नहीं पा रहा था जो अंकगणित की अभिव्यक्ति हो

(p*p^e-1)/(p-1)
sum$map(p^)[0..e]

शायद वहाँ से छुटकारा पाने का एक तरीका है (\p e->_)।

Infix फ़ंक्शन परिभाषा समान लंबाई (38) देती है:

p%e=(p*p^e-1)/(p-1)
product$zipWith(%)

Answer 6

सी ++, 111 80 77 बाइट्स * 0.8 = 61.6

int g(int*p,int*e,int n){return n?g(p+1,e+1,n-1)*(pow(*p,*e-1)-1)/(*p-1):1;}

यह गणना (p ^ (e + 1) -1) / (p-1) और पुनरावर्ती सभी कारकों को गुणा करता है। एक साल पहले खुद को पाया।

मदद करने के लिए धन्यवाद, पूरी तरह से c ++ शैली बूलियन उपयोग के बारे में भूल गया।

Comments

n==0सरल करता है !n- या आप परिणामों को उलट सकते हैं और बस उपयोग कर सकते हैंn

— टोबी स्पाइट नाइट

Answer 7

मतलब, ५३

function t=f(x,y)
s=1:prod(x.^y);t=s*~mod(s(end),s)';

उदाहरण:

>> f([2 3 5], [4 1 1])
ans =
   744

Comments

ऐसा लगता है कि आप 0.8 बोनस जोड़ सकते हैं

— Moartem

@ मोहतरम धन्यवाद! लेकिन मुझे इस पर यकीन नहीं है। मैं संख्या की गणना sऔर उसके बाद से हर संभव divisors का परीक्षण 1करने के लिए s। तो यह (कम से कम) हे (ओं), जो कि शायद हे (एक्सपोजर की राशि) और हे (

— एक्सपोजर के

हाँ, यह सही है, यह O (घातांक का उत्पाद) से भी बड़ा है

— Moartem

Answer 8

अजगर 2,156

from itertools import*
from operator import*
i=input()
print sum(reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]])))

इनपुट

[[2,3,5],[4,1,1]]

उत्पादन

744

व्याख्या

यह कार्यक्रम 2 सूचियों की सूची प्राप्त करता है: कारक और प्रतिपादक।

i=input() # Receive list of 2 lists: i[0] for factors i[1] for exponents

फिर इसकी घातांक सूची के सभी संभावित संयोजनों की सूची बनाएं।

[x+1 for x in i[1]] # [4,1,1]->[5,2,2] (to include last element)
map(range,[x+1 for x in i[1]]) # [[0, 1, 2, 3, 4], [0, 1], [0, 1]]
product(*map(range,[x+1 for x in i[1]])) # [(0, 0, 0), (0, 0, 1), ..., (4, 1, 1)]

और कारकों के साथ इसे ज़िप करें:

zip(i[0],p) for p in product(*map(range,[x+1 for x in i[1]])) # [[(2, 0), (3, 0), (5, 0)], ..., [(2, 4), (3, 1), (5, 1)]]

घातांक की शक्ति के कारकों की गणना करें:

 [a**b for a,b in zip(i[0],p)]for p in product(*map(range,[x+1 for x in i[1]])) # [[1, 1, 1], ..., [16, 3, 5]]

और प्रत्येक सूची को गुणा करें (यह हमें सभी भाजक देता है):

reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]])) # [1, 5, 3, 15, ..., 240]

अंत में, सभी सूचियों और योग को मुद्रित करें:

print sum(reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]]))) # 744

Comments

क्या आप संक्षेप में बता सकते हैं कि आपका कोड क्या करता है (जैसा कि मैं अजगर से परिचित नहीं हूं), इसलिए मैं आपके कोड की जटिलता का न्याय कर सकता हूं?

— मोहतरम

यह एक चतुर दृष्टिकोण है, लेकिन जटिलता

— एक्सपोजर्स

@ मोहतरम हां, मैंने जटिलता को कम करने में ज्यादा समय नहीं

— लगाया

Answer 9

अजगर 3, 134 120 117

इनपुट: अल्पविराम द्वारा दो अल्पविराम से अलग-अलग सरणियाँ।

उदाहरण:

(2,3,7,11),(4,2,3,2)
21439600

from functools import*
a=eval(input())
print(reduce(int.__mul__,(sum(x**j for j in range(y+1))for x,y in zip(*a)),1))

NumPy के साथ 100 बाइट्स घटाए जा सकते हैं:

import numpy
a=eval(input())
print(numpy.product([sum(x**j for j in range(y+1))for x,y in zip(*a)]))

Comments

पहले उदाहरण के लिए, बस इतना पता है कि एक बार operatorउपयोग करने के लिए आयात करने के बजाय mul, आप float.__mul__बाइट्स का एक गुच्छा बचाने के लिए उपयोग कर सकते हैं ।

— केड

Answer 10

जेली, गैर-प्रतिस्पर्धात्मक

यह जवाब गैर-प्रतिस्पर्धात्मक है, क्योंकि चुनौती जेली के निर्माण से पहले की है।

5 बाइट्स (कोई बोनस नहीं)

*PÆDS

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

यह काम किस प्रकार करता है

*PÆDS    Main link. Left input: p (prime factors). Right input: e (exponents).

*        Elevate the prime factors to the corresponding exponents.
 P       Take the product of all powers.
  ÆD     Find all divisors of the product.
    S    Compute the sum of the divisors.

7 बाइट्स (बोनस के बाद 5.6 बाइट्स)

*‘}’:’{P

यह काम किस प्रकार करता है

×*’:’{P  Main link. Left input: p (prime factors). Right input: e (exponents).

 *       Elevate the prime factors to the corresponding exponents.
         This yields p ** e.
×        Multiply the prime factors with the corresponding powers.
         This yields p ** (e + 1).
  ’      Decrement the resulting products.
         This yields p ** (e + 1) - 1.
    ’{   Decrement the prime factors.
         This yields p - 1.
   :     Divide the left result by the right one.
         This yields (p ** (e + 1) - 1) / (p - 1).
      P  Take the product of all quotients.

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

Answer 11

एपीएल, 12 बाइट्स * 0.8 = 9.6

×/1++/¨⎕*⍳¨⎕

यह कीबोर्ड से दो सूचियों को पढ़ता है, पहले, यानी:

      ×/1++/¨⎕*⍳¨⎕
⎕:
      4 1 1
⎕:
      2 3 5
744

स्पष्टीकरण:

• ⎕: कीबोर्ड से एक सूची पढ़ें (घातांक)
• ⍳¨: सूची में प्रत्येक संख्या के लिए, एक सूची बनाएं [1..n]।
• ⎕*: कीबोर्ड (प्रिम्स) से एक और सूची पढ़ें, और प्रत्येक सूची के प्रत्येक साथी को संबंधित सूचियों में बढ़ाएं
• +/¨: प्रत्येक सूची का योग
• 1+: प्रत्येक सूची में एक जोड़ने के लिए, x^0प्रत्येक सूची में लापता के लिए क्षतिपूर्ति करने के लिए
• ×/: परिणामों का उत्पाद ले लो

Answer 12

रैकेट (स्कीम), 65 * 0.8 = 52 बाइट्स

सभी के रूप में एक ही अंकगणित

(λ(x y)(foldl(λ(m n o)(*(/(-(expt m(+ n 1))1)(- m 1))o))1 x y))

स्पष्टीकरण:

(λ (x y)    ;defines anonymous function with two inputs
    (foldl    ;recursively applies the following function to all elements of the lists given to an argument given (foldl function argument lists lists lists...)
        (λ (m n o) (* (/ (- (expt m (+ n 1)) 1) (- m 1)) o))    ;an anonymous function representing the same arithmetic used in the CJam answer, then multiplying it with our incrementor
        1 x y))    ;the incrementor argument is 1, and the input lists are the ones provided into the original function

Answer 13

पायथन 2, 80 बाइट्स * 0.8 = 64

यह मानता है कि इनपुट एक के बाद एक आता है। Sp3000 के CJam उत्तर में उल्लिखित एक ही सूत्र का अनुसरण करता है।

print(reduce(float.__mul__,[~-(x**-~y)/~-x for x,y in zip(input(),input())],1)) 

यदि इसकी अनुमति नहीं है, तो मैं इसे एक समाधान के रूप में उपयोग करूंगा, जिसे 84 बाइट्स * 0.8 = 67.2 का स्कोर मिलता है। इनपुट को अल्पविराम द्वारा अलग किया जाना चाहिए, अर्थात [2,3,5],[4,1,1]।

k=input()
print(reduce(float.__mul__,[~-(x**-~y)/~-x for x,y in zip(k[0],k[1])],1))

---

^{अरे। अरे! यह प्रतीकात्मक में एक संभव समाधान है, कुछ मैं जिस पर काम कर रहा हूं:Ƥ(П([~-(x**-~y)/~-xϝx,yϊʐ(Ί,Ί)],1))}

Answer 14

गणितज्ञ, 40 बाइट्स

Total[Outer@@{*}~Join~(#^0~Range~#2),3]&

विभाजकों के साथ व्यवहार करने वाले किसी भी इनबिल्ट का उपयोग किए बिना, धागे में अन्य गणितज्ञ समाधान से अंतर करने के लिए।

इनपुट है (उदाहरण का उपयोग करके) [{2, 3, 5}, {4, 1, 1}]

Answer 15

पर्ल 5, 96 बाइट्स

जाहिर है कि यह नॉनविनिंग है, लेकिन मैंने इसे मजे के लिए लिखने का फैसला किया।

यह एक सबरूटीन है:

{($b,$e)=@_;$s=1;map$s*=$b->[$_]**$e->[$_],0..@$b-1;$_=1x$s;for$j(1..$s){$i+=$j*/^(.{$j})*$/}$i}

इसे कार्रवाई में इस प्रकार देखें:

perl -e'print sub{...}->([2,3,5],[4,1,1])'

यह काम किस प्रकार करता है:

• ($b,$e)=@_इनपुट arrayrefs $b(कुर्सियां) और $e(घातांक) पढ़ता है ।
• $s=1 उत्पाद को इनिशियलाइज़ करता है।
• map$s*=$b->[$_]**$e->[$_],0..@$b-1$sक्रमिक आधार-प्रतिपादक शक्तियों द्वारा गुणक । अब $sसमग्र संख्या है।
• $_=1x$sलंबे समय के $_लिए एक स्ट्रिंग के बराबर सेट करता है $s। $i0 पर आरंभीकृत होता है।
• for$j(1..$s){$i+=$j*/^(.{$j})*$/}की कोशिश करता है, हर नंबर के लिए $j1 और के बीच $s, तोड़ने के लिए $_ऊपर के रूप में $jपात्रों कितनी भी बार दोहराया। यदि यह हो सकता है, तो $jविभाजित होता है $s, और /^(.{$j})*$/1 है (अन्यथा यह 0 है), और $iद्वारा संवर्धित है $j। इस प्रकार, हम $iसमान आकार के विभाजन में विभाजन की संख्या जोड़ते हैं $_। जैसा कि उमर ई। पोल बताते हैं , $iवह संख्या है जिसकी हम मांग कर रहे हैं।
• $iअंत में लौटा $i।

Answer 16

जे, 14 बाइट्स * 0.8 = 11.2

[:*/(^>:)%&<:[

प्रयोग

   f =: [:*/(^>:)%&<:[
   2 3 5 f 4 1 1
744