Bạn được cung cấp một lưới hình lục giác của các ký tự .và #, như thế này:

 . . . . . . . .
. . . . # . . . 
 . # . . . # . .
. . . # . . . . 
 . . . . . # . .
. . . . . . . . 

Nhiệm vụ của bạn là lấp đầy toàn bộ khung giới hạn được điều chỉnh theo trục của #hơn nữa #:

 . . . . . . . .
. . # # # # . . 
 . # # # # # . .
. . # # # # # . 
 . . # # # # . .
. . . . . . . . 

Hộp giới hạn căn chỉnh trục là hình lục giác lồi nhỏ nhất chứa tất cả #. Lưu ý rằng trong trường hợp lưới lục giác, có ba trục cần xem xét (W / E, SW / NE, NW / SE):

Dưới đây là một ví dụ khác để chỉ ra rằng trong một số trường hợp, một hoặc nhiều mặt sẽ chỉ chứa một #:

. . . . . . . .         . . . . . . . . 
 . # . . . . . .         . # # # # . . .
. . . . . # . .         . . # # # # . . 
 . . # . . . . .         . . # # # . . .
. . . . . . . .         . . . . . . . . 

Bạn có thể xem chúng là các hình lục giác có các mặt suy biến hoặc bạn có thể vẽ hộp giới hạn xung quanh chúng, như tôi đã làm ở trên, trong trường hợp chúng vẫn là hình lục giác:

Quá khó? Hãy thử phần I!

Quy tắc

Bạn có thể sử dụng bất kỳ hai ký tự ASCII không thể in riêng biệt nào (0x21 đến 0x7E, đã bao gồm), thay cho #và .. Tôi sẽ tiếp tục đề cập đến chúng như #và .cho phần còn lại của đặc tả.

Đầu vào và đầu ra có thể là một chuỗi được phân tách theo dòng cấp dữ liệu hoặc một danh sách các chuỗi (một chuỗi cho mỗi dòng), nhưng định dạng phải nhất quán.

Bạn có thể giả sử rằng đầu vào chứa ít nhất một #và tất cả các dòng có cùng độ dài. Lưu ý rằng có hai "loại" dòng khác nhau (bắt đầu bằng khoảng trắng hoặc không phải khoảng trắng) - bạn có thể không cho rằng đầu vào luôn bắt đầu bằng cùng một loại. Bạn có thể cho rằng hộp giới hạn luôn nằm gọn trong lưới bạn được cung cấp.

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

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

Mỗi trường hợp thử nghiệm có đầu vào và đầu ra cạnh nhau.

#    #

 . .      . . 
# . #    # # #
 . .      . . 

 . #      . # 
. . .    . # .
 # .      # . 

 # .      # . 
. . .    . # .
 . #      . # 

 # .      # . 
# . .    # # .
 . #      # # 

 . #      # # 
# . .    # # #
 . #      # # 

. . #    . # #
 . .      # # 
# . .    # # .

# . .    # # .
 . .      # # 
. . #    . # #

. . . . . . . .         . . . . . . . . 
 . . # . # . . .         . . # # # . . .
. . . . . . . .         . . . # # . . . 
 . . . # . . . .         . . . # . . . .

. . . . . . . .         . . . . . . . . 
 . . # . . . # .         . . # # # # # .
. . . . . . . .         . . . # # # # . 
 . . . # . . . .         . . . # # # . .

. . . . . . . .         . . . . . . . . 
 . # . . . . . .         . # # # # . . .
. . . . . # . .         . . # # # # . . 
 . . . . . . . .         . . . . . . . .

. . . . . . . .         . . . . . . . . 
 . # . . . . . .         . # # # # . . .
. . . . . # . .         . . # # # # . . 
 . . # . . . . .         . . # # # . . .

. . . . # . . .         . . # # # # . . 
 . # . . . # . .         . # # # # # . .
. . . # . . . .         . . # # # # # . 
 . . . . . # . .         . . # # # # . .

Pyth , 82 71 byte

L, hbebMqH @ S + GH1KhMyJs.e, Lkfq \ # @ bTUb.zA, ySm - FdJySsMJj.es.eXW && gKkgG - kYgH + kYZ
MqH @ S [hGHeG) 1j.es.eXW && ghMJs.e, Lkfq \ # @ bTUb.zkgSm-FdJ-kYgSsMJ + kYZ \. \ # Bz

