함수의 미분은 수학, 공학, 물리, 생물학, 화학 및 기타 여러 과학의 초석입니다. 오늘 우리는 접선 적으로 관련된 것, 즉 산술 도함수를 계산할 것입니다.

정의

산술 도함수 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 와 | a |> 1로 설정하고 | | 수 f를 ₍₁₎ , ..., F _{, N} . 다음 원하는 결과는 · (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

파이썬, 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.

여기에서 시도 하십시오 .

파이썬 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되어 동일한 a시간의 소인수의 역수의 합 a. 1의 소인수의 역수의 합이 0이므로 1에 대한 예외는 필요하지 않습니다.

하스켈, 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 자

3자를 잘라낸 @Dennis 에게 감사합니다 .

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 바이트

암시 적 입력을 사랑하십시오! 대부분의 경우 젤리와 동등한 수준으로 가져와야합니다 (Dennis의 골프 기술 제외).

*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

하스켈, 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동일하다는 아이디어를 기반으로 합니다. 내 경우 에는 . 골프와 버그 수정에 도움 을 주신 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 유니 코드 버전은 이보다 더 긴 버전이므로 생략되었습니다.

편집 : 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 바이트

이 답변은 Luis Mendo의 MATL answer , wythagoras의 Python answer , 그리고 숫자의 산술 도함수 가 다중성 의 모든 주요 요소가 어디에 있는지와 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 ² ≤ 1 이면 0을 반환합니다. 그렇지 않으면 n ^2의 소인수 분해 를 a로 얻은 Dict다음 각 소수 / 지수 쌍에 대해 소수를 지수로 나눈 다음 n 을 결과 로 나눕니다 . 이것은 n x / p를 계산하는 것입니다 . 여기서 p 는 주요 요소이고 x 는 지수입니다. 이는 n / p 를 x 곱하는 것과 같습니다 . 필요한 배열의 두 배를 합산했기 때문에 결과 배열을 합산하고 2로 나눕니다. 그것은 우리가 n ^2를 인수 분해한다는 사실에 기인합니다.n 보다 . (이것은 factoring | n | 보다 짧은 바이트 입니다.)

Dennis 덕분에 29 바이트를 절약했습니다!

줄프, 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 의 젤리 답변 포트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

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

펄 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])

온라인으로 사용해보십시오!