对于具有素数分解的正整数n，n = p1^e1 * p2^e2 * ... pk^ek其中p1,...,pk素数和e1,...,ek正整数，我们可以定义两个函数：

• Ω(n) = e1+e2+...+ek主除数的数量（乘以倍数）（A001222）
  • ω(n) = k不同的素数除数。（A001221）

通过这两个功能，我们定义了多余的部分 e(n) = Ω(n) - ω(n)（A046660）。可以认为这是一个数字与无平方的接近程度的度量。

挑战

对于给定的正整数，n返回e(n)。

例子

对于n = 12 = 2^2 * 3我们有Ω(12) = 2+1和ω(12) = 2，因此e(12) = Ω(12) - ω(12) = 1。对于任何无平方数，n我们都非常清楚e(n) = 0。前几个词是

1       0
2       0
3       0
4       1
5       0
6       0
7       0
8       2
9       1
10      0
11      0
12      1
13      0
14      0
15      0

OEIS Wiki中有更多详细信息。

MATL，7 5字节

Yfd~s

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

说明

Yf    % Implicit input. Obtain prime factors, sorted and with repetitions
d     % Consecutive differences
~     % Logical negate: zeros become 1, nonzeros become 0
s     % Sum. Implicit display

Brachylog，11个字节

$pPd:Pr:la-

在线尝试！

说明

$pP            P is the list of prime factors of the Input
  Pd           Remove all duplicates in P
    :Pr        Construct the list [P, P minus duplicates]
       :la     Apply "length" to the two elements of that list
          -    Output is the subtraction of the first element by the second one

Mathematica，23个字节

PrimeOmega@#-PrimeNu@#&

很无聊。FactorInteger已经占用了13个字节，剩下的10个字节我看不出有什么可以做的。

果冻，5个字节

ÆfI¬S

在线尝试！

验证所有测试用例。

港路易斯Mendo在MATL答案。

ÆfI¬S

Æf     Implicit input. Obtain prime factors, sorted and with repetitions
  I    Consecutive differences
   ¬   Logical negate: zeros become 1, nonzeros become 0
    S  Sum. Implicit display

05AB1E，6个字节

Òg¹fg-

说明

Òg      # number of prime factors with duplicates
     -  # minus
  ¹fg   # number of prime factors without duplicates

在线尝试！

J，11 10字节

由于乔纳（Jonah），节省了1个字节。

1#.1-~:@q:

Pyth，7个字节

