소개

Pi 함수 라고도 하는 Prime Counting Function 은 이하의 소수를 반환합니다.$\pi(x)$

도전

프로그램은 양의 것으로 가정 할 수있는 정수 x를 가져 와서 x 이하의 소수와 동일한 단일 정수를 출력합니다. 이것은 코드 골프 도전이므로 승자는 가장 적은 바이트를 가진 프로그램이 될 것입니다.

이 챌린지가 시작되기 전에 존재하는 언어 중 원하는 언어를 사용할 수 있지만 언어에 내장 된 소수 계산 기능 또는 소수 검사 기능 (예 : Mathematica)이있는 경우 해당 함수를 코드에서 사용할 수 없습니다 .

입력 예

입력 :
1
출력 :
0

입력 :
2
출력 :
1

입력 :
5
출력 :
3

A000720-OEIS

05AB1E , 3 바이트

!fg

이것은 인수 분해 기본 제공이 허용되는 것으로 가정합니다. 온라인으로 사용해보십시오!

작동 원리

!    Compute the factorial of the input.
 f   Determine its unique prime factors.
  g  Get the length of the resulting list.

파이썬 2, 45 바이트

f=lambda n,k=1,p=1:n/k and p%k+f(n,k+1,p*k*k)

윌슨 정리 소수 생성기를 사용합니다 . 이 제품은 p추적 (k-1)!^2및 p%knonprimes에 대한 소수 1과 0입니다.

MATL , 11, 10, 8 , 5 바이트

:pYFn

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

MATL의 매트릭스 작동 방식에 대한 멋진 설명이 담긴 버전을 작성했습니다.

:YF!s1=1

그러나 더 이상 관련이 없습니다. 개정 내역을 보려면 확인하십시오.

새로운 설명 :

:p      % Compute factorial(input)
  YF    % Get the exponenents of prime factorization
    n   % Get the length of the array

Dennis의 천재 솔루션 덕분에 3 바이트 절약

젤리 , 8 5 바이트

@Dennis 덕분에 3 바이트가 절약되었습니다!

RÆESL

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

DJMcMayhem 포트 의 MATL 답변 (이전 버전)은 Dennis가 개선했습니다.

R          Range of input argument
 ÆE        List of lists of exponents of prime-factor decomposition
   S       Vectorized sum. This right-pads inner lists with zeros
    L      Length of result

ParserFunctions , 220 + 19 = 239 바이트의 MediaWiki 템플릿

