Tôi đã luôn muốn bao quanh một số văn bản với #s, nhưng tôi gặp khó khăn khi tìm ra những gì tôi đã bao quanh vì vậy trong thử thách này, bạn sẽ viết một chương trình để làm việc đó

Ví dụ

Đầu vào / Đầu ra được phân tách bằng một dòng mới.

###
#a#
###

a

 #
#a#
 #

a

  ###  
 # a #
# b c #
#######

  a 
 b c 

ABCDHIJ
E####GK
F# M #L
#   N#O
P####

  M 
   N

###A###
#C#B#o#
#d###e#
 # go#
  ###

C   o
d   e
  go

Thông số kỹ thuật

• #s là những gì "bao quanh" một khối văn bản
• # sẽ luôn liền kề với nhau (bao gồm cả đường chéo)
• # sẽ luôn luôn tạo thành một hình dạng khép kín
• Sẽ chỉ có một #hình dạng
• Trong trường hợp hình dạng lõm, các lỗ phải được lấp đầy khoảng trống.

• Khoảng trắng phải được bảo toàn trong đầu ra

Perl, 144 138 132 129 128 127 126 124 byte

Bao gồm +2 cho -p0

Mã giả định \0không phải là một ký tự đầu vào hợp lệ (ít nhất là bên trong #).

Chạy với đầu vào trên STDIN:

surround.pl < surround.txt

surround.pl:

#!/usr/bin/perl -p0
/^#[^#\0]/m&&s/^|[^#\n\0]\0/\0\0/mg,s%.%s/.(.*)/$+\0/g;/#/&&reverse"\n",/^./mg%seg until$?++<$$_++;y/\0/#/;s/^#*\n|#+$|^#//mg;y;#; 

Mã này hoạt động như là, nhưng thay thế \0và \nbằng các phiên bản nghĩa đen của chúng cho điểm số được yêu cầu. Chú ý có một khoảng trống ở cuối dòng. Các vòng lặp mã quá nhiều lần, do đó bạn có thể phải đợi 30 giây hoặc lâu hơn để xuất ra.

Giải trình

Tôi sẽ thực hiện một trận lũ lụt với sự \0dừng lại #từ bên ngoài theo các hướng trực giao. Sau đó, tôi sẽ cắt các #bên và thay thế tất cả những gì còn lại bởi khoảng trắng. Để tránh phải xử lý tất cả các hướng trong bãi lũ, tôi sẽ liên tục xoay khu vực mục tiêu và chỉ xả nước từ phải sang trái

/^#[^#\0]/m                   The rotation is written such that it slices
                              off the first column. That is ok unless the
                              first column contains a # that is followed by
                              something that could be the inside. There is
                              no newline inside the [] because short lines
                              will get extended during the rotation and 
                              the character following the # will end
                              up as a \0 and match in a later round
    &&s/^|[^#\n\0]\0/\0\0/mg  In case the # could be an interior border I
                              will add two columns of \0's in front. One 
                              will be a sacrifice for the rotation, the
                              other column will end up at the end of the area
                              after two rotations and function as seed for the
                              floodfill. This regex also does one step of
                              the floodfill from the back to the front.
                              After a certain number of loops we are certain
                              to get to a first column that must not be 
                              dropped so at some point the last column is 
                              guaranteed to consist of only \0. And we only need
                              to fill backward since the rotations will make
                              any direction backward at some point

s%.%  process column  %seg    I will replace each character (including \n)
                              in the string by the next column in reversed
                              order or an empty string if there are no more
                              interesting columns. This is therefore a right
                              rotation. There are less columns than
                              characters so this loop is long enough

    s%.%s/.(.*)/$+\0/g        Remove the next (now first) character from each
                              row (so remove the column). Because the
                              original area is not necessarily a rectangle
                              add a \0 at the end of the row so we won't run
                              out out of columns (this would cause shorter
                              rows to have no entry in the new rotated row)
                              This will not do anything for empty lines so
                              they DO get squeezed out. But that is not a 
                              problem since the problem statement says there
                              will be only one # shape so any empty lines
                              are can be safely dropped (this would not be
                              so if there could be multiple # shapes because
                              that could create a new surrounded area

    /#/                       Check if any of the remaining columns still 
                              has a #. If not all remaining columns are on 
                              the outside and can be dropped
       &&reverse"\n",/^./mg   Collect the column and add a \n to its reverse

 until$?++<$$_++              Keep doing this until we get to a multiple of
                              65536 rotations when $? waraps back around to 0
                              (this is a multiple of 4 so the area is left
                              unrotated) and an area we have seen before
                              ($$_ >= 1)
                              (so all slicing and flood filling is finished)
                              $_ having been seen in a previous rotations is
                              not a problem (though rather tricky to prove)

Tại thời điểm này, vd

AB##J
E####GK
F# M #L
#   N#O
P####

sẽ được thay thế bởi:

0000000
0####00
0# M #0
#   N#0
0####00

Về cơ bản, tất cả các cột và hàng không trực tiếp giáp với bên trong đã bị cắt đi. Bất kỳ ký tự bên ngoài nào còn lại đã được thay thế bằng \ 0. Ở trên cùng và bên phải có thêm một lớp \ 0. Vì vậy, tất cả những gì còn lại là dọn dẹp:

y/\0/#/                       Replace any outside that is left by #
s/^#*\n|#+$|^#//mg            Removes the first two and last line (the only 
                              lines that can consist of purely #)
                              Removes any trailing #
                              Removes the first column of #
y;#; \n;                      Replace any remaining # by space since they 
                              are needed to fill the concave parts
                              The final \n; is not written since it is implicit
                              in the -p loop

Javascript, 485 464 427 417 396 390 byte

s='indexOf';k='lastIndexOf';h="#";t=b=>b[0].map((x,i)=>b.map(x=>x[i]));i=>{m=i.split`
`;for(h of m){m[m[s](h)]=h.split``;}for(y=0;y<m.length;y++){for(z=x=0;x<m[y].length;x++){if(m[y][x]==h)break;if(m[y][s](h)<x&&m[y][k](h)>x)z++;q=t(m);if(q[y][s]h)<x&&m[y][k](h)>x)z++;if(z>2)m[y][x]=h}}for(p of m){v=p.join``.match(/\S/);e=v?p.join``:'';m[m[s](p)]=e;}m=m.join`
`;return m.replace(#/g," ")}

Đúng. Tôi đã thử. Và, mặc dù tôi ở mức 485 byte, tôi đang chiến thắng vì không ai khác cảm thấy muốn trả lời câu hỏi này. Vì vậy, hah!
Ngoài ra, tôi cũng nhận thức được rằng tôi có thể chơi golf này, tôi chỉ cảm thấy mệt mỏi vào lúc này ... giờ tôi đang ở 396 Cảm ơn Conor vì hầu hết việc chơi gôn ...: D