नहीं, मेरा मतलब यह नहीं है ϕ = 1.618...और π = 3.14159...। मेरा मतलब कार्यों से है ।

φ (x) पूर्णांक की तुलना में कम या उससे अधिक पूर्णांकों की संख्या है xजो अपेक्षाकृत प्रमुख हैं x।
π (x) पूर्व की तुलना में कम या बराबर primes की संख्या है x।
मान लीजिए कि "pi नहीं" तब that (x) है और इसे कम या अधिक के बराबर कंपोजिट की संख्या के रूप में परिभाषित करते हैं x।

कार्य

कड़ाई से सकारात्मक पूर्णांक को देखते हुए x, φ (x (x)) की गणना करें । स्कोरिंग बाइट्स में है।

उदाहरण

प्रत्येक पंक्ति में इनपुट (1 से 100, समावेशी) और एक अंतरिक्ष द्वारा अलग-अलग आउटपुट होते हैं।

किसी भी इनपुट के लिए अपेक्षित आउटपुट की गणना करने के लिए इस लिंक का उपयोग करें । इसके अलावा, pastebin पर इनपुट और आउटपुट की एक सूची यहां दीx <= 1000 गई है । ( इस Minkolang कार्यक्रम के साथ उत्पन्न ।)

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

var QUESTION_ID=63710,OVERRIDE_USER=12914;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Expand snippet

code-golf sequence primes number-theory code-golf decision-problem code-golf date code-golf typography code-golf math number multiple-holes code-golf quine code-golf string syntax code-golf math primes rational-numbers code-golf graphical-output image-processing code-golf kolmogorov-complexity music audio code-golf string code-golf math geometry code-golf math sequence combinatorics code-golf game grid board-game code-golf restricted-source array-manipulation source-layout code-golf base-conversion binary code-golf math physics code-golf math number date expression-building code-golf array-manipulation graph-theory decision-problem popularity-contest error-correction code-golf kolmogorov-complexity geometry grid code-challenge arithmetic combinatorics set-partitions code-golf kolmogorov-complexity sequence fibonacci code-golf restricted-source pristine-programming code-golf code-golf string kolmogorov-complexity code-golf arithmetic code-golf string parsing code-golf code-golf sorting counting permutations 3d code-golf code-golf ascii-art music code-golf string code-golf string ascii-art code-golf string code-golf quine polyglot code-golf math string code-golf internet

— एलेंडिया स्ट्राटन
स्रोत

क्या इनपुट के आकार की सीमाएं हैं?

— lirtosiast

4

क्या यह सवाल उपयोगकर्ता PhiNotPi के लिए एक श्रद्धांजलि है ?

— प्रिमो

24

@primo आप ऐसा क्यों सोचेंगे?

— मेगो

2

@primo: यह उसके नाम से प्रेरित था, और निश्चित रूप से उस पर एक दंड था, लेकिन उसके लिए बिल्कुल श्रद्धांजलि नहीं।

— एल'एंडिया स्ट्रोमैन

1

@ edc65: हां, जाहिरा तौर पर ऐसा है , जैसा कि मुझे कल पता चला।

— एल'एंडिया स्ट्रोमैन

27

जीएस 2 , 12 10 बाइट्स

V@'◄l.1&‼l

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

परीक्षण चालन

$ xxd -r -ps <<< 564027116c2e3126136c > phinotpi.gs2
$ wc -c phinotpi.gs2 
10 phinotpi.gs2
$ gs2 phinotpi.gs2 <<< 1000
552

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

V          Read an integer n from STDIN.
 @         Push a copy of n.
  '        Increment the copy of n.
   ◄l      Push 1 and call primes; push the list of all primes below n+1.
     .     Count the primes.
      1    Subtract the count from n.
       &   Decrement to account for 1 (neither prime nor composite).
        ‼l Push 3 and call primes; apply Euler's totient function.

— डेनिस
स्रोत

25

फ़ाइल का नाम प्रोग्राम से अधिक लंबा है।

— फ्लोरिस

43

रेगेक्स (.NET), 122 113 बाइट्स

^(?=((?=.*$(?<=^(\3+(.+.))(.*?(?>(.\4)?)))).)+(.*))((?=.*(?=\6$)(?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?)))).)+

मान लें कि इनपुट और आउटपुट एकात्मक हैं, और आउटपुट रेगेक्स के मुख्य मैच से लिया गया है।

