हममें से ज्यादातर लोग जानते हैं ...

कि सभी प्राइम्स p>3फॉर्म के हैं

लेकिन, एक निश्चित सीमा में प्लस प्राइम्स ( 6n+1) और कितने माइनस प्राइम्स ( 6n-1) हैं?

चुनौती

एक पूर्णांक को देखते हुए k>5, गणना करें कि प्लसप्रेम कितने primes<=kहैं और कितने माइनसप्राइम हैं ।

उदाहरण

क्योंकि k=100हमारे पास
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89] 12 MinusPrimes
और
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97] 11 PlusPrimes हैं

क्योंकि k=149हमारे पास
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89, 101, 107, 113, 131, 137, 149]
18 MinusPrimes
और
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97, 103, 109, 127, 139]
15 PlusPrimes हैं

नियम

आपके कोड में 2 पूर्णांकों का आउटपुट होना चाहिए : एक MinusPrimes के लिए और दूसरा आपको किसी भी क्रम में PlusPrimes के लिए (कृपया निर्दिष्ट करें कि कौन सा है)।
यह कोड-गोल्फ है : बाइट्स जीत में सबसे छोटा जवाब!

परीक्षण के मामलों

इनपुट -> आउटपुट [ MinusPrimes , PlusPrimes ]

6->[1,0]  
7->[1,1]   
86->[11,10]  
986->[86,78]  
5252->[351,344]  
100000->[4806,4784]   
4000000->[141696, 141448]

code-golf primes counting

45

मुझे नहीं पता था! :(

— स्टीवी ग्रिफिन

13

@StewieGriffin, यदि आप मापांक अनुक्रम को देखते हैं, तो इसे अलग करना आसान है: 0%66 का एक गुणक है, 1%6निर्धारित नहीं किया जा सकता है, 2%62 3%6का एक गुणक है, 3 4%6का एक गुणक है, 2 का एक गुणक है, 2 का एक गुणक है, और 5%6इसे निर्धारित नहीं किया जा सकता है।

— zzzzBov

3

@zzzzBov जो वास्तव में मददगार होगा अगर मुझे पता था कि मापांक में एक अनुक्रम क्यों था, और इसका मतलब क्या होता है primes ... मैं चाहता हूं कि हाई स्कूल में नंबर थ्योरी सिखाई जाए ...

— सोक्रेटिक फीनिक्स

@ लोकतांत्रिक घोइनेक्स, मापांक का अर्थ है "विभाजन के बाद शेष"। 0, 6, 12, आदि सभी 6 द्वारा विभाजन के बाद 0 का उत्पादन करते हैं; 1, 7, 13 सभी का उत्पादन 1. चूंकि हम संख्याओं की तलाश कर रहे हैं जिन्हें कारकों में विभाजित नहीं किया जा सकता है, यह जानकर कि एक संख्या 1 से अधिक पूर्णांक द्वारा विभाज्य है, हमें बताता है कि संख्या प्रमुख नहीं है।

— zzzzBov

10

05AB1E , 10 9 बाइट्स

1 बाइट को एरिक आउटग्लोफर के लिए धन्यवाद दिया

आउटपुट के रूप में [PlusPrimes, MinusPrimes]

LDpÏ6%5Ñ¢

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

L             # push range [1 ... input]
 DpÏ          # keep only primes
    6%        # mod each by 6
      5Ñ      # divisors of 5 [1, 5]
        ¢     # count

— Emigna
स्रोत

6

MATL , 10 बाइट्स

Zq6\!5lh=s

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

Zq     % Implicitly input k. Push row vector of primes up to k
6\     % Modulo 6, element-wise
!      % Transpose into a column vector
5lh    % Push row vector [5, 1]
=      % Is equal?, element-wise with broadcast
s      % Sum of each column. Implicitly display

— लुइस मेंडो
स्रोत

6

पायथन 2 , 77 बाइट्स

^{-2 बाइट्स नील को धन्यवाद}

lambda x:[sum(all(n%j for j in range(2,n))for n in range(i,x,6))for i in 7,5]

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

पिछला समाधान, 83 81 79 बाइट्स

^{-1 बाइट के लिए मिस्टर एक्सकोडर}
^{-2 बाइट्स का आभार हैलवार्ड फैमिली को}

lambda x:map([all(n%i for i in range(2,n))*n%6for n in range(4,x)].count,[5,1])

इसे ऑनलाइन आज़माएं!
दोनों आउटपुट [MinusPrimes, PlusPrimes] के रूप में

— छड़ी
स्रोत

83

— श्री एक्सकोडर

81 बाइट्स

— हल्वार्ड्ल्म्स

80?

— नील

मैंने बहुत सारे जावास्क्रिप्ट ऐरे कॉम्प्रिहेंशन किए हैं - मैं भूल गया हूँ कि पायथन लिस्ट में अक्सर []एस की जरूरत नहीं होती है ।

— नील

तो, आप सभी संख्याओं को n से i से n-1 तक विभाजित करते हैं, यह देखने के लिए कि क्या यह प्रधान है, तो सभी पूर्णांक (5,11, ...) और (7,13, ...) उत्पन्न करें और यदि परीक्षण करें प्रश्न में संख्या है, और उन्हें गिनें। कुशल लगता है। ;)

