Đạo hàm của một hàm là nền tảng của toán học, kỹ thuật, vật lý, sinh học, hóa học và một số lượng lớn các ngành khoa học khác. Hôm nay chúng ta sẽ tính toán một cái gì đó chỉ liên quan đến tiếp tuyến: đạo hàm số học.

Định nghĩa

Đạo hàm số học a(n)hoặc n'được định nghĩa ở đây ( A003415 ) bởi một số thuộc tính tương tự như đạo hàm của hàm.

• a(0) = a(1) = 0,
• a(p) = 1, đâu plà số nguyên tố, và
• a(mn) = m*a(n) + n*a(m).

Quy tắc thứ ba dựa trên quy tắc sản phẩm để phân biệt các chức năng: cho các chức năng f(x)và g(x), (fg)' = f'g + fg'. Vì vậy, với số , (ab)' = a'b + ab'.

Cũng cần lưu ý, vì đạo hàm số học có thể được mở rộng thành các số âm thông qua mối quan hệ đơn giản này a(-n) = -a(n), nên đầu vào có thể âm.

Quy tắc

• Viết chương trình hoặc hàm, cho bất kỳ số nguyên nào n, trả về đạo hàm số học của n.
• Đầu vào sẽ là , để tránh các vấn đề với kích thước nguyên và số quá lớn để tính hệ số trong một khoảng thời gian hợp lý. Thuật toán của bạn vẫn có thể tính toán theo lý thuyết đạo hàm số học của các số nằm ngoài phạm vi này.-230 < n < 230
• Được xây dựng cho toán học tượng trưng, ​​thừa số nguyên tố và phân biệt được cho phép.

Ví dụ

> 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

Như mọi khi, nếu vấn đề không rõ ràng, xin vui lòng cho tôi biết. Chúc may mắn và chơi golf tốt!

MATL , 12 byte

|1>?GtYf/s}0

Hãy thử trực tuyến!

Giải trình

Xét một số nguyên a với | a |> 1 và để các thừa số nguyên tố (có thể lặp lại) của | một | được f ₁ , ..., f _n . Khi đó, kết quả mong muốn là một · (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 byte

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

Một hàm đệ quy. Trên các đầu vào lớn, nó hết độ sâu ngăn xếp trên các hệ thống thông thường trừ khi bạn chạy nó với một cái gì đó như Stackless Python .

Định nghĩa đệ quy được thực hiện trực tiếp, đếm lên để tìm kiếm các yếu tố chính của ứng viên. Vì f(prime)=1, nếu ncó một nguyên tố plà một yếu tố, chúng ta có f(n) == p*f(n/p)+n/p.

Thạch, 8 7 byte

-1 byte bởi @Dennis

ÆfḟṠ³:S

Sử dụng cùng một công thức mà mọi người khác làm. Tuy nhiên, có một mẹo nhỏ để giải quyết 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.

Hãy thử nó ở đây .

Python 2, 87 78 76 74 byte

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

Những cải tiến nhờ @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

Cải thiện hơn nữa bởi hai byte:

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

Cải thiện hơn nữa nhờ @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

Giải trình

Đạo hàm số học abằng số alần tổng của các đối ứng của các thừa số nguyên tố của a. Không có ngoại lệ cho 1 là cần thiết vì tổng các đối ứng của các thừa số nguyên tố của 1 là 0.

Haskell, 203 90 byte

Cảm ơn @nimi!

Tôi vẫn không biết khi nào những vết lõm gây ra sự giải thích gì, đây là lần ngắn nhất tôi quản lý cho đến nay, và như mọi khi, tôi chắc chắn rằng nó có thể được chơi golf nhiều hơn nữa. Tôi sẽ thử lại vào buổi tối.

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 ký tự

Cảm ơn @Dennis vì đã cắt 3 ký tự.

Cảm ơn @Zgarb cắt 8 ký tự.

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

Hãy thử trực tuyến!

Đầu vào mẫu:

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

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

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

Làm thế nào nó hoạt động:

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

Số 10 - 10 8 byte

Yêu đầu vào ngầm! Nên mang nó ngang hàng với Jelly cho hầu hết mọi thứ (Ngoại trừ kỹ năng chơi gôn của Dennis).

*scL1P.a

Phòng thử nghiệ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 byte

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

Triển khai định nghĩa đệ quy trực tiếp, với một biến phụ trợ pđược tính để tìm kiếm các thừa số nguyên tố tiềm năng, bắt đầu từ đó 2. Dòng cuối cùng là chức năng chính, cắm p=2vào chức năng nhị phân được xác định trong dòng đầu tiên.

Hàm lần lượt kiểm tra từng trường hợp:

• Nếu n*n<2, sau đó nlà một trong những -1,0,1, và kết quả là0 .
• Nếu n không phải là bội số của pthì tăng pvà tiếp tục.
• Mặt khác, thể hiện n=p*rvà bằng thuộc tính "phái sinh", kết quả làr*a(p)+p*a(r) , đơn giản hóa r+p*a(r)vì plà số nguyên tố.

Trường hợp cuối cùng lưu các byte bằng cách liên kết rtrong một bộ bảo vệ , điều này cũng tránh 1>0cho bản tóm tắt otherwise. Nếu rcó thể bị ràng buộc sớm hơn, điều kiện thứ hai mod n p>0có thể được kiểm tra là r*p==n, ngắn hơn 3 byte, nhưng tôi không thấy cách làm điều đó.

Nghiêm túc , 17 14 11 12 byte

Câu trả lời đầu tiên của tôi. Câu trả lời này được dựa trên câu trả lời MATL Luis Mendo của và ý tưởng rằng đạo hàm số học của một số mtương đương với nơi là mỗi yếu tố chính của để đa dạng. Bổ sung của tôi là lưu ý rằng, nếu , sau đó . Cảm ơn Mego đã chơi golf và sửa lỗi. Hãy thử trực tuyến!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 byte

ÒU©a k £/X

- 6 byte nhờ @Shaggy

Hãy thử trực tuyến!

APL (Dyalog kéo dài) , 13 9 byte

Một giải pháp đơn giản. Phiên bản Dyalog Unicode đơn giản là phiên bản dài hơn của bản này vì vậy nó đã bị bỏ qua.

Chỉnh sửa: Đã lưu 4 byte bằng cách áp dụng phương thức trong giải pháp Jelly của lirtosiast .

{+/⍵÷⍭|⍵}

Hãy thử trực tuyến!

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 byte

Câu trả lời này được dựa trên câu trả lời MATL Luis Mendo của , Python câu trả lời wythagoras của , và ý tưởng rằng đạo hàm số học của một số mbằngm·(1/p1 + 1/p2 + ... + 1/pn) nơi là mỗi yếu tố chính của để đa dạng.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}

