양의 정수 n이 주어지면 Mertens 함수 M ( n ) 의 값을 계산하십시오 .

및 μ ( k는 )이있다 뫼비우스 함수 μ ( k는 ) 경우 1 = k는 별개 소인수 짝수 경우 -1 K는 별개 소인수 홀수 가지며, 0 소인수가 명료하지 않은 경우.

• 이것은 코드 골프 이므로 입력 정수 n > 0에 대해 Mertens 함수를 계산하는 함수 또는 프로그램에 대한 가장 짧은 코드를 작성하십시오 .
• 이것은 OEIS 시퀀스 A002321 입니다.

테스트 사례

n M(n)
1 1
2 0
3 -1
4 -1
5 -2
6 -1
7 -2
8 -2
9 -2
10 -1
117 -5
5525 5
7044 -25
8888 4
10000 -23

젤리 , 6 바이트

:Ḋ߀SC

온라인으로 사용해보십시오! 또는 더 작은 테스트 사례를 확인하십시오 . (시간이 걸린다)

배경

이 속성을 사용합니다

A002321 로부터 , 이는 다음의 재귀 공식으로 이어진다.

작동 원리

:Ḋ߀SC  Main link. Argument: n

 Ḋ      Dequeue; yield [2, ..., n].
:       Perform the integer division of n by each k in [2, ..., n].
  ߀    Recursively call the main link on each result.
    S   Sum; add the results from the recursive calls.
     C  Complement; map the sum r to 1 - r.

수학, 22 20 바이트

2 바이트를 절약 한 @miles에게 감사합니다.

Tr@*MoebiusMu@*Range

설명

Range

1부터 입력까지 목록을 생성하십시오.

MoebiusMu

MoebiusMu각 번호 찾기

Tr

결과를 합산하십시오.

파이썬 2, 45 37 바이트

f=lambda n,k=2:n<k or f(n,k+1)-f(n/k)

Ideone에서 테스트하십시오 .

배경

이 속성을 사용합니다

A002321 로부터 , 이는 다음의 재귀 공식으로 이어진다.

작동 원리

우리는 재귀를 사용 하여 몫에 대한 M 을 계산할뿐만 아니라 해당 이미지의 합도 계산합니다. 이렇게하면 다음과 같은 간단한 구현에 비해 8 바이트가 절약됩니다.

M=lambda n:1-sum(M(n/k)for k in range(2,n+1))

경우 F는 단일 인자로 호출 N , 선택적 인수 케이 디폴트 2 .

n = 1 인 경우 True를n<k 생성 하고 f 는이 값을 반환합니다. 이것이 우리의 기본 사례입니다.

경우 N> 1 , n<k처음에 반환 거짓 과 코드 다음은 or실행됩니다. f(n/k)재귀 적으로 합계의 한 항을 계산합니다.이 값은의 반환 값에서 뺍니다 f(n,k+1). 후자는 k를 증가 시키고 재귀 적으로 f를 호출 하여 가능한 k 값을 반복합니다 . 일단 N <K + 1 또는 N = 1 , f(n,k+1)반환 1 재귀를 종료한다.

05AB1E , 16 15 바이트

