Більшість з нас знає ...

що всі праймери p>3мають форму

Але, скільки Плюс Прімес ( 6n+1) і скільки Мінус Праймс ( 6n-1) у певному діапазоні?

Змагання

Дано ціле число k>5, порахувати , скільки primes<=kце PlusPrimes і скільки MinusPrimes .

Приклади

адже у k=100нас є
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89] 12 мінусів
і
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97] 11 плюс

адже у k=149нас є
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89, 101, 107, 113, 131, 137, 149]
18 мінусів
і
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97, 103, 109, 127, 139]
15 плюс

Правила

Ваш код повинен виводити 2 цілих числа : одне для 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 байт

Збережено 1 байт завдяки Еріку Переможця

Виходи як [PlusPrimes, MinusPrimes]

LDpÏ6%5Ñ¢

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

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

MATL , 10 байт

Zq6\!5lh=s

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

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 байт

^{-2 байти завдяки Нілу}

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

Спробуйте в Інтернеті!

Попереднє рішення, 83 81 79 байт

^{-1 байт завдяки містеру Xcoder
-2 байти завдяки Halvard Hummel}

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

Спробуйте в Інтернеті!
Обидва виходять як [MinusPrimes, PlusPrimes]

Желе , 7 байт

s6ÆPSm4

Плюс, тоді мінус.

Спробуйте в Інтернеті!

Як це працює

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.

Математика, 51 байт

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

Спробуйте в Інтернеті!

@ngenisis переграв його, врятувавши 4 байти

Математика, 47 байт

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

Japt , 15 13 11 байт

Порядок виводу є [+,-].

õj ò6 yx ë4

Перевірте це

• Черпав натхнення у рішення Jelnis Jelly, але після гольфу він ближче до порту.
• 2 байти зберегли подяку Оліверу, довівши до мене невідомий раніше ëметод для масивів.

Пояснення

Неявне введення цілого числа U.

õj

Створіть масив цілих чисел ( õ) від 1 до Uта перевірте, чи кожне є простим ( j), даючи масив булей.

ò6

Розділіть масив на підмасиви довжиною 6.

yx

Перемістіть ( y) і підсумовуйте стовпці.

ë4

Отримати кожен четвертий елемент масиву та неявно виводити їх.

Оригінал, 19 17 16 15 байт

õ fj
5â £è_%6¥X

Перевірте це

• 1 байт завдяки натхненній пропозиції Олівера використовувати дільники 5 після того, як я відпочив на лаврах, розділяючи 15 на масив.

J , 23 байти

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

Спробуйте в Інтернеті!

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)

Сітківка , 53 51 байт

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

*M`111
\b1\b

Спробуйте в Інтернеті! Пояснення:

.+
$*

Перетворити в одинарне.

1
$`1¶

Полічити від 1 до n.

G`1111

Видалити числа менше 4.

A`^(11+)\1+$

Видаліть складені числа.

1{6}

Візьміть залишок за модулем 6.

