No, non intendo ϕ = 1.618...e π = 3.14159.... Intendo le funzioni .

• φ (x) è il numero di numeri interi inferiori o uguali a xquelli a cui sono relativamente primi x.
• π (x) è il numero di numeri primi minori o uguali a x.
• Diciamo che "non pi" è quindi π̅ (x) e lo definiamo come il numero di compositi minore o uguale a x.

Compito

Dato un numero intero strettamente positivo x, calcola φ (π̅ (x)) . Il punteggio è in byte.

Esempi

Ogni riga è composta dall'input (da 1 a 100, compreso) e dall'output corrispondente separati da uno spazio.

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

Utilizzare questo collegamento per calcolare l'output previsto per qualsiasi input. Inoltre, un elenco di input e output x <= 1000è fornito qui su pastebin . (Generato con questo programma Minkolang .)

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

## [><>](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 byte

V@'◄l.1&‼l

Il codice sorgente utilizza la codifica CP437 . Provalo online!

Prova

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

Come funziona

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.

Regex (.NET), 122 113 byte

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

Supponendo che input e output siano unari e che l'output sia preso dalla corrispondenza principale di regex.

Ripartizione della regex:

• ^(?=((?=.*$(?<=^(\3+(.+.))(.*?(?>(.\4)?)))).)+(.*)) calcola π̅ (x) e acquisisce il resto della stringa nel gruppo di acquisizione 6 per l'asserzione nella seconda parte.

  • .*$imposta il puntatore alla fine della stringa in modo da avere l'intero numero xin una direzione.
  • (?<=^(\3+(.+.))(.*?(?>(.\4)?))) corrisponde da destra a sinistra e verifica il numero composto eseguendo il ciclo da x a 0.
    • (.*?(?>(.\4)?))è una "variabile" che inizia da 0 nella prima iterazione e continua dal numero nella precedente iterazione e passa in loop fino a x. Poiché il numero composito più piccolo è 4, (.\4)?non riesce mai ad abbinare se è disponibile il gruppo di acquisizione 4.
    • ^(\3+(.+.))controlla ciò che resta della "variabile" sopra (ovvero x - "variable") se si tratta di un numero composto.

• ((?=.*(?=\6$)(?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?)))).)+calcola φ (π̅ (x)), limitando le operazioni da sinistra a destra con (?=\6$).

  • .*(?=\6$)imposta il puntatore sulla posizione π̅ (x). Indichiamo y = π̅ (x).
  • (?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?))) corrisponde da destra a sinistra e verifica il numero primo relativo eseguendo il loop da (y - 1) a 0
    • (.+?(?>\9?)) è una "variabile" che inizia da 1 nella prima iterazione e continua dal numero nella precedente iterazione e scorre fino a y
    • (?!(.+.)\8*(?=\6$)(?<=^\8+))corrisponde da sinistra a destra ¹ e verifica se la "variabile" ey sono primi primi.
      • (.+.)\8*(?=\6$) seleziona un divisore di "variabile" che è maggiore di 1 e un effetto collaterale è che abbiamo un numero intero y sulla sinistra.
      • (?<=^\8+) controlla se il divisore di "variabile" è anche il divisore di y.

^{1 In .NET, look-ahead imposta la direzione su LTR anziché seguire la direzione corrente; look-behind imposta la direzione su RTL invece di invertire la direzione.}

Prova il regex su RegexStorm .

La revisione 2 elimina i gruppi non acquisiti e utilizza i gruppi atomici anziché la sintassi condizionale.

J, 15 14 byte

5 p:<:-_1 p:>:

Questo è un verbo tacito e monadico. Provalo in rete con J.js .

Come funziona

                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.

Scherzi a parte , 27 byte

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

Sì, ho battuto CJam! Provalo online

Spiegazione (si ariferisce all'inizio dello stack, si briferisce al secondo dall'alto):

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

Nota: dopo la pubblicazione di questa risposta, ho aggiunto le funzioni pi e phi a Seriamente. Ecco una risposta non competitiva con queste funzioni:

,;▓1-@-▒

Spiegazione (alcuni comandi vengono spostati per non sovrapporsi ad altri):

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

Julia, 52 50 byte

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

Questo crea una funzione senza nome che accetta e integer e restituisce un intero. Per chiamarlo, dagli un nome, ad es 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

Mathematica, 24 byte

