Giới thiệu

Hàm đếm số nguyên tố , còn được gọi là hàm Pi , trả về số lượng các số nguyên tố nhỏ hơn hoặc bằng x.$\pi(x)$

Thử thách

Chương trình của bạn sẽ lấy một số nguyên x mà bạn có thể giả sử là dương và xuất ra một số nguyên duy nhất bằng số lượng các số nguyên tố nhỏ hơn hoặc bằng x. Đây là một thử thách chơi gôn , vì vậy người chiến thắng sẽ là chương trình có ít byte nhất.

Bạn có thể sử dụng bất kỳ ngôn ngữ nào bạn chọn với điều kiện nó tồn tại trước khi thử thách này xảy ra, nhưng nếu ngôn ngữ đó có chức năng đếm số nguyên tố tích hợp hoặc chức năng kiểm tra tính nguyên thủy (như Mathicala), thì chức năng đó không thể được sử dụng trong mã của bạn .

Ví dụ đầu vào

Đầu vào:
1
Đầu ra:
0

Đầu vào:
2
Đầu ra:
1

Đầu vào:
5
Đầu ra:
3

A000720 - OEIS

05AB1E , 3 byte

!fg

Điều này giả định rằng các yếu tố tích hợp được cho phép. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Python 2, 45 byte

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

Sử dụng máy phát nguyên lý định lý Wilson . Các sản phẩm ptheo dõi (k-1)!^2, và p%klà 1 cho số nguyên tố và 0 cho số không.

MATL , 11, 10, 8 , 5 byte

:pYFn

Hãy thử trực tuyến!

Tôi đã viết một phiên bản có một lời giải thích thực sự hay về cách thức hoạt động của ma trận MATL:

:YF!s1=1

Nhưng nó không còn phù hợp nữa. Kiểm tra lịch sử sửa đổi nếu bạn muốn xem nó.

Giải thích mới:

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

Ba byte được lưu nhờ giải pháp thiên tài của Dennis

Thạch , 8 5 byte

3 byte được lưu nhờ @Dennis!

RÆESL

Hãy thử trực tuyến!

Cảng câu trả lời MATL DJMcMayhem của (cựu version) tinh chế bởi 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

Các mẫu MediaWiki với ParserFifts , 220 + 19 = 239 byte

{{#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}}}}}}}}}}}}

Để gọi mẫu:

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

Sắp xếp theo phong cách Lisp:

{{#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}}}}}}}}}}}}

Chỉ là một bài kiểm tra nguyên thủy cơ bản từ 2 đến n . Những con số với ba niềng răng xung quanh họ là các biến, mà {{{1}}}là n , {{{2}}}là số đang được thử nghiệm, {{{3}}}là yếu tố để kiểm tra.

Perl, 33 byte

Bao gồm +1 cho -p

Cho số đầu vào trên STDIN

primecount.pl

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

Cung cấp kết quả sai cho 0nhưng điều đó không sao, op chỉ yêu cầu hỗ trợ cho các số nguyên dương.

Võng mạc, 31 byte

Số lượng byte giả định mã hóa ISO 8859-1. Chuyển đổi đầu vào thành unary, tạo phạm vi từ 1đến n, mỗi dòng trên một dòng riêng. Phù hợp với các số nguyên tố.

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

Dùng thử trực tuyến - Nhập lớn hơn 2800 lần hoặc hết bộ nhớ.

Tài liệu tham khảo:

Máy phát điện phạm vi của Martin

Kiểm tra chính của Martin

Thạch , 3 byte

!Æv

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

!Æv  Main link. Argument: n

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

Thạch , 13 11 10 9 8 7 6 byte

Không sử dụng các hàm số nguyên tố tích hợp nào
-1 byte nhờ @miles (sử dụng bảng)
-1 byte nhờ @Dennis (chuyển đổi từ unary để đếm các ước số)

ḍþḅ1ċ2

TryItOnline
Hoặc xem 100 điều khoản đầu tiên của loạt bàin=[1,100], cũng tại TryItOnline

Làm sao?

ḍþḅ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)

JavaScript (ES6), 45 43 byte

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

Một sửa đổi của chức năng nguyên thủy 36 35 33 byte của tôi (1 byte được lưu bởi @Neil, 2 bởi @Arnauld):

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

(Tôi không thể đăng bài này ở bất cứ đâu vì số này có phải là số nguyên tố không? Chỉ chấp nhận các chương trình đầy đủ ...)

Kiểm tra đoạn

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 byte

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

Chú ý: Đây là chậm cho đầu vào lớn.

Về cơ bản việc tra cứu dựa trên đơn nguyên từ số này có phải là số nguyên tố không? , kết hợp với một forvòng lặp và một bộ $j++đếm. Một chút logic bổ sung ở mặt trước để giải thích cho các trường hợp cạnh đầu vào 1và 2, do cách thức hoạt động của hàng rào trong các forvòng lặp.

05AB1E , 5 byte

Giả sử rằng các phần tử nhân tố chính được cho phép.

Mã số:

LÒ1ùg

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

CJam , 7 byte

rim!mF,

Hãy thử trực tuyến! Sử dụng một chức năng nhân tố.

Giải trình:

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

Thạch , 6 byte

Ḷ!²%RS

Điều này chỉ sử dụng số học cơ bản và định lý Wilson. Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Ḷ!²%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);}

Bị đánh cắp

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

Thứ 7 - 7 6 byte

Vì những người khác đang sử dụng các hàm thừa số nguyên tố ...

l{sPMS

Phòng thử nghiệm .

Bash + coreutils, 30

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

Ideone.

Bash + coreutils + gói trò chơi BSD, 22

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

Câu trả lời ngắn hơn này yêu cầu bạn phải cài đặt gói bsdgames : sudo apt install bsdgames.

Pyke, 8 6 byte

SmPs}l

Hãy thử nó ở đây!

Cảm ơn Maltysen về thuật toán mới

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

C #, 157 byte

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;};

