Рядок Primenary ( бінарний прайм ) - це той, який, коли записується у вигляді двійкової сітки, у кожному рядку та стовпці має просту суму.

Це досить розпливчасте пояснення, тож давайте розбимо його на відпрацьованому прикладі ...

Для цього прикладу ми будемо використовувати рядок bunny:

Спочатку знайдіть точку коду ASCII кожного символу та його двійкове представлення:

Char | ASCII | Binary

b      98      1100010
u      117     1110101
n      110     1101110
n      110     1101110
y      121     1111001

Візьміть ці двійкові значення зверху вниз та впорядкуйте їх у сітку (додавши при необхідності нулі):

1 1 0 0 0 1 0
1 1 1 0 1 0 1
1 1 0 1 1 1 0
1 1 0 1 1 1 0
1 1 1 1 0 0 1

Потім підрахуйте кількість 1s у кожному рядку та стовпці:

1 1 0 0 0 1 0   > 3
1 1 1 0 1 0 1   > 5
1 1 0 1 1 1 0   > 5
1 1 0 1 1 1 0   > 5
1 1 1 1 0 0 1   > 5

v v v v v v v

5 5 2 3 3 3 2

Якщо, і лише якщо, кожне одне сумарне є простим (наприклад, тут), то рядок є дійсним бінарним простим.

Змагання

Ваше завдання - створити функцію або програму, яка при truthyвведенні рядка повертає / виводить, якщо рядок є первинним та falsyіншим чином.

Правила / подробиці

• Ви можете припустити, що символи рядка завжди будуть у діапазоні ASCII 33-126(включно).
• Рядок не буде порожнім.
• Попередня рядок не повинна мати прості довжини - наприклад, W1n*дійсна, незважаючи на 4 символи.
• Це код-гольф , тому найкоротша відповідь (у байтах) виграє - але всі подані матеріали вітаються.
• Стандартні лазівки заборонені.

Випробування

'husband'     -> True
'HOTJava'     -> True
'COmPaTIBILE' -> True
'AuT0HACk'    -> True

'PPCW'        -> False
'code-golf'   -> False
'C++'         -> False
'/kD'         -> False

'HI'          -> False
'A'           -> False

На repl.it також є робочий, але неймовірно багатослівний приклад Python, на який можна протестувати своє рішення.

MATL, 10 байт

BtXsw!shZp

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

Це ідеальна мова для роботи. Це майже буквальна транслітерація специфікації виклику.

Bt % Converts input to binary matrix, duplicate
Xs  % Sum columns (alternative X version to prevent defaulting to sum along first non-singleton dimension, thanks @Jonathan Allan)
w! % Get the duplicate to the top of the stack, transpose
s  % Sum again
h  % Concatenate horizontally
Zp % Check primality element-wise. Display implicitly.

Оскільки будь-який нуль робить масив MATL неправдивим, відповідно до мета , нічого іншого не потрібно - в основному, неявний Aзаклик ?(якщо).

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

OBUZ;$S€ÆPẠ

СпробуйтеItOnline! або всі тестові випадки

Як?

OBUZ;$S€ÆPẠ - Main link: word                  e.g. ha!
O           - cast to ordinals                 e.g. [104,97,33]
 B          - convert to binary                e.g. [[1,1,0,1,0,0,0],[1,1,0,0,0,0,1],[1,0,0,0,0,1]]
  U         - reverse each entry (say "b")     e.g. [[0,0,0,1,0,1,1],[1,0,0,0,0,1,1],[1,0,0,0,0,1]]
     $      - last two links as a monad
   Z        - transpose                        e.g. [[0,1,1],[0,0,0],[0,0,0],[1,0,0],[0,0,0],[1,1,1],[1,1]]
    ;       - concatenate with "b"             e.g. [[0,1,1],[0,0,0],[0,0,0],[1,0,0],[0,0,0],[1,1,1],[1,1],[0,0,0,1,0,1,1],[1,0,0,0,0,1,1],[1,0,0,0,0,1]]
      S€    - sum €ach                         e.g. [2,0,0,1,0,3,2,3,3,2]
        ÆP  - is prime (1 if prime, 0 if not)  e.g. [1,0,0,0,0,1,1,1,1,1]
          Ạ - all truthy?                      e.g. 0

05AB1E , 17 байт

Çžz+b€¦€SDøìO0ÛpP

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

Желе , 15 байт

O+⁹Bṫ€3µS€;SÆPP

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

Пояснення