*M`111

Роздрукуйте кількість цифр із залишком від 3 до 5.

\b1\b

Надрукуйте кількість цифр із залишком 1.

Рубі, 61 60 байт

(52 байти + 8 для -rprimesпрапора)

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

Повертає масив форми [плюс праймес, мінус primes].

Збережено 1 байт завдяки ГБ!

Спробуйте в Інтернеті.

Perl 6 , 42 байти

Збережено 1 байт, видаливши марний простір ...

Збережено 2 байти, реорганізувавши map виклик - завдяки @Joshua.

Збережено 3 байти, тому що .round дорівнює .round: 1 .

Насправді складний показник є класним, але дуже дорогим характером. Збережено 10 байт, просто скинувши його ...

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

Спробуйте в Інтернеті!

Це була версія зі складним експоненціалом. (Мені це дуже подобається, щоб його видалити.) Нова версія працює точно так само, просто складний експонент замінюється набагато коротшим термінальним оператором.

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

Спробуйте в Інтернеті!

Вихід - це складне число (PlusPrimes) + (MinusPrimes)i. Я сподіваюся, що це не надто проти правил.

Пояснення: Це функція, яка бере один цілий аргумент. Ми повторюємо всі цілі числа від 5 до аргументу ( (5..$_)). Для кожного з них ми оцінюємо .is-prime(до цього називається $_аргумент відображеного блоку), помножуємо його (якщо нумеровано True == 1, False == 0) на складний показник, який робиться як exp(0) = 1(для $_%6 = 1), або exp(iπ/2) = i(для $_%6 = 5), і, нарешті, округляємо його до найближче ціле число. Підсумовування їх [+]дає результат.

Нарешті: це дійсно ефективно, тому я не впевнений, чи TIO не вичерпає час, перш ніж ви отримаєте вихід для більшої кількості (для 1e5 це займає 26 секунд на моїй машині, а TIO має тенденцію дещо повільніше).

Власне , 21 байт

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

Спробуйте в Інтернеті!

Спочатку виводиться PlusPrimes, а потім - MinusPrimes

Пояснення:

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)

Зіставлено , 37 байт

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

Спробуйте в Інтернеті!

Досить повільні, тести на первинність для кожного K < N . Працює аналогічно моїй відповіді J.

MATLAB 2017a, 29 байт

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

Пояснення: primes(k)отримує всі прайми до і включаючи k. mod(primes(k),6)'приймає модуль 6 усіх простих чисел і переміщує його, щоб сума пролягала за правильним виміром. ==[5,1]встановлює всі п'яти (мінусПриміни) на 1 у першому стовпці, а всі (плюсПримени) на 1 у другому стовпці. sum()підсумовує кожен стовпець.

Це виводить [minusPrime, plusPrime]

Japt , 18 16 байт

-2 байти завдяки @Oliver

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

Спробуйте в Інтернеті!

Виводи у форматі [PlusPrimes, MinusPrimes].

C #, 202 179 174 байт

-23 байти, дякую містеру Xcoder

-5 байт завдяки Cyoce

Функція, яка повертає масив довжиною 2, [MinusPrimes, PlusPrimes] Виконати за допомогою виклику 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;}

Правильно відформатований код у програмі "Спробуйте онлайн": Ось

Haskell , 81 69 байт

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

Спробуйте в Інтернеті!

Першим рішенням було:

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)

Але я прочитав відповідь w0lf в Ruby ...

Pyth , 15 байт

/K%R6fP_TSQ5/K1

Тестовий сюїт.

Pyth , 16 байт

m/%R6fP_TSQd,1 5

Тестовий сюїт.

Як?

Пояснення №1

/ K% R6fP_TSQ5 / K1 - Повна програма.

     fP_TSQ - Фільтр простирадрів у діапазоні [1 ... введення].
  % R6 - Mod 6 на кожен.
 К - Призначте їх до змінної К.
/ 5 - Порахуйте випадки 5 у К.
            / К1 - Порахуйте випадки 1 в К.
                - Неналежне виведення результату.

Пояснення №2

м /% R6fP_TSQd, 1 5 - Повна програма.

     fP_TSQ - Фільтр простирадрів у діапазоні [1 ... input]
  % R6 - Mod 6 на кожен.
            , 1 5 - Натисніть на список [1, 5]
м / д - Порахуйте, скільки їх є.  
                 - Неналежне виведення результату. 

Альтернативи:

/ K% R6fP_TSQ5 / ХЗ (16 байт)
K% R6fP_TSQ / K5 / K1 (16 байт)
м /% R6fP_TSQdj15T (16 байт)
м /% R6fP_TSQd [1 5 (16 байт)   
м /% R6fP_TSQdsM`15 (17 байт)
м /% R6.MP_ZSQd, 1 5 (17 байт)
м /% R6.MP_ZSQdj15T (17 байт)
м /% R6.MP_ZSQd [1 5 (17 байт)

Желе ,  12 11  10 байт

Дякуємо @cairdcoinheringaahing за кілька порад у чаті. Дякуємо @Dennis за збереження одного байта у чаті.

ÆR%6ċЀ1,5

Спробуйте в Інтернеті!

Желе , 11 байт

ÆR%6µ1,5=þS

Спробуйте в Інтернеті!

Желе , 11 байт

ÆR%6µċ5,ċ1$

Спробуйте в Інтернеті!

Як це працює?

Пояснення №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.

Пояснення №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.

Пояснення №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 байт

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

Повертає цілий масив з двома значеннями у зворотному порядку порівняно з описом виклику:
[plusPrime, minusPrime] .

Порт @Xynos 'C # відповідь , після того як я пограв 39 40 42 байт.
Величезна допомога від @Nevay для чергових колосальних -55 байт.

Пояснення:

Спробуйте тут. (Остаточний тестовий випадок 4000000трохи перевищує обмеження часу в 60 с.)

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 байт

Виявилося, повністю рекурсивне рішення було набагато коротшим, ніж відображення масиву!

Порядок виводу є [-,+]. Виникає з помилкою переповнення десь 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

Спробуй це

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 байт

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

Програма, яка приймає вхід від STDIN і виводить два числа, розділені новою лінією через STDOUT.

Спробуйте в Інтернеті!

Пояснення

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

R + числа , 66 60 58 40 байт

-16 байт завдяки Джарко Дуббелдам! Згодом я відіграв ще два байти.

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

Відбитки PlusPrimes MinusPrimesдо stdout; читає зі стдін.

tableпідраховує підрахунок кожного виникнення значень у вхідному векторі у порядку зростання значення. Отже, оскільки є лише два значення, а саме 1і 5(mod 6), саме ця функція, яка нам потрібна, разом з numbers::Primesякою повертає всі прайми між4 входом та входом.

Спробуйте в Інтернеті!

База R , 97 91 89 86 65 байт

купа байтів, збережених Ярко і тут

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

Це майже ідентично вищесказаному, за винятком того, що він обчислює всі прайми в базовій R, а не використовуючи пакет, і він повертається шляхом виведення функції, а не друку. Видно у висновку, що він повертає таблицю з іменами 1та 5з підрахунками нижче.

Спробуйте в Інтернеті!

Парі / GP , 41 байт

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

Спробуйте в Інтернеті!

JavaScript (SpiderMonkey) , 151 , 140 , 131 байт

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

Спробуйте в Інтернеті!

Завдяки кошлатому, що допомагає виправляти помилки та займатися гольфом.

Пояснення:

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