Pour un entier positifn avec la factorisation en nombres premiers n = p1^e1 * p2^e2 * ... pk^ekoù p1,...,pksont des nombres premiers et e1,...,eksont des entiers positifs, nous pouvons définir deux fonctions:

• Ω(n) = e1+e2+...+ekle nombre de diviseurs premiers (compté avec la multiplicité) ( A001222 )
  • ω(n) = kle nombre de diviseurs premiers distincts. ( A001221 )

Avec ces deux fonctions, nous définissons l' excédent e(n) = Ω(n) - ω(n) ( A046660 ). Cela peut être considéré comme une mesure de la proximité d'un nombre sans carré.

Défi

Pour un nretour entier positif donné e(n).

Exemples

Car n = 12 = 2^2 * 3nous avons Ω(12) = 2+1et ω(12) = 2et donc e(12) = Ω(12) - ω(12) = 1. Pour tout numéro sans ncarré que nous avons de manière évidente e(n) = 0. Les premiers termes sont

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

Quelques détails supplémentaires dans le wiki OEIS.

MATL , 7 5 octets

Yfd~s

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

$pPd:Pr:la-

Essayez-le en ligne!

Explication

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

PrimeOmega@#-PrimeNu@#&

Très ennuyeux. FactorIntegerprend déjà 13 octets, et je ne vois pas grand-chose qui puisse être fait avec les 10 autres.

Gelée , 5 octets

ÆfI¬S

Essayez-le en ligne!

Vérifiez tous les cas de test.

Réponse de Port de Luis Mendo en 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 octets

Òg¹fg-

Explication

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

Essayez-le en ligne!

J, 11 10 octets

1 octet enregistré grâce à Jonah .

1#.1-~:@q:

Pyth, 7 octets

-lPQl{P

Essayez-le en ligne.

C, 74 octets

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

Python 2, 57 56 octets

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

Merci à @JonathanAllan d'avoir joué au golf sur 1 octet!

Testez-le sur Ideone .

Haskell, 65 octets

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

Ò¥_O

Port de la réponse MATL de @LuisMendo .

Essayez-le en ligne ou vérifiez les 15 premiers cas de test .

Explication:

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

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

La plupart du code est repris par une version golfée de cette réponse SO , qui stocke les facteurs premiers de l'entrée dans f. Ensuite, nous utilisons simplement la manipulation d'ensemble pour calculer les facteurs excédentaires.

Merci à Leaky Nun d'avoir économisé 1 3 octets!

Brachylog , 11 octets

$p@b:la:-a+

Essayez-le en ligne!

Vérifiez tous les cas de test. (Le wrapper est plus long que la fonction ...)

$p@b:la:-a+

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

SILOS , 113 octets

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

Essayez-le en ligne!

Un port de ma réponse en C .

Javascript (ES6), 53 51 46 octets

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

5 octets enregistrés grâce à Neil

Exemple:

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 octets

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

Programme complet, avec entrée $1et sortie sur sortie standard.

Nous allons IFScommencer par une nouvelle ligne, de sorte que l'extension "${f[*]}"soit séparée par une nouvelle ligne. Nous utilisons la substitution arithmétique pour imprimer la différence entre le nombre de mots dans la factorisation avec le résultat du filtrage uniq. Le nombre lui-même est imprimé en tant que préfixe par factor, mais il est également présent après le filtrage, il tombe donc dans la soustraction.

Python, (avec sympy) 66 octets

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

sympy.factorintrenvoie un dictionnaire avec des facteurs comme clés et leurs multiplicités comme valeurs, donc la somme des valeurs est Ω(n)et le nombre de valeurs est ω(n), donc la somme des valeurs décrémentées est ce que nous voulons.

CJam, 11 octets

ri_mf,\mF,-

Essayez-le en ligne!

Explication

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

Au début, il y a l'instruction goto ... même si elle est plus longue que la vôtre, elle est plus lisible et juste [si je ne considère pas n trop grand ...] une langue qui a 10000 fonctions de bibliothèque est pire qu'une langue qu'avec peu, 20 ou 30 fonctions de bibliothèque peuvent faire mieux [parce qu'on ne se souvient pas de toutes ces fonctions]

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

(dont +1 pour le -rdrapeau)

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

Entrée en décimal, sur stdin; sortie en unaire, sur sortie standard.

Explication

#!/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 caractères, 70 octets

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

la fonction π trouve la factorisation en nombre premier de son argument; il y a peu de choses à dire, cela semble clair, mais pour moi, il y a plus d'opérations (de factorisation) que le minimum ... la plage de caractères de comptage est hors des langues de golf car cela semble trop compter, mais moins que les langues de golf ... tester:

  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