रेगेक्स का टूटना:

^(?=((?=.*$(?<=^(\3+(.+.))(.*?(?>(.\4)?)))).)+(.*)) of (x) की गणना करता है और दूसरे भाग में अभिकथन के लिए समूह 6 को कैप्चर करने में स्ट्रिंग के बाकी हिस्सों को पकड़ता है।
- .*$सूचक को स्ट्रिंग के अंत तक सेट करता है ताकि हमारे पास पूरी संख्या xएक दिशा में हो।
- (?<=^(\3+(.+.))(.*?(?>(.\4)?))) दाएं से बाएं और माचिस की संख्‍या x से 0 तक लूपिंग द्वारा चेक करता है।
  - (.*?(?>(.\4)?))एक "वैरिएबल" है जो पहले पुनरावृत्ति में 0 से शुरू होता है और पिछले पुनरावृत्ति में संख्या से जारी रहता है और x तक लूप करता है। चूँकि सबसे छोटी संमिश्र संख्या 4 है, इसलिए (.\4)?यदि समूह 4 उपलब्ध है, कैप्चर करने से मेल नहीं खाता।
  - ^(\3+(.+.))ऊपर "चर" द्वारा छोड़ दिया गया है कि जाँच करता है (यानी x - "variable") कि क्या यह एक समग्र संख्या है।
((?=.*(?=\6$)(?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?)))).)+बाएं से दाएं संचालन को सीमित करके π̅ (π̅ (x)) की गणना करता है (?=\6$)।
- .*(?=\6$)पॉइंटर को स्थिति position (x) पर सेट करता है। चलो y = den (x) को निरूपित करते हैं।
- (?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?))) दाएं से बाएं और माचिस से सापेक्ष प्राइम के लिए जांच (y - 1) से 0 तक
  - (.+?(?>\9?)) एक "वैरिएबल" है जो पहले पुनरावृत्ति में 1 से शुरू होता है और पिछले पुनरावृत्ति में संख्या से जारी रहता है और y तक लूप करता है
  - (?!(.+.)\8*(?=\6$)(?<=^\8+))बाएं से दाएं ¹ से मेल खाता है और जांचता है कि "चर" और y सापेक्ष प्रधान हैं या नहीं।
    - (.+.)\8*(?=\6$) "वैरिएबल" का एक भाजक चुनता है जो 1 से बड़ा है, और इसका एक दुष्प्रभाव यह है कि हमारे पास बाईं ओर पूरी संख्या y है।
    - (?<=^\8+) जाँच करता है कि क्या "चर" का भाजक भी y का भाजक है।

^{¹ .NET में, देखो-आगे वर्तमान दिशा का पालन करने के बजाय LTR को दिशा निर्धारित करता है; लुक- बैक दिशा को उलटने के बजाय RTL को दिशा निर्धारित करता है।}

RegexStorm पर रेगेक्स का परीक्षण करें ।

संशोधन 2 गैर-कैप्चरिंग समूहों को छोड़ देता है और सशर्त सिंटैक्स के बजाय परमाणु समूहों का उपयोग करता है।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत

24

सर, आप पागल हैं।

— आर.के.

9

वह मुझे लगता है कि Zalgo का एक स्पर्श है।

— जिज्ञासु ने 13

11

और अब आपको दो समस्याएं हैं। (गंभीरता से पता नहीं था कि आप रेगेक्स के साथ इस तरह का काम कर सकते हैं ...)

— डारेल हॉफमैन

21

जे, 15 14 बाइट्स

5 p:<:-_1 p:>:

यह एक मौसमी, मौदिक क्रिया है। इसे Jjs के साथ ऑनलाइन आज़माएं ।

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

                Right argument: y
            >:  Increment y.
       _1 p:    Calculate the number of primes less than y+1.
    <:          Decrement y.
      -         Calculate the difference of the results to the left and right.
5 p:            Apply Euler's totient function to the difference.

— डेनिस
स्रोत

14

मैं खतरनाक व्याख्या कर सकता हूं? : P

— aoksquirrel

23

मैंने खतरनाक विवरण दिया

— डेनिस

5

