La plupart d'entre nous savent ...

que tous les nombres premiers p>3sont de la forme

Mais combien sont les Plus Primes ( 6n+1) et combien sont les Minus Primes ( 6n-1) dans une certaine plage?

Le défi

Pour un nombre entier k>5, compter combien primes<=ksont PlusPrimes et combien sont MinusPrimes .

Exemples

car k=100nous avons
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89] 12 MinusPrimes
et
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97] 11 PlusPrimes

car k=149nous avons
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89, 101, 107, 113, 131, 137, 149]
18 MinusPrimes
et
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97, 103, 109, 127, 139]
15 PlusPrimes

Règles

Votre code doit générer 2 entiers : un pour le MinusPrimes et un pour le PlusPrimes dans l'ordre de votre choix (veuillez préciser lequel est lequel).
C'est code-golf : la réponse la plus courte en octets gagne!

Cas de test

Entrée -> Sortie [ MinusPrimes , PlusPrimes ]

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

05AB1E , 10 à 9 octets

Enregistré 1 octet grâce à Erik the Outgolfer

Sorties en tant que [PlusPrimes, MinusPrimes]

LDpÏ6%5Ñ¢

Essayez-le en ligne! ou en tant que suite de tests

Explication

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

MATL , 10 octets

Zq6\!5lh=s

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

Python 2 , 77 octets

^{-2 octets grâce à Neil}

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

Essayez-le en ligne!

Solution précédente, 83 81 79 octets

^{-1 octet grâce à Mr. Xcoder
-2 octets grâce à Halvard Hummel}

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

Essayez-le en ligne!
Les deux sorties en tant que [MinusPrimes, PlusPrimes]

Gelée , 7 octets

s6ÆPSm4

Plus, puis moins.

Essayez-le en ligne!

Comment ça marche

s6ÆPSm4  Main link. Argument: n

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

Mathematica, 51 octets

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

Essayez-le en ligne!

@ ngenisis a joué au golf, économisant 4 octets

Mathematica, 47 octets

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

Japt , 15 13 11 octets

L'ordre de sortie est [+,-].

õj ò6 yx ë4

Essaye-le

• S'inspirer de la solution Jelly de Dennis mais après le golf, c'est plus proche d'un port.
• 2 octets enregistrés grâce à Oliver, qui a porté ëà mon attention la méthode de tableaux précédemment inconnue de moi .

Explication

Entrée implicite d'entier U.

õj

Générez un tableau d'entiers ( õ) de 1 à Uet vérifiez si chacun d'eux est une prime ( j), ce qui donne un tableau de booléens.

ò6

Partitionnez le tableau en sous-tableaux de longueur 6.

yx

Transposer ( y) et additionner les colonnes.

ë4

Récupère chaque 4ème élément du tableau et les affiche implicitement.

Original, 19 17 16 15 octets

õ fj
5â £è_%6¥X

Essaye-le

• 1 octet grâce à une suggestion inspirée d'Oliver d'utiliser les diviseurs de 5 après m'être reposée sur mes lauriers en divisant 15 en un tableau.

J , 23 octets

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

Essayez-le en ligne!

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

Retina , 53 51 octets

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

*M`111
\b1\b

Essayez-le en ligne! Explication:

.+
$*

Convertir en unaire.

1
$`1¶

Comptez de 1 à n.

G`1111

Supprimer les nombres inférieurs à 4.

A`^(11+)\1+$

Supprimer des nombres composés.

1{6}

Prenez le reste modulo 6.