— याकूब

5

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

s6ÆPSm4

साथ ही, फिर माइनस।

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

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

s6ÆPSm4  Main link. Argument: n

s6       Split [1, ..., n] into chunks of length 6.
  ÆP     Test all integers for primality.
    S    Sum across columns.
         This counts the primes of the form 6k + c for c = 1, ..., 6.
     m4  Take every 4th element, leaving the counts for 6k + 1 and 6k + 5.

— डेनिस
स्रोत

5

गणितज्ञ, 51 बाइट्स

(s=#;Mod[Prime~Array~PrimePi@s,6]~Count~#&/@{5,1})&

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

@ngenisis ने इसे नीचे गिरा दिया, जिससे 4 बाइट बच गईं

मैथेमेटिका, 47 बाइट्स

sPrime~Array~PrimePi@s~Mod~6~Count~#&/@{5,1}

— J42161217
स्रोत

Modभी infix हो सकता है, और यदि आप पहले तर्क का नाम देने जा रहे हैं, तो sएक नामित तर्क का उपयोग करें:sPrime~Array~PrimePi@s~Mod~6~Count~#&/@{5,1}

— ngenisis

5

जाप , 15 13 11 बाइट्स

आउटपुट ऑर्डर है [+,-]।

õj ò6 yx ë4

झसे आज़माओ

डेनिस के जेली समाधान से कुछ प्रेरणा ली , लेकिन, गोल्फ के बाद, यह एक बंदरगाह होने के करीब है।
2 बाइट्स ने ëमेरे ध्यान में सरणियों के लिए पहले से अज्ञात-से-मुझे विधि लाने के लिए ओलिवर को धन्यवाद दिया।

व्याख्या

पूर्णांक का निहित इनपुट U।

õj

पूर्णांक की एक सरणी उत्पन्न करें ( õ) 1 से Uऔर जाँच करें कि क्या प्रत्येक एक प्रधान है ( j), बूलियन की एक सरणी दे।

ò6

सरणी को लंबाई 6 के उप-सरणियों में विभाजित करें।

yx

yस्तंभों को स्थानांतरित करें ( ) और योग करें।

ë4

सरणी के प्रत्येक चौथे तत्व को प्राप्त करें और अंतर्निहित रूप से उन्हें आउटपुट करें।

मूल, 19 17 16 15 बाइट्स

õ fj
5â £è_%6¥X

झसे आज़माओ

1 अल्टिव से एक प्रेरित सुझाव के लिए ऑलिवर से 5 के विभाजक का उपयोग करने के बाद मैं अपने लॉरेल पर आराम करने के लिए 15 को एक सरणी में विभाजित करता हूं।

— झबरा
स्रोत

3

जे , 23 बाइट्स

1#.5 1=/6|_1 p:@i.@p:>:

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

1#.5 1=/6|_1 p:@i.@p:>:   input: y
          _1       p:     number of primes
                     >:   less than y + 1
             p:@i.        prime range from 0 to that number
        6|                get residues modulo 6
   5 1=/                  table of values equal to 5 or 1
1#.                       sum of each (antibase 1)

— कोनोर ओ ब्रायन
स्रोत

3

रेटिना , 53 51 बाइट्स

.+
$*
1
$`1¶
G`1111
A`^(11+)\1+$
1{6}

*M`111
\b1\b

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$*

यूनीरी में बदलें।

1
$`1¶

1 से गिनती तक n।

G`1111

4 से कम संख्या हटाएं।

A`^(11+)\1+$

समग्र संख्याएँ हटाएं।

1{6}

शेष मोडुलो 6 लें।

*M`111

3 और 5 के बीच शेष के साथ संख्याओं की संख्या को प्रिंट करें।

\b1\b

शेष 1 के साथ संख्याओं की संख्या को प्रिंट करें।

— नील
स्रोत

3

रूबी, 61 60 बाइट्स

( `-rprimes`ध्वज के लिए 52 बाइट + 8 )

->n{[1,5].map{|x|(4..n).count{|i|i.prime?&&i%6==x}}}

प्रपत्र की एक सरणी लौटाता है [प्लस प्राइम्स, माइनस प्राइम्स]।

GB के लिए 1 बाइट धन्यवाद सहेजा गया!

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

— क्रिस्टियन लुपस्कू
स्रोत

मैं आपके उत्तर और अपडेटेड खदान (हास्केल में) से प्रेरित था!

— जफर

@ जफर मुझे यह सुनकर बहुत खुशी हुई! :)

