अंकगणित व्युत्पन्न

34

एक फ़ंक्शन का व्युत्पन्न गणित, इंजीनियरिंग, भौतिकी, जीव विज्ञान, रसायन विज्ञान, और साथ ही अन्य विज्ञानों की एक बड़ी संख्या है। आज हम केवल मूर्त रूप से संबंधित कुछ चीज़ों की गणना करने जा रहे हैं: अंकगणितीय व्युत्पन्न।

परिभाषा

अंकगणित व्युत्पन्न a(n)या n'यहाँ परिभाषित किया गया है ( A003415 ) कई गुण जो एक फ़ंक्शन के व्युत्पन्न के समान हैं।

  • a(0) = a(1) = 0,
  • a(p) = 1, जहां pकोई भी प्रधान है, और
  • a(mn) = m*a(n) + n*a(m)।

तीसरा नियम कार्यों के भेदभाव के लिए उत्पाद नियम पर आधारित है: कार्यों के लिए f(x)और g(x), (fg)' = f'g + fg'। संख्या के साथ तो, (ab)' = a'b + ab'।

नोट के अलावा, चूंकि अंकगणितीय व्युत्पन्न को इस सरल संबंध के माध्यम से ऋणात्मक संख्याओं तक बढ़ाया जा सकता है, इसलिए a(-n) = -a(n), इनपुट नकारात्मक हो सकता है।

नियम

  • एक प्रोग्राम या फ़ंक्शन लिखें, जो किसी भी पूर्णांक को देखते हुए n, अंकगणितीय व्युत्पन्न देता है n।
  • इनपुट होंगे -230 < n < 230 उचित समय के साथ पूर्णांक आकार और संख्याओं के साथ समस्याओं से बचने के लिए बहुत बड़े कारक होंगे। आपका एल्गोरिथ्म अभी भी सैद्धांतिक रूप से इस सीमा के बाहर संख्याओं के अंकगणितीय व्युत्पन्न की गणना करने में सक्षम होना चाहिए।
  • प्रतीकात्मक गणित, अभाज्य गुणनखंडन और विभेदन के लिए अंतर्निर्मित।

उदाहरण

> a(1)
0
> a(7)
1
> a(14)   # a(7)*2 + a(2)*7 = 1*2 + 1*7 = 9
9
> a(-5)   # a(-5) = -a(5) = -1
-1
> a(8)    # a(8) = a(2**3) = 3*2**2 = 12
12
> a(225)  # a(225) = a(9)*25 + a(25)*9 = 6*25 + 10*9 = 150 + 90 = 240
240
> a(299792458)  # a(299792458) = a(2)*149896229 + a(7)*42827494 + a(73)*4106746 + a(293339)*1022 = 1*149896229 + 1*42827494 + 1*4106746 + 1*1022 = 149896229 + 42827494 + 4106746 + 1022 = 196831491
196831491

हमेशा की तरह, अगर समस्या स्पष्ट नहीं है, तो कृपया मुझे बताएं। गुड लक और गुड गोल्फिंग!

code-golf  math  sequence  arithmetic  number-theory 
— Sherlock9
स्रोत
क्या, वास्तव में, primeमें है a(prime)? क्या यह सिर्फ एक प्रमुख संख्या है?
— स्टैकस्टक
इसके अलावा, मुझे नहीं मिलता कि आपने अंतिम उदाहरण को कैसे विघटित किया।
— स्टैकस्टक
@Stackstuck हाँ, यह किसी भी प्रमुख है। मैंने स्पष्टता के लिए संपादन किया है। इसके अलावा, मैंने आखिरी उदाहरण में इसे स्पष्ट रूप से स्पष्ट करने के लिए जोड़ा।
— शर्लक

जवाबों:

10

MATL , 12 बाइट्स

|1>?GtYf/s}0

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

व्याख्या

एक पूर्णांक पर विचार करें एक साथ | ए |> 1, और चलो (संभवतः दोहराया) के प्रमुख कारक | ए | हो च 1 , ..., च n । फिर वांछित परिणाम एक · (1 / f 1 + ... + 1 / f n ) है।

|1>     % take input's absolute value. Is it greater than 1?
?       % if so:
  Gt    %   push input twice
  Yf    %   prime factors. For negative input uses its absolute value
  /     %   divide element-wise
  s     %   sum of the array
}       % else:
  0     %   push 0