*M`111

Imprimer le nombre de nombres avec un reste entre 3 et 5.

\b1\b

Imprimer le nombre de nombres avec un reste de 1.

Ruby, 61 ans 60 octets

(52 octets + 8 pour le -rprimesdrapeau)

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

Retourne un tableau de la forme [plus nombres premiers, moins nombres premiers].

Sauvé 1 octet grâce à GB!

Essayez-le en ligne.

Perl 6 , 42 octets

Sauvegardé 1 octet en supprimant un espace inutile ...

Sauvegardé 2 octets en réorganisant l' map appel - grâce à @Joshua.

Sauvegardé 3 octets car .round égal .round: 1 .

En réalité, le complexe exponentiel est cool mais très coûteux en caractères. Sauvegardé 10 octets juste en l'abandonnant ...

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

Essayez-le en ligne!

C'était la version avec le complexe exponentiel. (Je l'aime trop pour le supprimer.) La nouvelle version fonctionne exactement de la même manière, seule l'exponentielle complexe est remplacée par l'opérateur ternaire beaucoup plus court.

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

Essayez-le en ligne!

La sortie est un nombre complexe (PlusPrimes) + (MinusPrimes)i. J'espère que ce n'est pas trop contre les règles.

Explanation: C'est une fonction qui prend un argument entier. Nous parcourons tous les entiers de 5 à l'argument ( (5..$_)). Pour chacun de ceux-ci, nous évaluons .is-prime(ceci est appelé $_, l'argument du bloc mappé), le multiplions (s'il est numéroté True == 1, False == 0) avec une exponentielle complexe conçue pour être exp(0) = 1(pour $_%6 = 1) ou exp(iπ/2) = i(pour $_%6 = 5), et finalement l'arrondir à l'entier le plus proche. En les résumant avec[+] donne le résultat.

Enfin, c’est vraiment efficace, donc je ne suis pas sûr que TIO n’expérimentera pas une temporisation avant d’obtenir votre sortie pour des nombres plus élevés (pour 1e5, il faut 26 secondes sur ma machine et TIO a tendance à être un peu plus lent).

En fait , 21 octets

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

Essayez-le en ligne!

Envoie d'abord les PlusPrimes, puis les MinusPrimes

Explication:

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

Empilé , 37 octets

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

Essayez-le en ligne!

Plutôt lent, teste la primalité pour chaque K < N . Fonctionne comme mon J réponse.

MATLAB 2017a, 29 octets

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

Explication: primes(k)obtient tous les nombres premiers jusqu'à et y compris k. mod(primes(k),6)'prend le module 6 de tous les nombres premiers et le transpose pour que la somme corresponde à la dimension correcte.==[5,1]définit tous les cinq (minusPrimes) sur 1 dans la première colonne et tous les un (plusPrimes) sur 1 dans la deuxième colonne.sum()résume chaque colonne.

Cette sortie [minusPrime, plusPrime]

Japt , 18 16 octets

-2 octets grâce à @Oliver

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

Essayez-le en ligne!

Sorties au format [PlusPrimes, MinusPrimes].

C #, 202 179 174 octets

-23 octets grâce à M. Xcoder

-5 octets grâce à Cyoce

Fonction qui retourne un tableau de longueur 2, [MinusPrimes, PlusPrimes] exécutée par un appel a(n).

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

Code correctement formaté sur Essayez-le en ligne: ici

Haskell , 81 à 69 octets

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

Essayez-le en ligne!

La première solution était:

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

Mais j'ai lu la réponse de w0lf dans Ruby ...

Pyth , 15 octets

/K%R6fP_TSQ5/K1

Suite de tests.

Pyth , 16 octets

m/%R6fP_TSQd,1 5

Suite de tests.

Comment?

Explication # 1

/ K% R6fP_TSQ5 / K1 - Programme complet.

     fP_TSQ - Filtrez les nombres premiers dans la plage [1 ... entrée].
  % R6 - Mod 6 sur chacun.
 K - Attribuez-les à une variable K.
/ 5 - Compter les occurrences de 5 en K.
            / K1 - Compter les occurrences de 1 en K.
                - Sortie implicite du résultat.

Explication # 2

m /% R6fP_TSQd, 1 5 - Programme complet.

     fP_TSQ - Filtre les nombres premiers dans la plage [1 ... entrée]
  % R6 - Mod 6 sur chacun.
            , 1 5 - Poussez sur la liste [1, 5]
m / j - Comptez le nombre de chacun.  
                 - Sortie implicite du résultat. 

Alternatives:

/ K% R6fP_TSQ5 / KhZ (16 octets)
K% R6fP_TSQ / K5 / K1 (16 octets)
m /% R6fP_TSQdj15T (16 octets)
m /% R6fP_TSQd [1 5 (16 octets)   
m /% R6fP_TSQdsM`15 (17 octets)
m /% R6.MP_ZSQd, 1 5 (17 octets)
m /% R6.MP_ZSQdj15T (17 octets)
m /% R6.MP_ZSQd [1 5 (17 octets)

Jelly ,  12 11  10 octets

Merci à @cairdcoinheringaahing pour quelques conseils en discussion. Merci à @Dennis d' avoir enregistré un octet dans le chat.

ÆR%6ċЀ1,5

Essayez-le en ligne!

Gelée , 11 octets

ÆR%6µ1,5=þS

Essayez-le en ligne!

Gelée , 11 octets

ÆR%6µċ5,ċ1$

Essayez-le en ligne!

Comment cela marche-t-il?

Explication # 1

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

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

Explication # 2

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

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

Explication # 3

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

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

Java 8, 141 140 138 106 101 100 96 94 81 octets

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

Renvoie un-tableau d'entiers à deux valeurs, dans l' ordre inverse par rapport à la description de défi
[plusPrime, minusPrime].

Port de la réponse C # de @Xynos , après avoir joué au golf 39 40 42 octets.
Énorme aide de @ Nevay pour un autre énorme -55 octets.

Explication:

Essayez ici. (Le cas de test final de 4000000dépasse légèrement la limite de temps de 60 secondes.)

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

JavaScript (ES6), 83 82 80 68 66 octets

Il s'est avéré qu'une solution totalement récursive était beaucoup plus courte que la cartographie d'un tableau!

L'ordre de sortie est [-,+]. Craps avec une erreur de débordement quelque part autour de 3490.

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

L'essayer

o.innerText=(

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

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

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

CJam , 19 octets

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

Programme qui prend l’entrée de STDIN et produit les deux nombres séparés par une nouvelle ligne par STDOUT.

Essayez-le en ligne!

Explication

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

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

Numéros R + , 66 60 58 40 octets

-16 octets grâce à Jarko Dubbeldam! J'ai ensuite joué au golf deux autres octets.

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

Imprime PlusPrimes MinusPrimessur stdout; lit de stdin.

tabletabule le nombre de chaque occurrence des valeurs dans son vecteur d'entrée, par ordre croissant de valeur. Par conséquent, puisqu'il n'y a que deux valeurs, à savoir 1et 5(mod 6), il s'agit exactement de la fonction dont nous avons besoin numbers::Primes, qui renvoie tous les nombres premiers entre 4et l'entrée.

Essayez-le en ligne!

Base R , 97 91 89 86 65 octets

un tas d'octets enregistrés par Jarko ici aussi

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

Ceci est presque identique à ce qui est décrit ci-dessus, sauf qu'il calcule tous les nombres premiers en base R plutôt que d'utiliser un package et qu'il renvoie par la sortie de la fonction plutôt que de l'imprimer. Vous pouvez voir dans la sortie qu'elle renvoie une table avec des noms 1et 5, avec les nombres ci-dessous.

Essayez-le en ligne!

Paris / GP , 41 octets

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

Essayez-le en ligne!

JavaScript (SpiderMonkey) , 151 , 140 , 131 octets

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

Essayez-le en ligne!

Merci à Shaggy d’avoir aidé à résoudre un bug et à jouer au golf.

Explication:

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