La mayoría de nosotros sabemos ...

que todos los números primos p>3son de la forma

Pero, ¿cuántos son los Primos más ( 6n+1) y cuántos son los Primos menos ( 6n-1) en un rango determinado?

El reto

Dado un número entero k>5, cuente cuántos primes<=kson PlusPrimes y cuántos son MinusPrimes .

Ejemplos

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

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

Reglas

Su código debe generar 2 enteros : uno para MinusPrimes y otro para PlusPrimes en el orden que desee (especifique cuál es cuál).
Este es el código de golf : ¡la respuesta más corta en bytes gana!

Casos de prueba

Entrada -> Salida [ 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 bytes

Guardado 1 byte gracias a Erik el Outgolfer

Salidas como [PlusPrimes, MinusPrimes]

LDpÏ6%5Ñ¢

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

MATL , 10 bytes

Zq6\!5lh=s

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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 bytes

^{-2 bytes gracias a 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]

Pruébalo en línea!

Solución anterior, 83 81 79 bytes

^{-1 byte gracias al Sr. Xcoder
-2 bytes gracias a Halvard Hummel}

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

Pruébalo en línea!
Tanto la salida como [MinusPrimes, PlusPrimes]

Jalea , 7 bytes

s6ÆPSm4

Más, luego menos.

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

@ngenisis lo bajó, ahorrando 4 bytes

Mathematica, 47 bytes

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

Japt , 15 13 11 bytes

El orden de salida es [+,-].

õj ò6 yx ë4

Pruébalo

• Se inspiró en la solución Jelly de Dennis pero, después de jugar al golf, está más cerca de ser un puerto.
• 2 bytes guardados gracias a que Oliver me trajo ëa mi atención el método previamente desconocido para matrices.

Explicación

Entrada implícita de entero U.

õj

Genere una matriz de enteros ( õ) de 1 a Uy compruebe si cada uno es un primo ( j), dando una matriz de booleanos.

ò6

Particionar la matriz en sub-matrices de longitud 6.

yx

Transponer ( y) y sumar las columnas.

ë4

Obtenga cada 4to elemento de la matriz y explíquelos implícitamente.

Original, 19 17 16 15 bytes

õ fj
5â £è_%6¥X

Pruébalo

• 1 byte gracias a una sugerencia inspirada de Oliver para usar los divisores de 5 después de haber descansado en mis laureles dividiendo 15 en una matriz.

J , 23 bytes

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

Pruébalo en línea!

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 bytes

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

*M`111
\b1\b

Pruébalo en línea! Explicación:

.+
$*

Convierte a unario.

1
$`1¶

Cuenta desde 1 hasta n.

G`1111

Eliminar números menores que 4.

A`^(11+)\1+$

Eliminar números compuestos.

1{6}

Tome el resto del módulo 6.

*M`111

Imprima el número de números con un resto entre 3 y 5.

\b1\b

Imprima el número de números con un resto de 1.

Ruby, 61 60 bytes

(52 bytes + 8 para la -rprimesbandera)

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

Devuelve una matriz de la forma [primos más, primos menos].

¡Guardado 1 byte gracias a GB!

Pruébalo en línea.

Perl 6 , 42 bytes

Se guardó 1 byte al eliminar un espacio inútil ...

Ahorré 2 bytes al reorganizar la map llamada, gracias a @Joshua.

Guardado 3 bytes porque .round es igual .round: 1 .

En realidad, el exponencial complejo es genial pero muy costoso en cuanto a caracteres. Ahorró 10 bytes simplemente abandonándolo ...

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

Pruébalo en línea!

Esta era la versión con el exponencial complejo. (Me gusta demasiado como para eliminarlo). La nueva versión funciona exactamente de la misma manera, solo el exponencial complejo se reemplaza por el operador ternario mucho más corto.

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

Pruébalo en línea!

La salida es un número complejo (PlusPrimes) + (MinusPrimes)i. Espero que no sea demasiado en contra de las reglas.

Explicación: Es una función que toma un argumento entero. Repetimos todos los enteros desde 5 hasta el argumento ( (5..$_)). Para cada uno de estos, evaluamos .is-prime(se llama a esto $_, el argumento del bloque mapeado), lo multiplicamos (si se numera True == 1, False == 0) con un exponencial complejo que se convierte en exp(0) = 1(para $_%6 = 1) o exp(iπ/2) = i(para $_%6 = 5), y finalmente lo redondeamos a El entero más cercano. Sumarlos con [+]da el resultado.

Finalmente: es realmente eficiente, por lo que no estoy seguro de si TIO no excederá el tiempo de espera antes de que obtenga su salida para números más altos (para 1e5, toma 26 segundos en mi máquina, y TIO tiende a ser algo más lento).

En realidad , 21 bytes

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

Pruébalo en línea!

Imprime primero los PlusPrimes, seguidos por los MinusPrimes

Explicación:

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)

Apilado , 37 bytes

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

Pruébalo en línea!

Más bien lento, las pruebas de primalidad para cada K < N . Funciona de manera similar a mi respuesta J.

MATLAB 2017a, 29 bytes

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

Explicación: primes(k)obtiene todos los números primos hasta k inclusive. mod(primes(k),6)'toma el módulo 6 de todos los números primos y lo transpone para que la suma se ejecute a lo largo de la dimensión correcta.==[5,1]establece todos los cinco (minusPrimes) en 1 en la primera columna y todos los (plusPrimes) en 1 en la segunda columna. sum()suma cada columna.

Esto salidas [minusPrime, plusPrime]

Japt , 18 16 bytes

-2 bytes gracias a @Oliver

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

Pruébalo en línea!

Salidas en el formato [PlusPrimes, MinusPrimes].

C #, 202 179 174 Bytes

-23 Bytes gracias al Sr. Xcoder

-5 Bytes gracias a Cyoce

Función que devuelve una matriz de longitud 2, [MinusPrimes, PlusPrimes] Ejecutar llamando 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;}

Código correctamente formateado en Pruébelo en línea: aquí

Haskell , 81 69 bytes

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

Pruébalo en línea!

La primera solución fue:

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)

Pero leí la respuesta de w0lf en Ruby ...

Pyth , 15 bytes

/K%R6fP_TSQ5/K1

Banco de pruebas.

Pyth , 16 bytes

m/%R6fP_TSQd,1 5

Banco de pruebas.

¿Cómo?

Explicación # 1

/ K% R6fP_TSQ5 / K1: programa completo.

     fP_TSQ - Filtra los primos en el rango [1 ... entrada].
  % R6 - Mod 6 en cada uno.
 K - Asignarlos a una variable K.
/ 5 - Cuenta las ocurrencias de 5 en K.
            / K1: cuenta las ocurrencias de 1 en K.
                - Salida implícita del resultado.

Explicación # 2

m /% R6fP_TSQd, 1 5 - Programa completo.

     fP_TSQ - Filtra los primos en el rango [1 ... entrada]
  % R6 - Mod 6 en cada uno.
            , 1 5 - Presione la lista [1, 5]
m / d: cuenta cuántos de cada uno hay.  
                 - Salida implícita del resultado. 

Alternativas:

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

Jalea ,  12 11  10 bytes

Gracias a @cairdcoinheringaahing por algunos consejos en el chat. Gracias a @Dennis por guardar un byte en el chat.

ÆR%6ċЀ1,5

Pruébalo en línea!

Jalea , 11 bytes

ÆR%6µ1,5=þS

Pruébalo en línea!

Jalea , 11 bytes

ÆR%6µċ5,ċ1$

Pruébalo en línea!

¿Como funciona esto?

Explicación # 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.

Explicación # 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.

Explicación # 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 bytes

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

Devuelve un entero-array con dos valores, en orden inverso en comparación con la descripción reto:
[plusPrime, minusPrime].

Puerto de @Xynos C # respuesta ' , después de que Jugamos al golf 39 40 42 bytes.
Enorme ayuda de @Nevay para otro enorme -55 bytes.

Explicación:

Pruébalo aquí (El caso de prueba final 4000000excede ligeramente el límite de tiempo de 60 segundos).

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 bytes

Resultó que una solución totalmente recursiva era mucho más corta que mapear una matriz.

El orden de salida es [-,+]. Craps con un error de desbordamiento en algún lugar alrededor 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

Intentalo

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 bytes

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

Programa que toma la entrada de STDIN y emite los dos números separados por nueva línea a través de STDOUT.

Pruébalo en línea!

Explicación

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

Números R + , 66 60 58 40 bytes

-16 bytes gracias a Jarko Dubbeldam! Posteriormente jugué otros dos bytes.

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

Imprime PlusPrimes MinusPrimesen stdout; lee de stdin.

table tabulates the count of each occurrence of the values in its input vector, in ascending order of value. Hence, since there are only two values, namely 1 and 5 (mod 6), this is exactly the function we need, along with numbers::Primes, which returns all primes between 4 and the input.

Try it online!

Base R, 97 91 89 86 65 bytes

a bunch of bytes saved by Jarko here, too

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

This is nearly identical to the above, except it calculates all the primes in base R rather than using a package, and it returns by function output rather than printing it out. You can see in the output that it returns a table with names 1 and 5, with the counts below.

Try it online!

Pari/GP, 41 bytes

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

Try it online!

JavaScript (SpiderMonkey), 151, 140, 131 bytes

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

Try it online!

Thanks to shaggy for helping with a bug fix and golfing.

Explanation:

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