Hãy thử trực tuyến!

Giải trình

• Gọi A là điểm có tọa độ y thấp nhất và B là điểm có tọa độ y cao nhất.

• Gọi C là điểm có giá trị thấp nhất (giá trị x trừ đi giá trị y) và D là điểm có giá trị cao nhất.

• Gọi E là điểm có giá trị thấp nhất (giá trị x cộng với giá trị y) và F là điểm có giá trị cao nhất.

Khi đó, nó tương đương với việc tìm tọa độ tọa độ y nằm giữa A và B, giá trị x trừ đi giá trị y nằm giữa C và D và giá trị x cộng với giá trị y nằm giữa E và F.

Haskell, 256 254 243 byte

import Data.List
f=z(\l->(,).(,))[0..]l)[0..]
q l=m(m(\e->min(snd e).(".#"!!).fromEnum.and.z($)(m(\x y->y>=minimum x&&y<=maximum x).transpose.m b.filter((==)'#'.snd).concat$l)$b e))l
b=(m uncurry[const,(-),(+)]<*>).pure.fst
z=zipWith
m=map
q.f

Cảm ơn @Damien đã chơi golf f!

Đầu vào được lấy dưới dạng danh sách các ký tự, đầu ra được cung cấp theo cùng một cách.

Soo đây là một con thú để viết. Nó dựa trên ý tưởng của LeakyNun bằng cách sử dụng bộ lọc dựa trên tối đa và tối thiểu dựa trên tọa độ của các mục.

Tôi thực sự ngạc nhiên bởi thực tế là m=mapthực sự tiết kiệm byte vì nó có vẻ rất tốn kém.

Giải trình:

Đây là một phiên bản ít bị đánh cắp hơn (nhấn mạnh vào một chút ):

import Data.List
f=zipWith(\y l->zipWith(\x e->((y,x),e))[0..]l)[0..]
p=map(\x y->y>=minimum x&&y<=maximum x).transpose.map b.filter((==)'#'.snd).concat
q l=map(map(\e->min(snd e).(".#"!!).fromEnum.and.zipWith($)(p$l)$b e))l
b=(map uncurry[const,(-),(+)]<*>).pure.fst

• flà một hàm gán cho mỗi char một chỉ mục (y-index, x-index)trong khi duy trì cấu trúc ban đầu của danh sách.

• b: Đưa ra một mục của danh sách được lập chỉ mục, btính toán [y-index, y - x, y + x].

• p: Cho trường được lập chỉ mục, trả về 3 hàm Int -> Bool, hàm đầu tiên là kiểm tra chỉ số y, thứ hai của chênh lệch và thứ ba của tổng. min(snd e)chăm sóc các không gian (một không gian nhỏ hơn cả hai). Chức năng này được nội tuyến trong mã golf.

• qcho lĩnh vực lập chỉ mục, thay đổi tất cả cần thiết .để #bằng cách kiểm tra nếu đó lĩnh vực cụ thể trở lại Truecho mọi chức năng kiểm tra.

Giải pháp cuối cùng là thành phần của qvà f.

Python 3, 380 378 348 346 byte

Lưu ý rằng thụt lề là với các tab, không phải khoảng trắng.

Phiên bản chơi gôn:

def s(i):
    L=i.splitlines();E=enumerate;A=lambda x,y:(y,x+y,x-y);N=(2**64,)*3;X=(-2**64,)*3
    for y,l in E(L):
        for x,c in E(l):
            if c=='#':p=A(x,y);X=tuple(map(max,X,p));N=tuple(map(min,N,p))
    R=''
    for y,l in E(L):
        for x,c in E(l):
            if c!='.':R+=c
            else:p=A(x,y);f=all(N[j]<=p[j]<=X[j]for j in range(0,3));R+='.#'[f]
        R+='\n'
    return R

Kiểm tra nó trên Ideone

Giải thích (cho phiên bản chưa được chỉnh sửa bên dưới):

