Non, je ne veux pas dire ϕ = 1.618...et π = 3.14159.... Je veux dire les fonctions .

• φ (x) est le nombre d’entiers inférieurs ou égaux à xqui sont relativement premiers à x.
• π (x) est le nombre de nombres premiers inférieurs ou égaux à x.
• Disons que "pas pi" est alors π̅ (x) et définissons-le comme étant le nombre de composites inférieur ou égal à x.

Tâche

Étant donné un entier strictement positif x, calculez φ (π̅ (x)) . La notation est en octets.

Exemples

Chaque ligne comprend l’entrée (de 1 à 100 inclus) et la sortie correspondante, séparées par un espace.

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

Utilisez ce lien pour calculer la sortie attendue pour toute entrée. En outre, une liste des entrées et des sorties x <= 1000est fournie ici sur pastebin . (Généré avec ce programme Minkolang .)

Classements

Voici un extrait de pile permettant de générer un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

V@'◄l.1&‼l

Le code source utilise le codage CP437 . Essayez-le en ligne!

Essai

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

Comment ça fonctionne

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 octets

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

En supposant que les entrées et les sorties soient unaires, et que la sortie provienne de la correspondance principale de l'expression régulière.

Répartition de la regex:

• ^(?=((?=.*$(?<=^(\3+(.+.))(.*?(?>(.\4)?)))).)+(.*)) calcule π̅ (x) et capture le reste de la chaîne dans le groupe de capture 6 pour l'assertion dans la deuxième partie.

  • .*$positionne le pointeur à la fin de la chaîne pour avoir le nombre entier xdans une direction.
  • (?<=^(\3+(.+.))(.*?(?>(.\4)?))) correspond de droite à gauche et vérifie le nombre composé en passant de x à 0.
    • (.*?(?>(.\4)?))est une "variable" qui commence à 0 dans la première itération et continue à partir du nombre de l'itération précédente et boucle jusqu'à x. Étant donné que le plus petit numéro composé est 4, la correspondance (.\4)?ne manque jamais si le groupe de capture 4 est disponible.
    • ^(\3+(.+.))vérifie ce qui reste de la "variable" ci-dessus (c'est-à-dire x - "variable") s'il s'agit d'un nombre composé.

• ((?=.*(?=\6$)(?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?)))).)+calcule φ (π̅ (x)) en limitant les opérations de gauche à droite avec (?=\6$).

  • .*(?=\6$)positionne le pointeur sur π̅ (x). Notons y = π̅ (x).
  • (?<=(?!(.+.)\8*(?=\6$)(?<=^\8+))(.+?(?>\9?))) correspond de droite à gauche et vérifie l’amorce relative en passant de (y - 1) à 0
    • (.+?(?>\9?)) est une "variable" qui commence à 1 dans la première itération et continue à partir du nombre dans l'itération précédente et boucle jusqu'à y
    • (?!(.+.)\8*(?=\6$)(?<=^\8+))correspond de gauche à droite ¹ et vérifie si la "variable" et y sont des nombres premiers premiers.
      • (.+.)\8*(?=\6$) choisit un diviseur de "variable" qui est supérieur à 1 et un effet secondaire est que nous avons le nombre entier y à gauche.
      • (?<=^\8+) vérifie si le diviseur de "variable" est également le diviseur de y.