मैं यह कहने वाला था कि मैंने इसे उखाड़ फेंका है क्योंकि इसमें बहुत सारी स्माइलीज हैं, लेकिन पाठ ने मुझे उन लोगों से बचने के लिए कहा :(

— डोडी

@ डेनिस: आपके पहले उत्तर ने मुझे बहुत मुश्किल से हँसाया, इसके लिए धन्यवाद!

— मेहरदाद

19

गंभीरता से , 27 बाइट्स

,;R`p`MΣ(-D;n;;╟@RZ`ig1=`MΣ

हां, मैंने सीजेएम को हराया! इसे ऑनलाइन आज़माएं

स्पष्टीकरण ( aस्टैक के शीर्ष को bसंदर्भित करता है, दूसरे-से-शीर्ष को संदर्भित करता है):

,;       take input and duplicate it
R`p`MΣ   push sum([is_prime(i) for i in [1,...,a]]) (otherwise known as the pi function)
(-D      rotate stack right by 1, subtract top two elements, subtract 1, push
            (@ could be used instead of (, but I was hoping the unmatched paren would bother someone)
;n;;     dupe top, push a b times, dupe top twice (effectively getting a a+1 times)
╟        pop n, pop n elements and append to list, push
@        swap top two elements
RZ       push [1,...,a], zip a and b
`ig1=`   define a function:
  i        flatten list
  g1=      compute gcd(a,b), compare to 1 (totient function)
MΣ       perform the function a on each element of b, sum and push

नोट: इस उत्तर की पोस्टिंग के बाद से, मैंने pi और phi फ़ंक्शन को गंभीरता से जोड़ा है। यहाँ उन कार्यों के साथ एक गैर-जवाबदेह उत्तर है:

,;▓1-@-▒

स्पष्टीकरण (कुछ आदेश दूसरों को ओवरलैप नहीं करने के लिए स्थानांतरित किए जाते हैं):

,    get input (hereafter referred to as x)
;    duplicate x
 ▓   calculate pi(x) (we'll call this p)
1-   calculate 1-p
@-   bring x back on top, calculate x-1-p (not pi(x))
  ▒  calculate phi(not pi(x))

— मेगो
स्रोत

1

आपने @Dennis को गंभीरता से पूरा किया है!

— तनमथ

कृपया मुझे यह न बताएं कि आप इसे अपने सिर के शीर्ष पर जानते थे ..

— DividedByZero

1

जीजे की पिटाई सीजेएम =)

— दोष

14

जूलिया, 52 50 बाइट्स

x->count(i->gcd(i,p)<2,1:(p=x-endof(primes(x))-1))

यह एक अनाम फ़ंक्शन बनाता है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=x->...।

Ungolfed:

function phinotpi(x::Integer)
    # The number of composites less than or equal to x is
    # x - the number of primes less than or equal to x -
    # 1, since 1 is not composite
    p = x - length(primes(x)) - 1

    # Return the number of integers i between 1 and p such
    # that gcd(i, p) = 1. This occurs when i is relatively
    # prime to p.
    count(i -> gcd(i, p) == 1, 1:p)
end

— एलेक्स ए।
स्रोत

sumइसके बजाय countकुछ पात्रों को बचाने के लिए उपयोग करें । यह थोड़ा निराशाजनक है, हालांकि - primes को गिनने का दूसरा तरीका sum(isprime,1:x), बिल्कुल वैसा ही है जैसा कि endof(primes(x))।

— ग्लेन ओ

1

@GlenO सुझाव के लिए धन्यवाद, लेकिन रिटर्न के sumलिए खाली संग्रह के लिए विफल रहता countहै। 0. इस प्रकार के sumलिए वांछित परिणाम नहीं होगा x<4।

— एलेक्स ए।

8

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

EulerPhi[#-PrimePi@#-1]&

— LegionMammal978
स्रोत

2

के पाठ्यक्रम मेथेमेटिका इस में ... बनाया के सभी है

— ताली

@ConfusedMr_C स्पष्ट रूप से :) हालांकि, यह एक स्पष्ट कारण के लिए अयोग्य घोषित नहीं किया गया था: गणितीय सॉफ्टवेयर सरल दहनशील कार्यों में गोल्फ लैंगगेज को हरा नहीं सकता है :)

— यो

@ConfusedMr_C PhiNotPi@#&: 11 बाइट्स: P

— लीजनमैनल 978

8

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

JlftPTSQ/iLJJ1

प्रदर्शन , सत्यापनकर्ता

हम एक साधारण फिल्टर का उपयोग करके कंपोजिट की गणना करते हैं, इसकी लंबाई लेते हैं, और इसे बचाते हैं J। फिर, हम Jप्रत्येक संख्या के साथ gcd लेते हैं J, और गिनते हैं कि कितने परिणाम 1 के बराबर हैं।

— isaacg
स्रोत

7

मिंकोलंग 0.11 , 12 बाइट्स (प्रतिस्पर्धी नहीं)

यह उत्तर प्रतिस्पर्धी नहीं है। मैंने प्रश्न पोस्ट करने से पहले पी-पी और फी को बिल्ट-इन के रूप में लागू किया, जिससे मुझे अनुचित लाभ मिला। मैं यह केवल उन लोगों के लिए पोस्ट करता हूं जो भाषा में रुचि रखते हैं।

nd9M-1-9$MN.

इसे यहाँ आज़माएँ।

व्याख्या

n      Read in integer from input
d      Duplicate
9M     Pops off the top of stack as x and pushes pi(x)
-      Subtracts the top two elements on the stack (x - pi(x))
1-     Subtracts 1 (x-1 - pi(x))
9$M    Pops off the top of stack as x and pushes phi(x) (phi(x-1 - pi(x)))
N.     Outputs as integer and stops.

— एलेंडिया स्ट्राटन
स्रोत

2

मुझे नहीं लगता कि अमान्य उत्तर प्रकाशित करना एक अच्छा विचार है ...

— यति

20

जब तक उनके पास एक अस्वीकरण है, मुझे नहीं लगता कि इसमें कुछ भी गलत है। यह वास्तव में पुरानी चुनौतियों के लिए बहुत आम है।

— डेनिस

4

@yeti: तकनीकी रूप से, यह अमान्य नहीं है। चुनौती पोस्ट किए जाने से पहले यहां इस्तेमाल की जाने वाली सुविधाएँ लागू की गई थीं। मैं केवल इसे अयोग्य घोषित करता हूं क्योंकि मैंने चुनौती को पोस्ट करने में देरी की जब तक कि दो विशेष विशेषताओं को लागू नहीं किया गया था (जो मैं उदाहरण सूचियों, घटनाओं को उत्पन्न करने के लिए उपयोग करता था)।

— एलेंडिया स्ट्राटन

1

वही। मैं ऐसा तब करता हूं जब when अपडेट होता रहता है।

— मामा फन रोल

6

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

ri){mf1>},,_,f{){_@\%}h)=}1b

