関数の導関数は、数学、工学、物理学、生物学、化学、および他の多くの科学の基礎でもあります。今日は、接線方向にのみ関連する何か、算術微分を計算します。

定義

算術導関数a(n)またはn'は、関数の導関数に似た多くのプロパティによってここで定義されます（A003415）。

• a(0) = a(1) = 0、
• a(p) = 1、p任意の素数、および
• a(mn) = m*a(n) + n*a(m)。

第3の規則は、機能の分化のための製品のルールに基づいている：機能のため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は。次に、望ましい結果はa・（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バイト

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バイト

@Dennisによる-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.

ここで試してみてください。

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

2バイトのさらなる改善：

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等しい。1の素因数の逆数の合計がゼロであるため、1の例外は必要ありません。aa

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文字を切り捨ててくれてありがとう。

8文字を切り捨ててくれた@Zgarbに感謝。

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、はのn1つで-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前にバインドできる場合、2番目の条件mod n p>0はとしてチェックできますr*p==n。これは3バイト短くなりますが、その方法はわかりません。

真剣に、17 14 11 12バイト

初めての真剣な答え。この回答は基づいているルイスMendoのMATLの答えと数の算術誘導体は、という考えmに等しいところのすべての素因数である多重度に。私の追加は、もしそうなら、ことに注意することです。ゴルフとバグ修正のヘルプを提供してくれた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 Extended）、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.

ルビー、87 66 80 75 70 68バイト

この回答は、ルイスメンドーのMATL回答に基づいています。 wythagorasのPythonの答えは、その数の算術誘導体は、という考えmに等しいところのすべての素因数である多重度に。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

これは、整数を受け入れ、floatを返す匿名関数です。呼び出すには、変数に割り当てます。

入力整数をNと、N ² 0は、そうでない場合の素因数分解得る≤1リターンN ²などをDict、各プライム/指数対について、次に、その指数により素数を分割し、分割nは結果によって。これは、n x / pを計算するだけです。ここで、pは素因数で、xはその指数です。これはn / pをx回合計するのと同じです。結果の配列を合計し、必要な2倍を合計したため、それを2で除算します。これは、n ^2を因数分解しているという事実によるものです。nではなく n |ます。）。（それを行うことは、因数分解よりも短いバイトです|

デニスのおかげで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

オンラインでお試しください！

これが良い解決策であるとは信じませんが、改善する方法も見当たりません。

パリ/ GP、45バイト

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

オンラインでお試しください！