— क्रिस्टियन लुपस्कु

आप countफाटक ऑपरेटर (1 बाइट बचाएं) के बिना सीमा पर उपयोग कर सकते हैं ।

— जीबी

3

पर्ल 6 , 42 बाइट्स

बेकार जगह हटाकर 1 बाइट बचाई ...

कॉल को पुनर्गठित करके 2 बाइट्स सहेजे गए map - @Joshua को धन्यवाद।

बचे 3 बाइट्स क्योंकि .round बराबर .round: 1 ।

वास्तव में जटिल घातीय शांत है लेकिन बहुत महंगा चरित्रवान है। 10 बाइट्स बचाकर बस खाई ...

{[+] map {.is-prime*($_%6-1??i!!1)},5..$_}

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

यह जटिल घातांक वाला संस्करण था। (मुझे इसे हटाना बहुत पसंद है।) नया संस्करण ठीक उसी तरह काम करता है, जिस तरह से जटिल घातांक को बहुत कम टर्नरी ऑपरेटर द्वारा बदल दिया जाता है।

{[+] map {.is-prime*exp(π*($_%6-1)i/8).round},5..$_}

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

आउटपुट एक जटिल संख्या है (PlusPrimes) + (MinusPrimes)i। मुझे उम्मीद है कि यह नियमों के खिलाफ बहुत ज्यादा नहीं है।

स्पष्टीकरण: यह एक फ़ंक्शन है जो एक पूर्णांक तर्क लेता है। हम 5 से तर्क तक सभी पूर्णांक पर पुनरावृति करते हैं ( (5..$_))। इनमें से प्रत्येक के लिए, हम मूल्यांकन करते हैं .is-prime(यह कहा जाता है $_, मैप किए गए ब्लॉक का तर्क), इसे गुणा करें (यदि इसे सुधारा जाए True == 1, False == 0), एक जटिल घातांक के साथ जो या तो exp(0) = 1(के लिए $_%6 = 1) या exp(iπ/2) = i(के लिए $_%6 = 5) बना है, और अंत में इसे गोल करें। निकटतम पूर्णांक। उन्हें समेटने [+]से परिणाम मिलता है।

अंत में: यह वास्तव में कुशल है, इसलिए मुझे यकीन नहीं है कि उच्च संख्या के लिए अपना आउटपुट प्राप्त करने से पहले टीआईओ समय नहीं देगा (1e5 के लिए, यह मेरी मशीन पर 26 सेकंड लेता है, और टीआईओ थोड़ा धीमा हो जाता है)।

— Ramillies
स्रोत

कोई बात नहीं। बहुत बढ़िया!

मुझे लगता है कि आप कुशल में मतलब है ? हालांकि अच्छा तरीका है!

— जोनाथन एलन

यह विडंबना पर एक कच्चा प्रयास था:

— रामलीज २०

जब गोल्फिंग, mapया की विधि रूपों का उपयोग करके grepकभी-कभी आप कुछ पात्रों का खर्च उठा सकते हैं। यह 2 चार्ट बचाता है:{[+] map {.is-prime*exp(π*($_%6-1)i/8).round: 1},5..$_}

