아니, 내 말은하지 않습니다 ϕ = 1.618...와 π = 3.14159.... 나는 기능을 의미한다 .

• φ (x) 는 x상대적으로 소수 보다 작거나 같은 정수의 수입니다 x.
• π (x) 는 소수 이하의 소수 x입니다.
• "pi가 아님"이 π̅ (x)이고이를 이하 의 합성 수로 정의한다고 가정 해 봅시다 x.

태스크

엄격하게 양의 정수 감안할 때 x, φ (π (X))를 계산한다 . 점수는 바이트 단위입니다.

예

각 줄은 입력 (1 ~ 100 포함)과 공백으로 구분 된 해당 출력으로 구성됩니다.

1 0 
2 0 
3 0 
4 1 
5 1 
6 1 
7 1 
8 2 
9 2 
10 4 
11 4 
12 2 
13 2 
14 6 
15 4 
16 6 
17 6 
18 4 
19 4 
20 10 
21 4 
22 12 
23 12 
24 6 
25 8 
26 8 
27 16 
28 6 
29 6 
30 18 
31 18 
32 8 
33 12 
34 10 
35 22 
36 8 
37 8 
38 20 
39 12 
40 18 
41 18 
42 12 
43 12 
44 28 
45 8 
46 30 
47 30 
48 16 
49 20 
50 16 
51 24 
52 12 
53 12 
54 36 
55 18 
56 24 
57 16 
58 40 
59 40 
60 12 
61 12 
62 42 
63 20 
64 24 
65 22 
66 46 
67 46 
68 16 
69 42 
70 20 
71 20 
72 32 
73 32 
74 24 
75 52 
76 18 
77 40 
78 24 
79 24 
80 36 
81 28 
82 58 
83 58 
84 16 
85 60 
86 30 
87 36 
88 32 
89 32 
90 48 
91 20 
92 66 
93 32 
94 44 
95 24 
96 70 
97 70 
98 24 
99 72 
100 36

이 링크 를 사용 하여 모든 입력에 대한 예상 출력을 계산하십시오. 또한 여기에 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>

GS2 , 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.

정규식 (.NET), (122) 113 바이트

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

입력과 출력이 단항이라고 가정하고 출력은 정규식의 주요 일치 항목에서 가져옵니다.

정규식의 분석 :

• ^(?=((?=.*$(?<=^(\3+(.+.))(.*?(?>(.\4)?)))).)+(.*)) π̅ (x)를 계산하고 캡처 그룹 6의 나머지 문자열을 캡처하여 두 번째 부분의 어설 션을 찾습니다.

  • .*$x한 방향으로 정수를 갖도록 포인터를 문자열의 끝으로 설정합니다 .
  • (?<=^(\3+(.+.))(.*?(?>(.\4)?))) 오른쪽에서 왼쪽으로 일치하고 x에서 0으로 반복하여 복합 번호를 확인합니다.
    • (.*?(?>(.\4)?))"가변"은 첫 번째 반복에서 0에서 시작하여 이전 반복의 숫자에서 계속되고 최대 x까지 반복됩니다. 가장 작은 합성 번호는 4이므로 (.\4)?캡처 그룹 4를 사용할 수있는 경우 일치하지 않습니다.
    • ^(\3+(.+.))위의 "변수"에 남아있는 항목 (예 : x - "variable"복합 변수 인지 여부)을 확인합니다.

• ((?=.*(?=\6$)(?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?)))).)+로 왼쪽에서 오른쪽으로 연산을 제한하여 φ (π̅ (x))를 계산 (?=\6$)합니다.

  • .*(?=\6$)포인터를 π̅ (x) 위치로 설정합니다. y = π̅ (x)를 나타내겠습니다.
  • (?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?))) 오른쪽에서 왼쪽으로 일치하고 (y-1)에서 0으로 반복하여 상대 소수를 확인합니다.
    • (.+?(?>\9?)) "가변"은 첫 번째 반복에서 1부터 시작하여 이전 반복의 숫자부터 계속되고 y까지 반복됩니다.
    • (?!(.+.)\8*(?=\6$)(?<=^\8+))왼쪽에서 오른쪽 ¹ 까지 일치 하고 "변수"와 y가 상대 소수인지 확인합니다.
      • (.+.)\8*(?=\6$) 1보다 큰 "변수"의 제수를 선택하고 부작용은 왼쪽에 정수 y가 있다는 것입니다.
      • (?<=^\8+) "변수"의 제수가 y의 제수인지 확인합니다.

^{1 .NET에서 미리보기 는 현재 방향을 따르는 대신 방향을 LTR로 설정 합니다. look-behind 는 방향을 반전시키지 않고 방향을 RTL로 설정 합니다.}

RegexStorm 에서 정규식을 테스트하십시오 .

개정 2 는 캡처하지 않은 그룹을 삭제하고 조건부 구문 대신 원자 그룹을 사용합니다.

J, 15 14 바이트

5 p:<:-_1 p:>:

이것은 암묵적인 동사입니다. J.js로 온라인으로 사용해보십시오 .

작동 원리

                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.

진심으로 , 27 바이트

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

예, CJam을 이겼어요! 온라인으로 사용해보십시오

설명 ( 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))

줄리아, 52 50 바이트

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

이것은 정수를 받아들이고 정수를 반환하는 명명되지 않은 함수를 만듭니다. 호출하려면 이름을 지정하십시오 (예 :) f=x->....

언 골프 드 :

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

Mathematica, 24 바이트

