प्रधान गणना कार्य

Question

परिचय

प्रधानमंत्री गिनती समारोह , भी पाई समारोह के रूप में जाना , अभाज्य संख्या की राशि से कम या बराबर x देता है।$\pi(x)$

चुनौती

आपका प्रोग्राम एक पूर्णांक x लेगा जिसे आप सकारात्मक मान सकते हैं, और एक एकल पूर्णांक को x से कम या बराबर primes की मात्रा के बराबर आउटपुट कर सकते हैं। यह एक कोड-गोल्फ चुनौती है, इसलिए विजेता सबसे कम बाइट्स वाला कार्यक्रम होगा।

आप अपने चयन की किसी भी भाषा का उपयोग कर सकते हैं, बशर्ते कि यह चुनौती पूरी होने से पहले मौजूद थी, लेकिन अगर भाषा में अंतर्निहित प्राइम-काउंटिंग फ़ंक्शन या कोई प्रायोगिक जाँच फ़ंक्शन (जैसे Mathematica) है, तो वह फ़ंक्शन आपके कोड में उपयोग नहीं किया जा सकता है ।

उदाहरण इनपुट

इनपुट:
1
आउटपुट:
0

इनपुट:
2
आउटपुट:
1

इनपुट:
5
आउटपुट:
3

A000720 - OEIS

Comments

प्रधान-संबंधी अन्य कार्यों के बारे में क्या? उदाहरण के लिए, "अगले प्रधान" कवक

— लुइस मेंडो

मुख्य कारक के बारे में क्या कार्य करता है?

— माल्टीसेन

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— अदनान

जैसा कि अदनान ने कहा, पीपीसीजी में आपका स्वागत है! भविष्य की चुनौतियों के लिए, मुझे सैंडबॉक्स की सिफारिश करने दें जहां आप मुख्य साइट पर पोस्ट करने से पहले सार्थक प्रतिक्रिया और आलोचना प्राप्त करने के लिए चुनौती दे सकते हैं।

— AdmBorkBork

मुझे लगता है कि यह वही है जो @TheBikingViking को जोड़ने के लिए है: संबंधित

— mbomb007

Answer 1

05AB1E , 3 बाइट्स

!fg

यह माना जाता है कि निर्मितीकरण की अनुमति है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Comments

यह वास्तव में चालाक है!

— mbomb007

धिक्कार है, मैं अपनी भाषा में दूसरी बार हाहाकार कर रहा हूँ । +1

— अदनान

यह काम क्यों करता है?

— ओलिवर नी

@ ऑलिवर क्योंकि n का भाज्य सभी पूर्णांकों 1, ..., n (विशेष रूप से, primes p imes n ) द्वारा विभाज्य है , और अन्य प्राइम q> n के बाद से इसे छोटी संख्याओं के उत्पाद के रूप में व्यक्त नहीं किया जा सकता है।

— डेनिस

Answer 2

पायथन 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%kprimes के लिए 1 और nonprimes के लिए 0 है।

Comments

नीचे से ऊपर की ओर फैक्टरियल की गणना एक महान चाल है। +1

— ETHproductions

Answer 3

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

तीन बाइट्स ने डेनिस के प्रतिभाशाली समाधान के लिए धन्यवाद बचाया

Comments

यह फ़ंक्शन "प्राइम फैक्टर के घातांक" का उपयोग करने के लिए कम है, क्योंकि यह एक वेक्टर करता है:YF!s1=s

— लुइस मेंडो

@LuisMendo यह एक बिलकुल अलग तरीका है, इसलिए बेझिझक आगे बढ़ें और इसे पोस्ट करें। (यद्यपि यदि आप नहीं चाहते हैं, तो मैं खुशी से कहूंगा)

— डीजेमैकेम

आगे बढ़ें। मैं जेली को प्रैक्टिस करने के लिए पोर्ट करूंगा। :-)

— लुइस मेंडू

Answer 4

जेली , 8 5 बाइट्स

3 बाइट्स @ धन्यवाद के लिए बच गए!

RÆESL

इसे ऑनलाइन आज़माएं!

डेन्स द्वारा परिष्कृत किए गए DJMcMayhem के MATL उत्तर (पूर्व संस्करण) का पोर्ट ।

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

Comments

सुधार: लुइस मेंडो का पोर्ट: डीजेमेकमैम का MATL उत्तर। : पी

— DJMcMayhem

आपको केवल परिणामों की अधिकतम लंबाई की आवश्यकता होती है ÆE, क्योंकि प्रत्येक घातांक एक अलग प्रमुख कारक से मेल खाता है। RÆESLबस इतना ही हासिल होता है। !ÆELऔर भी छोटा होगा।

— डेनिस

@ डेनिस धन्यवाद! मैंने पहले सुझाव का उपयोग किया है। दूसरा भी बहुत अलग है, और आपका दृष्टिकोण है

— लुइस मेन्डो

Answer 5

ParserFunctions के साथ MediaWiki टेम्प्लेट , 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}}}}}}}}}}}}