— यहोशू

यहाँ ऐसा करना भूल गया, इसे मेरे ध्यान में लाने के लिए धन्यवाद!

— रामलीज

2

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

u5x`p░⌠6@%1=;`╖*ƒ⌡Ml╜

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

सबसे पहले PlusPrimes को आउटपुट करता है, उसके बाद MinusPrimes को

स्पष्टीकरण:

u5x`p░⌠6@%1=;`╖*ƒ⌡Ml╜
u5x                    range(5, n+1)
   `p░                 primes in range
      ⌠6@%1=;`╖*ƒ⌡M    for each prime:
       6@%               mod 6
          1=             equal to 1
            ;`╖*ƒ        execute ╖ if p%6==1 (add 1 to register 0, consuming p)
                   l   length of resulting list (MinusPrimes)
                    ╜  push value in register 0 (PlusPrimes)

— मेगो
स्रोत

2

स्टैक्ड , 37 बाइट्स

[~>$primeYES 6%5 1,$=table tr$summap]

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

धीमी गति से, प्रत्येक K < N के लिए primality के लिए परीक्षण । मेरे J उत्तर के समान काम करता है।

— कोनोर ओ ब्रायन
स्रोत

2

MATLAB 2017a, 29 बाइट्स

sum(mod(primes(k),6)'==[5,1])

स्पष्टीकरण: के primes(k)और के सहित सभी अपराधों को प्राप्त करता है। mod(primes(k),6)'सभी अपराधों के मापांक 6 लेता है और इसे स्थानांतरित करता है इसलिए योग सही आयाम के साथ चलता है। ==[5,1]पहले कॉलम में सभी फाइव (माइनसप्राइम) और दूसरे कॉलम में सभी (प्लसप्राइम) को 1 पर सेट करता है। sum()प्रत्येक कॉलम को गाया जाता है।

यह आउटपुट [minusPrime, plusPrime]

— Poelie
स्रोत

2

जाप , 18 16 बाइट्स

-2 बाइट्स @ ऑलिवर को धन्यवाद

õ_j ©Z%6
5â £è¥X

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

प्रारूप में आउटपुट [PlusPrimes, MinusPrimes]।

— जस्टिन मेरिनर
स्रोत

हम्म ... मैं बस अपनी डेस्क पर वापस आ गया, मेरा बाइट 17 बाइट्स तक नीचे गिरा दिया और फिर देखा कि आप इसे पोस्ट करेंगे ... मुझे नहीं पता कि मुझे इसे पोस्ट करना चाहिए या नहीं क्योंकि हमारे दोनों सॉल्यूशंस का क्रॉप मैपिंग कर रहा है [5,1]मायने रखने के लिए और आप पहले वहां पहुंच गए।

— शैगी

@Saggy IMO आपके समाधान में एक अलग पोस्ट बने रहने के लिए पर्याप्त अंतर है। आपने filter और एक स्ट्रिंग का उपयोग किया ; मैंने õएक सरणी के मैपिंग फ़ंक्शन का उपयोग किया । इसके अलावा, मुझे [5,1]एक और उत्तर से विचार मिला ।

— जस्टिन मेरिनर

मैं इस पर थोड़ा सोचूंगा; समान तरीकों का उपयोग करके विभिन्न भाषाओं में समाधान (भले ही एक "दूसरे से" उधार लिया गया हो) ठीक है, लेकिन एक ही भाषा में 2 समाधान ऐसा करने से पूरी तरह से मेरे साथ नहीं बैठते हैं। मैंने अभी के विकल्प के रूप में अपनी पोस्ट में संपादित किया है।

— शैगी

मैंने इसके साथ चलने का फैसला किया और फिर एक और बाइट का मुंडन किया।

— झबरा

आप 5âपाने के लिए उपयोग कर सकते हैं[1,5]

— ओलिवर

2

सी #, 202 179 174 बाइट्स

-23 बाइट्स मिस्टर एक्सकोडर का धन्यवाद

-5 बाइट्स साओस के लिए धन्यवाद

फ़ंक्शन जो लंबाई 2 की एक सरणी देता है, [MinusPrimes, PlusPrimes] कॉल करके निष्पादित करें a(n)।

int[]a(int n){int[]r={0,0};for(int i=5;i<=n;i++)if(i%2*b(i)>0)if(i%6<5)r[1]++;else++r[0];return r;}int b(int n){for(int i=3;i-2<Math.Sqrt(n);i+=2)if(n%i<1)return 0;return 1;}

कोशिश ऑनलाइन पर उचित स्वरूपित कोड: यहाँ

— MysticVagabond
स्रोत

क्या आप एक tio लिंक जोड़ सकते हैं?

— श्री एक्सकोडर

गोल्फ बाइट-टू-बाइट के लिए क्षमा करें, 194 बाइट्स:

public int[]a(int n){int[]r=new int[2];for(int i=5;i<=n;i++)if(i%2*b(i)>0)if(i%6<5)r[1]++;else++r[0];return r;}public int b(int n){for(int i=3;i<=Math.Sqrt(n)+1;i+=2)if(n%i<1)return 0;return 1;}

— श्री एक्सकोडर

193 बाइट्स:

public int[]a(int n){int[]r=new int[2];for(int i=5;i<=n;i++)if(i%2*b(i)>0)if(i%6<5)r[1]++;else++r[0];return r;}public int b(int n){for(int i=3;i-2<Math.Sqrt(n);i+=2)if(n%i<1)return 0;return 1;}

— मिस्टर एक्सकोडर

— लामाओ यू आर लविंग

1

सभी मदद के लिए धन्यवाद, क्योंकि आपने एक अलग उत्तर पोस्ट किया है और इसके बारे में बताया है कि मेरा एक गोल्फ है, मैं बस मेरा

— पीछा करने वाला हूं

2

हास्केल , 81 69 बाइट्स

f n=(\r->sum[1|i<-[2..n],all((>0).rem i)[2..i-1],rem i 6==r])<$>[5,1]

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

पहला उपाय था:

r!l=sum[1|i<-l,rem i 6==r]
f n|l<-[i|i<-[2..n],all((>0).rem i)[2..i-1]]=(5!l,1!l)

लेकिन मैंने रूबी में w0lf का जवाब पढ़ा ...

— jferard
स्रोत

1

अजगर , 15 बाइट्स

/K%R6fP_TSQ5/K1

परीक्षण सूट।

पायथ , 16 बाइट्स

m/%R6fP_TSQd,1 5

परीक्षण सूट।

कैसे?

स्पष्टीकरण # 1

/ K% R6fP_TSQ5 / K1 - पूर्ण कार्यक्रम।

     fP_TSQ - रेंज में primes फ़िल्टर करें [1 ... इनपुट]।
  % R6 - प्रत्येक पर मॉड 6।
 K - उन्हें एक चर K को असाइन करें।
/ 5 - K में 5 की घटनाओं को गिनें।
            / K1 - K में 1 की घटनाओं को गिनें।
                - परिणाम को तुरंत लागू करें।

व्याख्या # २

m /% R6fP_TSQd, 1 5 - पूर्ण कार्यक्रम।

     fP_TSQ - रेंज में primes फ़िल्टर करें [1 ... इनपुट]
  % R6 - प्रत्येक पर मॉड 6।
            , 1 5 - सूची को पुश करें [1, 5]
m / d - गणना करें कि प्रत्येक में से कितने हैं।  
                 - परिणाम को तुरंत लागू करें।

विकल्प:

/ K% R6fP_TSQ5 / KhZ (16 बाइट्स)
K% R6fP_TSQ / K5 / K1 (16 बाइट्स)
m /% R6fP_TSQdj15T (16 बाइट्स)
m /% R6fP_TSQd [1 5 (16 बाइट्स)   
m /% R6fP_TSQdsM`15 (17 बाइट्स)
m /% R6.MP_ZSQd, 1 5 (17 बाइट्स)
m /% R6.MP_ZSQdj15T (17 बाइट्स)
m /% R6.MP_ZSQd [1 5 (17 बाइट्स)

— मिस्टर एक्सकोडर
स्रोत

2

10k पर बधाई !!

— लुइस मेंडो

@LuisMendo बहुत धन्यवाद :-)