O+⁹Bṫ€3µS€;SÆPP  Main link. Input: string z
O                Ordinal, get ASCII value of each char
  ⁹              Nilad representing 256
 +               Add 256 to each ordinal value
   B             Binary digits of each
    ṫ€3          Tail, take each list of digits from the 3rd value to the end
                 These are the last seven digits of each
       µ         Start a new monadic chain
        S€       Sum each list of digits by rows
           S     Sum by column
          ;      Concatenate
            ÆP   Test if each is prime, 1 if true else 0
              P  Product

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

And@@Join@@PrimeQ@{+##&@@#,+##&@@@#}&@IntegerDigits[ToCharacterCode@#,2,7]&

Без імені функція приймає рядок в якості вхідних даних і повернення Trueабо False.

ToCharacterCode@#перетворює вхід у список його значень ASCII; IntegerDigits[...,2,7]перетворює кожне значення у перелік його бітів, доданий при необхідності до довжини 7. Отже, у нас є двовимірний масив, і ми хочемо, щоб всі його суми рядків і суми стовпців; ось і ось, спазм символів {+##&@@#,+##&@@@#}&@...робить саме це (він застосовує функцію +##&"підсумовувати всі аргументи" до списку векторів першої координати за допомогою @@, а до кожного вектору - як власний список цілих чисел у другій координаті за допомогою @@@) . Потім ми просто перевіряємо, чи є результати PrimeQ, вирівнюємо список Join@@і беремо Andвсі ці значення.

Рубін -rprime , 100 байт

->s{a=s.bytes.map{|b|b.digits 2}
a.all?{|r|r.sum.prime?}&([0]*7).zip(*a).all?{|c|c.count(1).prime?}}

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

Пояснення

->s{
    a=s.bytes                       # Get byte values from string
             .map{|b|b.digits 2}    # For each, map it to its binary digits
                                    #   (least significant digits first)
a.all?{|r|r.sum.prime?}             # Each character has a prime number of 1's?
    &                               # Bit-and (because it saves bytes here)
    ([0]*7).zip(*a)                 # Zip bit array with an all-zero array
                                    #   (If we don't, then uneven array lengths
                                    #   cause some columns to not be returned.)
    .all?{|c|c.count(1).prime?}     # All columns have a prime number of 1's?
                                    #   (We use count instead of sum here because
                                    #   zip pads columns with trailing nils, which
                                    #   can't be added to numbers via sum.)
}

Perl, 151 121 111 + 3 = 114 байт

Бігайте з -lF . Програма буде правильно функціонувати лише для першого введення. Завершіть програму і повторіть наступний вхід.

Завдяки @Dada за те, що повідомив мені, що //після цього Fбуло зайвим. Додатковий байт можна видалити (для 112), проклавши вхід через через echo -n, але я відчуваю, що це технічно додає більше коду, тому YMMV.

for$c(@a=map{sprintf"%07b",ord}@F){$b[$_].=substr$c,$_,1 for 0..6}s/0//g,$d|=/^1?$|^(11+?)\1+$/ for@a,@b;say!$d

Читає:

                                     #Implicitly split input into characters in @F array
for$c(@a=map{sprintf"%07b",ord}@F)  #Convert @F to 7-bit binary as @a, then loop through it                        
    $b[$_].=substr$c,$_,1 for 0..6   #Transpose @a's bits into @b
}
s/0//g,$d|=/^1?$|^(11+?)\1+$/ for@a,@b; #Remove any zeros, then run through composite regex
say!$d                          #If all composite regex checks fail, then it's fully prime.

Пітон 3, 228 227 225 байт

Не чудова відповідь, я не зміг пограти в нього так сильно, як хотілося б, але я витратив на нього так довго, що я відчуваю, що мушу опублікувати його. Пропозиції щодо скорочення байтів були б дуже вдячні.

r=range
n=[format(ord(c),"08b")for c in input()]
n=map(lambda s:s.count("1"),n+["".join([f[1]for f in filter(lambda e:e[0]%8<1,enumerate("X"*-~i+"".join(n)))][1:])for i in r(8)])
print(all(all(s%d for d in r(2,s))for s in n))

Редагувати 1: замінено e[0]%8==0на e[0]%8<1, втрачаючи байт. Дякую Flp.Tkc!

Редагувати 2: замінити (i + 1) на - ~ i, втратити два додаткові байти. Дякую Еріку, що виявив, наскільки погані мої знання на рівні бітів :) Під час тестування цієї версії я виявив, що kappaце дійсно ... зроби з того, що ти будеш.

Groovy, 151 137 байт

{p={x->x<3||(2..(x**0.5)).every{x%it}};y={it.every{p(it.count("1"))}};x=it.collect{0.toString((int)it,2) as List};y(x)&&y(x.transpose())}

Немає перевірки первинності в шумному ...

p={x->x<3||(2..(x**0.5)).every{x%it}}; - закриття для перевірки первинності.

