Bir fonksiyonun türevi, matematik, mühendislik, fizik, biyoloji, kimya ve aynı zamanda çok sayıda başka bilimlerin temel taşıdır. Bugün sadece teğetsel olarak ilişkili bir şeyi hesaplayacağız: aritmetik türevi.

Tanım

Aritmetik türev a(n)veya n'burada ( A003415 ) bir fonksiyonun türevine benzer bir takım özellikler tarafından tanımlanır .

• a(0) = a(1) = 0,
• a(p) = 1, pherhangi bir asal nerede ve
• a(mn) = m*a(n) + n*a(m).

Üçüncü kural fonksiyonlarının farklılaşması için ürün kurala dayanıyor: fonksiyonlar için f(x)ve g(x), (fg)' = f'g + fg'. Yani sayılarla (ab)' = a'b + ab'.

Ayrıca, aritmetik türev bu basit ilişki ile negatif sayılara uzatılabildiğinden a(-n) = -a(n), giriş negatif olabilir.

kurallar

• Herhangi bir tamsayı verilen n, aritmetik türevini döndüren bir program veya işlev yazın n.
• Girdiler, makul bir sürede faktörü etkileyemeyecek kadar büyük ve tam sayıdaki sorunlardan kaçınmak için olacaktır . Algoritmanız hala bu aralığın dışındaki sayıların aritmetik türevini teorik olarak hesaplayabilmelidir.-230 < n < 230
• Sembolik matematik, asal çarpanlara ayırma ve farklılaşma için yerleşik yapılara izin verilir.

Örnekler

> 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

Her zaman olduğu gibi, sorun açık değilse, lütfen bana bildirin. İyi şanslar ve iyi golf!

MATL , 12 bayt

|1>?GtYf/s}0

Çevrimiçi deneyin!

açıklama

Bir tamsayı düşünün a ile | a |> 1 ve | (muhtemelen tekrarlanan) asal faktörlerin | a | olmak f ₁ , ..., f _n . Daha sonra, istenen sonucu bir · (1 / f ₁ + ... + 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

Python, 59 bayt

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

Özyinelemeli bir işlev. Büyük girişlerde, Stackless Python gibi bir şeyle çalıştırmadığınız sürece tipik sistemlerde yığın derinliği azalıyor .

Özyinelemeli tanım, aday asal faktörleri aramak için sayılarak doğrudan uygulanır. Yana f(prime)=1ise, nbir asal vardır pbir faktör olarak, elimizdeki f(n) == p*f(n/p)+n/p.

Jöle, 8 7 bayt

@ Bayt tarafından -1 bayt

ÆfḟṠ³:S

Herkesin yaptığı gibi aynı formülü kullanır. Ancak, başa çıkmak için küçük bir hile var 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.

Burada dene .

Python 2, 87 78 76 74 bayt

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 sayesinde geliştirmeler:

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

İki byte ile daha fazla gelişme:

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 sayesinde daha fazla gelişme:

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çıklama

Aritmetik türevi ana eşit akez ana faktör tersinin toplamına a. 1 için bir istisna gerekmez, çünkü 1'in asal çarpanlarının karşıtlarının toplamı sıfırdır.

Haskell, 203 90 bayt

@Nimi teşekkürler!

Hangi girintilerin hangi yoruma yol açtığı hakkında hala hiçbir fikrim yok, bu şu ana kadar yönettiğim en kısa şeydi ve her zaman olduğu gibi, çok daha fazla golf oynayabileceğinden eminim. Akşamları tekrar deneyeceğim.

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]

J, 30 27 19 karakter

3 karakteri kesmek için @Dennis teşekkürler .

8 karakteri kesen @Zgarb'a teşekkürler .

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

Çevrimiçi deneyin!

Örnek giriş:

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

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

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

Nasıl çalışır:

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

Pyth - 10 8 bayt

