Molti di noi sanno ...

che tutti i numeri primi p>3sono della forma

Ma quanti sono i Plus Primes ( 6n+1) e quanti sono i Minus Primes ( 6n-1) in un determinato intervallo?

La sfida

Dato un numero intero k>5, conta quanti primes<=ksono PlusPrimes e quanti sono MinusPrimes .

Esempi

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

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

Regole

Il tuo codice deve generare 2 numeri interi : uno per MinusPrimes e uno per PlusPrimes nell'ordine che preferisci (specifica quale è quale).
Questo è code-golf : vince la risposta più breve in byte!

Casi test

Input -> Output [ 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 byte

Salvato 1 byte grazie a Erik the Outgolfer

Uscite come [PlusPrimes, MinusPrimes]

LDpÏ6%5Ñ¢

Provalo online! o come una suite di test

Spiegazione

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

MATL , 10 byte

Zq6\!5lh=s

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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 byte

^{-2 byte grazie 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]

Provalo online!

Soluzione precedente, 83 81 79 byte

^{-1 byte grazie a Mr. Xcoder
-2 byte grazie 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])

Provalo online!
Entrambi vengono visualizzati come [MinusPrimes, PlusPrimes]

Gelatina , 7 byte

s6ÆPSm4

Inoltre, quindi meno.

Provalo online!

Come funziona

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 byte

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

Provalo online!

@ngenisis lo ha risolto, risparmiando 4 byte

Mathematica, 47 byte

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

Japt , 15 13 11 byte

L'ordine di uscita è [+,-].

õj ò6 yx ë4

Provalo

• Ha preso ispirazione dalla soluzione Jelly di Dennis ma, dopo aver giocato a golf, è più vicino a essere un porto.
• 2 byte salvati grazie ad Oliver che mi ha portato ëalla mia attenzione il metodo precedentemente sconosciuto per me .

Spiegazione

Input implicito di numero intero U.

õj

Genera una matrice di numeri interi ( õ) da 1 a Ue controlla se ognuno è un numero primo ( j), fornendo una matrice di valori booleani.

ò6

Suddividere l'array in sotto-array di lunghezza 6.

yx

Trasponi ( y) e somma le colonne.

ë4

Ottieni ogni quarto elemento dell'array e li genera in modo implicito.

Originale, 19 17 16 15 byte

õ fj
5â £è_%6¥X

Provalo

• 1 byte grazie a un suggerimento ispirato di Oliver di utilizzare i divisori di 5 dopo che mi ero riposato sugli allori dividendo 15 in un array.

J , 23 byte

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

Provalo online!

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 byte

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

*M`111
\b1\b

Provalo online! Spiegazione:

.+
$*

Converti in unario.

1
$`1¶

Conta da 1 a n.

G`1111

Elimina numeri inferiori a 4.

A`^(11+)\1+$

Elimina numeri composti.

1{6}

Prendi il resto modulo 6.