— श्री एक्सकोडर

1

जेली , 12 11 10 बाइट्स

चैट में कुछ टिप्स के लिए @cairdcoinheringaahing को धन्यवाद । चैट में एक-एक बाइट बचाने के लिए @ डेनिस का धन्यवाद ।

ÆR%6ċÐ€1,5

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

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

ÆR%6µ1,5=þS

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

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

ÆR%6µċ5,ċ1$

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

यह कैसे काम करता है?

स्पष्टीकरण # 1

ÆR%6ċÐ€1,5   As usual, full program.

ÆR           Get all the primes in the range [2...input].
  %6         Modulo each by 6.
       1,5   The two-element list [1, 5].
    ċÐ€      Count the occurrences of each of ^ in the prime range.

व्याख्या # २

ÆR%6µ1,5=þS   As usual, full program.

ÆR            Get all the primes in the range [2...input].
  %6          Modulo each by 6.
    µ         Chain separator.
     1,5      The two-element list [1, 5].
        =     Equals?   
         þ    Outer product.     
          S   Sum.

व्याख्या # ३

ÆR%6µċ5,ċ1$   As usual, full program.

ÆR            All the primes in the range [2...input].
  %6          Modulo each by 6.
    µ     $   Some helpers for the chains.
       ,      Two element list.
     ċ5       The number of 5s.
        ċ1    The number of 1s.