— लुइस मेंडो
स्रोत
1 के प्रमुख कारकों का योग 0 के बराबर नहीं है? या MATL में वह काम नहीं करता है?
— विथगोरस
@wythagoras वास्तव में अपने "प्राइम" संख्या के अपघटन के रूप में 1देता है 1। यह एक अजीब परिणाम है (एक खाली सरणी अधिक सार्थक होगी)। लेकिन यह है कि कैसे Matlab काम करता है। और सीजेएम भी। इसलिए मुझे लगता 1है कि उस मामले में उत्पादन करने का अच्छा कारण होना चाहिए ? तुम क्या सोचते हो? मैं Yfएक खाली सरणी के उत्पादन के लिए फ़ंक्शन को फिर से परिभाषित करने के लिए लुभाया गया हूं 1, लेकिन मुझे यकीन नहीं था
— लुइस मेंडो
1
अजगर एक खाली सरणी देता है, fwiw।
— isaacg
@isaacg धन्यवाद! शायद मैं बदल देंगे
— लुइस Mendo
Mathematica में एक ही (लगभग एक बार एक समस्या थी)
— कैलक्यूलेटरफ़लाइन
7

पायथन, 59 बाइट्स

f=lambda n,p=2:+(n*n>1)and(n%p and f(n,p+1)or p*f(n/p)+n/p)

एक पुनरावर्ती कार्य। बड़े इनपुट पर, यह विशिष्ट प्रणालियों पर स्टैक डेप्थ से बाहर निकलता है जब तक कि आप इसे स्टैकलेस पायथन जैसी किसी चीज़ के साथ नहीं चलाते ।

प्रत्यावर्ती परिभाषा को सीधे लागू किया जाता है, उम्मीदवार प्रमुख कारकों की खोज करने के लिए गिनता है। चूंकि f(prime)=1, यदि एक कारक के रूप nमें एक प्रमुख pहै, तो हमारे पास है f(n) == p*f(n/p)+n/p।

— XNOR
स्रोत
क्या आपको इनपुट और प्रिंट की आवश्यकता नहीं है? कम से कम जब मैं इसे (पायथन 2) चलाता हूं, तो मुझे कोई परिणाम नहीं मिलता है।
— विथगोरस
@wythagoras डिफ़ॉल्ट रूप से, फ़ंक्शंस को कार्यक्रमों के विकल्प के रूप में अनुमति दी जाती है। साथ ही, यह चुनौती "कार्यक्रम या कार्य" कहती है।
— xnor
7

जेली, 8 7 बाइट्स

-1 बाइट @ डेनिस द्वारा

ÆfḟṠ³:S

उसी फॉर्मूले का उपयोग करता है जो हर कोई करता है। हालांकि, इससे निपटने के लिए थोड़ी तरकीब है 0।

o¬AÆfİS×     Main link. Inputs: n
o¬             Logical OR of n with its logical NOT
               That is, 0 goes to 1 and everything else goes to itself.
  A            Then take the absolute value
   Æf          get its list of prime factors
     İ         divide 1 by those
      S        sum
       ×       and multiply by the input.

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत
क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं? मुझे उत्तर देने से पहले स्पष्टीकरण देना पसंद है।
— शर्लक
@ शर्लक 9 किया।
— lirtosiast
मैं देख रहा हूं कि आपका उत्तर गढ़ दिया गया है और स्पष्टीकरण अब पुराना है। क्या आप इसे ठीक करेंगे? साभार: D
— Sherlock9
5

पायथन 2, 87 78 76 74 बाइट्स

a=b=input()
d=2
s=0
while d<=abs(b):
    if a%d==0:
        a=a/d
        s+=b/d
    else:
        d+=1
print s

@Maltysen के लिए धन्यवाद में सुधार: 

a=b=input()
d=2
s=0
while d<=abs(b):
    if a%d==0:a/=d;s+=b/d
    else:d+=1
print s

दो बाइट्स द्वारा और सुधार:

a=b=input()
d=2
s=0
while abs(a)>1:
    if a%d<1:a/=d;s+=b/d
    else:d+=1
print s

@Xnor के लिए और सुधार

a=b=input()
d=2
s=0
while a*a>1:
    if a%d<1:a/=d;s+=b/d
    else:d+=1
print s

व्याख्या

का अंकगणितीय व्युत्पन्न गुणनफल के अभाज्य गुणनफल के योग के aबराबर होता aहै a। 1 के लिए कोई अपवाद आवश्यक नहीं है क्योंकि 1 के प्रमुख कारकों के पारस्परिक के योग शून्य हैं।

— wythagoras
स्रोत
abs(a)>1हो सकता है a*a>1।
— xnor
@xnor हाँ, धन्यवाद।
— विथगोरस
पंक्ति 2 को बदलेंd,s = 2,0
— Agnishom चट्टोपाध्याय
@AgnishomChattopadhyay दोनों कुल मिलाकर 8 बाइट्स हैं।
— विथगोरस
4