*M`111

Stampa il numero di numeri con un resto compreso tra 3 e 5.

\b1\b

Stampa il numero di numeri con un resto di 1.

Rubino, 61 60 byte

(52 byte + 8 per la -rprimesbandiera)

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

Restituisce una matrice della forma [più numeri primi, meno primi].

Salvato 1 byte grazie a GB!

Provalo online.

Perl 6 , 42 byte

Salvato 1 byte rimuovendo uno spazio inutile ...

Salvato 2 byte riorganizzando la map chiamata, grazie a @Joshua.

Salvato 3 byte perché .round uguale .round: 1 .

In realtà l'esponenziale complesso è bello ma molto costoso dal punto di vista del carattere. Salvato 10 byte semplicemente abbandonandolo ...

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

Provalo online!

Questa era la versione con l'esponenziale complesso. (Mi piace troppo per eliminarlo.) La nuova versione funziona esattamente allo stesso modo, solo il complesso esponenziale viene sostituito dall'operatore ternario molto più corto.

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

Provalo online!

L'output è un numero complesso (PlusPrimes) + (MinusPrimes)i. Spero non sia troppo contro le regole.

Spiegazione: È una funzione che accetta un argomento intero. Esaminiamo tutti i numeri interi da 5 all'argomento ( (5..$_)). Per ognuno di questi, valutiamo .is-prime(questo è chiamato $_, l'argomento del blocco mappato), lo moltiplichiamo (se numerato, True == 1, False == 0) con un esponenziale complesso che è reso exp(0) = 1( $_%6 = 1o) o exp(iπ/2) = i(per $_%6 = 5), e infine arrotondato a il numero intero più vicino. Riassumendoli con[+] ottiene il risultato.

Infine: è davvero efficiente, quindi non sono sicuro se TIO non scadrà prima di ottenere l'output per numeri più alti (per 1e5, ci vogliono 26 secondi sulla mia macchina e TIO tende ad essere un po 'più lento).

In realtà , 21 byte

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

Provalo online!

Produce prima PlusPrimes, seguito da MinusPrimes

Spiegazione:

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)

Impilato , 37 byte

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

Provalo online!

Piuttosto lento, verifica la primalità per ogni K < N . Funziona in modo simile alla mia risposta J.

MATLAB 2017a, 29 byte

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

Spiegazione: primes(k)ottiene tutti i numeri primi fino a k compreso. mod(primes(k),6)'prende il modulo 6 di tutti i numeri primi e lo traspone in modo che la somma scorra lungo la dimensione corretta. ==[5,1]imposta tutti i cinque (meno Primes) su 1 nella prima colonna e tutti quelli (piùPrimes) su 1 nella seconda colonna. sum()somma ogni colonna.

Questo produce [minusPrime, plusPrime]

Japt , 18 16 byte

-2 byte grazie a @Oliver

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

Provalo online!

Output nel formato [PlusPrimes, MinusPrimes].

C #, 202 179 174 byte

-23 byte grazie a Mr. Xcoder

-5 byte grazie a Cyoce

Funzione che restituisce un array di lunghezza 2, [MinusPrimes, PlusPrimes] eseguire chiamando 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;}

Codice correttamente formattato su Provalo online: qui

Haskell , 81 69 byte

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

Provalo online!

La prima soluzione è stata:

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)

Ma ho letto la risposta di w0lf in Ruby ...

Pyth , 15 byte

/K%R6fP_TSQ5/K1

Test Suite.

Pyth , 16 byte

m/%R6fP_TSQd,1 5

Test Suite.

Come?

Spiegazione n. 1

/ K% R6fP_TSQ5 / K1 - Programma completo.

     fP_TSQ - Filtra i numeri primi nell'intervallo [1 ... input].
  % R6 - Mod 6 su ciascuno.
 K - Assegnali a una variabile K.
/ 5 - Conta le occorrenze di 5 in K.
            / K1 - Conta le occorrenze di 1 in K.
                - Emette implicitamente il risultato.

Spiegazione n. 2

m /% R6fP_TSQd, 1 5 - Programma completo.

     fP_TSQ - Filtra i numeri primi nell'intervallo [1 ... input]
  % R6 - Mod 6 su ciascuno.
            , 1 5 - Premere l'elenco [1, 5]
m / d - Conta quanti ce ne sono.  
                 - Emette implicitamente il risultato. 

alternative:

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

Gelatina ,  12 11  10 byte

Grazie a @cairdcoinheringaahing per alcuni suggerimenti in chat. Grazie a @Dennis per aver salvato un byte nella chat.

ÆR%6ċЀ1,5

Provalo online!

Gelatina , 11 byte

ÆR%6µ1,5=þS

Provalo online!

Gelatina , 11 byte

ÆR%6µċ5,ċ1$

Provalo online!

Come funziona?

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

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

Spiegazione 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 100 94 94 81 byte

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

Restituisce un array intero con due valori, in ordine inverso rispetto alla descrizione della sfida:
[plusPrime, minusPrime] .

Porta della risposta C # di @Xynos , dopo aver giocato a golf 39 40 42 byte.
Grande aiuto da @Nevay per un altro enorme -55 byte.

Spiegazione:

Provalo qui. (Il caso di test finale 4000000supera leggermente il limite di 60 secondi.)

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 byte

Si è scoperto che una soluzione completamente ricorsiva era molto più breve della mappatura di un array!

L'ordine di uscita è [-,+]. Craps out con un errore di overflow intorno al 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

Provalo

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 byte

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

Programma che prende l'input da STDIN e produce i due numeri separati da newline tramite STDOUT.

Provalo online!

Spiegazione

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

Numeri R + , 66 60 58 40 byte

-16 byte grazie a Jarko Dubbeldam! Successivamente ho golf altri due byte.

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

Stampa PlusPrimes MinusPrimessu stdout; legge da stdin.

tabletabula il conteggio di ciascuna occorrenza dei valori nel suo vettore di input, in ordine crescente di valore. Quindi, poiché ci sono solo due valori, vale a dire 1e 5(mod 6), questa è esattamente la funzione di cui abbiamo bisogno, insieme a numbers::Primes, che restituisce tutti i numeri primi tra4 e l'input.

Provalo online!

Base R , 97 91 89 86 65 byte

un mucchio di byte salvati anche da Jarko qui

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

Questo è quasi identico a quanto sopra, tranne per il fatto che calcola tutti i numeri primi nella base R piuttosto che usare un pacchetto, e restituisce in base all'output della funzione anziché stamparlo. Nell'output è possibile vedere che restituisce una tabella con nomi 1e 5, con i conteggi seguenti.

Provalo online!

Pari / GP , 41 byte

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

Provalo online!

JavaScript (SpiderMonkey) , 151 , 140 , 131 byte

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

Provalo online!

Grazie a shaggy per l'aiuto con una correzione di bug e golf.

Spiegazione:

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