— मिस्टर एक्सकोडर
स्रोत

1

जावा 8, 141 140 138 106 101 100 96 94 81 बाइट्स

n->{int r[]={0,0},c;for(;n-->4;r[n%6/4]+=c)for(c=n;c>1;c=c-1&~n%c>>-1);return r;}

चुनौती विवरण की तुलना में उल्टे क्रम में दो मानों के साथ पूर्णांक-सरणी देता है:
[plusPrime, minusPrime] :।

पोर्ट ऑफ @Xynos 'सी # उत्तर , के बाद मैं 39 40 42 बाइट्स गोल्फ । एक और whopping -55 बाइट्स के लिए @Nevay
से भारी मदद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (अंतिम परीक्षण का मामला 400000060 सेकंड की समय सीमा से थोड़ा अधिक है।)

n->{                   // Method with integer parameter and integer-array return-type
  int r[]={0,0},       //  Return integer-array, starting at [0,0]
      c;               //  Temp integer
  for(;n-->4;          //  Loop (1) as long as the input is larger than 4
                       //  and decrease `n` by 1 before every iteration
      r[n%6/4]+=c)     //    After every iteration, increase the plus or minus prime by `c`
                       //    (where `c` is either 0 or 1)
    for(c=n;           //   Reset `c` to `n`
        c>1;           //   And inner loop (2) as long as `c` is larger than 1
      c=               //    Change `c` to:
        c-1&~n%c>>-1;  //     inverting the bits of `n`,                    [~n]
                       //     modulo-`c` that result,                       [%c]
                       //     then bit-shift right that by -1,              [>>-1]
                       //     and then bitwise-AND that result with `c-1`   [c-1&]
    );                 //   End of inner loop (2)
                       //  End of loop (1) (implicit / single-line body)
  return r;            //  Return result integer-array
}                      // End of method

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

1

106 बाइट्स:n->{int r[]={0,0},i=4,j,c;for(;i++<n;){for(j=c=1;j*j<i;)c=i%(j+=2)<1?0:c;if(i%2*c>0)r[i%6%5]++;}return r;}

— नेवई

1

101 बाइट्स:n->{int r[]={0,0},i=4,j,c;for(;i++<n;r[i%6%5%2]-=-i%2*c>>-1)for(j=c=1;j*j<i;)c|=i%(j+=2)-1;return r;}

— नेवे

1

96 बाइट्स: n->{int r[]={0,0},i=4,j,c;for(;i++<n;r[i%6%5%2]+=i&c)for(j=c=1;j*j++<i;)c&=-i%++j>>-1;return r;}(-1 आपके लिए धन्यवाद j++,++j)

— नेवे

1

94 बाइट्स: n->{int r[]={0,0},i=4,j,c;for(;i++<n;r[i%6/4]+=i&c)for(j=c=1;j*j++<i;)c&=-i%++j>>-1;return r;}( [plusPrime, minusPrime])।

— नेवय

1