-lPQl{P

在线尝试。

C，74字节

f(n,e,r,i){r=0;for(i=2;n>1;i++,r+=e?e-1:e)for(e=0;n%i<1;e++)n/=i;return r;}

伊迪恩！

Python 2，57 56字节

f=lambda n,k=2:n/k and[f(n,k+1),(n/k%k<1)+f(n/k)][n%k<1]

感谢@JonathanAllan打高尔夫球1个字节！

在Ideone上进行测试。

Haskell，65个字节

(c%x)n|x>n=c|mod n x>0=c%(x+1)$n|y<-div n x=(c+0^mod y x)%x$y
0%2

05AB1E，4 个字节

Ò¥_O

@LuisMendo的MATL答案端口。

在线尝试或验证前15个测试用例。

说明：

Ò       # Get all prime factors with duplicates from the (implicit) input
        # (automatically sorted from lowest to highest)
 ¥      # Get all deltas
  _     # Check if it's equal to 0 (0 becomes 1; everything else becomes 0)
   O    # Take the sum (and output implicitly)

Python 2中，100个 99 98 96字节

n=input()
i=2
f=[]
while i<n:
 if n%i:i+=1
 else:n/=i;f+=i,
if-~n:f+=n,
print len(f)-len(set(f))

该SO答案的修订版本占用了大部分代码，该代码将输入的主要因素存储在f。然后，我们仅使用集合操作来计算多余因子。

感谢Leaky Nun节省1 3个字节！

Brachylog，11个字节

$p@b:la:-a+

在线尝试！

验证所有测试用例。（包装器比函数长...）

$p@b:la:-a+

$p            prime factorization
  @b          group blocks of equal elements
    :la       length of each
       :-a    each minus 1
          +   sum

SILOS，113个字节

readIO
t=2
lbla
e=0
GOTO b
lblc
i/t
e+1
lblb
m=i
m%t
n=1
n-m
if n c
d=e
d/d
e-d
r+e
A=i
A-1
t+1
if A a
printInt r

在线尝试！

我用C语言回答的内容。

Javascript（ES6），53 51 46字节

e=(n,i=2)=>i<n?n%i?e(n,i+1):e(n/=i,i)+!(n%i):0

由于尼尔节省了5个字节

例：

e=(n,i=2)=>i<n?n%i?e(n,i+1):e(n/=i,i)+!(n%i):0

// computing e(n) for n in [1, 30]
for(var n = 1, list = []; n <= 30; n++) {
  list.push(e(n));
}
console.log(list.join(','));

Bash，77个字节

IFS=$'\n '
f=(`factor $1`)
g=(`uniq<<<"${f[*]}"`)
echo $((${#f[*]}-${#g[*]}))

完整的程序，带有输入$1和输出到stdout。

我们IFS将从换行开始，以便扩展用"${f[*]}"换行分隔。我们使用算术替换来打印因式分解中的单词数之间的差，并通过过滤结果uniq。数字本身由标记为前缀factor，但在过滤后也存在，因此会在减法中掉落。

Python，（含sympy）66个字节

import sympy;lambda n:sum(x-1for x in sympy.factorint(n).values())

sympy.factorint返回一个以因子为键，其乘数为值的字典，因此值的总和为，值Ω(n)的个数为ω(n)，因此递减值的总和就是我们想要的。

CJam，11个字节

ri_mf,\mF,-

在线尝试！

说明

ri_         Get an integer from input and duplicate it
   mf,      Get the number of prime factors (with repetition)
      \     Swap top 2 elements on the stack
       mF,  Get the number of prime factors (with exponents)
          - Subtract

C，158

#define G(a,b) if(a)goto b
#define R return
f(n,i,j,o,w){if(!n)R 0;o=w=i=j=0;a:i+=2;b:if(n%i==0){++j;G(n/=i,b);}o+=!!j;w+=j;i+=(i==2);j=0;G(i*i<n,a);R w-o;}

首先，有一个goto指令...即使比您的指令更长，它也更具可读性和正确性[如果我考虑的范围不大...]一种具有10000个库函数的语言比一种语言更糟糕很少有20或30个库函数可以做的更好[因为我们不记得所有这些函数]

#define F for
#define P printf

main(i,r)
{F(i=0; i<100; ++i)
   r=f(i,0,0,0,0),P("[%u|%u]",i,r);
 R  0;
}

/*
 158
 [0|0][1|0][2|0][3|0][4|1][5|0][6|0][7|0][8|2]
 [9|0][10|0][11|0][12|1][13|0][14|0][15|0][16|3]
 [17|0][18|0][19|0][20|1][21|0][22|0][23|0][24|2][25|1][26|0][27|0] [28|1]
 [29|0][30|0][31|0][32|4][33|0][34|0][35|0][36|1]
 [37|0][38|0][39|0][40|2][41|0]
 */

GNU sed + coreutils，55个字节

（包括+1 -r）

s/^/factor /e
s/ ([^ ]+)(( \1)*)/\2/g
s/[^ ]//g
y/ /1/

在标准输入上以十进制输入；在stdout上以一元输出。

说明

#!/bin/sed -rf

# factor the number
s/^/factor /e
# remove first of each number repeated 0 or more times
s/ ([^ ]+)(( \1)*)/\2/g
# count just the spaces
s/[^ ]//g
y/ /1/

APL（NARS）35个字符，70个字节

{⍵=1:0⋄k-⍨+/+/¨{w=⍵⊃v}¨⍳k←≢v←∪w←π⍵}

函数π以其参数的素数求因式分解；几乎没有什么好说的，但是对我来说（因数分解）比最小操作更多...计数字符的范围超出了高尔夫语言的范围，因为它看起来太多了，但比不上高尔夫语言要少...测试：

  f←{⍵=1:0⋄k-⍨+/+/¨{w=⍵⊃v}¨⍳k←≢v←∪w←π⍵}
  f¨1..15
0 0 0 1 0 0 0 2 1 0 0 1 0 0 0