Este recipiente pode armazenar tanto líquido?

Resumo do Desafio

Como você provavelmente sabe, os líquidos têm uma forma indefinida e um volume definido. Como tal, eles sempre assumem a forma de seu recipiente. Eles não podem, no entanto, expandir para encher seu contêiner.

Sua tarefa hoje é determinar se uma certa quantidade de líquido (representada por um certo número de Lcaracteres ou números representando o volume da peça, conforme sugestão) pode caber em um contêiner de um determinado tamanho (representado por uma matriz de Ccaracteres) com uma certa quantidade de espaço vazio (representado por caracteres de espaço) dentro dele. O contêiner sempre terá Ccaracteres em todo o perímetro.

Seu programa retornará um valor de verdade / falsey com base no ajuste do líquido no contêiner. Só caberá se houver uma área de espaço vazio conectado (composto por espaços adjacentes um ao outro na horizontal, na diagonal ou na vertical) dentro do recipiente para cada parte do líquido que é separado do restante (por um espaço ou por dois caracteres de nova linha).

Casos de teste

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

Sinta-se livre para sugerir casos de teste!

Regras

• Isto é código-golfe, então a resposta mais curta em bytes vence.
• As brechas padrão não são permitidas.

Caracóis, 58 bytes

A entrada é obtida exatamente como nos exemplos.

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

Uma versão de 4 bytes mais longa é rápida o suficiente para concluir instantaneamente os casos de teste ( Experimente esta versão online ):

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

Uma formatação recuada deste último:

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

Limpo , 313 bytes

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))]

Experimente online!

Define a função $ :: [Int] [[Char]] -> Bool. O link TIO inclui um invólucro em torno do STDIN.

? :: [Int] -> [[Int]] é um auxiliar para gerar as diferentes maneiras pelas quais os volumes podem ser combinados.

Expandido:

$ 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
            )
        )
    ]