बस 2 से n तक एक मूल परिक्षण परीक्षण । उनके आसपास तीन कोष्ठक संख्या चर हैं, जहां {{{1}}}है n , {{{2}}}, संख्या परीक्षण किया जा रहा है {{{3}}}कारक जाँच करने के लिए है।

Answer 6

पर्ल, 33 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट नंबर दें

primecount.pl

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

के लिए गलत परिणाम देता है, 0लेकिन यह ठीक है, सेशन केवल सकारात्मक पूर्णांक के लिए समर्थन के लिए कहा।

Answer 7

रेटिना, 31 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। इनपुट को एकरी में रूपांतरित करें , प्रत्येक पंक्ति में से प्रत्येक 1तक n, श्रेणी उत्पन्न करें । मुकदमों का मिलान करें।

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

इसे ऑनलाइन आज़माएं - 2800 से अधिक इनपुट या तो कई बार स्मृति से बाहर हो जाता है या बाहर चला जाता है।

संदर्भ:

मार्टिन रेंज जनरेटर

मार्टिन के प्रमुख चेकर

Answer 8

जेली , 3 बाइट्स

!Æv

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

!Æv  Main link. Argument: n

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

Answer 9

जेली , 13 11 10 9 8 7 6 बाइट्स

कोई भी अंतर्निहित मुख्य कार्यों का उपयोग नहीं करता है, जो
@ 1 मीलों के लिए 1 बाइट के लिए धन्यवाद (तालिका का उपयोग करें)
- बाइट के लिए धन्यवाद @ डेनिस (विभाजकों को गिनने के लिए एकात्मक से परिवर्तित)

ḍþḅ1ċ2

TryItOnline
या TryItOnline पर श्रृंखला के पहले 100 शब्दn=[1,100]भी देखें

कैसे?

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

Comments