कोशिश करो इस बेला CJam दुभाषिया में या एक ही बार में सभी प्रकार के परीक्षण की पुष्टि ।

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

ri                            Read an integer N from STDIN.
  )                           Increment it. 
   {    },                    Filter; for each I in [0 ... N]:
    mf                          Push I's prime factorization.
      1>                        Discard the first prime.
                              If there are primes left, keep I.
          ,                   Count the kept integers. Result: C
           _,                 Push [0 ... C-1].
             f{          }    For each J in [0 ... C-1], push C and J; then:
               )                Increment J.
                {    }h         Do:
                 _                Push a copy of the topmost integer..
                  @               Rotate the integer below on top of it.
                   \%             Take that integer modulo the other integer.
                                If the residue is non-zero, repeat the loop.
                                This computes the GCD of C and J+1 using the
                                Euclidean algorithm.
                       )        Increment the 0 on the stack. This pushes 1.

                        =     Push 1 if the GCD is 1, 0 if not.
                          1b  Add all Booleans.

— डेनिस
स्रोत

मैंने "सभी मामलों को सत्यापित करने" लिंक की कोशिश की और यह मिला 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111:। क्या वह सही है?

— एलेंडिया स्ट्राटन

हां, यह जांचता है कि कोड को बाएं कॉलम (इनपुट) पर लागू करना सही कॉलम (आउटपुट) के बराबर है।

— डेनिस

5

मैं dis1 पर खतरनाक व्याख्या कर सकता हूं?

— अगस्त को एकवॉस्केलर

9

@anOKsquirrel i खतरनाक ने डिस 2 को समझाया

— डेनिस

5

@ डेनिस kthxbai

— anoksquirrel

5

अजगर, १३th १३ ९

n=input()
print n,len([b for b in range(len([a for a in range(n)if not all(a%i for i in xrange(2,a))]))if all(b%i for i in xrange(2,b))])

— wnnmaw
स्रोत

2

मुझे लगता है कि आप के बीच रिक्त स्थान को हटाने के द्वारा 2 बाइट्स बचा सकता है range(n) ifऔर])) if

