Похідна функції є наріжним каменем математики, техніки, фізики, біології, хімії та великої кількості інших наук. Сьогодні ми будемо обчислювати щось тільки тангенціально пов'язане: арифметичну похідну.

Визначення

Арифметична похідна 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 байт

-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 байт

Любіть неявний вклад! Слід зрівняти його нарівні з Jelly для більшості речей (за винятком навичок у гольфі Денніса).

*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 байт

Моя перша в історії серйозна відповідь. Ця відповідь ґрунтується на 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

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 байт

ÒU©a k £/X

- 6 байт завдяки @Shaggy

Спробуйте в Інтернеті!

APL (Dyalog Extended) , 13 9 байт

Просте рішення. Версія Dyalog Unicode була просто довшою версією, тому вона була опущена.

Редагувати: Збережено 4 байти, застосувавши метод у розчині желе ліртосіаста .

{+/⍵÷⍭|⍵}

Спробуйте в Інтернеті!

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.

Рубі, 87 66 80 75 70 68 байт

Ця відповідь заснований на MATL відповідь Луїса Mendo в , Python відповідь wythagoras ігровий , і ідею про те , що арифметична похідною від числа 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

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

Юлія, 72 43 байти

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

Це анонімна функція, яка приймає ціле число і повертає поплавок. Щоб викликати його, призначте його змінній.

Для вхідного цілого числа n , якщо n ² ≤ 1 повернемо 0. В іншому випадку отримайте просту множину n ² як a Dict, то для кожної пари простих / експонентів ділимо просте число на його показник, а потім ділимо n за результатом. Це просто обчислення n x / p , де p - основний коефіцієнт, а x - його показник, такий же, як підсумовування n / p , x разів. Ми підсумовуємо отриманий масив і ділимо його на 2, оскільки ми підсумували вдвічі більше, ніж нам потрібно. Це пов’язано з тим, що ми факторингу n, ² а нен . (Виконання цього байту коротше, ніж факторинг | n |.)

Збережено 29 байт завдяки Деннісу!

Джольф, 13 байт

*jmauΜm)jd/1H

Кудо на відповідь MATL за алгоритм! Спробуйте тут , або перевірити їх все відразу . (Виводить [ключ, вихід] у масив.)

Пояснення

*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 «s 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).

Перл 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])

Спробуйте в Інтернеті!