आप अवशेषों की %þ`¬Sċ2तालिका का उपयोग करके 7 बाइट्स प्राप्त कर सकते हैं ।

— मील

ḍþḅ1ċ2एक बाइट बचाता है।

— डेनिस

Answer 10

जावास्क्रिप्ट (ईएस 6), 45 43 बाइट्स

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

मेरे ३६ ३५ ३५ ३३ ३३-बाइट प्राइमलिटी फंक्शन का संशोधन (१ बाइट @Neil द्वारा सेव किया गया, २ अराउनल्ड द्वारा):

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>

Comments

वाव ... मुझे समझने में थोड़ा समय लगा। अच्छी नौकरी!

— टॉडल

अफसोस की बात है कि यह आपके उत्तर पर लागू नहीं होता है, लेकिन आप शायद &अपने प्रचार के बीच में एक के साथ दूर हो सकते हैं ।

— नील

Answer 11

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लूप में फ़ॉस्टपोस्टिंग कैसे काम करता है, इसके कारण ।

Answer 12

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

ÅPgक्या यह अभी होगा, है ना?

— मैजिक ऑक्टोपस Urn

Answer 13

सीजेएम , 7 बाइट्स

rim!mF,

इसे ऑनलाइन आज़माएं! एक फैक्टराइजेशन फ़ंक्शन का उपयोग करता है।

स्पष्टीकरण:

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

Answer 14

जेली , 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.

Answer 15

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

Comments

@tfbninja हाँ, आप सही हैं, लेकिन मैंने फ़ंक्शन को केवल वही दिया है, जो इसके द्वारा संकलित नहीं है

— एरियल बेर्स्लेव्स्की

@tfbninja वास्तव में, यह नहीं है।

— आउटगॉल्फ

अच्छा लग रहा है!

— फंतासी

Answer 16

पायथ - 7 6 बाइट्स

चूँकि अन्य लोग प्रधान गुणन क्रिया का उपयोग कर रहे हैं ...

l{sPMS

टेस्ट सूट ।

Answer 17

बैश + कोरुटिल्स, 30

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

Ideone।

---

बैश + कोरुटिल्स + बीएसडी-गेम्स पैकेज, 22

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

इस छोटे से उत्तर के लिए आवश्यक है कि आपके पास bsdgames पैकेज स्थापित हो sudo apt install bsdgames:।

Answer 18

Pyke, 8 6 बाइट्स

SmPs}l

यहाँ यह कोशिश करो!

नए एल्गोरिथ्म के लिए माल्टीसेन को धन्यवाद

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

Answer 19

सी #, 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 मिलियन से ऊपर जाने के बाद थोड़ी देर के लिए शुरू होता है।

Answer 20

मतलाब, 60 बाइट्स

एक पंक्ति वाले मटलब कार्यों के लिए अपने लगाव को जारी रखना। निर्मित एक कारक का उपयोग किए बिना:

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

निष्कर्ष: उन्हें गोल्फ भाषाओं में देखने की आवश्यकता है: डी

Answer 21

दरअसल, 10 बाइट्स

यह सबसे छोटा उपाय था जो मैंने पाया कि TIO पर दुभाषिया बग में नहीं चला। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

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

Answer 22

जेली , 3 बाइट्स

ÆRL

जेली में एक बिल्ट-इन प्राइम काउंटिंग फंक्शन ÆCऔर एक प्राइम चेकिंग फंक्शन होता है ÆP, यह इसके बजाय बिल्ट-इन प्राइम जनरेटिंग फंक्शन का उपयोग करता है, ÆRऔर लंबाई लेता है L।

मुझे लगता है कि यह बॉर्डरलाइन के बारे में है जैसा कि प्राइम फैक्टराइजेशन बिल्ट-इन का उपयोग करना है, जो कि 3 बाइट्स भी लेगा !Æv( !फैक्टरियल, Ævकाउंट प्राइम फैक्टर)

Answer 23

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;

सहेजे गए 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;

ऑनलाइन टेस्ट करें

Comments

आप उपयोग क्यों करते हैं isInt(...)?1:0और न कि सिर्फisInt(...)

— रोमन ग्रैफ

@ RomanGräf धन्यवाद, आप सही हैं। मैंने बहुत सारे कोड semplification के बाद ternary को छोड़ दिया, और यह इतना स्पष्ट था कि मैं इसे नहीं देख सका ...

— Mario

Answer 24

एपीएल (Dyalog यूनिकोड) , 13 बाइट्स ^SBCS

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

इसे ऑनलाइन आज़माएं!

⍳ ɩ ndices 1 ... एन
 ⧽ ∘.| शेष-तालिका (कुल्हाड़ियों के रूप में उन दोनों का प्रयोग करके)
⍳ ɩ ndices 1 ... N

0+.= शून्य के बराबर तत्वों का योग (यानी प्रत्येक के पास कितने डिवाइडर हैं)

2+.= दो के बराबर तत्वों का योग (यानी कितने प्राइम हैं)

Answer 25

पायथन 3, 40 बाइट्स

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

एक विषम पूर्णांक k अभाज्य है यदि केवल 2 ** (k-1) 1 mod k के अनुरूप है। इस प्रकार, हम सिर्फ इस स्थिति की जांच करते हैं और k = 2 के मामले में 1 जोड़ते हैं।

Comments

2 ** n% n == 2 प्रायोगिक परीक्षण के रूप में पर्याप्त नहीं है

— RosLuP

@RosLuP यही कारण है कि n == 0 का आधार मामला 1 (n = 2 मामले के लिए खाता) जोड़ना चाहिए।

— संदीप सिलवाल

2 ** n% n == 2 सामान्य रूप से पर्याप्त नहीं है ... बहुत से (जो मुझे याद होगा उसमें अनंत) संख्याएँ जहाँ 2 ^ n% n = 2 जो कि primes नहीं हैं

— RosLuP

उदाहरण के लिए 341 = 11 * 31 लेकिन (2 ^ 341) mod 341 == 2

— RosLuP

@RosLuP: आह ठीक है, मैंने इसे देखा। इन नंबरों को Fermat Psuedoprimes कहा जाता है, लेकिन वे काफी दुर्लभ प्रतीत होते हैं: P

— संदीप सिलवाल

Answer 26

MATL , 9 बाइट्स

यह प्राइम-फैक्टर अपघटन से बचा जाता है। इसकी जटिलता हे ( 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

Answer 27

जावास्क्रिप्ट (ईएस 6), 50 + 2 46 + 2 43 बाइट्स

बचाया 3 5 बाइट्स नील को धन्यवाद:

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

evalnपैरामीटर तक पहुँच सकते हैं । जांच करता है कि प्रधानमंत्री है।
eval(...)n

---

पिछले समाधान:
बाइट काउंट +2 होना चाहिए क्योंकि मैं फ़ंक्शन का नाम देना भूल गया f=(पुनरावृत्ति के लिए आवश्यक)

46 + 2 बाइट्स (3 बाइट्स ETHproductions के लिए धन्यवाद):

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)

Comments

कम से कम मेरे ब्राउज़र पर, आपके फ़ंक्शन evalके nपैरामीटर को एक्सेस कर सकता है (जिसे आप नाम देना भूल गए हैं, जिसकी कीमत आपको 2 बाइट्स है, यह जानना अच्छा है कि मैं केवल वही नहीं हूं जो उस गलती को करता है) जो आपको 5 बाइट्स बचाता है।

— नील

@ मुझे पता नहीं था eval। फ़ायरफ़ॉक्स, क्रोम और एज के साथ परीक्षण किया गया जो मेरे लिए काम करता है। विवरण स्पष्ट है () कथन के संदर्भ में परस है । दो उदाहरण: a=12;f=b=>eval('a + 5');f(8)प्रदर्शित 17और a=12;f=a=>eval('a + 5');f(8)प्रदर्शित करता है 13।

— हेडी

Answer 28

जावा 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;}

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

Comments

यह वर्तमान में इनपुट के लिए एक गलत परिणाम दे रहा है 1। इसके 1बजाय यह वर्तमान में लौटता है 0। आप या तो बदल कर इसे ठीक कर सकते return c;करने के लिए return n<2?0:c;या बदलने के ,c=1,लिए ,c=n<2?0:1,।

— केविन क्रूज़सेन

Answer 29

q 35 बाइट्स

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

Answer 30

दरअसल, 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.