Hãy xem xét lưới ô chữ 15 × 15 tiêu chuẩn sau đây .

Chúng ta có thể thể hiện điều này trong nghệ thuật ASCII bằng cách sử dụng #cho các khối và (không gian) cho các ô vuông màu trắng.

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

     ##   #    
   #       #   
    #   ##     

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

Đưa ra một lưới ô chữ theo định dạng nghệ thuật ASCII ở trên, xác định có bao nhiêu từ. (Lưới ở trên có 78 từ. Nó thực sự là câu đố của New York Times vào thứ Hai tuần trước .)

Một từ là một nhóm gồm hai hoặc nhiều không gian liên tiếp chạy dọc hoặc ngang. Một từ bắt đầu và kết thúc bằng một khối hoặc cạnh của lưới và luôn chạy từ trên xuống dưới hoặc từ trái sang phải, không bao giờ theo đường chéo hoặc ngược. Lưu ý rằng các từ có thể trải rộng toàn bộ chiều rộng của câu đố, như trong hàng thứ sáu của câu đố ở trên. Một từ không phải kết nối với một từ khác.

Chi tiết

• Đầu vào sẽ luôn là một hình chữ nhật chứa các ký tự #hoặc (dấu cách), với các hàng được phân tách bằng một dòng mới ( \n). Bạn có thể giả sử lưới được tạo từ 2 ký tự ASCII có thể in riêng biệt thay vì #và .
• Bạn có thể cho rằng có một dòng mới tùy chọn. Trailing space character DO đếm, vì chúng ảnh hưởng đến số lượng từ.
• Lưới sẽ không phải luôn luôn đối xứng, và nó có thể là tất cả các không gian hoặc tất cả các khối.
• Về mặt lý thuyết, chương trình của bạn có thể hoạt động trên một lưới có kích thước bất kỳ, nhưng đối với thử thách này, nó sẽ không bao giờ lớn hơn 21 × 21.
• Bạn có thể lấy chính lưới làm đầu vào hoặc tên của tệp chứa lưới.
• Lấy đầu vào từ stdin hoặc đối số dòng lệnh và đầu ra cho thiết bị xuất chuẩn.
• Nếu bạn thích, bạn có thể sử dụng hàm được đặt tên thay vì chương trình, lấy lưới làm đối số chuỗi và xuất ra một số nguyên hoặc chuỗi thông qua thiết bị xuất chuẩn hoặc trả về hàm.

Các trường hợp thử nghiệm

1. Đầu vào:

       #
       #
       #
   

   Đầu ra: 7(Có bốn khoảng trắng trước mỗi khoảng trống #. Kết quả sẽ giống nhau nếu mỗi ký hiệu số bị xóa, nhưng Markdown loại bỏ khoảng trắng từ các dòng trống khác.)

2. Đầu vào:

   ##
    #
   ##
   

   Đầu ra: 0(Từ một chữ cái không được tính.)

3. Đầu vào:

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

   Đầu ra: 4

4. Đầu vào: ( Câu đố ngày 10 tháng 5 của Chủ nhật NY Times )

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

   Đầu ra: 140

Chấm điểm

Mã ngắn nhất trong byte thắng. Tiebreaker là bài cũ nhất.

CJam, 18 17 13 11 byte

2 byte được lưu bởi Dennis.

Sử dụng khoảng trắng cho các ô đã điền và 1cho các ô trống:

qN/_z+:~1-,

Kiểm tra nó ở đây.

Giải trình

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.

Trượt , 18 + 3 = 21 byte

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

Chạy với các cờ no(do đó là +3) và sử dụng khoảng trắng / Xthay vì khoảng trắng / #. Khó chịu là cái này dài hơn cả CJam / Pyth, nhưng tôi đoán rằng Trượt không được thiết kế để trở nên đặc biệt ...

Hãy thử trực tuyến . Lưu ý rằng ví dụ đầu tiên là thiếu khoảng trắng trên một vài dòng.

Giải trình

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

Các nlá cờ làm cho sản lượng in số lượng các trận đấu, và ocờ cho phép trận đấu chồng chéo bắt đầu từ cùng một vuông. Lý do cho sự trở lại là bởi vì Trượt cố gắng khớp các trận đấu bắt đầu từ mọi ô vuông và chúng tôi muốn đảm bảo rằng chúng tôi chỉ khớp một hàng đầy đủ chứ không phải một phần. Trượt chỉ trả về các trận đấu duy nhất, ngay cả khi chúng bắt đầu từ các vị trí khác nhau.

Lưu ý: Ban đầu tôi có >?( +(X|$^)<<){2}, với không gian đầu tiên ở bên trong. Điều này sẽ bỏ lỡ một số trường hợp có 2 từ dài khoảng trắng ở cạnh, vì con trỏ sẽ đi như thế này:

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

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

Haskell, 81 byte

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

Sử dụng khoảng trắng dưới dạng ký tự khối và bất kỳ ký tự nào khác (không phải khoảng trắng) dưới dạng một ô trống.

Cách thức hoạt động: chia đầu vào thành danh sách các từ tại khoảng trắng. Lấy một từ 1cho mỗi khi thuê 2 ký tự và tính tổng các 1s đó. Áp dụng quy trình tương tự cho chuyển vị (tách tại \n) của đầu vào. Thêm cả hai kết quả.

JavaScript ( ES6 ) 87 121 147

Xây dựng chuyển vị của chuỗi đầu vào và nối nó vào đầu vào, sau đó đếm chuỗi từ 2 khoảng trống trở lên.

Chạy đoạn trích trong Firefox để kiểm tra.

Tín dụng @IsmaelMiguel, một giải pháp cho ES5 (122 byte):

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>

Bình thường, 15 14 13 byte

lftTcjd+.zC.z

Tôi đang sử dụng với tư cách là người tách biệt và #làm ký tự điền thay vì nghĩa trái ngược với OP. Dùng thử trực tuyến: Trình diễn

Thay vì #điền vào ký tự, điều này cũng chấp nhận các chữ cái. Vì vậy, bạn thực sự có thể lấy câu đố ô chữ đã giải, và nó sẽ in số lượng từ. Và nếu bạn loại bỏ llệnh, nó thậm chí sẽ in tất cả các từ. Kiểm tra nó ở đây: câu đố ngày chủ nhật NY 10 tháng 10

Giải trình

        .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