函数的导数是数学，工程学，物理学，生物学，化学以及许多其他科学的基石。今天，我们将要计算仅与切线相关的东西：算术导数。

定义

此处，算术导数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

与往常一样，如果问题仍然不清楚，请告诉我。祝你好运，打高尔夫球！

MATL，12字节

|1>?GtYf/s}0

在线尝试！

说明

考虑带| 的整数a 一个 |> 1，而让的（可能重复）的素因子| 一个 | 是f ₁，...，f _n。然后，期望的结果是一个 ·（1 / ˚F ₁ + ... + 1 / ˚F _Ñ）。

|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个字节

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

递归函数。在大型输入上，除非您使用Stackless Python之类的代码运行，否则它在典型系统上的堆栈深度将用完。

递归定义直接实现，累加起来搜索候选素因。因为f(prime)=1，如果n有素数p作为因数，我们就有f(n) == p*f(n/p)+n/p。

果冻，8 7个字节

-1字节@ @Dennis

Æ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.

在这里尝试。

Python 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不需要例外。

Haskell，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]

J，30 27 19个字符

感谢@Dennis斩除了3个字符。

感谢@Zgarb斩除了8个字符。

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

Pyth- 10 8个字节

喜欢隐式输入！在大多数情况下，应使其与果冻齐头并进（丹尼斯的高尔夫技巧除外）。

*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

Haskell，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个字节，但是我不知道该怎么做。

严重的是17 14 11 12个字节

我的第一个认真回答。该答案基于路易斯·门多（Luis Mendo）的MATL答案以及数字的算术导数m等于where 的想法，即乘法的每个素数。我的补充是要注意，如果，则。感谢Mego打高尔夫球和修正错误。在线尝试！m·(1/p1 + 1/p2 + ... + 1/pn)p1...pnnm = p1e1·p2e2·...·pnena(m) = m·(e1/p1 + e2/p2 + ... + en/pn)

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

开球：

,             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字节

ÒU©a k £/X

-感谢@Shaggy提供6个字节

在线尝试！

APL（Dyalog扩展），13 9字节

一个简单的解决方案。Dyalog Unicode版本只是该版本的较长版本，因此已被省略。

编辑：采用lirtosiast的Jelly解决方案中的方法节省了4个字节。

{+/⍵÷⍭|⍵}

在线尝试！

开球

{+/⍵÷⍭|⍵}

{        }  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字节

该答案基于Luis Mendo 的MATL答案，wythagoras的Python答案以及数字的算术导数m等于where 的思想，这是乘法的每个素数。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}

通过以下方式调用此函数：

> 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

开球：

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

朱莉娅，72 43字节

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

这是一个匿名函数，它接受整数并返回浮点数。要调用它，请将其分配给变量。

对于输入整数Ñ，如果Ñ ² ≤1返回0。否则得到的素数因数分解Ñ ²作为一个Dict，则对于每个素/指数对，通过其指数除以素数，则划分Ñ通过的结果。这仅仅是计算ñ X / p，其中p为素数因子和X是它的指数，这是一样的总结ñ / p，X倍。我们对结果数组求和，然后将其除以2，因为求和的次数是我们需要的两倍。那是由于我们在分解 n ²而不是 |。。）n。（这样做比分解|短一个字节| n

感谢Dennis，节省了29个字节！

Jolf，13个字节

*jmauΜm)jd/1H

对该算法的MATL答案表示赞赏！在这里尝试，或一次全部测试。（在数组中输出[key，out]。）

说明

*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个字节

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

APL（NARS），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

我以为那是不对的，因为我不知道c变量是否组成（而不是素数）。但是对于测试来说似乎还可以。

05AB1E，7 4 字节

ÄÒ÷O

@lirtosiast的Jelly答案端口。

在线尝试或验证所有测试用例。

说明：

Ä     # 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个字节

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

Perl 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更长的代码，但更快的计算。

墨迹，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

在线尝试！

我拒绝相信这是一个很好的解决方案，但是我也看不出任何改进方法。

Pari / GP，45字节

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

在线尝试！