— DankMemes

3

पाइथन की अपेक्षाकृत कम गोल्फ-क्षमता (व्हॉट्सएप आवश्यकताओं के कारण, आदि) को देखते हुए यह बहुत प्रभावशाली है!

— felixphew

@DankMemes, टिप के लिए धन्यवाद!

— wnnmaw

5

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

.+
$*
M&`(..+)\1+$
.+
$*
(?!(..+)\1*$(?<=^\1+)).

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

व्याख्या

.+
$*

इनपुट को unary में बदलें।

M&`(..+)\1+$

गिनती से इनपुट से अधिक नहीं समग्र संख्या की गणना करें कि हम कितनी बार एक स्ट्रिंग से मेल खा सकते हैं जिसमें कम से कम 2 के कारक के कम से कम दो दोहराव शामिल हैं।

.+
$*

फिर से संयुक्त में परिवर्तित करें।

(?!(..+)\1*$(?<=^\1+)).

गणना करें many उस स्थिति से प्रत्यय के एक कारक (कम से कम 2) को खोजने के लिए कितने पदों से गणना संभव नहीं है जो उपसर्ग का एक कारक भी है (यदि हम ऐसा कोई कारक पाते हैं तो यह i <= nएक कारक के साथ साझा करता है) nइसलिए इसके प्रति सहानुभूति नहीं है)। .अंत में सुनिश्चित करता है कि हम शून्य गिनती नहीं है (जिसके लिए हम कम से कम 2 का एक पहलू नहीं मिल सकता है)।

— मार्टिन एंडर
स्रोत

5

रेगेक्स (.NET), 88 86 बाइट्स

^(?=((?=(..+)\2+$)?.)+)(?=(?<-2>.)*(.+))(?=(((?!(..+)\6*(?<=^\6+)\3$))?.)*\3)(?<-5>.)*

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

समान I / O का उपयोग n̴̖̋h̷͉̃a̸̡̅ẗ̵̨́h̷̰̀ĥ̷̳d s के उत्तर के रूप में किया जाता है , अर्थात unary input और यह परिणाम की लंबाई के एक विकल्प से मेल खाता है।

आगे के संदर्भों के साथ एक या दोनों संतुलन समूहों को बदलकर इसे और छोटा करना संभव हो सकता है।

एक ही बाइट गिनती में वैकल्पिक:

^(?=((?=(..+)\2+$)?.)+)(?=(?<-2>.)*(.+))(?=(?((..+)\4*(?<=^\4+)\3$).|(.))*\3)(?<-5>.)*

पहली छमाही के लिए कुछ विकल्प भी हैं, जैसे कि कंपोजिटिव नंबरों के लिए एक सकारात्मक के बजाय एक नकारात्मक लुकहेड का उपयोग करना, या वहां एक सशर्त का उपयोग करना।

व्याख्या

मुझे लगता है कि आपको समूहों को संतुलित करने की एक बुनियादी समझ है , लेकिन संक्षेप में, .NET में समूहों को कैप्चर करना स्टैक है (इसलिए हर बार जब आप कैप्चरिंग समूह को नए कैप्चर को शीर्ष पर धकेल दिया जाता है) और (?<-x>...)स्टैक से कैप्चर को पॉप करता है x। जो चीजों को गिनने के लिए बहुत मददगार है।

^                   # Only look at matches from the beginning of the input.
(?=                 # First, we'll compute the number of composites less than
                    # or equal to the input in group 2. This is done in a
                    # lookahead so that we don't actually advance the regex
                    # engine's position in the string.
  (                 #   Iterate through the input, one character at a time.
    (?=(..+)\2+$)?  #     Try to match the remainder of the input as a
                    #     composite number. If so the (..+) will add one
                    #     one capture onto stack 2. Otherwise, this lookahead
                    #     is simply skipped.
    .
  )+
)
(?=                 # It turns out to be more convienient to work with n minus
                    # the number of composites less than or equal to n, and to
                    # have that a single backreference instead of the depth of
                    # a stack.
  (?<-2>.)*         #   Match one character for each composite we found.
  (.+)              #   Capture the remainder of the input in group 3.
)
(?=                 # Now we compute the totient function. The basic idea is
                    # similar to how we computed the number of composites,
                    # but there are a few differences.
                    # a) Of course the regex is different. However, this one
                    #    is more easily expressed as a negative lookahead (i.e.
                    #    check that the values don't share a factor), so this
                    #    won't leave a capture on the corresponding stack. We
                    #    fix this by wrapping the lookahead itself in a group
                    #    and making the entire group optional.
                    # b) We only want to search up the number of composites,
                    #    not up to the input. We do this by asserting that we
                    #    can still match our backreference \3 from earlier.

  (                 #   Iterate through the input, one character at a time.
    ((?!            #     Try not to match a number that shares a factor with
                    #     the number of composites, and if so push a capture
                    #     onto stack 5.
      (..+)\6*      #     Look for a factor that's at least 2...
      (?<=^\6+)     #     Make sure we can reach back to the input with that
                    #     factor...
      \3$           #     ...and that we're exactly at the end of the number
                    #     of composites.
    ))?
    .
  )*
  \3                #   Match group 3 again to make sure that we didn't look
                    #   further than the number of composites.
)
(?<-5>.)*           # Finally, match one character for each coprime number we
                    # found in the last lookahead.

