मोबियस समारोह

Question

मोबियस समारोह

Möbius फ़ंक्शन एक महत्वपूर्ण संख्या सिद्धांत है।

आपके सबमिशन को एक सकारात्मक पूर्णांक को स्वीकार करना चाहिए nऔर मोबीबियस फ़ंक्शन के मूल्यांकन का मूल्य वापस करना चाहिए n।

परिभाषा

Möbius फ़ंक्शन μ (n) को निम्नानुसार परिभाषित किया गया है:

       |  1 if n is squarefree and has an even number of distinct prime factors
μ(n) = | -1 if n is squarefree and has an odd number of distinct prime factors
       |  0 otherwise

nको वर्गफ्री कहा जाता है यदि n के मुख्य गुणनखण्ड के घातांक सभी कड़ाई से कम हैं जो दो हैं। (वैकल्पिक रूप से: दो विभाजनों की शक्ति का कोई अभिप्राय नहीं n)।

परीक्षण के मामलों

यहाँ आप μ के पहले 50 मान देख सकते हैं:

^{_{विकिपीडिया से सार्वजनिक डोमेन छवि}}

मोइसियस फ़ंक्शन OEIS में अनुक्रम संख्या A008683 है।

ये पहले 77 मान हैं:

1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0, -1, 0, 1, 1, -1, 0, 0, 1, 0, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, 1, 1, 0, -1, -1, -1, 0, 0, 1, -1, 0, 0, 0, 1, 0, -1, 0, 1, 0, 1, 1, -1, 0, -1, 1, 0, 0, 1, -1, -1, 0, 1, -1, -1, 0, -1, 1, 0, 0, 1

बड़े मूल्यों को भी आसानी से वुल्फरामाल्पा.कॉम या ओईआईएस की बी-फाइल में चेक किया जा सकता है , जैसा कि @ मार्टिनबटनर ने सुझाव दिया था।

Answer 1

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

m=lambda n,d=1:d%n and-m(d,n%d<1)+m(n,d+1)or 1/n

इससे पहले 51 बाइट संस्करण:

m=lambda n:1/n-sum(m(k)for k in range(1,n)if n%k<1)

Möbius- अनुक्रम को बदलता है 1,0,0,0,0...।

मॉबियस समारोह संपत्ति है कि किसी के लिए है n>1, के मॉबियस कार्यों nके divisors 0. तो करने के लिए योग, के लिए n>1, μ(n)की राशि को नकारने देकर की गई है μ(k)सभी उचित divisors के लिए kकी n। के लिए n=1, आउटपुट है 1।

कोड एक मंजिल-डिवीजन जोड़कर आधार मामले संभालती है 1/n, जो देता है 1के लिए n==1और 0अन्यथा।

इस चुनौती में एक समान संरचना से प्रेरित बेहतर पुनरावर्ती हैंडलिंग के साथ 3 बाइट्स को बचाने के लिए डेनिस के लिए धन्यवाद ।

Answer 2

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

कोड:

ÆF>1’PS

स्पष्टीकरण:

ÆF       # This computes the prime factorization as well as the exponent
  >1     # Compares each element if it's greater than 1, resulting in 1's and 0's
    ’    # Decrement on each element
     P   # Compute the product
      S  # Compute the sum of the list

उदाहरण के लिए, संख्या 10 :

ÆF       # [[2, 1], [5, 1]]
  >1     # [[1, 0], [1, 0]]
    ’    # [[0, -1], [0, -1]]
     P   # [0, 1]
      S  # 1

और 1 में परिणाम ।

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

Comments

-1 बाइट: ÆFỊNPS(सुनिश्चित नहीं है कि Ịएक अंतर्निहित बैक था, लेकिन अब ठीक होना चाहिए)।

— आउटगॉल्फ

Answer 3

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

MoebiusMu

बेशक, मैथेमेटिका में एक अंतर्निहित है। (और शायद वैसे भी जेली द्वारा पीटा जाएगा ।)

Answer 4

सीजाम, 18 15 बाइट्स

WrimFz~\1&+f/:*

तथ्य यह है कि सीजेएम फैक्टरिस बिल्डिंस में 1 लौटाता है, n = 1जो चीजों को थोड़ा मुश्किल बना देता है।