हास्केल, 203 90 बाइट्स

थैंक्स @nimi!

मुझे अभी तक पता नहीं है कि क्या इंडेंटेशन क्या व्याख्या का कारण बनता है, यह सबसे छोटा है जिसे मैंने अब तक प्रबंधित किया है, और हमेशा की तरह, मुझे यकीन है कि यह बहुत अधिक हो सकता है। मैं शाम को फिर से कोशिश करने जा रहा हूं।

n#(x:_)|y<-div n x=x*a y+y*a x;_#_=1
a n|n<0= -a(-n)|n<2=0|1<2=n#[i|i<-[2..n-1],mod n i<1]
— flawr
स्रोत
1
बहुत बहुत धन्यवाद, शिक्षक =) मैं हमेशा बहुत कुछ सीख सकता हूं जब भी आप यहां मेरी मदद करेंगे! अपने स्वयं के उत्तर के रूप में अपने संस्करण को जोड़ने के लिए स्वतंत्र महसूस करें!
— दोष
4

जे, 30 27 19 वर्ण

3 पात्रों को काट देने के लिए @ डेनिस का धन्यवाद ।

8 अक्षरों को काट देने के लिए @Zbb को धन्यवाद ।

0:`(*[:+/%@q:@|)@.*

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

नमूना इनपुट:

0:`(*[:+/%@q:@|)@.* _8
_12

0:`(*[:+/%@q:@|)@.* 0
0

0:`(*[:+/%@q:@|)@.* 8
12

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

0:`(*[:+/%@q:@|)@.* N
XX`YYYYYYYYYYYYY@.Z   if Z then Y else X end
0:                        X:  return 0
                  Z       Z:  signum(N)
   (*[:+/%@q:@|)          Y:  N*add_all(reciprocal_all(all_prime_factors(abs(N))))
                              N
    *                          *
      [:+/                      add_all(                                         )
          %@                            reciprocal_all(                         )
            q:@                                       all_prime_factors(      )
               |                                                        abs( )
                                                                            N
— लीक नन
स्रोत
3

अजगर - 10 8 बाइट्स

Lovin 'अंतर्निहित इनपुट! इसे ज्यादातर चीजों के लिए जेली के साथ लाना चाहिए (डेनिस गोल्फ कौशल को छोड़कर)।

*scL1P.a

टेस्ट सूट ।

*             Times the input, implicitly (This also adds the sign back in)
 s            Sum
  cL1         Reciprocal mapped over lit
   P          Prime factorization
    .a        Absolute value of input, implicitly
— Maltysen
स्रोत
3

हास्केल, 59 बाइट्स

n%p|n*n<2=0|mod n p>0=n%(p+1)|r<-div n p=r+p*r%2
(%2)

सीधे पुनरावर्ती परिभाषा को लागू करता है, एक सहायक चर के साथ जो pसंभावित प्रमुख कारकों की खोज के लिए गिनता है, जिससे शुरू होता है 2। अंतिम पंक्ति मुख्य कार्य है, जो प्लग करता हैp=2 पहली पंक्ति में परिभाषित बाइनरी फ़ंक्शन को करता है।

फ़ंक्शन बदले में प्रत्येक मामले की जाँच करता है:

  • यदि n*n<2, तो में nसे एक है -1,0,1, और परिणाम है0 ।
  • यदि nएक से अधिक नहीं है p, तो वेतन वृद्धि pऔर जारी रखें।
  • अन्यथा, व्यक्त n=p*r, और "व्युत्पन्न" संपत्ति द्वारा, परिणाम है r*a(p)+p*a(r), जो सरल है r+p*a(r)क्योंकि pप्रधान है।

आखिरी मामला एक गार्ड में बांधकरr बाइट्स बचाता है , जो 1>0बॉयलरप्लेट के लिए भी बचा जाता है otherwise। यदि rपहले बाध्य किया जा सकता है, तो दूसरी स्थिति के mod n p>0रूप में जाँच की जा सकती है r*p==n, जो 3 बाइट्स छोटी है, लेकिन मैं यह नहीं देखता कि यह कैसे करना है।

— XNOR
स्रोत
3

गंभीरता से , 17 14 11 12 बाइट्स

मेरा पहली बार गंभीरता से जवाब। इस उत्तर पर आधारित है लुइस Mendo के Matl जवाब और विचार है कि एक नंबर के गणित व्युत्पन्न mके बराबर है जहां के हर प्रधानमंत्री कारक है बहुलता के। मेरा जोड़ इस बात पर ध्यान देना है कि, अगर , तब । गोल्फ और बग फिक्सिंग मदद के लिए मेगो को धन्यवाद । इसे ऑनलाइन आज़माएं!m·(1/p1 + 1/p2 + ... + 1/pn)p1...pnnm = p1e1·p2e2·...·pnena(m) = m·(e1/p1 + e2/p2 + ... + en/pn)

,;w`i@/`MΣ*l

Ungolfing:

,             get a single input
 ;w           duplicate input and get prime factorization, p_f
               for input [-1..1], this returns [] and is dealt with at the end
   `   `M     map the function inside `` to p_f
    i         pop all elements of p_f[i], the prime and the exponent, to the stack
     @        rotate so that the exponent is at the top of the stack
      /       divide the exponent by the prime
         Σ    sum it all together
          *   multiply this sum with the input
           l  map and multiply do not affect an empty list, so we just take the length, 0
               l is a no-op for a number, so the result is unchanged for all other inputs
— Sherlock9
स्रोत
3

जाप्ट -x , 16 13 10 बाइट्स

ÒU©a k £/X

- 6 बाइट्स @ थैगी को धन्यवाद

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

— Quintec
स्रोत
दोनों नकारात्मक संख्याओं के लिए विफल हैं, क्योंकि किसी कारण से, N.k()उन पर काम नहीं करता है।
— झबरा
यहाँ कुछ गोल्फ के साथ एक फिक्स है।
— शैगी
या ध्वज के साथ -2 अधिक-x ।
— झबरा
— झबरा
@ शागी धन्यवाद, अच्छा
— क्विंटेक
3

एपीएल (डायलॉग एक्सटेंडेड) , १३ ९ बाइट्स

एक सरल उपाय। Dyalog यूनिकोड संस्करण केवल इसका एक लंबा संस्करण था इसलिए इसे छोड़ दिया गया है।

संपादित करें: विधि को अपनाकर 4 बाइट्स सहेजे गए lirtosiast के जेली समाधान ।

{+/⍵÷⍭|⍵}

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

Ungolfing

{+/⍵÷⍭|⍵}

{        }  A dfn, a function in {} brackets.
     ⍭|⍵   The prime factors of the absolute value of our input.
   ⍵÷      Then divide our input by the above array,
            giving us a list of products for the product rule.
 +/         We sum the above numbers, giving us our arithmetic derivative.
— Sherlock9
स्रोत
2

रूबी, 87 66 80 75 70 68 बाइट्स

यह उत्तर लुइस मेन्डो के MATL उत्तर , विथगोरस के पायथन उत्तर पर आधारित है , और यह विचार कि अंक की अंकगणितीय व्युत्पन्न कहाँ के mबराबर हैm·(1/p1 + 1/p2 + ... + 1/pn)p1...pn के हर प्रधानमंत्री कारक है nबहुलता के।

->n{s=0;(2...m=n.abs).map{|d|(m/=d;s+=n/d)while m%d<1};m<2?0:s+0**s}

इस फ़ंक्शन को निम्नलिखित तरीके से कहा जाता है:

> a=->n{s=0;(2...m=n.abs).map{|d|(m/=d;s+=n/d)while m%d<1};m<2?0:s+0**s}
> a[299792458]
196831491

Ungolfing:

def a(n)
  s = 0
  m = n.abs
  (2...m).each do |z|
    while m%d == 0
      m /= d
      s += n / d
    end
  end
  if s == 0
    if n > 1
      s += 1 # if s is 0, either n is prime and the while loop added nothing, so add 1
             # or n.abs < 2, so return 0 anyway
             # 0**s is used in the code because it returns 1 if s == 0 and 0 for all other s
    end
  end
  return s
end
— Sherlock9
स्रोत
2

जूलिया, 72 43 बाइट्स

n->n^2>1?sum(p->n÷/(p...),factor(n^2))/2:0

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और एक फ्लोट देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

एक इनपुट पूर्णांक n के लिए , यदि n 2 0. 1 प्रतिफल 0. अन्यथा n 2 के अभाज्य गुणनखंडन को a के रूप में प्राप्त करते हैं Dict, तो प्रत्येक अभाज्य / प्रतिपादक युग्म के लिए, प्रधान को उसके प्रतिपादक से विभाजित करते हैं, फिर परिणाम द्वारा n को विभाजित करते हैं । यह सिर्फ n x / p की गणना कर रहा है , जहाँ p अभाज्य गुणक है और x इसका प्रतिपादक है, जो कि n / n के समान है p , x बार के है। हम परिणामी सरणी को जोड़ते हैं और 2 से विभाजित करते हैं, क्योंकि हमने जितनी आवश्यकता है, उससे दो गुना अधिक राशि दी है। यह इस तथ्य के कारण है कि हम एन 2 फैक्टर कर रहे हैं n के बजाय। (ऐसा करना जो बाइटिंग फैक्टरिंग से छोटा हो | n । |)

डेनिस के लिए 29 बाइट्स बचाए गए!

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

जोल्फ, 13 बाइट्स

*jmauΜm)jd/1H

एल्गोरिथ्म के लिए MATL उत्तर के लिए यश! इसे यहाँ आज़माएं , या एक साथ उन सभी का परीक्षण करें । (एक सरणी में आउटपुट [कुंजी, आउट])

व्याख्या

*jmauΜm)jd/1H
*j             input times
      m)j         p.f. of input
     Μ   d/1H      mapped to inverse
    u            sum of
  ma            abs of
— कोनोर ओ ब्रायन
स्रोत
1

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

Tr[If[#>1,#2/#,0]&@@@FactorInteger@#]#&
— feersum
स्रोत
1
क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं? मुझे उत्तर देने से पहले स्पष्टीकरण देना पसंद है।
— शर्लक
1
@ शर्लक 9 यह एक बहुत ही अटूट उत्तर है, इसलिए मुझे इसमें शामिल करने की योजना नहीं है। यह ठीक है अगर कोई इसे बढ़ाता नहीं है।
— feersum
तो ठीक है। आपका दिन शुभ हो :)
— Sherlock9
वर्तमान मैथेमेटिका संस्करण में, FactorInteger@1पैदावार {1,1}, इसलिए Ifफ़ंक्शन अब आवश्यक नहीं है, 10 बाइट्स बचा रहा है।
— ग्रेग मार्टिन
@GregMartin गंभीरता से? यह {{1,1}}मेरे संस्करण द्वारा लौटाए गए मूल्य से अधिक असंगत है , (मेरे {}लिए अपेक्षित परिणाम है)।
— feersum
1

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

{1≥a←∣⍵:0⋄1=≢k←πa:×⍵⋄c+m×∇c←⍵÷m←↑k}

परीक्षण और उपयोग कैसे करें:

  f←{1≥a←∣⍵:0⋄1=≢k←πa:×⍵⋄c+m×∇c←⍵÷m←↑k}
  f 14
9
  f 8
12
  f 225
240
  f ¯5
¯1
  f 299792458
196831491

मैंने सोचा था कि यह ठीक नहीं होगा क्योंकि मुझे नहीं पता कि सी वेरिएबल (और प्राइम नहीं) से बना है ... लेकिन परीक्षण के लिए ठीक लगता है ...

— RosLuP
स्रोत
1

05AB1E , 7 4 बाइट्स

ÄÒ÷O

पोर्ट ऑफ @lirtosiast की जेली जवाब ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Ä     # Take the absolute value of the (implicit) input
 Ò    # Get all its prime factors (with duplicates)
  ÷   # Integer divide the (implicit) input by each of these prime factors
   O  # And take the sum (which is output implicitly)
— केविन क्रूज़सेन
स्रोत
0

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

perl -MMath::Prime::Util=:all -E"map$i+=1/$_,factor abs($j=<>);say$i*$j"

सूत्र का उपयोग करता है (OEIS से): If n = Product p_i^e_i, a(n) = n * Sum (e_i/p_i).

— msh210
स्रोत
0

पर्ल 6, 90

sub A(\n) {0>n??-A(-n)!!(n>1)*{$_??n/$_*A($_)+$_*A n/$_!!1}(first n%%*,2..^n)};say A slurp

यह बड़ी संख्या के लिए थोड़ा धीमा हो सकता है। लंबे समय तक कोड लेकिन तेजी से गणना के 2..^nसाथ बदलें 2..n.sqrt।

— bb94
स्रोत
0

स्याही , 183 बाइट्स

==function a(n)
{n<0:
~return-a(-n)
}
{n<2:
~return 0
}
~temp f=t(n,2)
{f:
~return a(n/f)*f+n/f
}
~return 1
==function t(n,i)
{n>1&&n-i:
{n%i:
~return t(n,i+1)
}
~return i
}
~return 0

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

मैं यह मानने से इनकार करता हूं कि यह एक अच्छा समाधान है, लेकिन मैं इसे सुधारने का कोई तरीका नहीं देख सकता।

— सारा जे
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.