Möbius ফাংশন

23

Möbius ফাংশন

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

পরীক্ষার মামলা

এখানে আপনি 50 এর প্রথম 50 টি মান দেখতে পাবেন:

উইকিপিডিয়া থেকে পাবলিক ডোমেন চিত্র

Möbius ফাংশনটি 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

@ মার্টিনব্যাটনার প্রস্তাবিত বৃহত্তর মানগুলি ওল্ফ্রামালফা ডটকম বা ওইআইএস - এর বি-ফাইলে সহজেই পরীক্ষা করা যায় ।

code-golf  math  sequence  number-theory  primes 
— flawr
সূত্র

উত্তর:

15

পাইথন 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)

এমবিয়াস- ক্রমটি উল্টে দেয় 1,0,0,0,0...।

Möbius ফাংশন সম্পত্তি যে কোনো জন্য রয়েছে n>1, এর Möbius ফাংশন nএর ভাজক 0. সুতরাং করতে সমষ্টি, জন্য n>1, μ(n)এর সমষ্টি অস্বীকার দ্বারা নির্ণয় করা হয় μ(k)সব সঠিক ভাজক জন্য kএর n। জন্য n=1, আউটপুট হয় 1।

কোড একটি মেঝে-বিভাজন যোগ করে বেস কেস পরিচালনা 1/n, যা দেয় 1জন্য n==1এবং 0অন্যথায়।

এই চ্যালেঞ্জের অনুরূপ কাঠামো দ্বারা অনুপ্রাণিত আরও ভাল পুনরাবৃত্ত হ্যান্ডলিং সহ 3 বাইট সংরক্ষণের জন্য ডেনিসকে ধন্যবাদ ।

— xnor
সূত্র
13

জেলি , 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 ।

এটি অনলাইনে চেষ্টা করুন ।

— আদনান
সূত্র
-1 বাইট: ÆFỊNPS(নিশ্চিত না যে Ịপিছনে কোনও বিল্ট-ইন ছিল কিনা , তবে এখনই ভাল হওয়া উচিত)।
— এরিক দি আউটগল্ফার
10

গণিত, 9 বাইট

MoebiusMu

অবশ্যই গণিতের একটি অন্তর্নির্মিত রয়েছে। (এবং সম্ভবত যেভাবেই হোক জেলি তাকে মারবে ।)

— মার্টিন ইন্ডার
সূত্র
7

সিজেম, 18 15 বাইট

WrimFz~\1&+f/:*

সিজেএম যে 1 টি ফিটারেসিফিকেশন বিল্টিনে দেয় তা আসলে n = 1কিছুটা জটিল করে তোলে।

অনলাইনে চেষ্টা করে দেখুন | পরীক্ষা স্যুট

1&+1 কেস পরিচালনা করার জন্য সুস্পষ্ট কৌশলটির জন্য @ পিটারটেলরকে ধন্যবাদ জানাই ।

ব্যাখ্যা

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স্কয়ারফ্রি যদি হয় তবে অ্যারেটি সমস্ত 1 এস হয়, যা বিভাগের পরে সমস্ত -1 হয়। অন্যথায়, n এর যদি একটি প্রাইম স্কোয়ার বিভাজক থাকে তবে বিভাগের পরে কোথাও 0 থাকবে, 0 দিয়ে একটি পণ্য দেওয়া।

জন্য n = 1পরিবর্তিত অ্যারে [1] + [1]যা হয়ে, [-1 -1], বিভাজন পর 1 একটি পণ্য প্রদান করে।

বিকল্প 16:

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

এটি 1 অনুসন্ধানের জন্য #প্রতিটি [base exponent]অ্যারেতে (খুঁজে) ব্যবহার করে , তারপরে মানচিত্রগুলি -1 -> 0, 0 -> 1, 1 -> -1।

— Sp3000
সূত্র
6

রুবি, 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
— ডোরকনব
সূত্র
5

পাইথ, 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.

এখানে চেষ্টা করুন ।

— lirtosiast
সূত্র
5

ল্যাবরেথ , 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)

দীর্ঘ ব্যাখ্যা

ভোল্টেজের সাধারণ প্রাইমার:

  • ল্যাবরেথটি স্ট্যাক-ভিত্তিক এবং দ্বি-মাত্রিক, প্রথম স্বীকৃত চরিত্রের সাথে মৃত্যুদন্ড কার্যকর হয়। দুটি স্ট্যাক রয়েছে, একটি প্রধান স্ট্যাক এবং একটি সহায়ক স্ট্যাক, তবে বেশিরভাগ অপারেটর কেবল প্রধান স্ট্যাকের উপর কাজ করে।
  • গোলকধাঁধার প্রতিটি শাখায়, স্ট্যাকের শীর্ষটি কোথায় পরীক্ষা করা উচিত তা নির্ধারণ করার জন্য চেক করা হয়। Gণাত্মক বাম দিকে ঘুরছে, শূন্যটি সরাসরি এগিয়ে এবং ধনাত্মক ডানদিকে বাঁকানো।

