मुख्य कारक के साथ एक सकारात्मक पूर्णांक 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। पहले कुछ शब्द हैं

OEIS विकी में कुछ और विवरण।

— flawr
स्रोत

1

शायद स्पष्ट है कि ^शक्ति है

— लुइस मेंडो

5

मेरी राय में यह आवश्यक नहीं है। यह प्रतीक यहां और पूरे इंटरनेट पर, साथ ही साथ कई कैलकुलेटर और कई प्रोग्रामिंग भाषाओं में उपयोग किया जाता है।

— दोष

7

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

— लुइस मेंडो
स्रोत

मुझे पता नहीं था कि factorMATL में काम कैसे होता है, वास्तव में अच्छा =)

— त्रुटिपूर्ण

@flawr क्या आपका मतलब है YF(कोड के 7-बाइट संस्करण में) या Yf(5-बाइट)? उत्तरार्द्ध MATLAB में है

— लुइस मेंडो

1

घातांक के लिए फ़ंक्शन, 5 बाइट अब और भी अधिक चतुर है =)

— दोष

6

ब्रेकीलॉग , 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

— Fatalize
स्रोत

6

गणितज्ञ, २३ बाइट्स

PrimeOmega@#-PrimeNu@#&

बहुत उबाऊ। FactorIntegerपहले से ही 13 बाइट्स लगते हैं, और मैं शेष 10 के साथ बहुत कुछ नहीं देख सकता।

— u54112
स्रोत

4

जेली , 5 बाइट्स

ÆfI¬S

इसे ऑनलाइन आज़माएं!

सभी टेस्टकेस को सत्यापित करें।

पोर्ट ऑफ Matl में लुइस Mendo के जवाब ।

Æ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

— लीक नन
स्रोत

पिछले दृष्टिकोण के लिए, ÆF’SṪमुझे लगता है कि काम किया होगा

— Sp3000

@ Sp3000 आपको पोस्ट करना चाहिए कि

— लीक

@LeakyNun मैं इसे स्वयं पोर्ट करने की कोशिश कर रहा था, लेकिन ¬मुझे भ्रमित करने की परिभाषा । मुझे यह पता नहीं था कि

— लुइस मेंडो

@LuisMendo वास्तव में जेली डॉक्स गड़बड़ हैं।

— लीकेज नन

3

05AB1E , 6 बाइट्स

Òg¹fg-

व्याख्या

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

इसे ऑनलाइन आज़माएं!

— Emigna
स्रोत

3

जे, 11 10 बाइट्स

जोनाह को 1 बाइट धन्यवाद दिया ।

1#.1-~:@q:

— alephalpha
स्रोत

1

1#.1-~:@q:10 बाइट्स के लिए। ~:btw का उपयोग कर अच्छा विचार है ।

— जोनाह

2

अजगर, 7 बाइट्स

-lPQl{P

इसे ऑनलाइन आज़माएं।

— orlp
स्रोत

2

सी, 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;}

Ideone यह!

— लीक नन
स्रोत

2

पायथन 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]

1 बाइट को बंद करने के लिए @JonathanAllan को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

आह अच्छा - आप का उपयोग करके एक बाइट बचा सकते हैंn/k%k<1

— जोनाथन एलन

ठीक है, n पहले से ही उस बिंदु पर k द्वारा विभाज्य है । धन्यवाद!

— डेनिस

2

हास्केल, 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

— डेमियन
स्रोत

यदि वह एक कार्य है: इनपुट चर कौन है? आउटपुट कौन है? धन्यवाद u ...

— RosLuP

(%) 3 इनपुट चर लेता है: एक संचायक (c), एक पूर्णांक (x) और एक पूर्णांक (n)। यह (n) की अधिकता लौटाता है जब c 0 और x से 2 पर सेट होता है। इसलिए (0% 2) एक आंशिक फ़ंक्शन है जो n लेता है और इसकी अतिरिक्त राशि लौटाता है

— डेमियन

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)

— केविन क्रूज़सेन
स्रोत

1

पायथन 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। फिर हम अतिरिक्त कारकों की गणना करने के लिए बस सेट हेरफेर का उपयोग करते हैं।

1 3 बाइट बचाने के लिए लीक नून को धन्यवाद !

— तांबा
स्रोत

1