इसे ऑनलाइन आज़माएं | परीक्षण सूट

1&+1 केस को संभालने के लिए नीट ट्रिक के लिए @PeterTaylor को धन्यवाद ।

व्याख्या

W                 Push -1
 ri               Push input as int
   mF             Factorise input into [base exponent] pairs
     z~           Zip and unwrap pairs, leaving stack like [-1 bases exponents]
       \1&        Setwise intersect bases with 1, giving [1] for 1 and [] otherwise
          +       Append to exponent array
           f/     Divide the previously pushed -1 by each element in the array 
                  This gives -1 for 1s and 0 otherwise, since / is int division
             :*   Take product

के लिए n > 1, संशोधित सरणी सिर्फ घातांक सरणी है। यदि nवर्गफ्री है तो सरणी सभी 1s है, जो विभाजन के बाद सभी -1 s बन जाती है। अन्यथा, यदि n में एक मुख्य वर्ग विभाजक है, तो विभाजन के बाद कहीं 0 होगा, 0 का उत्पाद दे रहा है।

के लिए n = 1संशोधित सरणी है [1] + [1]जो हो जाता है, [-1 -1], विभाजन के बाद 1 का एक उत्पाद दे रही है।

---

वैकल्पिक 16:

rimF{1#2+3%(}%:*

यह #प्रत्येक [base exponent]सरणी पर 1 (1), फिर मानचित्रों को देखने के लिए उपयोग करता है -1 -> 0, 0 -> 1, 1 -> -1।

Answer 5

रूबी, 65 + 7 = 72 62 + 7 = 69 बाइट्स

->x{((d=x.prime_division).all?{|_,n|n<2}?1:0)*(d.size%2*-2+1)}

-rprimeझंडे के लिए +7 बाइट्स ।

हम इसे बहुत भोली तरह से कर रहे हैं:

->x{
 (
  (d=x.prime_division)  # ex. input 20 results in [[2,2],[5,1]] here
  .all?{|_,n|n<2}?      # are all factors' exponents under 2?
  1:0                   # if so, result in a 1; otherwise, a 0
 )
 *                      # multiply that 1 or 0 by...
  (d.size%2*-2+1)       # magic
}

"मैजिक" भाग 1 में परिणाम देता है यदि संख्या समान है और -1 अन्यथा। ऐसे:

Expression       Even  Odd
--------------------------
d.size%2         0     1
d.size%2*-2      0     -2
d.size%2*-2+1    1     -1

Answer 6

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

^_{IPQlPQ

स्पष्टीकरण:

^_{IPQlPQ    Implicit: Q=input
    PQ       Prime factorization of Q
  {I         Is invariant under uniquify.
  {IPQ       1 if Q is squarefree; 0 otherwise.
 _{IPQ       -1 if Q is squarefree; 0 otherwise.
^     lPQ    Exponentiation to length of PQ.

इसे यहाँ आज़माएँ ।

Answer 7

भूलभुलैया , 87 बाइट्स

1
:
}
?   @ "}){/{=:
""({! "      ;
} )   :}}:={%"
* _}}){     ;
{      #}):{{
")`%#/{+

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

संक्षिप्त व्याख्या

यहाँ पाइथन में प्रयुक्त एल्गोरिथ्म का एक पोर्ट है:

divisor = 1
mobius = 1
n = int(input())

while n != 1:
  divisor += 1
  count = 0

  while n % divisor == 0:
    n //= divisor
    count += 1

  mobius *= (count + 3)//(count + 1)%3*-1 + 1

print(mobius)

लंबी व्याख्या

भूलभुलैया पर सामान्य प्राइमर:

• लैब्रिंथ स्टैक-आधारित और दो-आयामी है, निष्पादन के साथ पहले मान्यता प्राप्त चरित्र पर शुरू होता है। दो स्टैक हैं, एक मुख्य स्टैक और एक सहायक स्टैक, लेकिन अधिकांश ऑपरेटर केवल मुख्य स्टैक पर काम करते हैं।
• भूलभुलैया की हर शाखा में, स्टैक के शीर्ष को यह निर्धारित करने के लिए जाँच किया जाता है कि आगे कहाँ जाना है। नेगेटिव लेफ्ट टर्न है, जीरो स्ट्रेट फॉरवर्ड है और पॉजिटिव टर्न राइट है।

इस कार्यक्रम के लिए निष्पादन शीर्ष-बाएं से शुरू होता है 1।

Outer preparation
=================

1        Pop 0 (stack is bottomless and filled with 0s) and push 0*10+1 = 1
:}       Duplicate and shift to auxiliary stack
?        Read int from input
         Stack is now [div=1 n | mob=1]

Top of stack positive but can't turn right. Turn left into outer loop.

Begin outer loop
================
Inner preparation
-----------------

(        Decrement top of stack

If top was 1 (and is now zero), move forward and do...
------------------------------------------------------

{!       Print mob
@        Terminate

If top of stack was greater than 1, turn right and do...
--------------------------------------------------------

)        Increment n back to its previous value
_}       Push 0 and shift to aux
         This will count the number of times n can be divided by div
}){      Increment div
         Stack is now [div n | count mob]

Inner loop
----------

:}}      Dup n, shift both n's to aux
:=       Dup div and swap top of main with top of aux
{%       Shift div down and take mod
         Stack is now [div n%div | n count mob]

If n%div == 0, move forward and do...
-----------------------------------

;        Pop n%div
:={/     Turn n into n/div
{)}      Increment count
         (continue inner loop)

If n%div != 0, turn right (breaking out of inner loop) and do...
================================================================

;        Pop n%div
{{       Pull n and count from aux
:)}      Dup and increment count, giving (count+1), and shift to aux
#+       Add length of stack to count, giving (count+3)
{/       Calculate (count+3)/(count+1)
#%       Mod by length of stack, giving (count+3)/(count+1)%3
`        Multiply by -1
)        Increment, giving (count+3)/(count+1)%3*-1 + 1
         This is 1 if count was 0, -1 if count was 1 and 0 if count > 1
{*}      Multiply mob by this number
         (continue outer loop)

Answer 8

CJam, 20 बाइट्स

rimf1-___&=\,2%!2*(*

इसे यहां इनपुट्स की एक सीमा के विरुद्ध चलाएं।

गोल्फ लगता है।

Comments

तथ्य यह है कि 1 में वापस आ गया है mfया mFवास्तव में दर्द होता है ...

— Sp3000

@ Sp3000 मुझे इसके बारे में बताएं :-(

— लुइस मेंडो

Answer 9

R 39 16 बाइट्स

numbers::moebius

आपको अपने सिस्टम पर इंस्टॉल किए गए नंबर पैकेज की आवश्यकता है ...

संपादित करें: अगर मैं ऐनक को उचित रूप से पढ़ता हूं तो बहुत आसान है [धन्यवाद @AlexA।]

Comments

यह 1 से इनपुट के लिए प्रत्येक पूर्णांक के लिए मूल्यांकन किए गए Möbius फ़ंक्शन को लौटाता है, लेकिन इस चुनौती के लिए कार्य इनपुट पर Möbius फ़ंक्शन का मूल्यांकन करना है।

— एलेक्स ए।

गणितज्ञ उत्तर की तर्ज पर, आप केवल numbers::moebius16 बाइट्स के लिए भी कर सकते हैं ।

— एलेक्स ए।

Answer 10

पायथ , 16 बाइट्स

?nl{PQlPQZ^_1lPQ

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

मेरा पहला वास्तविक पाइथ उत्तर। सुझावों की सराहना की! :)

व्याख्या

मेरा समाधान इस तथ्य का उपयोग करता है कि एक संख्या वर्गफ्री है, यदि इसके प्रमुख कारकों में एक से अधिक बार संख्या नहीं है। यदि इनपुट स्क्वायरफ्री है, मोबीस-फंक्शन मान -1 ^ (प्राइमफैक्टर्स की संख्या) लेता है।

?n        if not equal
  l{PQ      length of the list of the distinct input-Primefactors
  lPQ       length of the list of primefactors including duplicates    
    Z         Input is not squarefree, so output Zero
  ^_1lPQ  if input is squarefree, output -1^(number of prime-factors)

Answer 11

MATL , 15 17 बाइट्स

tq?YftdAwn-1w^*

यह भाषा / संकलक की वर्तमान रिलीज़ (10.1.0) का उपयोग करता है ।

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

व्याख्या

t         % implicit input. Duplicate that
q         % decrement by 1. Gives truthy (nonzero) if input exceeds 1
?         % if input exceeds 1, compute function. Otherwise leave 1 on the stack
  Yf      % vector of prime factors. Results are sorted and possibly repeated
  td      % duplicate and compute differences
  A       % true if all differences are nonzero
  w       % swap
  n       % number of elements in vector of prime factors, "x"
  -1w^    % -1^x: gives -1 if x odd, 1 if x even 
  *       % multiply by previously obtained true/false value, so non-square-free gives 0
          % implicitly end "if"
          % implicitly display stack contents

Answer 12

05AB1E , 8 बाइट्स, गैर-प्रतिस्पर्धात्मक

दमित, एक बार फिर एक बग जो मेरे सबमिशन को गैर-प्रतिस्पर्धी बनाता है। कोड:

.p0K1›<P

स्पष्टीकरण:

.p        # Get the prime factorization exponents
  0K      # Remove all zeroes from the list
    1›    # Compare each element if greater than 1
      <   # Decrement on each element
       P  # Take the product

CP-1252 एन्कोडिंग का उपयोग करता है

Comments

›ISO 8859-1 में नहीं है ...

— ETHproductions

@ETHproductions हे? फिर किस तरह की एन्कोडिंग है? मुझे यह इस साइट से मिला है ।

— अदनान

मेरा मानना ​​है कि इसे विस्तारित ASCII कहा जाता है ।

— 20

@ETHproductions धन्यवाद, मैंने पोस्ट को संपादित किया है :)

— अदनान

@ThomasKwa आह, मुझे मिल गया है। यह CP-1252 एन्कोडिंग है।

— अदनान

Answer 13

अजगर, ११

*{IPQ^_1lPQ

परीक्षण सूट

यह बूलियन मान को गुणा करता है यदि प्रमुख कारक -1संख्या के पास प्रमुख कारकों की शक्ति से वर्गफ्री हैं ।

Iपूर्ववर्ती ऑपरेटर पर एक चालानी जाँच है, जो यहाँ है {, जो अद्वितीय-ify ऑपरेटर है।

Answer 14

जाप, 21 बाइट्स

V=Uk)¬¥Vâ ¬?Vl v ªJ:0

इसे ऑनलाइन टेस्ट करें!

Answer 15

जूलिया, 66 बाइट्स

n->(f=factor(n);any([values(f)...].>1)?0:length(keys(f))%2>0?-1:1)

यह एक लंबोदर फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

Ungolfed:

function µ(n::Int)
    # Get the prime factorization of n as a Dict with keys as primes
    # and values as exponents
    f = factor(n)

    # Return 0 for non-squarefree, otherwise check the length of the list
    # of primes
    any([values(f)...] .> 1) ? 0 : length(keys(f)) % 2 > 0 ? -1 : 1
end

Answer 16

PARI / GP, 7 बाइट्स

moebius

दुखद möbiusउपलब्ध नहीं है। :)

Answer 17

गंभीरता से, 19 18 बाइट्स

,w;`iX1=`Mπ)l1&τD*

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

स्पष्टीकरण:

,w;`iXDY`Mπ)l1&τD*
,w;                push two copies of the full prime factorization of the input
                      (a list of [base, exponent] pairs)
   `    `M         map the following function:
    iX1=             flatten list, discard, equal to 1
                        (push 1 if exponent == 1 else 0)
          π)       product of list, push to bottom of stack
            1&     push 1 if the # of prime factors is even else 0
              τD   double and decrement (transform [0,1] to [-1,1])
                *  multiply

Answer 18

सी # (.NET कोर) , 86 73 72 65 बाइट्स

a=>{int b=1,i=1;for(;++i<=a;)b=a%i<1?(a/=i)%i<1?0:-b:b;return b;}

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

-13 बाइट्स: सुव्यवस्थित लूप्स, अतिरिक्त रिटर्न वैरिएबल ( केविन क्रूज़सेन के लिए धन्यवाद )
-1 बाइट: परिवर्तित सेटिंग बी को शून्य से एक त्रिगुट में अगर ( केविन क्रूज़सेन के लिए )
-7 बाइट्स: यदि लूप के लिए एक टर्नरी में बयान बदल गया ( पीटर टेलर और केविन क्रूज़सेन को धन्यवाद )

Ungolfed:

a => {
    int b = 1, i = 1;           // initialize b and i to 1

    for(; ++i <= a;)            // loop from 2 (first prime) to a
        b = a % i < 1 ?                     // ternary: if a is divisible by i
            ((a /= i) % i < 1 ? 0 : -b) :   // if true: set b to 0 if a is divisible by i squared, otherwise flip sign of b
            b;                              // if false: don't change b

    return b;                   // return b (positive for even numbers of primes, negative for odd, zero for squares)
}

Comments

73 बाइट्स मैं बदल int b=1;for(int i=1;गया हूँ int b=1,i=1;for(;। {}लूप के लिए -brackets को हटा दिया । दोनों a%i==0को बदल दिया a%i<1। बदली गई b*=-1;करने के लिए b=-b;। और अंत में बदल return 0;करने के लिए b=0;।

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

हाँ, आपके द्वारा सुझाया गया सब कुछ सही लग रहा था। जब आप ने कहा कि यह सही नहीं था, तो मैं कभी थोड़ा चिंतित था, क्योंकि इसका मतलब होगा कि मेरा मूल कोड भी गलत था! :)

— मेकराट

हाँ, इसके बारे में क्षमा करें। :) गोल्फ के लिए 1 और बाइट btw है if(a%i<1)b=0;करने के लिए b=a%i<1?0:b;।

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

वास्तव में, यह एक आसान सुधार है: b=-b;b=a%i<1?0:b;गोल्फ के लिएb=a%i<1?0:-b;

— पीटर टेलर

@ ऊपर PeterTaylor गोल्फ पर जारी रखते हुए, आप तो बदल सकते हैं if(a%i<1){a/=i;b=a%i<1?0:-b;}करने के लिए b=a%i<1?(a/=i)%i<1?0:-b:b;3 और बाइट्स को बचाने के लिए।

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

Answer 19

GNU sed, 89 बाइट्स

#!/bin/sed -rf
s/.*/factor &/e
s/.*://
/\b([0-9]+) \1\b/!{
s/[0-9]+//g
s/$/1/
s/  //g
y/ /-/
}
s/ .*/0/

Answer 20

जे, 18 बाइट्स

[:*/3<:@|2+2<._&q:

Answer 21

Microsoft Office Excel, ब्रिटिश संस्करण, 196 बाइट्स

=IF(ROW()>=COLUMN(),IF(AND(ROW()=1,COLUMN()=1),1,IF(COLUMN()=1,
-SUM(INDIRECT(ADDRESS(ROW(),2)&":"&ADDRESS(ROW(),ROW()))),
IF(MOD(ROW(),COLUMN())=0,INDIRECT(ADDRESS(FLOOR(ROW()/COLUMN(),1),
1)),""))),"")

एक्सेल सेल फार्मूला को A1 से AX50 सेल में दर्ज किया जाना है।

Answer 22

जूलिया, 35 बाइट्स

\(n,k=1)=k%n>0?n\-~k-k\0^(n%k):1÷n

@ Xnor के पायथन उत्तर के आधार पर । इसे ऑनलाइन आज़माएं!

Answer 23

गंभीरता से, 11 बाइट्स

गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

;y;l0~ⁿ)π=*

Ungolfing

     Implicit input n.
;    Duplicate n.
y    Push a list of the distinct prime factors of n. Call it dpf.
;    Duplicate dpf.
l    Push len(dpf).
0~   Push -1.
ⁿ    Push (-1)**len(dpf).
)    Rotate (-1)**len(dpf) to BOS. Stack: dpf, n, (-1)**len(dpf)
π    Push product(dpf).
=    Check if product(dpf) == n.
      This is only true if n is squarefree.
*    Multiply (n is squarefree) by (-1)**len(dpf).
     Implicit return.

Comments

अच्छा समाधान =) (मुझे लगता है कि यह भाषा छोटी है कि सवाल है, यह है;)

— दोष

@flawr जाहिरा तौर पर इसका जवाब सिर्फ सीरियसली ही काम करता है, और मुझे नहीं पता कि वास्तव में पहली बार ऑनलाइन कब आया था, इसलिए मैं सिर्फ सुरक्षित रहने के लिए सीरियसली बदल गया।

— शर्लक

Answer 24

जावा 8, 72 68 65 बाइट्स

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

-4 बाइट्स @PeterTaylor की बदौलत ।

@ Meerkat's .NET C # उत्तर का पोर्ट , जिसे मैंने पहली बार थोड़ा और आगे बढ़ाया था, इसलिए उसे उभारना सुनिश्चित करें!

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

स्पष्टीकरण:

n->{                 // Method with integer as both parameter and return-type
  int r=1,           //  Result-integer, starting at 1
  i=1;for(;++i<=n;)  //  Loop `i` in the range [1, n]:
    r=n%i<1?         //   If `n` is divisible by `i`:
       (n/=i)        //    Divide `n` by `i` first
        %i<1?        //    And if `n` is still divisible by `i`:
         0           //     Change `r` to 0
        :            //    Else:
         -r          //     Swap the sign of `r` (positive to negative or vice-versa)
      :              //    Else:
       r;            //     Leave `r` unchanged
  return r;}         //  Return `r` as result

Comments

मीरकैट के उत्तर पर मेरी टिप्पणी देखें।

— पीटर टेलर

@PeterTaylor स्मार्ट, धन्यवाद! और फिर 3 और बाइट्स का उपयोग करके बचाया जा सकता है r=n%i<1?(n/=i)%i<1?0:-r:r;।

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

Answer 25

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

f=(n,i=1)=>n-1?n%++i?f(n,i):(n/=i)%i?-f(n,i):0:1

सबसे पहले - यह मेरी पहली कोड गोल्फ पोस्ट है इसलिए मैं कुछ हद तक नियमों को गलत समझ सकता हूं। इस अंतिम चरित्र प्रस्तुत करने में; को छोड़ा जा सकता है और यह अभी भी काम करेगा लेकिन मुझे यह भी पक्का नहीं है कि ईएसटी स्पेक्स के अनुसार कोड मान्य होगा या नहीं। वैसे भी, एक छोटी व्याख्या।

पहले, मैं विचार को थोड़ा समझाऊंगा; हम लेते हैं n, और हम पूर्णांक द्वारा इसे विभाजित करने का प्रयास करते हैं i। यदि यह विभाज्य है, तो हम ऐसा करते हैं और हम जाँचते हैं कि क्या यह iफिर से विभाज्य है । अगर ऐसा है, तो हमें लौटने की जरूरत है 0। अन्यथा, हम एक और कोशिश कर सकते हैं i। ठंडी बात यह है, हम सिर्फ शुरुआत कर सकते हैं i=2और इसे बढ़ा सकते हैं1 हर बार सकते हैं, ताकि हम सभी प्रमुख कारकों को विभाजित कर सकें।

तो, कोड इस तरह काम करता है:

f=(n,i=1)=>                                           We will increase i by one at the start of
                                                         the function body, so default is 1
           n-1?                                       Check if n==1.
               n%++i?                                 If i isn't, increase i by 1, check if n
                                                         is divisible by i
                     f(n,i):                          if it isn't, we check the next i
                            (n/=i)%i?                 if it is, divide n by i, and check for
                                                         divisibility by i again
                                     -f(n,i):         if it not, then we flip the value to
                                                         account for the 1 and -1 depending on the
                                                         amount of factors
                                             0:       if it's divisible by i twice, done.
                                               1      if we're at 1, divided out all factors,
                                                         then we return 1. The line with
                                                         -f(n,i) will then take care of the sign

तो, यह मेरा सबमिशन है।

Comments

साइट पर आपका स्वागत है। मैं js नहीं जानता, लेकिन मैं आपको बता सकता हूं कि यहां हम चश्मे के बारे में परवाह नहीं करते हैं, केवल कार्यान्वयन करते हैं। इसलिए यदि हटाने ;से यह टूटता नहीं है, तो इससे कोई फर्क नहीं पड़ता कि आप इसे हटा सकते हैं।

— गेहूं जादूगर

जानकार अच्छा लगा! मैं इसे निकाल दूंगा;)

— vrugtehagel