Bình chứa này có thể chứa nhiều chất lỏng này không?

Tóm tắt thử thách

Như bạn có thể biết, chất lỏng có hình dạng không xác định và khối lượng xác định. Như vậy, họ luôn có hình dạng của container của họ. Họ không thể, tuy nhiên, mở rộng để điền vào container của họ.

Công việc của bạn hôm nay là xác định xem một lượng chất lỏng nhất định (được biểu thị bằng một số Lký tự hoặc số nhất định đại diện cho thể tích của bộ phận, theo gợi ý) có thể vừa với một vật chứa có kích thước nhất định (được biểu thị bằng ma trận Ccác ký tự) với một số lượng không gian trống (được biểu thị bằng các ký tự khoảng trắng) bên trong nó. Container sẽ luôn có các Cký tự xung quanh chu vi.

Chương trình của bạn sẽ trả về giá trị trung thực / falsey dựa trên việc chất lỏng có vừa với vật chứa hay không. Nó sẽ chỉ phù hợp nếu có một vùng không gian trống được kết nối (được tạo thành từ các không gian liền kề nhau theo chiều ngang, đường chéo hoặc chiều dọc) trong thùng chứa cho từng phần của chất lỏng được tách ra khỏi phần còn lại (bằng một khoảng trắng hoặc bởi hai ký tự dòng mới).

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

LLL
L
-----    True
CCCCC
C  CC
C  CC
CCCCC

LLL
 LL
------   True
CCCCCC
C C  C
C  CCC
CCCCCC

L L
LLL
-----    False (Not enough space)
CCCCC
CCCCC
C  CC
CCCCC

LL
------   False (Spaces are not connected but liquid is)
CCCCCC
CCCC C
C CCCC
CCCCCC

L L
------   True
CCCCCC
CCCC C
C CCCC
CCCCCC

L L
------   True (There is a pocket of empty space which holds both parts of the liquid)
CCCCCC
CCC  C
CCCCCC
CCCCCC

L

L
------   True (There is a pocket of empty space for each part of the liquid)
CCCCCC
CCCC C
C CCCC
CCCCCC

L L L LL
------   True
CCCCCCCCC
CCCC  C C
C CCCCCCC
CCCCCC CC
CCCCCCCCC

L
L
-----    True
CCCCC
CCCCC
C  CC
CCCCC

Hãy đề nghị các trường hợp thử nghiệm!

Quy tắc

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.
• Sơ hở tiêu chuẩn là không được phép.

Ốc sên, 58 byte

Đầu vào được thực hiện chính xác như trong các ví dụ.

t\ t\L{t\L?t\ z!.o=(\ ,\C},!(tz(\L!.!~|\ !.o=(\ ,\C},!(t\L

Phiên bản dài hơn 4 byte đủ nhanh để hoàn thành ngay các trường hợp thử nghiệm ( Thử phiên bản trực tuyến này ):

?^
t\ t\L{t\L`?t\ z!.o=(\ ,\C},!(tz(\L!.!~|\ !.o=(\ ,\C},!(t\L

Một định dạng thụt lề sau:

?^
    t\ 
    t\L
    {
        t\L`?
        t\ 
        z!.
        o=(\ ,\C
    },
    !(tz(
         \L!.!~
         |
         \ !.o=(\ ,\C
},
!(t\L

Sạch sẽ , 313 byte

import StdEnv,Data.List
?v=nub[v:[[sum s:k]\\s<-subsequences v|s>[],k<- ?(difference v s)]]
$v m#p=[[(x,y)]\\x<-[0..]&l<-m,y<-[0..]&' '<-l]
=or[and(zipWith(>=)(s++[0,0..])r)\\r<- ?v,s<-permutations(map length(foldl(\p _=nub[sort(nub(e++[(x,y)\\(u,v)<-e,x<-[u-1,u,u+1],y<-[v-1,v,v+1]|(m!!x)!!y<'C']))\\e<-p])p p))]

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

Xác định hàm $ :: [Int] [[Char]] -> Bool. Liên kết TIO bao gồm một trình bao bọc xung quanh STDIN.

? :: [Int] -> [[Int]] là một người trợ giúp để tạo ra các cách khác nhau mà các khối lượng có thể được kết hợp.

Mở rộng:

$ v m // in function $ of v and m
    # p // define p as
        = [ // a list of
            [(x, y)]    // lists of pairs (x, y)
        \\              // for each
            x <- [0..]  // index x
            & l <- m    // at list l in m
        ,               // for each
            y <- [0..]  // index y
            & ' ' <- l  // at spaces in l
        ]
    = or [ // true if any of the list of
        and (               // true if all of
            zipWith         // element-wise application of
                (>=)            // greater than or equal to
                (s ++ [0, 0..]) // permutation s padded with zeroes
                v               // list v of volumes
        )
    \\                      // for each
        s <- permutations ( // permutation s of
            map length (    // the lengths of
                foldl       // a left-fold of
                    (\p _   // function on p discarding second argument
                        = nub [ // the unique elements of the list of
                            sort (          // sorted versions of
                                nub (       // unique lists composed of
                                    e       // list e of points in a region
                                    ++ [    // prepended to the list of
                                        (x, y)      // pairs (x, y)
                                    \\              // for each
                                        (u, v) <- e // pair (u, v) in list e
                                    ,               // for each
                                        x <- [u-1, u, u+1] // x-coordinate adjacent to u
                                    ,               // for each
                                        y <- [v-1, v, v+1] // y-coordinate adjacent to v
                                    |               // where
                                        (m!!x)!!y < 'C' // the character in m at (x, y) is a space
                                    ]
                                )
                            )
                        \\          // for each
                            e <- p  // region e in p
                        ]
                    )
                    p // applied to a starting argument of p
                    p // recursively, for each element in p
            )
        )
    ]