EulerPhi[#-PrimePi@#-1]&

Pyth, 14 byte

JlftPTSQ/iLJJ1

Dimostrazione , verificatore

Calcoliamo i compositi utilizzando un semplice filtro, ne prendiamo la lunghezza e lo salviamo in J. Quindi, prendiamo il gcd di Jcon ogni numero fino a Je contiamo quanti risultati equivalgono a 1.

Minkolang 0,11 , 12 byte (NON competitivo)

Questa risposta NON è competitiva. Ho implementato pi e phi come built-in prima di pubblicare la domanda, il che mi dà un vantaggio ingiusto. Pubblico questo solo per coloro che sono interessati alla lingua.

nd9M-1-9$MN.

Provalo qui.

Spiegazione

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 byte

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

Prova questo violino nell'interprete CJam o verifica tutti i casi di test contemporaneamente .

Come funziona

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.

Python, 137 139

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

Retina , 48 byte

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

Provalo online!

Spiegazione

.+
$*

Converti input in unario.

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

Contare i numeri compositi non maggiori dell'input contando la frequenza con cui possiamo abbinare una stringa che consiste di almeno due ripetizioni di un fattore di almeno 2.

.+
$*

Converti di nuovo in unario.

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

Calcola φ contando da quante posizioni non è possibile trovare un fattore (di almeno 2) del suffisso da quella posizione che è anche un fattore del prefisso (se troviamo un tale fattore allora questo i <= ncondivide un fattore con nnon è quindi coprime ad esso). Alla .fine ci assicura che non contiamo zero (per il quale non possiamo trovare un fattore di almeno 2).

Regex (.NET), 88 86 byte

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

Provalo online! (Come programma Retina.)

Utilizza lo stesso I / O della risposta di n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , ovvero input unario e corrisponde a una sottostringa della lunghezza del risultato.

Potrebbe essere possibile abbreviarlo ulteriormente sostituendo uno o entrambi i gruppi di bilanciamento con riferimenti a termine.

Alternativa con lo stesso numero di byte:

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

Ci sono anche alcune alternative per la prima metà, ad esempio usando un lookahead negativo invece di uno positivo per i numeri compositivi, o usando anche un condizionale lì.

Spiegazione

Presumo che tu abbia una conoscenza di base dei gruppi di bilanciamento , ma in breve, i gruppi di acquisizione in .NET sono stack (quindi ogni volta che riutilizzi il gruppo di acquisizione la nuova acquisizione viene spinta in cima) e ne (?<-x>...)estrae una dallo stack x. È molto utile per contare le cose.

^                   # 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 byte

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

Gelatina , non competitiva

7 byte Questa risposta non è competitiva, poiché utilizza un linguaggio che postdatizza la sfida.

ÆC_@’ÆṪ

Come funziona

Æ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.

Ottava, 52 51

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

Modifica: salvato 1 byte grazie a Thomas Kwa

Spiegazione:

@(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 byte

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

SageMath 26 byte

euler_phi(n-1-prime_pi(n))

Funziona bene anche per n=0e n=1, grazie all'implementazione di Sage.

Gelatina , 6 byte

_ÆC’ÆṪ

Provalo online!

Questa è una collaborazione tra caird coinheringahhing e Mr. Xcoder in chat

Spiegazione

_ÆC'ÆṪ ~ Programma completo.

 ÆC ~ Contare i numeri primi inferiori o uguali a Z.
_ ~ Sottrai dall'input.
   '~ Decremento.
    ÆṪ ~ Funzione completa di Eulero.

Gaia , 5 byte

ṗ⁈l(t

Provalo online!

(l (t ~ Programma completo.

 ⁈ ~ Rifiuta gli elementi che:
ṗ ~ Sono primi.
  l ~ lunghezza.
   (~ Decremento.
    t ~ Eulero.

Ohm v2 , 7 byte

³³Pl-‹φ

Provalo online!

MATL , 9 byte (non concorrenti)

Questa risposta non è competitiva, poiché la lingua postdatizza la sfida.

:Zp~sq_Zp

Utilizza la versione (10.1.0) della lingua / compilatore.

Provalo online!

Spiegazione

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

GAP, 33 byte

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

Number(l,p)conta quanti elementi lsoddisfano p. Per compensare il fatto che 1 non è né primo né composito, devo sottrarre da n uno in più rispetto al numero di numeri primi fino a n. Invece di fare -1per due byte, inizio la lista di -2 invece di 1 o 2, aggiungendo così un altro numero che è considerato primo IsPrimeper solo un byte extra.

Python 3.5 - 130 byte

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

Se non è accettabile passare la funzione come p (n, 0,0), quindi +3 byte.

Questo sfrutta il fatto che io uso il teorema di Wilson per verificare se un numero è composto e devo chiamare il modulo di matematica per la funzione fattoriale. Python 3.5 ha aggiunto una funzione gcd al modulo matematico.

Il primo ciclo del codice incrementerà k di uno se il numero è composto e aumenterà di 0 altrimenti. (Sebbene il teorema di Wilson valga solo per numeri interi superiori a 1, considera 1 come primo, quindi ci consente di sfruttarlo).

Il secondo ciclo eseguirà quindi un ciclo sull'intervallo del numero di compositi e incrementerà g solo quando il valore di non pi e l è co-prime.

g è quindi il numero di valori inferiore o uguale al numero di numeri compositi inferiore o uguale a n.

Python 3 + sympy , 59 58 byte

* -1 byte sostituendo compositepi(k)con k+~primepi(k).

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

Provalo online!

05AB1E , 11 8 byte

LDpÈÏg<Õ

Provalo online!

Questo potrebbe non essere in competizione - Non riesco a scoprire quando è stato creato 05AB1E.

Come funziona

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 byte

řṗ¬Ʃ⁻Ț

Spiegazione:

                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

Provalo online!

APL NARS, 38 byte, 19 caratteri

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

13π è la funzione totient e 2π è la funzione primo di conteggio <= il suo argomento. Test

  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

Aggiungi ++ , 21 byte

L,RþPbL1_dRdVÞ%bLG!!+

Provalo online!

Come funziona

$\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!!

_{Sì, volevo davvero provare il nuovo LaTex}