এই প্রোগ্রামটির জন্য সম্পাদনা উপরের-বামে শুরু হয় 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)
— Sp3000
সূত্র
4

সিজোম, 20 বাইট

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

এটি এখানে বিভিন্ন ইনপুটগুলির বিপরীতে চালান।

গল্ফযোগ্য মনে হয়।

— মার্টিন ইন্ডার
সূত্র
2
1 টি ফিরে আসে mfবা mFসত্যই ব্যথা হয় ...
— Sp3000
@ এসপি 3000 আমাকে এ সম্পর্কে বলুন :-(
— লুইস মেন্ডো
4

আর 39 16 বাইট

numbers::moebius

আপনার যে সমস্যা হচ্ছে প্রয়োজন সংখ্যার প্যাকেজ আপনার সিস্টেমে ইনস্টল ...

সম্পাদনা করুন: আমি যদি চশমাগুলি যথাযথভাবে পড়ে থাকি তবে আরও সহজ [ধন্যবাদ @ অ্যালেক্সা।]

— mnel
সূত্র
এটি প্রতিটি পূর্ণসংখ্যার জন্য 1 থেকে ইনপুটটিতে মূল্যায়ন করা এমবিয়াস ফাংশনটি ফিরিয়ে দেয় তবে এই চ্যালেঞ্জটির জন্য কাজটি কেবল ইনপুটটিতে এমবিয়াস ফাংশনটি মূল্যায়ন করা।
— অ্যালেক্স এ।
গাণিতিকের উত্তরের লাইনের পাশাপাশি আপনি numbers::moebius16 বাইটের জন্যও করতে পারেন ।
— অ্যালেক্স এ।
3

পাইথ , 16 বাইট

?nl{PQlPQZ^_1lPQ

এটি অনলাইন চেষ্টা করুন!

আমার প্রথম আসল পাইথ উত্তর। পরামর্শ প্রশংসা! :)

ব্যাখ্যা

আমার সমাধানটিতে এই সংখ্যাটি ব্যবহার করা হয় যে কোনও সংখ্যাটি স্কোয়ারফ্রি, যদি এর প্রধান কারণগুলির মধ্যে একাধিক সংখ্যা থাকে না। যদি ইনপুটটি স্কোয়ারফ্রি হয় তবে এমবিয়াস-ফাংশনটি মান -1 takes (প্রাইমফ্যাক্টরের সংখ্যা) নেয় takes


?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)
— Denker
সূত্র
3

এমএটিএল , 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
— লুইস মেন্ডো
সূত্র
3

05 এ বি 1 ই , 8 বাইট, অ-প্রতিযোগী

দাম্মিট, আবারও একটি বাগ যা আমার জমাটি প্রতিযোগিতামূলক করে তোলে makes কোড:

.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

সিপি -1222 এনকোডিং ব্যবহার করে

— আদনান
সূত্র
›আইএসও 8859-1 এ নেই ...
— ETH প্রোডাকশনগুলি
1
নিবন্ধন করুন তাহলে এটি কী ধরণের এনকোডিং? আমি এই সাইট থেকে এটি পেয়েছি ।
— আদনান
আমি বিশ্বাস করি এটাকে এক্সটেন্ডেড এএসসিআইআই বলা হয় ।
— ETH প্রোডাকশনগুলি
@ ইথ প্রডাকশন ধন্যবাদ, পোস্টটি আমি সম্পাদনা করেছি :)
— আদনান
@ থমাসকওয়া আহ, আমি এটি খুঁজে পেয়েছি। এটি সিপি -1222 এনকোডিং।
— আদনান
2

পাইথ, 11

