Primenary ( binary-prime ) 문자열은 이진 그리드로 작성 될 때 모든 행과 열에 총계가있는 문자열입니다.

꽤 모호한 설명이므로 예제를 사용하여 설명해 보겠습니다.

이 예제에서는 다음 문자열을 사용합니다 bunny.

먼저 각 문자의 ASCII 코드 포인트와 이진 표현을 찾으십시오.

Char | ASCII | Binary

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

이진 값을 위에서 아래로 가져 와서 그리드로 배열하십시오 (필요한 경우 앞에 0을 추가).

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

그런 다음 1각 행과 열의 s 수를 계산하십시오 .

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

모든 단일 합계가 소수 (예 : 여기) 인 경우에만 문자열이 유효한 2 진 프라임입니다.

도전

당신의 임무는 문자열이 주어지면 truthy문자열이 기본이거나 falsy그렇지 않으면 반환 / 출력하는 함수 또는 프로그램을 만드는 것 입니다.

규칙 / 세부 사항

• 문자열의 문자는 항상 ASCII 범위 33-126(포함)에 있다고 가정 할 수 있습니다 .
• 문자열은 비워 둘 수 없습니다.
• 기본 문자열은 소수를 가질 필요 가 없습니다. 예를 들어 W1n*4 개의 문자가 있지만 유효합니다.
• 이것은 code-golf 이므로 가장 짧은 답변 (바이트)이 이기지 만 모든 제출을 환영합니다.
• 표준 허점은 금지되어 있습니다.

테스트 사례

'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 배열 falsy 수 있기 때문에 메타 , 다른 아무것도 필요하지 않습니다 - 기본적으로 암시가 A호출됩니다 ?(있는 경우).

젤리 , 13 12 11 바이트

OBUZ;$S€ÆPẠ

TryItOnline! 또는 모든 테스트 사례

방법?

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

Mathematica, 75 바이트

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

이름이없는 함수는 입력으로 문자열을 가져 True오거나 반환 False합니다.

ToCharacterCode@#입력을 ASCII 값 목록으로 변환합니다. IntegerDigits[...,2,7]각 값을 비트 목록으로 변환하고 필요한 경우 길이 7로 채 웁니다. 이제 2D 배열이 있고 모든 행 합과 열 합이 필요합니다. 보라, 문자 경련 {+##&@@#,+##&@@@#}&@...은 정확히 그것을 수행합니다 ( +##&, "모든 인수 합계"를 사용하여 첫 번째 좌표의 벡터 목록에 함수를 적용하고 , @@각 벡터에을 사용하여 두 번째 좌표의 자체 정수 목록으로 적용 @@@) . 그런 다음 결과가 있는지 확인 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.)
}

펄 151 121 111 + 3 = 114 바이트

로 실행하십시오 -lF. 프로그램은 첫 번째 입력에 대해서만 올바르게 작동합니다. 프로그램을 종료하고 다음 입력을 위해 다시 실행하십시오.

//이후 F의 중복 을 알려주는 @Dada에게 감사드립니다 . via 입력을 파이핑하여 추가 바이트를 제거 할 수 있지만 (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로 바꾸면 2 바이트가 더 손실됩니다. 내 비트 수준 지식이 얼마나 나쁜지 밝히는 Erik에게 감사 kappa합니다.

당연, 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"))}}; -전달 된 이진 2D 배열의 모든 "1"카운트가 소수인지 확인하기위한 폐쇄.

x=it.collect{0.toString((int)it,2) as List}; -문자열에서 이진 배열로의 변환.

y(x)&&y(x.transpose()) -주 행렬과 전치 행렬의 모든 소수 유효성 합계에 대해 true를 반환해야합니다.

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

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

온라인으로 사용해보십시오!

K (oK) , 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;

온라인 테스트

자바 스크립트, 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))

숫자를 이진수로 변환하고 문자열 대체를 사용하여 0을 제거한 다음 1을 세면 가로 값을 얻습니다. 수직 합은 1에서 7까지 반복하고 2를 n 승으로 올린 비트 AND를 사용하여 얻습니다.

클로저, 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))))

비트리스트를 생성하는 더 짧은 방법과 원시성 테스트가있을 수 있습니다.

펄 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가 여전히 Ruby 2.5.5를 실행하기 때문에 TiO 링크가 없습니다. 😭

설명

꽤 간단합니다. 배열은 7 자리로 밖으로 패딩으로 첫 번째 라인은 각 문자의 이진수를 얻을 정말 쉽게되어야한다 :

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

확인해 그 블록 번호 파라미터 ( @1)와 beginless 범위 ( ..6) 뜨거움 .

두 번째 줄은 행과 열을 합산하고 모두 소수인지 테스트합니다.

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

자바 스크립트 (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()if 의 해당 비트를 반환하고 0 <= 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.
    • n % R is NaN: 잘못된 모듈 계산.
      • 만약 R == 0:n == 1. -1을 반환하십시오.
      • 만약 n is NaN: R is NaN. -1을 반환하십시오.
  • 결과적 R == 1으로이 함수가 거짓 값을 반환 할 수 있는 경우에만 n소수 임을 나타냅니다 .