บทนำ

ฟังก์ชั่นการนับนายกรัฐมนตรียังเป็นที่รู้จักฟังก์ชั่น Pi กลับปริมาณของจำนวนเฉพาะที่น้อยกว่าหรือเท่ากับ x$\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.

Python 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%kเป็น 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

เจลลี่ , 8ไบต์ 5

บันทึก 3 ไบต์ด้วย @Dennis!

RÆESL

ลองออนไลน์!

พอร์ตของคำตอบ MATLABของDJMcMayhem (เวอร์ชั่นเดิม) ปรับปรุงโดย 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

เทมเพลต MediaWiki ที่มีParserFunctions , 220 + 19 = 239 ไบต์

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

เพียง primality ทดสอบขั้นพื้นฐานตั้งแต่ 2 ถึงn ตัวเลขที่มีสามวงเล็บรอบตัวพวกเขาเป็นตัวแปรที่{{{1}}}เป็นn , {{{2}}}เป็นจำนวนที่ได้รับการทดสอบ{{{3}}}เป็นปัจจัยในการตรวจสอบ

Perl, 33 ไบต์

รวม +1 สำหรับ -p

ระบุหมายเลขอินพุตใน STDIN

primecount.pl

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

ให้ผลลัพธ์ที่ไม่ถูกต้อง0แต่ก็ไม่เป็นไร op ขอการสนับสนุนสำหรับจำนวนเต็มบวกเท่านั้น

เรติน่า 31 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1 แปลงอินพุตเป็น unary สร้างช่วงจาก1ถึงnแต่ละบรรทัดของตัวเอง ตรงกับช่วงเวลา

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

ลองออนไลน์ - อินพุตใหญ่กว่า 2,800 ครั้งหรือหน่วยความจำหมด

อ้างอิง:

เครื่องกำเนิดไฟฟ้าของมาร์ติน

ตัวตรวจสอบที่สำคัญของ Martin

เยลลี่ 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)

JavaScript (ES6), 45 43 ไบต์

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

การปรับเปลี่ยนฟังก์ชัน primality 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เนื่องจากการทำงานของเสารั้วใน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);}

Ungolfed

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 bytes

Since others are using prime factorization functions...

l{sPMS

Test Suite.

Bash + coreutils, 30

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

Ideone

Bash + coreutils + แพ็คเกจเกม BSD, 22

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

นี้คำตอบสั้น ๆ ที่คุณต้องมีแพคเกจติดตั้ง sudo apt install bsdgamesbsdgames:

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

เริ่มที่จะสักครู่เมื่อคุณไปมากกว่า 1 ล้าน

Matlab, 60 ไบต์

ดำเนินการต่อไฟล์แนบของฉันกับฟังก์ชัน Matlab แบบบรรทัดเดียว โดยไม่ต้องใช้การแยกตัวประกอบ:

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

ระบุว่านายกyมีเพียงสองปัจจัยใน[1,y]: เรานับตัวเลขในช่วง[1,x]ที่มีเพียงสองปัจจัย

Using factorisation allows for significant shortening (down to 46 bytes).

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

Conclusion: Need to look into them golfing languages :D

Actually, 10 bytes

This was the shortest solution I found that didn't run into interpreter bugs on TIO. Golfing suggestions welcome. Try it online!

;╗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.

Jelly, 3 bytes

ÆRL

Jelly has a built-in prime counting function, ÆC and a prime checking function, ÆP, this instead uses a built-in prime generating function, ÆR and takes the length L.

I guess this is about as borderline as using prime factorisation built-ins, which would also take 3 bytes with !Æv (! factorial, Æv count prime factors)

PHP, 96 92 bytes

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;

Saved 4 bytes thanks to Roman Gräf

Test online

Ungolfed testing code:

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

Test online

APL (Dyalog Unicode), 13 bytes^SBCS

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

Try it online!

⍳ ɩndices 1…N
 ⧽ ∘.| remainder-table (using those two as axes)
⍳ ɩndices 1…N

0+.= the sum of the elements equal to zero (i.e. how many dividers does each have)

2+.= the sum of the elements equal to two (i.e. how many primes are there)

Python 3, 40 bytes

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

An odd integer k is prime if an only if 2**(k-1) is congruent to 1 mod k. Thus, we just check for this condition and add 1 for the case of k=2.

MATL, 9 bytes

This avoids prime-factor decomposition. Its complexity is O(n²).

:t!\~s2=s

Try it online!

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

Saved 3 5 bytes thanks to Neil:

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

eval can access the n parameter.
The eval(...) checks if n is prime.

Previous solutions:
Byte count should be +2 because I forgot to name the function f= (needed for recursion)

46+2 bytes (Saved 3 bytes thanks to ETHproductions):

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

50+2 bytes:

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

Java 7,102 bytes

Brute force

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

Ungolfed

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 bytes

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

Actually, 10 bytes

If my first Actually answer is disallowed for using a prime-generating function, here is a backup answer using Wilson's theorem. Golfing suggestions welcome. Try it online!

R`;D!²%`MΣ

Try it online

         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.