y={it.every{p(it.count("1"))}}; - Закриття, щоб гарантувати, що всі рахунки "1" для пройденого бінарного 2D масиву є простими.

x=it.collect{0.toString((int)it,2) as List}; - Покриття від рядка до двійкового масиву.

y(x)&&y(x.transpose()) - Для всіх попередньо підтверджених сум у головній матриці та транспонованій матриці переконайтесь, що вони повертаються у вірно.

Pyth , 37 байт

L.AmP_sdb=sMM.[L\0lh.MlZQ=.BMQ&yZy.TZ

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

                                 Code | Explanation
--------------------------------------+----------------------------------------------------------------
L.AmP_sdb=sMM.[L\0lh.MlZQ=.BMQ&yZy.TZ | Full code
L                                     | Define function y(b):
   m    b                             |   For each d in b:
    P_sd                              |     Is the sum of the elements of the list prime?
 .A                                   |   Return whether all elements of the resulting list are truthy
                         =   Q        | Assign the following to Q:
                          .BMQ        |   The list of binary strings for each character in the input
         =             Z              | Assign the following to Z:
               L             Q        |   For every element in Q:
             .[ \0                    |     Pad with 0 on the left
                  lh.MlZQ             |     To the length of the longest element in Q
            M                         |   For each element in the resulting list:
          sM                          |     Convert each character to an integer
                              &yZ     | Print y(Z) AND
                                 y.TZ |   y( <Transpose of Z> )

Брахілог , 14 байт

ạḃᵐB↔ᵐz₁,B+ᵐṗᵐ

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

Виходи через успіх чи невдачу. (У разі успіху список всіх сум стовпців та рядків доступний через вихідну змінну.

   B              The variable B is
ạ                 the codepoints of the input
 ḃᵐ               converted to lists of binary digits,
    ↔ᵐ            which with each list reversed
      z₁          then zipped without cycling
        ,B        and concatenated with B
          +ᵐ      has elements which all sum to
            ṗᵐ    prime numbers.

O5AB1E, 12 байт

Çžy+bø€SOp¦W

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

Це мій перший гольф з кодом, так що просто :)

Ç              % Converts the implicit input into ascii values
 žy+           % Adds 128 to each value, inspired by Emigna as a way to pad zeros
    b          % Convert all values into bits
     ø         % Transpose
      €SO      % Sum each string of binary digits created
         p¦    % Check if each element is prime and cut the first element out (adding 128 makes it equal to the number of characters)
           W   % Take the minimum value to effectively "and" all the elements

Пітон 3 , 209 189 180 171 160 байт

Спасибі кальмарів на -9 байт :)

def p(s):n=s.count('1');return(n>1)*all(n%i for i in range(2,n))
def f(s):t=[f'{ord(c):07b}'for c in s];return all(map(p,t+[[u[j]for u in t]for j in range(7)]))

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

К (оК) , 40 33 байт

Рішення:

&/{2=+/d=_d:x%!x}'+/'m,+m:(7#2)\'

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

Пояснення:

Половина створює матрицю, інша половина - перевірка первинності.

&/{2=+/d=_d:x%!x}'+/'m,+m:(7#2)\' / the solution
                                ' / apply to each (')
                               \  / decode
                          (   )   / do this together
                           7#2    / 7#2 => 2 2 2 2 2 2 2
                        m:        / save as m
                       +          / transpose
                     m,           / append to m
                  +/'             / sum (+/) each (')
                 '                / apply to each
  {             }                 / lambda taking implicit x
              !x                  / range 0..x
            x%                    / x divided by ...
          d:                      / save as d
         _                        / floor
       d=                         / equal to d?
     +/                           / sum (+/)
   2=                             / equal to 2?
&/                                / minimum

PHP, 173 байти

for($r=1;$b=substr_count($t[$i]=sprintf('%07b',ord($argv[1][$i++])),1);)$r&=$b==2|$b%2&$b>2;for(;$k++<7;){for($b=$j=0;$t[++$j];$b+=$t[$j][$k-1]);$r&=$b==2|$b%2&$b>2;}echo$r;

Перевірте це в Інтернеті

JavaScript, 234 байти

f=z=>(z=[...z].map(v=>v.charCodeAt(0))).map(v=>v.toString(2).replace(/0/g,"").length).every((p=v=>{for(i=2;i<v;i++){if(v%i===0){return 0}};return v>1}))&&[...""+1e6].map((v,i)=>z.reduce((a,e)=>!!(e&Math.pow(2,i))+a,0)).every(v=>p(v))

Ми отримуємо горизонтальні значення, перетворюючи число у бінарне, видаляючи нулі за допомогою заміни рядка, а потім підраховуючи 1. Вертикальні суми одержують циклом від 1 до 7 та використанням бітового І з піднятим на 2-ю потужність.

Clojure, 180 байт

#(let[S(for[i %](for[j[1 2 4 8 16 32 64]](min(bit-and(int i)j)1)))A apply](not-any?(fn[i](or(= i 1)(seq(for[d(range 2 i):when(=(mod i d)0)]d))))(into(for[s S](A + s))(A map + S))))

Можливо, існує коротший спосіб генерування бітових списків, а також тест примітивності.

Perl 5 -MList::Util=all,sum -pF , 96 92 байт

$_=all{//;all{$'%$_}2..$_-1}(map{$_=sprintf'%07b',ord;y/1//}@F),map{sum map{s/.//;$&}@F}0..6

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

Пітон 3, 164 байти

import numpy;a=numpy.array([list(f'{ord(_):07b}')for _ in input()]).astype(int);print(all([(v>1)*all(v%i for i in range(2,v))for v in set(a.sum(0))|set(a.sum(1))]))

Рубін 2,7 -rprime, 95 байт

->s{a=s.bytes.map{[*@1.digits(2),0][..6]}
(a.map(&:sum)+a.transpose.map(&:sum)).all?(&:prime?)}

Немає зв'язку TiO, оскільки TiO все ще працює з Ruby 2.5.5. 😭

Пояснення

Досить просто. Перший рядок отримує двійкові цифри кожного символу у вигляді масиву, доповненого семи цифрами, що дійсно повинно бути простіше:

a = s.bytes.map { [*@1.digits(2), 0][..6] }

Перевірте , що параметр пронумеровані блок ( @1) і діапазон beginless ( ..6) жаркость .

Другий рядок підсумовує рядки та стовпці та тести, чи всі вони є простими:

(a.map(&:sum) + a.transpose.map(&:sum)).all?(&:prime?)

JavaScript (Node.js) , 149 146 ... 134 130 129 байт

x=>[...x].map(y=>a=[...a.map(n=>y.charCodeAt()&2**i++?++z&&-~n:n,z=i=0),z],a=[...Array(7)])&&!a.some(n=>(P=r=>n%--r?P(r):~-r)(n))

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

Пояснення

x=>                        // Main function:
 [...x].map(               //  For each y in x:
  y=>
   a=[...a.map(            //   For each i in range(0, len(a)):
    n=>                   
     y.charCodeAt()&2**i++ //    If y AND 2**i is not zero:
     ?++z&&-~n:n,          //     z = z + 1; a[i] = a[i] + 1 (1 if a[i] is undefined)
    z=i=0                  //   Initially z = 0
   ),z],                   //   Then push z at the end of a
  a=[...Array(7)]          //  Initially a = [undefined] * 7
 )&&!a.some(               //  Then for each n in a:
  n=>(
   P=r=>                   //   Composite function:
    n%--r?                 //    If n % (r - 1) == 0 or r == 1:
     P(r)                  //     Return P(r - 1)
    :~-r                   //    Else: Return r - 2
  )(n)                     //   Starting from r = n
 )                         //  Return whether the composite function returns 0 for all n.

Як це навіть працює !?

• y.charCodeAt()&2**i
  • Цей код нам потрібен, щоб повернути відповідний біт y.charCodeAt()if0 <= i < 7 і 0 в іншому випадку.
  • Коли i < 7 , код, мабуть, працює як завжди.
  • Коли 7 <= i <= 32, оскільки відповідний бітy.charCodeAt() дорівнює 0, результат дорівнює 0, як очікувалося.
  • Коли 32 < i < 1024, з тих пірint32(2**i) == 0 , результат дорівнює 0, як очікувалося.
  • Коли 1024 <= iми маємо 2**i == Infinityі з тих пір int32(Infinity) == 0, результат дорівнює 0, як очікувалося.
• (P=r=>n%--r?P(r):~-r)(n)
  • Для простоти ми дозволяємо R = --r = r - 1.
  • Ця допоміжна функція припиняється, коли n % R == 0або n % R is NaN.
    • n % R == 0: Rє фактором n.
      • Якщо R == 1, то nце прем'єр, тому що всі 1 < R < nне можуть розділити n. Повернути 0 (помилково).
      • Якщо R == -1, то n == 0. Повернення -2 (truthy).
      • В іншому випадку поверніться R - 1куди R - 1 > 0(truthy).
    • n % R is NaN: Недійсний модульний розрахунок.
      • Якщо R == 0:n == 1. Повернення -1 (truthy).
      • Якщо n is NaN: R is NaN. Повернення -1 (truthy).
  • Як результат, лише тоді, коли R == 1ця функція може повернути помилкове значення, вказуючи nна просте значення.