— मार्टिन एंडर
स्रोत

4

PARI / GP, 27 बाइट्स

n->eulerphi(n-1-primepi(n))

— चार्ल्स
स्रोत

4

जेली , गैर-प्रतिस्पर्धात्मक

7 बाइट्स यह उत्तर गैर-प्रतिस्पर्धात्मक है, क्योंकि यह चुनौती का सामना करने वाली भाषा का उपयोग करता है।

ÆC_@’ÆṪ

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

ÆC_@’ÆṪ  Input: n

ÆC       Count the primes less than or equal to n.
    ’    Yield n - 1.
  _@     Subtract the count from n - 1.
     ÆṪ  Apply Euler's totient function.

— डेनिस
स्रोत

3

ऑक्टेव, 52 51

@(b)nnz((d=[1:(c=b-1-nnz(primes(b)))])(gcd(d,c)<2))

संपादित करें: थॉमस केवा की बदौलत 1 बाइट बचा

स्पष्टीकरण:

@(b)                                            # Define anonymous func with parameter b
  nnz(                                          # Count elements in φ(c)
    (                                           #
      d = [1:                                   # Create d= array of 1 to π̅(b)
            ( c = b - 1 - nnz(primes(b)) )      # Calculate c=π̅(b) by subtracting the
                                                #  number of elements in the array of prime
          ]                                     #  numbers from the number of ints in 2:b
    )(gcd(d, c) < 2)                            # Calculate φ(c) by using gcd to filter
  )                                             # relative primes from d

— DankMemes
स्रोत

3

PARI / GP, 35 बाइट्स

n->eulerphi(sum(x=2,n,!isprime(x)))

— alephalpha
स्रोत

3

सेजमैथ 26 बाइट्स

euler_phi(n-1-prime_pi(n))

ऋषि के कार्यान्वयन के लिए धन्यवाद n=0और यहां तक कि अच्छी तरह से काम करता है n=1।

— यो'
स्रोत

3

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

_ÆC’ÆṪ

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

यह चैट में केयर्ड सिक्काहिंगहिंग और मिस्टर एक्सकोडर के बीच एक सहयोग है

व्याख्या

_C'ÆṪ ~ पूर्ण कार्यक्रम।

 ÆC ~ Z से कम या उसके बराबर वाले प्राइम की गिनती करें।
_ ~ इनपुट से घटाना।
   '~ कमी।
    ÆṪ ~ यूलर का कुल कार्य।

— caird coinheringaahing
स्रोत

3

गैया , 5 बाइट्स

