Per un numero intero positivon con la scomposizione n = p1^e1 * p2^e2 * ... pk^ekin fattori primi dove p1,...,pksono numeri primi e e1,...,eknumeri interi positivi, possiamo definire due funzioni:

• Ω(n) = e1+e2+...+ekil numero di divisori primi (contati con molteplicità) ( A001222 )
  • ω(n) = kil numero di divisori primi distinti. ( A001221 )

Con queste due funzioni definiamo l' eccesso e(n) = Ω(n) - ω(n) ( A046660 ). Questo può essere considerato come una misura di quanto è vicino un numero a essere quadrato libero.

Sfida

Per un dato nritorno intero positivo e(n).

Esempi

Perché n = 12 = 2^2 * 3abbiamo Ω(12) = 2+1e ω(12) = 2e quindi e(12) = Ω(12) - ω(12) = 1. Per ogni numero nquadrato che abbiamo ovviamente e(n) = 0. I primi termini sono

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

Alcuni dettagli in più nel wiki di OEIS.

MATL , 7 5 byte

Yfd~s

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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 byte

$pPd:Pr:la-

Provalo online!

Spiegazione

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

PrimeOmega@#-PrimeNu@#&

Molto noioso. FactorIntegeroccupa già 13 byte e non riesco a vedere molto che si possa fare con i restanti 10.

Gelatina , 5 byte

ÆfI¬S

Provalo online!

Verifica tutti i test.

La risposta di Port of Luis Mendo in 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 byte

Òg¹fg-

Spiegazione

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

Provalo online!

J, 11 10 byte

Salvato 1 byte grazie a Giona .

1#.1-~:@q:

Pyth, 7 byte

-lPQl{P

Provalo online.

C, 74 byte

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;}

Ideone esso!

Python 2, 57 56 byte

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

Grazie a @JonathanAllan per il golf off 1 byte!

Provalo su Ideone .

Haskell, 65 byte

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

Ò¥_O

Porto di @LuisMendo MATL risposta s' .

Provalo online o verifica i primi 15 casi di test .

Spiegazione:

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

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

Gran parte del codice è ripreso da una versione golfata di questa risposta SO , che memorizza i fattori primi dell'input f. Quindi usiamo semplicemente la manipolazione impostata per calcolare i fattori in eccesso.

Grazie a Leaky Nun per aver salvato 1 3 byte!

Brachylog , 11 byte

$p@b:la:-a+

Provalo online!

Verifica tutti i test. (Il wrapper è più lungo della funzione ...)

$p@b:la:-a+

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

SILOS , 113 byte

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

Provalo online!

Una porta della mia risposta in C .

Javascript (ES6), 53 51 46 byte

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

5 byte salvati grazie a Neil

Esempio:

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 byte

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

Programma completo, con input in $1e output su stdout.

Abbiamo impostato IFSper cominciare una nuova riga, in modo che l'espansione "${f[*]}"è newline separati. Usiamo la sostituzione aritmetica per stampare la differenza tra il numero di parole nella fattorizzazione con il risultato del filtraggio uniq. Il numero stesso viene stampato come prefisso da factor, ma è presente anche dopo il filtraggio, quindi cade nella sottrazione.

Python, (con sympy) 66 byte

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

sympy.factorintrestituisce un dizionario con fattori come chiavi e le loro molteplicità come valori, quindi la somma dei valori è Ω(n)e il numero di valori è ω(n), quindi la somma dei valori decrementati è ciò che vogliamo.

CJam, 11 byte

ri_mf,\mF,-

Provalo online!

Spiegazione

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;}

All'inizio c'è l'istruzione goto ... anche se questa è più lunga della tua è più leggibile e giusta [se non considero n troppo grande ...] una lingua che ha 10000 funzioni di libreria è più semplice di una lingua che con poche, 20 o 30 funzioni di libreria può fare tutto meglio [perché non possiamo ricordare tutte queste funzioni]

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

(incluso +1 per la -rbandiera)

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

Immissione in decimale, su stdin; uscita in unario, su stdout.

Spiegazione

#!/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 caratteri, 70 byte

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

la funzione π trova la fattorizzazione in primo piano del suo argomento; c'è poco da dire che sembra chiaro, ma per me fa più operazioni (dalla fattorizzazione) rispetto al minimo ... la gamma di caratteri di conteggio è fuori dalle lingue del golf perché sembra contare troppo, ma meno delle lingue da golf ... test:

  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