Für eine positive ganze Zahl nmit der Primfaktorisierung, n = p1^e1 * p2^e2 * ... pk^ekbei der p1,...,pkes sich um Primzahlen und e1,...,ekpositive ganze Zahlen handelt, können zwei Funktionen definiert werden:

• Ω(n) = e1+e2+...+ekdie Anzahl der Primteiler (gezählt mit der Multiplizität) ( A001222 )
  • ω(n) = kdie Anzahl der unterschiedlichen Primteiler. ( A001221 )

Mit diesen beiden Funktionen definieren wir den Überschuss e(n) = Ω(n) - ω(n) ( A046660 ). Dies kann als Maß dafür angesehen werden, wie nahe eine Zahl an der Quadratfreiheit ist.

Herausforderung

Für eine gegebene positive Ganzzahl wird nzurückgegeben e(n).

Beispiele

Denn n = 12 = 2^2 * 3wir haben Ω(12) = 2+1und ω(12) = 2und deshalb e(12) = Ω(12) - ω(12) = 1. Für jede quadratische Zahl haben nwir offensichtlich e(n) = 0. Die ersten Begriffe sind

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

Weitere Details im OEIS-Wiki.

MATL , 7 5 Bytes

Yfd~s

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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 Bytes

$pPd:Pr:la-

Probieren Sie es online!

Erläuterung

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

PrimeOmega@#-PrimeNu@#&

Sehr langweilig. FactorIntegernimmt bereits 13 Bytes ein und ich kann nicht viel sehen, das mit den restlichen 10 getan werden kann.

Gelee , 5 Bytes

ÆfI¬S

Probieren Sie es online!

Überprüfen Sie alle Testfälle.

Port von Luis Mendos Antwort 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 Bytes

Òg¹fg-

Erläuterung

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

Probieren Sie es online!

J, 11 10 Bytes

Dank Jonah 1 Byte gespeichert .

1#.1-~:@q:

Pyth, 7 Bytes

-lPQl{P

Probieren Sie es online aus.

C 74 Bytes

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 es!

Python 2, 57 56 Bytes

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

Vielen Dank an @JonathanAllan für das Abschlagen von 1 Byte!

Teste es auf Ideone .

Haskell, 65 Bytes

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

Ò¥_O

Port der MATL -Antwort von @LuisMendo .

Probieren Sie es online aus oder überprüfen Sie die ersten 15 Testfälle .

Erläuterung:

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

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

Der größte Teil des Codes wird von einer Golf-Version dieser SO-Antwort aufgenommen , in der die Primfaktoren der Eingabe gespeichert sind f. Dann verwenden wir einfach die Mengenmanipulation, um die überschüssigen Faktoren zu berechnen.

Vielen Dank an Leaky Nun für das Speichern von 1 bis 3 Bytes!

Brachylog , 11 Bytes

$p@b:la:-a+

Probieren Sie es online!

Überprüfen Sie alle Testfälle. (Der Wrapper ist länger als die Funktion ...)

$p@b:la:-a+

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

SILOS , 113 Bytes

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

Probieren Sie es online!

Ein Port meine Antwort in C .

Javascript (ES6), 53 51 46 Bytes

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

5 Bytes gespart dank Neil

Beispiel:

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 Bytes

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

Komplettes Programm mit Ein- $1und Ausgabe auf stdout.

Wir IFSbeginnen mit einem Zeilenumbruch, damit die Erweiterung durch "${f[*]}"Zeilenumbrüche getrennt wird. Wir verwenden die arithmetische Substitution, um die Differenz zwischen der Anzahl der Wörter in der Faktorisierung und dem Ergebnis des Durchfilterns auszudrucken uniq. Die Zahl selbst wird als Präfix von gedruckt factor, ist aber auch nach dem Filtern vorhanden, fällt also bei der Subtraktion heraus.

Python (mit Sympy) 66 Bytes

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

sympy.factorintGibt ein Wörterbuch mit Faktoren als Schlüssel und ihren Multiplizitäten als Werten zurück, also ist die Summe der Werte Ω(n)und die Anzahl der Werte ω(n), also ist die Summe der dekrementierten Werte das, was wir wollen.

CJam, 11 Bytes

ri_mf,\mF,-

Probieren Sie es online!

Erläuterung

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

Am Anfang gibt es die goto-Anweisung ... auch wenn diese länger ist als Ihre, ist sie lesbarer und korrekter [wenn ich sie nicht für zu groß halte ...]. Eine Sprache mit 10000 Bibliotheksfunktionen ist wrost als eine Sprache dass mit wenigen, 20 oder 30 Bibliotheksfunktionen alles besser geht [weil wir uns nicht alle diese Funktionen merken können]

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

(einschließlich +1 für -rFlagge)

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

Eingabe in dezimaler Schreibweise auf stdin; Ausgabe in unary, on stdout.

Erläuterung

#!/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 Zeichen, 70 Byte

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

die Funktion π findet die Faktorisierung in der Primzahl ihres Arguments; Es gibt nur wenige zu sagen, dass es klar erscheint, aber für mich werden mehr Operationen (aus der Faktorisierung) als das Minimum ausgeführt ... Der Bereich der Anzahl der Zeichen liegt außerhalb der Golfsprachen, weil es zu viel zu zählen scheint, aber weniger als keine Golfsprachen ... Prüfung:

  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