^{1 Dans .NET, Look-ahead définit la direction sur LTR au lieu de suivre la direction actuelle. Look-behind définit la direction vers RTL au lieu de l'inverser.}

Testez l'expression régulière sur RegexStorm .

La révision 2 supprime les groupes non capturés et utilise des groupes atomiques au lieu de la syntaxe conditionnelle.

J, 15 14 octets

5 p:<:-_1 p:>:

Ceci est un verbe tacite, monadique. Essayez en ligne avec J.js .

Comment ça fonctionne

                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.

Sérieusement , 27 octets

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

Oui, j'ai battu CJam! Essayez-le en ligne

Explication ( afait référence au haut de la pile, bfait référence au second du haut):

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

Remarque: depuis l'affichage de cette réponse, j'ai ajouté les fonctions pi et phi à Sérieusement. Voici une réponse non compétitive avec ces fonctions:

,;▓1-@-▒

Explication (certaines commandes sont décalées pour ne pas en superposer d'autres):

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

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

Cela crée une fonction non nommée qui accepte un entier et renvoie un entier. Pour l'appeler, donnez-lui un nom, par exemple 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 octets

EulerPhi[#-PrimePi@#-1]&

Pyth, 14 octets

JlftPTSQ/iLJJ1

Démonstration , vérificateur

Nous calculons les composites à l'aide d'un filtre simple, prenons sa longueur et l'enregistrons dans J. Ensuite, nous prenons le gcd de Javec chaque nombre jusqu’à J, et comptons combien de résultats sont égaux à 1.

Minkolang 0,11 , 12 octets (NON concurrentiel)

Cette réponse n'est pas compétitive. J'ai implémenté pi et phi en tant qu'éléments intégrés avant de poster la question, ce qui me donne un avantage injuste. Je poste ceci uniquement pour ceux qui sont intéressés par la langue.

nd9M-1-9$MN.

Essayez ici.

Explication

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 octets

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

Essayez ce violon dans l'interpréteur CJam ou vérifiez tous les cas de test à la fois .

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

Explication

.+
$*

Convertir une entrée en unaire.

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

Comptez les nombres composés non supérieurs à l’entrée en comptant la fréquence à laquelle vous pouvez faire correspondre une chaîne composée d’au moins deux répétitions d’un facteur d’au moins 2.

.+
$*

Convertir à nouveau unaire.

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

Calculez φ en comptant à partir de combien de positions il n'est pas possible de trouver un facteur (d'au moins 2) du suffixe à partir de cette position qui est aussi un facteur du préfixe (si nous trouvons un tel facteur, alors cela i <= npartage un facteur avec nn'est donc pas coprime à cela). Le .à la fin garantit que nous ne comptons pas zéro (pour lequel nous ne pouvons pas trouver un facteur d'au moins 2).

Regex (.NET), 88 86 octets

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

Essayez-le en ligne! (En tant que programme Retina.)

Utilise la même entrée / sortie que la réponse de n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , c’est-à-dire une entrée unaire, et correspond à une sous-chaîne de la longueur du résultat.

Il serait peut-être possible de raccourcir cette étape en remplaçant l'un des groupes d'équilibrage ou les deux par des références en aval.

Alternative au même nombre d'octets:

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

Il existe également des alternatives pour la première moitié, par exemple, en utilisant un indicateur négatif au lieu d'un indicateur positif pour les nombres composés, ou l'utilisation d'un conditionnel également.

Explication

Je suppose que vous avez une compréhension de base des groupes d'équilibrage , mais en bref, les groupes capturés dans .NET sont des piles (ainsi chaque fois que vous réutilisez le groupe capturé, la nouvelle capture est poussée au-dessus) et (?<-x>...)une capture de la pile apparaît x. C'est très utile pour compter les choses.

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

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

Gelée , non en compétition

7 octets Cette réponse est non concurrente, car elle utilise un langage postérieur au challenge.

ÆC_@’ÆṪ

Comment ça fonctionne

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

Octave, 52 51

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

Edit: sauvegardé 1 octet grâce à Thomas Kwa

Explication:

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

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

SageMath 26 octets

euler_phi(n-1-prime_pi(n))

Fonctionne bien même pour n=0et n=1grâce à l'implémentation de Sage.

Gelée , 6 octets

_ÆC’ÆṪ

Essayez-le en ligne!

Ceci est une collaboration entre Caird coinheringahhing et M. Xcoder dans le chat

Explication

_ÆC'ÆṪ ~ Programme complet.

 ÆC ~ Compter les nombres premiers inférieurs ou égaux à Z.
_ ~ Soustrayez de l'entrée.
   ~ Décrémente.
    ÆṪ ~ fonction totale d'Euler.

Gaia , 5 octets

ṗ⁈l(t

Essayez-le en ligne!

l (t ~ programme complet.

 ~ Rejeter les éléments qui:
~ Sont premiers.
  l ~ longueur.
   (~ Décrément.
    t ~ Euler's totient.

Ohm v2 , 7 octets

³³Pl-‹φ

Essayez-le en ligne!

MATL , 9 octets (non concurrents)

Cette réponse est sans concurrence, car la langue postdate le défi.

:Zp~sq_Zp

Utilise la version (10.1.0) du langage / compilateur.

Essayez-le en ligne!

Explication

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

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

Number(l,p)compte combien d'éléments de lsatisfaire p. Pour compenser le fait que 1 n'est ni premier ni composite, je dois soustraire de n un plus que le nombre de nombres premiers allant jusqu'à n. Au lieu de faire -1deux octets, je commence la liste par -2 au lieu de 1 ou 2, ajoutant ainsi un nombre supplémentaire qui est considéré comme premier IsPrimepour un seul octet supplémentaire.

Python 3.5 - 130 octets

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

S'il n'est pas acceptable de transmettre la fonction en tant que p (n, 0,0), alors +3 octets.

Cela profite du fait que j'utilise le théorème de Wilson pour vérifier si un nombre est composite et que je dois faire appel au module mathématique pour la fonction factorielle. Python 3.5 a ajouté une fonction gcd dans le module mathématique.

La première boucle du code incrémentera k de 1 si le nombre est composite et incrémentera de 0 sinon. (Bien que le théorème de Wilson ne concerne que les entiers supérieurs à 1, il considère que 1 est premier, nous permet donc de l'exploiter).

La seconde boucle passera ensuite sur la plage de nombres de composites et incrémentera g uniquement lorsque les valeurs de not pi et l sont co-prime.

g est alors le nombre de valeurs inférieures ou égales au nombre de nombres composés inférieurs ou égaux à n.

Python 3 + sympy , 59 58 octets

* -1 octet en remplaçant compositepi(k)par k+~primepi(k).

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

Essayez-le en ligne!

05AB1E , 11 8 octets

LDpÈÏg<Õ

Essayez-le en ligne!

Cela pourrait ne pas être compétitif - je ne peux pas savoir quand 05AB1E a été faite.

Comment ça fonctionne

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 octets

řṗ¬Ʃ⁻Ț

Explication:

                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

Essayez-le en ligne!

APL NARS, 38 octets, 19 caractères

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

13π est la fonction totale et 2π est la fonction de nombre premier <= son argument. Tester

  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

Ajouter ++ , 21 octets

L,RþPbL1_dRdVÞ%bLG!!+

Essayez-le en ligne!

Comment ça fonctionne

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

_{Oui, je voulais vraiment essayer le nouveau LaTex}