ब्रेकीलॉग , 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

— लीक नन
स्रोत

1

एसआईओएस , 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

इसे ऑनलाइन आज़माएं!

सी में मेरे जवाब का एक बंदरगाह ।

— लीक नन
स्रोत

तो पिटाई के इतने करीब :(

— रोहन झुनझुनवाला

1

जावास्क्रिप्ट (ईएस 6), 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(','));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

आप rपुनरावर्ती गणना करके 5 बाइट्स बचा सकते हैं f=(n,i=2)=>i<n?n%i?f(n,i+1):f(n/=i,i)+!(n%i):0:।

— नील

1

बैश, 77 बाइट्स

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

पूरा कार्यक्रम, इनपुट $1और आउटपुट के साथ stdout में।

हम IFSएक नई लाइन के साथ शुरू करने के लिए सेट करते हैं, ताकि विस्तार "${f[*]}"न्यूलाइन-अलग हो जाए। हम फ़िल्टरिंग के परिणाम के साथ गुणन में शब्दों की संख्या के बीच के अंतर को मुद्रित करने के लिए अंकगणितीय प्रतिस्थापन का उपयोग करते हैं uniq। संख्या स्वयं द्वारा उपसर्ग के रूप में मुद्रित की जाती है factor, लेकिन यह फ़िल्टर करने के बाद भी मौजूद होती है, इसलिए घटाव में बाहर आती है।

— टोबी स्पाईट
स्रोत

0

अजगर, (सिम्पी के साथ) 66 बाइट्स

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

sympy.factorintमूल्यों के रूप में कारकों और उनके गुणकों के साथ एक शब्दकोश लौटाता है, इसलिए मूल्यों का योग है Ω(n)और मूल्यों की संख्या है ω(n), इसलिए घटे हुए मूल्यों का योग वही है जो हम चाहते हैं।

— जोनाथन एलन
स्रोत

0

सीजेएम, 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

— बिजनेस कैट
स्रोत

0

सी, 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;}

शुरुआत में गोटो इंस्ट्रक्शन है ... भले ही यह आपकी तुलना में अधिक लंबा हो, यह अधिक पठनीय और सही है [अगर मैं एन को बहुत बड़ा नहीं मानता हूं ...] एक भाषा जिसमें 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]
 */

— RosLuP
स्रोत

0

GNU sed + coreutils, 55 बाइट्स

( -rझंडे के लिए +1 सहित )

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

स्टड पर दशमलव में इनपुट; उत्पादन में unary, 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/

— टोबी स्पाईट
स्रोत

0

एपीएल (एनएआरएस) 35 चार्ट, 70 बाइट्स

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

फ़ंक्शन the इसके तर्क के प्रमुख में गुणनखंड ज्ञात करें; यह कहने के लिए कुछ है कि यह स्पष्ट प्रतीत होता है, लेकिन मेरे लिए न्यूनतम से अधिक संचालन (कारक से) करता है ... गिनती वर्णों की श्रेणी गोल्फ भाषाओं से बाहर है क्योंकि यह बहुत अधिक गिनती लगती है, लेकिन गोल्फ भाषाओं से कम नहीं ... परीक्षा:

  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

— RosLuP
स्रोत

अत्यधिक घुसपैठियों

चुनौती

उदाहरण

MATL , 7 5 बाइट्स

व्याख्या

ब्रेकीलॉग , 11 बाइट्स

व्याख्या

गणितज्ञ, २३ बाइट्स

जेली , 5 बाइट्स

05AB1E , 6 बाइट्स

जे, 11 10 बाइट्स

अजगर, 7 बाइट्स

सी, 74 बाइट्स

पायथन 2, 57 56 बाइट्स

हास्केल, 65 बाइट्स

05AB1E , 4 बाइट्स

पायथन 2, 100 99 98 96 बाइट्स

ब्रेकीलॉग , 11 बाइट्स

एसआईओएस , 113 बाइट्स

जावास्क्रिप्ट (ईएस 6), 53 51 46 बाइट्स

बैश, 77 बाइट्स

अजगर, (सिम्पी के साथ) 66 बाइट्स

सीजेएम, 11 बाइट्स

GNU sed + coreutils, 55 बाइट्स

व्याख्या

एपीएल (एनएआरएस) 35 चार्ट, 70 बाइट्स