{{#ifexpr:{{{2}}}+1={{{1}}}|0|{{#ifexpr:{{{3}}}={{{2}}}|{{P|{{{1}}}|{{#expr:{{{2}}}+1}}|2}}|{{#ifexpr:{{{2}}} mod {{{3}}}=0|{{#expr:1+{{P|{{{1}}}|{{#expr:{{{2}}}+1}}|2}}|{{P|{{{1}}}|{{{2}}}|{{#expr:{{{2}}}+1}}}}}}}}}}}}

템플릿을 호출하려면

{{{P|{{{n}}}|2|2}}}

리스프 스타일로 정렬 :

{{#ifexpr:{{{2}}} + 1 = {{{1}}}|0|
    {{#ifexpr:{{{3}}} = {{{2}}} |
        {{P|{{{1}}}|{{#expr:{{{2}}} + 1}}|2}} |
            {{#ifexpr:{{{2}}} mod {{{3}}} = 0 |
                {{#expr:1 + {{P|{{{1}}}|{{#expr:{{{2}}} + 1}}|2}} |
                {{P|{{{1}}}|{{{2}}}|{{#expr:{{{2}}} + 1}}}}}}}}}}}}

2에서 n 까지의 기본 우선 순위 테스트입니다 . 주변 세 중괄호와 숫자는 변수, 어디에 {{{1}}}이다 N , {{{2}}}숫자가 테스트되고 {{{3}}}확인하는 요인이다.

펄, 33 바이트

에 +1 포함 -p

STDIN에 입력 번호를 줘

primecount.pl

#!/usr/bin/perl -p
$_=1x$_;$_=s%(?!(11+)\1+$)%%eg-2

잘못된 결과를 제공 0하지만 괜찮습니다. op는 양의 정수만 지원하도록 요청했습니다.

망막, 31 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다. 의 범위를 단항 입력을 변환 생성 1하는 n각각의 행에. 소수를 일치시킵니다.

.*
$*
\B
¶$`
m`^(?!(..+)\1+$)..

온라인으로 시도 -시간이 초과되거나 메모리가 부족한 2800보다 큰 입력.

참고 문헌 :

마틴 레인지 제너레이터

마틴 프라임 체커

젤리 , 3 바이트

!Æv

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

작동 원리

!Æv  Main link. Argument: n

!    Compute the factorial of n.
 Æv  Count the number of distinct prime factors.

젤리 , 13 11 10 9 8 7 6 바이트

더 내장 된 사용하여 주요 어떠한 기능
-1 바이트 감사 @miles하려면 (테이블을 사용하지)
-1 바이트 감사 @Dennis에 (단항 변환 약수를 계산)

ḍþḅ1ċ2

TryItOnline
또는이 시리즈의 첫 번째 100 개 용어를 참조n=[1,100]에서도, TryItOnline

방법?

ḍþḅ1ċ2 - Main link: n
 þ     - table or outer product, n implicitly becomes [1,2,3,...n]
ḍ      - divides
  ḅ1   - Convert from unary: number of numbers in [1,2,3,...,n] that divide x
                             (numbers greater than x do not divide x)
    ċ2 - count 2s: count the numbers in [1,2,3,...,n] with exactly 2 divisors
                   (only primes have 2 divisors: 1 and themselves)

자바 스크립트 (ES6), 45 43 바이트

f=(n,x=n)=>n>1&&(--x<2)+(n%x?f(n,x):f(n-1))

내 36 35 33 바이트 원시 기능 의 수정 (1 바이트는 @Neil, 2는 @Arnauld) :

f=(n,x=n)=>n>1&--x<2||n%x&&f(n,x)

( 이 숫자는 소수입니까? 전체 프로그램 만 허용 하므로 여기에 아무 것도 게시 할 수 없습니다 ...)

테스트 스 니펫

f=(n,x=n)=>n>1&&(--x<2)+(n%x?f(n,x):f(n-1))

<input type="number" oninput="console.log('f('+this.value+') is '+f(this.value))" value=2>

PowerShell v2 +, 98 바이트

param($n)if($j='001'[$n]){}else{for($i=1;$i-lt$n){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$j++}}}$j

주의 : 큰 입력의 경우 속도 가 느립니다 .

기본적으로 단항 기반 조회 는이 숫자가 소수입니까? for루프 및 $j++카운터 와 결합됩니다 . 약간의 추가 가장자리의 경우 입력에 대한 계정에 전면에 논리 1와 2인해 fenceposting가 어떻게 작동하는지에, for루프.

05AB1E , 5 바이트

소인수 분해 기본 제공이 허용된다고 가정합니다.

암호:

LÒ1ùg

설명:

L      # Get the range [1, ..., input]
 Ò     # Prime factorize each with duplicates
  1ù   # Keep the elements with length 1
    g  # Get the length of the resulting array

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

CJam , 7 바이트

rim!mF,

온라인으로 사용해보십시오! 인수 분해 기능을 사용합니다.

설명:

ri      | read input as integer
  m!    | take the factorial
    mF  | factorize with exponents (one element per prime)
      , | find length

젤리 , 6 바이트

Ḷ!²%RS

이것은 기본 산술과 윌슨 정리 만 사용합니다. 온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

Ḷ!²%RS  Main link. Argument: n

Ḷ       Unlength; yield [0, ..., n - 1].
 !      Factorial; yield [0!, ..., (n - 1)!].
  ²     Square; yield [0!², ..., (n - 1)!²].
    R   Range; yield [1, ..., n].
   %    Modulus; yield [0!² % 1, ..., (n - 1)!² % n].
        By a corollary to Wilson's theorem, (k - 1)!² % k yields 1 if k is prime
        and 0 if k is 1 or composite.
     S  Sum; add the resulting Booleans.

C # 5.0 78 77

int F(int n){int z=n;if(n<2)return 0;for(;n%--z!=0;);return(2>z?1:0)+F(n-1);}

언 골프

int F(int n)
{
    var z = n;
    if (n < 2) return 0;
    for (; n % --z != 0;) ;
    return F(n - 1) + (2 > z ? 1 : 0);
}

Pyth- 7 6 바이트

다른 사람들이 소인수 분해 함수를 사용하고 있기 때문에 ...

l{sPMS

테스트 스위트 .

배쉬 + 코어 유틸리티, 30

seq $1|factor|egrep -c :.\\S+$

이데온

Bash + coreutils + BSD-games 패키지, 22

primes 1 $[$1+1]|wc -l

이 짧은 대답은 bsdgames 패키지가 설치되어 있어야 sudo apt install bsdgames합니다.

파이크, 8 6 바이트

SmPs}l

여기 사용해보십시오!

새로운 알고리즘에 대한 Maltysen에게 감사

SmP    -    map(factorise, input)
   s   -   sum(^)
    }  -  uniquify(^)
     l - len(^)

C #, 157 바이트

n=>{int c=0,i=1,j;bool f;for(;i<=n;i++){if(i==1);else if(i<=3)c++;else if(i%2==0|i%3==0);else{j=5;f=1>0;while(j*j<=i)if(i%j++==0)f=1<0;c+=f?1:0;}}return c;};

테스트 케이스가 포함 된 전체 프로그램 :

using System;

class a
{
    static void Main()
    {
        Func<int, int> s = n =>
            {
                int c = 0, i = 1, j;
                bool f;
                for (; i <= n; i++)
                {
                    if (i == 1) ;
                    else if (i <= 3) c++;
                    else if (i % 2 == 0 | i % 3 == 0) ;
                    else
                    {
                        j = 5;
                        f = 1 > 0;
                        while (j * j <= i)
                            if (i % j++ == 0)
                                f = 1 < 0;
                        c += f ? 1 : 0;
                    }
                }
                return c;
            };

        Console.WriteLine("1 -> 0 : " + (s(1) == 0 ? "OK" : "FAIL"));
        Console.WriteLine("2 -> 1 : " + (s(2) == 1 ? "OK" : "FAIL"));
        Console.WriteLine("5 -> 3 : " + (s(5) == 3 ? "OK" : "FAIL"));
        Console.WriteLine("10 -> 4 : " + (s(10) == 4 ? "OK" : "FAIL"));
        Console.WriteLine("100 -> 25 : " + (s(100) == 25 ? "OK" : "FAIL"));
        Console.WriteLine("1,000 -> 168 : " + (s(1000) == 168 ? "OK" : "FAIL"));
        Console.WriteLine("10,000 -> 1,229 : " + (s(10000) == 1229 ? "OK" : "FAIL"));
        Console.WriteLine("100,000 -> 9,592 : " + (s(100000) == 9592 ? "OK" : "FAIL"));
        Console.WriteLine("1,000,000 -> 78,498 : " + (s(1000000) == 78498 ? "OK" : "FAIL"));
    }
}

백만 이상이되면 시간이 조금 걸립니다.

Matlab, 60 바이트

한 줄 Matlab 함수에 대한 첨부 파일을 계속합니다. 인수 분해 내장 기능을 사용하지 않는 경우 :

f=@(x) nnz(arrayfun(@(x) x-2==nnz(mod(x,[1:1:x])),[1:1:x]));

소수 y에는 두 가지 요소 만 있다고 가정하면 두 가지 요소 만 [1,y]있는 범위의 숫자를 계산합니다 [1,x].

인수 분해를 사용하면 크게 단축 될 수 있습니다 (46 바이트까지).

g=@(x) size(unique(factor(factorial(x))),2);

결론 : 골프 언어를 조사 할 필요가있다. : D

실제로 10 바이트

이것은 TIO에서 인터프리터 버그가 발생하지 않는 가장 짧은 솔루션이었습니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

;╗r`P╜>`░l

언 골핑

         Implicit input n.
;╗       Duplicate n and save a copy of n to register 0.
r        Push range [0..(n-1)].
`...`░   Push values of the range where the following function returns a truthy value.
  P        Push the a-th prime
  ╜        Push n from register 0.
  >        Check if n > the a-th prime.
l        Push len(the_resulting_list).
         Implicit return.

젤리 , 3 바이트

ÆRL

젤리는 빌트인 프라임 카운팅 기능 ÆC과 프라임 검사 기능을 가지고 있으며 ÆP, 대신 빌트인 프라임 생성 기능을 사용 ÆR하고 길이를 취합니다 L.

나는이도로 3 바이트를 취할 것입니다 주요 인수 분해 내장 기능을 사용하는 등 경계 등에 대해 추측 !Æv( !계승, Æv소인수를 계산)

PHP, 96 92 바이트

for($j=$argv[1]-1;$j>0;$j--){$p=1;for($i=2;$i<$j;$i++)if(is_int($j/$i))$p=0;$t+=$p;}echo $t;

Roman Gräf 덕분에 4 바이트 절약

온라인 테스트

Ungolfed 테스트 코드 :

$argv[1] = 5;

for($j=$argv[1]-1;$j>0;$j--) {
    $p=1;
    for($i=2;$i<$j;$i++) {
        if(is_int($j/$i)) {
            $p=0;
        }
    }
    $t+=$p;
}
echo $t;

온라인 테스트

APL (Dyalog Unicode) , 13 바이트 ^SBCS

2+.=0+.=⍳∘.|⍳

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

⍳ ndi ndices 1…
 N⧽ ∘.| 나머지 테이블 (두 축을 축으로 사용)
⍳ ɩ ndices 1… N

0+.= 요소의 합이 0과 같음

2+.= 요소의 합이 2와 같음 (즉, 소수가 몇 개인가)

파이썬 3, 40 바이트

f=lambda n:1if n<1else(2**n%n==2)+f(n-1)

2 ** (k-1)이 1 mod k와 일치하는 경우에만 홀수 정수 k가 소수입니다. 따라서이 조건을 확인하고 k = 2 인 경우 1을 더합니다.

MATL , 9 바이트

이는 소수 분해를 방지합니다. 복잡도는 O ( n ²)입니다.

:t!\~s2=s

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

:     % Range [1 2 ... n] (row vector)
t!    % Duplicate and transpose into a column vector
\     % Modulo with broadcast. Gives matrix in which entry (i,j) is i modulo j, with
      % i, j in [1 2 ... n]. A value 0 in entry (i,j) means i is divisible by j
~     % Negate. Now 1 means i is divisible by j
s     % Sum of each column. Gives row vector with the number of divisors of each j
2=    % Compare each entry with 2. A true result corresponds to a prime
s     % Sum

자바 스크립트 (ES6), 50 + 2 46 + 2 43 바이트

Neil 덕분에 3 5 바이트를 절약했습니다 .

f=n=>n&&eval(`for(z=n;n%--z;);1==z`)+f(n-1)

evaln매개 변수에 액세스 할 수 있습니다 . 확인하는 경우는 소수이다.
eval(...)n

이전 솔루션 :
함수 이름을 잊어 버렸기 때문에 바이트 수는 +2 여야합니다 f=(재귀 필요)

46 + 2 바이트 (ETH 프로덕션 덕분에 3 바이트 절약) :

n=>n&&eval(`for(z=n=${n};n%--z;);1==z`)+f(n-1)

50 + 2 바이트 :

n=>n&&eval(`for(z=${n};${n}%--z&&z;);1==z`)+f(n-1)

자바 7,102 바이트

무차별 대입

int f(int n){int i=2,j=2,c=1,t=0;for(;i<=n;j=2,c+=t==1?1:0,i++)for(;j<i;t=i%j++==0?j=i+1:1);return c;}

언 골프

int f(int n){
int i=2,j=2,c=1,t=0;
for(;i<=n;j=2,c+=t==1?1:0,i++)
    for(;j<i;)
        t=i%j++==0?j=i+1:1;
    return c;
 }

q 35 바이트

{sum 1=sum'[0=2_' a mod\: a:til x]}

실제로 10 바이트

프라임 생성 함수를 사용한 첫 번째 실제 답변이 허용되지 않는 경우 다음은 윌슨 정리를 사용한 백업 답변입니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

R`;D!²%`MΣ

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

         Implicit input n.
R        Push range [1..n]
`...`M   Map the following function over the range. Variable k.
  ;        Duplicate k.
  D        Decrement one of the copies of k.
  !²       Push ((k-1)!)².
  %        Push ((k-1)!)² % k. This returns 1 if k is prime, else 0.
Σ        Sums the result of the map, adding all the 1s that represent primes, 
          giving the total number of primes less than n.
         Implicit return.