Tất cả quá trình xử lý được thực hiện mà không có bất kỳ chuyển đổi nào, các ký tự khoảng trắng đơn giản được bỏ qua.
Hàm axes_postính toán 3-tuple tọa độ "3D" tưởng tượng, chúng được tích lũy thành (phần tử khôn ngoan) tối thiểu và tối đa 3-tuples ( bmin, bmax) cho tất cả các #ký tự.

Tọa độ được tính trong def axes_pos(x, y): return y, x + y, lc - y + x;
trong đó X đếm từ 0 sang phải và Y đếm từ 0 xuống dưới (từ dòng đầu tiên đến cuối cùng).
Tọa độ tưởng tượng đầu tiên về cơ bản là Y, vì rõ ràng là tại sao. Rìu của nó là trực giao với giới hạn màu xanh lá cây (trong ảnh của OP)
Thứ hai là trực giao với giới hạn màu đỏ và thứ ba là trực giao với giới hạn màu xanh.

Trong lần chuyển thứ hai, việc thay thế được thực hiện cho tất cả các .ký tự có tọa độ "3D" rơi vào bmin.. bmaxphạm vi, yếu tố khôn ngoan - điều này được kiểm tra trong biểu thức này all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3)).

Phiên bản Ungolfed với các bài kiểm tra, cũng trên Ideone :

def solve(i):
    ls = i.splitlines()
    lc = len(ls)

    def axes_pos(x, y):
        return y, x + y, lc - y + x

    I = 2 ** 64
    bmin = (I, I, I)
    bmax = (0, 0, 0)

    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '#': continue
            p = axes_pos(x, y)
            bmax = tuple(map(max, bmax, p))
            bmin = tuple(map(min, bmin, p))

    result = ''
    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '.':
                result += char
            else:
                p = axes_pos(x, y)
                f = all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3))
                result += '#' if f else char
        result += '\n'

    return result


def run_test(a, b):
    result = solve(a)
    if result != b:
        raise AssertionError('\n' + result + '\n\nshould be equal to\n\n' + b)


def run_tests():
    run_test(
        "#\n",

        "#\n")

    run_test(
        " . . \n"
        "# . #\n"
        " . . \n",

        " . . \n"
        "# # #\n"
        " . . \n")

    run_test(
        " . # \n"
        ". . .\n"
        " # . \n",

        " . # \n"
        ". # .\n"
        " # . \n")

    run_test(
        " # . \n"
        ". . .\n"
        " . # \n",

        " # . \n"
        ". # .\n"
        " . # \n")

    run_test(
        " # . \n"
        "# . .\n"
        " . # \n",

        " # . \n"
        "# # .\n"
        " # # \n")

    run_test(
        " . # \n"
        "# . .\n"
        " . # \n",

        " # # \n"
        "# # #\n"
        " # # \n")

    run_test(
        ". . . . . . . . \n"
        " . . # . # . . .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # . . .\n"
        ". . . # # . . . \n"
        " . . . # . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . . # . . . # .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # # # .\n"
        ". . . # # # # . \n"
        " . . . # # # . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . . . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . . . . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . # . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . # # # . . .\n")

    run_test(
        ". . . . # . . . \n"
        " . # . . . # . .\n"
        ". . . # . . . . \n"
        " . . . . . # . .\n",

        ". . # # # # . . \n"
        " . # # # # # . .\n"
        ". . # # # # # . \n"
        " . . # # # # . .\n")


if __name__ == '__main__':
    run_tests()

Đã xóa không cần thiết -1cho tọa độ tưởng tượng thứ ba, vì nó không thay đổi bất cứ điều gì

Một phần cải tiến được thực hiện được đề xuất bởi Leaky Nun+ của riêng tôi.

Thạch , 45 35 ₁₃ 42 41 byte

Ṁ€»\
ṚÇṚ«Çṁ"
ŒDṙZL$ÇṙL’$ŒḌ«Ç
ṚÇṚ«Ç
n⁶aÇo⁶

Đây là danh sách các liên kết; cái cuối cùng phải được gọi trên đầu vào để tạo đầu ra.

I / O ở dạng mảng chuỗi, trong đó .biểu thị trống và @biểu thị điền.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Lý lịch

Hãy xem xét ví dụ sau đây.

. . . . . . . . 
 . @ . . . . . .