Hàm này được gọi theo cách sau:

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

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

Đây là một hàm ẩn danh chấp nhận một số nguyên và trả về một số float. Để gọi nó, gán nó cho một biến.

Đối với một số nguyên đầu vào n , nếu n ² 1 trả về 0. Nếu không, lấy hệ số nguyên tố của n ² là a Dict, sau đó với mỗi cặp số nguyên tố / số mũ, chia số nguyên tố cho số mũ của nó, sau đó chia n cho kết quả. Đây chỉ là tính toán n x / p , trong đó p là thừa số nguyên tố và x là số mũ của nó, giống như tính tổng n / p , x lần. Chúng tôi tổng hợp mảng kết quả và chia cho 2, vì chúng tôi đã tính tổng gấp đôi số lượng chúng tôi cần. Đó là do thực tế là chúng tôi bao thanh toán n ²hơn là n |.). (Làm điều đó là một byte ngắn hơn bao thanh toán | n

Đã lưu 29 byte nhờ Dennis!

Jolf, 13 byte

*jmauΜm)jd/1H

Kudos cho câu trả lời MATL cho thuật toán! Hãy thử nó ở đây , hoặc kiểm tra tất cả chúng cùng một lúc . (Đầu ra [key, out] trong một mảng.)

Giải trình

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

Toán học 10.0, 39 byte

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

APL (NARS), 35 char, 70 byte

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

kiểm tra và cách sử dụng:

  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

Tôi nghĩ rằng nó sẽ không ổn vì tôi không biết nếu biến c được tạo (và không phải là số nguyên tố) ... Nhưng có vẻ ổn cho bài kiểm tra ...

05AB1E , 7 4 byte

ÄÒ÷O

Cổng của câu trả lời Jelly của @lirtosiast .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

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

Sử dụng công thức (từ 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

Điều này có thể hơi chậm đối với số lượng lớn. Thay thế 2..^nbằng 2..n.sqrtmã dài hơn nhưng tính toán nhanh hơn.

Mực , 183 byte

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

Hãy thử trực tuyến!

Tôi từ chối tin rằng đây là một giải pháp tốt, nhưng tôi cũng không thể tìm ra cách cải thiện nó.

Pari / GP , 45 byte

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

Hãy thử trực tuyến!