LÒvX(ygmyyÙïQ*O

설명

L        # range [1 .. n]
Ò        # list of prime factors for each in list
v        # for each prime factor list
 X(ygm   # (-1)^len(factors)
 yyÙïQ*  # multiplied by factors == (unique factors)
 O       # sum

온라인으로 사용해보십시오!

Brachylog , 22 20 바이트

yb:1a+
$p#dl:_1r^|,0

온라인으로 사용해보십시오!

설명

yb                 The list [1, 2, …, Input]
  :1a              Apply predicate 1 (second line) to each element
     +             Sum the resulting list


    $p#d               All elements of the list of prime factors of the Input are distinct
        l:_1r^         Output = (-1)^(<length of the list of prime factors>)
|                  Or
    ,0                 Output = 0

젤리 , 9 바이트

RÆFỊNP€FS

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

RÆFỊNP€FS  Main link. Argument: n

R          Range; yield [1, ..., n].
 ÆF        Factor; decompose each integer in that range into prime-exponent pairs.
   Ị       Insignificant; yield 1 for argument 1, 0 for all others.
    N      Negative; map n to -n.
           This maps primes to 0, exponent 1 to -1, and all other exponents to 0.
     P€    Reduce the columns of the resulting 2D arrays by multiplication.
           The product of the prime values will always be 0; the product of the
           exponent values is 0 if any exponent is greater than, 1 if there is an
           even number of them, -1 is there is an odd number of them.
       FS  Flatten and sum, computing the sum of µ(k) for k in [1, ..., n].

하스켈, 29 27 바이트

f n=1-sum(f.div n<$>[2..n])

젤리 , 7 바이트

Ị*%ðþÆḊ

그리 효율적이지 않습니다. 결정 인자는 어렵다.

온라인으로 사용해보십시오! 또는 더 작은 테스트 사례를 확인하십시오 . (시간이 걸린다)

배경

A002321 의 공식을 사용합니다 .

M이 (N) 부울 행렬의 행렬식이고 _{N × N} , _{I, J는} 인 1 의 경우 , J = 1 또는 I | j , 그렇지 않으면 0

작동 원리

Ị*%ðþÆḊ  Main link. Argument: n

   ð     Combine the preceding atoms into a chain (unknown arity).
         Begin a new, dyadic chain with arguments a and b.
Ị        Insignificant; return 1 iff a = 1.
  %      Compute a % b.
 *       Compute (a == 1) ** (a % b).
         This yields 1 if a = 1, or if a ≠ 1 and a % b = 0; otherwise, it yields 0.
    þ    Table; construct the matrix A by calling the defined chain for every pair
         of integers in [1, ..., n].
     ÆḊ  Compute the determinant of the resulting matrix.

PHP, 113 바이트

for(;$i=$argv[1]--;){for($n=$j=1;$j++<$i;)if(!($i%$j)){$i/=$j;$n++;if(!($i%$j))continue 2;}$a+=$n%2?1:-1;}echo$a;

내가 아는 한 PHP에는 소수 기능과 같은 것이 없기 때문에 일종의 고통입니다. 아마도 더 잘하는 것이 가능할 것입니다.

다음과 같이 사용하십시오.

 php -r "for(;$i=$argv[1]--;){for($n=$j=1;$j++<$i;)if(!($i%$j)){$i/=$j;$n++;if(!($i%$j))continue 2;}$a+=$n%2?1:-1;}echo$a;" 10000

라켓 103 바이트

(λ(N)(for/sum((n(range 1 N)))(define c(length(factorize n)))(cond[(= 0 c)0][(even? c)1][(odd? c)-1])))

언 골프 드 :

(define f
  (λ(N)
    (for/sum ((n (range 1 N)))
      (define c (length (factorize n)))
      (cond
        [(= 0 c) 0]
        [(even? c) 1]
        [(odd? c) -1]))))

CJam (20 바이트)

qiM{_,:)(@@f/{j-}/}j

온라인 데모

OEIS의 공식을 사용합니다

sum(k = 1..n, a([n/k])) = 1. -David W. Wilson, 2012 년 2 월 27 일

그리고 CJam의 메모 운영자 j입니다.

해부

qi       e# Read stdin as an integer
M{       e# Memoise with no base cases
         e#   Memoised function: stack contains n
  _,:)(  e#   Basic manipulations to give n [2 .. n] 1
  @@f/   e#   More basic manipulations to give 1 [n/2 ... n/n]
  {j-}/  e#   For each element of the array, make a memoised recursive call and subtract
}j

자바 스크립트 (ES6), 50 바이트

n=>[1,...Array(n-1)].reduce((r,_,i)=>r-f(n/++i|0))

@Dennis의 Python 답변 포트.

줄리아, 26 25 바이트

!n=1-sum(map(!,n÷(2:n)))

온라인으로 사용해보십시오!

배경

이 속성을 사용합니다

A002321 로부터 , 이는 다음의 재귀 공식으로 이어진다.

작동 원리

단항 연산자를 재정의합니다 ! 우리의 목적을 위해.

n÷(2:n)우리가 재정의 한 모든 필수 몫을 계산합니다 ! 는 그 위에 매핑되고 마지막으로 모든 재귀 호출의 합계가 1 에서 뺍니다 .

운수 나쁘게,

!n=1-sum(!,n÷(2:n))

Dyadic sum 이 빈 컬렉션에서 질식하기 때문에 작동하지 않습니다 .

!n=n<2||1-sum(!,n÷(2:n))

이 문제를 해결하지만 바이트를 저장하지 않고 입력 1에 대해 True 를 반환합니다 .

C, 51 50 47 바이트

f(n,t,u){for(t=u=1;n/++u;t-=f(n/u));return t;}

편집 : -3 바이트에 대한 @Dennis 덕분에 !

스칼라, 53 바이트

def?(n:Int,k:Int=2):Int=if(n<k)1 else?(n,k+1)- ?(n/k)

Dennis의 pythin 답변 포트.

나는 ?문자를 고수하지 않는 토큰 인 method를 호출했습니다 .

Pyth, 12 바이트

를받는 함수 y를 정의합니다 n.

L-1syM/LbtSb

여기에서 테스트 스위트. ( y여기 의 마지막 은 실제로 선언 된 함수를 호출하는 것입니다.)

실제로 18 17 16 바이트

골프 제안을 환영합니다. 온라인으로 사용해보십시오!

R`;y;l0~ⁿ)π=*`MΣ

언 골핑

         Implicit input n.
R        Push the range [1..n].
`...`M   Map the following function over the range. Variable k.
  ;        Duplicate k.
  y        Push the distinct prime factors of k. Call it dpf.
  ;        Duplicate dpf.
  l        Push len(dpf).
  0~       Push -1.
  ⁿ        Push (-1)**len(dpf).
  )        Move (-1)**len(dpf) to BOS. Stack: dpf, k, (-1)**len(dpf)
  π        Push product(dpf).
  =        Check if this product is equal to k.
            If so, then k is squarefree.
  *        Multiply (k is squarefree) * (-1)**(length).
            If k is NOT squarefree, then 0.
            Else if length is odd, then -1.
            Else if length is even, then 1.
           This function is equivalent to the Möbius function.
Σ        Sum the results of the map.
         Implicit return.

PARI / GP, 24 바이트

n->sum(x=1,n,moebius(x))

J, 19 바이트

1#.1*/@:-@~:@q:@+i.

n범위에 걸쳐 Möbius 함수의 합 을 사용하여 Mertens 함수를 계산합니다 [1, n].

용법

   f =: 1#.1*/@:-@~:@q:@+i.
   (,.f"0) 1 2 3 4 5 6 7 8 9 10 117 5525 7044 8888 10000
    1   1
    2   0
    3  _1
    4  _1
    5  _2
    6  _1
    7  _2
    8  _2
    9  _2
   10  _1
  117  _5
 5525   5
 7044 _25
 8888   4
10000 _23

설명

1#.1*/@:-@~:@q:@+i.  Input: integer n
                 i.  Range [0, 1, ..., n-1]
   1            +    Add 1 to each
             q:@     Get the prime factors of each
          ~:@        Sieve mask of each, 1s at the first occurrence
                     of a value and 0 elsewhere
        -@           Negate
    */@:             Reduce each using multiplication to get the product
1#.                  Convert that to decimal from a list of base-1 digits
                     Equivalent to getting the sum