81 बाइट्स:n->{int r[]={0,0},c;for(;n-->4;r[n%6/4]+=c)for(c=n;c>1;)c=c-1&~n%c>>-1;return r;}

— नेवई

1

जावास्क्रिप्ट (ईएस 6), 83 82 80 68 66 बाइट्स

एक पूरी तरह से पुनरावर्ती समाधान निकला एक सरणी मैप करने की तुलना में बहुत कम था !

आउटपुट ऑर्डर है [-,+]। 3490 के आसपास कहीं अतिप्रवाह त्रुटि के साथ क्रेप्स।

f=(n,a=[0,0])=>n>4?f(n-1,a,(g=y=>n%--y?g(y):y<2)(n)&&++a[n%6%5]):a

कोशिश करो

o.innerText=(

f=(n,a=[0,0])=>n>4?f(n-1,a,(g=y=>n%--y?g(y):y<2)(n)&&++a[n%6%5]):a

)(i.value=6);oninput=_=>o.innerText=i.value>5?f(+i.value):[0,0]

<input id=i min=6 type=number><pre id=o>

स्निपेट का विस्तार करें

— झबरा
स्रोत

0

CJam , 19 बाइट्स

ri){mp},6f%_5e=p1e=

प्रोग्राम जो एसटीडीआईएन से इनपुट लेता है, और एसटीडीयूएस के माध्यम से न्यूलाइन द्वारा अलग किए गए दो नंबरों को आउटपुट करता है।

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

व्याख्या

ri){mp},6f%_5e=p1e=

ri                        Read integer k
  )                       Add 1
       ,                  Filter the (implicit) array [0 1 ... k] ...
   {mp}                   ... on the function "is prime"
         f                Map over the resulting array...
          %               ... the function "modulus" ...
        6                 ... with extra parameter 6
           _              Duplicate the resulting array
             e=           Count occurrences ...
            5             ... of number 5
               p          Print with newline
                 e=       Count occurrences ...
                1         ... of number 1. Implicitly display

— लुइस मेंडो
स्रोत

0

आर + संख्या , 66 60 58 40 बाइट्स

-16 बाइट्स जारको डबेलडैम को धन्यवाद! मैंने बाद में एक और दो बाइट्स को गोल्फ से बाहर कर दिया।

cat(table(numbers::Primes(4,scan())%%6))

प्रिंट PlusPrimes MinusPrimesकरने के लिए प्रिंट ; स्टड से पढ़ता है।

tableमूल्य के आरोही क्रम में, अपने इनपुट वेक्टर में मूल्यों की प्रत्येक घटना की गणना को सारणीबद्ध करता है। इसलिए, चूंकि केवल दो मान हैं, अर्थात् 1और 5(मॉड 6), यह ठीक उसी प्रकार का कार्य है जिसकी हमें आवश्यकता है, साथ में और इनपुट के numbers::Primesबीच के सभी अपराधों को लौटाता है 4।

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

बेस आर , 97 91 89 86 65 बाइट्स

यहाँ भी जारको द्वारा बचाए गए बाइट्स का एक गुच्छा

function(n)table((5:n)[sapply(5:n,function(x)all(x%%2:x^.5))]%%6)

यह ऊपर दिए गए लगभग समान है, सिवाय इसके कि यह एक पैकेज का उपयोग करने के बजाय बेस आर में सभी अपराधों की गणना करता है, और यह इसे प्रिंट करने के बजाय फ़ंक्शन आउटपुट द्वारा वापस करता है। आप आउटपुट में देख सकते हैं कि यह नामों के साथ एक तालिका देता है 1और 5, नीचे की गणना के साथ।

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

— ग्यूसेप
स्रोत

47 बाइट्स

— JAD

(डेनिस ने TIO में नंबर जोड़े, ताकि अब काम करें :))

— JAD

42 बाइट्स

— JAD

all(x%%2:x^.5>0), कुछ भी नॉनजरो पहले से ही सत्य है, इसलिए all(x%%2:x^.5)भी काम करता है

— JAD

@JarkoDubbeldam बहुत अच्छा! चूंकि सभी मूल्य अधिक हैं, 4इसलिए हम इससे छुटकारा पा सकते हैं >4क्योंकि हमारे पास 2अब प्राइम के रूप में नहीं होगा , इसलिए इस गोल्फ को 40 बाइट के बजाय।