Örtük girişi kaybedersiniz! Çoğu şey için Jelly ile aynı seviyeye getirmeli (Dennis'in golf becerisi hariç).

*scL1P.a

Test Takımı .

*             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

Haskell, 59 bayt

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

Özyinelemeli tanımlamayı p, başından itibaren potansiyel asal çarpanları aramaya sayan bir yardımcı değişkenle doğrudan uygular 2. Son satır, p=2ilk satırda tanımlanan ikili fonksiyona takılan ana fonksiyondur .

İşlev sırayla her durumu kontrol eder:

• Eğer n*n<2öyleyse n, onlardan biri -1,0,1ve sonuç 0.
• Birden nfazla değilse p, artırın pve devam edin.
• Aksi takdirde, ifade n=p*rve "türev" özelliği ile sonuç, r*a(p)+p*a(r)basitliği kolaylaştıracaktır, r+p*a(r)çünkü pasaldır.

Son durum tarafından bayt kaydeder bağlayıcı rbir bekçi de önler, 1>0Demirbaş için otherwise. Daha rönce bağlanabilirse, ikinci durum 3 bayt daha kısa olan mod n p>0olarak kontrol edilebilir r*p==n, ancak bunun nasıl yapıldığını göremiyorum.

Cidden , 17 14 11 12 bayt

Benim ilk kez cidden cevap. Bu cevap, Luis Mendo'nun MATL cevabına ve bir sayının aritmetik türevinin çokluğun her ana faktörünün olduğu yere meşit olduğu fikrine dayanmaktadır . Benim ekim, eğer öyleyse , not etmek . Golf ve böcek tamir yardımları için Mego'ya teşekkürler . Çevrimiçi deneyin!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

Japt -x , 16 13 10 bayt

ÒU©a k £/X

- @Shaggy sayesinde 6 bayt

Çevrimiçi deneyin!

APL (Dyalog Genişletilmiş) , 13 9 bayt

Basit bir çözüm. Dyalog Unicode sürümü bunun sadece daha uzun bir versiyonuydu, bu nedenle ihmal edildi.

Düzenleme: lirtosiast'ın Jelly solüsyonundaki yöntemi kullanarak 4 bayt kurtardı .

{+/⍵÷⍭|⍵}

Çevrimiçi deneyin!

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.

Ruby, 87 66 80 75 70 68 bayt

Bu cevap, Luis Mendo'nun MATL cevabına , wythagoras'ın Python cevabına ve bir sayının aritmetik türevinin , çoğulculuğun her ana faktörünün olduğu yere meşit olduğu fikrine dayanır .m·(1/p1 + 1/p2 + ... + 1/pn)p1...pnn

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

Bu işlev aşağıdaki şekilde çağrılır:

> 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

Julia, 72 43 bayt

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

Bu bir tamsayı kabul eden ve bir şamandıra döndüren adsız bir işlevdir. Aramak için değişkene atayın.

Bir giriş tamsayı için n ise, n ² 0 Aksi asal çarpanlara elde ≤ 1 dönüş n ² , bir şekilde Dict, her ana / üs çifti için, daha sonra da üstü ile asal böler ve bölmek n sonucu ile. Bu sadece bilgi işlem n X / p , p ana bir faktördür ve x toplanmasıyla aynıdır olan üs olduğu , n / p , x kez. Ortaya çıkan diziyi toplamlarız ve 2'ye böleriz, çünkü ihtiyacımızın iki katı topladık. Bu, faktörü n ^{2 olarak kabul} etmemizden kaynaklanıyoryerine n . (Bunu yapmak, faktoring | n | .'den daha kısa bir bayttır .)

Dennis sayesinde 29 byte kurtarıldı!

Jolf, 13 bayt

*jmauΜm)jd/1H

Algoritmaya MATL cevabı Kudos! Burada deneyin , ya hepsini birden test etmek . (Dizideki [key, out] çıkışları.)

açıklama

*jmauΜm)jd/1H
*j             input times
      m)j         p.f. of input
     Μ   d/1H      mapped to inverse
    u            sum of
  ma            abs of

Mathematica 10.0, 39 bayt

Tr[If[#>1,#2/#,0]&@@@FactorInteger@#]#&

APL (NARS), 35 karakter, 70 bayt

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

test ve nasıl kullanılacağı:

  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

Tamam olmaz diye düşündüm çünkü c değişkeninin oluşup oluşmadığını bilmiyorum (asal değil) ... Fakat test için uygun görünüyor ...

05AB1E , 7 4 bayt

ÄÒ÷O

Port @lirtosiast 'ın Jelly cevap .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

Perl 5, 62 bayt

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

Formülü kullanır (OEIS'den): If n = Product p_i^e_i, a(n) = n * Sum (e_i/p_i).

Perl 6, 90

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

Bu, büyük sayılar için biraz yavaş olabilir. Değiştir 2..^nile 2..n.sqrtuzun kod ancak daha hızlı hesaplaması için.

Mürekkep , 183 bayt

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

Çevrimiçi deneyin!

Bunun iyi bir çözüm olduğuna inanmayı reddediyorum, ancak iyileştirmenin bir yolunu da göremiyorum.

Pari / GP , 45 bayt

n->n*vecsum([i[2]/i[1]|i<-factor(n)~,i[1]>0])

Çevrimiçi deneyin!