ṗ⁈l(t

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

ṗ⁈l (t ~ पूर्ण कार्यक्रम

 ⁈ ~ उन तत्वों को अस्वीकार करें जो:
prime ~ प्रधान हैं।
  एल ~ लंबाई।
   (~ घटाना)
    t ~ यूलर का योग।

— श्री Xcoder
स्रोत

3

ओम v2 , 7 बाइट्स

³³Pl-‹φ

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

— श्री Xcoder
स्रोत

2

MATL , 9 बाइट्स (गैर-प्रतिस्पर्धात्मक)

यह उत्तर गैर-प्रतिस्पर्धात्मक है, क्योंकि भाषा चुनौती का सामना करती है।

:Zp~sq_Zp

भाषा / संकलक के संस्करण (10.1.0) का उपयोग करता है ।

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

व्याख्या

:       % implicitly input a number "N" and produce array [1,2,...,N]
Zp      % true for entries that are prime
~       % negate. So it gives true for entries of [1,2,...,N] that are non-prime
s       % sum elements of array. So it gives number of non-primes
q       % subtract 1. Needed because number 1 is not prime, but not composite either
_       % unary minus
Zp      % with negative input, computes totient function of absolute value of input
        % implicit display

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

2

जीएपी, 33 बाइट्स

n->Phi(n-Number([-2..n],IsPrime))

Number(l,p)lसंतोष से कितने तत्व गिनाते हैं p। इस तथ्य की भरपाई करने के लिए कि 1 न तो प्रधान है और न ही समग्र, मुझे n से अधिक primes की संख्या से n को घटाना है। -1दो बाइट्स करने के बजाय , मैं सूची को 1 या 2 के बजाय -2 से शुरू करता हूं, इस प्रकार एक और संख्या जोड़ देता हूं जिसे IsPrimeकेवल एक अतिरिक्त बाइट के लिए प्रमुख माना जाता है ।

— क्रिश्चियन सिवर्स
स्रोत

2

पायथन 3.5 - 130 बाइट्स

from math import*
def p(n,k,g):
 for i in range(1,n+1):k+=factorial(i-1)%i!=i-1
 for l in range(1,k):g+=gcd(k,l)<2      
 return g

यदि यह p (n, 0,0) के रूप में फ़ंक्शन से गुजरना स्वीकार्य नहीं है, तो +3 बाइट्स।

यह इस तथ्य का लाभ उठाता है कि मैं विल्सन के प्रमेय का उपयोग यह जांचने के लिए करता हूं कि क्या कोई संख्या समग्र है और तथ्यात्मक कार्य के लिए गणित मॉड्यूल में कॉल करना है। पायथन 3.5 ने गणित मॉड्यूल में एक एलसीडी फ़ंक्शन जोड़ा।

कोड का पहला लूप k एक से वृद्धि करेगा यदि संख्या समग्र और वृद्धि 0-वार द्वारा है। (हालांकि विल्सन का प्रमेय केवल 1 से अधिक पूर्णांक के लिए है, यह 1 को प्रमुख मानता है, इसलिए हमें इसका फायदा उठाने की अनुमति देता है)।

दूसरा लूप तब कंपोजिट और इंक्रीमेंट जी की सीमा पर लूप करेगा जब पी और एल का मूल्य सह-प्रधान नहीं होगा।

g तब n की तुलना में या उससे कम संमिश्र संख्याओं की संख्या के बराबर या उससे कम मान है।

— जो हाबेल
स्रोत

2

पायथन 3 + सिम्पी , 59 58 बाइट्स

* -1 बाइट के compositepi(k)साथ प्रतिस्थापित करके k+~primepi(k)।

lambda k:totient(k+~primepi(k))
from sympy.ntheory import*

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

— श्री Xcoder
स्रोत

1

05AB1E , 11 8 बाइट्स

LDpÈÏg<Õ

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

यह गैर-प्रतिस्पर्धी हो सकता है - मुझे पता नहीं चल सकता है कि 05AB1E कब बनाया गया था।

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

L             # this gets us the list of numbers [1 .. a]
 D            # duplicates this list
  p           # applies isPrime to each element of the list, vectorised.
   È          # is the element even? (does 05AB1E not have a logical not?)
    Ï         # push elements of the first list where the same index in the 
              # second list is 1
     g<       # finds the length and subtracts 1 (as the list contains 1)
              # this is the not pi function
       Õ      # euler totient function

— अंतरिक्ष का कबाड़
स्रोत

1

पाइट , 6 बाइट्स

řṗ¬Ʃ⁻Ț

स्पष्टीकरण:

                Implicit input
ř               Push [1,2,...,input]
 ṗ              [is 1 prime?, is 2 prime?, ..., is input prime?]
  ¬             [is 1 not prime?, is 2 not prime?, ... is input not prime?]
   Ʃ            Number of non-primes (sums the array - booleans implicitly converted to ints)
    ⁻           Subtract one to remove the counting of '1'
     Ț          Euler's totient function

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

— mudkip201
स्रोत

1

एपीएल नार, 38 बाइट्स, 19 चार्ट

{⍵≤3:0⋄13π¯1+⍵-2π⍵}

13 का कुल योग फलन है और 2 <गणना प्रधान कार्य है = इसका तर्क। परीक्षा

  b←{⍵≤3:0⋄13π¯1+⍵-2π⍵}     
  (⍳12),¨b¨⍳12
1 0  2 0  3 0  4 1  5 1  6 1  7 1  8 2  9 2  10 4  11 4  12 2 
  (95..100),¨b¨(95..100)
95 24  96 70  97 70  98 24  99 72  100 36

— RosLuP
स्रोत

1

++ , 21 बाइट्स जोड़ें

L,RþPbL1_dRdVÞ%bLG!!+

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

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

$\overline\pi(n)$ $\varphi(n)$ $\overline\pi(n)$ $\varphi(n)$

$\overline\pi(n)$

RþPbL1_

यहां, सीधे इनपुट पर काम करते हुए, हम [0 .. n] से एक रेंज उत्पन्न करते हैं R, फिर किसी भी प्रकार के प्राइम þP(फिल्टर झूठे þ) ( प्राइम एलिमेंट्स ( P)) को हटाते हैं । दुर्भाग्य से, यह 1 नहीं निकालता है , क्योंकि यह प्रमुख नहीं है। इसलिए, साथ छोड़ दिए गए तत्वों की संख्या लेने के बाद bL, हम 1 के1_ लिए गणना को हटाने के लिए एक बार घटाते हैं । यह छोड़ देता है $x = \overline\pi(n)$ ढेर पर।

$\varphi(n)$

dRdVÞ%bLG!!+

यह एक नहीं बल्कि अधिक लंबा है, एक बार फिर 1 के कारण । पहले हम नकल करते हैं $x$ और के साथ काम करने के लिए एक सीमा बनाएँ dR। इसके बाद, हम इस श्रेणी की एक कॉपी को एक चेक के लिए सहेजते हैं जिसे हम बाद में संबोधित करेंगे। फिर, फ़िल्टर सही का उपयोग करके Þ%, हम किसी भी तत्व को विभाजित करते हैं जो विभाजित करते हैं $x$ , या 1 के साथ GCD वाले किसी भी तत्व को रखें $x$ । अंत में, हम इस सूची की लंबाई के साथ लेते हैं bL।

दुर्भाग्य से, यह 0 देता है जब परिणाम 0 होना चाहिए और $n - 1$ जब सही परिणाम है $n$ । इस विसंगति को ठीक करने के लिए, हम सहेजे गए रेंज को पुनः प्राप्त करते हैं G, और इसे बूलियन मान में परिवर्तित करते हैं !!। यह खाली रेंज बनाता है (जिसमें 0 होगा ) 0 में और हर 1 में अन्य रेंज । अंत में, हम इस मूल्य को अपने पिछले परिणाम में जोड़ते हैं और इसे वापस करते हैं।

_{_{_{हां, मैं वास्तव में नए LaTex की कोशिश करना चाहता था}}}

फी की गणना करें (पाई नहीं)

कार्य

उदाहरण

लीडरबोर्ड

जीएस 2 , 12 10 बाइट्स

परीक्षण चालन

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

रेगेक्स (.NET), 122 113 बाइट्स

जे, 15 14 बाइट्स

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

गंभीरता से , 27 बाइट्स

जूलिया, 52 50 बाइट्स

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

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

मिंकोलंग 0.11 , 12 बाइट्स (प्रतिस्पर्धी नहीं)

व्याख्या

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

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

अजगर, १३th १३ ९

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

व्याख्या

रेगेक्स (.NET), 88 86 बाइट्स

व्याख्या

PARI / GP, 27 बाइट्स

जेली , गैर-प्रतिस्पर्धात्मक

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

ऑक्टेव, 52 51

PARI / GP, 35 बाइट्स

सेजमैथ 26 बाइट्स

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

व्याख्या

गैया , 5 बाइट्स

ओम v2 , 7 बाइट्स

MATL , 9 बाइट्स (गैर-प्रतिस्पर्धात्मक)

व्याख्या

जीएपी, 33 बाइट्स

पायथन 3.5 - 130 बाइट्स

पायथन 3 + सिम्पी , 59 58 बाइट्स

05AB1E , 11 8 बाइट्स

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

पाइट , 6 बाइट्स

एपीएल नार, 38 बाइट्स, 19 चार्ट

++ , 21 बाइट्स जोड़ें

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

π¯¯¯( एन )π¯(n)\overline\pi(n)

φ ( एन )φ(n)\varphi(n)

$\overline\pi(n)$

$\varphi(n)$