— Giuseppe

0

परी / जीपी , 41 बाइट्स

n->vecsum([[i>3,i<3]|i<-primes([4,n])%6])

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

— alephalpha
स्रोत

0

जावास्क्रिप्ट (स्पाइडरमोंकी) , 151 , 140 , 131 बाइट्स

n=>[...Array(n+1).keys()].splice(5).filter(a=>!/^1?$|^(11+?)\1+$/.test("1".repeat(a))).reduce((r,a)=>(a%6<2?r[1]++:r[0]++,r),[0,0])

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

बग फिक्स और गोल्फिंग के साथ मदद करने के लिए झबरा धन्यवाद।

स्पष्टीकरण:

n=>                                                   // Create a lambda, taking n
    [...Array(n+1).keys()]                            // Create a list from 0 to n+1
        .splice(5)                                    // remove first five elements
        .filter(a=>                                   // filter the list to get primes
             !/^1?$|^(11+?)\1+$/.test("1".repeat(a))) // using the famous regex here: https://stackoverflow.com/questions/2795065/how-to-determine-if-a-number-is-a-prime-with-regex 
        .reduce((r,a)=>                               // reduce the list
           (a%6<2?r[1]++:r[0]++,r),                   // by counting plus primes
           [0,0])                                     // and minus primes

— Pureferret
स्रोत

1

17,15149 के लिए रिटर्न्स (होना चाहिए 18,15)। आपको अपने सरणी का आकार 1: TIO तक बढ़ाना होगा । संयोग से, यह सिर्फ "वैनिला" ईएस 6 है, इसमें स्पाइडरमोनकी के लिए कुछ भी विशिष्ट नहीं है। इसके अलावा, आप TIO के बजाय JS के लिए Stack Snippets का उपयोग कर सकते हैं। और, आपके पास बहुत सारे स्थान हैं जिन्हें आप हटा सकते हैं।

— झबरा

1

आपके लिए त्वरित बचत का एक और युगल, आपको 131 बाइट्स तक ले जाने के लिए ।

— झबरा

@ शैगी मुझे महसूस नहीं हुआ कि आप इस तरह कम कर सकते हैं।

— प्यूरफेरेट

प्लस प्राइम्स बनाम माइनस प्राइम

हममें से ज्यादातर लोग जानते हैं ...

चुनौती

उदाहरण

नियम

परीक्षण के मामलों

05AB1E , 10 9 बाइट्स

MATL , 10 बाइट्स

व्याख्या

पायथन 2 , 77 बाइट्स

पिछला समाधान, 83 81 79 बाइट्स

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

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

गणितज्ञ, 51 बाइट्स

मैथेमेटिका, 47 बाइट्स

जाप , 15 13 11 बाइट्स

व्याख्या

मूल, 19 17 16 15 बाइट्स

जे , 23 बाइट्स

रेटिना , 53 51 बाइट्स

रूबी, 61 60 बाइट्स

( -rprimesध्वज के लिए 52 बाइट + 8 )

पर्ल 6 , 42 बाइट्स

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

स्टैक्ड , 37 बाइट्स

MATLAB 2017a, 29 बाइट्स

जाप , 18 16 बाइट्स

सी #, 202 179 174 बाइट्स

हास्केल , 81 69 बाइट्स

अजगर , 15 बाइट्स

पायथ , 16 बाइट्स

कैसे?

स्पष्टीकरण # 1

व्याख्या # २

जेली , 12 11 10 बाइट्स

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

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

यह कैसे काम करता है?

स्पष्टीकरण # 1

व्याख्या # २

व्याख्या # ३

जावा 8, 141 140 138 106 101 100 96 94 81 बाइट्स

जावास्क्रिप्ट (ईएस 6), 83 82 80 68 66 बाइट्स

कोशिश करो

CJam , 19 बाइट्स

व्याख्या

आर + संख्या , 66 60 58 40 बाइट्स

बेस आर , 97 91 89 86 65 बाइट्स

परी / जीपी , 41 बाइट्स

जावास्क्रिप्ट (स्पाइडरमोंकी) , 151 , 140 , 131 बाइट्स

( `-rprimes`ध्वज के लिए 52 बाइट + 8 )