. . . . . @ . . 
 . . @ . . . . .

Bằng cách vẽ một cặp hoặc các đường song song - cặp gần nhất bao quanh tất cả các vị trí được lấp đầy - theo mỗi ba hướng, chúng ta có thể xác định hộp giới hạn hình lục giác.

Trong quá trình triển khai, chúng tôi thay thế tất cả các ký tự giữa hai dòng đó @và mọi thứ bên ngoài các dòng này ., ngoại trừ các đường chéo chỉ chứa khoảng trắng).

Đối với trục hoành, điều này mang lại

................
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@

đối với trục đường chéo rơi, nó cho

..@@@@@@@......
...@@@@@@@......
....@@@@@@@.....
 ....@@@@@@@....

và đối với trục chéo nâng lên, nó mang lại

....@@@@@@@@@...
...@@@@@@@@@....
..@@@@@@@@@....
.@@@@@@@@@.... .

Bằng cách lấy mức tối thiểu của nhân vật trong cả ba, kể từ .< @, chúng tôi nhận được

...............
...@@@@@@@......
....@@@@@@@....
 ....@@@@@.... .

Tất cả những gì còn lại phải làm là khôi phục lại không gian.

Làm thế nào nó hoạt động

n⁶aÇo⁶           Main link. Argument: A (array of strings)

n⁶               Not-equal space; yield 0 for spaces, 1 otherwise.
  aÇ             Take the logical AND with the result the 4th helper link.
                 This will replace 1's (corresponding to non-space characters) with
                 the corresponding character that result from calling the link.
    o⁶           Logical OR with space; replaces the 0's with spaces.

ṚÇṚ«Ç            4th helper link. Argument: A

Ṛ                Reverse the order of the strings in A.
 Ç               Call the 3rd helper link.
  Ṛ              Reverse the order of the strings in the resulting array.
    Ç            Call the 3rd helper link with argument A (unmodified).
   «             Take the character-wise minimum of both results.

ŒDṙZL$ÇṙL’$ŒḌ«Ç  3rd helper link. Argument: L (array of strings)

ŒD               Yield all falling diagonals of L. This is a reversible operation,
                 so it begins with the main diagonal.
   ZL$           Yield the length of the transpose (number of columns).
  ṙ              Shift the array of diagonals that many units to the left.
                 This puts the diagonals in their natural order.
      Ç          Call the helper link on the result.
        L’$      Yield the decremented length (number of columns) of L.
       ṙ         Shift the result that many units to the left.
                 This puts the changed diagonals in their original order.
           ŒḌ    Undiagonal; reconstruct the string array.
              Ç  Call the 2nd helper link with argument L (unmodified).
             «   Take the character-wise minimum of both results.

ṚÇṚ«Çṁ"          2nd helper link. Argument: M (array)

Ṛ                Reverse the rows of M.
 Ç               Call the 1st helper link on the result.
  Ṛ              Reverse the rows of the result.
    Ç            Call the 1nd helper link with argument M (unmodified).
   «             Take the minimum of both results.
     ṁ"          Mold zipwith; repeat each character in the result to the left
                 as many times as needed to fill the corresponding row of M.

Ṁ€»\             1st helper link. Argument: N (array)

Ṁ€               Take the maximum of each row of N.
  »\             Take the cumulative maxima of the resulting characters.

Python, 237 230 byte

7 byte nhờ Dennis.

def f(a):i=range(len(a[0]));j=range(len(a));b,c,d=map(sorted,zip(*[[x,x+y,x-y]for y in i for x in j if"?"<a[x][y]]));return[[[a[x][y],"#"][(a[x][y]>" ")*(b[0]<=x<=b[-1])*(c[0]<=x+y<=c[-1])*(d[0]<=x-y<=d[-1])]for y in i]for x in j]

Cảng câu trả lời của tôi trong Pyth .

Lấy mảng các dòng làm đầu vào, xuất ra mảng 2D của các ký tự.

• Python 2: Tôi nghĩ vậy!
• Python 3: Tôi nghĩ vậy!

Perl, 128 126 byte

Bao gồm +6 cho -0F\n

Chạy với đầu vào trên STDIN. Sử dụng 1cho đầy, 0cho trống. Các dòng không phải được đệm với khoảng trắng ở cuối:

