다음 표준 15 × 15 크로스 워드 퍼즐 그리드를 고려하십시오 .

#블록 으로 사용 하고 흰색 사각형으로 (공백)을 사용하여 ASCII 아트로 이것을 나타낼 수 있습니다 .

     #    #
     #    #
          #
   #   #
###     ##   ##

     ##   #
   #       #
    #   ##

##   ##     ###
       #   #
    #
    #    #
    #    #

위의 ASCII 아트 형식의 크로스 워드 그리드를 사용하여 보유한 단어 수를 결정하십시오. (위 그리드에는 78 단어가 있습니다. 지난 월요일 뉴욕 타임즈 퍼즐 입니다.)

단어는 세로 또는 가로로 연속되는 두 개 이상의 연속 공백으로 구성된 그룹입니다. 단어는 그리드의 블록 또는 가장자리로 시작하고 끝나며 대각선이나 뒤로는 절대로 위쪽에서 아래쪽으로 또는 왼쪽에서 오른쪽으로 실행됩니다. 위의 퍼즐의 여섯 번째 줄에서와 같이 단어는 퍼즐의 전체 너비에 걸쳐있을 수 있습니다. 단어를 다른 단어에 연결할 필요는 없습니다.

세부

• 입력은 항상 줄 바꿈 문자 ( )로 구분 된 문자 #또는 공백이 포함 된 사각형 \n입니다. 그리드가 및 대신에 2 개의 고유 한 인쇄 가능한 ASCII 문자 로 구성되어 있다고 가정 할 수 있습니다 .#
• 선택적인 후행 줄 바꿈이 있다고 가정 할 수 있습니다. 후행 공백 문자는 단어 수에 영향을주기 때문에 계산됩니다.
• 그리드가 항상 대칭 인 것은 아니며 모든 공간 또는 모든 블록 일 수 있습니다.
• 당신의 프로그램은 이론적으로 어떤 크기의 격자에서도 작동 할 수 있어야하지만,이 도전에서는 21 × 21보다 클 수 없습니다.
• 그리드 자체를 입력 또는 그리드를 포함하는 파일 이름으로 사용할 수 있습니다.
• stdin 또는 명령 행 인수에서 입력을 가져 와서 stdout으로 출력하십시오.
• 원하는 경우 프로그램 대신 명명 된 함수를 사용하여 그리드를 문자열 인수로 사용하고 stdout 또는 함수 반환을 통해 정수 또는 문자열을 출력 할 수 있습니다.

테스트 사례

1. 입력:

       #
       #
       #
   

   출력 : 7(각 앞에 4 개의 공백 #이 있습니다. 각 숫자 부호를 제거하면 결과는 동일하지만 Markdown은 빈 줄에서 공백을 제거합니다.)

2. 입력:

   ##
    #
   ##
   

   출력 : 0(한글자 단어는 포함되지 않습니다.)

3. 입력:

   ######
   #    #
     ####
   # ## #
   # ## #
   #### #
   

   산출: 4

4. 입력 : (5 월 10 일 일요일 NY 타임즈 퍼즐)

      #    ##   #
      #    #    #
      #         #
          #     ###   ##
       #       #
   ##   #   #
           #       ##
         #   ##
      #        ##      #
            #   ###   ##
   #   ##         ##   #
   ##   ###   #
   #      ##        #
            ##   #
      ##       #
              #   #   ##
           #       #
   ##   ###     #
          #         #
          #    #    #
          #   ##    #
   

   산출: 140

채점

바이트 단위의 최단 코드가 이깁니다. Tiebreaker는 가장 오래된 게시물입니다.

답변

qN/_z+:~1-,

q    e# Read the entire input.
N/   e# Split into lines.
_z   e# Make a copy and transpose it.
+    e# Add the lines of the two grids together.
:~   e# Evaluate each line which will push a rep-digit number for each empty-cell chunk.
1-   e# Remove all the 1s as these correspond to individual empty cells.
,    e# Get the length of the array.

>? ( +(X|$^)<<){2}

>?           Optionally turn right, hence matching either horizontally or vertically
[space]      Match a space
(    ){2}    Group, twice:
[space]+       Match 1+ spaces
(X|$^)         Either an X or the boundary of the grid
<<             Reverse the match pointer by turning left twice

XXX       XXX       XXX       XXX
X>        X >       X<        <
XXX       XXX       XXX       XXX

[sp]    [sp]+$^    <<[sp]    [sp]+   (uh oh match fails)

import Data.List
m x=sum[1|(_:_:_)<-words x]
f x=m x+m(unlines$transpose$lines x)

function F(z){for(r=z.split(/\n/),i=0;i<r[j=0][L='length'];i++)for(z+='#';j<r[L];)z+=r[j++][i];return~-z.split(/  +/)[L]};

F=z=>
(
  r=z.split(/\n/),
  [r.map(r=>z+=r[i],z+='#')for(i in r[0])],
  ~-z.split(/  +/).length
)

// TEST
out=x=>O.innerHTML += x + '\n';

[
'     #    #    \n     #    #    \n          #    \n   #   #       \n###     ##   ##\n               \n     ##   #    \n   #       #   \n    #   ##     \n               \n##   ##     ###\n       #   #   \n    #          \n    #    #     \n    #    #     ', '##\n #\n##', '    #\n    #\n    #',
 '######\n#    #\n  ####\n# ## #\n# ## #\n#### #',
 '   #    ##   #       \n   #    #    #       \n   #         #       \n       #     ###   ##\n    #       #        \n##   #   #           \n        #       ##   \n      #   ##         \n   #        ##      #\n         #   ###   ##\n#   ##         ##   #\n##   ###   #         \n#      ##        #   \n         ##   #      \n   ##       #        \n           #   #   ##\n        #       #    \n##   ###     #       \n       #         #   \n       #    #    #   \n       #   ##    #   '
].forEach(x=>out(x.replace(/ /g,'.')+'\n'+F(x)+'\n'))

<pre id=O></pre>

lftTcjd+.zC.z

        .z      all input rows
          C.z   all input columns (C transposes)
       +        add them (all rows and columns)
     jd         join by spaces
    c           split by spaces
 f              filter for pieces T, which satisfy:
  tT              len(T) > 1
l               length, implicitly printed