EulerPhi[#-PrimePi@#-1]&

Pyth, 14 바이트

JlftPTSQ/iLJJ1

데모 , 검증기

간단한 필터를 사용하여 합성물을 계산하고 길이를 가져 와서 저장합니다 J. 그런 다음 J모든 숫자 의 gcd를 최대로 가져 J오고 1과 같은 결과 수를 계산합니다.

Minkolang 0.11 , 12 바이트 (경쟁사 아님)

이 답변은 경쟁력이 없습니다. 질문을 게시하기 전에 pi와 phi를 내장으로 구현하여 불공정 한 이점을 얻었습니다. 나는 언어에 관심이있는 사람들을 위해 이것을 게시합니다.

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.

CJam, 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.

파이썬, 137139

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

레티 나 , 48 바이트

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

온라인으로 사용해보십시오!

설명

.+
$*

입력을 단항으로 변환합니다.

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

최소 2의 인수로 2 회 이상 반복되는 문자열을 얼마나 자주 일치시킬 수 있는지 계산하여 입력 값보다 크지 않은 복합 수를 계산합니다.

.+
$*

단항으로 다시 변환하십시오.

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

우리는 이러한 요인을 발견 할 경우는 (또한 접두사의 요인이다, 그 위치에서 접미사의 (적어도 2의) 요소를 찾을 수 없습니다 얼마나 많은 위치에서 계산하여 φ를 계산 다음이 i <= n요소와 공유 n따라서 이에 대한 책임이 없습니다). .끝에 우리가 (있는 우리는 적어도 2의 요인을 찾을 수 없습니다) 제로 계산하지 않도록합니다.

정규식 (.NET), 88 86 바이트

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

온라인으로 사용해보십시오! (레티 나 프로그램으로)

n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳의 답변 과 같은 I / O를 사용합니다 . 즉, 단항 입력이며 결과 길이의 하위 문자열과 일치합니다.

밸런싱 그룹 중 하나 또는 둘 다를 순방향 참조로 대체하여이를 더욱 단축시킬 수 있습니다.

동일한 바이트 수의 대안 :

^(?=((?=(..+)\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.

PARI / GP, 27 바이트

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

비경쟁 젤리

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.

옥타브, 52 51

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

편집 : Thomas Kwa 덕분에 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

PARI / GP, 35 바이트

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

SageMath 26 바이트

euler_phi(n-1-prime_pi(n))

Sage의 구현 덕분 에 n=0및에 대해서도 잘 작동합니다 n=1.

젤리 , 6 바이트

_ÆC’ÆṪ

온라인으로 사용해보십시오!

이 사이의 협력입니다 케어 드의 coinheringahhing 와 씨 Xcoder 에서 채팅

설명

_ÆC'ÆṪ ~ 전체 프로그램.

 ÆC ~ Z 이하의 소수를 세십시오.
_ ~ 입력에서 빼기.
   '~ 감소.
    ÆṪ ~ 오일러의 참을성있는 기능.

Gaia , 5 바이트

ṗ⁈l(t

온라인으로 사용해보십시오!

ṗ⁈l (t ~ 전체 프로그램.

 ⁈ ~ 다음 요소를 거부하십시오.
ṗ ~는 소수입니다.
  l ~ 길이.
   (~ 감소.
    t ~ 오일러의 끈기.

옴 v2 , 7 바이트

³³Pl-‹φ

온라인으로 사용해보십시오!

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

간격, 33 바이트

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

Number(l,p)l충족시키는 요소 수를 계산합니다 p. 1이 소수이거나 복합이 아니라는 사실을 보상하기 위해, 소수에서 n까지의 n보다 n을 더 빼야합니다. 대신 일의 -1두 바이트, 나는 이렇게함으로써 주요 고려 또 하나 개의 번호를 추가로 -2 대신 1 또는 2의 목록을 시작 IsPrime하나 추가 바이트에 대한합니다.

파이썬 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 바이트입니다.

이것은 내가 Wilson의 정리를 사용하여 숫자가 합성인지 확인하고 계승 함수를 위해 수학 모듈을 호출해야한다는 사실을 이용합니다. Python 3.5는 gcd 함수를 수학 모듈에 추가했습니다.

코드의 첫 번째 루프는 숫자가 합성이면 k를 1 씩 증가시키고 그렇지 않으면 0을 증가시킵니다. (윌슨의 정리는 1보다 큰 정수만 보유하지만 1을 소수로 취급하므로이를 활용할 수 있습니다).

그런 다음 두 번째 루프는 컴포지트 수 범위를 반복하고 pi 및 l이 아닌 값이 동일 프라임 인 경우에만 g를 증가시킵니다.

g는 n 이하의 합성 수의 수 이하의 값의 수이다.

파이썬 3 + sympy , 59 58 바이트

로 교체 compositepi(k)하여 * -1 바이트 k+~primepi(k).

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

온라인으로 사용해보십시오!

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

Pyt , 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

온라인으로 사용해보십시오!

APL NARS, 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

추가 ++ , 21 바이트

L,RþPbL1_dRdVÞ%bLG!!+

온라인으로 사용해보십시오!

작동 원리

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

$\overline\pi(n)$

RþPbL1_

RþPþPbL1_$x = \overline\pi(n)$

$\varphi(n)$

dRdVÞ%bLG!!+

$x$dRÞ%$x$$x$bL

$n - 1$$n$G!!

_{예, 정말 새로운 LaTex를 사용하고 싶었습니다.}