perl -M5.010 hexafill.pl
 0 0 0 0 0 0 0 0
0 0 1 1 1 1 0 0 
 0 1 1 1 1 1 0 0
0 0 1 1 1 1 1 0 
 0 0 1 1 1 1 0 0
0 0 0 0 0 0 0 0 
^D

hexafill.pl

#!/usr/bin/perl -0F\n
$-=map{s%$=%$=^!map{/$/;grep{pos=$`;$=?$_|="!"x$`.1:!/\b.*\G./}${--$@}}@F-$-+pos,$-+pos,$-%eeg;--$-;$=||say}@F while$=--

Sử dụng tọa độ khối. Xác định tối đa và tối thiểu trong $= == 1vòng lặp và điền tọa độ giữa các giới hạn trong $= == 0vòng lặp. 58 vòng đầu tiên là vô nghĩa và chỉ ở đó để điền vào $-số lượng dòng

TSQL, 768 byte

Tôi đã viết một truy vấn để giải quyết điều này - điều mà tôi thấy khá khó khăn. Nó không thể cạnh tranh với tất cả các câu trả lời ngắn hơn xuất sắc. Nhưng dù sao cũng muốn đăng nó cho những ai quan tâm. Xin lỗi về độ dài của câu trả lời - hy vọng codegolf cũng về các cách tiếp cận khác nhau.

Chơi gôn

DECLARE @ varchar(max)=
'
. . . . # . . . 
 . # . . . # . .
. . . # . . . . 
 . . . . . # . .
. . . . . . . . 
'

;WITH c as(SELECT cast(0as varchar(max))a,x=0,y=1,z=0UNION ALL SELECT SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),z+1FROM c WHERE LEN(@)>z)SELECT @=stuff(@,z-1,1,'#')FROM c b WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)or exists(SELECT*FROM c WHERE b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.y>y and'#'=a))and a='.')and(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))OPTION(MAXRECURSION 0)PRINT @

Ung dung:

DECLARE @ varchar(max)=
'
. . . . # . . . 
 . # . . . # . .
. . . # . . . . 
 . . . . . # . .
. . . . . . . . 
'
;WITH c as
(
  SELECT 
    cast(0as varchar(max))a,x=0,y=1,z=0
  UNION ALL
  SELECT
    SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),
    IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),
    z+1
  FROM c
  WHERE LEN(@)>z
)
SELECT @=stuff(@,z-1,1,'#')FROM c b
WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)
or exists(SELECT*FROM c WHERE b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.y>y and'#'=a)
)and a='.')
and 
(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)
and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))
and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))
OPTION(MAXRECURSION 0) 
PRINT @

Fiddle vô dụng

GNU Octave, 212 , 196 byte

Có thể không thực sự là ngôn ngữ lựa chọn yêu thích của người chơi gôn, nhưng đó là điều tạo nên thách thức, phải không? Giả sử m được lấy dưới dạng ma trận char: 178 byte độc lập và 196 nếu được nhồi vào một hàm .

đánh gôn

function k=f(m)[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;for j=1:3l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});endk(s&mod(x+y,2))=['#']end

vô dụng:

function k=f(m)
[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;
for j=1:3
  l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);
  s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});
end
k(s&mod(x+y,2))=['#']
end

Giải trình : chúng tôi xây dựng một hệ tọa độ, 3 trục - trực giao với các cạnh lục giác, tìm max và min của mỗi tọa độ, sau đó xây dựng mặt nạ logic bắt đầu bằng 1 ở mọi nơi và theo logic và: ing mỗi ràng buộc tối đa và tối thiểu của tọa độ mỗi vị trí "thật" còn lại thành "#" char.

Nếu bạn muốn kiểm tra nó, bạn chỉ có thể tạo m ma trận như thế này:

m = [' . . . . . . . .. . . . # . . .  . # . . . # . .. . . # . . . .  . . . . . # . .. . . . . . . . ']; m = reshape(m,[numel(m)/6,6])';

và sau đó gọi f (m) và so sánh với m bằng cách xây dựng một ma trận với cả hai trong:

['     before           after      ';m,ones(6,1)*'|',f(m)]