Chương trình đầy đủ với các trường hợp thử nghiệm:

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"));
    }
}

Bắt đầu mất một lúc sau khi bạn vượt quá 1 triệu.

Matlab, 60 byte

Tiếp tục tệp đính kèm của tôi với các hàm Matlab một dòng. Không sử dụng hệ số tích hợp:

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

Cho rằng một số nguyên tố ychỉ có hai yếu tố [1,y]: chúng tôi đếm các số trong phạm vi [1,x]chỉ có hai yếu tố.

Sử dụng hệ số cho phép rút ngắn đáng kể (xuống tới 46 byte).

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

Kết luận: Cần xem xét ngôn ngữ chơi gôn của họ: D

Trên thực tế, 10 byte

Đây là giải pháp ngắn nhất mà tôi thấy không gặp phải lỗi phiên dịch trên TIO. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

;╗r`P╜>`░l

Ungolfing

         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.

Thạch , 3 byte

ÆRL

Jelly có chức năng đếm số nguyên tố tích hợp, ÆC và chức năng kiểm tra số nguyên tố ÆP, thay vào đó, nó sử dụng chức năng tạo số nguyên tố tích hợp ÆRvà lấy độ dài L.

Tôi đoán đây là về đường biên như sử dụng các phần tử nguyên tố tích hợp, cũng sẽ mất 3 byte với !Æv( !giai thừa, Ævtính các thừa số nguyên tố)

PHP, 96 92 byte

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;

Đã lưu 4 byte nhờ Roman Gräf

Kiểm tra trực tuyến

Mã kiểm tra bị đánh cắp:

$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;

Kiểm tra trực tuyến

APL (Dyalog Unicode) , 13 byte ^SBCS

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

Hãy thử trực tuyến!

⍳ ɩ ndices 1 ... N
 ⧽ ∘.| còn lại-bảng (sử dụng hai như rìu)
⍳ ɩ ndices 1 lệch N

0+.= tổng các phần tử bằng 0 (tức là mỗi phần tử có bao nhiêu bộ chia)

2+.= tổng các phần tử bằng hai (tức là có bao nhiêu số nguyên tố)

Python 3, 40 byte

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

Một số nguyên k là số nguyên tố nếu chỉ khi 2 ** (k-1) đồng dạng với 1 mod k. Vì vậy, chúng tôi chỉ kiểm tra điều kiện này và thêm 1 cho trường hợp k = 2.

TOÁN , 9 byte

Điều này tránh sự phân hủy yếu tố chính. Độ phức tạp của nó là O ( n ²).

:t!\~s2=s

Hãy thử trực tuyến!

:     % 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

JavaScript (ES6), 50 + 2 46 + 2 43 byte

Đã lưu 3 5 byte nhờ Neil:

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

evalcó thể truy cập ntham số.
Việc eval(...)kiểm tra nếu nlà số nguyên tố.

Các giải pháp trước đây:
Số lượng byte nên là +2 vì tôi quên đặt tên hàm f=(cần thiết cho đệ quy)

46 + 2 byte (Đã lưu 3 byte nhờ ETHproductions):

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

50 + 2 byte:

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

Java 7,102 byte

Lực lượng vũ phu

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;}

Bị đánh cắp

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 byte

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

Trên thực tế, 10 byte

Nếu câu trả lời thực tế đầu tiên của tôi không được phép sử dụng hàm tạo nguyên tố, thì đây là câu trả lời dự phòng sử dụng định lý Wilson. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

R`;D!²%`MΣ

Dùng thử trực tuyến

         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.