*{IPQ^_1lPQ

পরীক্ষা স্যুট

এটি যদি মৌলিক -1সংখ্যাগুলি সংখ্যার প্রধান গুণকের সংখ্যার শক্তির দ্বারা বর্গক্ষেত্র হয় তবে এর বুলিয়ান মানকে গুণিত করে ।

I{প্রিরিসিডিং অপারেটরের উপর চালিত চেক, যা এখানে রয়েছে , এটি অনন্য-আইপি অপারেটর।

— FryAmTheEggman
সূত্র
2

জুলিয়া, 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
— অ্যালেক্স এ।
সূত্র
2

প্যারি / জিপি, 7 বাইট

moebius

দুঃখজনকভাবে möbiusপাওয়া যায় না। :)

— চার্লস
সূত্র
2

গুরুতরভাবে, 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
— ঐ মেগো
সূত্র
2

সি # (.নেট কোর) , 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;}

এটি অনলাইন চেষ্টা করুন!


-১ by বাইট: প্রবাহিত লুপস, যুক্ত রিটার্ন ভেরিয়েবল ( কেভিন ক্রুইজসেনকে ধন্যবাদ ) -১ বাইট: বি সেটিংকে শূন্যে পরিবর্তিত করে যদি একটি ইফ ( কেভিন ক্রুইজসেনকে ধন্যবাদ ) থেকে -tes
বাইট: পরিবর্তিত হয় যদি বিবৃতিটি একটি টার্নারিতে থাকে ( পিটার টেলর এবং কেভিন ক্রুইজসেনকে ধন্যবাদ )

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)
}
— Meerkat
সূত্র
1
73 বাইট আমি পরিবর্তিত int b=1;for(int i=1;হয়েছে int b=1,i=1;for(;। {}লুপের জন্য - বন্ধনীগুলি সরানো হয়েছে । উভয়ই পরিবর্তন a%i==0হয়েছে a%i<1। থেকে পরিবর্তন করা b*=-1;হয়েছে b=-b;। এবং পরিশেষে পরিবর্তিত return 0;করতে b=0;।
— কেভিন ক্রুইজসেন
হ্যাঁ, আপনি প্রস্তাবিত সমস্ত কিছু সঠিক দেখাচ্ছে। আপনি যখন বলেছিলেন যে এটি ঠিক ছিল না তখন আমি কখনই কিছুটা চিন্তিত ছিলাম, কারণ এর অর্থ হ'ল আমার মূল কোডটিও ভুল ছিল! :)
— মিরকাত
1
হ্যাঁ, দুঃখিত। :) গল্ফ 1 এর আরও বেশি বাইট BTW হয় if(a%i<1)b=0;থেকে b=a%i<1?0:b;।
— কেভিন ক্রুইজসেন
2
প্রকৃতপক্ষে, এটি একটি সহজ উন্নতি উপেক্ষা করে: b=-b;b=a%i<1?0:b;গল্ফসb=a%i<1?0:-b;
— পিটার টেলর
1
@ উপরে 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 বাইট সংরক্ষণ করুন।
— কেভিন ক্রুইজসেন 20
1

জিএনইউ সেড, 89 বাইট

#!/bin/sed -rf
s/.*/factor &/e
s/.*://
/\b([0-9]+) \1\b/!{
s/[0-9]+//g
s/$/1/
s/  //g
y/ /-/
}
s/ .*/0/
— টবির গতি
সূত্র
1

মাইক্রোসফ্ট অফিস এক্সেল, ব্রিটিশ সংস্করণ, 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 এ প্রবেশ করাতে এক্সেল সেল সূত্র।

— ম্যাটস গ্রানভিক
সূত্র
1

গুরুতরভাবে, 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.
— Sherlock9
সূত্র
চমৎকার সমাধান =) (তবে আমি অনুমান করি যে এই ভাষাটি যে প্রশ্নটির তুলনায় এটি আরও কম বয়সী?)
— flawr
@ ফ্লেয়ার স্পষ্টতই উত্তরটি সিরিয়াসলিভাবে কাজ করে, এবং আমি জানি না কখন আসল প্রথম অনলাইনে এসেছিল, তাই আমি নিরাপদে থাকার জন্য সিরিয়াসলি পরিবর্তিত হয়েছি।
— শার্লক 9
1

জাভা 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 এর .NET C # এর উত্তর , যা আমি প্রথম আরও একটু golfed, তাই তাকে ভোট দিন ভুলবেন না!

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা:

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
— কেভিন ক্রুইজসেন
সূত্র
মিরকাতের উত্তরে আমার মন্তব্য দেখুন।
— পিটার টেলর
@ পিটারটেলর স্মার্ট, ধন্যবাদ! এবং তারপরে আরও 3 বাইট ব্যবহার করে সংরক্ষণ করা যায় r=n%i<1?(n/=i)%i<1?0:-r:r;।
— কেভিন ক্রুইজসেন
0

জাভাস্ক্রিপ্ট (ES6), 48 বাইট

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

প্রথমত - এটি আমার প্রথম কোড গল্ফ পোস্ট তাই আমি কিছুটা হলেও নিয়মকে ভুল বুঝতে পারি। এই জমা দেওয়ার ক্ষেত্রে শেষ চরিত্রটি ;বাদ দেওয়া যেতে পারে এবং এটি এখনও কাজ করবে তবে আমি ES6 স্পেস অনুসারে কোডটি বৈধ হবে কিনা তাও নিশ্চিত নই। যাইহোক, একটি সংক্ষিপ্ত ব্যাখ্যা।

প্রথমে, আমি ধারণাটি কিছুটা ব্যাখ্যা করব; আমরা গ্রহণ করি 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

সুতরাং, এটি আমার জমা।

— vrugtehagel
সূত্র
সাইটে স্বাগতম। আমি জেএস জানি না, তবে আমি আপনাকে বলতে পারি যে আমরা এখানে চশমা, কেবল বাস্তবায়ন সম্পর্কে চিন্তা করি না। সুতরাং যদি মুছে ফেলা ;এটি ভেঙে না যায় তবে আপনি যে চশমাগুলি এটি সরাতে পারবেন তাতে কিছু যায় আসে না।
— গম উইজার্ড
জানা ভাল! আমি তখন এটি সরিয়ে
— ফেলব
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.